Skip to content

Rastrear local

Aprenda como rastrear local através do SDK Braze.

Registro do local atual

Para obter o local atual de um usuário, use o método getCurrentPosition() da API de geolocalização. Isso solicitará imediatamente que o usuário permita ou não o rastreamento (a menos que já o tenha feito).

1
2
3
4
5
6
7
8
9
10
11
12
13

import * as braze from "@braze/web-sdk";
function success(position) {
  var coords = position.coords;
  braze.getUser().setLastKnownLocation(
    coords.latitude,
    coords.longitude,
    coords.accuracy,
    coords.altitude,
    coords.altitudeAccuracy
  );
}

navigator.geolocation.getCurrentPosition(success);

Agora, quando os dados são enviados ao Braze, o SDK pode detectar automaticamente o país do usuário usando seu endereço IP. Para saber mais, consulte setLastKnownLocation().

Monitoramento contínuo da localização

Para monitorar continuamente o local de um usuário durante o carregamento de uma página, use o método watchPosition() da API de geolocalização. A chamada desse método solicitará imediatamente que o usuário permita ou não o rastreamento (a menos que já o tenha feito).

Se houver aceitação, um retorno de chamada de sucesso será invocado sempre que o local for atualizado.

1
2
3
4
5
6
7
8
9
10
11
12

function success(position) {
  var coords = position.coords;
  braze.getUser().setLastKnownLocation(
    coords.latitude,
    coords.longitude,
    coords.accuracy,
    coords.altitude,
    coords.altitudeAccuracy
  );
}

navigator.geolocation.watchPosition(success);

Registro do local atual

Mesmo que o monitoramento contínuo esteja desativado, é possível registrar manualmente o local atual do usuário usando o método setLastKnownLocation() método.

1
2
3
4
5
6

Braze.getInstance(context).getCurrentUser(new IValueCallback<BrazeUser>() {
  @Override
  public void onSuccess(BrazeUser brazeUser) {
    brazeUser.setLastKnownLocation(LATITUDE_DOUBLE_VALUE, LONGITUDE_DOUBLE_VALUE, ALTITUDE_DOUBLE_VALUE, ACCURACY_DOUBLE_VALUE);
  }
}

1
2
3

Braze.getInstance(context).getCurrentUser { brazeUser ->
  brazeUser.setLastKnownLocation(LATITUDE_DOUBLE_VALUE, LONGITUDE_DOUBLE_VALUE, ALTITUDE_DOUBLE_VALUE, ACCURACY_DOUBLE_VALUE)
}

Monitoramento contínuo da localização

Para rastrear continuamente a localização de um usuário, será necessário declarar a intenção do app de coletar dados de localização adicionando pelo menos uma das seguintes permissões ao arquivo AndroidManifest.xml.

Seu AndroidManifest.xml deve ser semelhante ao seguinte:

1
2
3
4
5
6
7
8

<manifest ... >
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

    <application ... >
        ...
    </application>
</manifest>

Desativar o rastreamento contínuo

É possível desativar o rastreamento contínuo em tempo de compilação ou em tempo de execução.

Para desativar o monitoramento contínuo de localização em tempo de compilação, defina com_braze_enable_location_collection como false em braze.xml:

1

<bool name="com_braze_enable_location_collection">false</bool>

Para desativar seletivamente o monitoramento contínuo de localização em tempo de execução, use BrazeConfig:

1
2
3
4

BrazeConfig brazeConfig = new BrazeConfig.Builder()
  .setIsLocationCollectionEnabled(false)
  .build();
Braze.configure(this, brazeConfig);

1
2
3
4

val brazeConfig = BrazeConfig.Builder()
    .setIsLocationCollectionEnabled(false)
    .build()
Braze.configure(this, brazeConfig)

Registro do local atual

Etapa 1: Configure seu projeto

Para ativar o monitoramento de localização, abra seu projeto Xcode e selecione seu app. Na guia General (Geral ), adicione o módulo BrazeLocation.

Em seu arquivo AppDelegate.swift, importe o módulo BrazeLocation na parte superior do arquivo. Adicione uma instância de BrazeLocationProvider à configuração da Braze, conferindo se todas as alterações na configuração estão feitas antes de chamar Braze(configuration:). Consulte Braze.Configuration.Location para ver as configurações disponíveis.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import UIKit
import BrazeKit
import BrazeLocation

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

  static var braze: Braze? = nil

  func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    // Setup Braze
    let configuration = Braze.Configuration(apiKey: brazeApiKey, endpoint: brazeEndpoint)
    configuration.logger.level = .info
    configuration.location.brazeLocationProvider = BrazeLocationProvider()
    configuration.location.automaticLocationCollection = true
    configuration.location.geofencesEnabled = true
    configuration.location.automaticGeofenceRequests = true
    let braze = Braze(configuration: configuration)
    AppDelegate.braze = braze

    return true
  }

}

