Notifications push

Conditions préalables

Avant de pouvoir utiliser cette fonctionnalité, vous devrez intégrer le SDK Android de Braze.

Fonctionnalités intégrées

Les fonctionnalités suivantes sont intégrées au SDK Android de Braze. Pour utiliser d’autres fonctionnalités de notification push, vous devrez configurer les notifications push pour votre application.

À propos du cycle de vie des notifications push

Le diagramme suivant illustre la manière dont Braze gère le cycle de vie des notifications push, notamment les demandes d’autorisation, la génération de jetons et la distribution des messages.

• accorder les autorisations
• génération des jetons push
• affichage des 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

Configuration des notifications push

Conseil

Pour découvrir un exemple d’application utilisant FCM avec le SDK Android de Braze, consultez Braze : exemple d’application Firebase Push.

Limites de débit

L’API Firebase Cloud Messaging (FCM) a une limite de débit par défaut de 600 000 requêtes par minute. Si vous atteignez cette limite, Braze réessaiera automatiquement dans quelques minutes. Pour demander une augmentation, contactez le support Firebase.

Étape 1 : Ajouter Firebase à votre projet

Commencez par ajouter Firebase à votre projet Android. Pour des instructions détaillées, consultez le guide de configuration Firebase de Google.

Étape 2 : Ajouter Cloud Messaging à vos dépendances

Ensuite, ajoutez la bibliothèque Cloud Messaging aux dépendances de votre projet. Dans votre projet Android, ouvrez build.gradle, puis ajoutez la ligne suivante à votre bloc dependencies.

1

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

Vos dépendances devraient ressembler à ceci :

1
2
3
4

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

Étape 3 : Activer l’API Firebase Cloud Messaging

Dans Google Cloud, sélectionnez le projet utilisé par votre application Android, puis activez l’API Firebase Cloud Messaging.

Étape 4 : Créer un compte de service

Ensuite, créez un nouveau compte de service, afin que Braze puisse effectuer des appels API autorisés lors de l’enregistrement des jetons FCM. Dans Google Cloud, accédez à Service Accounts, puis sélectionnez votre projet. Sur la page Service Accounts, sélectionnez Create Service Account.

Saisissez un nom, un ID et une description pour le compte de service, puis sélectionnez Create and continue.

Dans le champ Role, recherchez et sélectionnez Firebase Cloud Messaging API Admin dans la liste des rôles. Pour un accès plus restrictif, créez un rôle personnalisé avec la permission cloudmessaging.messages.create, puis choisissez-le dans la liste à la place. Lorsque vous avez terminé, sélectionnez Done.

Avertissement

Veillez à sélectionner Firebase Cloud Messaging API Admin, et non Firebase Cloud Messaging Admin.

Étape 5 : Générer les identifiants JSON

Ensuite, générez les identifiants JSON pour votre compte de service FCM. Sur Google Cloud IAM & Admin, accédez à Service Accounts, puis sélectionnez votre projet. Localisez le compte de service FCM que vous avez créé précédemment, puis sélectionnez  Actions > Manage Keys.

Sélectionnez Add Key > Create new key.

Choisissez JSON, puis sélectionnez Create. Si vous avez créé votre compte de service en utilisant un ID de projet Google Cloud différent de votre ID de projet FCM, vous devrez mettre à jour manuellement la valeur attribuée à project_id dans votre fichier JSON.

N’oubliez pas l’emplacement de téléchargement de la clé—vous en aurez besoin à l’étape suivante.

Avertissement

Les clés privées peuvent présenter un risque de sécurité en cas de compromission. Conservez vos identifiants JSON dans un emplacement sécurisé pour le moment—vous supprimerez votre clé après l’avoir chargée dans Braze.

Étape 6 : Charger vos identifiants JSON dans Braze

Ensuite, chargez vos identifiants JSON dans votre tableau de bord de Braze. Dans Braze, sélectionnez  Settings > App Settings.

