Skip to content

Géorepérages

Découvrez comment configurer des géorepérages pour le SDK de Braze. Un géorepérage est une zone géographique virtuelle qui forme un cercle autour d’une position globale spécifique et qui est conseillée en combinant la latitude, la longitude et un rayon.

Conditions préalables

Avant de pouvoir utiliser cette fonctionnalité, vous devrez intégrer le SDK Android Braze. En outre, vous devrez configurer des notifications push silencieuses.

Mise en place de géorepérages

Étape 1 : Activer en Braze

Vous pouvez activer les géorepérages pour votre app à l’un des endroits suivants :

Pour activer les géorepérages à partir de la page Emplacements:

  1. Dans Braze, allez dans Audience > Emplacements.
  2. Le nombre d’apps de votre espace de travail qui ont activé les géorepérages est indiqué sous la carte. Par exemple, si les géorepérages ne sont activés que pour certaines de vos apps, on peut lire : 2 sur 5 Apps avec géorepérages activés. Pour activer d’autres applications, sélectionnez le compte actuel sous le mappage.
  3. Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Les options de géorepérage sur la page des localisations Braze.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :

  1. Dans Braze, allez dans Paramètres > Paramètres de l’application.
  2. Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
  3. Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

La case à cocher de géorepérage située sur les pages de paramètres Braze.

Étape 2 : Mise à jour build.gradle

Ajoutez android-sdk-location à votre build.gradle au niveau de l’application. Ajoutez également les services de localisation de Google Play en utilisant le guide de configuration des services Google Play :

1
2
3
4
dependencies {
  implementation "com.braze:android-sdk-location:+"
  implementation "com.google.android.gms:play-services-location:${PLAY_SERVICES_VERSION}"
}

Étape 3 : Mettre à jour le manifeste

Ajoutez des autorisations de démarrage, de recherche de position et de position en arrière-plan à votre AndroidManifest.xml :

1
2
3
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

Ajoutez le récepteur de démarrage Braze à l’élément application de votre AndroidManifest.xml:

1
2
3
4
5
<receiver android:name="com.braze.BrazeBootReceiver">
  <intent-filter>
    <action android:name="android.intent.action.BOOT_COMPLETED" />
  </intent-filter>
</receiver>

Étape 4 : Activer le recueil des données de localisation Braze

Si vous n’avez pas encore activé la collecte d’emplacements/localisations de Braze, mettez à jour votre fichier braze.xml pour y inclure com_braze_enable_location_collection et confirmez que sa valeur est fixée à true:

1
<bool name="com_braze_enable_location_collection">true</bool>

Les géorepérages de Braze sont activés si la fonction de géolocalisation de Braze est activée. Si vous souhaitez désactiver notre fonction de géolocalisation par défaut mais que vous souhaitez toujours utiliser des géorepérages, elle peut être activée de manière sélective en définissant la valeur de la clé com_braze_geofences_enabled sur true dans braze.xml, indépendamment de la valeur de com_braze_enable_location_collection :

1
<bool name="com_braze_geofences_enabled">true</bool>

Étape 5 : Obtenir les autorisations de localisation de l’utilisateur final

Pour Android M et les versions plus élevées, vous devez demander des autorisations de position auprès de l’utilisateur final avant de collecter des informations de position ou d’enregistrer des géorepérages.

Ajoutez l’appel suivant pour notifier Braze lorsqu’un utilisateur accorde l’autorisation de position à votre application :

1
Braze.getInstance(context).requestLocationInitialization();
1
Braze.getInstance(context).requestLocationInitialization()

Le SDK va alors demander des géorepérages aux serveurs de Braze et initialiser le suivi du géorepérage.

Voir RuntimePermissionUtils.java dans notre exemple d’application pour un exemple de mise en œuvre.

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
public class RuntimePermissionUtils {
  private static final String TAG = BrazeLogger.getBrazeLogTag(RuntimePermissionUtils.class);
  public static final int DROIDBOY_PERMISSION_LOCATION = 40;

