Analytics protokollieren

Beim Erstellen einer angepassten UI für Content Cards müssen Sie Analytics wie Impressionen, Klicks und Ausblendungen manuell protokollieren, da dies nur für Standard-Kartenmodelle automatisch erfolgt. Die Protokollierung dieser Ereignisse ist ein Standardbestandteil der Integration von Content Cards und für eine genaue Campaign-Berichterstattung und Abrechnung unerlässlich. Füllen Sie dazu Ihre angepasste UI mit Daten aus den Braze-Datenmodellen und protokollieren Sie die Ereignisse anschließend manuell. Sobald Sie wissen, wie man Analytics protokolliert, können Sie sehen, wie Braze-Kund:innen häufig angepasste Content Cards erstellen.

Analytics protokollieren

Wenn Sie Ihre angepassten Content Cards implementieren, können Sie die Content-Card-Objekte parsen und deren Nutzlastdaten wie title, cardDescription und imageUrl extrahieren. Anschließend können Sie die resultierenden Modelldaten verwenden, um Ihre angepasste UI zu befüllen.

Um die Content-Card-Datenmodelle zu erhalten, abonnieren Sie Content-Card-Updates. Dabei gibt es zwei Eigenschaften, auf die Sie besonders achten sollten:

• id: Repräsentiert den Content-Card-ID-String. Dies ist der eindeutige Bezeichner, der verwendet wird, um Analytics von angepassten Content Cards zu protokollieren.
• extras: Umfasst alle Schlüssel-Wert-Paare aus dem Braze-Dashboard.

Alle Eigenschaften außerhalb von id und extras sind beim Parsen für angepasste Content Cards optional. Weitere Informationen zum Datenmodell finden Sie im Integrationsartikel der jeweiligen Plattform: Android, iOS, Web.

• web
• android
• swift
• react native

Registrieren Sie eine Callback-Funktion mit subscribeToContentCardsEvents(), um die zwischengespeicherten Cards zu erhalten und Updates zu empfangen, wenn Cards aktualisiert werden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

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

// - Available in version 7.0.0+
braze.subscribeToContentCardsEvents((event) => {
  switch (event.type) {
    case braze.ChannelEventType.CACHE_REPLAY:
    case braze.ChannelEventType.CACHE_LOAD:
    case braze.ChannelEventType.DATA_UPDATED: {
      const cards = event.cacheSnapshot.contentCards.cards;
      // For example:
      cards.forEach(card => {
        if (card.isControl) {
          // Do not display the control card, but remember to call `logContentCardImpressions([card])`
        }
        else if (card instanceof braze.ClassicCard || card instanceof braze.CaptionedImage) {
          // Use `card.title`, `card.imageUrl`, etc.
        }
        else if (card instanceof braze.ImageOnly) {
          // Use `card.imageUrl`, etc.
        }
      });
      break;
    }
    case braze.ChannelEventType.ERROR:
      // Check `event.reason` and `event.retryState`
      break;
  }
});

braze.subscribeToContentCardsUpdates((updates) => {
  const cards = updates.cards;
// For example:
  cards.forEach(card => {
    if (card.isControl) {
      // Do not display the control card, but remember to call `logContentCardImpressions([card])`
    }
    else if (card instanceof braze.ClassicCard || card instanceof braze.CaptionedImage) {
      // Use `card.title`, `card.imageUrl`, etc.
    }
    else if (card instanceof braze.ImageOnly) {
      // Use `card.imageUrl`, etc.
    }
  })
});

braze.openSession();

Verwenden Sie subscribeToContentCardsEvents ab Web SDK 7.0.0 und höher. subscribeToContentCardsUpdates ist das ältere Muster, das ab Version 7.0.0 als veraltet gilt.

Hinweis

Content Cards werden nur beim Sitzungsstart aktualisiert, wenn eine Abonnement-Anfrage vor openSession() aufgerufen wird. Sie können den Feed auch manuell aktualisieren.

Eine vollständige Liste der Events, die Sie empfangen können, finden Sie unter Content-Card erstellen.

• java
• kotlin

Schritt 1: Erstellen Sie eine private Subscriber-Variable

