Skip to content


Braze iOS SDK-Integrationsanleitung

Dieser optionale Leitfaden zur iOS-Integration führt Sie Schritt für Schritt durch die bewährten Verfahren bei der ersten Integration des iOS SDK und seiner Kernkomponenten in Ihre Anwendung. Diese Anleitung hilft Ihnen bei der Erstellung einer BrazeManager.swift-Hilfsdatei, die alle Abhängigkeiten vom Braze iOS SDK vom Rest Ihres produktiven Codes entkoppelt, was zu einem einzigen import AppboyUI in Ihrer gesamten Anwendung führt. Dieser Ansatz vermeidet Probleme, die durch übermäßige SDK-Importe entstehen, und erleichtert das Tracking, Debugging und Ändern von Code.

Integrationsübersicht

Die folgenden Schritte helfen Ihnen, eine BrazeManager-Hilfsdatei zu erstellen, die Ihr Produktionscode aufruft. Diese Hilfsdatei behandelt alle Braze-bezogenen Abhängigkeiten, indem sie verschiedene Erweiterungen für die folgenden aufgelisteten Integrationsthemen hinzufügt. Jedes Thema enthält horizontale Tab-Schritte und Code-Snippets sowohl in Swift als auch in Objective-C. Beachten Sie, dass die Schritte für Content Cards und In-App-Nachrichten für die Integration nicht erforderlich sind, wenn Sie diese Kanäle in Ihrer Anwendung nicht nutzen möchten.

BrazeManager.swift erstellen

BrazeManager.swift erstellen

Um Ihre BrazeManager.swift-Datei aufzubauen, erstellen Sie eine neue Swift-Datei namens BrazeManager, die Sie an der gewünschten Stelle zu Ihrem Projekt hinzufügen. Ersetzen Sie anschließend import Foundation durch import AppboyUI für SPM (import Appboy_iOS_SDK für CocoaPods) und erstellen Sie dann eine BrazeManager-Klasse, die alle Braze-bezogenen Methoden und Variablen beherbergt. Appboy_iOS_SDK

  1. Fügen Sie eine statische Variable namens shared hinzu, die die BrazeManager-Klasse initialisiert. Es ist garantiert, dass diese nur einmal lazily initialisiert wird.
  2. Fügen Sie als Nächstes eine private Konstantenvariable namens apiKey hinzu und setzen Sie sie als API-Schlüsselwert aus Ihrem Workspace im Braze-Dashboard.
  3. Fügen Sie eine private berechnete Variable namens appboyOptions hinzu, die Konfigurationswerte für das SDK speichert. Sie wird vorerst leer sein.
1
2
3
4
5
6
7
8
9
10
11
12
class BrazeManager: NSObject {
  // 1
  static let shared = BrazeManager()

  // 2
  private let apikey = "YOUR-API-KEY"

  // 3
  private var appboyOptions: [String:Any] {
    return [:]
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@implementation BrazeManager

// 1
+ (instancetype)shared {
    static BrazeManager *shared = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        shared = [[BrazeManager alloc] init];
        // Do any other initialisation stuff here
    });
    return shared;
}

// 2
- (NSString *)apiKey {
  return @"YOUR-API-KEY";
}

// 3
- (NSDictionary *)appboyOptions {
  return [NSDictionary dictionary];
}

SDK initialisieren

SDK über BrazeManager.swift initialisieren

Als Nächstes müssen Sie das SDK initialisieren. Dieser Leitfaden geht davon aus, dass Sie das SDK bereits hinzugefügt haben. Außerdem müssen Sie Ihren Workspace-SDK-Endpunkt und das LogLevel in Ihrer Info.plist-Datei oder in appboyOptions festgelegt haben.

Fügen Sie die Methode didFinishLaunchingWithOptions aus der AppDelegate.swift-Datei ohne Rückgabetyp in Ihre BrazeManager.swift-Datei ein. Durch das Erstellen einer ähnlichen Methode in der BrazeManager.swift-Datei wird kein import AppboyUI-Statement in Ihrer AppDelegate.swift-Datei benötigt.

