
Das AppboyKit (auch bekannt als Objective-C SDK) wird nicht mehr unterstützt und wurde durch das Swift SDK. ] ersetzt. Es wird keine neuen Features, Fehlerbehebungen, Sicherheitsupdates oder technischen Support mehr erhalten - Messaging und Analytics werden jedoch weiterhin wie gewohnt funktionieren. Weitere Informationen finden Sie unter Einführung in das neue Braze Swift SDK.
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 einzigenimport AppboyUIin 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.

Diese Anleitung geht davon aus, dass Sie das SDK bereits zu Ihrem Xcode-Projekt hinzugefügt haben.
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
- SDK initialisieren
- Push-Benachrichtigungen
- Auf Nutzervariablen und -methoden zugreifen
- Analytics protokollieren
- In-App-Nachrichten (optional)
- Content Cards (optional)
- Nächste Schritte
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

BrazeManagerist eineNSObject-Klasse und kein Struct, damit sie ABK-Delegates wie demABKInAppMessageUIDelegateentsprechen kann.BrazeManagerist designbedingt eine Singleton-Klasse, sodass nur eine Instanz dieser Klasse verwendet wird. Dies bietet einen einheitlichen Zugriffspunkt auf das Objekt.
- Fügen Sie eine statische Variable namens shared hinzu, die die
BrazeManager-Klasse initialisiert. Es ist garantiert, dass diese nur einmal lazily initialisiert wird. - 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.
- 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.

Die Initialisierung sollte im Haupt-Thread erfolgen.
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]];
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
An diesem Punkt sollte das SDK laufen. Überprüfen Sie in Ihrem Dashboard, dass Sitzungen protokolliert werden, bevor Sie fortfahren.
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.


Überspringen Sie nicht den dedizierten Checkpoint am Ende dieses Schritts!
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:
- Konfigurieren Sie die Inhalte für die Anfrage zur Autorisierung der Interaktion mit Nutzer:innen. Diese Optionen sind als Beispiel aufgeführt.
- 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
grantedgespeichert. - Leiten Sie die Push-Autorisierungsergebnisse an Braze weiter, nachdem Nutzer:innen mit der Benachrichtigungsaufforderung interagiert haben.
- Starten Sie den Registrierungsprozess bei APNs; dies sollte im Haupt-Thread erfolgen. Bei erfolgreicher Registrierung ruft die App die Methode
didRegisterForRemoteNotificationsWithDeviceTokenIhresAppDelegate-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];
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
- Bestätigen Sie in Ihrer App, dass Sie zur Erlaubnis von Push-Benachrichtigungen aufgefordert werden, bevor Sie fortfahren.
- Wenn Sie nicht aufgefordert werden, versuchen Sie, die App zu löschen und neu zu installieren, um sicherzustellen, dass die Push-Benachrichtigungsaufforderung nicht bereits zuvor angezeigt wurde.
Stellen Sie sicher, dass Sie zur Erlaubnis von Push-Benachrichtigungen aufgefordert werden, bevor Sie fortfahren.
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:
- Nach dem Muster, kein
import AppboyUI-Statement in IhremAppDelegateeinzufügen, werden die Push-Benachrichtigungsmethoden in derBrazeManager.swift-Datei behandelt. Die Device-Tokens der Nutzer:innen müssen über die MethodedidRegisterForRemote...an Braze übergeben werden. Diese Methode wird benötigt, um Silent-Push-Benachrichtigungen zu implementieren. Fügen Sie anschließend dieselbe Methode aus demAppDelegatein IhreBrazeManager-Klasse ein. - 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.
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];
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
Versuchen Sie, sich selbst eine Push-Benachrichtigung über das Braze-Dashboard zu senden, und stellen Sie sicher, dass Analytics aus Push-Benachrichtigungen protokolliert werden, bevor Sie fortfahren.
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:
- 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 dasABKUser-Objekt abzurufen; diese Variable wird wiederverwendet, um Variablen über die:den Nutzer:in abzurufen. - Fragen Sie die Nutzervariable ab, um einfach auf die
userIdzuzugreifen. Neben den anderen Variablen ist dasABKUser-Objekt verantwortlich für (firstName,lastName,phone,homeCityusw.) - Setzen Sie die:den Nutzer:in, indem Sie
changeUser()mit einer entsprechendenuserIdaufrufen.
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];
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
Versuchen Sie, Nutzer:innen über einen erfolgreichen Anmelde-/Registrierungsvorgang zu identifizieren. Stellen Sie sicher, dass Sie ein solides Verständnis davon haben, was ein geeigneter Nutzerbezeichner ist und was nicht.
Überprüfen Sie in Ihrem Dashboard, dass der Nutzerbezeichner protokolliert wird, bevor Sie fortfahren.
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
valueist ein generischer Typ, der demEquatable-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
keyundvaluesind 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];
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
Versuchen Sie, angepasste Events zu protokollieren.
Überprüfen Sie in Ihrem Dashboard, dass die angepassten Events protokolliert werden, bevor Sie fortfahren.
In-App-Nachrichten

Der folgende Abschnitt zu In-App-Nachrichten ist für die Integration nicht erforderlich, wenn Sie diesen Kanal in Ihrer Anwendung nicht nutzen möchten.
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.

Der ABKInAppMessageUIDelegate enthält keine Pflichtmethoden, aber das Folgende ist ein Beispiel für eine solche.
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;
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
Versuchen Sie, sich selbst eine In-App-Nachricht zu senden.
Setzen Sie in der BrazeManager.swift-Datei einen Breakpoint am Einstiegspunkt der ABKInAppMessageUIDelegate-Beispielmethode. Senden Sie sich selbst eine In-App-Nachricht und bestätigen Sie, dass der Breakpoint erreicht wird, bevor Sie fortfahren.
Content Cards

Der folgende Abschnitt zu Content Cards ist für die Integration nicht erforderlich, wenn Sie diesen Kanal in Ihrer Anwendung nicht nutzen möchten.
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:
- Zeigen Sie den
ABKContentCardsTableViewControlleran. Ein optionalernavigationControllerist der einzige benötigte Parameter, um unseren View-Controller zu präsentieren oder zu pushen. - 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];
}

Fahren Sie mit dem Kompilieren Ihres Codes fort und starten Sie Ihre Anwendung.
Versuchen Sie, den ABKContentCardsTableViewController in Ihrer Anwendung anzuzeigen, bevor Sie fortfahren.
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:
- Erweiterter Implementierungsleitfaden für Push-BenachrichtigungenOptionale erweiterte Muster zur Anpassung des Verhaltens von Push-Benachrichtigungen in Ihrer iOS-App.
- Erweiterter Implementierungsleitfaden für In-App-NachrichtenOptionale erweiterte Muster zur Anpassung der Zustellung und Anzeige von In-App-Nachrichten.
- Erweiterter Implementierungsleitfaden für Content CardsOptionale erweiterte Muster zur Anpassung von Content-Card-Feeds und der UI.