integração de notificações por push

Este artigo de referência explica como configurar notificações por push no Swift SDK da Braze para iOS.

Notificações por push permitem que você envie notificações do seu app quando eventos importantes ocorrerem. Você pode enviar uma notificação por push quando tiver novas mensagens instantâneas para entregar, alertas de notícias de última hora para enviar ou o episódio mais recente do programa de TV favorito do seu usuário pronto para ele baixar para visualização offline. Notificações por push também podem ser silenciosas, sendo usadas apenas para atualizar a interface do seu app ou disparar trabalho em segundo plano.

As notificações por push também podem ser muito mais eficientes do que a busca em segundo plano, pois seu aplicativo só é iniciado quando necessário. As notificações por push também podem ser muito mais eficientes do que a busca em segundo plano, pois seu aplicativo só é iniciado quando necessário.

As notificações por push são limitadas por taxa, então não tenha medo de enviar quantas sua aplicação precisar. O iOS e o serviço de Notificações por Push da Apple (APNs) controlarão a frequência com que são entregues, e você não terá problemas por enviar muitas. Se suas notificações por push forem limitadas, elas podem ser atrasadas até a próxima vez que o dispositivo enviar um pacote keep-alive ou receber outra notificação.

Configuração inicial

Etapa 1: Faça upload do seu certificado APNs

Antes de poder enviar uma notificação por push iOS usando a Braze, você precisa fornecer seu .p8 arquivo de notificação por push fornecido pela Apple. Conforme descrito na documentação do desenvolvedor da Apple:

1. Em sua conta de desenvolvedor Apple, acessar Certificados, Identificadores e Perfis.
2. Em Chaves, selecione Todos e clique no botão adicionar (+) no canto superior direito.
3. Em Descrição da Chave, insira um nome único para a chave de assinatura.
4. Em Serviços Principais, selecione a caixa de seleção serviço de Notificações por Push da Apple (APNs), depois clique em Continuar. Clique Confirmar.
5. Note o ID da chave. Clique em baixar para gerar e baixar a chave. Certifique-se de salvar o arquivo baixado em um local seguro, pois você não pode baixar isso mais de uma vez.
6. Na Braze, acesse Configurações > Configurações do app e faça upload do arquivo .p8 em Certificado de push da Apple. Você pode fazer upload do seu certificado de push de desenvolvimento ou de produção. Para testar notificações por push depois que seu app estiver disponível na App Store, é recomendável configurar um espaço de trabalho separado para a versão de desenvolvimento do seu app.
7. Quando solicitado, informe o ID do pacote, o ID da chave e o ID da equipe e clique em Salvar.

Etapa 2: Ativar push capabilities

No Xcode, adicione a capacidade de notificações por push usando o painel Assinatura e Capacidades ao alvo principal do app.

Integração automática de push

O SDK SWIFT fornece uma abordagem apenas de configuração para automatizar o processamento de notificações remotas recebidas da Braze. Esta abordagem é a maneira mais simples de integrar notificações por push e é recomendada para a maioria dos clientes.

Para ativar a integração automática de push, defina a propriedade automation da configuração push para true:

• swift
• objective c

1
2
let configuration = Braze.Configuration(apiKey: "{YOUR-BRAZE-API-KEY}", endpoint: "{YOUR-BRAZE-API-ENDPOINT}")
configuration.push.automation = true

1
2
BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:@"{YOUR-BRAZE-API-KEY}" endpoint:@"{YOUR-BRAZE-API-ENDPOINT}"];
configuration.push.automation = [[BRZConfigurationPushAutomation alloc] initEnablingAllAutomations:YES];

Isso instrui o SDK a:

• Registre seu aplicativo para notificação por push no sistema.
• Solicite a autorização/permissão de notificação por push na inicialização.
• Forneça dinamicamente implementações para os métodos delegados relacionados ao sistema de notificação por push.

Substituindo configurações individuais

Para um controle mais granular, cada etapa de automação pode ser ativada ou desativada individualmente:

• swift
• objective c

1
2
3
// Enable all automations and disable the automatic notification authorization request at launch.
configuration.push.automation = true
configuration.push.automation.requestAuthorizationAtLaunch = false

