Notificaciones push

Requisitos previos

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

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, deberás configurar las notificaciones push para 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.

• granting permissions
• generating push tokens
• displaying notifications

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

Configuración de notificaciones push

Límites de tarifa

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 volverá a intentar automáticamente en unos minutos. Para solicitar un aumento, ponte en contacto con el servicio de asistencia de Firebase.

Paso 1: Añade Firebase a tu proyecto

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

Paso 2: Añade Mensajería en la Nube 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 añade la siguiente línea a tu bloque dependencies.

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

Tus dependencias deben 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 mensajería en la nube de Firebase

En Google Cloud, selecciona el proyecto que utiliza tu aplicación Android y, a continuación, habilita la API de mensajería de Firebase Cloud.

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 (Cuentas de servicio) y elige tu proyecto. En la página Cuentas de servicio, selecciona Crear cuenta de servicio.

Introduce un nombre de cuenta de servicio, un ID y una descripción, luego selecciona Crear y continuar.

En el campo Rol, busca y selecciona Administrador de la API de mensajería en la nube de Firebase en la lista de roles. Para un acceso más restrictivo, crea un rol personalizado con el permiso cloudmessaging.messages.create y, en su lugar, elígelo de la lista. Cuando hayas terminado, selecciona Hecho.

Paso 5: Generar credenciales JSON

A continuación, genera las credenciales JSON de tu cuenta del servicio FCM. En Google Cloud IAM&Admin, ve a Cuentas de servicio y selecciona tu proyecto. Localiza la cuenta de servicio FCM que creaste anteriormente y, a continuación, selecciona Acciones > Gestionar claves.

Selecciona Añadir clave > Crear nueva clave.

Elige JSON y selecciona Crear. Si creaste tu cuenta de servicio utilizando un ID de proyecto de Google Cloud distinto del 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.

Paso 6: Sube tus credenciales JSON a Braze

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

En la configuración de notificaciones push de tu aplicación Android, elige Firebase, luego selecciona Cargar archivo JSON y carga las credenciales que generaste anteriormente. Cuando haya terminado, seleccione Guardar.

Paso 7: Configurar el registro automático de tokens

Cuando uno de tus usuarios opta por recibir 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 del token FCM para cada dispositivo de usuario en los archivos de configuración Braze de tu proyecto.

Primero, ve a la Consola Firebase, abre tu proyecto y selecciona Configuración > Configuración del proyecto.

Selecciona Mensajería en la nube y, a continuación, en API de mensajería en la nube de Firebase (V1), copia el número en el campo ID del remitente.

A continuación, abre tu proyecto de Android Studio y utiliza tu ID de remitente de Firebase para habilitar el registro automático del token de FCM en 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)

Paso 8: Elimina 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 de Android: Aplicación.

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 la que mejor se adapte a tus necesidades específicas.

• new
• existing
• non-braze

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>

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyFirebaseMessagingService extends FirebaseMessagingService {
  @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
class MyFirebaseMessagingService : FirebaseMessagingService() {
  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.
    }
  }
}

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>

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: Ajustar los iconos pequeños a las directrices de diseño

Para obtener información general sobre los iconos de notificación de Android, visita el resumen de Notificaciones.

A partir de Android N, debes actualizar o eliminar los activos de los iconos de notificación pequeños que impliquen 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 en el icono pequeño de notificación. En otras palabras, Android convertirá todas las partes de tu pequeño icono de notificación en monocromo, excepto las regiones transparentes.

Para crear un pequeño activo 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.

Los siguientes íconos grandes y pequeños son ejemplos de íconos correctamente diseñados:

Paso 3: Configurar iconos de notificación

Especificar íconos en braze.xml

Braze te permite configurar tus iconos de notificación especificando recursos dibujables 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 necesario configurar un pequeño icono de notificación. Si no estableces ninguno, Braze utilizará por defecto el icono de la aplicación como icono pequeño de notificación, lo que puede parecer poco óptimo.

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

Especificar el color de acento del icono

El color de acento del icono de notificación se puede anular en tu braze.xml. Si no se especifica el color, el color 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

Habilitación de la apertura automática de vínculos profundos

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

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

Esta bandera también se puede establecer mediante la 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 quieres gestionar de forma personalizada los vínculos profundos, tendrás que crear una devolución de llamada push que escuche las intenciones push recibidas y abiertas de Braze. Para obtener más información, consulta Uso de una devolución de llamada para eventos push.

Manejo de notificaciones en primer plano

De forma predeterminada, cuando llega una notificación push mientras la 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), envía los datos push entrantes a Braze dentro de tuFirebaseMessagingService.onMessageReceivedmétodo.

Cómo funciona

Cuando llamas BrazeFirebaseMessagingService.handleBrazeRemoteMessagea , Braze determina si la carga útil es una notificación push de Braze y, si es así, crea y muestra la notificación con elNotificationManagerCompatmétodo . 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 obtener más información, consulta el ejemplo de integración de Firebase en el repositorio del SDK de Braze para Android.

Personalización del comportamiento en primer plano

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

