Geofences
Aprenda como configurar geofences para o SDK Braze. Um geofence é uma área geográfica virtual que forma um círculo ao redor de uma posição global específica, e é representada pela combinação de latitude, longitude e um raio.
Pré-requisitos
Antes de usar este recurso, você precisará integrar o SDK Android Braze. Além disso, você precisará configurar notificações por push silenciosas.
Configuração de geofences
Etapa 1: Capacitação em Braze
Você pode ativar geofences para seu app em um dos seguintes lugares:
Para ativar geofences na página Locais:
- No Braze, acesse Público > Locais.
- O número de apps em seu espaço de trabalho que têm geofences ativadas é listado sob o mapa. Por exemplo, se o geofencing estiver ativado apenas para alguns de seus apps, ele poderá ser lido: 2 de 5 Apps com geofences ativadas. Para ativar aplicativos adicionais, selecione a contagem atual no mapa.
- Escolha um app para ativar as geofences e selecione Concluído.

Para ativar as geofences na página de configurações do app:
- No Braze, acesse Configurações > Configurações do app.
- Selecione o app para o qual deseja ativar as geofences.
- Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

Etapa 2: Atualize build.gradle
Adicione android-sdk-location ao seu nível de app build.gradle. Além disso, adicione o pacote local do Google Play Services usando o guia de configuração do Google Play Services:
1
2
3
4
dependencies {
implementation "com.braze:android-sdk-location:+"
implementation "com.google.android.gms:play-services-location:${PLAY_SERVICES_VERSION}"
}
Etapa 3: Atualizar o manifesto
Adicione permissões de inicialização, de local de trabalho e de local de fundo ao seu site 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" />
A permissão de acesso ao local em segundo plano foi adicionada no Android 10 e é necessária para que o Geofences funcione enquanto o app estiver em segundo plano em todos os dispositivos Android 10+.
Adicione o receptor de inicialização da Braze ao elemento application de seu 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>
Etapa 4: Ativar a coleta de locais do Braze
Se ainda não tiver ativado a coleta de locais do Braze, atualize seu arquivo braze.xml para incluir com_braze_enable_location_collection e confirme que seu valor está definido como true:
1
<bool name="com_braze_enable_location_collection">true</bool>
A partir da versão 3.6.0 do Braze Android SDK, a coleta de locais da Braze é desativada por padrão.
As geofences do Braze são ativadas se a coleta de locais do Braze estiver ativada. Se desejar optar por não participar da nossa coleta de locais padrão, mas ainda quiser usar geofences, isso pode ser ativado seletivamente definindo o valor da chave com_braze_geofences_enabled como true em braze.xml, independentemente do valor de com_braze_enable_location_collection:
1
<bool name="com_braze_geofences_enabled">true</bool>
Etapa 5: Obter permissões de local do usuário final
Para Android M e versões superiores, é necessário solicitar permissões de localização ao usuário final antes de coletar informações de local ou registrar geofences.
Adicione a seguinte chamada para notificar o Braze quando um usuário conceder a permissão de local ao seu app:
1
Braze.getInstance(context).requestLocationInitialization();
1
Braze.getInstance(context).requestLocationInitialization()
Isso fará com que o SDK solicite geofences dos servidores da Braze e inicialize o rastreamento de geofences.
Veja RuntimePermissionUtils.java em nosso aplicativo de amostra para ver um exemplo de implementação.
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
}
}
O uso do código de exemplo anterior é feito por meio de:
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)
}
}
}
Etapa 6: Solicitar manualmente atualizações de geofence (opcional)
Por padrão, a Braze recupera automaticamente o local do dispositivo e solicita geofences com base nesse local coletado. No entanto, você pode fornecer manualmente uma coordenada GPS que será usada para recuperar geofences Braze próximas. Para solicitar geofences do Braze manualmente, você deve desativar as solicitações automáticas de geofences do Braze e fornecer uma coordenada de GPS para as solicitações.
Etapa 6.1: Desativar solicitações automáticas de geofence
As solicitações automáticas de geofence da Braze podem ser desativadas em seu arquivo braze.xml, definindo com_braze_automatic_geofence_requests_enabled como false:
1
<bool name="com_braze_automatic_geofence_requests_enabled">false</bool>
Além disso, isso pode ser feito em tempo de execução por meio de:
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())
Etapa 6.2: Solicitar manualmente a geofence do Braze com coordenadas de GPS
As geofences da Braze são solicitadas manualmente por meio do método requestGeofences() método:
1
Braze.getInstance(getApplicationContext()).requestGeofences(latitude, longitude);
1
Braze.getInstance(applicationContext).requestGeofences(33.078947, -116.601356)
As geofences só podem ser solicitadas uma vez por sessão, seja automaticamente pelo SDK ou manualmente com esse método.
Capacitação de push-to-sync
Note que o Braze sincroniza geofences com dispositivos usando o push em segundo plano. Na maioria dos casos, isso não envolverá alterações de código, pois esse recurso não requer integração adicional por parte do app.
No entanto, note que, se seu aplicativo estiver interrompido, o recebimento de um push em segundo plano o iniciará em segundo plano e seu método Application.onCreate() será chamado. Se você tiver uma implementação personalizada do Application.onCreate(), deverá adiar as chamadas automáticas ao servidor e quaisquer outras ações que não queira que sejam disparadas pelo push em segundo plano.
A partir do iOS 14, geofences não funcionam de forma confiável para usuários que optam por dar apenas permissão para sua localização aproximada.
Pré-requisitos
Antes de poder usar esse recurso, você precisará integrar o Swift Braze SDK.
Configurando geofences
Etapa 1: Ativar no Braze
Você pode ativar geofences para seu app em um dos seguintes lugares:
Para ativar geofences na página Locais:
- No Braze, acesse Público > Locais.
- O número de apps em seu espaço de trabalho que têm geofences ativadas é listado sob o mapa. Por exemplo, se o geofencing estiver ativado apenas para alguns de seus apps, ele poderá ser lido: 2 de 5 Apps com geofences ativadas. Para ativar aplicativos adicionais, selecione a contagem atual no mapa.
- Escolha um app para ativar as geofences e selecione Concluído.

