Push-Benachrichtigungen

Voraussetzungen

Bevor Sie dieses Feature nutzen können, müssen Sie das Android Braze SDK integrieren.

Integrierte Features

Die folgenden Features sind im Braze Android SDK integriert. Um weitere Push-Benachrichtigungs-Features zu nutzen, müssen Sie Push-Benachrichtigungen einrichten für Ihre App.

Über den Lebenszyklus der Push-Benachrichtigung

Das folgende Flussdiagramm zeigt, wie Braze den Lebenszyklus der Push-Benachrichtigung handhabt, z. B. die Aufforderung zur Erteilung von Berechtigungen, die Generierung von Token und die Zustellung von Nachrichten.

• berechtigungen erteilen
• push-token generieren
• benachrichtigungen anzeigen

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

Push-Benachrichtigungen einrichten

Tipp

Um eine Beispiel-App mit FCM und dem Braze Android SDK auszuprobieren, sehen Sie sich Braze: Firebase Push Sample App an.

Rate-Limits

Die Firebase Cloud Messaging (FCM) API hat ein Standard-Rate-Limit von 600.000 Anfragen pro Minute. Wenn Sie dieses Limit erreichen, versucht Braze es automatisch nach einigen Minuten erneut. Um eine Erhöhung anzufordern, wenden Sie sich an den Firebase Support.

Schritt 1: Firebase zu Ihrem Projekt hinzufügen

Fügen Sie zunächst Firebase zu Ihrem Android-Projekt hinzu. Eine Schritt-für-Schritt-Anleitung finden Sie in Googles Firebase-Einrichtungsanleitung.

Schritt 2: Cloud Messaging zu Ihren Abhängigkeiten hinzufügen

Fügen Sie als Nächstes die Cloud-Messaging-Bibliothek zu Ihren Projektabhängigkeiten hinzu. Öffnen Sie in Ihrem Android-Projekt die Datei build.gradle und fügen Sie die folgende Zeile zu Ihrem dependencies-Block hinzu.

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

Ihre Abhängigkeiten sollten in etwa wie folgt aussehen:

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

Schritt 3: Die Firebase Cloud Messaging API aktivieren

Wählen Sie in Google Cloud das Projekt aus, das Ihre Android-App verwendet, und aktivieren Sie dann die Firebase Cloud Messaging API.

Schritt 4: Ein Dienstkonto erstellen

Erstellen Sie als Nächstes ein neues Dienstkonto, damit Braze autorisierte API-Aufrufe bei der Registrierung von FCM-Token durchführen kann. Gehen Sie in Google Cloud zu Service Accounts und wählen Sie Ihr Projekt aus. Wählen Sie auf der Seite Service Accounts die Option Create Service Account.

Geben Sie einen Namen, eine ID und eine Beschreibung für das Dienstkonto ein und wählen Sie dann Create and continue.

Suchen Sie im Feld Role den Eintrag Firebase Cloud Messaging API Admin in der Rollenliste und wählen Sie ihn aus. Für einen restriktiveren Zugriff erstellen Sie eine benutzerdefinierte Rolle mit der Berechtigung cloudmessaging.messages.create und wählen Sie diese stattdessen aus der Liste. Wenn Sie fertig sind, wählen Sie Done.

Warnung

Achten Sie darauf, Firebase Cloud Messaging API Admin auszuwählen, nicht Firebase Cloud Messaging Admin.

Schritt 5: JSON-Zugangsdaten generieren

Generieren Sie als Nächstes JSON-Zugangsdaten für Ihr FCM-Dienstkonto. Gehen Sie in Google Cloud IAM & Admin zu Service Accounts und wählen Sie Ihr Projekt aus. Suchen Sie das FCM-Dienstkonto, das Sie zuvor erstellt haben, und wählen Sie dann  Actions > Manage Keys.

Wählen Sie Add Key > Create new key.

Wählen Sie JSON und dann Create. Wenn Sie Ihr Dienstkonto mit einer anderen Google-Cloud-Projekt-ID als Ihrer FCM-Projekt-ID erstellt haben, müssen Sie den Wert von project_id in Ihrer JSON-Datei manuell aktualisieren.

