Skip to content

In-App-Nachrichten triggern

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

Nachrichten-Trigger und Zustellung

In-App-Nachrichten werden getriggert, 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 Eigenschaftsfilter).

Zu Beginn einer Nutzer:innen-Sitzung stellt Braze alle berechtigten In-App-Nachrichten auf deren Gerät zu und lädt gleichzeitig Assets vorab, um die Anzeigelatenz zu minimieren. Wenn das Trigger-Event mehr als eine berechtigte In-App-Nachricht hat, wird nur die Nachricht mit der höchsten Priorität zugestellt. Weitere Informationen finden Sie unter Sitzungslebenszyklus.

Arten von In-App-Nachrichten

Braze sendet die folgenden Arten 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 vorlagenbasiert aufbereitet, wie z. B. angepassten Attributen, die Braze bereits kennt. Wenn die In-App-Nachricht auf das Gerät heruntergeladen wird, bewirkt das Trigger-Event 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 (vorlagenbasiert)

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

In-App-Nachrichten werden als vorlagenbasierte In-App-Nachrichten zugestellt, wenn Campaign-Berechtigung 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 erhält, nicht die gesamte Nachricht. Wenn Nutzer:innen die In-App-Nachricht triggern, stellt ihr 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-Nachricht-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 angepasste Logik, um die Darstellung einer In-App-Nachricht basierend auf ihren Schlüssel-Wert-Paaren in extras festzulegen. Ein vollständiges Anpassungsbeispiel 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.
  }
}

Automatische Trigger deaktivieren

Standardmäßig werden In-App-Nachrichten automatisch getriggert. So deaktivieren Sie dies:

Entfernen Sie den Aufruf von braze.automaticallyShowInAppMessages() aus Ihrem Lade-Snippet und erstellen Sie dann eine angepasste Logik, um die Anzeige einer In-App-Nachricht zu steuern.

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 Nachrichtentimings, einschließlich des Zurückstellens und Wiederherstellens getriggerter Nachrichten, lesen Sie unser Tutorial: Getriggerte Nachrichten zurückstellen und wiederherstellen.

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

Für eine erweiterte Steuerung des Nachrichtentimings, einschließlich späterer Anzeige und erneutem Einreihen in die Warteschlange, lesen Sie unsere Seite Nachrichten anpassen.

  1. Implementieren Sie den BrazeInAppMessageUIDelegate-Delegate in Ihrer App. Eine vollständige Anleitung finden Sie unter Tutorial: In-App Message UI.
  2. Aktualisieren Sie Ihre inAppMessage(_:displayChoiceForMessage:)-Delegate-Methode, sodass sie .discard zurückgibt.

Für eine erweiterte Steuerung des Nachrichtentimings, einschließlich des Zurückstellens und Wiederherstellens getriggerter Nachrichten, lesen Sie unser Tutorial: Getriggerte Nachrichten zurückstellen und wiederherstellen.

  1. Stellen Sie sicher, dass Sie den automatischen Integrations-Initializer verwenden, der in den Versionen 2.2.0 und höher standardmäßig aktiviert ist.
  2. Setzen Sie die Standard-Operation für In-App-Nachrichten auf DISCARD, indem Sie die folgende Zeile zu Ihrer braze.xml-Datei hinzufügen. 
    1

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

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

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

Legen Sie für iOS die Spielobjekt-Listener im Braze-Konfigurationseditor fest 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“ festgelegt werden.

Verkettung zweier In-App-Nachrichten in einer Sitzung

Sie können eine In-App-Nachricht beim Sitzungsstart triggern und dann eine zweite In-App-Nachricht triggern, nachdem ein Button in der ersten 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 sich bereits auf dem Gerät befinden (die Nutzer:innen müssen bereits für die zweite Nachricht qualifiziert sein) und auf der Geräteseite ausgelöst werden (das Braze SDK übernimmt keine Änderungen an angepassten Attributen, die auf den Braze-Servern vorgenommen werden). Der standardmäßige 30-Sekunden-Cooldown zwischen In-App-Nachricht-Triggern muss angepasst werden, um mehrere In-App-Nachrichten in schneller Folge anzuzeigen. Informationen zur plattformspezifischen Konfiguration finden Sie unter Überschreiben des Standard-Rate-Limits.

Überschreiben des Standard-Rate-Limits

Standardmäßig begrenzt das SDK getriggerte In-App-Nachrichten auf einmal alle 30 Sekunden. Um dies zu überschreiben, 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 sind 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 angezeigt werden. Wenn bereits eine In-App-Nachricht 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 Triggern von Nachrichten

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

Verwenden eines serverseitigen Events

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

Um eine In-App-Nachricht über ein vom Server gesendetes Event zu triggern, senden Sie eine stille Push-Benachrichtigung an das Gerät, die es einem angepassten Push-Callback ermöglicht, ein SDK-basiertes Event zu protokollieren. Dieses Event triggert dann die für Nutzer:innen sichtbare In-App-Nachricht.

Schritt 1: Push-Callback erstellen, um die stille Push-Benachrichtigung zu empfangen

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

Zwei Events werden protokolliert, damit die In-App-Nachricht zugestellt wird: eines vom Server und eines aus Ihrem angepassten Push-Callback heraus. Um sicherzustellen, dass dasselbe Event nicht dupliziert wird, sollte das aus Ihrem Push-Callback heraus protokollierte Event einer generischen Namenskonvention folgen, zum Beispiel „In-App-Nachricht-Trigger-Event“, und nicht denselben Namen wie das vom Server gesendete Event tragen. Wenn dies nicht beachtet wird, können Segmentierung und Nutzerdaten durch doppelt protokollierte Events für eine einzelne Nutzeraktion beeinträchtigt 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)
    }
}

