Content Cards erstellen

Dieser Artikel beschreibt den grundlegenden Ansatz, den Sie bei der Implementierung angepasster Content Cards verwenden, sowie drei häufige Anwendungsfälle. Es wird davon ausgegangen, dass Sie bereits die anderen Artikel der Anleitung zur Anpassung von Content Cards gelesen haben, um zu verstehen, was standardmäßig möglich ist und was angepassten Code erfordert. Es ist besonders hilfreich zu verstehen, wie Sie Analytics protokollieren für Ihre angepassten Content Cards.

Tipp

Content Cards für Nachrichten im Banner-Stil verwenden? Probieren Sie Banner aus – perfekt für inline, persistente In-App- und Web-Nachrichten.

Eine Card erstellen

Schritt 1: Erstellen Sie eine benutzerdefinierte UI

• web
• android
• swift

Schritt 2: Card-Updates abonnieren

Registrieren Sie eine Callback-Funktion, um Datenaktualisierungen zu abonnieren, wenn Cards aktualisiert werden. Sie können die Content-Card-Objekte parsen und ihre Nutzdaten extrahieren, z. B. title, cardDescription und imageUrl, und dann die resultierenden Modelldaten verwenden, um Ihre benutzerdefinierte UI zu befüllen.

Um die Content-Card-Datenmodelle zu erhalten, abonnieren Sie Content-Card-Updates. Achten Sie besonders auf die folgenden Eigenschaften:

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

Alle Eigenschaften außer id und extras sind für benutzerdefinierte Content Cards optional zu parsen. Weitere Informationen zum Datenmodell finden Sie im jeweiligen Integrationsartikel der Plattform: Android, iOS, Web.

• web
• android
• swift

  Web: 7.0.0+  

Verwenden Sie subscribeToContentCardsEvents, um Content-Card-Ereignisse zu empfangen. Das SDK ruft Ihren Handler mit einem Ereignisobjekt auf. Verwenden Sie event.type, um zwischen den verschiedenen Ereignistypen zu unterscheiden. Weitere Informationen zu den Ereigniswerten finden Sie unter Ereignis-Abonnements.

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

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

function renderCards(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.
    }
  });
}

// - Available in version 7.0.0+
const subscriptionId = braze.subscribeToContentCardsEvents((event) => {
  switch (event.type) {
    case braze.ChannelEventType.CACHE_REPLAY:
      // Sent once, right away, with the cards that are already cached.
      // Render them now instead of waiting for the network.
      renderCards(event.cacheSnapshot.contentCards.cards);
      break;

    case braze.ChannelEventType.CACHE_LOAD:
      // The cache changed without a refresh, such as after changeUser().
      // The snapshot can be empty, so clear cards from the previous user.
      renderCards(event.cacheSnapshot.contentCards.cards);
      break;

    case braze.ChannelEventType.DATA_UPDATED:
      // A refresh finished, even if no cards changed, or a card was dismissed.
      renderCards(event.cacheSnapshot.contentCards.cards);
      break;

    case braze.ChannelEventType.ERROR:
      switch (event.retryState) {
        case braze.RetryState.SDK_WILL_RETRY:
          // The SDK is retrying. Keep the current cards and wait.
          break;
        case braze.RetryState.INTEGRATOR_MAY_RETRY: {
          // The SDK stopped retrying. Try again later, and limit how often you retry.
          const delayMs = event.rateLimitedUntil
            ? Math.max(event.rateLimitedUntil.getTime() - Date.now(), 0)
            : 30000;
          setTimeout(() => braze.requestContentCardsRefresh(), delayMs);
          break;
        }
        case braze.RetryState.DO_NOT_RETRY:
          // The failure is final. For example, Content Cards are disabled for this workspace.
          if (event.reason === braze.ChannelErrorReason.FEATURE_DISABLED) {
            // Hide your Content Cards UI.
          }
          break;
      }
      break;
  }
});

const deprecatedSubscriptionId = braze.subscribeToContentCardsUpdates((updates) => {
  renderCards(updates.cards);
});

braze.openSession();

// Remove the subscription when you no longer need it
// braze.removeSubscription(subscriptionId);

Hinweis