Para ativar as geofences na página de configurações do app:
- No Braze, acesse Configurações > Configurações do app.
- Selecione o app para o qual deseja ativar as geofences.
- Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

Etapa 2: Ative os serviços de localização do seu app
Por padrão, os serviços de localização do Braze não estão ativados. Para ativá-los no seu app, complete as seguintes etapas. Para um tutorial passo a passo, veja Tutorial: Localizações e Geofences do Braze.
Etapa 2.1: Adicione o módulo BrazeLocation
No Xcode, abra a guia Geral. Em Frameworks, Bibliotecas e Conteúdo Embutido, adicione o módulo BrazeLocation.

Etapa 2.2: Atualize seu Info.plist
No seu info.plist, atribua um valor String a uma das seguintes chaves que descrevem por que seu aplicativo precisa rastrear a localização. Essa string será exibida quando seus usuários forem solicitados a permitir serviços de localização, então certifique-se de explicar claramente o valor de ativar esse recurso para seu app.
NSLocationAlwaysAndWhenInUseUsageDescriptionNSLocationWhenInUseUsageDescription

A Apple descontinuou NSLocationAlwaysUsageDescription. Para mais informações, veja documentação do desenvolvedor da Apple.
Etapa 3: Ative geofences no seu código
No código do seu app, ative geofences definindo location.geofencesEnabled como true no objeto configuration que inicializa a instância Braze. Para outras opções de configuração location, veja referência do 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;
Etapa 3.1: Ativar relatórios em segundo plano (opcional)
Por padrão, eventos de geofence são monitorados apenas se seu app estiver em primeiro plano ou tiver Always autorização, que monitora todos os estados do aplicativo.
No entanto, você pode optar por monitorar eventos de geofence se seu app estiver em segundo plano ou tiver When In Use autorização.
Para monitorar esses eventos adicionais de geofence, abra seu projeto no Xcode, depois vá para Assinatura & Capacidades. Em Modos em segundo plano, marque Atualizações de localização.

