Geofences
Saiba como configurar geofences para o SDK do Braze. Uma geofence é uma área geográfica virtual que forma um círculo em torno 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, as geofences não funcionam de forma confiável para usuários que optam por dar permissão apenas para o local aproximado.
Pré-requisitos
Antes de poder usar esse recurso, você precisará integrar o Swift Braze SDK.
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: Ative os serviços de local do seu app
Por padrão, os serviços de local do Braze não estão ativados. Para ativá-las em seu app, conclua as etapas a seguir. Para obter um tutorial passo a passo, consulte Tutorial: Locais do Braze e geofences.
Etapa 2.1: Adicione o módulo BrazeLocation
No Xcode, abra a guia General. Em Frameworks, Libraries, and Embedded Content, adicione o módulo BrazeLocation.

Etapa 2.2: Atualize seu Info.plist
Em seu info.plist, atribua um valor String a uma das seguintes chaves que descreva por que seu aplicativo precisa rastrear o local. Essa string será exibida quando os usuários forem solicitados a usar os serviços locais, portanto, certifique-se de explicar claramente o valor de ativar esse recurso para o seu app.
NSLocationAlwaysAndWhenInUseUsageDescriptionNSLocationWhenInUseUsageDescription

A Apple descontinuou o site NSLocationAlwaysUsageDescription. Para saber mais, consulte a documentação do desenvolvedor da Apple.
Etapa 3: Ative as geofences em seu código
No código de seu app, ative as geofences definindo location.geofencesEnabled como true no objeto configuration que inicializa a Braze instância. Para obter outras opções de configuração do site location, consulte a referência do 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;
Etapa 3.1: Ativar relatórios em segundo plano (opcional)
Por padrão, os eventos de geofence só são monitorados se o app estiver em primeiro plano ou se tiver a autorização Always, que monitora todos os estados do aplicativo.
No entanto, você pode optar por monitorar também os eventos de geofence se o seu app estiver em segundo plano ou tiver autorizaçãoWhen In Use .
Para monitorar esses eventos adicionais de geofence, abra seu projeto Xcode e acesse Acessar & Capabilities. Em Modos de segundo plano, verifique Atualizações de local.

Em seguida, ative o allowBackgroundGeofenceUpdates no código do seu app. Isso permite que o Braze estenda o status “Quando em uso” do seu app, monitorando continuamente as atualizações do local. Essa configuração só funciona quando o 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 o esgotamento da bateria e o limite de frequência, configure distanceFilter em 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 a autorização de um usuário, solicite 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 avisar imediatamente o usuário ligando primeiro para requestWhenInUseAuthorization() e depois para requestAlwaysAuthorization() após receber a autorização inicial de When In Use.
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 o 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 por push silenciosas para que as atualizações de geofence do servidor sejam tratadas adequadamente.
Para garantir que seu aplicativo não execute nenhuma ação indesejada ao receber notificações de sincronização de geofence do Braze, siga o artigo Ignorando o push silencioso.
Solicitar geofences manualmente
Quando o SDK do Braze solicita geofences do backend, ele informa o local atual do usuário e recebe geofences que são determinadas como relevantes de forma ideal com base no local informado.
Para controlar o local que o SDK informa para receber os 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: Ligue para requestGeofences manualmente
Em seu código, solicite geofences com a latitude e a 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 em meu dispositivo?
Para confirmar se as geofences estão ou não sendo recebidas no seu dispositivo, primeiro use a ferramenta SDK Debugger para verificar os registros do SDK. Poderá então ver se as geofences estão sendo recebidas com sucesso do servidor e se há algum erro notável.
Abaixo estão outros possíveis motivos pelos quais as geofences podem não ser recebidas em seu dispositivo:
Limitações do sistema operacional iOS
O sistema operacional iOS só permite o armazenamento de até 20 geofences para um determinado app. Com as geofences ativadas, a Braze usará alguns desses 20 slots disponíveis.
Para evitar a interrupção acidental ou indesejada de outras funcionalidades relacionadas a geofences em seu aplicativo, é necessário ativar geofences locais 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 isso funciona se eu estiver usando os recursos de geofence Braze e não Braze?
Como mencionado acima, o iOS permite que um único app armazene um máximo de 20 geofences. Esse armazenamento é compartilhado por geofences Braze e não-Braze e é gerenciado pelo CLLocationManager.
Por instância do app, se o seu aplicativo contiver 20 geofences não Braze, não haverá armazenamento para rastreamento de geofences Braze (ou vice-versa). Para receber novas geofences, será necessário usar as APIs de local da Apple para interromper o monitoramento de algumas das geofences existentes no dispositivo.
O recurso Geofences pode ser usado quando um dispositivo está off-line?
Um dispositivo precisa estar conectado à Internet somente quando ocorrer uma atualização. Depois de receber geofences com sucesso do servidor, é possível registrar uma entrada ou saída de geofence mesmo que o dispositivo esteja offline. Isso ocorre porque o local de um dispositivo opera separadamente de sua conectividade com a Internet.
Por exemplo, digamos que um dispositivo tenha recebido e registrado geofences com sucesso no início da sessão e fique off-line. Se ele entrar em uma dessas geofences registradas, poderá disparar uma campanha do Braze.
Por que as geofences não são monitoradas quando meu app está em segundo plano/terminado?
Sem a autorização do Always, a Apple impede que os serviços locais sejam executados enquanto um app não estiver 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 aplicativo está em segundo plano, não há como contornar essas restrições para aplicativos que são encerrados sem receber autorização explícita do usuário.
Editar esta página no GitHub