Content Cards werden nur bei Sitzungsstart aktualisiert, wenn Sie subscribeToContentCardsEvents() (oder das veraltete subscribeToContentCardsUpdates()) vor openSession() aufrufen. Sie können den Feed auch jederzeit manuell aktualisieren.

Informationen dazu, wann jedes Ereignis ausgelöst wird und was jeder Aktualisierungsgrund, Wiederholungsstatus, jede Analytics-Aktion und jeder Fehlergrund bedeutet, finden Sie unter Ereignis-Abonnements.

Verwenden Sie subscribeToContentCardsEvents ab Web SDK 7.0.0 und höher. subscribeToContentCardsUpdates ist das frühere Muster, das ab Version 7.0.0 als veraltet gilt. Das frühere Muster liefert nur die aktuellen Cards, sodass es Ihnen nicht mitteilen kann, warum sich die Cards geändert haben oder wann eine Aktualisierung fehlgeschlagen ist.

  Android: 44.0.0+  

• java
• kotlin

Schritt 2a: Eine private Subscriber-Variable erstellen

Um Card-Updates zu abonnieren, deklarieren Sie zunächst eine private Variable in Ihrer benutzerdefinierten Klasse, die Ihren Subscriber enthält:

1
2
3
4

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

private IEventSubscriber<ContentCardsUpdatedEvent> mContentCardsUpdatedSubscriber;

Schritt 2b: Ereignisse abonnieren

Fügen Sie den folgenden Code hinzu, um mit subscribeToContentCardsEvents() zu abonnieren, typischerweise innerhalb von Activity.onCreate() Ihrer benutzerdefinierten Content-Cards-Activity. Verwenden Sie Pattern-Matching für die ContentCardsEvent-Unterklassen, die Sie benötigen.

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

Ereignisse treffen auf einem Hintergrund-Thread ein. Wechseln Sie zum Haupt-Thread, bevor Sie Views aktualisieren.

Schritt 2c: Abonnement beenden

Beenden Sie das Abonnement, wenn Ihre benutzerdefinierte Activity aus dem Sichtbereich verschwindet. 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 2a: Eine private Subscriber-Variable erstellen

Um Card-Ereignisse zu abonnieren, deklarieren Sie zunächst eine private Variable in Ihrer benutzerdefinierten Klasse, die Ihren Subscriber enthält:

1
2
3
4

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

private var contentCardsUpdatedSubscriber: IEventSubscriber<ContentCardsUpdatedEvent>? = null

Schritt 2b: Ereignisse abonnieren

Fügen Sie den folgenden Code hinzu, um mit subscribeToContentCardsEvents() zu abonnieren, typischerweise innerhalb von Activity.onCreate() Ihrer benutzerdefinierten Content-Cards-Activity. Verwenden Sie Pattern-Matching für die ContentCardsEvent-Unterklassen, die Sie benötigen.

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
}

Ereignisse treffen auf einem Hintergrund-Thread ein. Wechseln Sie zum Haupt-Thread, bevor Sie Views aktualisieren.

Schritt 2c: Abonnement beenden

Beenden Sie das Abonnement, wenn Ihre benutzerdefinierte Activity aus dem Sichtbereich verschwindet. 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 dazu, wann jedes Ereignis ausgelöst wird und was jeder Aktualisierungsgrund, Wiederholungsstatus, jede Analytics-Aktion und jeder Fehlergrund bedeutet, finden Sie unter Ereignis-Abonnements.

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

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

• swift
• objective-c

  Swift: 19.0.0+  

1

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

Zusätzlich können Sie Content-Card-Ereignisse abonnieren, um Cache-Änderungen, Analytics und Fehler zu beobachten. Dafür gibt es zwei Möglichkeiten:

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

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 frühere Muster, das ab Version 19.0.0 als veraltet gilt.

1

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

Wenn Sie zusätzlich Content-Card-Ereignisse abonnieren möchten, können Sie subscribeToEvents: aufrufen. Jeder Ereignistyp wird an seine eigene Klasse gebridgt (z. B. BRZContentCardsDataUpdatedEvent), die Sie mit isKindOfClass: unterscheiden können. Der initiale Cache-Replay und nachfolgende Datenaktualisierungen werden beide an BRZContentCardsDataUpdatedEvent gebridgt; 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 frühere Muster, das ab Version 19.0.0 als veraltet gilt.

