Notificaciones push

Requisitos previos

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

Características integradas

Las siguientes características están integradas en el SDK de Braze para Android. Para utilizar cualquier otra característica de notificaciones push, necesitarás configurar las notificaciones push en tu aplicación.

Acerca del ciclo de vida de las notificaciones push

El siguiente diagrama de flujo muestra cómo Braze gestiona el ciclo de vida de las notificaciones push, como las solicitudes de permiso, la generación de tokens y la entrega de mensajes.

• conceder permisos
• generar tokens push
• mostrar notificaciones

---
config:
  theme: neutral
---
flowchart TD

%% Permission flow
subgraph Permission[Push Permissions]
    B{Android version of the device?}
    B -->|Android 13+| C["requestPushPermissionPrompt() called"]
    B -->|Android 12 and earlier| D[No permissions required]

    %% Connect Android 12 path to Braze state
    D --> H3[Braze: user subscription state]
    H3 --> J3[Defaults to 'subscribed' when user profile created]

    C --> E{Did the user grant push permission?}
    E -->|Yes| F[POST_NOTIFICATIONS permission granted]
    E -->|No| G[POST_NOTIFICATIONS permission denied]

    %% Braze subscription state updates
    F --> H1[Braze: user subscription state]
    G --> H2[Braze: user subscription state]

    H1 --> I1{Automatically opt in after permission granted?}
    I1 -->|true| J1[Set to 'opted-in']
    I1 -->|false| J2[Remains 'subscribed']

    H2 --> K1[Remains 'subscribed'<br/>or 'unsubscribed']

    %% Subscription state legend
    subgraph BrazeStates[Braze subscription states]
        L1['Subscribed' - default state<br/>when user profile created]
        L2['Opted-in' - user explicitly<br/>wants push notifications]
        L3['Unsubscribed' - user explicitly<br/>opted out of push]
    end

    %% Note about user-level states
    note1[Note: These states are user-level<br/>and apply across all devices for the user]

    %% Connect states to legend
    J1 -.-> L2
    J2 -.-> L1
    J3 -.-> L1
    K1 -.-> L3
    note1 -.-> BrazeStates
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

---
config:
  theme: neutral
---
flowchart TD

%% Token generation flow
subgraph Token[Token Generation]
    H["Braze SDK initialized"] --> Q{Is FCM auto-registration enabled?}
    Q -->|Yes| L{Is required configuration present?}
    Q -->|No| M[No FCM token generated]
    L -->|Yes| I[Generate FCM token]
    L -->|No| M
    I --> K[Register token with Braze]

    %% Configuration requirements
    subgraph Config[Required configuration]
        N['google-services.json' file is present]
        O['com.google.firebase:firebase-messaging' in gradle]
        P['com.google.gms.google-services' plugin in gradle]
    end

    %% Connect config to check
    N -.-> L
    O -.-> L
    P -.-> L
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

---
config:
  theme: neutral
  fontSize: 10
---
flowchart TD

subgraph Display[Push Display]
    %% Push delivery flow
    W[Push sent to FCM servers] --> X{Did FCM receive push?}
    X -->|App is terminated| Y[FCM cannot deliver push to the app]
    X -->|Delivery conditions met| X1[App receives push from FCM]
    X1 --> X2[Braze SDK receives push]
    X2 --> R[Push type?]

    %% Push Display Flow
    R -->|Standard push| S{Is push permission required?}
    R -->|Silent push| T[Braze SDK processes silent push]
    S -->|Yes| S1{Did the user grant push permission?}
    S -->|No| V[Notification is shown to the user]
    S1 -->|Yes| V
    S1 -->|No| U[Notification is not shown to the user]
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

Configurar las notificaciones push

Consejo

Para ver una aplicación de ejemplo que usa FCM con el SDK de Braze para Android, consulta Braze: Firebase Push Sample App.

Límites de velocidad

La API de Firebase Cloud Messaging (FCM) tiene un límite de velocidad predeterminado de 600 000 solicitudes por minuto. Si alcanzas este límite, Braze lo intentará de nuevo automáticamente en unos minutos. Para solicitar un aumento, ponte en contacto con el soporte de Firebase.

