Notifications push

Conditions préalables

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

Fonctionnalités créées

Les fonctionnalités suivantes sont créées dans le SDK Android de Braze. Pour utiliser toute autre fonctionnalité de notification push, vous devrez configurer les notifications push pour votre application.

À propos du cycle de vie des notifications push

L’organigramme suivant montre comment Braze gère le cycle de vie des notifications push, notamment les demandes d’autorisation, la génération de jetons et l’envoi/distribution des messages.

• octroi de permissions
• générer des jetons de poussée
• 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

Mise en place des notifications push

Limites de débit

L’API Firebase Cloud Messaging (FCM) présente 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 service d’assistance de Firebase.

Étape 1 : Ajoutez Firebase à votre projet

Tout d’abord, ajoutez Firebase à votre projet Android. Pour obtenir des instructions pas à pas, consultez le guide de configuration de Firebase de Google.

Étape 2 : Ajoutez 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 à ce qui suit :

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

Étape 3 : Activez l’API d’envoi de messages de Firebase Cloud.

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, sélectionnez Service Accounts (Comptes de service), puis choisissez votre projet. Sur la page Comptes de service, sélectionnez Créer un compte de service.

Saisissez un nom de compte de service, un ID et une description, puis sélectionnez Create and continue (Créer et continuer).

Dans le champ Rôle, 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 l’autorisation cloudmessaging.messages.create, puis choisissez-le dans la liste. Lorsque vous avez terminé, sélectionnez Terminé.

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

Ensuite, générez les identifiants JSON pour votre compte de service FCM. Dans Google Cloud IAM & Admin, sélectionnez Service Accounts (Comptes de service), puis choisissez votre projet. Recherchez le compte de service FCM que vous avez créé précédemment, puis sélectionnez Actions > Manage Keys (Gérer les clés).

Sélectionnez Ajouter une clé > Créer une nouvelle clé.

Choisissez JSON, puis sélectionnez Create (Créer). 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 à l’adresse project_id dans votre fichier JSON.

N’oubliez pas l’endroit où vous avez téléchargé la clé : vous en aurez besoin à l’étape suivante.

Étape 6 : Téléchargez vos informations d’identification JSON vers Braze.

Ensuite, chargez vos identifiants JSON dans votre tableau de bord de Braze. Dans Braze, sélectionnez Paramètres > Paramètres des applications.

Sous les paramètres de notifications push de votre application Android, choisissez Firebase, puis sélectionnez Charger un fichier JSON et chargez les identifiants que vous avez générés précédemment. Lorsque vous avez terminé, sélectionnez Enregistrer.

Étape 7 : Configurer l’enregistrement automatique des jetons

Lorsqu’un de vos utilisateurs opte pour les notifications push, votre application doit générer un jeton FCM sur son appareil avant que vous puissiez lui envoyer des notifications push. Avec le SDK 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 Paramètres > Paramètres du projet.

Sélectionnez Cloud Messaging, puis sous API Firebase Cloud Messaging (V1), copiez le numéro dans le champ ID de l’expéditeur.

Ensuite, ouvrez votre projet Android Studio et utilisez votre ID d’expéditeur Firebase pour activer l’enregistrement automatique des jetons FCM au sein de 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)

Étape 8 : Supprimez les demandes automatiques dans votre classe d’application

Pour éviter que Braze ne déclenche des requêtes réseau inutiles à chaque fois que vous envoyez des notifications push silencieuses, supprimez toutes les requêtes réseau automatiques configurées dans la méthode onCreate() de votre classe Application. Pour plus d’informations, consultez Référence pour les développeurs Android : Application.

Affichage des notifications

Étape 1 : Enregistrer le service de messagerie de Firebase de Braze

Vous pouvez créer un service d’envoi de messages Firebase nouveau, existant ou non Braze. Choisissez celui qui répond le mieux à vos besoins spécifiques.

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

Étape 2 : Conformer les petites icônes aux lignes directrices en matière de conception

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

À partir de Android N, vous devez mettre à jour ou supprimer les objets de petites icônes de notification qui impliquent une couleur. 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 les petites icônes de notification. En d’autres termes, Android convertit toutes les parties de votre petite icône de notification en monochrome, sauf pour les zones transparentes.

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

• Supprimez toutes les couleurs de l’image sauf le blanc.
• Toutes les parties non blanches de l’objet doivent être transparentes.

Les grandes et petites icônes suivantes sont des exemples d’icônes correctement conçues :

Étape 3 : Configurer les icônes de notification

Spécifier des icônes dans braze.xml

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

Il est nécessaire de définir une petite icône de notification. 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 n’est pas forcément idéal.

Définir une grande icône de notification est facultatif, mais recommandé.

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

La couleur d’accentuation de l’icône de notification peut être modifiée dans votre braze.xml. Si la couleur n’est pas spécifiée, la couleur par défaut est le même gris que celui utilisé par Lollipop pour les notifications du 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 liens profonds

Activer l’ouverture automatique du lien profond

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

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

Cet indicateur peut également être défini par la configuration de 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 de manière personnalisée les liens profonds, vous devrez créer un rappel de poussée qui écoute les poussées reçues et les intentions d’ouverture de Braze. Pour plus d’informations, voir Utilisation d’un rappel pour les événements “push”.

Création de liens profonds personnalisés

