Geofences
Erfahren Sie, wie Sie Geofences für das Braze SDK einrichten. Ein Geofence ist ein virtueller geografischer Bereich, der einen Kreis um eine bestimmte globale Position bildet und durch die Kombination von Breitengrad, Längengrad und einem Radius dargestellt wird.
Voraussetzungen
Bevor Sie dieses Feature nutzen können, müssen Sie das Android Braze SDK integrieren.
Einrichten von Geofences
Schritt 1: Enablement in Braze
Sie können Geofences für Ihre App an einem der folgenden Orte aktivieren:
So aktivieren Sie GeoFencing auf der Seite Standorte:
- Gehen Sie in Braze zu Zielgruppe > Standorte.
- Die Anzahl der Apps in Ihrem Workspace, bei denen Geofencing Enablement aktiviert ist, wird unter der Karte aufgeführt. Wenn Geoofences zum Beispiel nur für einige Ihrer Apps aktiviert ist, könnte es heißen: 2 von 5 Apps mit Enablement von Geofences. Um weitere Apps zu aktivieren, wählen Sie die aktuelle Anzahl unter der Karte aus.
- Wählen Sie eine App, für die Sie Geofences aktivieren möchten, und wählen Sie dann Fertig.

So aktivieren Sie Geoofences auf der Seite App-Einstellungen:
- Gehen Sie in Braze zu Einstellungen > App-Einstellungen.
- Wählen Sie die App, für die Sie Geofences aktivieren möchten.
- Markieren Sie Geofences Enablement und wählen Sie dann Speichern.

Schritt 2: build.gradle aktualisieren
Fügen Sie android-sdk-location zu Ihrer App-Ebene build.gradle hinzu. Fügen Sie außerdem das Standortpaket der Google-Play-Dienste mithilfe der Setup-Anleitung der Google-Play-Dienste hinzu:
1
2
3
4
dependencies {
implementation "com.braze:android-sdk-location:+"
implementation "com.google.android.gms:play-services-location:${PLAY_SERVICES_VERSION}"
}
Schritt 3: Manifest aktualisieren
Fügen Sie Ihrer AndroidManifest.xml die Berechtigungen für Boot, genauen Standort und Standort im Hintergrund hinzu:
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" />

Die Berechtigung für den Zugriff auf den Standort im Hintergrund wurde in Android 10 hinzugefügt und ist erforderlich, damit Geofences auf allen Geräten ab Android 10 funktionieren, während die App im Hintergrund läuft.
Fügen Sie den Braze Boot Receiver in das application-Element Ihrer AndroidManifest.xml ein:
1
2
3
4
5
<receiver android:name="com.braze.BrazeBootReceiver">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
Schritt 4: Braze-Standorterfassung aktivieren
Wenn Sie die Braze-Standorterfassung noch nicht aktiviert haben, aktualisieren Sie Ihre braze.xml-Datei so, dass sie com_braze_enable_location_collection enthält, und stellen Sie sicher, dass der Wert auf true gesetzt ist:
1
<bool name="com_braze_enable_location_collection">true</bool>