Initialisieren Sie als Nächstes das SDK mit Ihren neu deklarierten Variablen apiKey und appboyOptions.

1
2
3
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
  Appboy.start(withApiKey: apikey, in: application, withLaunchOptions: launchOptions, withAppboyOptions: appboyOptions)
}
1
2
3
- (void)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [Appboy startWithApiKey:[self apiKey] inApplication:application withLaunchOptions:launchOptions withAppboyOptions:[self appboyOptions]];
}
Appboy-Initialisierung in AppDelegate.swift handhaben

Navigieren Sie als Nächstes zurück zur AppDelegate.swift-Datei und fügen Sie das folgende Code-Snippet in die didFinishLaunchingWithOptions-Methode des AppDelegate ein, um die Appboy-Initialisierung aus der BrazeManager.swift-Hilfsdatei zu handhaben. Denken Sie daran, dass kein import AppboyUI-Statement in der AppDelegate.swift erforderlich ist.

1
2
3
4
5
6
7
8
9
10
func application(
  _ application: UIApplication,
  didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
  // Override point for customization after application launch

  BrazeManager.shared.application(application, didFinishLaunchingWithOptions: launchOptions)

  return true
}
1
2
3
4
5
6
7
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  // Override point for customization after application launch

  [[BrazeManager shared] application:application didFinishLaunchingWithOptions:launchOptions];

  return YES;
}

Push-Benachrichtigungen

Push-Zertifikat hinzufügen

Navigieren Sie zu Ihrem bestehenden Workspace im Braze-Dashboard. Laden Sie unter Push Notification Settings Ihre Push-Zertifikatsdatei in Ihr Braze-Dashboard hoch und speichern Sie sie.

Braze-Dashboard Push Notification Settings mit APNs-Schlüssel-Upload-Feldern.

Für Push-Benachrichtigungen registrieren

Registrieren Sie sich als Nächstes für Push-Benachrichtigungen. Dieser Leitfaden geht davon aus, dass Sie Ihre Push-Zugangsdaten korrekt eingerichtet haben — sowohl in Ihrem Apple Developer Portal als auch in Ihrem Xcode-Projekt.

Der Code zur Registrierung von Push-Benachrichtigungen wird in der Methode didFinishLaunching... in der BrazeManager.swift-Datei hinzugefügt. Ihr Initialisierungscode sollte am Ende wie folgt aussehen:

  1. Konfigurieren Sie die Inhalte für die Anfrage zur Autorisierung der Interaktion mit Nutzer:innen. Diese Optionen sind als Beispiel aufgeführt.
  2. Fordern Sie die Autorisierung an, um Ihren Nutzer:innen Push-Benachrichtigungen zu senden. Die Antwort der Nutzer:innen, Push-Benachrichtigungen zuzulassen oder abzulehnen, wird in der Variable granted gespeichert.
  3. Leiten Sie die Push-Autorisierungsergebnisse an Braze weiter, nachdem Nutzer:innen mit der Benachrichtigungsaufforderung interagiert haben.
  4. Starten Sie den Registrierungsprozess bei APNs; dies sollte im Haupt-Thread erfolgen. Bei erfolgreicher Registrierung ruft die App die Methode didRegisterForRemoteNotificationsWithDeviceToken Ihres AppDelegate-Objekts auf.
