Skip to content

Geovallas

Aprende a configurar geovallas para el SDK de Braze. Una geovalla es un área geográfica virtual que forma un círculo alrededor de una posición global específica y se representa combinando la latitud, la longitud y un radio.

Requisitos previos

Antes de poder utilizar esta característica, tendrás que integrar el SDK de Android Braze. Además, tendrás que configurar las notificaciones push silenciosas.

Configuración de geovallas

Paso 1: Habilitación en Braze

Puedes habilitar geovallas para tu aplicación en uno de los siguientes lugares:

Para habilitar geovallas desde la página Ubicaciones:

  1. En Braze, ve a Audiencia > Ubicaciones.
  2. Bajo el mapa aparece el número de aplicaciones de tu espacio de trabajo que tienen habilitado el geovallado. Por ejemplo, si el geovallado sólo está habilitado para algunas de tus aplicaciones, puede decir: 2 de 5 Aplicaciones con geovallas habilitadas. Para habilitar aplicaciones adicionales, selecciona el recuento actual bajo el mapa.
  3. Elige una aplicación para la que habilitar geovallas y, a continuación, selecciona Hecho.

Las opciones de geovalla en la página de ubicaciones de Braze.

Para habilitar geovallas desde la página de configuración de la aplicación:

  1. En Braze, ve a Configuración > Configuración de la aplicación .
  2. Selecciona la aplicación para la que quieres habilitar las geovallas.
  3. Marca la casilla Geovallas habilitadas y, a continuación, selecciona Guardar.

La casilla de geovalla situada en las páginas de configuración de Braze.

Paso 2: Actualiza build.gradle

Añade android-sdk-location al nivel de tu aplicación build.gradle. Además, añade el paquete de ubicación de Google Play Services utilizando la guía de configuración de 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}"
}

Paso 3: Actualiza el manifiesto

Añade permisos de arranque, ubicación fina y ubicación en segundo plano a tu 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ñade el receptor de arranque Braze al elemento application de tu 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>

Paso 4: Habilitar la recogida de ubicaciones Braze

Si aún no has habilitado la recopilación de ubicaciones de Braze, actualiza tu archivo braze.xml para incluir com_braze_enable_location_collection y confirma que su valor es true:

1
<bool name="com_braze_enable_location_collection">true</bool>

Las geovallas Braze están habilitadas si está habilitada la recopilación de ubicaciones Braze. Si deseas excluirte de nuestra recopilación predeterminada de ubicaciones, pero quieres seguir utilizando geovallas, puedes habilitarlo selectivamente estableciendo el valor de la clave com_braze_geofences_enabled en true en braze.xml, independientemente del valor de com_braze_enable_location_collection:

1
<bool name="com_braze_geofences_enabled">true</bool>

Paso 5: Obtener permisos de ubicación del usuario final

Para Android M y versiones superiores, debes solicitar permisos de ubicación al usuario final antes de recopilar información de ubicación o registrar geovallas.

Añade la siguiente llamada para notificar a Braze cuando un usuario conceda el permiso de ubicación a tu aplicación:

1
Braze.getInstance(context).requestLocationInitialization();
1
Braze.getInstance(context).requestLocationInitialization()

Esto hará que el SDK solicite geovallas a los servidores Braze e inicie el seguimiento de geovallas.

Consulta RuntimePermissionUtils.java en nuestro ejemplo de aplicación para ver un ejemplo de implementación.

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
  }
}

El uso del código de ejemplo anterior se realiza mediante:

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

Paso 6: Solicitar manualmente actualizaciones de geovallas (opcional)

Por defecto, Braze recupera automáticamente la ubicación del dispositivo y solicita geovallas basadas en esa ubicación recopilada. Sin embargo, puedes proporcionar manualmente una coordenada GPS que se utilizará para recuperar geovallas próximas de Braze. Para solicitar manualmente geovallas Braze, debes desactivar las solicitudes automáticas de geovallas Braze y proporcionar una coordenada GPS para las solicitudes.

Paso 6.1: Desactivar las solicitudes automáticas de geovallas

Las solicitudes automáticas de geovallas de Braze pueden desactivarse en tu archivo braze.xml configurando com_braze_automatic_geofence_requests_enabled como false:

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

Esto puede hacerse adicionalmente en tiempo de ejecución mediante:

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

Paso 6.2: Solicitar manualmente la geovalla Braze con coordenadas GPS

Las geovallas de Braze se solicitan manualmente mediante el método requestGeofences():

1
Braze.getInstance(getApplicationContext()).requestGeofences(latitude, longitude);
1
Braze.getInstance(applicationContext).requestGeofences(33.078947, -116.601356)