Schritt 2: Push-Campaign erstellen

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

Zustellungsschritt einer stillen Push-Campaign, konfiguriert für aktionsbasierte Zustellung mit einem angepassten Event-Trigger „server_event“.

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

Zwei Schlüssel-Wert-Paare: IS_SERVER_EVENT auf „true“ gesetzt und CAMPAIGN_NAME auf „example campaign name“ gesetzt.

Der oben gezeigte Push-Callback-Beispielcode erkennt die Schlüssel-Wert-Paare und protokolliert das entsprechende angepasste SDK-Event.

Wenn Sie Event-Eigenschaften an Ihr „In-App-Nachricht-Trigger“-Event anhängen möchten, können Sie dies erreichen, indem Sie diese in den Schlüssel-Wert-Paaren des Push-Payloads übergeben. In diesem Beispiel wurde der Campaign-Name der nachfolgenden In-App-Nachricht einbezogen. Ihr angepasster Push-Callback kann dann den Wert als Parameter der Event-Eigenschaft übergeben, wenn das angepasste Event protokolliert wird.

Schritt 3: In-App-Nachricht-Campaign erstellen

Erstellen Sie Ihre für Nutzer:innen sichtbare In-App-Nachricht-Campaign im Braze-Dashboard. Diese Campaign sollte eine aktionsbasierte Zustellung haben und durch das angepasste Event getriggert werden, das aus Ihrem angepassten Push-Callback heraus protokolliert wird.

Im folgenden Beispiel wurde die spezifische In-App-Nachricht, die getriggert werden soll, konfiguriert, indem die Event-Eigenschaft als Teil des initialen stillen Push gesendet wurde.

Eine aktionsbasierte Zustellungs-Campaign, bei der eine In-App-Nachricht getriggert wird, wenn „campaign_name“ gleich „IAM campaign name example“ ist.

Wenn ein vom Server gesendetes Event protokolliert wird, während die App nicht im Vordergrund ist, 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, muss eine Prüfung in Ihrem angepassten Push-Empfänger enthalten sein, um das Event zu verwerfen oder zu verzögern, bis die App in den Vordergrund gewechselt hat.

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

Implementieren Sie die folgende Funktion und rufen Sie sie innerhalb 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"]}];
  }
};

Wenn die stille Push-Benachrichtigung empfangen wird, wird ein vom SDK aufgezeichnetes Event „In-App-Nachricht-Trigger“ gegen das Nutzerprofil protokolliert.

Schritt 2: Stille Push-Campaign erstellen

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

Eine aktionsbasierte Zustellungs-In-App-Nachricht-Campaign, die an Nutzer:innen zugestellt wird, deren Nutzerprofile das angepasste Event „server_event“ aufweisen.

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

Eine aktionsbasierte Zustellungs-In-App-Nachricht-Campaign mit zwei Schlüssel-Wert-Paaren. „CAMPAIGN_NAME“ auf „In-app message name example“ gesetzt und „IS_SERVER_EVENT“ auf „true“ gesetzt.

Der Code innerhalb der application(_:didReceiveRemoteNotification:fetchCompletionHandler:)-Methode 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 innerhalb der Schlüssel-Wert-Paar-Extras des Push-Payloads senden. Beim Protokollieren des angepassten Events können diese Extras als Parameter entweder des Event-Namens oder als Event-Eigenschaft verwendet werden.

Schritt 3: In-App-Nachricht-Campaign erstellen

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

Im folgenden Beispiel wurde die spezifische In-App-Nachricht, die getriggert werden soll, konfiguriert, indem die Event-Eigenschaft als Teil des initialen stillen Push gesendet wurde.

Eine aktionsbasierte Zustellungs-In-App-Nachricht-Campaign, die an Nutzer:innen zugestellt wird, die das angepasste Event „In-app message trigger“ ausführen, wobei „campaign_name“ gleich „IAM Campaign Name Example“ ist.

Anzeigen einer vordefinierten Nachricht

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

Verwenden Sie für das Web SDK braze.showInAppMessage(inAppMessage), um eine beliebige In-App-Nachricht anzuzeigen. Details und ein Beispiel finden Sie unter Nachricht in Realtime anzeigen.

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)
}

Nachricht in Realtime anzeigen

Sie können auch lokale In-App-Nachrichten in Realtime erstellen und anzeigen, wobei dieselben Anpassungsoptionen wie im Dashboard zur Verfügung stehen. Gehen Sie dazu wie folgt vor:

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 Anzeigeaktion für die In-App-Nachricht gewählt wird.

1

Appboy.AppboyBinding.DisplayNextInAppMessage();

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

Wenn Sie eine In-App-Nachricht-Campaign einige Sekunden nach Sitzungsbeginn erhalten, kann die Verzögerung folgende Ursachen haben:

  • Eine Verzögerung beim Campaign-Trigger
  • Anpassungen
  • Das Trigger-Event wurde später als erwartet aufgezeichnet (z. B. bei einem templated_iam)

Exit-Intent-Nachrichten für Web

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

Um Trigger für diese Nachrichtentypen im Web-SDK einzurichten, implementieren Sie eine Exit-Intent-Bibliothek auf Ihrer Website (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. Ihre zukünftigen In-App-Nachricht-Campaigns können diesen Nachrichtentyp dann als Trigger für ein angepasstes Event verwenden.

1
2
3

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