Em seu arquivo AppDelegate.m, importe o módulo BrazeLocation na parte superior do arquivo. Adicione uma instância de BrazeLocationProvider à configuração da Braze, conferindo se todas as alterações na configuração estão feitas antes de chamar Braze(configuration:). Consulte BRZConfigurationLocation para ver as configurações disponíveis.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#import "AppDelegate.h"

@import BrazeKit;
@import BrazeLocation;

@implementation AppDelegate

#pragma mark - Lifecycle

- (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  // Setup Braze
  BRZConfiguration *configuration =
      [[BRZConfiguration alloc] initWithApiKey:brazeApiKey
                                      endpoint:brazeEndpoint];
  configuration.logger.level = BRZLoggerLevelInfo;
  configuration.location.brazeLocationProvider = [[BrazeLocationProvider alloc] init];
  configuration.location.automaticLocationCollection = YES;
  configuration.location.geofencesEnabled = YES;
  configuration.location.automaticGeofenceRequests = YES;
  Braze *braze = [[Braze alloc] initWithConfiguration:configuration];
  AppDelegate.braze = braze;

  [self.window makeKeyAndVisible];
  return YES;
}

#pragma mark - AppDelegate.braze

static Braze *_braze = nil;

+ (Braze *)braze {
  return _braze;
}

+ (void)setBraze:(Braze *)braze {
  _braze = braze;
}

@end

Etapa 2: Registre o local do usuário

Em seguida, registre o último local conhecido do usuário no Braze. Os exemplos a seguir pressupõem que você atribuiu a instância do Braze como uma variável em seu site AppDelegate.

1
2

AppDelegate.braze?.user.setLastKnownLocation(latitude:latitude,
                                             longitude:longitude)

1
2
3
4
5

AppDelegate.braze?.user.setLastKnownLocation(latitude:latitude,
                                             longitude:longitude,
                                             altitude:altitude,
                                             horizontalAccuracy:horizontalAccuracy,
                                             verticalAccuracy:verticalAccuracy)

1
2
3
4

[AppDelegate.braze.user setLastKnownLocationWithLatitude:latitude
                                               longitude:longitude
                                      horizontalAccuracy:horizontalAccuracy];


1
2
3
4
5
6

[AppDelegate.braze.user setLastKnownLocationWithLatitude:latitude
                                               longitude:longitude
                                      horizontalAccuracy:horizontalAccuracy
                                                altitude:altitude
                                        verticalAccuracy:verticalAccuracy];

Pré-requisitos

Antes de poder usar esse recurso, você precisará integrar o React Native Braze SDK.

Definindo a última localização conhecida

Para definir manualmente a última localização conhecida de um usuário, use o método setLastKnownLocation. Isso é útil se você coletar dados de localização fora do SDK do Braze.

1

Braze.setLastKnownLocation(LATITUDE, LONGITUDE, ALTITUDE, HORIZONTAL_ACCURACY, VERTICAL_ACCURACY);
  • No Android, latitude e longitude são obrigatórios. altitude, horizontalAccuracy e verticalAccuracy são opcionais.
  • No iOS, latitude, longitude e horizontalAccuracy são obrigatórios. altitude e verticalAccuracy são opcionais.

Para compatibilidade entre plataformas, forneça latitude, longitude e horizontalAccuracy no mínimo.

Definindo um atributo de localização personalizado

Para definir um atributo de localização personalizado em um perfil de usuário, use o método setLocationCustomAttribute.

1

Braze.setLocationCustomAttribute("favorite_restaurant", 40.7128, -74.0060, optionalCallback);

Solicitando inicialização de localização (apenas Android)

Chame requestLocationInitialization após um usuário conceder permissões de localização para inicializar os recursos de localização do Braze no Android. Este método não é suportado no iOS e não é necessário para recursos de geofence ou localização no iOS.

1

Braze.requestLocationInitialization();

Geofences

Geofences são suportados tanto no iOS quanto no Android. Por padrão, o SDK do Braze pode solicitar e monitorar geofences automaticamente quando a localização está disponível. Você pode contar com essa configuração automática para a maioria das integrações.

Solicitação manual de geofences

Para solicitar manualmente uma atualização de geofence para uma coordenada GPS específica, use requestGeofences. Isso está disponível tanto no iOS quanto no Android. Se você usar este método, desative as solicitações automáticas de geofence em sua configuração nativa para que o SDK não sobrescreva suas solicitações manuais.

1

Braze.requestGeofences(LATITUDE, LONGITUDE);
Github   Editar esta página no GitHub
New Stuff!