1
2
3
4
5
6
7
8
9
10
11
12
13
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions:[UIApplication.LaunchOptionsKey:Any]?) {
  Appboy.start(withAPIKey: apikey, in: application, withLaunchOptions: launchOptions, withAppboyOptions: appboyOptions)
  // 1
  let options: UNAuthorizationOptions = [.alert, .sound, .badge]
  // 2
  UNUserNotificationCenter.current().requestAuthorization(option: options) { (granted, error) in
  // 3
    Appboy.sharedInstance()?.pushAuthorization(fromUserNotificationCenter: granted)
  }

  // 4
  UIApplications.shared.registerForRemoteNotificiations()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (void)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [Appboy startWithApiKey:[self apiKey] inApplication:application withLaunchOptions:launchOptions withAppboyOptions:[self appboyOptions]];

  // 1
  UNAuthorizationOptions options = (UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge);

  // 2
  [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) {
  // 3
    [[Appboy sharedInstance] pushAuthorizationFromUserNotificationCenter:granted];
  }];

  // 4
  [[UIApplication sharedApplication] registerForRemoteNotifications];
}
Push-Benachrichtigungsmethoden weiterleiten

Leiten Sie als Nächstes die System-Push-Benachrichtigungsmethoden von AppDelegate.swift an BrazeManager.swift weiter, damit sie vom Braze iOS SDK verarbeitet werden.

Schritt 1: Erweiterung für Push-Benachrichtigungscode erstellen

Erstellen Sie eine Erweiterung für Ihren Push-Benachrichtigungscode in Ihrer BrazeManager.swift-Datei, damit er übersichtlicher lesbar ist und der Zweck in der Hilfsdatei klar erkennbar wird:

  1. Nach dem Muster, kein import AppboyUI-Statement in Ihrem AppDelegate einzufügen, werden die Push-Benachrichtigungsmethoden in der BrazeManager.swift-Datei behandelt. Die Device-Tokens der Nutzer:innen müssen über die Methode didRegisterForRemote... an Braze übergeben werden. Diese Methode wird benötigt, um Silent-Push-Benachrichtigungen zu implementieren. Fügen Sie anschließend dieselbe Methode aus dem AppDelegate in Ihre BrazeManager-Klasse ein.
  2. Fügen Sie die folgende Zeile innerhalb der Methode hinzu, um das Device-Token bei Braze zu registrieren. Dies ist notwendig, damit Braze das Token mit dem aktuellen Gerät verknüpfen kann.
1
2
3
4
5
6
7
8
9
10
11
// MARK - Push Notifications
extension BrazeManager {
  // 1
  func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
  ) {
    // 2
    Appboy.sharedInstance().?registerDeviceToken(deviceToken)
  }
}
1
2
3
4
5
6
// MARK - Push Notifications
// 1
- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
  // 2
  [[Appboy sharedInstance] registerDeviceToken:deviceToken];
}
Schritt 2: Remote-Benachrichtigungen unterstützen

Fügen Sie im Tab Signing & Capabilities die Unterstützung für Background Modes hinzu und wählen Sie Remote notifications, um mit der Unterstützung von Remote-Push-Benachrichtigungen zu beginnen, die von Braze stammen.

Signing & Capabilities

Schritt 3: Remote-Benachrichtigungsbehandlung

Das Braze SDK kann Remote-Push-Benachrichtigungen verarbeiten, die von Braze stammen. Leiten Sie Remote-Benachrichtigungen an Braze weiter; das SDK ignoriert automatisch Push-Benachrichtigungen, die nicht von Braze stammen. Fügen Sie die folgende Methode in Ihrer BrazeManager.swift-Datei in der Push-Benachrichtigungserweiterung hinzu.

1
2
3
4
5
6
7
8
9
10
11
func application(
  _ application: UIApplication,
  didReceiveRemoteNotification userInfo: [AnyHashable : Any],
  fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
) {
  Appboy.sharedInstance()?.register(
    application,
    didReceiveRemoteNotification: userInfo,
    fetchCompletionHandler: completionHandler
  )
}
1
2
3
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  [[Appboy sharedInstance] registerApplication:application didReceiveRemoteNotification:userInfo fetchCompletionHandler:completionHandler];
}
Schritt 4: Benachrichtigungsantworten weiterleiten

