
AppboyKit (également connu sous le nom de SDK Objective-C) n’est plus pris en charge et a été remplacé par Swift SDK. Il ne recevra plus de nouvelles fonctionnalités, de corrections de bugs, de mises à jour de sécurité ou d’assistance technique - cependant, la messagerie et l’analyse continueront à fonctionner normalement. Pour en savoir plus, consultez Présentation du nouveau SDK Braze Swift.
Guide d’intégration SDK de Braze pour iOS
Ce guide d’intégration iOS facultatif vous accompagne étape par étape dans les meilleures pratiques de configuration lors de la première intégration du SDK iOS et de ses principaux composants dans votre application. Ce guide vous aidera à créer un fichier d’aide
BrazeManager.swiftqui découplera toutes les dépendances du SDK Braze pour iOS du reste de votre code de production, ce qui se traduira par un seulimport AppboyUIdans l’ensemble de votre application. Cette approche limite les problèmes liés aux importations excessives du SDK, ce qui facilite le suivi, le débogage et la modification du code.

Aperçu de l’intégration
Les étapes suivantes vous aident à créer un fichier d’aide BrazeManager que votre code de production appelle. Ce fichier d’aide gèrera toutes les dépendances liées à Braze en ajoutant diverses extensions pour les sujets d’intégration suivants. Chaque sujet inclura des étapes avec des onglets horizontaux et des extraits de code en Swift et en Objective-C. Notez que les étapes relatives aux Content Cards et aux In-App Messages ne sont pas requises pour l’intégration si vous ne prévoyez pas d’utiliser ces canaux dans votre application.
- Créer BrazeManager.swift
- Initialiser le SDK
- Notifications push
- Accéder aux variables et méthodes utilisateur
- Journaliser les données d’analyse
- In-App Messages (optionnel)
- Content Cards (optionnel)
- Étapes suivantes
Créer BrazeManager.swift
Créer BrazeManager.swift
Pour construire votre fichier BrazeManager.swift, créez un nouveau fichier Swift nommé BrazeManager à ajouter à votre projet à l’emplacement souhaité. Ensuite, remplacez import Foundation par import AppboyUI pour SPM (import Appboy_iOS_SDK pour CocoaPods) puis créez une classe BrazeManager qui sera utilisée pour héberger toutes les méthodes et variables liées à Braze. Appboy_iOS_SDK

BrazeManagerest une classeNSObjectet non une struct, afin de pouvoir se conformer aux délégués ABK tels queABKInAppMessageUIDelegate.BrazeManagerest une classe singleton par conception, de sorte qu’une seule instance de cette classe sera utilisée. Cela permet de fournir un point d’accès unifié à l’objet.
- Ajoutez une variable statique nommée shared qui initialise la classe
BrazeManager. Celle-ci est garantie d’être initialisée paresseusement une seule fois. - Ensuite, ajoutez une variable constante privée nommée apiKey et définissez-la comme la valeur de la clé API de votre espace de travail dans le tableau de bord de Braze.
- Ajoutez une variable calculée privée nommée appboyOptions, qui stockera les valeurs de configuration du SDK. Elle sera vide pour l’instant.
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];
}
Initialiser le SDK
Initialiser le SDK depuis BrazeManager.swift
Ensuite, vous devez initialiser le SDK. Ce guide suppose que vous avez déjà ajouté le SDK à votre projet Xcode. Vous devez également avoir défini votre endpoint SDK de l’espace de travail et le LogLevel dans votre fichier Info.plist ou dans appboyOptions.
Ajoutez la méthode didFinishLaunchingWithOptions du fichier AppDelegate.swift sans type de retour dans votre fichier BrazeManager.swift. En créant une méthode similaire dans le fichier BrazeManager.swift, il n’y aura pas d’instruction import AppboyUI dans votre fichier AppDelegate.swift.
Ensuite, initialisez le SDK en utilisant vos variables apiKey et appboyOptions nouvellement déclarées.

L’initialisation doit être effectuée dans le fil d’exécution principal.
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]];
}