Ab Version 3.6.0 des Braze Android SDK ist die Braze-Standorterfassung standardmäßig deaktiviert.
Braze-Geofences sind aktiviert, wenn die Braze-Standorterfassung aktiviert ist. Wenn Sie die standardmäßige Standorterfassung ablehnen, aber dennoch Geofences verwenden möchten, können Sie diese selektiv aktivieren, indem Sie – unabhängig vom Wert für com_braze_enable_location_collection – den Wert des Schlüssels com_braze_geofences_enabled in braze.xml auf true setzen:
1
<bool name="com_braze_geofences_enabled">true</bool>
Schritt 5: Standortberechtigungen von Nutzer:innen einholen
Bei Android M und höheren Versionen müssen Sie Nutzer:innen um Standortberechtigungen bitten, bevor Sie Standortinformationen erfassen oder Geofences registrieren können.
Fügen Sie den folgenden Aufruf hinzu, um Braze zu benachrichtigen, wenn Nutzer:innen Ihrer App die Standortberechtigung erteilen:
1
Braze.getInstance(context).requestLocationInitialization();
1
Braze.getInstance(context).requestLocationInitialization()
Daraufhin fordert das SDK Geofences von Braze-Servern an und initialisiert das Geofence-Tracking.
Eine Beispielimplementierung finden Sie unter RuntimePermissionUtils.java in unserer Beispielanwendung.
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
}
}
Die Verwendung des vorangehenden Beispielcodes erfolgt über:
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)
}
}
}
Schritt 6: Manuelles Anfordern von Geofence-Updates (optional)
Braze ruft den Standort des Geräts standardmäßig automatisch ab und fordert anhand des erfassten Standorts Geofences an. Sie können jedoch manuell eine GPS-Koordinate angeben, die stattdessen zum Abrufen der nächstgelegenen Braze-Geofences verwendet wird. Um Braze-Geofences manuell anzufordern, müssen Sie die automatischen Braze-Geofence-Anfragen deaktivieren und eine GPS-Koordinate für Anfragen angeben.
Schritt 6.1: Automatische Geofence-Anfragen deaktivieren
Automatische Geofence-Anfragen von Braze können in der Datei braze.xml deaktiviert werden, indem com_braze_automatic_geofence_requests_enabled auf false gesetzt wird:
1
<bool name="com_braze_automatic_geofence_requests_enabled">false</bool>
Dies kann auch zur Laufzeit wie folgt erfolgen:
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())
Schritt 6.2: Braze-Geofence manuell mit GPS-Koordinate anfordern
Braze-Geofences werden manuell über die Methode requestGeofences() angefordert:
1
Braze.getInstance(getApplicationContext()).requestGeofences(latitude, longitude);
1
Braze.getInstance(applicationContext).requestGeofences(33.078947, -116.601356)

Geofences können nur einmal pro Sitzung angefordert werden – entweder automatisch durch das SDK oder manuell mit dieser Methode.

Ab iOS 14 funktionieren Geofences nicht mehr zuverlässig für Nutzer:innen, die nur ihre ungefähre Standortberechtigung erteilen.
Voraussetzungen
Bevor Sie dieses Feature nutzen können, müssen Sie das Swift Braze SDK integrieren.
Einrichten von Geofences
1. Schritt: Enablement in Braze
Sie können Geofences für Ihre App an einem der folgenden Orte aktivieren:
So aktivieren Sie GeoFencing auf der Seite Standorte:
- Gehen Sie in Braze zu Zielgruppe > Standorte.
- Die Anzahl der Apps in Ihrem Workspace, bei denen Geofencing Enablement aktiviert ist, wird unter der Karte aufgeführt. Wenn Geoofences zum Beispiel nur für einige Ihrer Apps aktiviert ist, könnte es heißen: 2 von 5 Apps mit Enablement von Geofences. Um weitere Apps zu aktivieren, wählen Sie die aktuelle Anzahl unter der Karte aus.
- Wählen Sie eine App, für die Sie Geofences aktivieren möchten, und wählen Sie dann Fertig.

So aktivieren Sie Geoofences auf der Seite App-Einstellungen:
- Gehen Sie in Braze zu Einstellungen > App-Einstellungen.
- Wählen Sie die App, für die Sie Geofences aktivieren möchten.
- Markieren Sie Geofences Enablement und wählen Sie dann Speichern.

2. Schritt: Aktivieren Sie die Standortdienste Ihrer App
Standardmäßig sind die Standortdienste von Braze nicht aktiviert. Um sie in Ihrer App zu aktivieren, führen Sie die folgenden Schritte aus. Eine Schritt-für-Schritt-Anleitung finden Sie unter Tutorial: Braze Standorte und Geofences.
Schritt 2.1: Fügen Sie das Modul BrazeLocation hinzu
Öffnen Sie in Xcode den Tab General. Fügen Sie unter Frameworks, Libraries, and Embedded Content das Modul BrazeLocation hinzu.