  public static void handleOnRequestPermissionsResult(Context context, int requestCode, int[] grantResults) {
    switch (requestCode) {
      case DROIDBOY_PERMISSION_LOCATION:
        // In Android Q, we require both FINE and BACKGROUND location permissions. Both
        // are requested simultaneously.
        if (areAllPermissionsGranted(grantResults)) {
          Log.i(TAG, "Required location permissions granted.");
          Toast.makeText(context, "Required location permissions granted.", Toast.LENGTH_SHORT).show();
          Braze.getInstance(context).requestLocationInitialization();
        } else {
          Log.i(TAG, "Required location permissions NOT granted.");
          Toast.makeText(context, "Required location permissions NOT granted.", Toast.LENGTH_SHORT).show();
        }
        break;
      default:
        break;
    }
  }

  private static boolean areAllPermissionsGranted(int[] grantResults) {
    for (int grantResult : grantResults) {
      if (grantResult != PackageManager.PERMISSION_GRANTED) {
        return false;
      }
    }
    return true;
  }
}
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
object RuntimePermissionUtils {
  private val TAG = BrazeLogger.getBrazeLogTag(RuntimePermissionUtils::class.java!!)
  val DROIDBOY_PERMISSION_LOCATION = 40

  fun handleOnRequestPermissionsResult(context: Context, requestCode: Int, grantResults: IntArray) {
    when (requestCode) {
      DROIDBOY_PERMISSION_LOCATION ->
        // In Android Q, we require both FINE and BACKGROUND location permissions. Both
        // are requested simultaneously.
        if (areAllPermissionsGranted(grantResults)) {
          Log.i(TAG, "Required location permissions granted.")
          Toast.makeText(context, "Required location permissions granted.", Toast.LENGTH_SHORT).show()
          Braze.getInstance(context).requestLocationInitialization()
        } else {
          Log.i(TAG, "Required location permissions NOT granted.")
          Toast.makeText(context, "Required location permissions NOT granted.", Toast.LENGTH_SHORT).show()
        }
      else -> {
      }
    }
  }

  private fun areAllPermissionsGranted(grantResults: IntArray): Boolean {
    for (grantResult in grantResults) {
      if (grantResult != PackageManager.PERMISSION_GRANTED) {
        return false
      }
    }
    return true
  }
}

L’utilisation de l’exemple de code précédent est effectuée via :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    boolean hasAllPermissions = PermissionUtils.hasPermission(getApplicationContext(), Manifest.permission.ACCESS_BACKGROUND_LOCATION)
        && PermissionUtils.hasPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION);
    if (!hasAllPermissions) {
      // Request both BACKGROUND and FINE location permissions
      requestPermissions(new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_BACKGROUND_LOCATION},
          RuntimePermissionUtils.DROIDBOY_PERMISSION_LOCATION);
    }
  } else {
    if (!PermissionUtils.hasPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION)) {
      // Request only FINE location permission
      requestPermissions(new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
          RuntimePermissionUtils.DROIDBOY_PERMISSION_LOCATION);
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    val hasAllPermissions = PermissionUtils.hasPermission(applicationContext, Manifest.permission.ACCESS_BACKGROUND_LOCATION)
        && PermissionUtils.hasPermission(applicationContext, Manifest.permission.ACCESS_FINE_LOCATION)
    if (!hasAllPermissions) {
      // Request both BACKGROUND and FINE location permissions
      requestPermissions(arrayOf(android.Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_BACKGROUND_LOCATION),
          RuntimePermissionUtils.DROIDBOY_PERMISSION_LOCATION)
    }
  } else {
    if (!PermissionUtils.hasPermission(applicationContext, Manifest.permission.ACCESS_FINE_LOCATION)) {
      // Request only FINE location permission
      requestPermissions(arrayOf(android.Manifest.permission.ACCESS_FINE_LOCATION),
          RuntimePermissionUtils.DROIDBOY_PERMISSION_LOCATION)
    }
  }
}

Étape 6 : Demander manuellement des mises à jour de géorepérage (facultatif)