Compilez votre code et exécutez votre application.
À ce stade, le SDK devrait être opérationnel. Dans votre tableau de bord, vérifiez que les sessions sont enregistrées avant d’aller plus loin.
Notifications push
Ajouter le certificat push
Accédez à votre espace de travail existant dans le tableau de bord de Braze. Sous Push Notification Settings, téléversez votre fichier de certificat push sur votre tableau de bord de Braze et enregistrez-le.


Ne manquez pas le point de contrôle dédié à la fin de cette étape !
S’inscrire aux notifications push
Ensuite, inscrivez-vous aux notifications push. Ce guide suppose que vous avez correctement configuré vos identifiants push dans votre portail développeur Apple et dans votre projet Xcode.
Le code d’inscription aux notifications push sera ajouté dans la méthode didFinishLaunching... du fichier BrazeManager.swift. Votre code d’initialisation devrait ressembler à ceci :
- Configurez le contenu de la demande d’autorisation d’interaction avec l’utilisateur. Ces options sont listées à titre d’exemple.
- Demandez l’autorisation d’envoyer des notifications push à vos utilisateurs. La réponse de l’utilisateur pour autoriser ou refuser les notifications push est suivie dans la variable
granted. - Transmettez les résultats de l’autorisation push à Braze après que l’utilisateur a interagi avec l’invite de notification.
- Lancez le processus d’inscription auprès des APN ; cela doit être fait dans le fil d’exécution principal. Si l’inscription réussit, l’application appelle la méthode
didRegisterForRemoteNotificationsWithDeviceTokende votre objetAppDelegate.
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];
}

Compilez votre code et exécutez votre application.
- Dans votre application, confirmez que vous recevez l’invite pour les notifications push avant d’aller plus loin.
- Si vous ne recevez pas l’invite, essayez de supprimer et de réinstaller l’application pour vous assurer que l’invite de notification push n’a pas été affichée précédemment.
Vérifiez que vous recevez l’invite pour les notifications push avant d’aller plus loin.
Transmettre les méthodes de notification push
Ensuite, transmettez les méthodes système de notification push depuis AppDelegate.swift vers BrazeManager.swift pour qu’elles soient gérées par le SDK iOS de Braze.
Étape 1 : Créer une extension pour le code de notification push
Créez une extension pour votre code de notification push dans votre fichier BrazeManager.swift afin qu’il soit organisé de manière plus lisible quant au rôle servi dans le fichier d’aide, comme suit :
- En suivant le principe de ne pas inclure d’instruction
import AppboyUIdans votreAppDelegate, nous allons gérer les méthodes de notification push dans le fichierBrazeManager.swift. Les jetons d’appareil des utilisateurs devront être transmis à Braze depuis la méthodedidRegisterForRemote.... Cette méthode est nécessaire pour implémenter les notifications push silencieuses. Ensuite, ajoutez la même méthode de l’AppDelegatedans votre classeBrazeManager. - Ajoutez la ligne suivante à l’intérieur de la méthode pour enregistrer le jeton d’appareil auprès de Braze. Cela est nécessaire pour que Braze associe le jeton à l’appareil actuel.
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];
}
Étape 2 : Prendre en charge les notifications à distance
Dans l’onglet Signing & Capabilities, ajoutez la prise en charge de Background Modes et sélectionnez Remote notifications pour commencer à prendre en charge les notifications push à distance provenant de Braze.
Étape 3 : Gestion des notifications à distance
Le SDK de Braze peut gérer les notifications push à distance provenant de Braze. Transmettez les notifications à distance à Braze ; le SDK ignorera automatiquement les notifications push qui ne proviennent pas de Braze. Ajoutez la méthode suivante à votre fichier BrazeManager.swift dans l’extension de notification push.
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];
}
Étape 4 : Transmettre les réponses aux notifications
Le SDK de Braze peut gérer les réponses aux notifications push provenant de Braze. Transmettez les réponses des notifications à Braze ; le SDK ignorera automatiquement les réponses des notifications push qui ne proviennent pas de Braze. Ajoutez la méthode suivante à votre fichier BrazeManager.swift :
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];
}

