Skip to content

Localisation de l’emplacement de la voie

Découvrez comment suivre l’emplacement/localisation à l’aide du SDK de Braze.

Enregistrement de l’emplacement/localisation actuel

Pour obtenir l’emplacement/localisation actuel d’un utilisateur, utilisez la méthode de l’API géolocalisation getCurrentPosition() de l’API de géolocalisation. L’utilisateur sera immédiatement invité à autoriser ou à refuser le suivi (à moins qu’il ne l’ait déjà fait).

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);

Désormais, lorsque des données sont envoyées à Braze, le SDK peut automatiquement détecter le pays de l’utilisateur à l’aide de son adresse IP. Pour plus d’informations, voir setLastKnownLocation().

Suivi continu de l’emplacement/localisation

Pour suivre en continu l’emplacement/localisation d’un utilisateur pendant le chargement d’une page, utilisez la méthode de géolocalisation de l’API watchPosition() de l’API de géolocalisation. L’appel de cette méthode invitera immédiatement l’utilisateur à autoriser ou non le suivi (à moins qu’il ne l’ait déjà fait).

En cas d’abonnement, un rappel de réussite sera désormais invoqué chaque fois que leur emplacement/localisation sera mis à jour.

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);

Enregistrement de l’emplacement/localisation actuel

Même si le suivi continu est désactivé, vous pouvez enregistrer manuellement l’emplacement/localisation actuel de l’utilisateur à l’aide de la méthode setLastKnownLocation() méthode.

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)
}

Suivi continu de l’emplacement/localisation

Pour suivre en permanence l’emplacement/localisation d’un utilisateur, vous devrez déclarer l’intention de votre application de collecter des données d’emplacement/localisation en ajoutant au moins l’une des autorisations suivantes à votre fichier AndroidManifest.xml.

Votre site AndroidManifest.xml devrait ressembler à ce qui suit :

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>

Désactiver le suivi continu

Vous pouvez désactiver le suivi continu au moment de la compilation ou de l’exécution.

Pour désactiver le suivi continu de l’emplacement/localisation au moment de la compilation, définissez com_braze_enable_location_collection sur false dans braze.xml:

1

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

Pour désactiver de manière sélective le suivi continu de l’emplacement/localisation au moment de l’exécution, utilisez l’option 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)

Enregistrement de l’emplacement/localisation actuel

Étape 1 : Configurez votre projet

Pour activer l’emplacement/localisation, ouvrez votre projet Xcode et sélectionnez votre appli. Dans l’onglet Général, ajoutez le module BrazeLocation.

Dans votre fichier AppDelegate.swift, importez le module BrazeLocation au début du fichier. Ajoutez une instance BrazeLocationProvider à la configuration de Braze, en veillant à ce que toutes les modifications apportées à la configuration soient effectuées avant d’appeler Braze(configuration:). Consultez le site Braze.Configuration.Location pour connaître les configurations disponibles.

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
  }

}

Dans votre fichier AppDelegate.m, importez le module BrazeLocation au début du fichier. Ajoutez une instance BrazeLocationProvider à la configuration de Braze, en veillant à ce que toutes les modifications apportées à la configuration soient effectuées avant d’appeler Braze(configuration:). Consultez le site BRZConfigurationLocation pour connaître les configurations disponibles.

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

Étape 2 : Enregistrer l’emplacement/localisation de l’utilisateur

Ensuite, enregistrez dans Braze le dernier emplacement/localisation connu de l’utilisateur. Les exemples suivants supposent que vous avez assigné l’instance de Braze en tant que variable dans votre 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];

Conditions préalables

Avant de pouvoir utiliser cette fonctionnalité, vous devrez intégrer le SDK React Native Braze.

Définition de la dernière localisation connue

Pour définir manuellement la dernière localisation connue d’un utilisateur, veuillez utiliser lasetLastKnownLocationméthode. Cette fonctionnalité est utile si vous collectez des données d’emplacement en dehors du SDK Braze.

1

Braze.setLastKnownLocation(LATITUDE, LONGITUDE, ALTITUDE, HORIZONTAL_ACCURACY, VERTICAL_ACCURACY);
  • Sur Android,latitudeles éléments etlongitudesont obligatoires. altitudeLes éléments horizontalAccuracy, etverticalAccuracysont facultatifs.
  • Sur iOS, latitude,longitude ethorizontalAccuracysont obligatoires.altitudeetverticalAccuracysont facultatifs.

Pour assurer la compatibilité entre les différentes plateformes, veuillez fournir au horizontalAccuracyminimumlatitude , longitude, et .

Définition d’un attribut d’emplacement personnalisé

Pour définir un attribut de localisation personnalisé sur un profil utilisateur, veuillez utiliser lasetLocationCustomAttributeméthode.

1

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

Demande d’initialisation de l’emplacement/localisation (Android uniquement)

Veuillez appeler cette fonctionrequestLocationInitialization après qu’un utilisateur ait accordé les autorisations d’emplacement afin d’initialiser les fonctionnalités de localisation Braze sur Android. Cette méthode n’est pas prise en charge sur iOS et n’est pas requise pour les fonctionnalités de géorepérage ou de localisation iOS.

1

Braze.requestLocationInitialization();

Géorepérages

Les géorepérages sont pris en charge à la fois sur iOS et Android. Par défaut, le SDK Braze peut automatiquement demander et surveiller les géorepérages lorsque l’emplacement est disponible. Vous pouvez vous fier à cette configuration automatique pour la plupart des intégrations.

Demander manuellement des géorepérages

Pour demander manuellement une mise à jour du géorepérage pour une coordonnée GPS spécifique, veuillez utiliser requestGeofences. Ceci est disponible à la fois sur iOS et Android. Si vous utilisez cette méthode, veuillez désactiver les demandes automatiques de géorepérage dans votre configuration native afin que le SDK ne remplace pas vos demandes manuelles.

1

Braze.requestGeofences(LATITUDE, LONGITUDE);
Github   Modifier cette page sur GitHub
New Stuff!