Par défaut, Braze récupère automatiquement la localisation de l’appareil et demande des géorepérages en fonction de la localisation collectée. Cependant, vous pouvez fournir manuellement une coordonnée GPS qui sera utilisée pour récupérer à la place les géorepérages de proximité de Braze. Pour demander manuellement des géorepérages Braze, vous devez désactiver les demandes de géorepérage automatiques de Braze et fournir une coordonnée GPS pour les demandes.

Étape 6.1 : Désactiver les requêtes de géorepérage automatique

Les demandes de géorepérage automatique de Braze peuvent être désactivées dans votre fichier braze.xml en définissant com_braze_automatic_geofence_requests_enabled sur false :

1
<bool name="com_braze_automatic_geofence_requests_enabled">false</bool>

Cela peut également être effectué au moment de l’exécution via :

1
2
3
BrazeConfig.Builder brazeConfigBuilder = new BrazeConfig.Builder()
    .setAutomaticGeofenceRequestsEnabled(false);
Braze.configure(getApplicationContext(), brazeConfigBuilder.build());
1
2
3
val brazeConfigBuilder = BrazeConfig.Builder()
    .setAutomaticGeofenceRequestsEnabled(false)
Braze.configure(applicationContext, brazeConfigBuilder.build())

Étape 6.2 : Demander manuellement un géorepérage Braze avec des coordonnées GPS

Les géorepérages de Braze sont demandés manuellement via la méthode requestGeofences() :

1
Braze.getInstance(getApplicationContext()).requestGeofences(latitude, longitude);
1
Braze.getInstance(applicationContext).requestGeofences(33.078947, -116.601356)

Activation de la synchronisation push-to-sync

Notez que Braze synchronise les géorepérages vers les dispositifs à l’aide de notifications push en arrière-plan. Dans la plupart des cas, cela n’implique aucun changement de code, car cette fonctionnalité ne nécessite aucune intégration supplémentaire de la part de l’application.

Cependant, notez que si votre application est arrêtée, la réception d’une notification push en arrière-plan la lancera en arrière-plan et la méthode Application.onCreate() sera appelé. Si vous avez une implémentation personnalisée Application.onCreate(), vous devez reporter les appels de serveur automatique et toute autre action que vous ne souhaitez pas déclencher par la notification push en arrière-plan.

Conditions préalables

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

Configuration des géorepérages

Étape 1 : Activer dans Braze

Vous pouvez activer les géorepérages pour votre app à l’un des endroits suivants :

Pour activer les géorepérages à partir de la page Emplacements:

  1. Dans Braze, allez dans Audience > Emplacements.
  2. Le nombre d’apps de votre espace de travail qui ont activé les géorepérages est indiqué sous la carte. Par exemple, si les géorepérages ne sont activés que pour certaines de vos apps, on peut lire : 2 sur 5 Apps avec géorepérages activés. Pour activer d’autres applications, sélectionnez le compte actuel sous le mappage.
  3. Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Les options de géorepérage sur la page des localisations Braze.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :

  1. Dans Braze, allez dans Paramètres > Paramètres de l’application.
  2. Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
  3. Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

La case à cocher de géorepérage située sur les pages de paramètres Braze.

Étape 2 : Activez les services de localisation de votre application.

Par défaut, les services de localisation Braze ne sont pas activés. Pour les activer dans votre application, veuillez suivre les étapes suivantes. Pour un tutoriel étape par étape, veuillez consulter le Tutoriel : Emplacements Braze et géorepérage.

Étape 2.1 : Veuillez ajouter leBrazeLocationmodule

Dans Xcode, veuillez ouvrir l’onglet Général. Sous Frameworks, Libraries, and Embedded Content, veuillez ajouter leBrazeLocationmodule.

Veuillez ajouter le module BrazeLocation à votre projet Xcode.

Étape 2.2 : Mettez à jour votre Info.plist