Sous les Push Notification Settings de votre application Android, choisissez Firebase, puis sélectionnez Upload JSON File et chargez les identifiants que vous avez générés précédemment. Lorsque vous avez terminé, sélectionnez Save.

Avertissement

Les clés privées peuvent présenter un risque de sécurité en cas de compromission. Maintenant que votre clé est chargée dans Braze, supprimez le fichier que vous avez généré précédemment.

Étape 7 : Configurer l’enregistrement automatique des jetons

Lorsqu’un de vos utilisateurs s’abonne aux notifications push, votre application doit générer un jeton FCM sur son appareil avant de pouvoir lui envoyer des notifications push. Avec le SDK de Braze, vous pouvez activer l’enregistrement automatique des jetons FCM pour l’appareil de chaque utilisateur dans les fichiers de configuration Braze de votre projet.

Tout d’abord, accédez à la console Firebase, ouvrez votre projet, puis sélectionnez  Settings > Project settings.

Sélectionnez Cloud Messaging, puis sous Firebase Cloud Messaging API (V1), copiez le numéro dans le champ Sender ID.

Ensuite, ouvrez votre projet Android Studio et utilisez votre Firebase Sender ID pour activer l’enregistrement automatique des jetons FCM dans votre braze.xml ou 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)

Conseil

Si vous préférez enregistrer manuellement les jetons FCM, définissez la propriété registeredPushToken sur l’instance Braze dans la méthode onCreate() de votre application.

1
2

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

1
2

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

Utiliser plusieurs projets Firebase

Si votre application utilise plusieurs projets Firebase, suivez ces étapes :

1. Conservez les notifications push Braze sur le projet Firebase par défaut initialisé à partir du fichier google-services.json de votre application.
2. Si vous utilisez un service de messagerie Firebase personnalisé, suivez Enregistrer les Installation ID dans les services de messagerie Firebase personnalisés.
3. Si votre application obtient un jeton push d’une autre manière, définissez manuellement registeredPushToken comme indiqué dans l’astuce précédente.

Important

Firebase Cloud Messaging ne dispose pas d’API prise en charge pour récupérer un jeton à partir d’une FirebaseApp que vous initialisez manuellement. Les rappels de FirebaseMessagingService tels que onNewToken et onRegistered ne se déclenchent que pour le projet par défaut. Pour plus d’informations, consultez Configurer plusieurs projets dans la documentation Firebase.

Pour les détails de version, consultez les journaux des modifications du SDK.

Étape 8 : Supprimer les requêtes automatiques dans votre classe Application

Pour empêcher Braze de déclencher des requêtes réseau inutiles chaque fois que vous envoyez des notifications push silencieuses, supprimez toute requête réseau automatique configurée dans la méthode onCreate() de votre classe Application. Pour plus d’informations, consultez Référence développeur Android : Application.

Afficher les notifications

Étape 1 : Enregistrer le service Firebase Messaging de Braze

Vous pouvez créer un nouveau service Firebase Messaging, utiliser un service existant ou un service non-Braze. Choisissez l’option qui correspond le mieux à vos besoins spécifiques.

• nouveau
• existant
• non-braze

Braze inclut un service pour gérer la réception des notifications push et les intentions d’ouverture. Notre classe BrazeFirebaseMessagingService doit être enregistrée dans votre 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>

Notre code de notification utilise également BrazeFirebaseMessagingService pour gérer le suivi des ouvertures et des clics. Ce service doit être enregistré dans le AndroidManifest.xml pour fonctionner correctement. N’oubliez pas non plus que Braze préfixe les notifications de notre système avec une clé unique afin de n’afficher que les notifications envoyées depuis nos systèmes. Vous pouvez enregistrer des services supplémentaires séparément pour afficher les notifications envoyées par d’autres services FCM. Consultez AndroidManifest.xml dans l’application d’exemple Firebase push.

Important