Merken Sie sich, wo Sie den Schlüssel heruntergeladen haben—Sie benötigen ihn im nächsten Schritt.

Warnung

Private Keys können ein Sicherheitsrisiko darstellen, wenn sie kompromittiert werden. Bewahren Sie Ihre JSON-Zugangsdaten vorerst an einem sicheren Ort auf—Sie werden Ihren Schlüssel löschen, nachdem Sie ihn in Braze hochgeladen haben.

Schritt 6: Ihre JSON-Zugangsdaten in Braze hochladen

Laden Sie als Nächstes Ihre JSON-Zugangsdaten in Ihr Braze-Dashboard hoch. Wählen Sie in Braze  Settings > App Settings.

Wählen Sie unter den Push Notification Settings Ihrer Android-App Firebase aus, wählen Sie dann Upload JSON File und laden Sie die Zugangsdaten hoch, die Sie zuvor generiert haben. Wenn Sie fertig sind, wählen Sie Save.

Warnung

Private Keys können ein Sicherheitsrisiko darstellen, wenn sie kompromittiert werden. Da Ihr Schlüssel nun in Braze hochgeladen ist, löschen Sie die Datei, die Sie zuvor generiert haben.

Schritt 7: Automatische Token-Registrierung einrichten

Wenn sich Nutzer:innen für Push-Benachrichtigungen entscheiden, muss Ihre App ein FCM-Token auf deren Gerät generieren, bevor Sie ihnen Push-Benachrichtigungen senden können. Mit dem Braze SDK können Sie die automatische FCM-Token-Registrierung für das Gerät jedes Nutzers bzw. jeder Nutzerin in den Braze-Konfigurationsdateien Ihres Projekts aktivieren.

Gehen Sie zunächst zur Firebase Console, öffnen Sie Ihr Projekt und wählen Sie  Settings > Project settings.

Wählen Sie Cloud Messaging und kopieren Sie unter Firebase Cloud Messaging API (V1) die Nummer im Feld Sender ID.

Öffnen Sie als Nächstes Ihr Android-Studio-Projekt und verwenden Sie Ihre Firebase-Sender-ID, um die automatische FCM-Token-Registrierung in Ihrer braze.xml oder BrazeConfig zu aktivieren.

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

Tipp

Wenn Sie FCM-Token stattdessen manuell registrieren möchten, setzen Sie die Eigenschaft registeredPushToken auf der Braze-Instanz in der onCreate()-Methode Ihrer App.

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

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

Mehrere Firebase-Projekte verwenden

Wenn Ihre App mehrere Firebase-Projekte verwendet, gehen Sie wie folgt vor:

1. Belassen Sie Braze-Push beim Standard-Firebase-Projekt, das über die google-services.json Ihrer App initialisiert wird.
2. Wenn Sie einen benutzerdefinierten Firebase-Messaging-Dienst verwenden, führen Sie Installations-IDs in benutzerdefinierten Firebase-Messaging-Diensten registrieren durch.
3. Wenn Ihre App ein Push-Token auf andere Weise erhält, setzen Sie registeredPushToken manuell, wie im vorherigen Tipp gezeigt.

Wichtig

Firebase Cloud Messaging bietet keine unterstützte API zum Abrufen eines Tokens von einer FirebaseApp, die Sie manuell initialisieren. FirebaseMessagingService-Callbacks wie onNewToken und onRegistered werden nur für das Standardprojekt ausgelöst. Weitere Informationen finden Sie unter Mehrere Projekte konfigurieren in der Firebase-Dokumentation.

Versionsdetails finden Sie in den SDK-Changelogs.

Schritt 8: Automatische Anfragen in Ihrer Application-Klasse entfernen

Um zu verhindern, dass Braze bei jedem Senden stiller Push-Benachrichtigungen unnötige Netzwerkanfragen auslöst, entfernen Sie alle automatischen Netzwerkanfragen, die in der onCreate()-Methode Ihrer Application-Klasse konfiguriert sind. Weitere Informationen finden Sie unter Android Developer Reference: Application.