Dans votre info.plist, veuillez attribuer uneStringvaleur à l’une des clés suivantes qui décrit pourquoi votre application doit suivre les emplacements. Cette chaîne de caractères s’affichera lorsque vos utilisateurs seront invités à activer les services de localisation. Veuillez donc expliquer clairement l’intérêt d’activer cette fonctionnalité pour votre application.

  • NSLocationAlwaysAndWhenInUseUsageDescription
  • NSLocationWhenInUseUsageDescription

Info.plist chaînes de caractères de localisation dans Xcode

Étape 3 : Activez les géorepérages dans votre code.

Dans le code de votre application, veuillez activer les géorepérages en définissantlocation.geofencesEnabled surtrue dans configurationl’objet qui initialise Brazel’instance . Pour d’autres optionslocation de configuration, veuillez consulter la référence Braze Swift SDK.

1
2
3
4
5
6
7
8
9
10
11
12
13
let configuration = Braze.Configuration(
  apiKey: "<BRAZE_API_KEY>",
  endpoint: "<BRAZE_ENDPOINT>"
)
configuration.location.brazeLocationProvider = BrazeLocationProvider()
configuration.location.automaticLocationCollection = true
configuration.location.geofencesEnabled = true
configuration.location.automaticGeofenceRequests = true

// Additional configuration customization...

let braze = Braze(configuration: configuration)
AppDelegate.braze = braze
1
2
3
4
5
6
7
8
9
10
11
12
13
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;

// Additional configuration customization...

Braze *braze = [[Braze alloc] initWithConfiguration:configuration];
AppDelegate.braze = braze;

Étape 3.1 : Activer les rapports en arrière-plan (facultatif)

Par défaut, les événements de géorepérage ne sont surveillés que si votre application est au premier plan ou disposeAlwaysd’une autorisation qui surveille tous les états de l’application.

Cependant, vous pouvez également choisir de surveiller les événements de géorepérage si votre application est en arrière-plan ou disposeWhen In Used’une autorisation.

Pour surveiller ces événements de géorepérage supplémentaires, veuillez ouvrir votre projet Xcode, puis accédez à Signing&Capabilities. Sous Modes d’arrière-plan, veuillez cocher Mises à jour de l’emplacement/localisation.

Dans Xcode, Mode arrière-plan > Mises à jour d’emplacement

Ensuite, veuillez activerallowBackgroundGeofenceUpdatesdans le code de votre application. Cela permet à Braze de prolonger le statut « En cours d’utilisation » de votre application en surveillant en permanence les mises à jour d’emplacement. Ce paramètre ne fonctionne que lorsque votre application est en arrière-plan. Lorsque l’application se rouvre, tous les processus d’arrière-plan existants sont mis en pause et les processus d’avant-plan sont prioritaires.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let configuration = Braze.Configuration(
  apiKey: "<BRAZE_API_KEY>",
  endpoint: "<BRAZE_ENDPOINT>"
)

// Additional configuration customization...

// Enable background geofence reporting with `When In Use` authorization.
configuration.location.allowBackgroundGeofenceUpdates = true

// Determines the number of meters required to trigger a new location update.
configuration.location.distanceFilter = 8000

let braze = Braze(configuration: configuration)
AppDelegate.braze = braze
1
2
3
4
5
6
7
8
9
10
11
12
13
14
BRZConfiguration *configuration =
    [[BRZConfiguration alloc] initWithApiKey:brazeApiKey
                                    endpoint:brazeEndpoint];

// Additional configuration customization...

// Enable background geofence reporting with `When In Use` authorization.
configuration.location.allowBackgroundGeofenceUpdates = YES;

// Determines the number of meters required to trigger a new location update.
configuration.location.distanceFilter = 8000;

Braze *braze = [[Braze alloc] initWithConfiguration:configuration];
AppDelegate.braze = braze;

Étape 4 : Veuillez demander l’autorisation

Lorsque vous sollicitez l’autorisation d’un utilisateur, veuillez demander l’autorisationWhen In UseouAlwaysl’autorisation.

Pour demander l’autorisation When In Use, utilisez la méthode requestWhenInUseAuthorization() :

