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 zu sehen, die FCM mit dem Braze Android SDK verwendet, besuchen Sie Braze: Firebase Push Sample App.

Rate-Limits

Die Firebase Cloud Messaging (FCM) API hat ein standardmäßiges Rate-Limit von 600.000 Anfragen pro Minute. Wenn Sie dieses Limit erreichen, versucht Braze es automatisch in wenigen 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-Einrichtungsleitfaden.

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

Fügen Sie als Nächstes die Cloud-Messaging-Bibliothek zu den Abhängigkeiten Ihres Projekts 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-Tokens durchführen kann. Navigieren Sie in Google Cloud zu Service Accounts und wählen Sie dann 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 eingeschränkteren Zugriff erstellen Sie eine benutzerdefinierte Rolle mit der Berechtigung cloudmessaging.messages.create und wählen Sie diese stattdessen aus der Liste aus. Wenn Sie fertig sind, wählen Sie Done.

Warnung

Stellen Sie sicher, dass Sie Firebase Cloud Messaging API Admin auswählen, nicht Firebase Cloud Messaging Admin.

Schritt 5: JSON-Zugangsdaten generieren

Generieren Sie als Nächstes JSON-Zugangsdaten für Ihr FCM-Dienstkonto. Navigieren Sie unter Google Cloud IAM & Admin zu Service Accounts und wählen Sie dann 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 unbedingt, wohin Sie den Schlüssel heruntergeladen haben—Sie benötigen ihn im nächsten Schritt.

Warnung

Private Schlüssel können bei Kompromittierung ein Sicherheitsrisiko darstellen. 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  Einstellungen > App-Einstellungen.

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 Schlüssel können bei Kompromittierung ein Sicherheitsrisiko darstellen. Da Ihr Schlüssel jetzt 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 anmelden, 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 jedes Gerät Ihrer Nutzer:innen in den Braze-Konfigurationsdateien Ihres Projekts aktivieren.

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

Wählen Sie Cloud Messaging und kopieren Sie dann 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-Tokens 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 im 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 anderem Weg erhält, setzen Sie registeredPushToken manuell, wie im vorherigen Tipp gezeigt.

Wichtig

Firebase Cloud Messaging bietet keine unterstützte API zum Abrufen eines Tokens aus 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
• vorhandener
• nicht-braze

Braze enthält einen Service 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 Öffnungs- und Klick-Aktions-Tracking zu verarbeiten. Dieser Service muss in der AndroidManifest.xml registriert werden, 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 weitere Services separat registrieren, um Benachrichtigungen von anderen FCM-Services zu rendern. 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 benutzerdefiniertem Firebase Messaging Service registrieren

Wenn Sie firebase-messaging v25.1.0 oder höher verwenden, nutzt die Firebase-Registrierung die Firebase-Installations-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 eine Push-Benachrichtigung empfängt, die 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 Design-Richtlinien anpassen

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

Ab Android N sollten Sie kleine Benachrichtigungssymbol-Assets, die Farben 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 mit Ausnahme von 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 dargestellt wird. Dies liegt daran, dass das Android-System keine transparenten Bereiche im kleinen Benachrichtigungssymbol-Asset finden kann.

Die folgenden 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 durch die Angabe von Drawable-Ressourcen in Ihrer braze.xml zu konfigurieren:

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>

Die Angabe eines kleinen Benachrichtigungssymbols ist erforderlich. Wenn Sie keines festlegen, verwendet Braze standardmäßig das App-Symbol als kleines Benachrichtigungssymbol, was möglicherweise nicht optimal aussieht.

Die Angabe eines großen Benachrichtigungssymbols ist optional, wird aber empfohlen.

Akzentfarbe des Symbols festlegen

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>

Optional können Sie 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 das automatische Öffnen Ihrer App und aller Deeplinks beim Klicken auf eine Push-Benachrichtigung zu ermöglichen, 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

Wenn eine Push-Benachrichtigung unter Android eintrifft, während Ihre App im Vordergrund ist, zeigt das System sie standardmäßig automatisch an. Damit Braze den Payload der Push-Benachrichtigung verarbeitet (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 es sich beim Payload um eine Braze-Push-Benachrichtigung handelt, 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-Integrations-Beispiel im Braze Android SDK Repository.

Vordergrundverhalten anpassen

Wenn Sie ein benutzerdefiniertes Vordergrundverhalten wünschen, z. B. die Systembenachrichtigung unterdrücken oder stattdessen eine In-App-Oberfläche anzeigen, können Sie Folgendes tun:

• Verwenden Sie subscribeToPushNotificationEvents, um auf Push-Ereignisse zu reagieren, und die Methode BrazeNotificationUtils.routeUserWithNotificationOpenedIntent, um Deeplinks 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. Um mehr darüber zu erfahren, was Deeplinks sind, lesen Sie unseren 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 aufgerufen werden. Braze ermöglicht es Ihnen, eine benutzerdefinierte Aktivität festzulegen, die anstelle Ihrer Hauptstartaktivität im Back-Stack geöffnet wird, oder den Back-Stack vollständig zu deaktivieren.

Um beispielsweise eine Aktivität namens YourMainActivity als Back-Stack-Aktivität über die 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 finden Sie in Ihrer braze.xml. Beachten Sie, dass der Klassenname mit dem von Class.forName() zurückgegebenen übereinstimmen muss.

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 aufweist, 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 Kanal-ID des Dashboard-Fallbacks.

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

Der Standard-Kanalname 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 aktuellen Nutzerin bzw. Ihres aktuellen Nutzers 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 beim Eintreffen klicken, sollte der Wert für Direct Opens auf Ihrer Campaign-Ergebnisseite um 1 steigen. Weitere Informationen zu Push-Analytics finden Sie in unserem Artikel zu Push-Berichten.

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

Über die Befehlszeile testen

Wenn Sie In-App- und Push-Benachrichtigungen über die Befehlszeile testen möchten, können Sie eine einzelne Benachrichtigung über das Terminal mit cURL und der 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 auf der Seite Search Users nach einem Profil.)
• 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 Unterhaltungen

Die People-and-Conversations-Initiative ist eine mehrjährige Android-Initiative, die darauf abzielt, Personen und Unterhaltungen auf den Systemoberflächen des Telefons hervorzuheben. Diese Priorisierung basiert auf der Tatsache, dass die Kommunikation und Interaktion mit anderen Menschen nach wie vor der wertvollste und wichtigste Funktionsbereich für die Mehrheit der Android-Nutzer:innen über alle demografischen Gruppen hinweg 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 standardmäßige 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überschreitungsfehler

Wenn Ihr Limit für Firebase Cloud Messaging (FCM) überschritten wird, gibt Google „Kontingent überschritten“-Fehler 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 Volumen dieser Fehler kann die Zustellzeit jedoch um mehrere Minuten verlängern. Um mögliche Auswirkungen abzumildern, sendet Braze Ihnen eine Benachrichtigung, dass das Rate-Limit überschritten wird, sowie Maßnahmen, die Sie ergreifen können, um die Fehler zu vermeiden.

Um Ihr aktuelles Limit zu überprüfen, gehen 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 die folgenden Best Practices, um das Volumen dieser Fehler gering zu halten.

Eine Rate-Limit-Erhöhung bei FCM beantragen

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

1. Gehen 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 helfen, die Zustellrate Ihrer ausgehenden Nachrichten zu regulieren. Weitere Informationen finden Sie unter Workspace-Messaging-Rate-Limits.