Paso 1: Añadir Firebase a tu proyecto

Primero, añade Firebase a tu proyecto Android. Para obtener instrucciones paso a paso, consulta la guía de configuración de Firebase de Google.

Paso 2: Añadir Cloud Messaging a tus dependencias

A continuación, añade la biblioteca Cloud Messaging a las dependencias de tu proyecto. En tu proyecto Android, abre build.gradle y luego añade la siguiente línea a tu bloque dependencies.

1

implementation "google.firebase:firebase-messaging:+"

Tus dependencias deberían tener un aspecto similar al siguiente:

1
2
3
4

dependencies {
  implementation project(':android-sdk-ui')
  implementation "com.google.firebase:firebase-messaging:+"
}

Paso 3: Habilitar la API de Firebase Cloud Messaging

En Google Cloud, selecciona el proyecto que usa tu aplicación Android y luego habilita la API de Firebase Cloud Messaging.

Paso 4: Crear una cuenta de servicio

A continuación, crea una nueva cuenta de servicio para que Braze pueda realizar llamadas autorizadas a la API al registrar tokens de FCM. En Google Cloud, ve a Service Accounts y luego selecciona tu proyecto. En la página Service Accounts, selecciona Create Service Account.

Introduce un nombre, un ID y una descripción para la cuenta de servicio, y luego selecciona Create and continue.

En el campo Role, busca y selecciona Firebase Cloud Messaging API Admin en la lista de roles. Para un acceso más restrictivo, crea un rol personalizado con el permiso cloudmessaging.messages.create y selecciónalo de la lista en su lugar. Cuando hayas terminado, selecciona Done.

Advertencia

Asegúrate de seleccionar Firebase Cloud Messaging API Admin, no Firebase Cloud Messaging Admin.

Paso 5: Generar credenciales JSON

A continuación, genera credenciales JSON para tu cuenta de servicio de FCM. En Google Cloud IAM & Admin, ve a Service Accounts y luego selecciona tu proyecto. Localiza la cuenta de servicio de FCM que creaste anteriormente y selecciona  Actions > Manage Keys.

Selecciona Add Key > Create new key.

Elige JSON y luego selecciona Create. Si creaste tu cuenta de servicio usando un ID de proyecto de Google Cloud diferente al ID de tu proyecto de FCM, tendrás que actualizar manualmente el valor asignado a project_id en tu archivo JSON.

Asegúrate de recordar dónde descargaste la clave—la necesitarás en el siguiente paso.

Advertencia

Las claves privadas podrían suponer un riesgo de seguridad si se ven comprometidas. Almacena tus credenciales JSON en un lugar seguro por ahora—eliminarás tu clave después de subirla a Braze.

Paso 6: Subir tus credenciales JSON a Braze

A continuación, sube tus credenciales JSON a tu panel de Braze. En Braze, selecciona  Configuración > Configuración de la aplicación.

En la sección Push Notification Settings de tu aplicación Android, elige Firebase, luego selecciona Upload JSON File y sube las credenciales que generaste anteriormente. Cuando hayas terminado, selecciona Save.

Advertencia

Las claves privadas podrían suponer un riesgo de seguridad si se ven comprometidas. Ahora que tu clave se ha subido a Braze, elimina el archivo que generaste anteriormente.

Paso 7: Configurar el registro automático de tokens

Cuando uno de tus usuarios acepta las notificaciones push, tu aplicación necesita generar un token de FCM en su dispositivo antes de que puedas enviarle notificaciones push. Con el SDK de Braze, puedes habilitar el registro automático de tokens de FCM para el dispositivo de cada usuario en los archivos de configuración de Braze de tu proyecto.

Primero, ve a Firebase Console, abre tu proyecto y selecciona  Settings > Project settings.

Selecciona Cloud Messaging y luego, en Firebase Cloud Messaging API (V1), copia el número del campo Sender ID.

A continuación, abre tu proyecto de Android Studio y usa tu Firebase Sender ID para habilitar el registro automático de tokens de FCM dentro de tu braze.xml o BrazeConfig.

• braze.xml
• brazeconfig

1
2

<bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">FIREBASE_SENDER_ID</string>

1
2
3
4
5
6

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string translatable="false" name="com_braze_api_key">12345ABC-6789-DEFG-0123-HIJK456789LM</string>
  <bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">603679405392</string>
</resources>

1
2

.setIsFirebaseCloudMessagingRegistrationEnabled(true)
.setFirebaseCloudMessagingSenderIdKey("FIREBASE_SENDER_ID")

1
2

.setIsFirebaseCloudMessagingRegistrationEnabled(true)
.setFirebaseCloudMessagingSenderIdKey("FIREBASE_SENDER_ID")

1
2
3
4
5
6
7
8
9
10

BrazeConfig brazeConfig = new BrazeConfig.Builder()
  .setApiKey("12345ABC-6789-DEFG-0123-HIJK456789LM")
  .setCustomEndpoint("sdk.iad-01.braze.com")
  .setSessionTimeout(60)
  .setHandlePushDeepLinksAutomatically(true)
  .setGreatNetworkDataFlushInterval(10)
  .setIsFirebaseCloudMessagingRegistrationEnabled(true)
  .setFirebaseCloudMessagingSenderIdKey("603679405392")
  .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5
6
7
8
9
10

val brazeConfig = BrazeConfig.Builder()
  .setApiKey("12345ABC-6789-DEFG-0123-HIJK456789LM")
  .setCustomEndpoint("sdk.iad-01.braze.com")
  .setSessionTimeout(60)
  .setHandlePushDeepLinksAutomatically(true)
  .setGreatNetworkDataFlushInterval(10)
  .setIsFirebaseCloudMessagingRegistrationEnabled(true)
  .setFirebaseCloudMessagingSenderIdKey("603679405392")
  .build()
Braze.configure(this, brazeConfig)

Consejo

Si prefieres registrar los tokens de FCM manualmente, establece la propiedad registeredPushToken en la instancia de Braze dentro del método onCreate() de tu aplicación.

1
2

// Kotlin
Braze.getInstance(context).registeredPushToken = "FCM_TOKEN"

1
2

// Java
Braze.getInstance(context).setRegisteredPushToken("FCM_TOKEN");

Usar múltiples proyectos de Firebase

Si tu aplicación usa múltiples proyectos de Firebase, sigue estos pasos:

1. Mantén el push de Braze en el proyecto de Firebase predeterminado inicializado desde el archivo google-services.json de tu aplicación.
2. Si usas un servicio de mensajería de Firebase personalizado, completa Registrar ID de instalación en servicios de mensajería de Firebase personalizados.
3. Si tu aplicación obtiene un token de push de otra forma, establece manualmente registeredPushToken como se muestra en el consejo anterior.

Importante

Firebase Cloud Messaging no tiene una API compatible para obtener un token de un FirebaseApp que inicialices manualmente. Las devoluciones de llamada de FirebaseMessagingService como onNewToken y onRegistered solo se activan para el proyecto predeterminado. Para más información, consulta Configurar múltiples proyectos en la documentación de Firebase.

Para obtener detalles sobre versiones, consulta el Registro de cambios del SDK.

Paso 8: Eliminar las solicitudes automáticas en tu clase de aplicación

Para evitar que Braze desencadene solicitudes de red innecesarias cada vez que envíes notificaciones push silenciosas, elimina cualquier solicitud de red automática configurada en el método onCreate() de tu clase Application. Para más información, consulta Referencia para desarrolladores Android: Application.

Mostrar notificaciones

Paso 1: Registrar el servicio de mensajería Firebase de Braze

Puedes crear un servicio de mensajería Firebase nuevo, existente o que no sea de Braze. Elige el que mejor se adapte a tus necesidades específicas.

• new
• existing
• non-braze

Braze incluye un servicio para gestionar la recepción de push y las intenciones de apertura. Nuestra clase BrazeFirebaseMessagingService deberá registrarse en tu AndroidManifest.xml:

1
2
3
4
5
6

<service android:name="com.braze.push.BrazeFirebaseMessagingService"
  android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT" />
  </intent-filter>
</service>

