Skip to content

In-App-Nachrichten triggern

Erfahren Sie, wie Sie In-App-Nachrichten über das Braze SDK triggern können.

Auslöser und Zustellung von Nachrichten

In-App-Nachrichten werden ausgelöst, wenn das SDK einen der folgenden angepassten Event-Typen protokolliert: Session Start, Push Click, Any Purchase, Specific Purchase und Custom Event (die letzten beiden enthalten robuste Filter für Eigenschaften).

Zu Beginn der Sitzung einer Nutzerin oder eines Nutzers stellt Braze alle in Frage kommenden In-App-Nachrichten auf deren Gerät zu, während gleichzeitig Assets vorab abgerufen werden, um die Anzeige-Latenz zu minimieren. Wenn das triggernde Ereignis mehr als eine in Frage kommende In-App-Nachricht hat, wird nur die Nachricht mit der höchsten Priorität zugestellt. Weitere Informationen finden Sie unter Session Lifecycle.

Typen von In-App-Nachrichten

Braze sendet die folgenden Typen von In-App-Nachrichten beim Sitzungsstart an die Geräte der Nutzer:innen: inapp und templated_iam. Als Dashboard-Nutzer:in sehen Sie die verschiedenen Typen nicht, aber Braze behandelt sie je nach Einrichtung und Inhalt unterschiedlich.

inapp (Standard)

Eine inapp- (oder „Standard“-) In-App-Nachricht ist bereits mit den erforderlichen Informationen vorausgefüllt, wie z. B. angepassten Attributen, die Braze bereits kennt. Wenn die In-App-Nachricht auf das Gerät heruntergeladen wird, bewirkt das triggernde Ereignis in der Regel, dass das SDK die inapp-In-App-Nachricht anzeigt, auch wenn das Gerät offline ist oder sich im Flugmodus befindet.

templated_iam (Templated)

Eine templated_iam- (oder „Templated“-) In-App-Nachricht ist noch nicht mit den erforderlichen Informationen vorausgefüllt. Braze muss eine weitere Anfrage stellen, um die Informationen abzurufen, bevor die Nachricht angezeigt werden kann.

In-App-Nachrichten werden als Template-basierte In-App-Nachrichten zugestellt, wenn Kampagnenberechtigung vor der Anzeige erneut prüfen ausgewählt ist oder wenn einer der folgenden Liquid-Tags in der Nachricht vorhanden ist:

  • canvas_entry_properties
  • connected_content
  • SMS-Variablen wie {sms.${*}}
  • catalog_items
  • catalog_selection_items
  • event_properties

Das bedeutet, dass das Gerät beim Sitzungsstart den Trigger dieser In-App-Nachricht anstelle der gesamten Nachricht erhält. Wenn Nutzer:innen die In-App-Nachricht triggern, stellt das Gerät eine Netzwerkanfrage, um die eigentliche Nachricht abzurufen.

Schlüssel-Wert-Paare

Wenn Sie eine Campaign in Braze erstellen, können Sie Schlüssel-Wert-Paare als extras festlegen, die das In-App-Messaging-Objekt verwenden kann, um Daten an Ihre App zu senden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import * as braze from "@braze/web-sdk";

braze.subscribeToInAppMessage(function(inAppMessage) {
  // control group messages should always be "shown"
  // this will log an impression and not show a visible message
  if (inAppMessage instanceof braze.ControlMessage) {
    return braze.showInAppMessage(inAppMessage);
  }


  if (inAppMessage instanceof braze.InAppMessage) {
    const extras = inAppMessage.extras;
    if (extras) {
      for (const key in extras) {
        console.log("key: " + key + ", value: " + extras[key]);
      }
    }
  }
  braze.showInAppMessage(inAppMessage);
});

1

Map<String, String> getExtras()

1

extras: Map<String, String>

Das folgende Beispiel verwendet eine angepasste Logik, um die Darstellung einer In-App-Nachricht auf der Grundlage ihrer Schlüssel-Wert-Paare in extras festzulegen. Ein Beispiel für eine vollständige Anpassung finden Sie in unserer Beispiel-App.

1
2
3
4

let customization = message.extras["custom-display"] as? String
if customization == "colorful-slideup" {
  // Perform your custom logic.
}

1
2
3
4
5
6