Schritt 2.2: Aktualisieren Sie Ihre Info.plist
Weisen Sie in Ihrer info.plist einem der folgenden Schlüssel einen String-Wert zu, der beschreibt, warum Ihre Anwendung den Standort verfolgen muss. Dieser String wird angezeigt, wenn Ihre Nutzer:innen zur Eingabe von Standortdiensten aufgefordert werden. Erklären Sie daher deutlich, welchen Wert die Aktivierung dieses Features für Ihre App hat.
NSLocationAlwaysAndWhenInUseUsageDescriptionNSLocationWhenInUseUsageDescription


Apple hat NSLocationAlwaysUsageDescription als veraltet markiert. Weitere Informationen finden Sie in der Entwickler:innen-Dokumentation von Apple.
3. Schritt: Geofences in Ihrem Code aktivieren
Aktivieren Sie im Code Ihrer App Geofences, indem Sie location.geofencesEnabled auf true im configuration-Objekt setzen, das die Braze-Instanz initialisiert. Für weitere location-Konfigurationsoptionen siehe Braze Swift SDK-Referenz.
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;
Schritt 3.1: Hintergrundberichte aktivieren (optional)
Standardmäßig werden Geofence-Ereignisse nur überwacht, wenn sich Ihre App im Vordergrund befindet oder über eine Always-Autorisierung verfügt, die alle Anwendungszustände überwacht.
Sie können jedoch auch Geofence-Ereignisse überwachen, wenn Ihre App im Hintergrund läuft oder über eine When In Use-Autorisierung verfügt.
Um diese zusätzlichen Geofence-Ereignisse zu überwachen, öffnen Sie Ihr Xcode-Projekt und gehen Sie zu Signing & Capabilities. Aktivieren Sie unter Background Modes die Option Location updates.

Aktivieren Sie als Nächstes allowBackgroundGeofenceUpdates im Code Ihrer App. So kann Braze den „When In Use“-Status Ihrer App verlängern, indem es kontinuierlich Standort-Updates überwacht. Diese Einstellung funktioniert nur, wenn sich Ihre App im Hintergrund befindet. Wenn die App wieder geöffnet wird, werden alle bestehenden Hintergrundprozesse angehalten und stattdessen Vordergrundprozesse priorisiert.
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;

Um Batterieverbrauch und Rate-Limiting zu vermeiden, konfigurieren Sie distanceFilter auf einen Wert, der den spezifischen Anforderungen Ihrer App entspricht. Wenn Sie distanceFilter auf einen höheren Wert einstellen, wird verhindert, dass Ihre App den Standort der Nutzer:innen zu häufig anfragt.
4. Schritt: Autorisierung anfragen
Wenn Sie eine Autorisierung von Nutzer:innen anfordern, fragen Sie entweder die When In Use- oder die Always-Autorisierung an.
Um eine When In Use-Autorisierung anzufragen, verwenden Sie die Methode requestWhenInUseAuthorization():
1
2
var locationManager = CLLocationManager()
locationManager.requestWhenInUseAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestWhenInUseAuthorization];
Standardmäßig gewährt requestAlwaysAuthorization() Ihrer App nur die When In Use-Autorisierung und fordert Ihre Nutzer:innen nach einiger Zeit erneut zur Always-Autorisierung auf.
Sie können Ihre Nutzer:innen jedoch auch sofort auffordern, indem Sie zuerst requestWhenInUseAuthorization() und dann requestAlwaysAuthorization() aufrufen, nachdem Sie die erste When In Use-Autorisierung erhalten haben.

