Skip to content


Guide d’intégration SDK de Braze pour iOS

Ce guide d’intégration iOS facultatif vous guide étape par étape sur 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édoublera toutes les dépendances sur le SDK Braze pour iOS du reste de votre code de production, ce qui entraînera une import AppboyUI dans toute votre application. Cette approche limite les problèmes liés aux importations excessives de SDK, ce qui facilite le suivi, le débogage et la modification du code.

Présentation de l’intégration

Les étapes suivantes vous aident à créer un fichier d’aide BrazeManager qui sera appelé par votre code de production. Ce fichier d’aide traitera de toutes les dépendances liées au Braze en ajoutant diverses extensions pour les sujets d’intégration suivants répertoriés. Chaque sujet inclura des étapes de tabulation horizontale et des extraits de code à la fois en Swift et en Objective-C. Notez que les étapes de la carte de contenu et du message in-app ne sont pas nécessaires à 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 créer votre fichier BrazeManager.swift, créez un nouveau fichier Swift nommé BrazeManager à ajouter à votre projet dans votre emplacement souhaité. Ensuite, remplacez import Foundation par import AppboyUI pour le SPM (import Appboy_iOS_SDK pour CocoaPods), puis créez une classe BrazeManager qui servira à 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. Il est garanti que cela sera mollement lancé qu’une seule fois.
  2. Ensuite, ajoutez une variable constante privée nommée apiKey et définissez-la comme clé-valeur 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 pour le 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 à partir de 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 le point d’endpoint de votre SDK pour l’espace de travail et LogLevel dans votre fichier Info.plist ou dans appboyOptions.

Ajouter la méthode didFinishLaunchingWithOptions à partir 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 de déclaration import AppboyUI dans votre fichier AppDelegate.swift.

Ensuite, initialisez le SDK en utilisant vos variables nouvellement déclarées apiKey et 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]];
}
Gérer l’initialisation Appboy dans l’AppDelegate.swift

Ensuite, revenez au fichier AppDelegate.swift et ajoutez l’extrait de code suivant dans la méthode didFinishLaunchingWithOptions AppDelegate pour gérer l’initialisation Appboy du fichier d’aide BrazeManager.swift. N’oubliez pas qu’il n’est pas nécessaire d’ajouter une déclaration import AppboyUI dans le 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 un certificat de notification push

Accédez à votre espace de travail existant dans le tableau de bord de Braze. Sous Paramètres de notification push, téléchargez votre fichier de certificat push dans votre tableau de bord de Braze et enregistrez-le.

Inscrivez-vous aux notifications push

Ensuite, inscrivez-vous aux notifications push. Ce guide part du principe que vous avez correctement configuré vos informations d’identification push dans votre portail de développement Apple et dans votre projet Xcode.

Le code d’enregistrement des notifications push sera ajouté dans la méthode didFinishLaunching... dans le fichier BrazeManager.swift. Votre code d’initialisation devrait ressembler à ceci :

  1. Configurez le contenu pour demander l’autorisation d’interagir avec l’utilisateur. Ces options sont présentées à titre d’exemple.
  2. Demandez une autorisation pour envoyer les notifications push de vos utilisateurs. La réponse de l’utilisateur à autoriser ou refuser les notifications push est suivie dans la variable granted.
  3. Transférer les résultats d’autorisation de notification push à Braze après que l’utilisateur interagit avec l’invite de notification.
  4. Lancer le processus d’inscription avec des APN ; cela devrait être fait dans le fil principal. Si l’enregistrement réussit, l’application appelle la méthode AppDelegate de l’objet didRegisterForRemoteNotificationsWithDeviceToken.
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];
}
Transférer les méthodes de notification push

Ensuite, transférez les méthodes de notifications push système de AppDelegate.swift vers BrazeManager.swift à manipuler par le SDK Braze pour iOS.

É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 de sorte qu’il puisse être lu de manière plus organisée dans le cadre de l’objectif du fichier d’aide, comme :

  1. Suivre le modèle de non-inclusion d’une déclaration import AppboyUI dans votre AppDelegate, nous allons gérer les méthodes de notification push dans le fichier BrazeManager.swift. Les jetons d’appareil de l’utilisateur devront être transmis à Braze depuis la méthode didRegisterForRemote.... Cette méthode est requise pour mettre en œuvre des notifications push silencieuses. Ensuite, ajoutez la même méthode à partir de AppDelegate dans votre classe BrazeManager.
  2. Ajoutez la ligne suivante à l’intérieur de la méthode pour enregistrer le jeton d’appareil dans Braze. Ceci 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 : Support des notifications à distance

Dans l’onglet Capacités& de signature, veuillez ajouter la prise en charge des modes d’arrière-plan et sélectionner Notifications à distance pour commencer à prendre en charge les notifications push à distance provenant de Braze.

Capacités& de signature

Étape 3 : Gestion des notifications à distance

Le SDK Braze peut gérer les notifications push à distance provenant de Braze. Transférer 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 à la notification

Le SDK Braze peut gérer la réponse des notifications push provenant de Braze. Transférer la réponse des notifications à Braze ; le SDK ignore 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 des variables et des méthodes utilisateur