if ([message.extras[@"custom-display"] isKindOfClass:[NSString class]]) {
  NSString *customization = message.extras[@"custom-display"];
  if ([customization isEqualToString:@"colorful-slideup"]) {
    // Perform your custom logic.
  }
}

Deaktivieren von automatischen Triggern

In-App-Nachrichten werden standardmäßig automatisch getriggert. Um dies zu deaktivieren:

Entfernen Sie den Aufruf von braze.automaticallyShowInAppMessages() in Ihrem Lade-Snippet und erstellen Sie dann eine angepasste Logik für die Anzeige oder Nichtanzeige einer In-App-Nachricht.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

braze.subscribeToInAppMessage(function(inAppMessage) {
  // control group messages should always be "shown"
  // this will log an impression and not show a visible message

  if (inAppMessage.isControl) { // v4.5.0+, otherwise use  `inAppMessage instanceof braze.ControlMessage`
     return braze.showInAppMessage(inAppMessage);
  }

  // Display the in-app message. You could defer display here by pushing this message to code within your own application.
  // If you don't want to use the display capabilities in Braze, you could alternatively pass the in-app message to your own display code here.

  if ( should_show_the_message_according_to_your_custom_logic ) {
      braze.showInAppMessage(inAppMessage);
  } else {
      // do nothing
  }
});

Für eine erweiterte Steuerung des Nachrichtenzeitplans, einschließlich des Aufschiebens und Wiederherstellens getriggerter Nachrichten, lesen Sie bitte unser Tutorial: Aufschieben und Wiederherstellen von getriggerten Nachrichten.

  1. Implementieren Sie den IInAppMessageManagerListener, um einen angepassten Listener festzulegen.
  2. Aktualisieren Sie Ihre beforeInAppMessageDisplayed()-Methode, um InAppMessageOperation.DISCARD zurückzugeben.

Für eine erweiterte Steuerung des Nachrichtenzeitplans, einschließlich der Anzeige zu einem späteren Zeitpunkt und der erneuten Einreihung in die Warteschlange, konsultieren Sie bitte unsere Seite Anpassen von Nachrichten.

  1. Implementieren Sie den Delegaten BrazeInAppMessageUIDelegate in Ihrer App. Eine vollständige Anleitung finden Sie unter Tutorial: In-App-Nachricht UI.
  2. Aktualisieren Sie die Delegate-Methode inAppMessage(_:displayChoiceForMessage:), um .discard zurückzugeben.

Für eine erweiterte Steuerung des Nachrichtenzeitplans, einschließlich des Aufschiebens und Wiederherstellens getriggerter Nachrichten, lesen Sie bitte unser Tutorial: Aufschieben und Wiederherstellen von getriggerten Nachrichten.

  1. Überprüfen Sie, ob Sie die automatische Initialisierung der Integration verwenden, die in den Versionen 2.2.0 und höher standardmäßig aktiviert ist.
  2. Setzen Sie die Standardeinstellung für In-App-Nachrichten auf DISCARD, indem Sie die folgende Zeile in Ihre Datei braze.xml einfügen. 
    1

     <string name="com_braze_flutter_automatic_integration_iam_operation">DISCARD</string>

Für Android deaktivieren Sie die Option Automatically Display In-App Messages im Braze-Konfigurationseditor. Alternativ können Sie com_braze_inapp_show_inapp_messages_automatically auf false in der Datei braze.xml Ihres Unity-Projekts setzen.

Die anfängliche Anzeigeoperation für In-App-Nachrichten kann in der Braze-Konfiguration über „In App Message Manager Initial Display Operation“ eingestellt werden.

Für iOS stellen Sie Spielobjekt-Listener im Braze-Konfigurationseditor ein und stellen Sie sicher, dass Braze Displays In-App Messages nicht ausgewählt ist.

Die anfängliche Anzeigeoperation für In-App-Nachrichten kann in der Braze-Konfiguration über „In App Message Manager Initial Display Operation“ eingestellt werden.

Zwei In-App-Nachrichten in einer Sitzung verketten

