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:
logInAppMessageClickedlogInAppMessageImpressionlogInAppMessageButtonClicked(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.

Da es sich hierbei um eine fortgeschrittene Anpassungsoption handelt, beachten Sie bitte, dass durch das Überschreiben der Standard-Implementierung von Braze auch die Logik zum Senden von In-App-Nachrichten-Events an Ihre JavaScript-Listener aufgehoben wird. Wenn Sie weiterhin Braze.subscribeToInAppMessage oder Braze.addListener verwenden möchten, wie unter Zugriff auf In-App-Nachrichten-Daten beschrieben, müssen Sie die Veröffentlichung der Events selbst übernehmen.
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.
-
Implementieren Sie den Delegaten
BrazeInAppMessageUIDelegatewie in diesem iOS-Artikel beschrieben. -
In der Delegate-Methode
inAppMessage(_:displayChoiceForMessage:)können Sie auf die Daten voninAppMessagezugreifen, 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.

BrazeUI kann nur in Objective-C oder Swift importiert werden. Wenn Sie Objective-C++ verwenden, müssen Sie dies in einer separaten Datei behandeln.
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.