Informationen dazu, wann jedes Ereignis ausgelöst wird und was jeder Aktualisierungsgrund, Wiederholungsstatus, jede Analytics-Aktion und jeder Fehlergrund bedeutet, finden Sie unter Ereignis-Abonnements.

Schritt 3: Analytics implementieren

Content-Card-Impressionen, -Klicks und -Abweisungen werden in Ihrer benutzerdefinierten Ansicht nicht automatisch protokolliert. Sie müssen die jeweiligen Methoden implementieren, um alle Metriken ordnungsgemäß an die Analytics des Braze-Dashboards zurückzumelden.

Schritt 4: Ihre Card testen (optional)

So testen Sie Ihre Content Card:

1. Legen Sie eine:n aktive:n Nutzer:in in Ihrer Anwendung fest, indem Sie die Methode changeUser() aufrufen.
2. Gehen Sie in Braze zu Campaigns und erstellen Sie eine neue Content-Card-Campaign.
3. Wählen Sie in Ihrer Campaign Test aus und geben Sie die user-id der Testnutzer:in ein. Wenn Sie bereit sind, wählen Sie Send Test. In Kürze können Sie eine Content Card auf Ihrem Gerät starten.

Content-Card-Platzierungen

Content Cards können auf viele verschiedene Arten verwendet werden. Drei gängige Implementierungen sind die Nutzung als Nachrichtenzentrum, als dynamische Bildanzeige oder als Bildkarussell. Für jede dieser Platzierungen weisen Sie Ihren Content Cards Schlüssel-Wert-Paare (die Eigenschaft extras im Datenmodell) zu und passen basierend auf den Werten das Verhalten, die Darstellung oder die Funktionalität der Card zur Laufzeit dynamisch an.

Nachrichtenposteingang

Content Cards können verwendet werden, um ein Nachrichtenzentrum zu simulieren. In diesem Format ist jede Nachricht eine eigene Card, die Schlüssel-Wert-Paare enthält, welche Klick-Ereignisse steuern. Diese Schlüssel-Wert-Paare sind die zentralen Bezeichner, anhand derer die Anwendung entscheidet, wohin navigiert werden soll, wenn Nutzer:innen auf eine Posteingangs-Nachricht klicken. Die Werte der Schlüssel-Wert-Paare sind beliebig.

Beispiel

Sie möchten beispielsweise zwei Nachrichten-Cards erstellen: einen Call-to-Action, der Nutzer:innen auffordert, Leseempfehlungen zu aktivieren, und einen Gutscheincode für Ihr neues Abonnent:innen-Segment.

Schlüssel wie body, title und buttonText könnten einfache String-Werte haben, die Ihre Marketer festlegen können. Schlüssel wie terms könnten Werte haben, die eine kleine Sammlung von Formulierungen bereitstellen, die von Ihrer Rechtsabteilung genehmigt wurden. Schlüssel wie style und class_type haben String-Werte, die Sie festlegen können, um zu bestimmen, wie Ihre Card in Ihrer App oder auf Ihrer Website dargestellt wird.

• leseempfehlungen
• gutschein für neue abonnent:innen

1
2
3
4
5
6
7
8
9
10
11

 private fun createContentCardable(metadata: Map<String, Any>, type: ContentCardClass?): ContentCardable?{
        return when(type){
            ContentCardClass.AD -> Ad(metadata)
            ContentCardClass.MESSAGE_WEB_VIEW -> WebViewMessage(metadata)
            ContentCardClass.NOTIFICATION_CENTER -> FullPageMessage(metadata)
            ContentCardClass.ITEM_GROUP -> Group(metadata)
            ContentCardClass.ITEM_TILE -> Tile(metadata)
            ContentCardClass.COUPON -> Coupon(metadata)
            else -> null
        }
    }

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

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //...
        listView.onItemClickListener = AdapterView.OnItemClickListener { parent, view, position, id ->
           when (val card = dataProvider[position]){
                is WebViewMessage -> {
                    val intent = Intent(this, WebViewActivity::class.java)
                    val bundle = Bundle()
                    bundle.putString(WebViewActivity.INTENT_PAYLOAD, card.contentString)
                    intent.putExtras(bundle)
                    startActivity(intent)
                }
                is FullPageMessage -> {
                    val intent = Intent(this, FullPageContentCard::class.java)
                    val bundle = Bundle()
                    bundle.putString(FullPageContentCard.CONTENT_CARD_IMAGE, card.icon)
                    bundle.putString(FullPageContentCard.CONTENT_CARD_TITLE, card.messageTitle)
                    bundle.putString(FullPageContentCard.CONTENT_CARD_DESCRIPTION, card.cardDescription)
                    intent.putExtras(bundle)
                    startActivity(intent)
                }
            }

        }
    }

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

