Skip to content

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:

  1. No Braze, acesse Público > Locais.
  2. 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.
  3. Escolha um app para ativar as geofences e selecione Concluído.

As opções de geofence na página de locais do Braze.

Para ativar as geofences na página de configurações do app:

  1. No Braze, acesse Configurações > Configurações do app.
  2. Selecione o app para o qual deseja ativar as geofences.
  3. Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

A caixa de seleção geofence localizada nas páginas de configurações do Braze.

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

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>

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)

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.

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:

  1. No Braze, acesse Público > Locais.
  2. 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.
  3. Escolha um app para ativar as geofences e selecione Concluído.

As opções de geofence na página de locais do Braze.

Para ativar as geofences na página de configurações do app:

  1. No Braze, acesse Configurações > Configurações do app.
  2. Selecione o app para o qual deseja ativar as geofences.
  3. Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

A caixa de seleção geofence localizada nas páginas de configurações do Braze.

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.

Adicione o módulo BrazeLocation no seu projeto Xcode

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.

  • NSLocationAlwaysAndWhenInUseUsageDescription
  • NSLocationWhenInUseUsageDescription

Info.plist strings de localização no Xcode

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.

No Xcode, Modo em segundo plano > 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;

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.

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.

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:

  1. No Braze, acesse Público > Locais.
  2. 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.
  3. Escolha um app para ativar as geofences e selecione Concluído.

As opções de geofence na página de locais do Braze.

Para ativar as geofences na página de configurações do app:

  1. No Braze, acesse Configurações > Configurações do app.
  2. Selecione o app para o qual deseja ativar as geofences.
  3. Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

A caixa de seleção geofence localizada nas páginas de configurações do Braze.


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

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);

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>

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

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();

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:

  1. No Braze, acesse Público > Locais.
  2. 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.
  3. Escolha um app para ativar as geofences e selecione Concluído.

As opções de geofence na página de locais do Braze.

Para ativar as geofences na página de configurações do app:

  1. No Braze, acesse Configurações > Configurações do app.
  2. Selecione o app para o qual deseja ativar as geofences.
  3. Marque Geofences Enabled (Geofences ativadas) e selecione Save (Salvar).

A caixa de seleção geofence localizada nas páginas de configurações do Braze.

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.

  1. Atualizar build.gradle: Adicionar android-sdk-location e os serviços de localização do Google Play. Veja geofences do Android.
  2. Atualizar o manifesto: Adicionar permissões de localização e o receptor de inicialização do Braze. Veja geofences do Android.
  3. Ativar a coleta de localização do Braze: Atualize seu braze.xml arquivo. 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:

  1. Desativar solicitações automáticas de geofence. No Android, defina com_braze_automatic_geofence_requests_enabled como false na sua braze.xml. No iOS, defina automaticGeofenceRequests como false na sua configuração Braze.
  2. Chame requestGeofences com a latitude e longitude desejadas:
1
2
3
import Braze from '@braze/react-native-sdk';

Braze.requestGeofences(33.078947, -116.601356);
New Stuff!