Sie können eine In-App-Nachricht beim Sitzungsstart triggern und dann eine zweite In-App-Nachricht auslösen, nachdem ein Button in der ersten Nachricht gedrückt wurde. Protokollieren Sie dazu ein angepasstes Event für den Button-Klick, das die zweite Nachricht triggert. Der Trigger für die zweite Nachricht muss bereits auf dem Gerät vorhanden sein (die Nutzerin oder der Nutzer muss bereits für die zweite Nachricht berechtigt sein) und auf der Geräteseite auftreten (das Braze SDK übernimmt keine Änderungen an angepassten Attributen, die auf Braze-Servern vorgenommen werden). Der standardmäßige 30-Sekunden-Cooldown zwischen In-App-Nachrichten-Triggern muss angepasst werden, um mehrere In-App-Nachrichten in schneller Folge anzuzeigen. Informationen zur plattformspezifischen Konfiguration finden Sie unter Außerkraftsetzen des Standard-Rate-Limits.

Außerkraftsetzen des Standard-Rate-Limits

Standardmäßig begrenzt das SDK getriggerte In-App-Nachrichten auf einmal alle 30 Sekunden. Um dies außer Kraft zu setzen, fügen Sie die folgende Eigenschaft zu Ihrer Konfigurationsdatei hinzu, bevor die Braze-Instanz initialisiert wird. Dieser Wert wird als neues Rate-Limit in Sekunden verwendet.

Setzen Sie diesen Wert bei Produktions-Apps nicht unter 10 Sekunden, damit Nutzer:innen nicht mit aufeinanderfolgenden In-App-Nachrichten überhäuft werden. Für Tests und Beispiel-App-Abläufe ist ein Wert von 5 Sekunden eine gängige Einstellung.

Sie können dieses Intervall zu Testzwecken auf 0 setzen. Ein Intervall von 0 Sekunden erzwingt jedoch nicht, dass mehrere In-App-Nachrichten gleichzeitig erscheinen. Wenn eine In-App-Nachricht bereits sichtbar ist, wird eine weitere getriggerte Nachricht erst angezeigt, nachdem die aktuelle Nachricht geschlossen wurde.

1
2

// Sets the minimum time interval between triggered in-app messages to 5 seconds instead of the default 30
braze.initialize('YOUR-API-KEY', { minimumIntervalBetweenTriggerActionsInSeconds: 5 })

1

<integer name="com_braze_trigger_action_minimum_time_interval_seconds">5</integer>

1
2
3
4
5
6
7
8

let configuration = Braze.Configuration(
  apiKey: "YOUR-APP-IDENTIFIER-API-KEY",
  endpoint: "YOUR-BRAZE-ENDPOINT"
)
// Sets the minimum trigger time interval to 5 seconds
configuration.triggerMinimumTimeInterval = 5
let braze = Braze(configuration: configuration)
AppDelegate.braze = braze

1
2
3
4
5
6
7

BRZConfiguration *configuration =
    [[BRZConfiguration alloc] initWithApiKey:@"<BRAZE_API_KEY>"
                                    endpoint:@"<BRAZE_ENDPOINT>"];
// Sets the minimum trigger time interval to 5 seconds
configuration.triggerMinimumTimeInterval = 5;
Braze *braze = [BrazePlugin initBraze:configuration];
AppDelegate.braze = braze;

Manuelles Auslösen von Nachrichten

Standardmäßig werden In-App-Nachrichten automatisch getriggert, wenn das SDK ein angepasstes Event protokolliert. Darüber hinaus können Sie Nachrichten aber auch manuell triggern, indem Sie die folgenden Methoden verwenden.

Ein serverseitiges Ereignis verwenden

Derzeit unterstützt das Web Braze SDK das manuelle Triggern von Nachrichten über serverseitige Ereignisse nicht.

Um eine In-App-Nachricht über ein vom Server gesendetes Ereignis auszulösen, senden Sie eine stille Push-Benachrichtigung an das Gerät, die einen angepassten Push-Callback zur Protokollierung eines SDK-basierten Ereignisses ermöglicht. Dieses Ereignis triggert dann die In-App-Nachricht für die Nutzer:innen.

1. Schritt: Erstellen Sie einen Push-Callback, um den stillen Push zu empfangen

Registrieren Sie Ihren angepassten Push-Callback, um auf eine bestimmte stille Push-Benachrichtigung zu warten. Weitere Informationen finden Sie unter Push-Benachrichtigungen einrichten.