Avant le SDK Braze 3.1.1, AppboyFcmReceiver était utilisé pour gérer les notifications push FCM. La classe AppboyFcmReceiver doit être retirée de votre manifeste et remplacée par l’intégration précédente.

Si vous avez déjà un service Firebase Messaging enregistré, vous pouvez transmettre les objets RemoteMessage à Braze via BrazeFirebaseMessagingService.handleBrazeRemoteMessage(). Cette méthode n’affichera une notification que si l’objet RemoteMessage provient de Braze et l’ignorera en toute sécurité dans le cas contraire.

Enregistrer les ID d’installation dans les services Firebase Messaging personnalisés

Si vous utilisez firebase-messaging v25.1.0 ou une version ultérieure, l’enregistrement Firebase utilise l’ID d’installation Firebase. Dans votre service Firebase Messaging personnalisé, remplacez onRegistered et définissez 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 vous disposez d’un autre service Firebase Messaging que vous souhaitez également utiliser, vous pouvez spécifier un service Firebase Messaging de secours à appeler si votre application reçoit une notification push qui ne provient pas de Braze.

Dans votre braze.xml, spécifiez :

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>

ou définissez-le via la configuration à l’exécution :

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

Étape 2 : Adapter les petites icônes aux directives de conception

Pour des informations générales sur les icônes de notification Android, consultez l’aperçu des notifications.

À partir d’Android N, vous devez mettre à jour ou supprimer les ressources de petites icônes de notification qui comportent des couleurs. Le système Android (et non le SDK Braze) ignore tous les canaux non-alpha et de transparence dans les icônes d’action et la petite icône de notification. Autrement dit, Android convertira toutes les parties de votre petite icône de notification en monochrome, à l’exception des régions transparentes.

Pour créer une ressource de petite icône de notification qui s’affiche correctement :

• Supprimez toutes les couleurs de l’image à l’exception du blanc.
• Toutes les autres régions non blanches de la ressource doivent être transparentes.

Remarque

Un symptôme courant d’une ressource incorrecte est le rendu de la petite icône de notification sous la forme d’un carré monochrome plein. Cela est dû au fait que le système Android ne parvient pas à trouver de régions transparentes dans la ressource de la petite icône de notification.

Les grandes et petites icônes illustrées ci-dessous sont des exemples d’icônes correctement conçues :

Étape 3 : Configurer les icônes de notification

Spécifier les icônes dans braze.xml

Braze vous permet de configurer vos icônes de notification en spécifiant des ressources drawable dans votre 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>

La définition d’une petite icône de notification est obligatoire. Si vous n’en définissez pas, Braze utilisera par défaut l’icône de l’application comme petite icône de notification, ce qui peut donner un résultat non optimal.

La définition d’une grande icône de notification est facultative mais recommandée.

Spécifier la couleur d’accentuation de l’icône

La couleur d’accentuation de l’icône de notification peut être remplacée dans votre braze.xml. Si aucune couleur n’est spécifiée, la couleur par défaut est le même gris que celui utilisé par Lollipop pour les notifications système.

1

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

Vous pouvez également utiliser une référence de couleur :

1

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

Étape 4 : Ajouter des deep links

Activer l’ouverture automatique des deep links

Pour permettre à Braze d’ouvrir automatiquement votre application et tous les deep links lorsqu’une notification push est cliquée, définissez com_braze_handle_push_deep_links_automatically sur true dans votre braze.xml :

1

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

Ce paramètre peut également être défini via la configuration à l’exécution :

• 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 vous souhaitez gérer les deep links de manière personnalisée, vous devrez créer un rappel push qui écoute les intentions de réception et d’ouverture push de Braze. Pour plus d’informations, consultez Utiliser un rappel pour les événements push.

Gestion des notifications au premier plan

Par défaut, lorsqu’une notification push arrive alors que votre application est au premier plan sur Android, le système l’affiche automatiquement. Pour que Braze traite le payload de la notification push (suivi analytique, gestion des deep links et traitement personnalisé), transmettez les données push entrantes à Braze dans votre méthode FirebaseMessagingService.onMessageReceived.

