Skip to content

Daten zu In-App-Nachrichten protokollieren

Erfahren Sie, wie Sie In-App-Nachricht-Daten (IAM) über das Braze SDK protokollieren können.

Voraussetzungen

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

Protokollierung von Nachrichten-Daten

Die Protokollierung der Impressionen und Klicks von In-App-Nachrichten erfolgt automatisch, wenn Sie die Methode showInAppMessage oder automaticallyShowInAppMessage verwenden.

Wenn Sie keine der beiden Methoden verwenden und sich dafür entscheiden, die Nachricht manuell über Ihren eigenen UI Code anzuzeigen, verwenden Sie die folgenden Methoden zur Protokollierung von Analytics:

1
2
3
4
5
6
7
8
// Registers that a user has viewed an in-app message with the Braze server.
braze.logInAppMessageImpression(inAppMessage);
// Registers that a user has clicked on the specified in-app message with the Braze server.
braze.logInAppMessageClick(inAppMessage);
// Registers that a user has clicked a specified in-app message button with the Braze server.
braze.logInAppMessageButtonClick(button, inAppMessage);
// Registers that a user has clicked on a link in an HTML in-app message with the Braze server.
braze.logInAppMessageHtmlClick(inAppMessage, buttonId?, url?)

Voraussetzungen

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

Protokollierung von Nachrichten-Daten

Um Analytics mit Ihrer BrazeInAppMessage zu protokollieren, übergeben Sie die Instanz an die gewünschte Analytics-Funktion:

  • logInAppMessageClicked
  • logInAppMessageImpression
  • logInAppMessageButtonClicked (zusammen mit dem Button-Index)

Zum Beispiel:

1
2
3
4
5
6
// Log a click
braze.logInAppMessageClicked(inAppMessage);
// Log an impression
braze.logInAppMessageImpression(inAppMessage);
// Log button index `0` being clicked
braze.logInAppMessageButtonClicked(inAppMessage, 0);

Zugriff auf Nachrichten-Daten

Für den Zugriff auf In-App-Nachrichten-Daten in Ihrer Flutter-App unterstützt das BrazePlugin das Senden von In-App-Nachrichten-Daten über Dart Streams.

Das BrazeInAppMessage-Objekt unterstützt eine Teilmenge der Felder, die in den nativen Modellobjekten verfügbar sind, darunter uri, message, header, buttons, extras und weitere.

Auf In-App-Nachrichten-Daten im Dart-Layer lauschen

Um In-App-Nachrichten-Daten im Dart-Layer zu empfangen, verwenden Sie den folgenden Code, um eine StreamSubscription zu erstellen und braze.subscribeToInAppMessages() aufzurufen. Denken Sie daran, das Stream-Abo mit cancel() zu beenden, wenn es nicht mehr benötigt wird.

1
2
3
4
5
6
7
8
9
// Create stream subscription
StreamSubscription inAppMessageStreamSubscription;