Für die zuzustellende In-App-Nachricht werden zwei Events protokolliert, eines vom Server und eines von Ihrem angepassten Push-Callback. Um sicherzustellen, dass dasselbe Event nicht doppelt vorkommt, sollte das von Ihrem Push-Callback protokollierte Event einer generischen Namenskonvention folgen, z. B. „In-App-Nachricht triggern“, und nicht denselben Namen tragen wie das vom Server gesendete Event. Andernfalls können die Segmentierung und die Nutzerdaten dadurch beeinträchtigt werden, dass für eine einzelne Nutzeraktion doppelte Ereignisse protokolliert werden.

1
2
3
4
5
6
7
8
9
10
11

Braze.getInstance(context).subscribeToPushNotificationEvents(event -> {
  final Bundle kvps = event.getNotificationPayload().getBrazeExtras();
  if (kvps.containsKey("IS_SERVER_EVENT")) {
    BrazeProperties eventProperties = new BrazeProperties();

    // The campaign name is a string extra that clients can include in the push
    String campaignName = kvps.getString("CAMPAIGN_NAME");
    eventProperties.addProperty("campaign_name", campaignName);
    Braze.getInstance(context).logCustomEvent("IAM Trigger", eventProperties);
  }
});

1
2
3
4
5
6
7
8
9
10
11

Braze.getInstance(applicationContext).subscribeToPushNotificationEvents { event ->
    val kvps = event.notificationPayload.brazeExtras
    if (kvps.containsKey("IS_SERVER_EVENT")) {
        val eventProperties = BrazeProperties()

        // The campaign name is a string extra that clients can include in the push
        val campaignName = kvps.getString("CAMPAIGN_NAME")
        eventProperties.addProperty("campaign_name", campaignName)
        Braze.getInstance(applicationContext).logCustomEvent("IAM Trigger", eventProperties)
    }
}

2. Schritt: Erstellen Sie eine Push-Kampagne

Erstellen Sie eine stille Push-Kampagne, die über das vom Server gesendete Event getriggert wird.

Die Push-Kampagne muss Schlüssel-Wert-Paare enthalten, die angeben, dass diese Push-Kampagne gesendet wird, um ein angepasstes SDK-Event zu protokollieren. Dieses Event wird verwendet, um die In-App-Nachricht zu triggern.

Zwei Sätze von Schlüssel-Wert-Paaren: IS_SERVER_EVENT auf „true“ gesetzt und CAMPAIGN_NAME auf „Beispielname der Kampagne“ gesetzt.

Der frühere Code für den Push-Callback erkennt die Schlüssel-Wert-Paare und protokolliert das entsprechende angepasste SDK-Event.

Wenn Sie Ihrem „In-App-Nachricht triggern“-Event Event-Eigenschaften hinzufügen möchten, können Sie diese in den Schlüssel-Wert-Paaren des Push-Payloads übergeben. In diesem Beispiel wurde der Campaign-Name der nachfolgenden In-App-Nachricht eingefügt. Ihr angepasster Push-Callback kann dann bei der Protokollierung des angepassten Events den Wert als Parameter der Event-Eigenschaft übergeben.

3. Schritt: In-App-Kampagne erstellen

Erstellen Sie Ihre für Nutzer:innen sichtbare In-App-Nachrichten-Kampagne im Braze-Dashboard. Diese Kampagne sollte eine aktionsbasierte Zustellung haben und durch das angepasste Event ausgelöst werden, das in Ihrem Push-Callback protokolliert wird.

Im folgenden Beispiel wurde die zu triggernde In-App-Nachricht konfiguriert, indem die Event-Eigenschaft im Rahmen des ursprünglichen stillen Push gesendet wurde.

Eine aktionsbasierte Zustellung, bei der eine In-App-Nachricht ausgelöst wird, wenn „campaign_name“ gleich „IAM-Kampagnenname Beispiel“ ist.

Wenn ein vom Server gesendetes Event protokolliert wird, während sich die App nicht im Vordergrund befindet, wird das Event protokolliert, aber die In-App-Nachricht wird nicht angezeigt. Wenn Sie möchten, dass das Event verzögert wird, bis die Anwendung im Vordergrund ist, müssen Sie in Ihrem angepassten Push-Empfänger eine Prüfung einbauen, um das Event zu verwerfen oder zu verzögern, bis die App in den Vordergrund getreten ist.