Compilez votre code et exécutez votre application.
Essayez de vous envoyer une notification push depuis le tableau de bord de Braze et vérifiez que les données d’analyse sont enregistrées à partir des notifications push avant d’aller plus loin.
Accéder aux variables et méthodes utilisateur
Créer les variables et méthodes utilisateur
Ensuite, vous voudrez un accès facile aux variables et méthodes ABKUser. Créez une extension pour votre code utilisateur dans le fichier BrazeManager.swift afin qu’il soit organisé de manière plus lisible quant au rôle servi dans le fichier d’aide, comme suit :
- Un objet
ABKUserreprésente un utilisateur connu ou anonyme dans votre application iOS. Ajoutez une variable calculée pour récupérer l’ABKUser; cette variable sera réutilisée pour récupérer des informations sur l’utilisateur. - Interrogez la variable utilisateur pour accéder facilement au
userId. Parmi les autres variables, l’objetABKUserest responsable de (firstName,lastName,phone,homeCity, etc.) - Définissez l’utilisateur en appelant
changeUser()avec unuserIdcorrespondant.
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];
}

Compilez votre code et exécutez votre application.
Essayez d’identifier les utilisateurs lors d’une connexion ou d’une inscription réussie. Assurez-vous d’avoir une bonne compréhension de ce qui constitue ou non un identifiant utilisateur approprié.
Dans votre tableau de bord, vérifiez que l’identifiant utilisateur est enregistré avant d’aller plus loin.
Journaliser les données d’analyse
Créer la méthode de journalisation d’événement personnalisé
Basez-vous sur la méthode logCustomEvent suivante du SDK de Braze pour créer une méthode correspondante.
Méthode de référence logCustomEvent de Braze
Ceci est conçu intentionnellement car seul le fichier BrazeManager.swift peut accéder directement aux méthodes du SDK iOS de Braze. Par conséquent, en créant une méthode correspondante, le résultat est le même et est réalisé sans avoir besoin de dépendances directes au SDK iOS de Braze dans votre code de production.
1
open func logCustomEvent(_ eventName: String, withProperties properties: [AnyHashable : Any]?)
Méthode correspondante
Journalisez les événements personnalisés depuis l’objet Appboy vers Braze. Properties est un paramètre optionnel avec une valeur par défaut de nil. Les événements personnalisés ne nécessitent pas obligatoirement de propriétés mais doivent obligatoirement avoir un nom.
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];
}
Créer la méthode de journalisation d’attributs personnalisés
Le SDK peut journaliser de nombreux types comme attributs personnalisés. Il n’est pas nécessaire de créer des méthodes d’aide pour chaque type de valeur qui peut être défini. À la place, exposez une seule méthode qui peut filtrer vers le type de valeur approprié.
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;
Les attributs personnalisés sont journalisés depuis l’objet ABKUser.
Créez une méthode qui peut englober tous les types disponibles pouvant être définis pour un attribut. Ajoutez cette méthode dans votre fichier BrazeManager.swift dans l’extension d’analyse. Cela peut être fait en filtrant les types d’attributs personnalisés valides et en appelant la méthode associée au type correspondant.
- Le paramètre
valueest un type générique qui se conforme au protocoleEquatable. Ceci est fait explicitement, de sorte que si le type n’est pas celui attendu par le SDK iOS de Braze, il y aura une erreur de compilation. - Les paramètres
keyetvaluesont des paramètres optionnels qui seront conditionnellement déballés dans la méthode. C’est une façon parmi d’autres de s’assurer que des valeurs non-nil sont transmises au SDK iOS de Braze.
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]];
}
}
}
Créer la méthode de journalisation d’achat
Ensuite, basez-vous sur la méthode logPurchase suivante du SDK de Braze pour créer une méthode correspondante.
Méthode de référence logPurchase de Braze
Ceci est conçu intentionnellement car seul le fichier BrazeManager.swift peut accéder directement aux méthodes du SDK iOS de Braze. Par conséquent, en créant une méthode correspondante, le résultat est le même et est réalisé sans avoir besoin de dépendances directes au SDK iOS de Braze dans votre code de production.
1
open func logPurchase(_ productIdentifier: String, inCurrency currency: String, atPrice price: NSDecimalNumber, withoutQuantity quantity: UInt)
Méthode correspondante
Journalisez les achats depuis l’objet Appboy vers Braze. Le SDK dispose de plusieurs méthodes pour journaliser les achats, et ceci n’est qu’un exemple. Cette méthode gère également la création des objets NSDecimal et UInt. La façon dont vous souhaitez gérer cette partie vous appartient, ce qui est fourni n’est qu’un exemple.
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];
}