Fonctionnement

Lorsque vous appelez BrazeFirebaseMessagingService.handleBrazeRemoteMessage, Braze détermine si le payload est une notification push Braze et, le cas échéant, crée et affiche la notification avec la méthode NotificationManagerCompat. Contrairement à iOS, Android affiche les notifications indépendamment du fait que l’application soit au premier plan ou en arrière-plan.

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

Pour plus d’informations, consultez l’exemple d’intégration Firebase dans le dépôt du SDK Android de Braze.

Personnaliser le comportement au premier plan

Si vous souhaitez un comportement personnalisé au premier plan, comme supprimer la notification système ou afficher une interface intégrée à l’application à la place, vous pouvez :

• Utiliser subscribeToPushNotificationEvents pour réagir aux événements push et gérer les deep links avec la méthode BrazeNotificationUtils.routeUserWithNotificationOpenedIntent. Pour plus d’informations, consultez l’exemple push Firebase.
• Créer et publier votre propre notification à l’aide d’une IBrazeNotificationFactory personnalisée, ou supprimer la notification en n’appelant pas notificationManager.notify dans votre flux de traitement.

Pour plus d’informations sur la personnalisation des notifications, consultez Usine de notifications personnalisée.

Créer des deep links personnalisés

Suivez les instructions de la documentation développeur Android sur les deep links si vous n’avez pas encore ajouté de deep links à votre application. Pour en savoir plus sur les deep links, consultez notre article FAQ.

Ajouter des deep links

Le tableau de bord de Braze permet de définir des deep links ou des URL web dans les Campaigns et Canvas de notifications push qui s’ouvriront lorsque la notification est cliquée.

Personnaliser le comportement de la pile de retour

Le SDK Android, par défaut, placera l’activité principale de lancement de votre application hôte dans la pile de retour lors du suivi des deep links push. Braze vous permet de définir une activité personnalisée à ouvrir dans la pile de retour à la place de votre activité principale de lancement, ou de désactiver complètement la pile de retour.

Par exemple, pour définir une activité appelée YourMainActivity comme activité de la pile de retour en utilisant la configuration à l’exécution :

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

Consultez la configuration équivalente pour votre braze.xml. Notez que le nom de la classe doit être identique à celui renvoyé par 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>

Étape 5 : Définir les canaux de notification

Le SDK Android de Braze prend en charge les canaux de notification Android. Si une notification Braze ne contient pas l’ID d’un canal de notification ou si une notification Braze contient un ID de canal invalide, Braze affichera la notification avec le canal de notification par défaut défini dans le SDK. Les utilisateurs de l’entreprise utilisent les canaux de notification Android au sein de la plateforme pour regrouper les notifications.

Pour définir le nom visible par l’utilisateur du canal de notification Braze par défaut, utilisez BrazeConfig.setDefaultNotificationChannelName().

Pour définir la description visible par l’utilisateur du canal de notification Braze par défaut, utilisez BrazeConfig.setDefaultNotificationChannelDescription().

Mettez à jour toutes les Campaigns API avec le paramètre de l’objet push Android pour inclure le champ notification_channel. Si ce champ n’est pas spécifié, Braze enverra le payload de notification avec l’ID du canal de secours du tableau de bord.

En dehors du canal de notification par défaut, Braze ne créera aucun canal. Tous les autres canaux doivent être définis par programmation par l’application hôte, puis saisis dans le tableau de bord de Braze.

Le nom et la description du canal par défaut peuvent également être configurés dans 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>

Étape 6 : Tester l’affichage des notifications et les analyses

Tester l’affichage

À ce stade, vous devriez pouvoir voir les notifications envoyées depuis Braze. Pour tester cela, accédez à la page Campaigns sur votre tableau de bord de Braze et créez une Campaign de notification push. Choisissez Android Push et concevez votre message. Cliquez ensuite sur l’icône en forme d’œil dans le composeur pour accéder à l’outil d’envoi de test. Saisissez l’ID utilisateur ou l’adresse e-mail de votre utilisateur actuel et cliquez sur Send Test. Vous devriez voir la notification push apparaître sur votre appareil.