Nuestro código de notificación también utiliza BrazeFirebaseMessagingService para gestionar el seguimiento de apertura y acción de clic. Este servicio debe registrarse en el AndroidManifest.xml para funcionar correctamente. Además, recuerda que Braze añade un prefijo con una clave única a las notificaciones de nuestro sistema, de modo que solo se renderizan las notificaciones enviadas desde nuestros sistemas. Puedes registrar servicios adicionales por separado para renderizar notificaciones enviadas desde otros servicios de FCM. Consulta AndroidManifest.xml en la aplicación de ejemplo de push con Firebase.

Importante

Antes del SDK de Braze 3.1.1, se utilizaba AppboyFcmReceiver para gestionar el push de FCM. La clase AppboyFcmReceiver debe eliminarse de tu manifiesto y sustituirse por la integración anterior.

Si ya tienes un servicio de mensajería Firebase registrado, puedes pasar objetos RemoteMessage a Braze a través de BrazeFirebaseMessagingService.handleBrazeRemoteMessage(). Este método solo mostrará una notificación si el objeto RemoteMessage se originó en Braze y lo ignorará de forma segura en caso contrario.

Registrar los ID de instalación en servicios de mensajería Firebase personalizados

Si utilizas firebase-messaging v25.1.0 o posterior, el registro de Firebase utiliza el ID de instalación de Firebase. En tu servicio de mensajería Firebase personalizado, sobrescribe onRegistered y configura registeredPushToken.

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class MyFirebaseMessagingService extends FirebaseMessagingService {
  @Override
  public void onRegistered(String installationId) {
    super.onRegistered(installationId);
    Braze.getInstance(this).setRegisteredPushToken(installationId);
  }

  @Override
  public void onMessageReceived(RemoteMessage remoteMessage) {
    super.onMessageReceived(remoteMessage);
    if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
      // This Remote Message originated from Braze and a push notification was displayed.
      // No further action is needed.
    } else {
      // This Remote Message did not originate from Braze.
      // No action was taken and you can safely pass this Remote Message to other handlers.
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class MyFirebaseMessagingService : FirebaseMessagingService() {
  override fun onRegistered(installationId: String) {
    super.onRegistered(installationId)
    Braze.getInstance(this).registeredPushToken = installationId
  }

  override fun onMessageReceived(remoteMessage: RemoteMessage?) {
    super.onMessageReceived(remoteMessage)
    if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
      // This Remote Message originated from Braze and a push notification was displayed.
      // No further action is needed.
    } else {
      // This Remote Message did not originate from Braze.
      // No action was taken and you can safely pass this Remote Message to other handlers.
    }
  }
}

Si tienes otro servicio de mensajería Firebase que también quieras utilizar, puedes especificar un servicio de mensajería Firebase alternativo al que llamar si tu aplicación recibe un push que no sea de Braze.

En tu braze.xml, especifica:

1
2

<bool name="com_braze_fallback_firebase_cloud_messaging_service_enabled">true</bool>
<string name="com_braze_fallback_firebase_cloud_messaging_service_classpath">com.company.OurFirebaseMessagingService</string>

o configúralo mediante configuración en tiempo de ejecución:

• java
• kotlin

1
2
3
4
5

BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setFallbackFirebaseMessagingServiceEnabled(true)
        .setFallbackFirebaseMessagingServiceClasspath("com.company.OurFirebaseMessagingService")
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5

val brazeConfig = BrazeConfig.Builder()
        .setFallbackFirebaseMessagingServiceEnabled(true)
        .setFallbackFirebaseMessagingServiceClasspath("com.company.OurFirebaseMessagingService")
        .build()
Braze.configure(this, brazeConfig)

Paso 2: Adaptar los iconos pequeños a las directrices de diseño

Para información general sobre los iconos de notificación de Android, consulta la Descripción general de las notificaciones.

A partir de Android N, debes actualizar o eliminar los activos de iconos pequeños de notificación que incluyan color. El sistema Android (no el SDK de Braze) ignora todos los canales no alfa y de transparencia en los iconos de acción y el icono pequeño de notificación. En otras palabras, Android convertirá todas las partes de tu icono pequeño de notificación a monocromo, excepto las regiones transparentes.

Para crear un activo de icono pequeño de notificación que se muestre correctamente:

• Elimina todos los colores de la imagen excepto el blanco.
• Todas las demás regiones no blancas del activo deben ser transparentes.

Nota

Un síntoma común de un activo incorrecto es que el icono pequeño de notificación se renderice como un cuadrado monocromo sólido. Esto se debe a que el sistema Android no puede encontrar ninguna región transparente en el activo del icono pequeño de notificación.

Los siguientes iconos grande y pequeño son ejemplos de iconos diseñados correctamente:

Paso 3: Configurar los iconos de notificación

Especificar iconos en braze.xml

Braze te permite configurar tus iconos de notificación especificando recursos drawable en tu braze.xml:

1
2

<drawable name="com_braze_push_small_notification_icon">REPLACE_WITH_YOUR_ICON</drawable>
<drawable name="com_braze_push_large_notification_icon">REPLACE_WITH_YOUR_ICON</drawable>

Es obligatorio establecer un icono pequeño de notificación. Si no lo configuras, Braze utilizará por defecto el icono de la aplicación como icono pequeño de notificación, lo que puede no verse de forma óptima.

Establecer un icono grande de notificación es opcional pero recomendable.

Especificar el color de acento del icono

El color de acento del icono de notificación puede sobrescribirse en tu braze.xml. Si no se especifica el color, el predeterminado es el mismo gris que Lollipop utiliza para las notificaciones del sistema.

1

<integer name="com_braze_default_notification_accent_color">0xFFf33e3e</integer>

También puedes utilizar opcionalmente una referencia de color:

1

<color name="com_braze_default_notification_accent_color">@color/my_color_here</color>

Paso 4: Añadir vínculos profundos

Habilitar la apertura automática de vínculos profundos

Para que Braze abra automáticamente tu aplicación y cualquier vínculo profundo cuando se pulse una notificación push, configura com_braze_handle_push_deep_links_automatically como true en tu braze.xml:

1

<bool name="com_braze_handle_push_deep_links_automatically">true</bool>

Este indicador también se puede configurar mediante configuración en tiempo de ejecución:

• java
• kotlin

1
2
3
4

BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4

val brazeConfig = BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build()
Braze.configure(this, brazeConfig)

Si deseas gestionar los vínculos profundos de forma personalizada, deberás crear una devolución de llamada push que escuche las intenciones de push recibido y abierto desde Braze. Para obtener más información, consulta Usar una devolución de llamada para eventos push.

Gestionar notificaciones en primer plano

De forma predeterminada, cuando una notificación push llega mientras tu aplicación está en primer plano en Android, el sistema la muestra automáticamente. Para que Braze procese la carga útil de la notificación push (para el seguimiento de análisis, la gestión de vínculos profundos y el procesamiento personalizado), enruta los datos push entrantes a Braze dentro de tu método FirebaseMessagingService.onMessageReceived.

Cómo funciona

Cuando llamas a BrazeFirebaseMessagingService.handleBrazeRemoteMessage, Braze determina si la carga útil es una notificación push de Braze y, de ser así, crea y muestra la notificación con el método NotificationManagerCompat. A diferencia de iOS, Android muestra las notificaciones independientemente de si la aplicación está en primer plano o en segundo plano.

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package com.example.push;

import com.braze.push.BrazeFirebaseMessagingService;
import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class MyFirebaseMessagingService extends FirebaseMessagingService {
    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        super.onMessageReceived(remoteMessage);

        // Let Braze process the payload and display the notification
        if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
            // Braze successfully handled the push notification
        } else {
            // Handle non-Braze messages
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.example.push

import com.braze.push.BrazeFirebaseMessagingService
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage

class MyFirebaseMessagingService : FirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)

        // Let Braze process the payload and display the notification
        if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
            // Braze successfully handled the push notification
        } else {
            // Handle non-Braze messages
        }
    }
}