Habilitación de push-to-sync

Ten en cuenta que Braze sincroniza las geovallas con los dispositivos mediante notificaciones push en segundo plano. En la mayoría de los casos, esto no implicará cambios en el código, ya que esta característica no requiere una mayor integración por parte de la aplicación.

Sin embargo, nota que si tu aplicación está parada, al recibir un push en segundo plano se lanzará en segundo plano y se llamará a su método Application.onCreate(). Si tienes una implementación personalizada de Application.onCreate(), debes aplazar las llamadas automáticas al servidor y cualquier otra acción que no quieras que sea desencadenada por el push en segundo plano.

Requisitos previos

Antes de poder utilizar esta característica, tendrás que integrar el SDK de Swift Braze.

Configuración de geovallas

Paso 1: Habilitar en Braze

Puedes habilitar geovallas para tu aplicación en uno de los siguientes lugares:

Para habilitar geovallas desde la página Ubicaciones:

  1. En Braze, ve a Audiencia > Ubicaciones.
  2. Bajo el mapa aparece el número de aplicaciones de tu espacio de trabajo que tienen habilitado el geovallado. Por ejemplo, si el geovallado sólo está habilitado para algunas de tus aplicaciones, puede decir: 2 de 5 Aplicaciones con geovallas habilitadas. Para habilitar aplicaciones adicionales, selecciona el recuento actual bajo el mapa.
  3. Elige una aplicación para la que habilitar geovallas y, a continuación, selecciona Hecho.

Las opciones de geovalla en la página de ubicaciones de Braze.

Para habilitar geovallas desde la página de configuración de la aplicación:

  1. En Braze, ve a Configuración > Configuración de la aplicación .
  2. Selecciona la aplicación para la que quieres habilitar las geovallas.
  3. Marca la casilla Geovallas habilitadas y, a continuación, selecciona Guardar.

La casilla de geovalla situada en las páginas de configuración de Braze.

Paso 2: Habilita los servicios de ubicación de tu aplicación.

De forma predeterminada, los servicios de ubicación de Braze no están habilitados. Para habilitarlos en tu aplicación, sigue estos pasos. Para obtener un tutorial paso a paso, consulta Tutorial: Ubicaciones y geovallas de Braze.

Paso 2.1: Añadir elBrazeLocationmódulo

En Xcode, abre la pestaña General. En Marcos, bibliotecas y contenido incrustado, añade elBrazeLocationmódulo.

Añade el módulo BrazeLocation en tu proyecto Xcode.

Paso 2.2: Actualiza tu Info.plist

En tu info.plist, asigna unStringvalor a una de las siguientes claves que describa por qué tu aplicación necesita realizar el seguimiento de la ubicación. Esta cadena se mostrará cuando se solicite a tus usuarios que activen los servicios de ubicación, así que asegúrate de explicar claramente la importancia de habilitar esta característica para tu aplicación.

  • NSLocationAlwaysAndWhenInUseUsageDescription
  • NSLocationWhenInUseUsageDescription

Info.plist cadenas de ubicación en Xcode

Paso 3: Habilita las geovallas en tu código.

En el código de tu aplicación, habilita las geovallas estableciendolocation.geofencesEnabled entrue en elconfigurationobjeto que inicializa laBrazeinstancia . Para otras opcioneslocation de configuración, consulta la referencia de 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;

Paso 3.1: Habilitar informes en segundo plano (opcional)

De forma predeterminada, los eventos de geovalla solo se supervisan si la aplicación está en primer plano o tieneAlways autorización, lo que supervisa todos los estados de la aplicación.

Sin embargo, también puedes optar por supervisar los eventos de geovalla si tu aplicación está en segundo plano o tieneWhen In Use autorización.

Para supervisar estos eventos de geovalla adicionales, abre tu proyecto Xcode y ve a Capacidades& de firma. En Modos en segundo plano, marca Actualizaciones de ubicación.

En Xcode, Modo en segundo plano > Actualizaciones de ubicación

A continuación, habilitaallowBackgroundGeofenceUpdates en el código de tu aplicación. Esto permite a Braze ampliar el estado «En uso» de tu aplicación mediante la supervisión continua de las actualizaciones de ubicación. Esta configuración solo funciona cuando la aplicación está en segundo plano. Cuando la aplicación se vuelve a abrir, todos los procesos en segundo plano existentes se pausan y, en su lugar, se da prioridad a los procesos en primer plano.

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;

Paso 4: Solicitar autorización

Cuando solicites autorización a un usuario, solicita la autorizaciónWhen In UseAlways o .