Pour les problèmes liés à l’affichage des notifications push, consultez notre guide de résolution des problèmes.

Tester les analyses

À ce stade, vous devriez également disposer de l’enregistrement analytique pour les ouvertures de notifications push. Cliquer sur la notification lorsqu’elle arrive devrait entraîner une augmentation de 1 du compteur Direct Opens sur la page de résultats de votre Campaign. Consultez notre article sur les rapports push pour un détail des analyses push.

Pour les problèmes liés aux analyses push, consultez notre guide de résolution des problèmes.

Tester depuis la ligne de commande

Si vous souhaitez tester les notifications intégrées à l’application et les notifications push via l’interface en ligne de commande, vous pouvez envoyer une seule notification via le terminal à l’aide de cURL et de l’API d’envoi de messages. Vous devrez remplacer les champs suivants par les valeurs correctes pour votre cas de test :

• YOUR_API_KEY (Accédez à Settings > API Keys.)
• YOUR_EXTERNAL_USER_ID (Recherchez un profil sur la page Search Users.)
• YOUR_KEY1 (facultatif)
• YOUR_VALUE1 (facultatif)

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

Cet exemple utilise l’instance US-01. Si vous n’êtes pas sur cette instance, remplacez l’endpoint US-01 par votre endpoint.

Notifications push conversationnelles

L’initiative People and Conversations est une initiative Android pluriannuelle qui vise à mettre en avant les personnes et les conversations dans les surfaces système du téléphone. Cette priorité repose sur le fait que la communication et l’interaction avec d’autres personnes restent le domaine fonctionnel le plus apprécié et le plus important pour la majorité des utilisateurs Android, toutes catégories démographiques confondues.

Conditions d’utilisation

• Ce type de notification nécessite le SDK Braze pour Android v15.0.0+ et des appareils sous Android 11+.
• Les appareils ou SDK non pris en charge afficheront une notification push standard par défaut.

Cette fonctionnalité n’est disponible que via la REST API de Braze. Consultez l’objet push Android pour en savoir plus.

Erreurs de dépassement de quota FCM

Lorsque votre limite pour Firebase Cloud Messaging (FCM) est dépassée, Google renvoie des erreurs « quota exceeded » (quota dépassé). La limite par défaut pour FCM est de 600 000 requêtes par minute. Braze effectue de nouvelles tentatives d’envoi conformément aux bonnes pratiques recommandées par Google. Cependant, un volume important de ces erreurs peut prolonger le temps d’envoi de plusieurs minutes. Pour atténuer l’impact potentiel, Braze vous enverra une alerte indiquant que la limitation du débit est dépassée, ainsi que les mesures à prendre pour éviter ces erreurs.

Pour vérifier votre limite actuelle, accédez à votre Google Cloud Console > APIs & Services > Firebase Cloud Messaging API > Quotas & System Limits, ou consultez la page des quotas de l’API FCM.

Bonnes pratiques

Nous recommandons ces bonnes pratiques pour maintenir un faible volume de ces erreurs.

Demander une augmentation de la limitation du débit auprès de FCM

Pour demander une augmentation de la limitation du débit auprès de FCM, vous pouvez contacter directement le support Firebase ou procéder comme suit :

1. Accédez à la page des quotas de l’API FCM.
2. Localisez le quota Send requests per minute.
3. Sélectionnez Edit Quota.
4. Saisissez une nouvelle valeur et soumettez votre demande.

Appliquer une limitation du débit au niveau de l’espace de travail

Vous pouvez appliquer une limitation du débit au niveau de l’espace de travail pour les notifications push Android. Cela peut aider à réguler le rythme de distribution de vos messages sortants. Pour plus de détails, consultez la section Limites de débit de communication de l’espace de travail.