Para más información, consulta el ejemplo de integración de Firebase en el repositorio del SDK de Braze para Android.

Personalizar el comportamiento en primer plano

Si deseas un comportamiento personalizado en primer plano, como suprimir la notificación del sistema o mostrar una interfaz de usuario dentro de la aplicación, puedes:

• Usar subscribeToPushNotificationEvents para reaccionar a eventos push y gestionar vínculos profundos con el método BrazeNotificationUtils.routeUserWithNotificationOpenedIntent. Para más información, consulta el ejemplo de push con Firebase.
• Crear y publicar tu propia notificación usando un IBrazeNotificationFactory personalizado, o suprimir la notificación al no llamar a notificationManager.notify en tu flujo de gestión.

Para más información sobre la personalización de notificaciones, consulta Fábrica de notificaciones personalizada.

Crear vínculos profundos personalizados

Sigue las instrucciones que se encuentran en la documentación para desarrolladores de Android sobre vinculación en profundidad si aún no has añadido vínculos profundos a tu aplicación. Para aprender más sobre qué son los vínculos profundos, consulta nuestro artículo de preguntas frecuentes.

Añadir vínculos profundos

El panel de Braze permite configurar vínculos profundos o URLs web en Campaigns de notificaciones push y Canvas que se abrirán cuando se haga clic en la notificación.