Ensuite, vous souhaiterez un accès facile aux variables et aux méthodes ABKUser. Créez une extension pour votre code de notification push dans votre fichier BrazeManager.swift de sorte qu’il puisse être lu de manière plus organisée dans le cadre de l’objectif du fichier d’aide, comme :

  1. Un objet ABKUser représente un utilisateur connu ou anonyme dans votre application iOS. Ajoutez une variable calculée pour récupérer le ABKUser ; cette variable sera réutilisée pour récupérer des variables concernant l’utilisateur.
  2. Interrogez la variable utilisateur pour accéder facilement au userId. Parmi les autres variables, le ABKUser est responsable de (firstName, lastName, phone, homeCity, etc.)
  3. Définir l’utilisateur en utilisant 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];
}

Enregistrer les analyses

Créer une méthode d’événement personnalisé de journal

En vous basant sur la méthode logCustomEvent SDK Braze suivante, créez une méthode de correspondance.

Méthode de référence logCustomEvent de Braze
C’est par conception parce que seul le fichier BrazeManager.swift peut accéder directement aux méthodes SDK Braze pour iOS. Par conséquent, en créant une méthode de correspondance, le résultat est le même et se fait sans avoir besoin de dépendances directes sur le SDK Braze pour iOS dans votre code de production.

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

Méthode de correspondance
Consignez les événements personnalisés de l’objet Appboy dans Braze. Properties est un paramètre facultatif avec une valeur par défaut de zéro. Les événements personnalisés n’ont pas besoin d’avoir des propriétés, mais doivent 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 une méthode d’attributs personnalisés de journal

Le SDK peut enregistrer plusieurs types comme attributs personnalisés. Il n’est pas nécessaire de créer des méthodes d’aide pour chaque type de valeur pouvant être défini. À la place, exposez qu’une seule méthode permettant de filtrer jusqu’à la valeur appropriée.

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 enregistrés depuis l’objet ABKUser.

Créez une méthode pouvant englober tous les types disponibles pouvant être définis pour un attribut. Ajoutez cette méthode dans votre fichier BrazeManager.swift dans l’extension analytique. On peut y parvenir 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 correspond au protocole Equatable. Cela est explicitement fait, donc si le type n’est pas ce que le SDK de Braze iOS prévoit, il y aura une erreur de compilation.
  • Les paramètres key et value sont des paramètres facultatifs qui seront conditionnellement désencapsulés dans la méthode. Ce n’est qu’un moyen de s’assurer que des valeurs non nulles sont transmises au SDK Braze pour iOS.
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éez une méthode de journalisation des achats

Puis, en vous basant sur la méthode logPurchase SDK Braze suivante, créez une méthode de correspondance.

Méthode de référence logPurchase de Braze
C’est par conception parce que seul le fichier BrazeManager.swift peut accéder directement aux méthodes SDK Braze pour iOS. Par conséquent, en créant une méthode de correspondance, le résultat est le même et se fait sans avoir besoin de dépendances directes sur le SDK Braze pour iOS dans votre code de production.

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

Méthode de correspondance
Enregistrez les achats depuis l’objet Appboy dans Braze. Le SDK a plusieurs méthodes pour enregistrer les achats, et ce n’est qu’un exemple. Cette méthode gère également la création des objets NSDecimal et UInt. La façon dont vous voulez gérer cette partie dépend de vous, un seul exemple est fourni.

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

Conforme à ABKinAppMessageUIDelegate

Ensuite, activez votre code de fichier BrazeManager.swift pour se conformer à ABKInAppMessageUIDelegate afin de gérer directement les méthodes associées.

Le code de conformité au délégué sera ajouté dans les méthodes didFinishLaunching... au 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];
}
Ajoutez des méthodes de délégation

Ensuite, créez une extension qui correspond à la ABKInAppMessageUIDelegate.

Ajoutez la section d’analyse de l’extrait de code suivant. Notez que l’objet BrazeManager.swift est défini comme délégué ; ce sera l’endroit où le fichier BrazeManager.swift traite 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;
}

Cartes de contenu

Créez des variables et des méthodes de carte de contenu

Activez votre code de production pour afficher le contrôleur de visualisation des cartes de contenu sans besoin de déclarations import AppboyUI inutiles.

Créez une extension pour votre code de notification push dans votre fichier BrazeManager.swift de sorte qu’il puisse être lu de manière plus organisée dans le cadre de l’objectif du fichier d’aide, comme :

  1. Afficher le ABKContentCardsTableViewController. Un navigationController facultatif est le seul paramètre nécessaire pour présenter ou forcer notre contrôleur de visualisation.
  2. Initialiser un ABKContentCardsTableViewController et modifiez le titre en option. Vous devez également ajouter le contrôleur de visualisation 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 meilleures pratiques ! Vous trouverez un exemple de fichier d’aide BrazeManager sur GitHub.

Maintenant que vous avez dissocié toutes les dépendances du SDK Braze pour iOS du reste de votre code de production, consultez certains de nos guides d’implémentation avancés facultatifs :

New Stuff!