Skip to content


Guia de integração do SDK do Braze para iOS

Este guia opcional de integração do iOS leva você a uma jornada passo a passo sobre as práticas recomendadas de configuração ao integrar pela primeira vez o SDK do iOS e seus componentes principais em seu aplicativo. Este guia o ajudará a criar um arquivo auxiliar BrazeManager.swift que desacoplará todas as dependências do SDK da Braze para iOS do restante do seu código de produção, resultando em um import AppboyUI em todo o seu aplicativo. Essa abordagem limita os problemas decorrentes do excesso de importações de SDK, facilitando o rastreamento, a depuração e a alteração do código.

Visão geral da integração

As etapas a seguir o ajudam a criar um arquivo auxiliar BrazeManager para o qual seu código de produção faz chamadas. Esse arquivo auxiliar tratará de todas as dependências relacionadas ao Braze, adicionando várias extensões para os seguintes tópicos de integração listados. Cada tópico incluirá etapas de guias horizontais e trechos de código em Swift e Objective C. Observe que as etapas do cartão de conteúdo e da mensagem no app não são necessárias para a integração se você não planeja usar esses canais em seu aplicativo.

Criar BrazeManager.swift

Criar BrazeManager.swift

Para construir seu arquivo BrazeManager.swift, crie um novo arquivo Swift chamado BrazeManager para adicionar ao seu projeto no local desejado. Em seguida, substitua import Foundation por import AppboyUI para SPM (import Appboy_iOS_SDK para CocoaPods) e crie uma classe BrazeManager que será usada para hospedar todos os métodos e variáveis relacionados à Braze. Appboy_iOS_SDK

  1. Adicione uma variável estática chamada shared que inicializa a classe BrazeManager. É garantido que isso seja iniciado de forma preguiçosa apenas uma vez.
  2. Em seguida, adicione uma variável constante privada chamada apiKey e defina-a como a chave de API de seu espaço de trabalho no dashboard da Braze.
  3. Adicione uma variável computada privada chamada appboyOptions, que armazenará valores de configuração para o SDK. Ele ficará vazio por enquanto.
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];
}

Inicializar o SDK

Inicializar o SDK a partir de BrazeManager.swift

Em seguida, você deve inicializar o SDK. Este guia pressupõe que você já tenha adicionado o SDK ao seu projeto Xcode. Você também deve ter seu endpoint de SDK do espaço de trabalho e LogLevel definidos em seu arquivo Info.plist ou em appboyOptions.

Adicione o método didFinishLaunchingWithOptions do arquivo AppDelegate.swift sem um tipo de retorno em seu arquivo BrazeManager.swift. Ao criar um método semelhante no arquivo BrazeManager.swift, não haverá uma declaração import AppboyUI em seu arquivo AppDelegate.swift.

Em seguida, inicialize o SDK usando suas variáveis recém-declaradas apiKey e 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]];
}
Lidar com a inicialização do Appboy no AppDelegate.swift

Em seguida, volte ao arquivo AppDelegate.swift e adicione o seguinte trecho de código no método didFinishLaunchingWithOptions do AppDelegate para tratar da inicialização do Appboy no arquivo auxiliar BrazeManager.swift. Lembre-se de que não há necessidade de adicionar uma declaração import AppboyUI no site 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;
}

Notificações por push

Adicionar certificado push

Navegue até seu espaço de trabalho existente no dashboard do Braze. Em Push Notification Settings (Configurações de notificações por push ), faça upload do arquivo de certificado push no dashboard do Braze e salve-o.

Registre-se para receber notificações por push

Em seguida, registre-se para receber notificações por push. Este guia pressupõe que você tenha configurado suas credenciais push corretamente no portal do desenvolvedor da Apple e no projeto Xcode.