1
2
var locationManager = CLLocationManager()
locationManager.requestWhenInUseAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestWhenInUseAuthorization];

Par défaut, requestAlwaysAuthorization() n’accorde à votre appli que l’autorisation When In Use et demandera à nouveau à votre utilisateur l’autorisation Always après un certain temps.

Cependant, vous pouvez choisir d’interroger immédiatement votre utilisateur en appelant d’abordrequestWhenInUseAuthorization() puis en appelantrequestAlwaysAuthorization() après avoir reçu votre autorisation When In Useinitiale .

1
2
var locationManager = CLLocationManager()
locationManager.requestAlwaysAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestAlwaysAuthorization];

Étape 5 : Vérifier la mise à jour en arrière-plan

Braze synchronise les géorepérage vers les appareils à l’aide de notifications push en arrière-plan. Veuillez suivre ces instructions pour configurer les notifications push silencieuses afin que les mises à jour de géorepérage provenant du serveur soient correctement gérées.

Demander manuellement des géorepérages

Lorsque le SDK Braze demande des géorepérages au backend, il communique l’emplacement actuel de l’utilisateur et reçoit les géorepérages jugés les plus pertinents en fonction de l’emplacement communiqué.

Pour contrôler l’emplacement/localisation que le SDK signale afin de recevoir les géorepérages les plus pertinents, vous pouvez demander manuellement des géorepérages en fournissant les coordonnées souhaitées.

Étape 1 : Définir automaticGeofenceRequests à false

Vous pouvez désactiver les demandes automatiques de géorepérage dans votre objet configuration passé à init(configuration). Définissez automaticGeofenceRequests sur false.

1
2
3
4
5
6
7
let configuration = Braze.Configuration(
  apiKey: "{BRAZE_API_KEY}",
  endpoint: "{BRAZE_ENDPOINT}"
)
configuration.automaticGeofencesRequest = false
let braze = Braze(configuration: configuration)
AppDelegate.braze = braze
1
2
3
4
5
6
BRZConfiguration *configuration =
  [[BRZConfiguration alloc] initWithApiKey:{BRAZE_API_KEY}
                                  endpoint:{BRAZE_ENDPOINT}];
configuration.automaticGeofencesRequest = NO;
Braze *braze = [[Braze alloc] initWithConfiguration:configuration];
AppDelegate.braze = braze;

Étape 2 : Veuillez appelerrequestGeofencesmanuellement

Dans votre code, veuillez demander des géorepérages avec la latitude et la longitude appropriées.

1
AppDelegate.braze?.requestGeofences(latitude: latitude, longitude: longitude)
1
2
[AppDelegate.braze requestGeofencesWithLatitude:latitude
                                      longitude:longitude];

Foire aux questions (FAQ)

Pourquoi ne reçois-je pas les géorepérages sur mon appareil ?

Pour vérifier si les géorepérages sont bien reçus sur votre appareil, veuillez d’abord utiliser l’outil SDK Debugger afin de consulter les journaux du SDK. Vous pourrez alors vérifier si les géorepérages sont correctement reçus depuis le serveur et s’il existe des erreurs notables.

Voici d’autres raisons possibles pour lesquelles les géorepérages peuvent ne pas être reçus sur votre appareil :

Limitations du système d’exploitation iOS

Le système d’exploitation iOS ne permet de stocker que 20 géorepérages maximum pour une application donnée. Avec les géorepérages activés, Braze utilisera une partie de ces 20 emplacements disponibles.

Afin d’éviter toute perturbation accidentelle ou indésirable des autres fonctionnalités liées aux géorepérages dans votre application, il est nécessaire d’activer les géorepérages d’emplacement pour chaque application sur le tableau de bord. Pour que nos services d’emplacement/localisation fonctionnent correctement, vérifiez que votre appli n’utilise pas tous les emplacements de géorepérage disponibles.

Limitation du taux

Braze impose une limite d’une actualisation du géorepérage par session afin d’éviter les requêtes superflues.