1
2
3
// Enable all automations and disable the automatic notification authorization request at launch.
configuration.push.automation = [[BRZConfigurationPushAutomation alloc] initEnablingAllAutomations:YES];
configuration.push.automation.requestAuthorizationAtLaunch = NO;

Consulte Braze.Configuration.Push.Automation para todas as opções disponíveis e automation para saber mais sobre o comportamento da automação.

Você pode pular a próxima seção e continuar para deep linking se estiver usando a integração automática de push.

Integração manual de push

As notificações por push também podem ser integradas manualmente. Esta seção descreve os passos necessários para esta integração.

Etapa 1: Registre-se para notificações por push com APNs

Inclua o exemplo de código apropriado no método de delegado application:didFinishLaunchingWithOptions: do seu app para que os dispositivos dos seus usuários possam se registrar no APNs. Certifique-se de chamar todo o código de integração push na thread principal do seu aplicativo.

Braze também fornece categorias de push padrão para suporte ao botão de ação por push, que devem ser adicionadas manualmente ao seu código de registro de push. Consulte os botões de ação por push para obter etapas adicionais de integração.

Adicione o seguinte código ao método application:didFinishLaunchingWithOptions: do seu delegado do app.

• swift
• objective c

1
2
3
4
5
6
7
8
9
10
11
application.registerForRemoteNotifications()
let center = UNUserNotificationCenter.current()
center.setNotificationCategories(Braze.Notifications.categories)
center.delegate = self
var options: UNAuthorizationOptions = [.alert, .sound, .badge]
if #available(iOS 12.0, *) {
  options = UNAuthorizationOptions(rawValue: options.rawValue | UNAuthorizationOptions.provisional.rawValue)
}
center.requestAuthorization(options: options) { granted, error in
  print("Notification authorization, granted: \(granted), error: \(String(describing: error))")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[application registerForRemoteNotifications];
UNUserNotificationCenter *center = UNUserNotificationCenter.currentNotificationCenter;
[center setNotificationCategories:BRZNotifications.categories];
center.delegate = self;
UNAuthorizationOptions options = UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge;
if (@available(iOS 12.0, *)) {
  options = options | UNAuthorizationOptionProvisional;
}
[center requestAuthorizationWithOptions:options
                      completionHandler:^(BOOL granted, NSError *_Nullable error) {
                        NSLog(@"Notification authorization, granted: %d, "
                              @"error: %@)",
                              granted, error);
}];

Etapa 2: Registre push tokens com a Braze

Depois que o registro do APNs estiver completo, passe o deviceToken resultante para a Braze para ativar as notificações por push para o usuário.

• swift
• objective c

1
AppDelegate.braze?.notifications.register(deviceToken: deviceToken)

1
[AppDelegate.braze.notifications registerDeviceToken:deviceToken];

Etapa 3: Ativar push handling

Em seguida, passe as notificações por push recebidas para a Braze. Esta etapa é necessária para registrar a análise de dados de push e o manuseio de links. Certifique-se de chamar todo o código de integração push na thread principal do seu aplicativo.

Manipulação padrão de push

• swift
• objective c

1
2
3
4
5
6
7
if let braze = AppDelegate.braze, braze.notifications.handleBackgroundNotification(
  userInfo: userInfo,
  fetchCompletionHandler: completionHandler
) {
  return
}
completionHandler(.noData)

1
2
3
4
5
6
7
if let braze = AppDelegate.braze, braze.notifications.handleUserNotification(
  response: response,
  withCompletionHandler: completionHandler
) {
  return
}
completionHandler()

1
2
3
4
5
6
7
BOOL processedByBraze = AppDelegate.braze != nil && [AppDelegate.braze.notifications handleBackgroundNotificationWithUserInfo:userInfo
                                                                                                       fetchCompletionHandler:completionHandler];
if (processedByBraze) {
  return;
}

completionHandler(UIBackgroundFetchResultNoData);

1
2
3
4
5
6
7
BOOL processedByBraze = AppDelegate.braze != nil && [AppDelegate.braze.notifications handleUserNotificationWithResponse:response
                                                                                                  withCompletionHandler:completionHandler];
if (processedByBraze) {
  return;
}

completionHandler();

Manipulação de push em primeiro plano

• swift
• objective c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func userNotificationCenter(
  _ center: UNUserNotificationCenter,
  willPresent notification: UNNotification,
  withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions
) -> Void) {
  if let braze = AppDelegate.braze {
    // Forward notification payload to Braze for processing.
    braze.notifications.handleForegroundNotification(notification: notification)
  }

  // Configure application's foreground notification display options.
  if #available(iOS 14.0, *) {
    completionHandler([.list, .banner])
  } else {
    completionHandler([.alert])
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       willPresentNotification:(UNNotification *)notification
         withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
  if (AppDelegate.braze != nil) {
    // Forward notification payload to Braze for processing.
    [AppDelegate.braze.notifications handleForegroundNotificationWithNotification:notification];
  }

  // Configure application's foreground notification display options.
  if (@available(iOS 14.0, *)) {
    completionHandler(UNNotificationPresentationOptionList | UNNotificationPresentationOptionBanner);
  } else {
    completionHandler(UNNotificationPresentationOptionAlert);
  }
}