Para solicitar la autorización de When In Use, utiliza el método requestWhenInUseAuthorization():

1
2
var locationManager = CLLocationManager()
locationManager.requestWhenInUseAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestWhenInUseAuthorization];

De manera predeterminada, requestAlwaysAuthorization() solo concede a tu aplicación la autorización When In Use y volverá a solicitar al usuario la autorización Always cuando haya transcurrido cierto tiempo.

Sin embargo, puedes optar por solicitar inmediatamente al usuario que primero llame arequestWhenInUseAuthorization() y luego arequestAlwaysAuthorization() después de recibir tu autorización When In Useinicial .

1
2
var locationManager = CLLocationManager()
locationManager.requestAlwaysAuthorization()
1
2
CLLocationManager *locationManager = [[CLLocationManager alloc] init];
[locationManager requestAlwaysAuthorization];

Paso 5: Verificar push en segundo plano

Braze sincroniza las geovallas con los dispositivos mediante notificaciones push en segundo plano. Sigue estas instrucciones para configurar notificaciones push silenciosas, de modo que las actualizaciones de geovallas del servidor se gestionen correctamente.

Solicitar geovallas manualmente

Cuando el SDK de Braze solicita geovallas al backend, informa de la ubicación actual del usuario y recibe las geovallas que se consideran más relevantes en función de la ubicación comunicada.

Para controlar la ubicación que el SDK informa con el fin de recibir las geovallas más relevantes, puedes solicitar geovallas manualmente proporcionando las coordenadas deseadas.

Paso 1: Configura automaticGeofenceRequests en false

Puedes desactivar las solicitudes automáticas de geovallas en tu objeto configuration pasado a init(configuration). Configura automaticGeofenceRequests en 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;

Paso 2: LlamarrequestGeofences manualmente

En tu código, solicita geovallas con la latitud y longitud adecuadas.

1
AppDelegate.braze?.requestGeofences(latitude: latitude, longitude: longitude)
1
2
[AppDelegate.braze requestGeofencesWithLatitude:latitude
                                      longitude:longitude];

Preguntas más frecuentes (FAQ)

¿Por qué no recibo geovallas en tu dispositivo?

Para confirmar si se están recibiendo geovallas en tu dispositivo, primero utiliza la herramienta SDK Debugger para comprobar los registros del SDK. A continuación, podrás ver si las geovallas se reciben correctamente desde el servidor y si hay algún error notable.

A continuación se indican otras posibles razones por las que es posible que no recibas geovallas en tu dispositivo:

Limitaciones del sistema operativo iOS

El sistema operativo iOS solo permite almacenar hasta 20 geovallas para una aplicación determinada. Con las geovallas habilitadas, Braze utilizará algunas de estas 20 plazas disponibles.

Para evitar interrupciones accidentales o no deseadas en otras funciones relacionadas con las geovallas de tu aplicación, debes habilitar las geovallas de ubicación para aplicaciones individuales en el panel. Para que nuestros servicios de ubicación funcionen correctamente, comprueba que tu aplicación no esté utilizando todos los puntos de geovalla disponibles.

Limitación de velocidad

Braze tiene un límite de una actualización de geovalla por sesión para evitar solicitudes innecesarias.

¿Cómo funciona si utilizas tanto las características de geovalla de Braze como las que no son de Braze?

Como se ha mencionado anteriormente, iOS permite que una sola aplicación almacene un máximo de 20 geovallas. Este almacenamiento es compartido por las geovallas de Braze y las que no son de Braze, y es administrado por CLLocationManager.

Por ejemplo, si tu aplicación contiene 20 geovallas que no son de Braze, no habría almacenamiento para realizar el seguimiento de ninguna geovalla de Braze (o viceversa). Para recibir nuevas geovallas, tendrás que utilizar las API de ubicación de Apple para dejar de supervisar algunas de las geovallas existentes en el dispositivo.

¿Se puede utilizar la característica de geovalla cuando un dispositivo está desconectado?

Un dispositivo solo necesita estar conectado a Internet cuando se produce una actualización. Una vez que hayas recibido correctamente las geovallas del servidor, es posible registrar una entrada o salida de la geovalla incluso si el dispositivo está desconectado. Esto se debe a que la ubicación de un dispositivo funciona de forma independiente de su conexión a Internet.

Por ejemplo, supongamos que un dispositivo ha recibido y realizado el registro de las geovallas al inicio de la sesión y se desconecta. Si luego entra en una de esas geovallas registradas, puede desencadenar una campaña de Braze.