Das Braze SDK kann die Antwort auf Push-Benachrichtigungen verarbeiten, die von Braze stammen. Leiten Sie die Antwort der Benachrichtigungen an Braze weiter; das SDK ignoriert automatisch Antworten auf Push-Benachrichtigungen, die nicht von Braze stammen. Fügen Sie die folgende Methode in Ihrer BrazeManager.swift-Datei hinzu:

1
2
3
4
5
6
7
8
9
10
11
func userNotificationCenter(
  _ center: UNUserNotificationCenter,
  didReceive response: UNNotificationResponse,
  withCompletionHandler completionHandler: @escaping () -> Void
) {
  Appboy.sharedInstance()?.userNotificationCenter(
    center,
    didReceive: response,
    withCompletionHandler: completionHandler
  )
}
1
2
3
4
5
6
7
- (void)userNotificationCenter:(UNUserNotificationCenter *)center
didReceiveNotificationResponse:(UNNotificationResponse *)response
         withCompletionHandler:(void (^)(void))completionHandler {
  [[Appboy sharedInstance] userNotificationCenter:center
                   didReceiveNotificationResponse:response
                            withCompletionHandler:completionHandler];
}

Auf Nutzervariablen und -methoden zugreifen

Nutzervariablen und -methoden erstellen

Als Nächstes möchten Sie einen einfachen Zugriff auf die ABKUser-Variablen und -Methoden. Erstellen Sie eine Erweiterung für Ihren Nutzercode in der BrazeManager.swift-Datei, damit er übersichtlicher lesbar ist und der Zweck in der Hilfsdatei klar erkennbar wird:

  1. Ein ABKUser-Objekt repräsentiert eine:n bekannte:n oder anonyme:n Nutzer:in in Ihrer iOS-Anwendung. Fügen Sie eine berechnete Variable hinzu, um das ABKUser-Objekt abzurufen; diese Variable wird wiederverwendet, um Variablen über die:den Nutzer:in abzurufen.
  2. Fragen Sie die Nutzervariable ab, um einfach auf die userId zuzugreifen. Neben den anderen Variablen ist das ABKUser-Objekt verantwortlich für (firstName, lastName, phone, homeCity usw.)
  3. Setzen Sie die:den Nutzer:in, indem Sie changeUser() mit einer entsprechenden userId aufrufen.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// MARK: - User
extension BrazeManager {
  // 1
  var user: ABKUser? {
    return Appboy.sharedInstance()?.user
  }

  // 2
  var userId: String? {
    return user?.userID
  }