Personalizar el comportamiento de la pila de retroceso

El SDK de Android, de forma predeterminada, colocará la actividad principal del lanzador de tu aplicación anfitriona en la pila de retroceso al seguir vínculos profundos push. Braze te permite configurar una actividad personalizada para abrir en la pila de retroceso en lugar de tu actividad principal del lanzador, o deshabilitar la pila de retroceso por completo.

Por ejemplo, para configurar una actividad llamada YourMainActivity como la actividad de la pila de retroceso usando la configuración en tiempo de ejecución:

• java
• kotlin

1
2
3
4
5

BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setPushDeepLinkBackStackActivityEnabled(true)
        .setPushDeepLinkBackStackActivityClass(YourMainActivity.class)
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5

val brazeConfig = BrazeConfig.Builder()
        .setPushDeepLinkBackStackActivityEnabled(true)
        .setPushDeepLinkBackStackActivityClass(YourMainActivity.class)
        .build()
Braze.configure(this, brazeConfig)

Consulta la configuración equivalente para tu braze.xml. Ten en cuenta que el nombre de la clase debe ser el mismo que devuelve Class.forName().

1
2

<bool name="com_braze_push_deep_link_back_stack_activity_enabled">true</bool>
<string name="com_braze_push_deep_link_back_stack_activity_class_name">your.package.name.YourMainActivity</string>

Paso 5: Definir canales de notificación

El SDK de Braze para Android es compatible con los canales de notificación de Android. Si una notificación de Braze no contiene el ID de un canal de notificación o si la notificación de Braze contiene un ID de canal no válido, Braze mostrará la notificación con el canal de notificación predeterminado definido en el SDK. Los usuarios de la empresa utilizan los canales de notificación de Android dentro de la plataforma para agrupar notificaciones.

Para configurar el nombre visible para el usuario del canal de notificación predeterminado de Braze, usa BrazeConfig.setDefaultNotificationChannelName().

Para configurar la descripción visible para el usuario del canal de notificación predeterminado de Braze, usa BrazeConfig.setDefaultNotificationChannelDescription().

Actualiza cualquier Campaign de API con el parámetro del objeto push de Android para incluir el campo notification_channel. Si este campo no se especifica, Braze enviará la carga útil de la notificación con el ID del canal alternativo del panel.

Aparte del canal de notificación predeterminado, Braze no creará ningún canal. Todos los demás canales deben ser definidos programáticamente por la aplicación anfitriona y luego ingresados en el panel de Braze.

El nombre y la descripción del canal predeterminado también pueden configurarse en braze.xml.

1
2

<string name="com_braze_default_notification_channel_name">Your channel name</string>
<string name="com_braze_default_notification_channel_description">Your channel description</string>

Paso 6: Probar la visualización y los análisis de las notificaciones

Probar la visualización

En este punto, deberías poder ver las notificaciones enviadas desde Braze. Para probarlo, ve a la página Campaigns en tu panel de Braze y crea una Campaign de notificaciones push. Elige Android Push y diseña tu mensaje. Luego haz clic en el ícono del ojo en el creador para acceder al remitente de prueba. Introduce el ID de usuario o la dirección de correo electrónico de tu usuario actual y haz clic en Send Test. Deberías ver la notificación push aparecer en tu dispositivo.