Si vous n’avez pas encore ajouté de liens profonds à votre application, suivez les instructions figurant dans la documentation destinée aux développeurs Android sur la création de liens profonds. Pour en savoir plus sur les liens profonds, consultez notre article de FAQ.

Ajouter des liens profonds

Le tableau de bord de Braze prend en charge la mise en place de liens profonds ou d’URL Web dans les campagnes de notifications push et des Canvas qui seront ouverts lorsque la notification est cliquée.

Personnaliser le comportement de la pile arrière

Par défaut, le SDK Android place l’activité du lanceur principal de votre application hôte dans la pile arrière lorsqu’il suit des liens profonds de notification push. Braze vous permet de définir qu’une activité personnalisée s’ouvre dans la pile arrière à la place de votre activité de lanceur principal ou de désactiver complètement la pile arrière.

Par exemple, pour définir une activité appelée YourMainActivity comme activité de la pile arrière à l’aide de la configuration d’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 d’ID pour un canal de notification ou qu’une notification Braze contient un ID de canal non valide, Braze affichera la notification avec le canal de notification par défaut défini dans le SDK. Les utilisateurs de Braze utilisent les canaux de notification Android au sein de la plateforme pour regrouper les notifications.

Pour définir le nom du canal de notification par défaut de Braze auquel l’utilisateur est confronté, procédez comme suit BrazeConfig.setDefaultNotificationChannelName().

Pour définir la description du canal de notification par défaut de Braze à laquelle l’utilisateur est confronté, utilisez la commande BrazeConfig.setDefaultNotificationChannelDescription().

Mettez à jour toutes les campagnes API avec le paramètre Android push object pour inclure le champ notification_channel. Si ce champ n’est pas spécifié, Braze enverra la charge utile de notification avec l’ID du canal de repli du tableau de bord.

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

Le nom et la description par défaut du canal 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 et l’analyse des notifications

Tester l’affichage

À ce stade, vous devriez pouvoir voir les notifications envoyées par Braze. Pour tester cela, rendez-vous sur la page Campagnes de votre tableau de bord Braze et créez une campagne de notification push. Choisissez Android Push et concevez votre message. Cliquez ensuite sur l’icône « Œil » dans le composeur pour obtenir l’expéditeur de test. Saisissez l’ID ou l’adresse e-mail de votre utilisateur actuel et cliquez sur Envoyer le test. Vous devriez voir la notification push s’afficher sur votre appareil.

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

Tester l’analyse

À ce stade, vous devez également disposer d’un enregistrement de l’analyse pour les ouvertures de notifications push. En cliquant sur la notification lorsqu’elle arrive, le nombre d’ouvertures directes sur la page des résultats de votre campagne devrait augmenter de 1. Consultez notre article sur les rapports push pour en savoir plus sur les analyses/analytiques push.

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

Tester depuis la ligne de commande

Si vous souhaitez tester les notifications in-app et push via l’interface de ligne de commande, vous pouvez envoyer une seule notification par le biais du terminal via cURL et l ‘API de messages. Vous devrez remplacer les champs suivants par les valeurs correctes pour votre cas de test :

• YOUR_API_KEY (Allez dans Paramètres > Clés API.)
• YOUR_EXTERNAL_USER_ID ( Recherchez un profil utilisateur sur la page Recherche d’utilisateurs).
• 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 de la conversion

L’initiative des personnes et des conversations est une initiative Android pluriannuelle qui vise à améliorer la prise en compte des personnes et des conversations dans les surfaces du système du téléphone. Cette priorité est basée sur le fait que la communication et l’interaction avec d’autres personnes restent la zone fonctionnelle la plus valorisée et la plus importante pour la majorité des utilisateurs d’Android dans toutes les tranches démographiques.

Exigences d’utilisation

• Ce type de notification nécessite le SDK Braze pour Android v15.0.0 et ultérieures et des appareils Android 11 et ultérieurs.
• Les appareils ou les SDK non pris en charge reprennent une notification push standard.

Cette fonctionnalité est uniquement disponible sur l’API REST de Braze. Voir l’objet push d’Android pour plus d’informations.

Erreurs de dépassement de quota du FCM

Lorsque votre limite pour Firebase Cloud Messaging (FCM) est dépassée, Google renvoie des erreurs de type “quota dépassé”. La limite par défaut du FCM est de 600 000 requêtes par minute. Braze retente l’envoi conformément aux meilleures pratiques recommandées par Google. Cependant, un grand nombre 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 limite de débit est dépassée et les mesures que vous pouvez prendre pour éviter les erreurs.

Pour vérifier votre limite actuelle, accédez à votre Google Cloud Console > API et services > Firebase Cloud Messaging API > Quotas et limites du système, ou consultez la page Quotas de l’API FCM.

Bonnes pratiques

Nous vous recommandons les meilleures pratiques suivantes pour limiter le nombre d’erreurs.

Demande d’augmentation de la limite de débit auprès de la FCM

Pour demander une augmentation de la limite de débit au FCM, vous pouvez contacter directement le service d’assistance de Firebase ou procéder comme suit :

1. Allez à la page Quotas de l’API du FCM.
2. Emplacement/localisation du quota d’envoi de requêtes par minute.
3. Sélectionnez Modifier le quota.
4. Saisissez une nouvelle valeur et soumettez votre demande.

Demander une limite de débit globale via Braze

Pour appliquer une limite à l’échelle de l’espace de travail pour les notifications push Android, contactez le support Braze.