¿Por qué no se supervisan las geovallas cuando tu aplicación se ejecuta en segundo plano o se cierra?

SinAlwaysautorización, Apple restringe el funcionamiento de los servicios de ubicación cuando una aplicación no está en uso. Esto lo impone el sistema operativo y queda fuera del control del SDK de Braze. Aunque Braze ofrece configuraciones independientes para ejecutar servicios mientras la aplicación está en segundo plano, no hay forma de eludir estas restricciones para las aplicaciones que se cierran sin recibir la autorización explícita del usuario.

Requisitos previos

Antes de poder utilizar esta característica, deberás realizar la integración del SDK .NET MAUI Braze. Además, tendrás que configurar notificaciones push silenciosas.

Requisitos previos

Estas son las versiones mínimas del SDK necesarias para empezar a utilizar geovallas:

Configuración de geovallas

Paso 1: Habilitar en Braze

Puedes habilitar geovallas para tu aplicación en uno de los siguientes lugares:

Para habilitar geovallas desde la página Ubicaciones:

  1. En Braze, ve a Audiencia > Ubicaciones.
  2. Bajo el mapa aparece el número de aplicaciones de tu espacio de trabajo que tienen habilitado el geovallado. Por ejemplo, si el geovallado sólo está habilitado para algunas de tus aplicaciones, puede decir: 2 de 5 Aplicaciones con geovallas habilitadas. Para habilitar aplicaciones adicionales, selecciona el recuento actual bajo el mapa.
  3. Elige una aplicación para la que habilitar geovallas y, a continuación, selecciona Hecho.

Las opciones de geovalla en la página de ubicaciones de Braze.

Para habilitar geovallas desde la página de configuración de la aplicación:

  1. En Braze, ve a Configuración > Configuración de la aplicación .
  2. Selecciona la aplicación para la que quieres habilitar las geovallas.
  3. Marca la casilla Geovallas habilitadas y, a continuación, selecciona Guardar.

La casilla de geovalla situada en las páginas de configuración de Braze.


A continuación, sigue las instrucciones específicas de la plataforma que se indican a continuación para Android o iOS:

Paso 2: Añadir dependencias

Añade la siguiente referencia al paquete NuGet a tu proyecto:

  • BrazePlatform.BrazeAndroidLocationBinding

Paso 3: Actualiza tu AndroidManifest.xml

Añade los siguientes permisos a tu 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" />

Paso 4: Configurar la recopilación de ubicación de Braze

Asegúrate de que la recopilación de ubicación esté habilitada en tu configuración de Braze. Si deseas habilitar las geovallas sin la recopilación automática de la ubicación, configura lo siguiente en tu Braze.xml:

1
2
<bool name="com_braze_enable_location_collection">true</bool>
<bool name="com_braze_geofences_enabled">true</bool>

Paso 5: Solicitar permisos de ubicación en tiempo de ejecución

Debes solicitar permisos de ubicación al usuario antes del registro de geovallas. En tu código C#, utiliza el siguiente patrón:

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...
}

Una vez concedidos los permisos, inicializa la recopilación de ubicación de Braze:

1
Braze.GetInstance(this).RequestLocationInitialization();

Paso 6: Solicitar manualmente actualizaciones de geovallas (opcional)

Para solicitar manualmente geovallas para una ubicación específica:

1
Braze.GetInstance(this).RequestGeofences(latitude, longitude);

Paso 2: Añadir dependencias

Añade la siguiente referencia al paquete NuGet a tu proyecto:

  • Braze.iOS.BrazeLocation

Paso 3: Configura el uso de la ubicación en Info.plist

Añade una cadena con la descripción del uso de los servicios de ubicación en tu 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>

Paso 4: Habilita las geovallas en tu configuración de Braze.

En el código de inicio de tu aplicación (e.g., App.xaml.cs), configura Braze con las geovallas habilitadas:

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

Paso 5: Habilita las actualizaciones de ubicación en segundo plano (opcional)

Para supervisar las geovallas en segundo plano, habilita el modo de fondo de actualizaciones de ubicación añadiendo la siguiente configuración a tu Info.plist:

1
2
3
4
<key>UIBackgroundModes</key>
<array>
  <string>location</string>
</array>

A continuación, en tu configuración de Braze, establece:

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

Paso 6: Solicitar autorización de ubicación

Solicita al usuario la autorizaciónAlways oWhen In Use :

1
2
3
4
5
6
using CoreLocation;

var locationManager = new CLLocationManager();
locationManager.RequestWhenInUseAuthorization();
// or
locationManager.RequestAlwaysAuthorization();

Requisitos previos

