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:
- 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 : 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" />
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, tandis que l’application est mise en arrière-plan pour tous les appareils Android 10 et suivants.
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>
À partir de la version 3.6.0 du SDK Braze pour Android, le recueil des données de localisation Braze est désactivé par défaut.
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)
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.
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.
À 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 : 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.

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

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

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;
Afin d’éviter une décharge excessive de la batterie et une limite de débit, veuillez configurerdistanceFilter à 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 l’emplacement/localisation de votre utilisateur.
É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 .
Vous ne pouvez demander immédiatement l’autorisation de Always qu’une seule fois.
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.
Afin de garantir que votre application n’effectue aucune action indésirable lors de la réception des notifications de synchronisation de géorepérage Braze, veuillez suivre les instructions fournies dans l’article sur l’ignorance des notifications push silencieuses.
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:
- 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
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" />
L’autorisation d’accès à l’emplacement 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 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);
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
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>
Apple a déprécié NSLocationAlwaysUsageDescription. Veuillez utiliser les clés ci-dessus pour iOS 14 et versions ultérieures.
É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
VeuillezDistanceFilterdéfinir une valeur adaptée aux besoins de votre application afin d’éviter une consommation excessive de la batterie.
É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();
SansAlwaysautorisation, iOS empêche les services d’emplacement de fonctionner lorsque l’application n’est pas utilisée. Cette mesure est appliquée par le système d’exploitation et ne peut ê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. CetterequestLocationInitializationméthode est réservée à Android et n’est pas nécessaire pour iOS. CetterequestGeofencesméthode 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 appelerrequestGeofencespour effectuer une demande manuellement.
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:
- 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 : 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.
- 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. - 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.
- Activer la collecte de données d’emplacement Braze : Veuillez mettre à jour votre
braze.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 :
- Veuillez désactiver les demandes automatiques de géorepérage. Sur Android, veuillez configurer
com_braze_automatic_geofence_requests_enabledsurfalsedans votrebraze.xml. Sur iOS, veuillez configurerautomaticGeofenceRequestssurfalsedans votre configuration Braze. - Veuillez appeler
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.
Modifier cette page sur GitHub