Um Card-Events zu abonnieren, deklarieren Sie zunächst eine private Variable in Ihrer angepassten Klasse, die Ihren Subscriber hält:

1
2
3
4

// - Available in version 44.0.0+
private IEventSubscriber<ContentCardsEvent> mContentCardsEventSubscriber;

private IEventSubscriber<ContentCardsUpdatedEvent> mContentCardsUpdatedSubscriber;

Schritt 2: Events abonnieren

Fügen Sie als Nächstes den folgenden Code hinzu, um Content-Card-Events von Braze zu abonnieren, typischerweise innerhalb der Activity.onCreate()-Methode Ihrer angepassten Content-Cards-Activity:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// - Available in version 44.0.0+
// Remove the previous subscriber before rebuilding a new one with our new activity.
Braze.getInstance(context).removeSingleSubscription(mContentCardsEventSubscriber, ContentCardsEvent.class);
mContentCardsEventSubscriber = new IEventSubscriber<ContentCardsEvent>() {
    @Override
    public void trigger(ContentCardsEvent event) {
        if (event instanceof ContentCardsEvent.CacheReplay) {
            handleCards(((ContentCardsEvent.CacheReplay) event).getCacheSnapshot());
        } else if (event instanceof ContentCardsEvent.CacheLoad) {
            handleCards(((ContentCardsEvent.CacheLoad) event).getCacheSnapshot());
        } else if (event instanceof ContentCardsEvent.DataUpdated) {
            handleCards(((ContentCardsEvent.DataUpdated) event).getCacheSnapshot());
        }
    }
};
Braze.getInstance(context).subscribeToContentCardsEvents(mContentCardsEventSubscriber);
Braze.getInstance(context).requestContentCardsRefresh();

// Remove the previous subscriber before rebuilding a new one with our new activity.
Braze.getInstance(context).removeSingleSubscription(mContentCardsUpdatedSubscriber, ContentCardsUpdatedEvent.class);
mContentCardsUpdatedSubscriber = new IEventSubscriber<ContentCardsUpdatedEvent>() {
    @Override
    public void trigger(ContentCardsUpdatedEvent event) {
        List<Card> allCards = event.getAllCards();
    }
};
Braze.getInstance(context).subscribeToContentCardsUpdates(mContentCardsUpdatedSubscriber);
Braze.getInstance(context).requestContentCardsRefresh();

private void handleCards(ContentCardsCacheSnapshot cacheSnapshot) {
    List<Card> allCards = cacheSnapshot.getCards();
}

Schritt 3: Abonnement kündigen

Wir empfehlen außerdem, das Abonnement zu kündigen, wenn Ihre angepasste Activity nicht mehr sichtbar ist. Fügen Sie den folgenden Code zur onDestroy()-Lifecycle-Methode Ihrer Activity hinzu:

1
2
3
4

// - Available in version 44.0.0+
Braze.getInstance(context).removeSingleSubscription(mContentCardsEventSubscriber, ContentCardsEvent.class);

Braze.getInstance(context).removeSingleSubscription(mContentCardsUpdatedSubscriber, ContentCardsUpdatedEvent.class);

Schritt 1: Erstellen Sie eine private Subscriber-Variable

Um Card-Events zu abonnieren, deklarieren Sie zunächst eine private Variable in Ihrer angepassten Klasse, die Ihren Subscriber hält:

1
2
3
4

// - Available in version 44.0.0+
private var contentCardsEventSubscriber: IEventSubscriber<ContentCardsEvent>? = null

private var contentCardsUpdatedSubscriber: IEventSubscriber<ContentCardsUpdatedEvent>? = null

Schritt 2: Events abonnieren

Fügen Sie als Nächstes den folgenden Code hinzu, um Content-Card-Events von Braze zu abonnieren, typischerweise innerhalb der Activity.onCreate()-Methode Ihrer angepassten Content-Cards-Activity:

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

