Skip to content


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.swift qui découplera toutes les dépendances du SDK Braze pour iOS du reste de votre code de production, ce qui se traduira par un seul import AppboyUI dans 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

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

  1. Ajoutez une variable statique nommée shared qui initialise la classe BrazeManager. Celle-ci est garantie d’être initialisée paresseusement une seule fois.
  2. 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.
  3. 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.

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]];
}
Gérer l’initialisation d’Appboy dans AppDelegate.swift

Ensuite, retournez dans le fichier AppDelegate.swift et ajoutez l’extrait de code suivant dans la méthode didFinishLaunchingWithOptions de l’AppDelegate pour gérer l’initialisation d’Appboy depuis le fichier d’aide BrazeManager.swift. N’oubliez pas qu’il n’est pas nécessaire d’ajouter une instruction import AppboyUI dans le fichier AppDelegate.swift.

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

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.

Paramètres de notification push du tableau de bord de Braze avec les champs de téléversement de clé APN.

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 :

  1. Configurez le contenu de la demande d’autorisation d’interaction avec l’utilisateur. Ces options sont listées à titre d’exemple.
  2. 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.
  3. Transmettez les résultats de l’autorisation push à Braze après que l’utilisateur a interagi avec l’invite de notification.
  4. 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 didRegisterForRemoteNotificationsWithDeviceToken de votre objet AppDelegate.
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];
}
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 :

  1. En suivant le principe de ne pas inclure d’instruction import AppboyUI dans votre AppDelegate, nous allons gérer les méthodes de notification push dans le fichier BrazeManager.swift. Les jetons d’appareil des utilisateurs devront être transmis à Braze depuis la méthode didRegisterForRemote.... Cette méthode est nécessaire pour implémenter les notifications push silencieuses. Ensuite, ajoutez la même méthode de l’AppDelegate dans votre classe BrazeManager.
  2. 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.

Signing et Capabilities

É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];
}

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 :

  1. Un objet ABKUser repré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.
  2. Interrogez la variable utilisateur pour accéder facilement au userId. Parmi les autres variables, l’objet ABKUser est responsable de (firstName, lastName, phone, homeCity, etc.)
  3. Définissez l’utilisateur en appelant changeUser() avec un userId correspondant.
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];
}

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 value est un type générique qui se conforme au protocole Equatable. 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 key et value sont 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];
}

In-App Messages

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.

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

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 :

  1. Affichez le ABKContentCardsTableViewController. Un navigationController optionnel est le seul paramètre nécessaire pour présenter ou empiler notre contrôleur de vue.
  2. Initialisez un objet ABKContentCardsTableViewController et 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];
}

É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 :

New Stuff!