O código para registrar notificações por push será adicionado ao método didFinishLaunching... no arquivo BrazeManager.swift. Seu código de inicialização deve ser parecido com o seguinte:

  1. Configure o conteúdo para solicitar autorização para interagir com o usuário. Essas opções estão listadas como exemplo.
  2. Solicite autorização para enviar notificações por push aos seus usuários. A resposta do usuário para permitir ou negar notificações por push é rastreada na variável granted.
  3. Encaminhe os resultados da autorização por push para o Braze depois que o usuário interagir com o prompt de notificação.
  4. Inicie o processo de registro com APNs; isso deve ser feito no thread principal. Se o registro for bem-sucedido, o app chamará o método didRegisterForRemoteNotificationsWithDeviceToken do seu objeto 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];
}
Encaminhar métodos de notificação por push

Em seguida, encaminhe os métodos de notificações por push do sistema de AppDelegate.swift para BrazeManager.swift para serem tratados pelo SDK da Braze para iOS.

Etapa 1: Criar extensão para o código de notificação por push

Crie uma extensão para o seu código de notificação por push no arquivo BrazeManager.swift para que ele seja lido de forma mais organizada quanto à finalidade que está sendo atendida no arquivo auxiliar, da seguinte forma:

  1. Seguindo o padrão de não incluir uma instrução import AppboyUI em seu arquivo AppDelegate, trataremos dos métodos de notificações por push no arquivo BrazeManager.swift. Os tokens de dispositivo do usuário precisarão ser passados para o Braze a partir do método didRegisterForRemote.... Esse método é necessário para implementar notificações por push silenciosas. Em seguida, adicione o mesmo método do site AppDelegate em sua classe BrazeManager.
  2. Adicione a seguinte linha dentro do método para registrar o token do dispositivo no Braze. Isso é necessário para que a Braze associe o token ao dispositivo atual.
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];
}
Etapa 2: Suporte a notificações remotas

Na aba Assinatura & Capacidades, adicione suporte a Modos em segundo plano e selecione Notificações remotas para começar a oferecer suporte a notificações push remotas originadas do Braze.

Assinatura & Capacidades

Etapa 3: Manuseio de notificações remotas

O SDK da Braze pode lidar com notificações por push remotas originadas da Braze. Encaminhe as notificações remotas para a Braze; o SDK ignorará automaticamente as notificações por push que não forem originadas na Braze. Adicione o seguinte método ao seu arquivo BrazeManager.swift na extensão de notificação por 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];
}
Etapa 4: Encaminhar respostas de notificação

O SDK da Braze pode lidar com a resposta de notificações por push originadas na Braze. Encaminhe a resposta das notificações para a Braze; o SDK ignorará automaticamente as respostas das notificações por push que não forem originadas na Braze. Adicione o seguinte método ao seu arquivo 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];
}

Acessar variáveis e métodos do usuário

Criar variáveis e métodos de usuário

Em seguida, você desejará ter acesso fácil às variáveis e aos métodos do site ABKUser. Crie uma extensão para o seu código de usuário no arquivo BrazeManager.swift para que ele seja lido de forma mais organizada quanto à finalidade do arquivo auxiliar, da seguinte forma:

  1. Um objeto ABKUser representa um usuário conhecido ou anônimo no seu aplicativo iOS. Adicione uma variável computada para recuperar o ABKUser; essa variável será reutilizada para recuperar variáveis sobre o usuário.
  2. Consulte a variável do usuário para acessar facilmente o site userId. Entre as outras variáveis, o objeto ABKUser é responsável por (firstName, lastName, phone, homeCity, etc.)
  3. Defina o usuário chamando changeUser() com um userId correspondente.
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];
}

Análise de dados

Criar método de evento personalizado de registro

Com base no seguinte método do SDK da Braze logCustomEvent, crie um método correspondente.

Braze logCustomEvent método de referência
Isso foi projetado porque somente o arquivo BrazeManager.swift pode acessar diretamente os métodos do SDK da Braze para iOS. Portanto, ao criar um método correspondente, o resultado é o mesmo e é feito sem a necessidade de nenhuma dependência direta do SDK da Braze para iOS em seu código de produção.

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

