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:
- Dans Braze, allez dans Audience > Emplacements.
- 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.
- Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :
- Dans Braze, allez dans Paramètres > Paramètres de l’application.
- Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
- Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

É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" />

L’autorisation d’accès à la localisation en arrière-plan a été ajoutée dans Android 10 et est requise pour que les géorepérages fonctionnent lorsque l’application est en arrière-plan sur tous les appareils Android 10 et ultérieurs.
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>

À partir de la version 3.6.0 du SDK Braze pour Android, la collecte de localisation Braze est désactivée par défaut.
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)

Les géorepérages ne peuvent être demandés qu’une seule fois par session, soit automatiquement par le SDK, soit manuellement avec cette méthode.

À partir d’iOS 14, les géorepérages ne fonctionnent pas de manière fiable pour les utilisateurs qui choisissent de n’autoriser que leur emplacement approximatif.
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:
- Dans Braze, allez dans Audience > Emplacements.
- 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.
- Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :
- Dans Braze, allez dans Paramètres > Paramètres de l’application.
- Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
- Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

É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.

É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.
NSLocationAlwaysAndWhenInUseUsageDescriptionNSLocationWhenInUseUsageDescription


Apple a déprécié NSLocationAlwaysUsageDescription. Pour plus d’informations, consultez la documentation pour développeurs d’Apple.
É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.

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;

Afin d’éviter une décharge excessive de la batterie et une limitation du débit, configurez distanceFilter à une valeur qui répond aux besoins spécifiques de votre application. En définissant une valeur plus élevée pour distanceFilter, vous évitez que votre application ne demande trop souvent la localisation de l’utilisateur.
É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.

Vous ne pouvez demander immédiatement l’autorisation Always qu’une seule fois.
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:
- Dans Braze, allez dans Audience > Emplacements.
- 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.
- Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :
- Dans Braze, allez dans Paramètres > Paramètres de l’application.
- Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
- Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

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" />

L’autorisation d’accès à la localisation en arrière-plan est nécessaire pour que les géorepérages fonctionnent lorsque l’application est en arrière-plan sur les appareils Android 10+.
É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);

Les géorepérages ne peuvent être demandés qu’une seule fois par session, soit automatiquement par le SDK, soit manuellement avec cette méthode.
É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>

Apple a déprécié NSLocationAlwaysUsageDescription. Utilisez les clés ci-dessus pour iOS 14 et versions ultérieures.
É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

Définissez DistanceFilter sur une valeur adaptée aux besoins de votre application afin d’éviter une consommation excessive de la batterie.
É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();

Sans l’autorisation Always, iOS empêche les services de localisation de fonctionner lorsque l’application n’est pas utilisée. Cette restriction est appliquée par le système d’exploitation et ne peut pas être contournée par le SDK Braze.

Les géorepérages sont pris en charge à la fois sur iOS et Android dans le SDK React Native. La méthode requestLocationInitialization est réservée à Android et n’est pas nécessaire pour iOS. La méthode requestGeofences est disponible sur les deux plateformes. Par défaut, le SDK peut automatiquement demander et surveiller les géorepérages lorsque l’emplacement est disponible ; vous pouvez vous fier à cette configuration automatique ou appeler requestGeofences pour effectuer une demande manuellement.
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:
- Dans Braze, allez dans Audience > Emplacements.
- 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.
- Choisissez une app pour laquelle activer les géorepérages, puis sélectionnez Terminé.

Pour activer les géorepérages à partir de la page Paramètres de l’appli :
- Dans Braze, allez dans Paramètres > Paramètres de l’application.
- Sélectionnez l’app pour laquelle vous souhaitez activer les géorepérages.
- Cochez la case Géorepérages activés, puis sélectionnez Enregistrer.

É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.
- Mettre à jour
build.gradle: Ajoutezandroid-sdk-locationet les services de localisation Google Play. Consultez les géorepérages Android. - Mettre à jour le manifeste : Ajoutez les autorisations de localisation et le récepteur de démarrage Braze. Consultez les géorepérages Android.
- 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 :
- Désactivez les demandes automatiques de géorepérage. Sur Android, définissez
com_braze_automatic_geofence_requests_enabledsurfalsedans votrebraze.xml. Sur iOS, définissezautomaticGeofenceRequestssurfalsedans votre configuration Braze. - Appelez
requestGeofencesen indiquant la latitude et la longitude souhaitées :
1
2
3
import Braze from '@braze/react-native-sdk';
Braze.requestGeofences(33.078947, -116.601356);

Les géorepérages ne peuvent être demandés qu’une seule fois par session, soit automatiquement par le SDK, soit manuellement avec cette méthode.