Para problemas relacionados con la visualización de push, consulta nuestra guía de solución de problemas.

Probar los análisis

En este punto, también deberías tener el registro de análisis para las aperturas de notificaciones push. Hacer clic en la notificación cuando llegue debería hacer que los Direct Opens en la página de resultados de tu Campaign aumenten en 1. Consulta nuestro artículo sobre informes push para un desglose de los análisis push.

Para problemas relacionados con los análisis push, consulta nuestra guía de solución de problemas.

Probar desde la línea de comandos

Si deseas probar In-App Messages y notificaciones push a través de la interfaz de línea de comandos, puedes enviar una sola notificación a través del terminal mediante cURL y la API de mensajería. Necesitarás reemplazar los siguientes campos con los valores correctos para tu caso de prueba:

• YOUR_API_KEY (Ve a Configuración > Claves de API.)
• YOUR_EXTERNAL_USER_ID (Busca un perfil en la página Buscar usuarios.)
• YOUR_KEY1 (opcional)
• YOUR_VALUE1 (opcional)

1
2
3
4
5
6
7
8
9
10
11
12

curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer {YOUR_API_KEY}" -d '{
  "external_user_ids":["YOUR_EXTERNAL_USER_ID"],
  "messages": {
    "android_push": {
      "title":"Test push title",
      "alert":"Test push",
      "extra": {
        "YOUR_KEY1":"YOUR_VALUE1"
      }
    }
  }
}' https://rest.iad-01.braze.com/messages/send

Este ejemplo usa la instancia US-01. Si no estás en esta instancia, reemplaza el endpoint US-01 con tu endpoint.

Notificaciones push de conversación

La iniciativa de personas y conversaciones es una iniciativa plurianual de Android que tiene como objetivo destacar a las personas y las conversaciones en las superficies del sistema del teléfono. Esta prioridad se basa en el hecho de que la comunicación y la interacción con otras personas sigue siendo el área funcional más valorada e importante para la mayoría de los usuarios de Android en todos los grupos demográficos.

Requisitos de uso

• Este tipo de notificación requiere el SDK de Braze para Android v15.0.0+ y dispositivos con Android 11+.
• Los dispositivos o SDK no compatibles recurrirán a una notificación push estándar.

Esta característica solo está disponible a través de la REST API de Braze. Consulta el objeto push de Android para obtener más información.

Errores de cuota excedida de FCM

Cuando se excede tu límite de Firebase Cloud Messaging (FCM), Google devuelve errores de “cuota excedida”. El límite predeterminado para FCM es de 600 000 solicitudes por minuto. Braze reintenta el envío de acuerdo con las prácticas recomendadas de Google. Sin embargo, un gran volumen de estos errores puede prolongar el tiempo de envío varios minutos. Para mitigar el impacto potencial, Braze te enviará una alerta indicando que se está excediendo el límite de velocidad y los pasos que puedes seguir para prevenir los errores.

Para verificar tu límite actual, ve a Google Cloud Console > APIs & Services > Firebase Cloud Messaging API > Quotas & System Limits, o visita la página de cuotas de la API de FCM.

Prácticas recomendadas

Recomendamos estas prácticas para mantener bajo el volumen de estos errores.

Solicitar un aumento del límite de velocidad a FCM

Para solicitar un aumento del límite de velocidad a FCM, puedes contactar directamente con el soporte de Firebase o hacer lo siguiente:

1. Ve a la página de cuotas de la API de FCM.
2. Localiza la cuota Send requests per minute.
3. Selecciona Edit Quota.
4. Introduce un nuevo valor y envía tu solicitud.

Aplicar un límite de velocidad del espacio de trabajo

Puedes aplicar un límite de velocidad del espacio de trabajo para las notificaciones push de Android. Esto puede ayudar a regular la tasa de entrega de tus mensajes salientes. Para más detalles, consulta Límites de velocidad de mensajería del espacio de trabajo.