• UtilizasubscribeToPushNotificationEvents para reaccionar ante eventos push y gestionar vínculos profundos con elBrazeNotificationUtils.routeUserWithNotificationOpenedIntentmétodo . Para obtener más información, consulta el ejemplo de notificaciones push de Firebase.
• Crea y publica tu propia notificación utilizando una personalizadaIBrazeNotificationFactory, o suprime la notificación sin llamarnotificationManager.notifya en tu ruta de gestión.

Para obtener más información sobre cómo personalizar las notificaciones personalizadas, consulta Fábrica de notificaciones personalizadas.

Crear vínculos profundos personalizados

Sigue las instrucciones que se encuentran en la documentación para desarrolladores de Android sobre la vinculación en profundidad si aún no has añadido vínculos profundos a tu aplicación. Para saber 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 admite la configuración de vínculos profundos o URL de Web en campañas de notificaciones push y Lienzos que se abrirán cuando se haga clic en la notificación.

Personalizar el comportamiento de la pila de actividades

El SDK de Android, de forma predeterminada, colocará la actividad principal iniciadora de tu aplicación anfitriona en la pila de actividades cuando se sigan vínculos profundos push. Braze te permite configurar una actividad personalizada para que se abra en la pila de actividades en lugar de tu actividad principal iniciadora o desactivar por completo la pila de actividades.

Por ejemplo, para establecer una actividad llamada YourMainActivity como actividad de la pila trasera mediante 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. Nota 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 para Android de Braze es compatible con los canales de notificación de Android. Si una notificación Braze no contiene el ID de un canal de notificación o que una notificación 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 las notificaciones.

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

Para configurar la descripción orientada al usuario del canal de notificación predeterminado de Braze, utiliza BrazeConfig.setDefaultNotificationChannelDescription().

Actualiza cualquier campaña de la API con el parámetro de objeto push de Android para incluir el campo notification_channel. Si no se especifica este campo, 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 mediante programación por la aplicación anfitriona y luego introducidos en el panel de Braze.

El nombre y la descripción predeterminados del canal también se pueden configurar 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: Visualización y análisis de las notificaciones de las pruebas

Pantalla de pruebas

En este punto, deberías poder ver las notificaciones enviadas desde Braze. Para probarlo, ve a la página Campañas de tu panel de Braze y crea una campaña de Notificación push. Elige Android Push y diseña tu mensaje. A continuación, haz clic en el icono del ojo en el compositor para obtener el remitente de la prueba. Introduce el ID de usuario o la dirección de correo electrónico de tu usuario actual y haz clic en Enviar prueba. Deberías ver aparecer el push en tu dispositivo.

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

Análisis de pruebas

En este punto, también deberías tener un registro de análisis de las aperturas de notificaciones push. Si haces clic en la notificación cuando llegue, las Direct Opens de la página de resultados de tu campaña aumentarán en 1. Consulta nuestro artículo sobre los informes push para obtener más información sobre los análisis push.

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

Pruebas desde la línea de comandos

Si quieres probar las notificaciones dentro de la aplicación y las notificaciones push a través de la interfaz de línea de comandos, puedes enviar una única notificación a través del terminal mediante cURL y la API de mensajería. Tendrás que sustituir los siguientes campos por 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 utiliza la instancia US-01. Si no estás en esta instancia, sustituye el punto final US-01 por tu punto final.

Notificaciones push de conversaciones

La iniciativa de personas y conversaciones es una iniciativa plurianual de Android que pretende elevar 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 de todos los grupos demográficos.

Requisitos de uso

• Este tipo de notificación requiere la versión 15.0.0 en adelante del SDK de Braze para Android y dispositivos Android a partir de la versión 11.
• Los dispositivos o SDK no compatibles recibirán como alternativa una notificación push estándar.

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

Errores por exceso de cuota FCM

Cuando se supera el límite de Firebase FCM, Google devuelve errores de «cuota excedida». El límite predeterminado para FCM es de 600.000 peticiones por minuto. Braze vuelve a intentar el envío según las prácticas recomendadas por Google. Sin embargo, un gran volumen de estos errores puede prolongar el tiempo de envío varios minutos. Para mitigar el posible impacto, Braze te enviará una alerta de que se está superando el límite de velocidad y las medidas que puedes tomar para evitar los errores.

Para consultar tu límite actual, ve a Google Cloud Console > Servicios de& API > API de Firebase FCM > Cuotas Límites& del sistema, o visita la página Cuotas de la API de FCM.

Buenas prácticas

Recomendamos estas prácticas recomendadas para mantener bajos estos volúmenes de error.

Solicitar un aumento del límite de velocidad a FCM

Para solicitar un aumento del límite de velocidad a FCM, puedes ponerte en contacto directamente con el servicio de asistencia de Firebase o seguir estos pasos:

1. Ve a la página Cuotas de la API de FCM.
2. La ubicación de la cuota de solicitudes enviadas por minuto.
3. Selecciona Editar cuota.
4. Introduce un nuevo valor y envía tu solicitud.

Solicita el límite de velocidad para las tasas globales a través de Braze.

Para aplicar un límite en todo el espacio de trabajo para las notificaciones push de Android, ponte en contacto con el soporte de Braze.