  // 3
  func changeUser(_ userId: String) {
    Appboy.sharedInstance()?.changeUser(userId)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// MARK: - User
  // 1
- (ABKUser *)user {
  return [[Appboy sharedInstance] user];
}

   // 2
- (NSString *)userId {
  return [self user].userID;
}

  // 3
- (void)changeUser:(NSString *)userId {
  [[Appboy sharedInstance] changeUser:userId];
}

Analytics protokollieren

Methode zum Protokollieren angepasster Events erstellen

Erstellen Sie basierend auf der folgenden Braze SDK-Methode logCustomEvent eine entsprechende Methode.

Braze logCustomEvent-Referenzmethode
Dies ist designbedingt so, da nur die BrazeManager.swift-Datei direkt auf die Methoden des Braze iOS SDK zugreifen kann. Durch das Erstellen einer entsprechenden Methode ist das Ergebnis dasselbe und es werden keine direkten Abhängigkeiten zum Braze iOS SDK in Ihrem Produktionscode benötigt.

1
open func logCustomEvent(_ eventName: String, withProperties properties: [AnyHashable : Any]?)

Entsprechende Methode
Protokollieren Sie angepasste Events vom Appboy-Objekt zu Braze. Properties ist ein optionaler Parameter mit dem Standardwert nil. Angepasste Events benötigen nicht zwingend Properties, müssen aber einen Namen haben.

1
2
3
func logCustomEvent(_ eventName: String, withProperties properties: [AnyHashable: Any]? = nil) {
  Appboy.sharedInstance()?.logCustomEvent(eventName, withProperties: properties)
}
1
2
3
- (void)logCustomEvent:(NSString *)eventName withProperties:(nullable NSDictionary *)properties {
  [[Appboy sharedInstance] logCustomEvent:eventName withProperties:properties];
}
Methode zum Protokollieren angepasster Attribute erstellen

Das SDK kann zahlreiche Typen als angepasste Attribute protokollieren. Es ist nicht notwendig, Hilfsmethoden für jeden Wertetyp zu erstellen, der gesetzt werden kann. Stattdessen wird nur eine Methode bereitgestellt, die zum passenden Wert filtern kann.

1
2
3
4
5
- (BOOL)setCustomAttributeWithKey:(NSString *)key andBOOLValue:(BOOL)value;
- (BOOL)setCustomAttributeWithKey:(NSString *)key andIntegerValue:(NSIntenger)value;
- (BOOL)setCustomAttributeWithKey:(NSString *)key andDoubleValue:(double)value;
- (BOOL)setCustomAttributeWithKey:(NSString *)key andStringValue:(NSString *)value;
- (BOOL)setCustomAttributeWithKey:(NSString *)key andDateValue:(NSDate *)value;

Angepasste Attribute werden über das ABKUser-Objekt protokolliert.

Erstellen Sie eine Methode, die alle verfügbaren Typen abdecken kann, die für ein Attribut gesetzt werden können. Fügen Sie diese Methode in Ihrer BrazeManager.swift-Datei in der Analytics-Erweiterung hinzu. Dies kann durch Filtern der gültigen angepassten Attributtypen und Aufrufen der Methode erreicht werden, die dem passenden Typ zugeordnet ist.

  • Der Parameter value ist ein generischer Typ, der dem Equatable-Protokoll entspricht. Dies ist explizit so gemacht, damit bei einem Typ, der nicht dem entspricht, was das Braze iOS SDK erwartet, ein Kompilierungsfehler auftritt.
  • Die Parameter key und value sind optionale Parameter, die innerhalb der Methode bedingt entpackt werden. Dies ist nur eine Möglichkeit, sicherzustellen, dass keine nil-Werte an das Braze iOS SDK übergeben werden.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func setCustomAttributeWithKey<T: Equatable>(_ key: String?, andValue value: T?) {
  guard let key = key, let value = value else { return }
  switch value.self {
  case let value as Date:
    user?.setCustomAttributeWithKey(key, andDateValue: value)
  case let value as Bool:
    user?.setCustomAttributeWithKey(key, andBOOLValue: value)
  case let value as String:
    user?.setCustomAttributeWithKey(key, andStringValue: value)
  case let value as Double:
    user?.setCustomAttributeWithKey(key, andDoubleValue: value)
  case let value as Int:
    user?.setCustomAttributeWithKey(key, andIntegerValue: value)
  default:
   return
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (void)setCustomAttributeWith:(NSString *)key andValue:(id)value {
  if ([value isKindOfClass:[NSDate class]]) {
    [[self user] setCustomAttributeWithKey:key andDateValue:value];
  } else if ([value isKindOfClass:[NSString class]]) {
    [[self user] setCustomAttributeWithKey:key andStringValue:value];
  } else if ([value isKindOfClass:[NSNumber class]]) {
    if (strcmp([value objCType], @encode(double)) == 0) {
      [[self user] setCustomAttributeWithKey:key andDoubleValue:[value doubleValue]];
    } else if (strcmp([value objCType], @encode(int)) == 0) {
      [[self user] setCustomAttributeWithKey:key andIntegerValue:[value integerValue]];
    } else if ([value boolValue]) {
      [[self user] setCustomAttributeWithKey:key andBOOLValue:[value boolValue]];
    }
  }
}
Methode zum Protokollieren von Käufen erstellen

Erstellen Sie als Nächstes basierend auf der folgenden Braze SDK-Methode logPurchase eine entsprechende Methode.

Braze logPurchase-Referenzmethode
Dies ist designbedingt so, da nur die BrazeManager.swift-Datei direkt auf die Methoden des Braze iOS SDK zugreifen kann. Durch das Erstellen einer entsprechenden Methode ist das Ergebnis dasselbe und es werden keine direkten Abhängigkeiten zum Braze iOS SDK in Ihrem Produktionscode benötigt.

1
open func logPurchase(_ productIdentifier: String, inCurrency currency: String, atPrice price: NSDecimalNumber, withoutQuantity quantity: UInt)

Entsprechende Methode
Protokollieren Sie Käufe vom Appboy-Objekt zu Braze. Das SDK bietet mehrere Methoden zum Protokollieren von Käufen, und dies ist nur ein Beispiel. Diese Methode übernimmt auch das Erstellen der NSDecimal- und UInt-Objekte. Wie Sie diesen Teil handhaben möchten, bleibt Ihnen überlassen; hier wird nur ein Beispiel gezeigt.

1
2
3
4
5
6
func logPurchase(_ productIdentifier: String, inCurrency currency: String, atPrice price:
String, withQuantity quantity: Int) {

  Appboy.sharedInstance()?.logPurchase(productIdentifier, inCurrency: currency, atPrice: NSDecimalNumber(string: price), withQuantity: UInt(quantity))

}
1
2
3
- (void)logPurchase:(NSString *)productIdentifier inCurrency:(nonnull NSString *)currencyCode atPrice:(nonnull NSDecimalNumber *)price withQuantity:(NSUInteger)quantity {
  [[Appboy sharedInstance] logPurchase:productIdentifier inCurrency:currencyCode atPrice:price withQuantity:quantity];
}

In-App-Nachrichten

Dem ABKInAppMessageUIDelegate entsprechen

Aktivieren Sie als Nächstes Ihren BrazeManager.swift-Dateicode, damit er dem ABKInAppMessageUIDelegate entspricht und die zugehörigen Methoden direkt verarbeiten kann.

Der Code für die Delegate-Konformität wird in den didFinishLaunching...-Methoden in der BrazeManager.swift-Datei hinzugefügt. Ihr Initialisierungscode sollte am Ende wie folgt aussehen:

1
2
3
4
5
6
7
8
9
10
11
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
  Appboy.start(withApiKey: apiKey, in: application, withLaunchOptions: launchOptions, withAppboyOptions: appboyOptions)

  let options: UNAuthorizationOptions = [.alert, .sound, .badge]
  UNUserNotificationCenter.current().requestAuthorization(options: options) { (granted, error) in
    Appboy.sharedInstance()?.pushAuthorization(fromUserNotificationCenter: granted)
  }
  UIApplication.shared.registerForRemoteNotifications()

  Appboy.sharedInstance()?.inAppMessageController.inAppMessageUIController?.setInAppMessageUIDelegate?(self)
}
1
2
3
4
5
6
7
8
9
10
11
- (void)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [Appboy startWithApiKey:[self apiKey] inApplication:application withLaunchOptions:launchOptions withAppboyOptions:[self appboyOptions]];

  UNAuthorizationOptions options = (UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge);
  [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) {
    [[Appboy sharedInstance] pushAuthorizationFromUserNotificationCenter:granted];
  }];
  [[UIApplication sharedApplication] registerForRemoteNotifications];

  [[Appboy sharedInstance].inAppMessageController.inAppMessageUIController setInAppMessageUIDelegate:self];
}
Delegate-Methoden hinzufügen

Erstellen Sie als Nächstes eine Erweiterung, die dem ABKInAppMessageUIDelegate entspricht.

Fügen Sie das folgende Snippet im Analytics-Abschnitt hinzu. Beachten Sie, dass das BrazeManager.swift-Objekt als Delegate gesetzt ist; hier werden alle ABKInAppMessageUIDelegate-Methoden von der BrazeManager.swift-Datei verarbeitet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// MARK: - ABKInAppMessage UI Delegate
extension AppboyManager: ABKInAppMessageUIDelegate{
  func inAppMessageViewControllerWith(_ inAppMessage: ABKInAppMessage) -> ABKInAppMessageViewController {
    switch inAppMessage {
    case is ABKInAppMessageSlideup:
      return ABKInAppMessageSlideupViewController(inAppMessage: inAppMessage)
    case is ABKInAppMessageModal:
      return ABKInAppMessageModalViewController(inAppMessage: inAppMessage)
    case is ABKInAppMessageFull:
      return ABKInAppMessageFullViewController(inAppMessage: inAppMessage)
    case is ABKInAppMessageHTML:
      return ABKInAppMessageHTMLViewController(inAppMessage: inAppMessage)
    default:
      return ABKInAppMessageViewController(inAppMessage: inAppMessage)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// MARK: - ABKInAppMessage UI Delegate
- (ABKInAppMessageViewController *)inAppMessageViewControllerWithInAppMessage:(ABKInAppMessage *)inAppMessage {
  if ([inAppMessage isKindOfClass:[ABKInAppMessageSlideup class]]) {
    return [[ABKInAppMessageSlideupViewController alloc] initWithInAppMessage:inAppMessage];
  } else if ([inAppMessage isKindOfClass:[ABKInAppMessageModal class]]) {
    return [[ABKInAppMessageModalViewController alloc] initWithInAppMessage:inAppMessage];
  } else if ([inAppMessage isKindOfClass:[ABKInAppMessageFull class]]) {
    return [[ABKInAppMessageFullViewController alloc] initWithInAppMessage:inAppMessage];
  } else if ([inAppMessage isKindOfClass:[ABKInAppMessageHTML class]]) {
    return [[ABKInAppMessageHTMLViewController alloc] initWithInAppMessage:inAppMessage];
  }
  return nil;
}

Content Cards

Content-Card-Variablen und -Methoden erstellen

Ermöglichen Sie es Ihrem Produktionscode, den Content-Cards-View-Controller ohne unnötige import AppboyUI-Statements anzuzeigen.

Erstellen Sie eine Erweiterung für Ihren Content-Cards-Code in Ihrer BrazeManager.swift-Datei, damit er übersichtlicher lesbar ist und der Zweck in der Hilfsdatei klar erkennbar wird:

  1. Zeigen Sie den ABKContentCardsTableViewController an. Ein optionaler navigationController ist der einzige benötigte Parameter, um unseren View-Controller zu präsentieren oder zu pushen.
  2. Initialisieren Sie ein ABKContentCardsTableViewController-Objekt und ändern Sie optional den Titel. Sie müssen außerdem den initialisierten View-Controller zum Navigation-Stack hinzufügen.
1
2
3
4
5
6
7
8
9
10
11
12
// MARK: - Content Cards
extension BrazeManager {

  // 1
  func displayContentCards(navigationController: UINavigationController?) {

    // 2
    let contentCardsVc = ABKContentCardsTableViewController()
    contentCardsVc.title = "Content Cards"
    navigationController?.pushViewController(contentCardsVc, animated: true)
  }
}
1
2
3
4
5
6
7
8
// MARK: - Content Cards
  // 1
- (void)displayContentCards:(UINavigationController *)navigationController {
  // 2
  ABKContentCardsTableViewController *contentCardsVc = [[ABKContentCardsTableViewController alloc] init];
  contentCardsVc.title = @"Content Cards";
  [navigationController pushViewController:contentCardsVc animated:YES];
}

Nächste Schritte

Herzlichen Glückwunsch! Sie haben diesen Leitfaden zur Best-Practice-Integration abgeschlossen! Eine Beispieldatei für den BrazeManager-Helper finden Sie auf GitHub.

Nachdem Sie alle Abhängigkeiten vom Braze iOS SDK vom Rest Ihres Produktionscodes entkoppelt haben, sehen Sie sich einige unserer optionalen erweiterten Implementierungsleitfäden an:

New Stuff!