Método de correspondência
Registre eventos personalizados do objeto Appboy no Braze. Properties é um parâmetro opcional com um valor padrão de nil. Não é necessário que os eventos personalizados tenham propriedades, mas é necessário que tenham um nome.

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];
}
Criar método de atributos personalizados de registro

O SDK pode registrar vários tipos como atributos personalizados. Não há necessidade de criar métodos auxiliares para cada tipo de valor que pode ser definido. Em vez disso, exponha apenas um método que possa filtrar até o valor apropriado.

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;

Os atributos personalizados são registrados a partir do objeto ABKUser.

Crie um método que possa abranger todos os tipos disponíveis que podem ser definidos para uma atribuição. Adicione esse método em seu arquivo BrazeManager.swift na extensão de análise de dados. Isso pode ser feito filtrando os tipos de atributos personalizados válidos e chamando o método associado ao tipo correspondente.

  • O parâmetro value é um tipo genérico que está em conformidade com o protocolo Equatable. Isso é feito explicitamente, portanto, se o tipo não for o que o SDK da Braze para iOS espera, haverá um erro de tempo de compilação.
  • Os parâmetros key e value são parâmetros opcionais que serão desembrulhados condicionalmente no método. Essa é apenas uma maneira de garantir que valores não nulos sejam passados para o SDK da Braze para 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]];
    }
  }
}
Criar método de compra de registro

Em seguida, com base no seguinte método do SDK da Braze logPurchase, crie um método correspondente.

Braze logPurchase método de referência
Isso foi projetado porque somente o arquivo BrazeManager.swift pode acessar diretamente os métodos do SDK da Braze para iOS. Portanto, ao criar um método correspondente, o resultado é o mesmo e é feito sem a necessidade de nenhuma dependência direta do SDK da Braze para iOS em seu código de produção.

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

Método de correspondência
Registre as compras do objeto Appboy para a Braze. O SDK tem vários métodos para registrar compras, e este é apenas um exemplo. Esse método também lida com a criação dos objetos NSDecimal e UInt. A maneira como você deseja lidar com essa parte depende de você, este é apenas um exemplo.

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

Mensagem no app

Em conformidade com o ABKInAppMessageUIDelegate

Em seguida, ative o código de seu arquivo BrazeManager.swift para que esteja em conformidade com o ABKInAppMessageUIDelegate e manipule diretamente os métodos associados.

O código de conformidade com o delegate será adicionado aos métodos didFinishLaunching... no arquivo BrazeManager.swift. Seu código de inicialização deve ter a seguinte aparência:

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];
}
Adicionar métodos delegados

Em seguida, crie uma extensão que esteja em conformidade com o site ABKInAppMessageUIDelegate.

Adicione o seguinte snippet à seção de análise de dados. Note que o objeto BrazeManager.swift está definido como o delegate; é nesse objeto que o arquivo BrazeManager.swift manipula todos os métodos 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;
}

Cartões de conteúdo

Criar variáveis e métodos do cartão de conteúdo

Ative seu código de produção para exibir o controlador de visualização dos cartões de conteúdo sem a necessidade de instruções import AppboyUI desnecessárias.

Crie uma extensão para o código dos seus cartões de conteúdo no arquivo BrazeManager.swift, para que ele seja lido de forma mais organizada quanto à finalidade do arquivo auxiliar, da seguinte forma:

  1. Exibir o site ABKContentCardsTableViewController. Um navigationController opcional é o único parâmetro necessário para apresentar ou fazer um push do controlador de visualizações.
  2. Inicializar um objeto ABKContentCardsTableViewController e, opcionalmente, alterar o título. Você também deve adicionar o controlador de visualizações inicializado à pilha de navegação.
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];
}

Próximas etapas

Parabéns! Você concluiu este guia de práticas recomendadas de integração! Um exemplo de arquivo auxiliar BrazeManager pode ser encontrado no GitHub.

Agora que você desacoplou todas as dependências do SDK da Braze para iOS do restante de seu código de produção, confira alguns de nossos guias de implementação avançada opcionais:

New Stuff!