Benachrichtigungen anzeigen

Schritt 1: Braze Firebase Messaging Service registrieren

Sie können einen neuen, vorhandenen oder einen Nicht-Braze Firebase Messaging Service erstellen. Wählen Sie die Option, die Ihren spezifischen Anforderungen am besten entspricht.

• neu
• vorhanden
• nicht-braze

Braze enthält einen Dienst zur Verarbeitung von Push-Empfangs- und Öffnungs-Intents. Unser BrazeFirebaseMessagingService muss in Ihrer AndroidManifest.xml registriert werden:

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>

Unser Benachrichtigungscode verwendet ebenfalls BrazeFirebaseMessagingService, um das Tracking von Öffnungs- und Klickaktionen zu verarbeiten. Dieser Dienst muss in der AndroidManifest.xml registriert sein, damit er korrekt funktioniert. Beachten Sie außerdem, dass Braze Benachrichtigungen aus unserem System mit einem eindeutigen Schlüssel versieht, sodass nur Benachrichtigungen gerendert werden, die von unseren Systemen gesendet wurden. Sie können zusätzliche Dienste separat registrieren, um Benachrichtigungen zu rendern, die von anderen FCM-Diensten gesendet werden. Siehe AndroidManifest.xml in der Firebase-Push-Beispiel-App.

Wichtig

Vor Braze SDK 3.1.1 wurde AppboyFcmReceiver zur Verarbeitung von FCM-Push verwendet. Die Klasse AppboyFcmReceiver sollte aus Ihrem Manifest entfernt und durch die vorstehende Integration ersetzt werden.

Wenn Sie bereits einen Firebase Messaging Service registriert haben, können Sie RemoteMessage-Objekte über BrazeFirebaseMessagingService.handleBrazeRemoteMessage() an Braze übergeben. Diese Methode zeigt nur dann eine Benachrichtigung an, wenn das RemoteMessage-Objekt von Braze stammt, und ignoriert es andernfalls sicher.

Installations-IDs in benutzerdefinierten Firebase Messaging Services registrieren

Wenn Sie firebase-messaging v25.1.0 oder höher verwenden, nutzt die Firebase-Registrierung die Firebase Installation ID. Überschreiben Sie in Ihrem benutzerdefinierten Firebase Messaging Service onRegistered und setzen Sie 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.
    }
  }
}

Wenn Sie einen weiteren Firebase Messaging Service verwenden möchten, können Sie auch einen Fallback-Firebase-Messaging-Service angeben, der aufgerufen wird, wenn Ihre Anwendung einen Push empfängt, der nicht von Braze stammt.

Geben Sie in Ihrer braze.xml Folgendes an:

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>

oder legen Sie es über die Laufzeitkonfiguration fest:

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

Schritt 2: Kleine Symbole an die Designrichtlinien anpassen

Allgemeine Informationen zu Android-Benachrichtigungssymbolen finden Sie in der Übersicht zu Benachrichtigungen.

Ab Android N sollten Sie kleine Benachrichtigungssymbol-Assets, die Farbe enthalten, aktualisieren oder entfernen. Das Android-System (nicht das Braze SDK) ignoriert alle Nicht-Alpha- und Transparenzkanäle in Aktionssymbolen und dem kleinen Benachrichtigungssymbol. Mit anderen Worten: Android konvertiert alle Teile Ihres kleinen Benachrichtigungssymbols in Monochrom, mit Ausnahme transparenter Bereiche.

So erstellen Sie ein kleines Benachrichtigungssymbol-Asset, das korrekt angezeigt wird:

• Entfernen Sie alle Farben aus dem Bild außer Weiß.
• Alle anderen nicht-weißen Bereiche des Assets sollten transparent sein.

Hinweis

Ein häufiges Symptom eines fehlerhaften Assets ist, dass das kleine Benachrichtigungssymbol als einfarbiges monochromes Quadrat gerendert wird. Dies liegt daran, dass das Android-System keine transparenten Bereiche im kleinen Benachrichtigungssymbol-Asset finden kann.