Antes de poder utilizar esta característica, tendrás que integrar el SDK Braze de React Native. En Android, tendrás que configurar notificaciones push silenciosas para la sincronización de geovallas.

Configuración de geovallas

Paso 1: Habilitar en Braze

Puedes habilitar geovallas para tu aplicación en uno de los siguientes lugares:

Para habilitar geovallas desde la página Ubicaciones:

  1. En Braze, ve a Audiencia > Ubicaciones.
  2. Bajo el mapa aparece el número de aplicaciones de tu espacio de trabajo que tienen habilitado el geovallado. Por ejemplo, si el geovallado sólo está habilitado para algunas de tus aplicaciones, puede decir: 2 de 5 Aplicaciones con geovallas habilitadas. Para habilitar aplicaciones adicionales, selecciona el recuento actual bajo el mapa.
  3. Elige una aplicación para la que habilitar geovallas y, a continuación, selecciona Hecho.

Las opciones de geovalla en la página de ubicaciones de Braze.

Para habilitar geovallas desde la página de configuración de la aplicación:

  1. En Braze, ve a Configuración > Configuración de la aplicación .
  2. Selecciona la aplicación para la que quieres habilitar las geovallas.
  3. Marca la casilla Geovallas habilitadas y, a continuación, selecciona Guardar.

La casilla de geovalla situada en las páginas de configuración de Braze.

Paso 2: Configuración completa nativa de Android

Dado que el SDK de React Native utiliza el SDK nativo de Braze para Android, completa la configuración de geovallas nativas de Android para tu proyecto. El equivalente en iOS de estos pasos se describe en la guía nativa de geovallas del SDK de SWIFT (pasos 2.2 a 3.1); el paso 2.1 (Añadir el módulo BrazeLocation) no es necesario para React Native, ya que BrazeLocation ya está incluido implícitamente en el SDK de Braze React Native.

  1. Actualizaciónbuild.gradle: Añadeandroid-sdk-location y la ubicación de Google Play Services. Ver geovallas de Android.
  2. Actualiza el manifiesto: Añade permisos de ubicación y el receptor de arranque Braze. Ver geovallas de Android.
  3. Habilitar la recopilación de ubicación de Braze: Actualiza tubraze.xmlarchivo. Ver geovallas de Android.

Paso 3: Configuración nativa completa para iOS

Dado que el SDK de React Native utiliza el SDK nativo de Braze para iOS, completa la configuración de geovallas nativas de iOS para tu proyecto siguiendo las instrucciones del SDK nativo de SWIFT a partir del paso 2.2: actualiza tuInfo.plist con descripciones del uso de la ubicación (paso 2.2) y habilita las geovallas en tu configuración de Braze, incluyendoautomaticGeofenceRequests = true (paso 3); opcionalmente, habilita los informes en segundo plano (paso 3.1). El paso 2.1 (Añadir el módulo BrazeLocation) no es necesario, ya que BrazeLocation ya está incluido implícitamente en el SDK de Braze React Native. Consulta las geovallas de iOS, pasos 2.2 a 3.1.

Paso 4: Solicitar geovallas desde JavaScript

En Android: Después de que el usuario conceda los permisos de ubicación, llama arequestLocationInitialization() para inicializar las características de ubicación de Braze y solicitar geovallas a los servidores de Braze. Este método no es compatible con iOS y no es necesario para iOS.

En iOS: El equivalente es habilitar laautomaticGeofenceRequestsconfiguración en tu configuración nativa de SWIFT u Objective-C Braze (consulta el paso 3). Con esta habilitación, el SDK solicita y supervisa automáticamente las geovallas cuando la ubicación está disponible; no se requiere ninguna requestLocationInitializationllamada JavaScript equivalente a .

1
2
3
4
import Braze from '@braze/react-native-sdk';

// Android only: call this after the user grants location permission
Braze.requestLocationInitialization();

Paso 5: Solicitar geovallas manualmente (opcional)

Tanto en iOS como en Android, puedes solicitar manualmente una actualización de la geovalla para unas coordenadas GPS específicas utilizando requestGeofences. De forma predeterminada, Braze recupera automáticamente la ubicación del dispositivo y solicita geovallas. Para proporcionar manualmente una coordenada:

  1. Desactiva las solicitudes automáticas de geovallas. En Android, configuracom_braze_automatic_geofence_requests_enabled enfalse en tu braze.xml. En iOS, configuraautomaticGeofenceRequests enfalse en tu configuración de Braze.
  2. LlamarequestGeofencescon la latitud y longitud deseadas:
1
2
3
import Braze from '@braze/react-native-sdk';

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