Comment cela fonctionne-t-il si j’utilise à la fois les fonctionnalités de géorepérage Braze et non Braze ?

Comme mentionné précédemment, iOS permet à une seule application de stocker un maximum de 20 unités de géorepérage. Cet espace de stockage est partagé entre les géorepérages Braze et non Braze et est géré par CLLocationManager.

Par exemple, si votre application contient 20 géorepérages non Braze, il n’y aurait pas de stockage disponible pour suivre les géorepérages Braze (ou vice versa). Afin de recevoir de nouveaux géorepérages, il est nécessaire d’utiliser les API de localisation d’Apple pour désactiver la surveillance de certains géorepérages existants sur l’appareil.

La fonctionnalité de géorepérage peut-elle être utilisée lorsqu’un appareil est hors ligne ?

Un appareil doit être connecté à Internet uniquement lorsqu’il est nécessaire d’actualiser. Une fois les géorepérages reçus avec succès depuis le serveur, il est possible d’enregistrer une entrée ou une sortie de géorepérage même si l’appareil est hors ligne. En effet, l’emplacement d’un appareil fonctionne indépendamment de sa connexion Internet.

Par exemple, supposons qu’un appareil ait reçu et enregistré avec succès du géorepérage au début de la session et se déconnecte. Si l’utilisateur pénètre dans l’une de ces zones de géorepérage enregistrées, cela peut déclencher une campagne Braze.

Pourquoi les géorepérages ne sont-ils pas surveillés lorsque mon application est en arrière-plan ou fermée ?

SansAlwaysautorisation, Apple limite l’exécution des services de localisation lorsqu’une application n’est pas utilisée. Cette mesure est appliquée par le système d’exploitation et échappe au contrôle du SDK Braze. Bien que Braze propose des configurations distinctes pour exécuter des services lorsque l’application est en arrière-plan, il n’existe aucun moyen de contourner ces restrictions pour les applications qui sont fermées sans l’autorisation explicite de l’utilisateur.

Conditions préalables

Avant de pouvoir utiliser cette fonctionnalité, il est nécessaire d’intégrer le SDK .NET MAUI Braze. De plus, il sera nécessaire de configurer les notifications push silencieuses.

Conditions préalables

Voici les versions minimales requises du SDK pour commencer à utiliser les géorepérages :

Configuration des géorepérages

Étape 1 : Activer dans Braze

Vous pouvez activer les géorepérages pour votre app à l’un des endroits suivants :

Pour activer les géorepérages à partir de la page Emplacements:

  1. Dans Braze, allez dans Audience > Emplacements.
  2. Le nombre d’apps de votre espace de travail qui ont activé les géorepérages est indiqué sous la carte. Par exemple, si les géorepérages ne sont activés que pour certaines de vos apps, on peut lire : 2 sur 5 Apps avec géorepérages activés. Pour activer d’autres applications, sélectionnez le compte actuel sous le mappage.
  3. Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Les options de géorepérage sur la page des localisations Braze.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :

  1. Dans Braze, allez dans Paramètres > Paramètres de l’application.
  2. Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
  3. Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

La case à cocher de géorepérage située sur les pages de paramètres Braze.


Veuillez ensuite suivre les instructions spécifiques à la plateforme ci-dessous, pour Android ou iOS :

Étape 2 : Ajouter des dépendances

Veuillez ajouter la référence au package NuGet suivante à votre projet :

  • BrazePlatform.BrazeAndroidLocationBinding

Étape 3 : Mettez à jour votre AndroidManifest.xml

Veuillez ajouter les autorisations suivantes à votre AndroidManifest.xml:

1
2
3
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

Étape 4 : Configurer la collecte de données d’emplacement Braze

Veuillez vous assurer que la collecte des données d’emplacement est activée dans votre configuration Braze. Si vous souhaitez activer les géorepérages sans collecte automatique d’emplacements, veuillez définir les paramètres suivants dans votre Braze.xml:

1
2
<bool name="com_braze_enable_location_collection">true</bool>
<bool name="com_braze_geofences_enabled">true</bool>