// - Available in version 44.0.0+
// Remove the previous subscriber before rebuilding a new one with our new activity.
Braze.getInstance(context).removeSingleSubscription(contentCardsEventSubscriber, ContentCardsEvent::class.java)
contentCardsEventSubscriber = IEventSubscriber { event ->
    when (event) {
        is ContentCardsEvent.CacheReplay -> handleCards(event.cacheSnapshot)
        is ContentCardsEvent.CacheLoad -> handleCards(event.cacheSnapshot)
        is ContentCardsEvent.DataUpdated -> handleCards(event.cacheSnapshot)
        else -> {}
    }
}
Braze.getInstance(context).subscribeToContentCardsEvents(contentCardsEventSubscriber)
Braze.getInstance(context).requestContentCardsRefresh()

// Remove the previous subscriber before rebuilding a new one with our new activity.
Braze.getInstance(context).removeSingleSubscription(contentCardsUpdatedSubscriber, ContentCardsUpdatedEvent::class.java)
contentCardsUpdatedSubscriber = IEventSubscriber { event ->
    val allCards = event.allCards
}
Braze.getInstance(context).subscribeToContentCardsUpdates(contentCardsUpdatedSubscriber)
Braze.getInstance(context).requestContentCardsRefresh()

private fun handleCards(cacheSnapshot: ContentCardsCacheSnapshot) {
    val allCards = cacheSnapshot.cards
}

Schritt 3: Abonnement kündigen

Wir empfehlen außerdem, das Abonnement zu kündigen, wenn Ihre angepasste Activity nicht mehr sichtbar ist. Fügen Sie den folgenden Code zur onDestroy()-Lifecycle-Methode Ihrer Activity hinzu:

1
2
3
4

// - Available in version 44.0.0+
Braze.getInstance(context).removeSingleSubscription(contentCardsEventSubscriber, ContentCardsEvent::class.java)

Braze.getInstance(context).removeSingleSubscription(contentCardsUpdatedSubscriber, ContentCardsUpdatedEvent::class.java)

Informationen darüber, wann jedes Event ausgelöst wird und was die einzelnen Update-Gründe, Retry-Zustände, Analytics-Aktionen und Fehlergründe bedeuten, finden Sie unter Event-Abonnements.

Verwenden Sie subscribeToContentCardsEvents ab Android SDK 44.0.0 und höher. subscribeToContentCardsUpdates ist das ältere Muster, das ab Version 44.0.0 als veraltet gilt.

Um auf das Content-Cards-Datenmodell zuzugreifen, rufen Sie contentCards.cards auf Ihrer braze-Instanz auf.

• swift
• objective-c

1

let cards: [Braze.ContentCard] = AppDelegate.braze?.contentCards.cards

Hinweis

Das Lesen von contentCards.cards, contentCards.unviewedCards oder contentCards.lastUpdate blockiert den aufrufenden Thread, bis das SDK seine Operationen nach der Initialisierung abgeschlossen hat. Verwenden Sie die nicht-blockierenden Getter unter Nicht-blockierende Snapshot-Zugriffe für Kontexte auf dem Main-Thread oder bei Latenzempfindlichkeit.

Darüber hinaus können Sie auch Content-Card-Events abonnieren, um Cache-Änderungen, Analytics und Fehler zu beobachten. Dafür gibt es zwei Möglichkeiten:

1. Ein Cancellable verwalten; oder
2. Einen AsyncStream verwalten.

Cancellable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// - Available in version 19.0.0+
// This subscription is maintained through a Braze cancellable, which will observe for events until the subscription is cancelled.
// You must keep a strong reference to the cancellable to keep the subscription active.
// The subscription is canceled either when the cancellable is deinitialized or when you call its `.cancel()` method.
let cancellable = AppDelegate.braze?.contentCards.subscribeToEvents { [weak self] event in
  switch event {
  case .cacheReplay(let cacheSnapshot):
    // Initial cache snapshot, delivered immediately after subscribing
    break
  case .cacheLoad(let cacheSnapshot):
    // Cache loaded at the start of a user session (for example, after `changeUser()`)
    break
  case .dataUpdated(let cacheSnapshot, let reason):
    // Cache changed after the initial replay
    break
  case .impressionEvent(let card, let action):
    break
  case .clickEvent(let card, let action):
    break
  case .dismissEvent(let card, let action):
    break
  case .error(let reason, let retryState):
    break
  }
}