Sie können nur ein einziges Mal sofort eine Always-Autorisierung anfordern.
1
2
var locationManager = CLLocationManager()
locationManager.requestAlwaysAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestAlwaysAuthorization];
Manuelle Anfrage für Geofences
Wenn das Braze SDK Geofences vom Backend anfragt, meldet es den aktuellen Standort der Nutzer:innen und erhält Geofences, die auf der Grundlage des gemeldeten Standorts als optimal relevant eingestuft werden.
Um den Standort zu kontrollieren, den das SDK meldet, um die relevantesten Geofences zu erhalten, können Sie Geofences manuell anfragen, indem Sie die gewünschten Koordinaten angeben.
1. Schritt: Setzen Sie automaticGeofenceRequests auf false
Sie können automatische Geofence-Anfragen in Ihrem configuration-Objekt deaktivieren, das an init(configuration) übergeben wird. Setzen Sie automaticGeofenceRequests auf 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;
2. Schritt: Rufen Sie requestGeofences manuell auf
Fragen Sie in Ihrem Code Geofences mit dem entsprechenden Breiten- und Längengrad an.
1
AppDelegate.braze?.requestGeofences(latitude: latitude, longitude: longitude)
1
2
[AppDelegate.braze requestGeofencesWithLatitude:latitude
longitude:longitude];
Häufig gestellte Fragen (FAQ)
Warum erhalte ich keine Geofences auf meinem Gerät?
Um zu überprüfen, ob Geofences auf Ihrem Gerät empfangen werden, verwenden Sie zunächst den SDK-Debugger, um die Protokolle des SDK zu prüfen. Sie können dann sehen, ob Geofences erfolgreich vom Server empfangen werden und ob es bemerkenswerte Fehler gibt.
Nachstehend finden Sie weitere mögliche Gründe, warum Geofences auf Ihrem Gerät nicht empfangen werden:
Einschränkungen des iOS-Betriebssystems
Das iOS-Betriebssystem erlaubt es nur, bis zu 20 Geofences für eine bestimmte App zu speichern. Wenn Geofences aktiviert sind, wird Braze einige dieser 20 verfügbaren Slots verwenden.
Um versehentliche oder unerwünschte Störungen anderer Geofence-Funktionen in Ihrer App zu vermeiden, müssen Sie Standort-Geofences für einzelne Apps im Dashboard aktivieren. Damit unsere Standortdienste korrekt funktionieren, überprüfen Sie, ob Ihre App nicht alle verfügbaren Geofence-Slots nutzt.
Rate-Limiting
Braze hat ein Limit von 1 Geofence-Aktualisierung pro Sitzung, um unnötige Anfragen zu vermeiden.
Wie funktioniert es, wenn ich sowohl Braze- als auch Nicht-Braze-Geofence-Features verwende?
Wie bereits erwähnt, erlaubt iOS einer einzelnen App, maximal 20 Geofences zu speichern. Dieser Speicher wird sowohl von Braze- als auch von Nicht-Braze-Geofences gemeinsam genutzt und wird von CLLocationManager verwaltet.
Wenn Ihre App beispielsweise 20 Nicht-Braze-Geofences enthält, wäre kein Speicherplatz verfügbar, um Braze-Geofences zu verfolgen (oder umgekehrt). Um neue Geofences zu erhalten, müssen Sie die Standort-APIs von Apple verwenden, um die Überwachung einiger der bestehenden Geofences auf dem Gerät zu beenden.
Kann das Geofences-Feature verwendet werden, wenn ein Gerät offline ist?
Ein Gerät muss nur dann mit dem Internet verbunden sein, wenn eine Aktualisierung erfolgt. Sobald es erfolgreich Geofences vom Server empfangen hat, ist es möglich, einen Geofence-Eingang oder -Ausgang zu protokollieren, selbst wenn das Gerät offline ist. Das liegt daran, dass der Standort eines Geräts getrennt von seiner Internetverbindung funktioniert.
Nehmen wir an, ein Gerät hat zu Beginn der Sitzung erfolgreich Geofences empfangen und registriert und geht dann offline. Wenn es dann in einen dieser registrierten Geofences eintritt, kann es eine Braze-Campaign triggern.
Warum werden Geofences nicht überwacht, wenn meine App im Hintergrund läuft oder beendet wird?
Ohne Always-Autorisierung schränkt Apple die Ausführung von Standortdiensten ein, wenn eine App nicht benutzt wird. Dies wird durch das Betriebssystem erzwungen und liegt außerhalb der Kontrolle des Braze SDK. Braze bietet zwar separate Konfigurationen für die Ausführung von Diensten, während sich die App im Hintergrund befindet, aber es gibt keine Möglichkeit, diese Einschränkungen für Apps zu umgehen, die ohne ausdrückliche Genehmigung der Nutzer:innen beendet werden.
Voraussetzungen
Bevor Sie dieses Feature nutzen können, müssen Sie das .NET MAUI Braze SDK integrieren.
Voraussetzungen
Dies sind die Mindestversionen des SDK, die erforderlich sind, um Geofences zu verwenden:
Einrichten von Geofences
1. Schritt: Enablement in Braze
Sie können Geofences für Ihre App an einem der folgenden Orte aktivieren:
So aktivieren Sie GeoFencing auf der Seite Standorte:
- Gehen Sie in Braze zu Zielgruppe > Standorte.
- Die Anzahl der Apps in Ihrem Workspace, bei denen Geofencing Enablement aktiviert ist, wird unter der Karte aufgeführt. Wenn Geoofences zum Beispiel nur für einige Ihrer Apps aktiviert ist, könnte es heißen: 2 von 5 Apps mit Enablement von Geofences. Um weitere Apps zu aktivieren, wählen Sie die aktuelle Anzahl unter der Karte aus.
- Wählen Sie eine App, für die Sie Geofences aktivieren möchten, und wählen Sie dann Fertig.