Étape 5 : Demander des autorisations d’emplacement lors de l’exécution

Il est nécessaire de demander l’autorisation d’emplacement à l’utilisateur avant d’enregistrer du géorepérage. Dans votre code C#, veuillez utiliser le modèle suivant :

1
2
3
4
5
6
7
8
9
10
11
12
using AndroidX.Core.App;
using AndroidX.Core.Content;

private void RequestLocationPermission()
{
  // ...existing code for checking and requesting permissions...
}

public override void OnRequestPermissionsResult(int requestCode, string[] permissions, Permission[] grantResults)
{
  // ...existing code for handling permission result...
}

Une fois les autorisations accordées, veuillez initialiser la collecte d’emplacements/localisations Braze :

1
Braze.GetInstance(this).RequestLocationInitialization();

Étape 6 : Demander manuellement des mises à jour de géorepérage (facultatif)

Pour demander manuellement des géorepérages pour un emplacement spécifique :

1
Braze.GetInstance(this).RequestGeofences(latitude, longitude);

Étape 2 : Ajouter des dépendances

Veuillez ajouter la référence au package NuGet suivante à votre projet :

  • Braze.iOS.BrazeLocation

Étape 3 : Veuillez configurer l’utilisation de l’emplacement/localisation dans Info.plist

Veuillez ajouter une chaîne de caractères de description d’utilisation pour les services de localisation dans votre Info.plist:

1
2
3
4
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>This app uses your location to enable geofences and location-based messaging.</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>This app uses your location to enable geofences and location-based messaging.</string>

Étape 4 : Activez les géorepérages dans votre configuration Braze.

Dans le code de démarrage de votre application (e.g., App.xaml.cs), veuillez configurer Braze avec les géorepérages activés :

1
2
3
4
5
6
7
8
9
10
using BrazeKit;
using BrazeLocation;

var configuration = new BRZConfiguration("<BRAZE_API_KEY>", "<BRAZE_ENDPOINT>");
configuration.Location.BrazeLocationProvider = new BrazeLocationProvider();
configuration.Location.AutomaticLocationCollection = true;
configuration.Location.GeofencesEnabled = true;
configuration.Location.AutomaticGeofenceRequests = true;
// ...other configuration...
var braze = new Braze(configuration);

Étape 5 : Activer les mises à jour de localisation en arrière-plan (facultatif)

Pour surveiller le géorepérage en arrière-plan, veuillez activer le mode arrière-plan des mises à jour d’emplacement en ajoutant la configuration suivante à votre Info.plist:

1
2
3
4
<key>UIBackgroundModes</key>
<array>
  <string>location</string>
</array>

Ensuite, dans votre configuration Braze, veuillez définir :

1
2
configuration.Location.AllowBackgroundGeofenceUpdates = true;
configuration.Location.DistanceFilter = 8000; // meters

Étape 6 : Demander l’autorisation pour l’emplacement/la localisation

Veuillez demanderWhen In UseAlways l’autorisation à l’utilisateur :

1
2
3
4
5
6
using CoreLocation;

var locationManager = new CLLocationManager();
locationManager.RequestWhenInUseAuthorization();
// or
locationManager.RequestAlwaysAuthorization();

Conditions préalables

Avant de pouvoir utiliser cette fonctionnalité, vous devrez intégrer le SDK React Native Braze. Sur Android, il est nécessaire de configurer les notifications push silencieuses pour la synchronisation de géorepérage.

Configuration des géorepérages

Étape 1 : Activer dans Braze

Vous pouvez activer les géorepérages pour votre app à l’un des endroits suivants :

Pour activer les géorepérages à partir de la page Emplacements:

  1. Dans Braze, allez dans Audience > Emplacements.
  2. Le nombre d’apps de votre espace de travail qui ont activé les géorepérages est indiqué sous la carte. Par exemple, si les géorepérages ne sont activés que pour certaines de vos apps, on peut lire : 2 sur 5 Apps avec géorepérages activés. Pour activer d’autres applications, sélectionnez le compte actuel sous le mappage.
  3. Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Les options de géorepérage sur la page des localisations Braze.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :

  1. Dans Braze, allez dans Paramètres > Paramètres de l’application.
  2. Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
  3. Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