Die folgenden abgebildeten großen und kleinen Symbole sind Beispiele für korrekt gestaltete Symbole:

Schritt 3: Benachrichtigungssymbole konfigurieren

Symbole in braze.xml angeben

Braze ermöglicht es Ihnen, Ihre Benachrichtigungssymbole zu konfigurieren, indem Sie Drawable-Ressourcen in Ihrer braze.xml angeben:

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>

Das Festlegen eines kleinen Benachrichtigungssymbols ist erforderlich. Wenn Sie keines festlegen, verwendet Braze standardmäßig das Anwendungssymbol als kleines Benachrichtigungssymbol, was möglicherweise nicht optimal aussieht.

Das Festlegen eines großen Benachrichtigungssymbols ist optional, wird aber empfohlen.

Akzentfarbe des Symbols angeben

Die Akzentfarbe des Benachrichtigungssymbols kann in Ihrer braze.xml überschrieben werden. Wenn keine Farbe angegeben wird, ist die Standardfarbe dasselbe Grau, das Lollipop für Systembenachrichtigungen verwendet.

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

Sie können optional auch eine Farbreferenz verwenden:

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

Schritt 4: Deeplinks hinzufügen

Automatisches Öffnen von Deeplinks aktivieren

Um Braze zu ermöglichen, Ihre App und alle Deeplinks automatisch zu öffnen, wenn eine Push-Benachrichtigung angeklickt wird, setzen Sie com_braze_handle_push_deep_links_automatically in Ihrer braze.xml auf true:

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

Dieses Flag kann auch über die Laufzeitkonfiguration gesetzt werden:

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

Wenn Sie Deeplinks benutzerdefiniert verarbeiten möchten, müssen Sie einen Push-Callback erstellen, der auf Push-Empfangs- und Öffnungs-Intents von Braze lauscht. Weitere Informationen finden Sie unter Einen Callback für Push-Ereignisse verwenden.

Vordergrund-Benachrichtigungen verarbeiten

Standardmäßig zeigt das System eine Push-Benachrichtigung automatisch an, wenn sie eintrifft, während Ihre App auf Android im Vordergrund ist. Damit Braze den Payload der Push-Benachrichtigung verarbeiten kann (für Analytics-Tracking, Deeplink-Verarbeitung und benutzerdefinierte Verarbeitung), leiten Sie die eingehenden Push-Daten in Ihrer FirebaseMessagingService.onMessageReceived-Methode an Braze weiter.

Funktionsweise

Wenn Sie BrazeFirebaseMessagingService.handleBrazeRemoteMessage aufrufen, prüft Braze, ob der Payload eine Braze-Push-Benachrichtigung ist, und erstellt und zeigt die Benachrichtigung gegebenenfalls mit der NotificationManagerCompat-Methode an. Anders als bei iOS zeigt Android Benachrichtigungen unabhängig davon an, ob sich die App im Vordergrund oder Hintergrund befindet.

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

Weitere Informationen finden Sie im Firebase-Integrationsbeispiel im Braze Android SDK-Repository.

Vordergrund-Verhalten anpassen

Wenn Sie ein benutzerdefiniertes Vordergrund-Verhalten wünschen, z. B. die Systembenachrichtigung unterdrücken oder stattdessen eine In-App-UI anzeigen möchten, können Sie Folgendes tun:

• Verwenden Sie subscribeToPushNotificationEvents, um auf Push-Ereignisse zu reagieren und Deeplinks mit der Methode BrazeNotificationUtils.routeUserWithNotificationOpenedIntent zu verarbeiten. Weitere Informationen finden Sie im Firebase-Push-Beispiel.
• Erstellen und veröffentlichen Sie Ihre eigene Benachrichtigung mit einer benutzerdefinierten IBrazeNotificationFactory, oder unterdrücken Sie die Benachrichtigung, indem Sie notificationManager.notify in Ihrem Verarbeitungspfad nicht aufrufen.

Weitere Informationen zum Anpassen von Benachrichtigungen finden Sie unter Benutzerdefinierte Benachrichtigungs-Factory.