So aktivieren Sie Geoofences auf der Seite App-Einstellungen:
- Gehen Sie in Braze zu Einstellungen > App-Einstellungen.
- Wählen Sie die App, für die Sie Geofences aktivieren möchten.
- Markieren Sie Geofences Enablement und wählen Sie dann Speichern.

Befolgen Sie anschließend die unten aufgeführten plattformspezifischen Anweisungen für Android oder iOS:
2. Schritt: Abhängigkeiten hinzufügen
Fügen Sie die folgende NuGet-Paket-Referenz zu Ihrem Projekt hinzu:
BrazePlatform.BrazeAndroidLocationBinding
3. Schritt: AndroidManifest.xml aktualisieren
Fügen Sie die folgenden Berechtigungen zu Ihrer AndroidManifest.xml hinzu:
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" />

Die Berechtigung für den Zugriff auf den Standort im Hintergrund ist erforderlich, damit Geofences funktionieren, während sich die App auf Android 10+-Geräten im Hintergrund befindet.
4. Schritt: Braze-Standorterfassung konfigurieren
Stellen Sie sicher, dass die Standorterfassung in Ihrer Braze-Konfiguration aktiviert ist. Wenn Sie Geofences ohne automatische Standorterfassung aktivieren möchten, nehmen Sie die folgenden Einstellungen in Ihrer Braze.xml vor:
1
2
<bool name="com_braze_enable_location_collection">true</bool>
<bool name="com_braze_geofences_enabled">true</bool>
5. Schritt: Standortberechtigungen zur Laufzeit anfordern
Sie müssen Standortberechtigungen von den Nutzer:innen anfordern, bevor Sie Geofences registrieren. Verwenden Sie in Ihrem C#-Code das folgende Muster:
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...
}
Nachdem die Berechtigungen erteilt wurden, initialisieren Sie die Braze-Standorterfassung:
1
Braze.GetInstance(this).RequestLocationInitialization();
6. Schritt: Geofence-Updates manuell anfordern (optional)
Um Geofences für einen bestimmten Standort manuell anzufordern:
1
Braze.GetInstance(this).RequestGeofences(latitude, longitude);