let cancellable = AppDelegate.braze?.contentCards.subscribeToUpdates { [weak self] contentCards in
  // Implement your completion handler to respond to updates in `contentCards`.
}

AsyncStream

1
2
3
4
5
6
7
8

// - Available in version 19.0.0+
Task {
  for await event in AppDelegate.braze?.contentCards.eventsStream ?? AsyncStream { _ in } {
    // Same switch statement as the cancellable example above.
  }
}

let stream: AsyncStream<[Braze.ContentCard]> = AppDelegate.braze?.contentCards.cardsStream

Verwenden Sie subscribeToEvents(_:) oder eventsStream ab Swift SDK 19.0.0 und höher. subscribeToUpdates(_:) und cardsStream sind das ältere Muster, das ab Version 19.0.0 als veraltet gilt.

Informationen darüber, wann jedes Event ausgelöst wird und was die einzelnen Update-Gründe, Retry-Zustände, Analytics-Aktionen und Fehlergründe bedeuten, finden Sie unter Event-Abonnements.

Nicht-blockierende Snapshot-Zugriffe

Verwenden Sie diese Methoden, um den aktuellen Cache-Zustand zu lesen, ohne den aufrufenden Thread zu blockieren. Jeder Completion-Handler wird immer auf dem Main-Thread ausgeliefert.

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

// All cached cards.
AppDelegate.braze?.contentCards.getCachedContentCards { cards in
  // Use `cards` here.
}

// Unviewed cards only (excludes control cards).
AppDelegate.braze?.contentCards.getUnviewedCards { cards in
  // Use `cards` here.
}

// Date of the last server sync for the current user (nil until the first sync completes).
AppDelegate.braze?.contentCards.getLastUpdate { date in
  // Use `date` here.
}

1

NSArray<BRZContentCardRaw *> *contentCards = AppDelegate.braze.contentCards.cards;

Wenn Sie zusätzlich Content-Card-Events abonnieren möchten, können Sie subscribeToEvents: aufrufen. Jeder Event-Typ wird auf seine eigene Klasse abgebildet (z. B. BRZContentCardsDataUpdatedEvent), die Sie mit isKindOfClass: unterscheiden können. Der initiale Cache-Replay und nachfolgende Daten-Updates werden beide auf BRZContentCardsDataUpdatedEvent abgebildet; prüfen Sie reason gegen BRZContentCardsDataUpdatedEvent.cacheReplayReason, um sie zu unterscheiden:

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

// - Available in version 19.0.0+
// This subscription is maintained through a Braze cancellable, which will continue to observe for events until the subscription is cancelled.
BRZCancellable *cancellable = [self.braze.contentCards subscribeToEvents:^(BRZContentCardsEvent *event) {
  if ([event isKindOfClass:[BRZContentCardsDataUpdatedEvent class]]) {
    BRZContentCardsDataUpdatedEvent *updated = (BRZContentCardsDataUpdatedEvent *)event;
    if (updated.reason == BRZContentCardsDataUpdatedEvent.cacheReplayReason) {
      // Initial cache snapshot, delivered immediately after subscribing
    } else {
      // Cache changed after the initial replay
    }
  } else if ([event isKindOfClass:[BRZContentCardsCacheLoadEvent class]]) {
    // Cache loaded at the start of a user session (for example, after `changeUser()`)
  }
}];

BRZCancellable *cancellable = [self.braze.contentCards subscribeToUpdates:^(NSArray<BRZContentCardRaw *> *contentCards) {
  // Implement your completion handler to respond to updates in `contentCards`.
}];

Verwenden Sie subscribeToEvents: ab Swift SDK 19.0.0 und höher. subscribeToUpdates: ist das ältere Muster, das ab Version 19.0.0 als veraltet gilt.

Um den aktuellen Cache-Zustand zu lesen, ohne den aufrufenden Thread zu blockieren, verwenden Sie die folgenden Methoden. Jeder Completion-Handler wird auf dem Main-Thread ausgeliefert.

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

// All cached cards.
[AppDelegate.braze.contentCards getCachedContentCardsWithCompletion:^(NSArray<BRZContentCardRaw *> *cards) {
  // Use `cards` here.
}];