private ContentCardable createContentCardable(Map<String, ?> metadata,  ContentCardClass type){
    switch(type){
        case ContentCardClass.AD:{
            return new Ad(metadata);
        }
        case ContentCardClass.MESSAGE_WEB_VIEW:{
            return new WebViewMessage(metadata);
        }
        case ContentCardClass.NOTIFICATION_CENTER:{
            return new FullPageMessage(metadata);
        }
        case ContentCardClass.ITEM_GROUP:{
            return new Group(metadata);
        }
        case ContentCardClass.ITEM_TILE:{
            return new Tile(metadata);
        }
        case ContentCardClass.COUPON:{
            return new Coupon(metadata);
        }
        default:{
            return null;
        }
    }
}

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

@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState)
        //...
        listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id){
               ContentCardable card = dataProvider.get(position);
               if (card instanceof WebViewMessage){
                    Bundle intent = new Intent(this, WebViewActivity.class);
                    Bundle bundle = new Bundle();
                    bundle.putString(WebViewActivity.INTENT_PAYLOAD, card.getContentString());
                    intent.putExtras(bundle);
                    startActivity(intent);
                }
                else if (card instanceof FullPageMessage){
                    Intent intent = new Intent(this, FullPageContentCard.class);
                    Bundle bundle = Bundle();
                    bundle.putString(FullPageContentCard.CONTENT_CARD_IMAGE, card.getIcon());
                    bundle.putString(FullPageContentCard.CONTENT_CARD_TITLE, card.getMessageTitle());
                    bundle.putString(FullPageContentCard.CONTENT_CARD_DESCRIPTION, card.getCardDescription());
                    intent.putExtras(bundle)
                    startActivity(intent)
                }
            }

        });
    }

Karussell

Sie können Content Cards in Ihrem vollständig angepassten Karussell-Feed einrichten, sodass Nutzer:innen wischen und weitere hervorgehobene Cards anzeigen können. Standardmäßig werden Content Cards nach Erstellungsdatum sortiert (neueste zuerst), und Ihre Nutzer:innen sehen alle Cards, für die sie berechtigt sind.

So implementieren Sie ein Content-Card-Karussell:

1. Erstellen Sie eine angepasste Logik, die Änderungen an Ihren Content Cards beobachtet und das Eintreffen von Content Cards verarbeitet.
2. Erstellen Sie eine angepasste clientseitige Logik, um eine bestimmte Anzahl von Cards gleichzeitig im Karussell anzuzeigen. Sie könnten beispielsweise die ersten fünf Content-Card-Objekte aus dem Array auswählen oder Schlüssel-Wert-Paare einführen, um bedingte Logik aufzubauen.

Tipp

Wenn Sie ein Karussell als sekundären Content-Cards-Feed implementieren, stellen Sie sicher, dass Sie Cards mithilfe von Schlüssel-Wert-Paaren dem richtigen Feed zuordnen.

Nur Bild

Content Cards müssen nicht wie „Cards“ aussehen. Beispielsweise können Content Cards als dynamisches Bild erscheinen, das dauerhaft auf Ihrer Startseite oder am Anfang bestimmter Seiten angezeigt wird.

Um dies zu erreichen, erstellen Ihre Marketer eine Campaign oder einen Canvas-Schritt mit dem Content-Card-Typ Nur Bild. Legen Sie dann Schlüssel-Wert-Paare fest, die für die Nutzung von Content Cards als ergänzende Inhalte geeignet sind.