Geofences können nur einmal pro Sitzung angefordert werden – entweder automatisch durch das SDK oder manuell mit dieser Methode.
2. Schritt: Abhängigkeiten hinzufügen
Fügen Sie die folgende NuGet-Paket-Referenz zu Ihrem Projekt hinzu:
Braze.iOS.BrazeLocation
3. Schritt: Standortnutzung in der Info.plist konfigurieren
Fügen Sie einen Beschreibungstext für die Nutzung von Standortdiensten in Ihrer Info.plist hinzu:
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 hat NSLocationAlwaysUsageDescription als veraltet markiert. Verwenden Sie die oben genannten Schlüssel für iOS 14+.
4. Schritt: Geofences in Ihrer Braze-Konfiguration aktivieren
Konfigurieren Sie Braze in Ihrem App-Startcode (z. B. App.xaml.cs) mit aktivierten Geofences:
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);
5. Schritt: Standort-Updates im Hintergrund aktivieren (optional)
Um Geofences im Hintergrund zu überwachen, aktivieren Sie den Hintergrundmodus Location updates, indem Sie die folgende Konfiguration zu Ihrer Info.plist hinzufügen:
1
2
3
4
<key>UIBackgroundModes</key>
<array>
<string>location</string>
</array>
Legen Sie anschließend in Ihrer Braze-Konfiguration Folgendes fest:
1
2
configuration.Location.AllowBackgroundGeofenceUpdates = true;
configuration.Location.DistanceFilter = 8000; // meters

Setzen Sie DistanceFilter auf einen Wert, der den Anforderungen Ihrer App entspricht, um einen übermäßigen Batterieverbrauch zu vermeiden.
6. Schritt: Standortautorisierung anfordern
Fordern Sie entweder die When In Use- oder die Always-Autorisierung von den Nutzer:innen an:
1
2
3
4
5
6
using CoreLocation;
var locationManager = new CLLocationManager();
locationManager.RequestWhenInUseAuthorization();
// or
locationManager.RequestAlwaysAuthorization();

Ohne die Always-Autorisierung schränkt iOS die Ausführung von Standortdiensten ein, wenn die App nicht verwendet wird. Dies wird vom Betriebssystem erzwungen und kann vom Braze SDK nicht umgangen werden.

Geofences werden sowohl auf iOS als auch auf Android im React Native SDK unterstützt. Die Methode requestLocationInitialization ist ausschließlich für Android verfügbar und für iOS nicht erforderlich. Die Methode requestGeofences ist auf beiden Plattformen verfügbar. Standardmäßig kann das SDK Geofences automatisch anfragen und überwachen, wenn der Standort verfügbar ist. Sie können sich auf diese automatische Konfiguration verlassen oder requestGeofences aufrufen, um Geofences manuell anzufordern.
Voraussetzungen
Bevor Sie dieses Feature nutzen können, müssen Sie das React Native Braze SDK integrieren.
Einrichten von Geofences
Schritt 1: Enablement in Braze
Sie können Geofences für Ihre App an einem der folgenden Orte aktivieren:
So aktivieren Sie GeoFencing auf der Seite Standorte:
- Gehen Sie in Braze zu Zielgruppe > Standorte.
- Die Anzahl der Apps in Ihrem Workspace, bei denen Geofencing Enablement aktiviert ist, wird unter der Karte aufgeführt. Wenn Geoofences zum Beispiel nur für einige Ihrer Apps aktiviert ist, könnte es heißen: 2 von 5 Apps mit Enablement von Geofences. Um weitere Apps zu aktivieren, wählen Sie die aktuelle Anzahl unter der Karte aus.
- Wählen Sie eine App, für die Sie Geofences aktivieren möchten, und wählen Sie dann Fertig.

So aktivieren Sie Geoofences auf der Seite App-Einstellungen:
- Gehen Sie in Braze zu Einstellungen > App-Einstellungen.
- Wählen Sie die App, für die Sie Geofences aktivieren möchten.
- Markieren Sie Geofences Enablement und wählen Sie dann Speichern.