// Unviewed cards only (excludes control cards).
[AppDelegate.braze.contentCards getUnviewedCardsWithCompletion:^(NSArray<BRZContentCardRaw *> *cards) {
  // Use `cards` here.
}];

// Date of the last server sync for the current user (nil until the first sync completes).
[AppDelegate.braze.contentCards getLastUpdateWithCompletion:^(NSDate * _Nullable date) {
  // Use `date` here.
}];

Um auf Updates zu lauschen, abonnieren Sie Content-Card-Update-Events:

1
2
3
4
5
6
7
8
9
10

const subscription = Braze.addListener(Braze.Events.CONTENT_CARDS_UPDATED, (update) => {
  const cards = update.cards;
  cards.forEach(card => {
    if (card.isControl) {
      // Do not display the control card, but remember to log an impression
    } else {
      // Use card.title, card.cardDescription, card.image, etc.
    }
  });
});

Um die zuletzt zwischengespeicherten Content-Card-Daten abzurufen:

1
2
3

import Braze from "@braze/react-native-sdk";

const cachedCards = await Braze.getCachedContentCards();

Um eine manuelle Aktualisierung der Content Cards von den Braze-Servern anzufordern:

1

Braze.requestContentCardsRefresh();

Events protokollieren

Das Protokollieren wertvoller Metriken wie Impressionen, Klicks und Schließungen ist schnell und einfach. Richten Sie einen angepassten Klick-Listener ein, um diese Analytics manuell zu verarbeiten.

• web
• android
• swift
• react native

Protokollieren Sie Impression-Events, wenn Cards von Nutzer:innen angesehen werden, mit logContentCardImpressions:

1
2
3

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

braze.logContentCardImpressions([card1, card2, card3]);

Protokollieren Sie Card-Klick-Events, wenn Nutzer:innen mit einer Card interagieren, mit logContentCardClick:

1
2
3

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

braze.logContentCardClick(card);

Der BrazeManager kann auf Braze-SDK-Abhängigkeiten verweisen, wie z. B. die Content-Card-Objekt-Array-Liste, um das Card-Objekt abzurufen und die Braze-Protokollierungsmethoden aufzurufen. Verwenden Sie die ContentCardable-Basisklasse, um einfach Daten zu referenzieren und dem BrazeManager bereitzustellen.

Um eine Impression oder einen Klick auf eine Card zu protokollieren, rufen Sie Card.logClick() bzw. Card.logImpression() auf.

Sie können eine Content-Card manuell protokollieren oder für eine bestimmte Card bei Braze als „geschlossen“ markieren, indem Sie isDismissed verwenden. Wenn eine Card bereits als geschlossen markiert ist, kann sie nicht erneut als geschlossen markiert werden.

Um einen angepassten Klick-Listener zu erstellen, erstellen Sie eine Klasse, die IContentCardsActionListener implementiert, und registrieren Sie sie beim BrazeContentCardsManager. Implementieren Sie die Methode onContentCardClicked(), die aufgerufen wird, wenn ein:e Nutzer:in auf eine Content-Card klickt. Weisen Sie dann Braze an, Ihren Content-Card-Klick-Listener zu verwenden.

• java
• kotlin

Zum Beispiel:

1
2
3
4
5
6
7
8
9
10
11

BrazeContentCardsManager.getInstance().setContentCardsActionListener(new IContentCardsActionListener() {
  @Override
  public boolean onContentCardClicked(Context context, Card card, IAction cardAction) {
    return false;
  }

  @Override
  public void onContentCardDismissed(Context context, Card card) {

  }
});

Zum Beispiel:

1
2
3
4
5
6
7
8
9

BrazeContentCardsManager.getInstance().contentCardsActionListener = object : IContentCardsActionListener {
  override fun onContentCardClicked(context: Context, card: Card, cardAction: IAction): Boolean {
    return false
  }

  override fun onContentCardDismissed(context: Context, card: Card) {

  }
}

Wichtig