La case à cocher de géorepérage située sur les pages de paramètres Braze.

Étape 2 : Configuration Android native complète

Étant donné que le SDK React native utilise le SDK Android natif de Braze, veuillez effectuer la configuration native du géorepérage Android pour votre projet. L’équivalent iOS de ces étapes est décrit dans le guide des géorepérages du SDK Swift natif (étapes 2.2 à 3.1) ; l’étape 2.1 (Ajouter le module BrazeLocation) n’est pas nécessaire pour React native, car BrazeLocation est déjà inclus implicitement dans le SDK Braze React native.

  1. Mise à jour build.gradle: Veuillezandroid-sdk-locationajouter les services de localisation Google Play pour l’emplacement/la localisation. Veuillez consulter les géorepérages Android.
  2. Veuillez mettre à jour le manifeste : Veuillez ajouter les autorisations pour les emplacements et le récepteur de démarrage Braze. Veuillez consulter les géorepérages Android.
  3. Activer la collecte de données d’emplacement Braze : Veuillez mettre à jour votrebraze.xmlfichier. Veuillez consulter les géorepérages Android.

Étape 3 : Configuration iOS native complète

Étant donné que le SDK React native utilise le SDK iOS natif de Braze, veuillez terminer la configuration native du géorepérage iOS pour votre projet en suivant les instructions du SDK Swift natif à partir de l’étape 2.2 : mettez à jour votreInfo.plistconfiguration avec les descriptions d’utilisation des emplacements (étape 2.2) et activez le géorepérage dans votre configuration Braze, y comprisautomaticGeofenceRequests = trueles paramètres de géolocalisation (étape 3) ; vous pouvez également activer les rapports en arrière-plan (étape 3.1). L’étape 2.1 (Ajouter le module BrazeLocation) n’est pas nécessaire, car BrazeLocation est déjà inclus implicitement dans le SDK Braze React native. Veuillez vous référer aux géorepérages iOS, étapes 2.2 à 3.1.

Étape 4 : Demander du géorepérage à partir de JavaScript

Sur Android : Une fois que l’utilisateur a accordé les autorisations d’emplacement, veuillez appelerrequestLocationInitialization()pour initialiser les fonctionnalités d’emplacement Braze et demander des géorepérages aux serveurs Braze. Cette méthode n’est pas prise en charge sur iOS et n’est pas requise pour iOS.

Sur iOS : L’équivalent consiste à activer laautomaticGeofenceRequestsconfiguration dans votre configuration native Swift ou Objective-C Braze (voir étape 3). Lorsque cette fonctionnalité est activée, le SDK demande et surveille automatiquement les géorepérages lorsque l’emplacement est disponible ; aucun appel JavaScript équivalent àrequestLocationInitialization n’est nécessaire.

1
2
3
4
import Braze from '@braze/react-native-sdk';

// Android only: call this after the user grants location permission
Braze.requestLocationInitialization();

Étape 5 : Demander manuellement des géorepérages (facultatif)

Sur iOS et Android, vous pouvez demander manuellement une mise à jour du géorepérage pour une coordonnée GPS spécifique en utilisant requestGeofences. Par défaut, Braze récupère automatiquement l’emplacement de l’appareil et demande des géorepérages. Pour fournir manuellement une coordonnée à la place :

  1. Veuillez désactiver les demandes automatiques de géorepérage. Sur Android, veuillez configurercom_braze_automatic_geofence_requests_enabled surfalse dans votre braze.xml. Sur iOS, veuillez configurerautomaticGeofenceRequests surfalse dans votre configuration Braze.
  2. Veuillez appelerrequestGeofencesen indiquant la latitude et la longitude souhaitées :
1
2
3
import Braze from '@braze/react-native-sdk';

Braze.requestGeofences(33.078947, -116.601356);
New Stuff!