Benutzerdefinierte Deeplinks erstellen

Folgen Sie den Anweisungen in der Android-Entwicklerdokumentation zum Deeplinking, falls Sie Ihrer App noch keine Deeplinks hinzugefügt haben. Weitere Informationen darüber, was Deeplinks sind, finden Sie in unserem FAQ-Artikel.

Deeplinks hinzufügen

Das Braze-Dashboard unterstützt das Festlegen von Deeplinks oder Web-URLs in Push-Benachrichtigungs-Campaigns und Canvases, die beim Klicken auf die Benachrichtigung geöffnet werden.

Back-Stack-Verhalten anpassen

Das Android SDK platziert standardmäßig die Hauptstartaktivität Ihrer Host-App im Back-Stack, wenn Push-Deeplinks verfolgt werden. Braze ermöglicht es Ihnen, eine benutzerdefinierte Aktivität festzulegen, die im Back-Stack anstelle Ihrer Hauptstartaktivität geöffnet wird, oder den Back-Stack vollständig zu deaktivieren.

Um beispielsweise eine Aktivität namens YourMainActivity als Back-Stack-Aktivität mithilfe der Laufzeitkonfiguration festzulegen:

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

Die entsprechende Konfiguration für Ihre braze.xml finden Sie unten. Beachten Sie, dass der Klassenname derselbe sein muss, der von Class.forName() zurückgegeben wird.

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>

Schritt 5: Benachrichtigungskanäle definieren

Das Braze Android SDK unterstützt Android-Benachrichtigungskanäle. Wenn eine Braze-Benachrichtigung keine ID für einen Benachrichtigungskanal enthält oder eine ungültige Kanal-ID enthält, zeigt Braze die Benachrichtigung mit dem im SDK definierten Standard-Benachrichtigungskanal an. Nutzer:innen verwenden Android-Benachrichtigungskanäle innerhalb der Plattform, um Benachrichtigungen zu gruppieren.

Um den für Nutzer:innen sichtbaren Namen des Standard-Braze-Benachrichtigungskanals festzulegen, verwenden Sie BrazeConfig.setDefaultNotificationChannelName().

Um die für Nutzer:innen sichtbare Beschreibung des Standard-Braze-Benachrichtigungskanals festzulegen, verwenden Sie BrazeConfig.setDefaultNotificationChannelDescription().

Aktualisieren Sie alle API-Campaigns mit dem Parameter Android-Push-Objekt, um das Feld notification_channel einzuschließen. Wenn dieses Feld nicht angegeben wird, sendet Braze den Benachrichtigungs-Payload mit der Dashboard-Fallback-Kanal-ID.

Abgesehen vom Standard-Benachrichtigungskanal erstellt Braze keine weiteren Kanäle. Alle anderen Kanäle müssen programmatisch von der Host-App definiert und dann im Braze-Dashboard eingetragen werden.

Der Standardkanalname und die Beschreibung können auch in braze.xml konfiguriert werden.

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>

Schritt 6: Benachrichtigungsanzeige und Analytics testen

Anzeige testen

An diesem Punkt sollten Sie Benachrichtigungen sehen können, die von Braze gesendet werden. Um dies zu testen, gehen Sie zur Seite Campaigns in Ihrem Braze-Dashboard und erstellen Sie eine Push Notification-Campaign. Wählen Sie Android Push und gestalten Sie Ihre Nachricht. Klicken Sie dann auf das Augensymbol im Composer, um den Testsender aufzurufen. Geben Sie die Nutzer-ID oder E-Mail-Adresse Ihrer/Ihres aktuellen Nutzer:in ein und klicken Sie auf Send Test. Die Push-Benachrichtigung sollte auf Ihrem Gerät erscheinen.

Bei Problemen mit der Push-Anzeige lesen Sie unseren Leitfaden zur Fehlerbehebung.

Analytics testen