Um Kontrollvarianten-Content Cards in Ihrer angepassten UI zu verarbeiten, übergeben Sie Ihr com.braze.models.cards.Card-Objekt und rufen Sie dann die logImpression-Methode auf, wie Sie es bei jedem anderen Content-Card-Typ tun würden. Das Objekt protokolliert implizit eine Kontroll-Impression, um unsere Analytics darüber zu informieren, wann ein:e Nutzer:in die Kontroll-Card gesehen hätte.

Implementieren Sie das Protokoll BrazeContentCardUIViewControllerDelegate und setzen Sie Ihr Delegate-Objekt als delegate-Eigenschaft Ihres BrazeContentCardUI.ViewController. Dieses Delegate übernimmt die Weitergabe der Daten Ihres angepassten Objekts an Braze zur Protokollierung. Ein Beispiel finden Sie im Content Cards UI Tutorial.

• swift
• objective-c

1
2
3
4
5
6
7
8
9
10
11
12

// Set the delegate when creating the Content Cards controller
contentCardsController.delegate = delegate

// Method to implement in delegate
func contentCard(
    _ controller: BrazeContentCardUI.ViewController,
    shouldProcess clickAction: Braze.ContentCard.ClickAction,
    card: Braze.ContentCard
  ) -> Bool {
  // Intercept the content card click action here.
  return true
}

1
2
3
4
5
6
7
8
9
10

// Set the delegate when creating the Content Cards controller
contentCardsController.delegate = delegate;

// Method to implement in delegate
- (BOOL)contentCardController:(BRZContentCardUIViewController *)controller
                shouldProcess:(NSURL *)url
                         card:(BRZContentCardRaw *)card {
  // Intercept the content card click action here.
  return YES;
}

Wichtig

Um Kontrollvarianten-Content Cards in Ihrer angepassten UI zu verarbeiten, übergeben Sie Ihr Braze.ContentCard.Control-Objekt und rufen Sie dann die logImpression-Methode auf, wie Sie es bei jedem anderen Content-Card-Typ tun würden. Das Objekt protokolliert implizit eine Kontroll-Impression, um unsere Analytics darüber zu informieren, wann ein:e Nutzer:in die Kontroll-Card gesehen hätte.

Protokollieren Sie Impression-Events, wenn Cards von Nutzer:innen angesehen werden:

1

Braze.logContentCardImpression(card.id);

Protokollieren Sie Card-Klick-Events, wenn Nutzer:innen mit einer Card interagieren:

1

Braze.logContentCardClicked(card.id);

Protokollieren Sie Schließungs-Events, wenn ein:e Nutzer:in eine Card schließt:

1

Braze.logContentCardDismissed(card.id);

Handhabung des Klickverhaltens

• web
• android
• swift
• react native