1. Schritt: Stille Push-Benachrichtigungen und Schlüssel-Wert-Paare verarbeiten

Implementieren Sie die folgende Funktion und rufen Sie sie in der application(_:didReceiveRemoteNotification:fetchCompletionHandler:)-Methode auf:

1
2
3
4
5
6

func handleExtras(userInfo: [AnyHashable : Any]) {
  print("A push was received")
  if userInfo != nil && (userInfo["IS_SERVER_EVENT"] as? String) != nil && (userInfo["CAMPAIGN_NAME"] as? String) != nil {
    AppDelegate.braze?.logCustomEvent("IAM Trigger", properties: ["campaign_name": userInfo["CAMPAIGN_NAME"]])
  }
}

1
2
3
4
5
6

- (void)handleExtrasFromPush:(NSDictionary *)userInfo {
  NSLog(@"A push was received.");
  if (userInfo !=nil && userInfo[@"IS_SERVER_EVENT"] !=nil && userInfo[@"CAMPAIGN_NAME"]!=nil) {
    [AppDelegate.braze logCustomEvent:@"IAM Trigger" properties:@{@"campaign_name": userInfo[@"CAMPAIGN_NAME"]}];
  }
};

Beim Empfang einer stillen Push-Benachrichtigung wird ein vom SDK aufgezeichnetes Event des Typs „In-App-Nachrichten-Trigger“ im Nutzerprofil protokolliert.

2. Schritt: Erstellen Sie eine stille Push-Kampagne

Erstellen Sie eine stille Push-Kampagne, die über das vom Server gesendete Event ausgelöst wird.

Eine aktionsbasierte Zustellung von In-App-Nachrichten, die an Nutzer:innen zugestellt wird, deren Nutzerprofile das angepasste Event „server_event“ enthalten.

Die Push-Kampagne muss zusätzliche Schlüssel-Wert-Paare (Extras) enthalten, die angeben, dass diese Push-Kampagne gesendet wird, um ein angepasstes SDK-Event zu protokollieren. Dieses Event wird verwendet, um die In-App-Nachricht zu triggern.

Eine aktionsbasierte Zustellung von In-App-Nachrichten mit zwei Schlüssel-Wert-Paaren. „CAMPAIGN_NAME“ auf „Beispiel für den Namen der In-App-Nachricht“ gesetzt und „IS_SERVER_EVENT“ auf „true“ gesetzt.

Der Code in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:) prüft auf den Schlüssel IS_SERVER_EVENT und protokolliert ein angepasstes SDK-Event, wenn dieser vorhanden ist.

Sie können entweder den Event-Namen oder die Event-Eigenschaften ändern, indem Sie den gewünschten Wert in den zusätzlichen Schlüssel-Wert-Paaren (Extras) der Push-Nutzlast senden. Bei der Protokollierung des angepassten Events können diese Extras entweder als Parameter des Event-Namens oder der Event-Eigenschaft verwendet werden.

3. Schritt: In-App-Kampagne erstellen

Erstellen Sie im Braze-Dashboard eine für Ihre Nutzer:innen sichtbare In-App-Nachrichten-Kampagne. Diese Kampagne sollte eine aktionsbasierte Zustellung haben und durch das angepasste Event ausgelöst werden, das in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:) protokolliert wird.

Im folgenden Beispiel wurde die zu triggernde In-App-Nachricht konfiguriert, indem die Event-Eigenschaft im Rahmen des ursprünglichen stillen Push gesendet wurde.

Eine aktionsbasierte Zustellung von In-App-Nachrichten, die an Nutzer:innen zugestellt wird, die das angepasste Event „In-App-Nachrichtenauslöser“ ausführen, wobei „campaign_name“ gleich „IAM-Kampagnenname Beispiel“ ist.

Anzeige einer vordefinierten Nachricht

Um eine vordefinierte In-App-Nachricht manuell anzuzeigen, verwenden Sie die folgende Methode:

Für das Web SDK verwenden Sie braze.showInAppMessage(inAppMessage), um jede In-App-Nachricht anzuzeigen. Weitere Informationen und ein Beispiel finden Sie unter Anzeige einer Nachricht in Realtime.

1

