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 représenté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.

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 : Mettre à jour build.gradle

Ajoutez android-sdk-location à votre build.gradle au niveau de l’application. Ajoutez également le package de localisation des services 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 les autorisations de démarrage, de localisation précise et de localisation 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 la collecte de localisation Braze

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

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

Les géorepérages Braze sont activés si la collecte de localisation Braze est activée. Si vous souhaitez désactiver la collecte de localisation par défaut tout en continuant à utiliser les géorepérages, vous pouvez les activer 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 ultérieures, vous devez demander les autorisations de localisation à l’utilisateur final avant de collecter des informations de localisation ou d’enregistrer des géorepérages.

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

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

Le SDK demandera alors des géorepérages aux serveurs Braze et initialisera le suivi des géorepérages.

Consultez RuntimePermissionUtils.java dans notre exemple d’application pour un exemple d’implémentation.

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

Voici comment utiliser l’exemple de code précédent :

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 les géorepérages Braze à proximité. Pour demander manuellement des géorepérages Braze, vous devez désactiver les demandes automatiques de géorepérage Braze et fournir une coordonnée GPS pour les demandes.

Étape 6.1 : Désactiver les demandes automatiques de géorepérage

Les demandes automatiques de géorepérage 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 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)

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 : Activer les services de localisation de votre application

Par défaut, les services de localisation de Braze ne sont pas activés. Pour les activer dans votre application, suivez les étapes ci-dessous. Pour un tutoriel étape par étape, consultez Tutoriel : Emplacements Braze et géorepérages.

Étape 2.1 : Ajouter le module BrazeLocation

Dans Xcode, ouvrez l’onglet General. Sous Frameworks, Libraries, and Embedded Content, ajoutez le module BrazeLocation.

Ajout du module BrazeLocation dans votre projet Xcode

Étape 2.2 : Mettre à jour votre Info.plist

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

  • NSLocationAlwaysAndWhenInUseUsageDescription
  • NSLocationWhenInUseUsageDescription

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

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

Dans le code de votre application, activez les géorepérages en définissant location.geofencesEnabled sur true dans l’objet configuration qui initialise l’instance Braze. Pour d’autres options de configuration location, consultez la référence du SDK Braze Swift.

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 dispose de l’autorisation Always, 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 dispose de l’autorisation When In Use.

Pour surveiller ces événements de géorepérage supplémentaires, ouvrez votre projet Xcode, puis accédez à Signing & Capabilities. Sous Background Modes, cochez Location updates.

Dans Xcode, Background Mode > Location Updates

Ensuite, activez allowBackgroundGeofenceUpdates dans le code de votre application. Cela permet à Braze de prolonger le statut « When In Use » de votre application en surveillant en permanence les mises à jour de localisation. 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 de premier 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 : Demander l’autorisation

Lorsque vous sollicitez l’autorisation d’un utilisateur, demandez l’autorisation When In Use ou Always.

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 application que l’autorisation When In Use et demandera à nouveau à votre utilisateur l’autorisation Always après un certain temps.

Cependant, vous pouvez choisir de solliciter immédiatement votre utilisateur en appelant d’abord requestWhenInUseAuthorization(), puis en appelant requestAlwaysAuthorization() après avoir reçu votre autorisation initiale When In Use.

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

Demander manuellement des géorepérages

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

Pour contrôler la 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 sur 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 : Appeler requestGeofences manuellement

Dans votre code, demandez 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 est-ce que je ne reçois pas de géorepérages sur mon appareil ?

Pour vérifier si les géorepérages sont bien reçus sur votre appareil, commencez par utiliser l’outil de débogage du SDK 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, vous devez activer les géorepérages de localisation pour chaque application sur le tableau de bord. Pour que nos services de localisation fonctionnent correctement, vérifiez que votre application n’utilise pas tous les emplacements de géorepérage disponibles.

Limitation du débit

Braze impose une limite d’une actualisation de 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 de Braze et d’autres fournisseurs ?

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

Par exemple, si votre application contient 20 géorepérages non Braze, il n’y aurait pas d’espace disponible pour suivre les géorepérages Braze (et vice versa). Afin de recevoir de nouveaux géorepérages, vous devrez 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 lors d’une actualisation. 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, la localisation d’un appareil fonctionne indépendamment de sa connexion Internet.

Par exemple, supposons qu’un appareil ait reçu et enregistré avec succès des géorepérages au début de la session, puis 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 ?

Sans l’autorisation Always, 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 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.

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

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

  • BrazePlatform.BrazeAndroidLocationBinding

Étape 3 : Mettre à jour votre AndroidManifest.xml

Ajoutez 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 localisation Braze

Assurez-vous que la collecte de localisation est activée dans votre configuration Braze. Si vous souhaitez activer les géorepérages sans collecte automatique de localisation, définissez 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 les autorisations de localisation lors de l’exécution

Vous devez demander les autorisations de localisation à l’utilisateur avant d’enregistrer les géorepérages. Dans votre code C#, utilisez 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, initialisez la collecte de localisation 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

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

  • Braze.iOS.BrazeLocation

Étape 3 : Configurer l’utilisation de la localisation dans Info.plist

Ajoutez 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 : Activer les géorepérages dans votre configuration Braze

Dans le code de démarrage de votre application (par exemple, App.xaml.cs), configurez 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 les géorepérages en arrière-plan, activez le mode arrière-plan Location updates 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, définissez :

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

Étape 6 : Demander l’autorisation de localisation

Demandez l’autorisation When In Use ou Always à 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.

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 : Effectuer la configuration Android native

Étant donné que le SDK React Native utilise le SDK Android natif de Braze, effectuez 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. Mettre à jour build.gradle : Ajoutez android-sdk-location et les services de localisation Google Play. Consultez les géorepérages Android.
  2. Mettre à jour le manifeste : Ajoutez les autorisations de localisation et le récepteur de démarrage Braze. Consultez les géorepérages Android.
  3. Activer la collecte de données d’emplacement Braze : Mettez à jour votre fichier braze.xml. Consultez les géorepérages Android.

Étape 3 : Effectuer la configuration iOS native

Étant donné que le SDK React Native utilise le SDK iOS natif de Braze, effectuez 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 votre Info.plist avec les descriptions d’utilisation de la localisation (étape 2.2), et activez les géorepérages dans votre configuration Braze en incluant automaticGeofenceRequests = true (é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 — BrazeLocation est déjà inclus implicitement dans le SDK Braze React Native. Consultez les géorepérages iOS, étapes 2.2 à 3.1.

Étape 4 : Demander des géorepérages depuis JavaScript

Sur Android : Une fois que l’utilisateur a accordé les autorisations de localisation, appelez requestLocationInitialization() pour initialiser les fonctionnalités de localisation de 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 la configuration automaticGeofenceRequests dans votre configuration native Swift ou Objective-C de Braze (voir étape 3). Lorsque cette option 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. Désactivez les demandes automatiques de géorepérage. Sur Android, définissez com_braze_automatic_geofence_requests_enabled sur false dans votre braze.xml. Sur iOS, définissez automaticGeofenceRequests sur false dans votre configuration Braze.
  2. Appelez requestGeofences en 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!