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.

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: Actualiza build.gradle

Añade android-sdk-location al build.gradle a nivel de tu aplicación. 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 precisa 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 de 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 recopilación de ubicaciones de 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 de Braze se habilitan cuando la recopilación de ubicaciones de Braze está habilitada. Si deseas excluirte de nuestra recopilación predeterminada de ubicaciones, pero quieres seguir utilizando geovallas, puedes habilitarlas selectivamente estableciendo el valor de la clave com_braze_geofences_enabled en true en braze.xml, de forma independiente 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 de Braze e inicie el seguimiento de geovallas.

Consulta RuntimePermissionUtils.java en nuestra aplicación de ejemplo 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 código de ejemplo anterior se utiliza de la siguiente manera:

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)

De forma predeterminada, Braze recupera automáticamente la ubicación del dispositivo y solicita geovallas basándose 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 de Braze, debes desactivar las solicitudes automáticas de geovallas de 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 también puede hacerse 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 geovallas de 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)

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 el módulo BrazeLocation

En Xcode, abre la pestaña General. En Frameworks, Libraries, and Embedded Content, añade el módulo BrazeLocation.

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

Paso 2.2: Actualiza tu Info.plist

En tu info.plist, asigna un valor String 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

Cadenas de ubicación de Info.plist en Xcode

Paso 3: Habilita las geovallas en tu código

En el código de tu aplicación, habilita las geovallas estableciendo location.geofencesEnabled en true en el objeto configuration que inicializa la instancia Braze. Para otras opciones de configuración de location, consulta la referencia del SDK de Swift de Braze.

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 tiene autorización Always, 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 tiene autorización When In Use.

Para supervisar estos eventos de geovalla adicionales, abre tu proyecto Xcode y ve a Signing & Capabilities. En Background Modes, marca Location updates.

En Xcode, Background Mode > Location Updates

A continuación, habilita allowBackgroundGeofenceUpdates en el código de tu aplicación. Esto permite a Braze ampliar el estado “When In Use” 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ón When In Use o Always.

Para solicitar la autorización 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 llamando primero a requestWhenInUseAuthorization() y luego a requestAlwaysAuthorization() después de recibir tu autorización inicial When In Use.

1
2

var locationManager = CLLocationManager()
locationManager.requestAlwaysAuthorization()

1
2

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

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: Llama a requestGeofences 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 mi dispositivo?

Para confirmar si se están recibiendo geovallas en tu dispositivo, primero utiliza la herramienta Depurador de SDK 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 dashboard. Para que nuestros servicios de ubicación funcionen correctamente, comprueba que tu aplicación no esté utilizando todos los puntos de geovalla disponibles.

Límite de velocidad

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

¿Cómo funciona si utilizo 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 registrado 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 mi aplicación se ejecuta en segundo plano o se cierra?

Sin autorización Always, 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.

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 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 de registrar 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 (por ejemplo, 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 Location updates 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ón When In Use o Always:

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.

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: Completar la configuración 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. Actualiza build.gradle: Añade android-sdk-location y la ubicación de Google Play Services. Consulta geovallas de Android.
  2. Actualiza el manifiesto: Añade permisos de ubicación y el receptor de arranque de Braze. Consulta geovallas de Android.
  3. Habilita la recopilación de ubicación de Braze: Actualiza tu archivo braze.xml. Consulta geovallas de Android.

Paso 3: Completar la configuración nativa de 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 tu Info.plist con descripciones del uso de la ubicación (paso 2.2) y habilita las geovallas en tu configuración de Braze, incluyendo automaticGeofenceRequests = 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 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 a requestLocationInitialization() 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 la configuración automaticGeofenceRequests en tu configuración nativa de Swift u Objective-C de Braze (consulta el paso 3). Con esta opción habilitada, el SDK solicita y supervisa automáticamente las geovallas cuando la ubicación está disponible; no se requiere ninguna llamada JavaScript equivalente a requestLocationInitialization.

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, configura com_braze_automatic_geofence_requests_enabled en false en tu braze.xml. En iOS, configura automaticGeofenceRequests en false en tu configuración de Braze.
  2. Llama a requestGeofences con la latitud y longitud deseadas:
1
2
3

import Braze from '@braze/react-native-sdk';

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