Em seguida, ative allowBackgroundGeofenceUpdates no código do seu app. Isso permite que a Braze estenda o status “Quando em uso” do seu app, monitorando continuamente as atualizações de localização. Essa configuração só funciona quando seu app está em segundo plano. Quando o app é reaberto, todos os processos em segundo plano existentes são pausados e os processos em primeiro plano são priorizados.
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;
Para evitar consumo excessivo de bateria e limitação de taxa, configure distanceFilter para um valor que atenda às necessidades específicas do seu app. Configurar distanceFilter para um valor mais alto impede que seu app solicite a localizaçāo do usuário com muita frequência.
Etapa 4: Solicitar autorização
Ao solicitar autorização de um usuário, peça autorização When In Use ou Always.
Para solicitar autorização When In Use, use o método requestWhenInUseAuthorization():
1
2
var locationManager = CLLocationManager()
locationManager.requestWhenInUseAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestWhenInUseAuthorization];
Por padrão, requestAlwaysAuthorization() só concede ao seu app When In Use autorização e solicitará novamente ao seu usuário para autorização Always após algum tempo.
No entanto, você pode optar por solicitar imediatamente ao seu usuário, chamando primeiro requestWhenInUseAuthorization() e depois chamando requestAlwaysAuthorization() após receber sua When In Use autorização inicial.
Você só pode solicitar Always autorização uma única vez imediatamente.
1
2
var locationManager = CLLocationManager()
locationManager.requestAlwaysAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestAlwaysAuthorization];
Etapa 5: Verificar push em segundo plano
Braze sincroniza geofences com dispositivos usando notificações por push em segundo plano. Siga estas instruções para configurar notificações push silenciosas para que as atualizações de geofence do servidor sejam tratadas corretamente.
Para garantir que seu aplicativo não tome ações indesejadas ao receber notificações de sincronização de geofence da Braze, siga o artigo ignorando push silencioso.
Solicitar geofences manualmente
Quando o SDK da Braze solicita geofences do backend, ele reporta a localização atual do usuário e recebe geofences que são determinadas como otimalmente relevantes com base na localização reportada.
Para controlar a localização que o SDK reporta para receber as geofences mais relevantes, você pode solicitar geofences manualmente fornecendo as coordenadas desejadas.
Etapa 1: Defina automaticGeofenceRequests como false
Você pode desativar solicitações automáticas de geofence no seu configuration objeto passado para init(configuration). Defina automaticGeofenceRequests como 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;
Etapa 2: Chame requestGeofences manualment
No seu código, solicite geofences com a latitude e longitude apropriadas.
1
AppDelegate.braze?.requestGeofences(latitude: latitude, longitude: longitude)
1
2
[AppDelegate.braze requestGeofencesWithLatitude:latitude
longitude:longitude];
Perguntas Frequentes (FAQ)
Por que não estou recebendo geofences no meu dispositivo?
Para confirmar se os geofences estão sendo recebidos no seu dispositivo, primeiro use a ferramenta de depuração do SDK para verificar os registros do SDK. Você poderá ver se os geofences estão sendo recebidos com sucesso do servidor e se há algum erro notável.
Abaixo estão outras possíveis razões pelas quais os geofences podem não ser recebidos no seu dispositivo:
limitações do sistema operacional iOS
O sistema operacional iOS permite armazenar até 20 geofences para um determinado app. Com as geofences ativadas, a Braze usará alguns desses 20 slots disponíveis.
Para evitar interrupções acidentais ou indesejadas em outras funcionalidades relacionadas a geofences no seu app, você deve ativar os geofences de localização para aplicativos individuais no dashboard. Para que nossos serviços de localização funcionem corretamente, verifique se seu app não está usando todos os pontos de geofence disponíveis.
Limite de taxa
O Braze tem um limite de 1 atualização de geofence por sessão para evitar solicitações desnecessárias.
Como funciona se estou usando tanto recursos de geofence do Braze quanto não-Braze?
Como mencionado acima, o iOS permite que um único app armazene um máximo de 20 geofences. Esse armazenamento é compartilhado entre geofences do Braze e não-Braze e é gerenciado pelo CLLocationManager.
Por exemplo, se seu app contém 20 geofences não-Braze, não haverá armazenamento para rastrear geofences do Braze (ou vice-versa). Para receber novos geofences, você precisará usar APIs de localização da Apple para parar de monitorar alguns dos geofences existentes no dispositivo.
A funcionalidade de Geofences pode ser usada enquanto um dispositivo está offline?
Um dispositivo precisa estar conectado à internet apenas quando uma atualização ocorre. Uma vez que ele tenha recebido com sucesso geofences do servidor, é possível registrar uma entrada ou saída de geofence mesmo que o dispositivo esteja offline. Isso ocorre porque a localização de um dispositivo opera separadamente de sua conectividade com a internet.
Por exemplo, digamos que um dispositivo recebeu e registrou com sucesso geofences no início da sessão e fica offline. Se entrar em uma dessas geofences registradas, pode disparar uma campanha do Braze.
Por que as geofences não são monitoradas quando meu app está em segundo plano/terminado?
Sem Always autorização, a Apple restringe os serviços de localização de funcionar enquanto um app não está em uso. Isso é imposto pelo sistema operacional e está fora do controle do SDK do Braze. Embora o Braze ofereça configurações separadas para executar serviços enquanto o app está em segundo plano, não há como contornar essas restrições para apps que são terminados sem receber autorização explícita do usuário.
Pré-requisitos
Antes de usar este recurso, você precisará integrar o SDK Braze .NET MAUI. Além disso, você precisará configurar notificações por push silenciosas.
Pré-requisitos
Estas são as versões mínimas do SDK necessárias para começar a usar geofences:
Configurando geofences
Etapa 1: Ativar no Braze
Você pode ativar geofences para seu app em um dos seguintes lugares:
Para ativar geofences na página Locais:
- No Braze, acesse Público > Locais.
- O número de apps em seu espaço de trabalho que têm geofences ativadas é listado sob o mapa. Por exemplo, se o geofencing estiver ativado apenas para alguns de seus apps, ele poderá ser lido: 2 de 5 Apps com geofences ativadas. Para ativar aplicativos adicionais, selecione a contagem atual no mapa.
- Escolha um app para ativar as geofences e selecione Concluído.