Deep linking

Deep linking de um push para o app é automaticamente tratado por meio da nossa documentação padrão de integração de push. Se você quiser saber mais sobre como adicionar links profundos a locais específicos no seu app, veja nossos casos de uso avançados.

Assinando atualizações de notificações por push

Para acessar as cargas úteis de notificação por push processadas pela Braze, use o método Braze.Notifications.subscribeToUpdates(payloadTypes:_:).

Você pode usar o parâmetro payloadTypes para especificar se deseja se inscrever em notificações envolvendo eventos de push abertos, eventos de push recebidos ou ambos.

• swift
• objective c

1
2
3
4
5
6
// This subscription is maintained through a Braze cancellable, which will observe for changes until the subscription is cancelled.
// You must keep a strong reference to the cancellable to keep the subscription active.
// The subscription is canceled either when the cancellable is deinitialized or when you call its `.cancel()` method.
let cancellable = AppDelegate.braze?.notifications.subscribeToUpdates(payloadTypes: [.open, .received]) { payload in
  print("Braze processed notification with title '\(payload.title)' and body '\(payload.body)'")
}

1
2
3
4
5
NSInteger filtersValue = BRZNotificationsPayloadTypeFilter.opened.rawValue | BRZNotificationsPayloadTypeFilter.received.rawValue;
BRZNotificationsPayloadTypeFilter *filters = [[BRZNotificationsPayloadTypeFilter alloc] initWithRawValue: filtersValue];
BRZCancellable *cancellable = [notifications subscribeToUpdatesWithPayloadTypes:filters update:^(BRZNotificationsPayload * _Nonnull payload) {
  NSLog(@"Braze processed notification with title '%@' and body '%@'", payload.title, payload.body);
}];

Testando

Se você quiser testar notificações no app e notificações por push via a linha de comando, você pode enviar uma única notificação através do terminal via CURL e a API de envio de mensagens. Você precisará substituir os seguintes campos pelos valores corretos para o seu caso de teste:

• YOUR_API_KEY - disponível em Configurações > Chaves de API.
• YOUR_EXTERNAL_USER_ID - disponível na página Pesquisar Usuários. Para saber mais, consulte atribuir IDs de usuário.
• YOUR_KEY1 (opcional)
• YOUR_VALUE1 (opcional)

No exemplo a seguir, a instânciaUS-01 está sendo usada. Se você não estiver nessa instância, consulte nossa documentação da API para ver em qual endpoint fazer solicitações.

1
2
3
4
5
6
7
8
9
10
11
curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer {YOUR_API_KEY}" -d '{
  "external_user_ids":["YOUR_EXTERNAL_USER_ID"],
  "messages": {
    "apple_push": {
      "alert":"Test push",
      "extra": {
        "YOUR_KEY1":"YOUR_VALUE1"
      }
    }
  }
}' https://rest.iad-01.braze.com/messages/send

Push primers

Campanhas de push primer incentivam seus usuários a ativar notificações por push em seu dispositivo para seu app. Isso pode ser feito sem personalização de SDK usando nosso Push Primer sem código.