BrazeInAppMessageManager.getInstance().addInAppMessage(inAppMessage);

1

BrazeInAppMessageManager.getInstance().addInAppMessage(inAppMessage)

1
2
3

if let inAppMessage = AppDelegate.braze?.inAppMessagePresenter?.nextAvailableMessage() {
  AppDelegate.braze?.inAppMessagePresenter?.present(message: inAppMessage)
}

Anzeige einer Nachricht in Realtime

Sie können auch In-App-Nachrichten in Realtime erstellen und anzeigen, indem Sie dieselben Anpassungsoptionen nutzen, die auch auf dem Dashboard zur Verfügung stehen. Um dies zu tun:

1
2
3
4

  // Displays a slideup type in-app message.
  var message = new braze.SlideUpMessage("Welcome to Braze! This is an in-app message.");
  message.slideFrom = braze.InAppMessage.SlideFrom.TOP;
  braze.showInAppMessage(message);

1
2
3

// Initializes a new slideup type in-app message and specifies its message.
InAppMessageSlideup inAppMessage = new InAppMessageSlideup();
inAppMessage.setMessage("Welcome to Braze! This is a slideup in-app message.");

1
2
3

// Initializes a new slideup type in-app message and specifies its message.
val inAppMessage = InAppMessageSlideup()
inAppMessage.message = "Welcome to Braze! This is a slideup in-app message."

Rufen Sie manuell die present(message:)-Methode auf Ihrem inAppMessagePresenter auf. Zum Beispiel:

1
2
3
4

let customInAppMessage = Braze.InAppMessage.slideup(
  .init(message: "YOUR_CUSTOM_SLIDEUP_MESSAGE", slideFrom: .bottom, themes: .defaults)
)
AppDelegate.braze?.inAppMessagePresenter?.present(message: customInAppMessage)

1
2
3
4
5
6
7
8
9

BRZInAppMessageRaw *customInAppMessage = [[BRZInAppMessageRaw alloc] init];
customInAppMessage.type = BRZInAppMessageRawTypeSlideup;
customInAppMessage.message = @"YOUR_CUSTOM_SLIDEUP_MESSAGE";
customInAppMessage.slideFrom = BRZInAppMessageRawSlideFromBottom;
customInAppMessage.themes = @{
  @"light": BRZInAppMessageRawTheme.defaultLight,
  @"dark": BRZInAppMessageRawTheme.defaultDark
};
[AppDelegate.braze.inAppMessagePresenter presentMessage:customInAppMessage];

Um die nächste Nachricht im Stack anzuzeigen, verwenden Sie die Methode DisplayNextInAppMessage(). Nachrichten werden in diesem Stack gespeichert, wenn DISPLAY_LATER oder BrazeUnityInAppMessageDisplayActionType.IAM_DISPLAY_LATER als Aktion zur Anzeige von In-App-Nachrichten gewählt wurde.

1

Appboy.AppboyBinding.DisplayNextInAppMessage();

Ursachen für Verzögerungen bei In-App-Nachrichten

Wenn Sie eine In-App-Nachrichten-Kampagne einige Sekunden nach dem Sitzungsstart erhalten, kann die Verzögerung folgende Ursachen haben:

  • Eine Verzögerung beim Kampagnen-Trigger
  • Anpassungen
  • Das triggernde Ereignis wurde später als erwartet aufgezeichnet (z. B. bei einer templated_iam)

Exit-Intent-Nachrichten für das Web

Exit-Intent-Nachrichten sind nicht-störende In-App-Nachrichten, die verwendet werden, um Besuchern wichtige Informationen mitzuteilen, bevor sie Ihre Website verlassen.

Um Trigger für diese Nachrichtentypen im Web SDK einzurichten, implementieren Sie eine Exit-Intent-Bibliothek in Ihrer Website (wie z. B. die Open-Source-Bibliothek von ouibounce) und verwenden Sie dann den folgenden Code, um 'exit intent' als angepasstes Event in Braze zu protokollieren. Jetzt können Ihre zukünftigen In-App-Nachrichten-Campaigns diesen Nachrichtentyp als angepassten Event-Trigger verwenden.

1
2
3

  var _ouibounce = ouibounce(false, {
    callback: function() { braze.logCustomEvent('exit intent'); }
  });
New Stuff!