inAppMessageStreamSubscription = braze.subscribeToInAppMessages((BrazeInAppMessage inAppMessage) {
  // Handle in-app messages
}

// Cancel stream subscription
inAppMessageStreamSubscription.cancel();

Ein Beispiel finden Sie in main.dart in der Braze Flutter SDK Beispiel-App.

In-App-Nachrichten-Daten aus dem nativen Layer weiterleiten

In-App-Nachrichten-Daten werden automatisch von den nativen Android- und iOS-Layern weitergeleitet. Es ist keine zusätzliche Einrichtung erforderlich.

Wenn Sie Flutter SDK 17.1.0 oder älter verwenden, erfordert die Weiterleitung von In-App-Nachrichten-Daten aus dem nativen iOS-Layer eine manuelle Einrichtung. Ihre Anwendung enthält wahrscheinlich eine der folgenden Varianten. Um auf Flutter SDK 18.0.0 zu migrieren, entfernen Sie den Aufruf von BrazePlugin.processInAppMessage(_:) – die Datenweiterleitung wird jetzt automatisch gehandhabt.

Entfernen Sie den Aufruf von BrazePlugin.processInAppMessage(_:) aus Ihrer willPresent-Delegatenimplementierung.

Entfernen Sie den Aufruf von BrazePlugin.processInAppMessage(message) aus der present(message:)-Implementierung Ihres angepassten Presenters:

1
2
3
4
5
6
7
8
9
class CustomInAppMessagePresenter: BrazeInAppMessageUI {
  override func present(message: Braze.InAppMessage) {
    // Pass in-app message data to the Dart layer.
    BrazePlugin.processInAppMessage(message)

    // If you want the default UI to display the in-app message.
    super.present(message: message)
  }
}

Callback für In-App-Nachrichten erneut abspielen (optional)

Um alle In-App-Nachrichten zu speichern, die getriggert wurden, bevor der Callback verfügbar ist, und sie nach dem Setzen des Callbacks erneut abzuspielen, fügen Sie bei der Initialisierung des BrazePlugin den folgenden Eintrag in die customConfigs-Map ein:

1
BrazePlugin braze = new BrazePlugin(customConfigs: {replayCallbacksConfigKey: true});

Voraussetzungen

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

Methoden zur Protokollierung

Sie können diese Methoden nutzen, indem Sie Ihre BrazeInAppMessage-Instanz zur Protokollierung von Analytics und zur Durchführung von Aktionen übergeben:

Methode Beschreibung
logInAppMessageClicked(inAppMessage) Protokolliert einen Klick für die bereitgestellten Daten der In-App-Nachricht.
logInAppMessageImpression(inAppMessage) Protokolliert eine Impression für die bereitgestellten In-App-Nachricht-Daten.
logInAppMessageButtonClicked(inAppMessage, buttonId) Protokolliert einen Button-Klick für die angegebenen In-App-Nachricht-Daten und die Button-ID.
hideCurrentInAppMessage() Schließt die aktuell angezeigte In-App-Nachricht.
performInAppMessageAction(inAppMessage) Führt die Aktion für eine In-App-Nachricht aus.
performInAppMessageButtonAction(inAppMessage, buttonId) Führt die Aktion für einen Button einer In-App-Nachricht aus.

Umgang mit Nachrichten-Daten

In den meisten Fällen können Sie die Methode Braze.addListener verwenden, um Event-Listener zu registrieren, die Daten aus In-App-Nachrichten verarbeiten.

Außerdem können Sie auf die Daten der In-App-Nachricht im JavaScript-Layer zugreifen, indem Sie die Methode Braze.subscribeToInAppMessage aufrufen, damit die SDKs ein inAppMessageReceived-Event veröffentlichen, wenn eine In-App-Nachricht getriggert wird. Übergeben Sie einen Callback an diese Methode, um Ihren eigenen Code auszuführen, wenn die In-App-Nachricht getriggert und vom Listener empfangen wird.

Um die Behandlung von Nachrichten-Daten anzupassen, sehen Sie sich die folgenden Implementierungsbeispiele an:

Um das Standardverhalten zu verbessern oder wenn Sie keinen Zugang zur Anpassung des nativen iOS- oder Android-Codes haben, empfehlen wir Ihnen, die Standard-UI zu deaktivieren, während Sie weiterhin In-App-Nachrichten-Events von Braze erhalten. Um die Standard-UI zu deaktivieren, übergeben Sie false an die Methode Braze.subscribeToInAppMessage und verwenden Sie die Daten der In-App-Nachricht, um Ihre eigene Nachricht in JavaScript zu erstellen. Beachten Sie, dass Sie Analytics für Ihre Nachrichten manuell protokollieren müssen, wenn Sie die Standard-UI deaktivieren möchten.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import Braze from "@braze/react-native-sdk";

// Option 1: Listen for the event directly via `Braze.addListener`.
//
// You may use this method to accomplish the same thing if you don't
// wish to make any changes to the default Braze UI.
Braze.addListener(Braze.Events.IN_APP_MESSAGE_RECEIVED, (event) => {
  console.log(event.inAppMessage);
});

// Option 2: Call `subscribeToInAppMessage`.
//
// Pass in `false` to disable the automatic display of in-app messages.
Braze.subscribeToInAppMessage(false, (event) => {
  console.log(event.inAppMessage);
  // Use `event.inAppMessage` to construct your own custom message UI.
});

Um eine fortgeschrittenere Logik einzubauen, die bestimmt, ob eine In-App-Nachricht über die integrierte UI angezeigt wird oder nicht, implementieren Sie In-App-Nachrichten über den nativen Layer.

Implementieren Sie IInAppMessageManagerListener wie in unserem Android-Artikel über angepasste Manager-Listener beschrieben. In Ihrer beforeInAppMessageDisplayed-Implementierung können Sie auf die Daten von inAppMessage zugreifen, sie an den JavaScript-Layer senden und anhand des Rückgabewerts entscheiden, ob Sie die native Nachricht anzeigen oder nicht.

Mehr über diese Werte erfahren Sie in unserer Android-Dokumentation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// In-app messaging
@Override
public InAppMessageOperation beforeInAppMessageDisplayed(IInAppMessage inAppMessage) {
    WritableMap parameters = new WritableNativeMap();
    parameters.putString("inAppMessage", inAppMessage.forJsonPut().toString());
    getReactNativeHost()
        .getReactInstanceManager()
        .getCurrentReactContext()
        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
        .emit("inAppMessageReceived", parameters);
    // Note: return InAppMessageOperation.DISCARD if you would like
    // to prevent the Braze SDK from displaying the message natively.
    return InAppMessageOperation.DISPLAY_NOW;
}

Überschreiben des Standard-UI-Delegaten

Standardmäßig wird BrazeInAppMessageUI erstellt und zugewiesen, wenn Sie die Instanz braze initialisieren. BrazeInAppMessageUI ist eine Implementierung des BrazeInAppMessagePresenter-Protokolls und verfügt über die Eigenschaft delegate, mit der Sie die Behandlung von empfangenen In-App-Nachrichten anpassen können.

  1. Implementieren Sie den Delegaten BrazeInAppMessageUIDelegate wie in diesem iOS-Artikel beschrieben.

  2. In der Delegate-Methode inAppMessage(_:displayChoiceForMessage:) können Sie auf die Daten von inAppMessage zugreifen, sie an den JavaScript-Layer senden und anhand des Rückgabewerts entscheiden, ob die native Nachricht angezeigt werden soll oder nicht.

Weitere Einzelheiten zu diesen Werten finden Sie in unserer iOS-Dokumentation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
- (enum BRZInAppMessageUIDisplayChoice)inAppMessage:(BrazeInAppMessageUI *)ui
                            displayChoiceForMessage:(BRZInAppMessageRaw *)message {
  // Convert the message to a JavaScript representation.
  NSData *inAppMessageData = [message json];
  NSString *inAppMessageString = [[NSString alloc] initWithData:inAppMessageData encoding:NSUTF8StringEncoding];
  NSDictionary *arguments = @{
    @"inAppMessage" : inAppMessageString
  };

  // Send to JavaScript.
  [self sendEventWithName:@"inAppMessageReceived" body:arguments];

  // Note: Return `BRZInAppMessageUIDisplayChoiceDiscard` if you would like
  // to prevent the Braze SDK from displaying the message natively.
  return BRZInAppMessageUIDisplayChoiceNow;
}

Um diesen Delegaten zu verwenden, weisen Sie ihn brazeInAppMessagePresenter.delegate zu, nachdem Sie die Instanz braze initialisiert haben.

1
2
3
4
5
6
7
8
@import BrazeUI;

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:apiKey endpoint:endpoint];
  Braze *braze = [BrazeReactBridge initBraze:configuration];
  ((BrazeInAppMessageUI *)braze.inAppMessagePresenter).delegate = [[CustomDelegate alloc] init];
  AppDelegate.braze = braze;
}