Compilez votre code et exécutez votre application.
Essayez de journaliser des événements personnalisés.
Dans votre tableau de bord, vérifiez que les événements personnalisés sont enregistrés avant d’aller plus loin.
In-App Messages

La section suivante concernant les In-App Messages n’est pas requise pour l’intégration si vous ne prévoyez pas d’utiliser ce canal dans votre application.
Se conformer à ABKInAppMessageUIDelegate
Ensuite, activez votre code dans le fichier BrazeManager.swift pour se conformer à ABKInAppMessageUIDelegate afin de gérer directement les méthodes associées.
Le code pour se conformer au délégué sera ajouté dans les méthodes didFinishLaunching... du fichier BrazeManager.swift. Votre code d’initialisation devrait ressembler à ceci :
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];
}
Ajouter les méthodes du délégué
Ensuite, créez une extension qui se conforme à ABKInAppMessageUIDelegate.
Ajoutez l’extrait suivant dans la section d’analyse. Notez que l’objet BrazeManager.swift est défini comme délégué ; c’est ici que le fichier BrazeManager.swift gérera toutes les méthodes ABKInAppMessageUIDelegate.

ABKInAppMessageUIDelegate ne comporte aucune méthode requise, mais voici un exemple d’utilisation.
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;
}

Compilez votre code et exécutez votre application.
Essayez de vous envoyer un message in-app.
Dans le fichier BrazeManager.swift, placez un point d’arrêt à l’entrée de la méthode d’exemple ABKInAppMessageUIDelegate. Envoyez-vous un message in-app et confirmez que le point d’arrêt est atteint avant d’aller plus loin.
Content Cards

La section suivante concernant les Content Cards n’est pas requise pour l’intégration si vous ne prévoyez pas d’utiliser ce canal dans votre application.
Créer les variables et méthodes Content Cards
Activez votre code de production pour afficher le contrôleur de vue Content Cards sans avoir besoin d’instructions import AppboyUI inutiles.
Créez une extension pour votre code Content Cards dans votre fichier BrazeManager.swift, afin qu’il soit organisé de manière plus lisible quant au rôle servi dans le fichier d’aide, comme suit :
- Affichez le
ABKContentCardsTableViewController. UnnavigationControlleroptionnel est le seul paramètre nécessaire pour présenter ou empiler notre contrôleur de vue. - Initialisez un objet
ABKContentCardsTableViewControlleret changez éventuellement le titre. Vous devez également ajouter le contrôleur de vue initialisé à la pile de navigation.
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];
}

Compilez votre code et exécutez votre application.
Essayez d’afficher le ABKContentCardsTableViewController dans votre application avant d’aller plus loin.
Étapes suivantes
Félicitations ! Vous avez terminé ce guide d’intégration des bonnes pratiques ! Un exemple de fichier helper BrazeManager est disponible sur GitHub.
Maintenant que vous avez découplé toute dépendance au SDK Braze pour iOS du reste de votre code de production, consultez certains de nos guides d’implémentation avancée optionnels :
- Advanced push notification implementation guideOptional advanced patterns for customizing push notification behavior in your iOS app.
- Advanced in-app messages implementation guideOptional advanced patterns for customizing in-app message delivery and display.
- Advanced Content Card implementation guideOptional advanced patterns for customizing Content Card feeds and UI.