Schritt 2: Vollständige native Android-Einrichtung
Da das React Native SDK das native Braze Android SDK verwendet, führen Sie die native Android-Geofence-Einrichtung für Ihr Projekt durch. Die entsprechenden Schritte für iOS werden im nativen Swift-SDK-Leitfaden zu Geofences (Schritte 2.2 bis 3.1) behandelt. Schritt 2.1 (Hinzufügen des BrazeLocation-Moduls) ist für React Native nicht erforderlich, da BrazeLocation bereits implizit im Braze React Native SDK enthalten ist.
build.gradleaktualisieren: Fügen Sieandroid-sdk-locationund die Standortdienste der Google-Play-Dienste hinzu. Siehe Android-Geofences.- Manifest aktualisieren: Fügen Sie Standortberechtigungen und den Braze-Boot-Empfänger hinzu. Siehe Android-Geofences.
- Standortdatenerfassung von Braze aktivieren: Aktualisieren Sie Ihre
braze.xml-Datei. Siehe Android-Geofences.
Schritt 3: Vollständige native iOS-Einrichtung
Da das React Native SDK das native Braze iOS SDK verwendet, führen Sie die native iOS-Geofence-Einrichtung für Ihr Projekt durch, indem Sie die Anweisungen für das native Swift SDK ab Schritt 2.2 befolgen: Aktualisieren Sie Ihre Info.plist mit Beschreibungen zur Standortnutzung (Schritt 2.2) und aktivieren Sie Geofences in Ihrer Braze-Konfiguration einschließlich automaticGeofenceRequests = true (Schritt 3); optional können Sie die Hintergrundberichterstattung aktivieren (Schritt 3.1). Schritt 2.1 (Hinzufügen des BrazeLocation-Moduls) ist nicht erforderlich – BrazeLocation ist bereits implizit im Braze React Native SDK enthalten. Siehe iOS-Geofences, Schritte 2.2 bis 3.1.
Schritt 4: Geofences über JavaScript anfordern
Auf Android: Nachdem die Nutzer:innen die Standortberechtigungen erteilt haben, rufen Sie requestLocationInitialization() auf, um die Standort-Features von Braze zu initialisieren und Geofences von den Braze-Servern anzufordern. Diese Methode wird unter iOS nicht unterstützt und ist für iOS nicht erforderlich.
Auf iOS: Das Äquivalent besteht darin, die Konfiguration automaticGeofenceRequests in Ihrer nativen Swift- oder Objective-C-Braze-Konfiguration zu aktivieren (siehe Schritt 3). Wenn diese Funktion aktiviert ist, fordert das SDK automatisch Geofences an und überwacht sie, sobald der Standort verfügbar ist. Ein JavaScript-Aufruf, der requestLocationInitialization entspricht, ist nicht erforderlich.
1
2
3
4
import Braze from '@braze/react-native-sdk';
// Android only: call this after the user grants location permission
Braze.requestLocationInitialization();
Schritt 5: Geofences manuell anfordern (optional)
Sowohl auf iOS als auch auf Android können Sie manuell ein Geofence-Update für eine bestimmte GPS-Koordinate anfordern, indem Sie requestGeofences verwenden. Standardmäßig ruft Braze automatisch den Standort des Geräts ab und fordert Geofences an. Um stattdessen manuell eine Koordinate anzugeben:
- Deaktivieren Sie automatische Geofence-Anfragen. Setzen Sie auf Android
com_braze_automatic_geofence_requests_enabledin Ihrerbraze.xmlauffalse. Setzen Sie auf iOSautomaticGeofenceRequestsin Ihrer Braze-Konfiguration auffalse. - Rufen Sie
requestGeofencesmit den gewünschten Breiten- und Längengraden auf:
1
2
3
import Braze from '@braze/react-native-sdk';
Braze.requestGeofences(33.078947, -116.601356);

Geofences können nur einmal pro Sitzung angefordert werden – entweder automatisch durch das SDK oder manuell mit dieser Methode.