Native Standard-UI überschreiben

Wenn Sie die Darstellung Ihrer In-App-Nachrichten auf der nativen iOS-Ebene vollständig anpassen möchten, halten Sie sich an das BrazeInAppMessagePresenter-Protokoll und weisen Sie Ihren angepassten Presenter nach dem folgenden Beispiel zu:

1
2
3
4
BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:apiKey endpoint:endpoint];
Braze *braze = [BrazeReactBridge initBraze:configuration];
braze.inAppMessagePresenter = [[MyCustomPresenter alloc] init];
AppDelegate.braze = braze;

Voraussetzungen

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

Protokollierung von Nachrichten-Daten

Um die Analytics für Ihre Kampagne zu verarbeiten, müssen Sie sicherstellen, dass bestimmte Funktionen aufgerufen werden.

Angezeigte Nachrichten

Wenn eine Nachricht angezeigt oder gesehen wird, protokollieren Sie eine Impression:

1
LogInAppMessageImpression(in_app_message.id, brazetask)

Angeklickte Nachrichten

Sobald ein Nutzer auf die Nachricht klickt, protokollieren Sie einen Klick und verarbeiten dann in_app_message.click_action:

1
LogInAppMessageClick(in_app_message.id, brazetask)

Angeklickte Buttons

Wenn der Nutzer auf einen Button klickt, protokollieren Sie den Button-Klick und verarbeiten dann inappmessage.buttons[selected].click_action:

1
LogInAppMessageButtonClick(inappmessage.id, inappmessage.buttons[selected].id, brazetask)

Nach der Verarbeitung einer Nachricht

Nach der Verarbeitung einer In-App-Nachricht, sollten Sie das Feld löschen:

1
m.BrazeTask.BrazeInAppMessage = invalid

In-App-Nachrichten abonnieren

Sie können Unity Spielobjekte registrieren, um über eingehende In-App-Nachrichten benachrichtigt zu werden. Wir empfehlen Ihnen, Spielobjekt-Listener über den Braze-Konfigurationseditor einzustellen. Im Konfigurationseditor müssen die Hörer für Android und iOS getrennt eingestellt werden.

Wenn Sie den Spielobjekt-Listener zur Laufzeit konfigurieren müssen, verwenden Sie AppboyBinding.ConfigureListener() und geben Sie BrazeUnityMessageType.IN_APP_MESSAGE an.

Parsing von Nachrichten

Eingehende string Nachrichten, die in Ihrem In-App-Nachricht Spielobjekt Callback empfangen werden, können der Einfachheit halber in unsere vorgefertigten Modellobjekte geparst werden.

Verwenden Sie InAppMessageFactory.BuildInAppMessage(), um Ihre In-App-Nachricht zu analysieren. Das resultierende Objekt ist entweder eine Instanz von IInAppMessage.cs oder IInAppMessageImmersive.cs abhängig von seinem Typ.

1
2
3
4
5
6
7
8
9
10
// Automatically logs a button click, if present.
void InAppMessageReceivedCallback(string message) {
  IInAppMessage inApp = InAppMessageFactory.BuildInAppMessage(message);
  if (inApp is IInAppMessageImmersive) {
    IInAppMessageImmersive inAppImmersive = inApp as IInAppMessageImmersive;
    if (inAppImmersive.Buttons != null && inAppImmersive.Buttons.Count > 0) {
      inAppImmersive.LogButtonClicked(inAppImmersive.Buttons[0].ButtonID);
    }
  }
}

Protokollierung von Nachrichten-Daten

Klicks und Impressionen müssen für In-App-Nachrichten, die nicht direkt von Braze angezeigt werden, manuell protokolliert werden.

Verwenden Sie LogClicked() und LogImpression() auf IInAppMessage, um Klicks und Impressionen auf die Nachricht zu protokollieren.

Verwenden Sie LogButtonClicked(int buttonID) auf IInAppMessageImmersive, um Klicks auf Buttons zu protokollieren. Beachten Sie, dass die Buttons als Listen von InAppMessageButton-Instanzen dargestellt werden, von denen jede eine ButtonID enthält.

New Stuff!