An diesem Punkt sollte auch das Analytics-Logging für das Öffnen von Push-Benachrichtigungen funktionieren. Wenn Sie auf die Benachrichtigung klicken, sobald sie eintrifft, sollte der Wert für Direct Opens auf Ihrer Campaign-Ergebnisseite um 1 steigen. Lesen Sie unseren Artikel zu Push-Reporting für eine Aufschlüsselung der Push-Analytics.

Bei Problemen mit Push-Analytics lesen Sie unseren Leitfaden zur Fehlerbehebung.

Über die Befehlszeile testen

Wenn Sie In-App- und Push-Benachrichtigungen über die Befehlszeilenschnittstelle testen möchten, können Sie eine einzelne Benachrichtigung über das Terminal per cURL und die Messaging-API senden. Sie müssen die folgenden Felder durch die korrekten Werte für Ihren Testfall ersetzen:

• YOUR_API_KEY (Gehen Sie zu Settings > API Keys.)
• YOUR_EXTERNAL_USER_ID (Suchen Sie ein Profil auf der Seite Search Users.)
• YOUR_KEY1 (optional)
• YOUR_VALUE1 (optional)

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

Dieses Beispiel verwendet die US-01-Instanz. Wenn Sie sich nicht auf dieser Instanz befinden, ersetzen Sie den US-01-Endpunkt durch Ihren Endpunkt.

Push-Benachrichtigungen für Konversationen

Die People-and-Conversations-Initiative ist eine mehrjährige Android-Initiative, die darauf abzielt, Personen und Konversationen in den Systemoberflächen des Telefons hervorzuheben. Diese Priorisierung basiert auf der Tatsache, dass Kommunikation und Interaktion mit anderen Menschen für die Mehrheit der Android-Nutzer:innen über alle demografischen Gruppen hinweg nach wie vor der wichtigste und am meisten geschätzte Funktionsbereich ist.

Nutzungsvoraussetzungen

• Dieser Benachrichtigungstyp erfordert das Braze Android SDK v15.0.0+ und Geräte mit Android 11+.
• Nicht unterstützte Geräte oder SDKs fallen auf eine Standard-Push-Benachrichtigung zurück.

Dieses Feature ist nur über die Braze REST API verfügbar. Weitere Informationen finden Sie im Android-Push-Objekt.

FCM-Kontingent überschritten – Fehler

Wenn Ihr Limit für Firebase Cloud Messaging (FCM) überschritten wird, gibt Google Fehler vom Typ „Kontingent überschritten“ zurück. Das Standardlimit für FCM beträgt 600.000 Anfragen pro Minute. Braze versucht den Versand gemäß den von Google empfohlenen Best Practices erneut. Ein hohes Aufkommen dieser Fehler kann die Versandzeit jedoch um mehrere Minuten verlängern. Um mögliche Auswirkungen abzumildern, sendet Braze Ihnen eine Benachrichtigung, dass das Rate-Limit überschritten wird, sowie Schritte, die Sie unternehmen können, um die Fehler zu vermeiden.

Um Ihr aktuelles Limit zu überprüfen, navigieren Sie zu Google Cloud Console > APIs & Services > Firebase Cloud Messaging API > Quotas & System Limits, oder besuchen Sie die FCM-API-Kontingentseite.

Best Practices

Wir empfehlen diese Best Practices, um das Aufkommen dieser Fehler gering zu halten.

Eine Erhöhung des Rate-Limits bei FCM beantragen

Um eine Erhöhung des Rate-Limits bei FCM zu beantragen, können Sie sich direkt an den Firebase-Support wenden oder wie folgt vorgehen:

1. Navigieren Sie zur FCM-API-Kontingentseite.
2. Suchen Sie das Kontingent Send requests per minute.
3. Wählen Sie Edit Quota aus.
4. Geben Sie einen neuen Wert ein und senden Sie Ihre Anfrage ab.

Ein Workspace-Rate-Limit anwenden

Sie können ein Workspace-Rate-Limit für Android-Push-Benachrichtigungen anwenden. Dies kann dabei helfen, die Zustellrate Ihrer ausgehenden Nachrichten zu regulieren. Weitere Informationen finden Sie unter Workspace-Messaging-Rate-Limits.