Zum Inhalt springen

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 Braze Web 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:

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

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

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

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:

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 verwenden, indem Sie Ihre BrazeInAppMessage-Instanz übergeben, um Analytics zu protokollieren und Aktionen auszuführen:

Methode Beschreibung
logInAppMessageClicked(inAppMessage) Protokolliert einen Klick für die bereitgestellten In-App-Nachrichten-Daten.
logInAppMessageImpression(inAppMessage) Protokolliert eine Impression für die bereitgestellten In-App-Nachrichten-Daten.
logInAppMessageButtonClicked(inAppMessage, buttonId) Protokolliert einen Button-Klick für die bereitgestellten In-App-Nachrichten-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 In-App-Nachrichten-Button aus.

Verarbeitung von 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.

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

Informationen zur Anpassung der Verarbeitung von Nachrichten-Daten finden Sie in den folgenden Implementierungsbeispielen:

Um das Standardverhalten zu verbessern oder wenn Sie keinen Zugriff auf die Anpassung des nativen iOS- oder Android-Codes haben, empfehlen wir, die Standard-UI zu deaktivieren und gleichzeitig In-App-Nachrichten-Events von Braze zu empfangen. Um die Standard-UI zu deaktivieren, übergeben Sie false an die Methode Braze.subscribeToInAppMessage und verwenden Sie die In-App-Nachrichten-Daten, 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.

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 fortgeschrittenere Logik einzubauen, die bestimmt, ob eine In-App-Nachricht über die integrierte UI angezeigt werden soll oder nicht, implementieren Sie In-App-Nachrichten über den nativen Layer.

Implementieren Sie den IInAppMessageManagerListener wie in unserem Android-Artikel über Custom Manager Listener beschrieben. In Ihrer beforeInAppMessageDisplayed-Implementierung können Sie auf die inAppMessage-Daten zugreifen, diese an den JavaScript-Layer senden und basierend auf dem Rückgabewert entscheiden, ob die native Nachricht angezeigt werden soll oder nicht.

Weitere Informationen zu diesen Werten finden Sie in unserer Android-Dokumentation.

// 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 braze-Instanz initialisieren. BrazeInAppMessageUI ist eine Implementierung des BrazeInAppMessagePresenter-Protokolls und verfügt über eine delegate-Eigenschaft, die zur Anpassung der Verarbeitung empfangener In-App-Nachrichten verwendet werden kann.

  1. Implementieren Sie den BrazeInAppMessageUIDelegate-Delegaten wie in unserem iOS In-App-Nachrichten-UI-Tutorial beschrieben.

  2. In der Delegaten-Methode inAppMessage(_:displayChoiceForMessage:) können Sie auf die inAppMessage-Daten zugreifen, diese an den JavaScript-Layer senden und basierend auf dem Rückgabewert entscheiden, ob die native Nachricht angezeigt werden soll oder nicht.

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

- (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 nach der Initialisierung der braze-Instanz brazeInAppMessagePresenter.delegate zu.

@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;
}

Überschreiben der nativen Standard-UI

Wenn Sie die Darstellung Ihrer In-App-Nachrichten auf dem nativen iOS-Layer vollständig anpassen möchten, implementieren Sie das BrazeInAppMessagePresenter-Protokoll und weisen Sie Ihren angepassten Presenter wie in diesem Beispiel zu:

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:

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:

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:

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:

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.

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