Para ativar as geofences na página de configurações do app:
- No Braze, acesse Configurações > Configurações do app.
- Selecione o app para o qual deseja ativar as geofences.
- Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

Em seguida, siga as instruções específicas da plataforma abaixo para Android ou iOS:
Etapa 2: Adicionar dependências
Adicione a seguinte referência de pacote NuGet ao seu projeto:
BrazePlatform.BrazeAndroidLocationBinding
Etapa 3: Atualize seu AndroidManifest.xml
Adicione as seguintes permissões ao seu 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" />
A permissão de acesso à localização em segundo plano é necessária para que os geofences funcionem enquanto o app está em segundo plano em dispositivos Android 10 ou superiores.
Etapa 4: Configurar a coleta de localização do Braze
Certifique-se de que a coleta de localização esteja ativada na sua configuração do Braze. Se você quiser ativar geofences sem a coleta automática de localização, defina o seguinte em seu Braze.xml:
1
2
<bool name="com_braze_enable_location_collection">true</bool>
<bool name="com_braze_geofences_enabled">true</bool>
Etapa 5: Solicitar permissões de localização em tempo de execução
Você deve solicitar permissões de localização do usuário antes de registrar geofences. No seu código C#, use o seguinte padrão:
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...
}
Após as permissões serem concedidas, inicialize a coleta de localização do Braze:
1
Braze.GetInstance(this).RequestLocationInitialization();
Etapa 6: Solicitar manualmente atualizações de geofence (opcional)
Para solicitar geofences manualmente para uma localização específica:
1
Braze.GetInstance(this).RequestGeofences(latitude, longitude);
As geofences só podem ser solicitadas uma vez por sessão, seja automaticamente pelo SDK ou manualmente com esse método.
Etapa 2: Adicionar dependências
Adicione a seguinte referência de pacote NuGet ao seu projeto:
Braze.iOS.BrazeLocation
Etapa 3: Configurar o uso de localização em Info.plist
Adicione uma descrição de uso para os serviços de localização em seu 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>
A Apple descontinuou NSLocationAlwaysUsageDescription. Use as chaves acima para iOS 14+.
Etapa 4: Ative geofences na sua configuração do Braze
No seu código de inicialização do app (e.g., App.xaml.cs), configure o Braze com geofences ativados:
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);
Etapa 5: Ative atualizações de localização em segundo plano (opcional)
Para monitorar geofences em segundo plano, ative o modo de fundo Atualizações de localização adicionando a seguinte configuração ao seu Info.plist:
1
2
3
4
<key>UIBackgroundModes</key>
<array>
<string>location</string>
</array>
Então, na sua configuração do Braze, defina:
1
2
configuration.Location.AllowBackgroundGeofenceUpdates = true;
configuration.Location.DistanceFilter = 8000; // meters
Defina DistanceFilter para um valor que atenda às necessidades do seu app para evitar consumo excessivo de bateria.
Etapa 6: Solicite autorização de localização
Solicite autorização When In Use ou Always do usuário:
1
2
3
4
5
6
using CoreLocation;
var locationManager = new CLLocationManager();
locationManager.RequestWhenInUseAuthorization();
// or
locationManager.RequestAlwaysAuthorization();
Sem autorização Always, o iOS restringe os serviços de localização enquanto o app não está em uso. Isso é imposto pelo sistema operacional e não pode ser contornado pelo SDK do Braze.
Os geofences são suportados em ambos iOS e Android no SDK do React Native. O requestLocationInitialization método é exclusivo do Android e não é necessário para iOS. O requestGeofences método está disponível em ambas as plataformas. Por padrão, o SDK pode solicitar e monitorar geofences automaticamente quando a localização está disponível; você pode confiar nessa configuração automática ou chamar requestGeofences para solicitar manualmente.
Pré-requisitos
Antes de poder usar esse recurso, você precisará integrar o React Native Braze SDK. No Android, você precisará configurar notificações push silenciosas para a sincronização de geofences.
Configurando geofences
Etapa 1: Ativar no Braze
Você pode ativar geofences para seu app em um dos seguintes lugares:
Para ativar geofences na página Locais:
- No Braze, acesse Público > Locais.
- O número de apps em seu espaço de trabalho que têm geofences ativadas é listado sob o mapa. Por exemplo, se o geofencing estiver ativado apenas para alguns de seus apps, ele poderá ser lido: 2 de 5 Apps com geofences ativadas. Para ativar aplicativos adicionais, selecione a contagem atual no mapa.
- Escolha um app para ativar as geofences e selecione Concluído.