Wenn Nutzer:innen in einem angepassten Feed auf eine Content-Card klicken, wird das Klickverhalten (z. B. Navigation zu einer URL, Deeplinking oder Protokollierung eines angepassten Events) nicht automatisch ausgeführt. Verwenden Sie handleBrazeAction, um die URL der Card zu verarbeiten und die konfigurierte Klick-Aktion auszuführen, einschließlich Braze-Aktionen (brazeActions://-URLs).

1
2
3
4
5
6
7
8
9
10
11
12

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

// In your card click handler
function onCardClick(card) {
  // Log the click
  braze.logContentCardClick(card);

  // Handle the on-click behavior
  if (card.url) {
    braze.handleBrazeAction(card.url);
  }
}

Parameter	Beschreibung
url	Eine gültige URL oder eine gültige Braze-Aktions-URL mit dem Schema brazeActions://.
openLinkInNewTab	(Optional) Ob die URL in einem neuen Tab geöffnet werden soll. Standardwert ist false.

Wichtig

Wenn Sie handleBrazeAction() nicht aufrufen, werden die im Braze-Dashboard konfigurierten Klick-Aktionen (z. B. „Angepasstes Event protokollieren“ oder „Zu URL navigieren“) für Cards in einem angepassten Feed nicht ausgeführt.

Das Klickverhalten wird von der Standard-Content-Cards-UI automatisch gehandhabt. Für angepasste Implementierungen verwenden Sie die Schnittstelle IContentCardsActionListener, die unter Analytics protokollieren beschrieben ist.

Das Klickverhalten wird von der Standard-Content-Cards-UI automatisch gehandhabt. Für angepasste Implementierungen verwenden Sie das Protokoll BrazeContentCardUIViewControllerDelegate, das unter Analytics protokollieren beschrieben ist.

Wenn Nutzer:innen in einem angepassten Feed auf eine Content-Card klicken, wird das Klickverhalten nicht automatisch ausgeführt. Nachdem Sie den Klick mit Braze.logContentCardClicked(cardId) protokolliert haben, rufen Sie Braze.processContentCardClickAction(cardId) auf, um Deeplinks, URLs und brazeActions://-Aktionen zu verarbeiten. Eine Methodenreferenz finden Sie unter React Native Content Cards.

1
2
3
4
5
6
7
8
9

import Braze from "@braze/react-native-sdk";

function onCardPress(card) {
  Braze.logContentCardClicked(card.id);

  if (card.url) {
    Braze.processContentCardClickAction(card.id);
  }
}

Wichtig

Wenn Sie processContentCardClickAction() nicht aufrufen, werden die im Braze-Dashboard konfigurierten Klick-Aktionen für Cards in einem angepassten Feed nicht ausgeführt.

Eindeutige Ausblendungen höher als eindeutige Impressionen

Wenn Eindeutige Ausblendungen die Eindeutigen Impressionen übersteigen, hat Ihre angepasste Content-Card-Integration Ausblendungen protokolliert, ohne für dieselben Karten Impressionen zu protokollieren. Die Standard-Content-Card-UI von Braze protokolliert beides automatisch, sodass diese Abweichung nur auftritt, wenn Sie eine angepasste UI verwenden.

Protokollieren Sie jedes Mal eine Impression, wenn Sie eine Karte anzeigen, und protokollieren Sie eine Ausblendung, wenn Nutzer:innen sie ausblenden. Methodennamen und Beispiele finden Sie in den nachfolgenden Plattformabschnitten.

Fehlende Content-Cards-Analytics

Wenn Content Cards in Ihrer App korrekt angezeigt werden, Sie aber durchgehend keine Analytics erhalten (Impressionen, Klicks usw.), liegt wahrscheinlich ein Problem mit der SDK-Integration vor.

• Angepasste Content-Card-Ansichten (Android, iOS, Internet): Die Standard-Braze-UI protokolliert Impressionen und Klicks auf allen Plattformen automatisch. Wenn Sie eine angepasste Content-Card-Ansicht oder -Implementierung verwenden, müssen Sie die entsprechenden Protokollierungsmethoden explizit in Ihrer Anwendung aufrufen. Weitere Informationen finden Sie unter Analytics protokollieren für Ihre Plattform. Stellen Sie bei angepassten Internet-Implementierungen insbesondere sicher, dass das Braze Web SDK geladen ist, prüfen Sie die Browser-Konsole auf Fehler und überprüfen Sie, ob Kartendaten empfangen werden.
• SDK-Initialisierung und Nutzeridentifikation: Stellen Sie sicher, dass das SDK vollständig initialisiert ist, bevor Karten angezeigt werden. Ereignisse werden stillschweigend verworfen (nicht in die Warteschlange gestellt), wenn das SDK nicht initialisiert ist, sich im verzögerten Initialisierungsmodus befindet oder DSGVO-deaktiviert ist. Das SDK protokolliert zwar Analytics für anonyme Nutzer:innen, aber Dashboard-Metriken wie „Eindeutige tägliche Impressionen“ erfordern eine aufgelöste Nutzeridentität. Rufen Sie daher nach Möglichkeit changeUser auf, bevor Karten angezeigt werden.

Content-Card-ID

Jeder Campaign-Versand an eine:n Empfänger:in erzeugt eine neue Content-Card-ID. Wenn dieselben Nutzer:innen die Campaign bei einem späteren Versand erneut erhalten, weist Braze eine neue ID zu. Referenzieren Sie die Karten-id, wenn Sie Impressionen, Klicks und Ausblendungen in angepassten Implementierungen protokollieren.