Skip to content

Geofences

Aprenda como configurar geofences para o SDK da Braze. Um geofence é uma área geográfica virtual que forma um círculo ao redor de uma posição global específica, representada pela combinação de latitude, longitude e um raio.

Pré-requisitos

Antes de usar este recurso, você precisará integrar o SDK Android Braze.

Configurando geofences

Etapa 1: Ativar na 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 build.gradle do nível do app. Além disso, adicione o pacote de localização 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, localização precisa e localização em segundo plano ao seu 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 do 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 localização da Braze

Se ainda não tiver ativado a coleta de localização da 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>

Os geofences da Braze são ativados se a coleta de localização da Braze estiver ativada. Se você quiser fazer o descadastramento da nossa coleta de localização 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 localização 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 localização ou registrar geofences.

Adicione a seguinte chamada para notificar a Braze quando um usuário conceder a permissão de localização 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 no nosso aplicativo de exemplo para ver uma implementação de referência.

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 da seguinte forma:

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 a localização do dispositivo e solicita geofences com base nessa localização coletada. No entanto, você pode fornecer manualmente uma coordenada GPS que será usada para recuperar geofences da Braze próximos. Para solicitar geofences da Braze manualmente, você deve desativar as solicitações automáticas de geofence e fornecer uma coordenada 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 no seu arquivo braze.xml, definindo com_braze_automatic_geofence_requests_enabled como false:

1

<bool name="com_braze_automatic_geofence_requests_enabled">false</bool>

Isso também 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 geofence da Braze com coordenada GPS

Os geofences da Braze são solicitados manualmente por meio do método requestGeofences():

1

Braze.getInstance(getApplicationContext()).requestGeofences(latitude, longitude);

1

Braze.getInstance(applicationContext).requestGeofences(33.078947, -116.601356)

Pré-requisitos

Antes de poder usar esse recurso, você precisará integrar o Swift Braze SDK.

Configurando geofences

Etapa 1: Ativar na 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 da 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 da Braze.

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.

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

Strings de localização do Info.plist 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 a 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 autorização Always, que monitora todos os estados do aplicativo.

No entanto, você também pode optar por monitorar eventos de geofence quando seu app estiver em segundo plano ou tiver autorização When In Use.

Para monitorar esses eventos adicionais de geofence, abra seu projeto no Xcode e vá para Signing & Capabilities. Em Background Modes, marque Location updates.

No Xcode, Background Mode > Location Updates

Em seguida, ative allowBackgroundGeofenceUpdates no código do seu app. Isso permite que a Braze estenda o status “When In Use” 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 autorização When In Use e solicitará novamente ao seu usuário a 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 autorização inicial When In Use.

1
2

var locationManager = CLLocationManager()
locationManager.requestAlwaysAuthorization()

1
2

CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestAlwaysAuthorization];

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 otimamente 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 objeto configuration 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 manualmente

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 Depurador 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 slots de geofence disponíveis.

Limite de taxa

A Braze tem um limite de 1 atualização de geofence por sessão para evitar solicitações desnecessárias.

Como funciona se estou usando recursos de geofence da Braze e de terceiros?

Como mencionado acima, o iOS permite que um único app armazene um máximo de 20 geofences. Esse armazenamento é compartilhado entre geofences da Braze e de terceiros e é gerenciado pelo CLLocationManager.

Por exemplo, se seu app contém 20 geofences de terceiros, não haverá armazenamento para rastrear geofences da Braze (ou vice-versa). Para receber novos geofences, você precisará usar as 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 da 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, isso pode disparar uma Campaign da Braze.

Por que as geofences não são monitoradas quando meu app está em segundo plano/terminado?

Sem autorização Always, 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 da Braze. Embora a 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.

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 na 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 da Braze

Certifique-se de que a coleta de localização esteja ativada na sua configuração da Braze. Se você quiser ativar geofences sem a coleta automática de localização, defina o seguinte no 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 da 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 no Info.plist

Adicione uma string de descrição de uso para os serviços de localização no 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: Ativar geofences na sua configuração da Braze

No seu código de inicialização do app (por exemplo, App.xaml.cs), configure a 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: Ativar atualizações de localização em segundo plano (opcional)

Para monitorar geofences em segundo plano, ative o modo de segundo plano Location updates 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 da Braze, defina:

1
2

configuration.Location.AllowBackgroundGeofenceUpdates = true;
configuration.Location.DistanceFilter = 8000; // meters

Etapa 6: Solicitar 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.

Configurando geofences

Etapa 1: Ativar na 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 da Braze para Android, complete a configuração nativa de geofence do Android para o seu projeto. O equivalente para iOS dessas etapas é abordado no guia de geofences do SDK nativo Swift (etapas 2.2 a 3.1; a etapa 2.1 (Adicionar o módulo BrazeLocation) não é necessária para o React Native porque o BrazeLocation já está incluído implicitamente no SDK da Braze para React Native.

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

Etapa 3: Completar a configuração nativa do iOS

Como o SDK do React Native usa o SDK nativo da Braze para iOS, complete a configuração nativa de geofence do iOS para o 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 da 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 — o BrazeLocation já está incluído implicitamente no SDK da Braze para React Native. Veja geofences do iOS, etapas 2.2 a 3.1.

Etapa 4: Solicitar geofences pelo 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. Esse 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:

  1. Desative as solicitações automáticas de geofence. No Android, defina com_braze_automatic_geofence_requests_enabled como false no seu braze.xml. No iOS, defina automaticGeofenceRequests como false na sua configuração da 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!