Para ativar as geofences na página de configurações do app:
- No Braze, acesse Configurações > Configurações do app.
- Selecione o app para o qual deseja ativar as geofences.
- Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

Etapa 2: Completar a configuração nativa do Android
Como o SDK do React Native usa o SDK nativo do Braze para Android, complete a configuração nativa do geofence do Android para seu projeto. O equivalente para iOS desses passos é abordado no guia de geofences do SDK nativo Swift (passos 2.2 a 3.1); o passo 2.1 (Adicionar o módulo BrazeLocation) não é necessário para o React Native porque o BrazeLocation já está incluído implicitamente no SDK do Braze para React Native.
- Atualizar
build.gradle: Adicionarandroid-sdk-locatione os serviços de localização do Google Play. Veja geofences do Android. - Atualizar o manifesto: Adicionar permissões de localização e o receptor de inicialização do Braze. Veja geofences do Android.
- Ativar a coleta de localização do Braze: Atualize seu
braze.xmlarquivo. Veja geofences do Android.
Etapa 3: Completar a configuração nativa do iOS
Como o SDK React Native usa o SDK nativo Braze iOS, complete a configuração nativa de geofence para seu projeto seguindo as instruções do SDK nativo Swift a partir da etapa 2.2: atualize seu Info.plist com descrições de uso de localização (etapa 2.2) e ative geofences na sua configuração Braze, incluindo automaticGeofenceRequests = true (etapa 3); opcionalmente, ative o relatório em segundo plano (etapa 3.1). A Etapa 2.1 (Adicionar o módulo BrazeLocation) não é necessária—BrazeLocation já está incluído implicitamente no SDK React Native da Braze. Veja geofences iOS, etapas 2.2 a 3.1.
Etapa 4: Solicitar geofences do JavaScript
No Android: Depois que o usuário conceder permissões de localização, chame requestLocationInitialization() para inicializar os recursos de localização da Braze e solicitar geofences dos servidores da Braze. Este método não é suportado no iOS e não é necessário para o iOS.
No iOS: O equivalente é ativar a configuração automaticGeofenceRequests na sua configuração nativa Swift ou Objective-C da Braze (veja a Etapa 3). Com isso ativado, o SDK solicita e monitora automaticamente geofences quando a localização está disponível; nenhuma chamada JavaScript equivalente a requestLocationInitialization é necessária.
1
2
3
4
import Braze from '@braze/react-native-sdk';
// Android only: call this after the user grants location permission
Braze.requestLocationInitialization();
Etapa 5: Solicitar geofences manualmente (opcional)
Em iOS e Android, você pode solicitar manualmente uma atualização de geofence para uma coordenada GPS específica usando requestGeofences. Por padrão, a Braze recupera automaticamente a localização do dispositivo e solicita geofences. Para fornecer manualmente uma coordenada em vez disso:
- Desativar solicitações automáticas de geofence. No Android, defina
com_braze_automatic_geofence_requests_enabledcomofalsena suabraze.xml. No iOS, definaautomaticGeofenceRequestscomofalsena sua configuração Braze. - Chame
requestGeofencescom a latitude e longitude desejadas:
1
2
3
import Braze from '@braze/react-native-sdk';
Braze.requestGeofences(33.078947, -116.601356);
As geofences só podem ser solicitadas uma vez por sessão, seja automaticamente pelo SDK ou manualmente com esse método.
Editar esta página no GitHub