Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Configurar um app cliente do Firebase Cloud Messaging no iOS

Para aplicativos cliente iOS, é possível receber payloads de notificação e dados de até 4.000 bytes pela interface APNs do Firebase Cloud Messaging.

Para escrever o código cliente em Objective-C ou Swift, recomendamos usar a API FIRMessaging. O exemplo do guia de início rápido (em inglês) disponibiliza um código de amostra dessas duas linguagens.

Para ativar o envio de notificações push por meio de APNs, é necessário ter:

  • uma chave de autenticação de notificação push da Apple para sua conta de desenvolvedor dessa empresa. O Firebase Cloud Messaging usa esse token para enviar notificações push para o aplicativo identificado pelo ID do app;

  • um perfil de provisionamento para esse ID do app com notificações push ativadas. Além disso, para testar seu app ainda em desenvolvimento, você precisará de um perfil de provisionamento para que seus dispositivos sejam autorizados a executar um app ainda não publicado na App Store.

Ambos são criados no Apple Developer Member Center.

Swizzling de métodos no Firebase Cloud Messaging

O SDK do FCM executa o Swizzling de métodos em duas áreas importantes: mapeamento do token de APNs para o token de registro do FCM e captura de dados de análise durante o processamento de chamada de retorno de mensagens downstream. Os desenvolvedores que preferem não usar o Swizzling podem desativá-lo adicionando a sinalização FirebaseAppDelegateProxyEnabled no arquivo Info.plist do app e defini-lo como NO (valor booleano). As áreas relevantes dos guias exibem exemplos de código, seja com o método Swizzling ativado ou não.

Adicionar o Firebase ao seu projeto para iOS

Esta seção aborda tarefas que você talvez tenha realizado se já ativou outros elementos do Firebase para o app. Especificamente para o FCM, você precisa fazer upload da chave de autenticação dos APNs e inscrever-se para receber notificações remotas.

Pré-requisitos

  • Instalação dos programas a seguir:

    • Xcode 12.2 ou posterior
    • CocoaPods 1.10.0 ou posterior
  • Verifique se o projeto atende a estes requisitos:

    • Seu projeto precisa ser desenvolvido para iOS 10 ou versões posteriores.
  • Configurar um dispositivo iOS físico para executar o app e concluir estas tarefas:

    • Conseguir uma chave de autenticação de notificação push da Apple para a conta do Apple Developer.
    • Ativar as notificações push no Xcode em App > Capabilities.

Se você ainda não tem um projeto do Xcode e quiser testar um produto do Firebase, faça o download de uma das nossas amostras de início rápido.

Criar um projeto do Firebase

Antes de adicionar o Firebase ao app para iOS, é preciso criar um projeto do Firebase para então conectá-lo ao app. Visite Noções básicas sobre projetos do Firebase para saber mais.

Registrar seu app no Firebase

Depois de criar um projeto do Firebase, é possível adicionar o app para iOS a ele.

Consulte Noções básicas sobre projetos do Firebase para ver práticas recomendadas e informações sobre como adicionar apps a um projeto do Firebase, incluindo como lidar com diversas variantes de build.

  1. Acesse o Console do Firebase.

  2. No centro da página de visão geral do projeto, clique no ícone iOS () para iniciar o fluxo de trabalho de configuração.

    Se você já adicionou um app ao seu projeto do Firebase, clique em Adicionar app para exibir as opções da plataforma.

  3. Insira o ID do pacote do seu app no campo ID do pacote do iOS.

  4. (Opcional) Insira outras informações do aplicativo: apelido do aplicativo e ID da App Store.

  5. Clique em Registrar app.

Adicionar um arquivo de configuração do Firebase

  1. Clique em Fazer o download do GoogleService-Info.plist para solicitar o arquivo de configuração do Firebase para iOS (GoogleService-Info.plist).

  2. Mova o arquivo de configuração para a raiz do seu projeto XCode. Se solicitado, selecione adicionar o arquivo de configuração a todos os destinos.

Se o projeto tiver vários IDs de pacotes, associe cada ID com um app registrado no Console do Firebase para que tenha o próprio arquivo GoogleService-Info.plist.

Adicionar SDKs do Firebase ao app

Recomendamos o uso do CocoaPods (em inglês) para instalar as bibliotecas do Firebase. No entanto, se você prefere não usar o CocoaPods, é possível integrar os frameworks do SDK diretamente ou usar o Gerenciador de pacotes Swift.

Você está usando um dos exemplos do guia de início rápido? O projeto Xcode e o Podfile (com pods) já estão presentes, mas você ainda precisará adicionar o arquivo de configuração do Firebase e instalar os pods.

  1. Crie um Podfile, se ainda não tiver um:

    cd your-project-directory
    pod init
  2. No seu Podfile, adicione os pods do Firebase que você quer usar no app.

    É possível adicionar qualquer um dos produtos do Firebase compatíveis ao app para iOS.

    Para uma experiência ideal com o Firebase Cloud Messaging, recomendamos ativar o Google Analytics no projeto. Além disso, como parte da configuração do Google Analytics, você precisa adicionar o SDK do Firebase para Google Analytics ao seu aplicativo.

    Analytics ativado

    # Add the Firebase pod for Google Analytics
    pod 'Firebase/Analytics'
    
    # For Analytics without IDFA collection capability, use this pod instead
    # pod ‘Firebase/AnalyticsWithoutAdIdSupport’
    
    # Add the pod for Firebase Cloud Messaging
    pod 'Firebase/Messaging'

    Saiba mais sobre o IDFA, o identificador de publicidade no nível do dispositivo, na documentação da Apple Privacidade do usuário e uso de dados e Transparência no rastreamento de apps.

    Analytics não ativado

    # Add the pod for Firebase Cloud Messaging
    pod 'Firebase/Messaging'
  3. Instale os pods e abra seu arquivo .xcworkspace para ver o projeto no Xcode:

    pod install
    open your-project.xcworkspace

Fazer upload da chave de autenticação de APNs

Faça upload da chave de autenticação de APNs para o Firebase. Se você ainda não tiver uma chave de autenticação de APNs, crie uma no Apple Developer Member Center.

  1. No seu projeto do Console do Firebase, selecione o ícone de engrenagem, Configurações do projeto e a guia Cloud Messaging.

  2. Acesse a Configuração do app para iOS. Em Chave de autenticação de APNs, clique no botão Fazer upload.

  3. Navegue até o local onde você salvou a chave, selecione-a e clique em Abrir. Adicione o ID da chave, disponível na Apple Developer Member Center, e clique em Fazer upload.

Inicializar o Firebase no seu app

É necessário adicionar o código de inicialização do Firebase ao seu app. Importe o módulo do Firebase e configure uma instância compartilhada da seguinte maneira:

  1. Importe o módulo do Firebase no UIApplicationDelegate:

    Swift

    import Firebase

    Objective-C

    @import Firebase;
  2. Configure uma instância compartilhada do FirebaseApp, normalmente no método application:didFinishLaunchingWithOptions: do app.

    Swift

    // Use Firebase library to configure APIs
    FirebaseApp.configure()

    Objective-C

    // Use Firebase library to configure APIs
    [FIRApp configure];

Registrar o app para receber notificações remotas

Na inicialização ou no ponto desejado do fluxo do seu app, registre-o para receber notificações remotas. Chame registerForRemoteNotifications como mostrado:

Swift

if #available(iOS 10.0, *) {
  // For iOS 10 display notification (sent via APNS)
  UNUserNotificationCenter.current().delegate = self

  let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
  UNUserNotificationCenter.current().requestAuthorization(
    options: authOptions,
    completionHandler: { _, _ in }
  )
} else {
  let settings: UIUserNotificationSettings =
    UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
  application.registerUserNotificationSettings(settings)
}

application.registerForRemoteNotifications()

Objective-C

if ([UNUserNotificationCenter class] != nil) {
  // iOS 10 or later
  // For iOS 10 display notification (sent via APNS)
  [UNUserNotificationCenter currentNotificationCenter].delegate = self;
  UNAuthorizationOptions authOptions = UNAuthorizationOptionAlert |
      UNAuthorizationOptionSound | UNAuthorizationOptionBadge;
  [[UNUserNotificationCenter currentNotificationCenter]
      requestAuthorizationWithOptions:authOptions
      completionHandler:^(BOOL granted, NSError * _Nullable error) {
        // ...
      }];
} else {
  // iOS 10 notifications aren't available; fall back to iOS 8-9 notifications.
  UIUserNotificationType allNotificationTypes =
  (UIUserNotificationTypeSound | UIUserNotificationTypeAlert | UIUserNotificationTypeBadge);
  UIUserNotificationSettings *settings =
  [UIUserNotificationSettings settingsForTypes:allNotificationTypes categories:nil];
  [application registerUserNotificationSettings:settings];
}

[application registerForRemoteNotifications];

Acessar o token de registro

Por padrão, o SDK do FCM gera um token de registro para a instância do app cliente na inicialização do seu app. Semelhante ao token do dispositivo de APNs, este token permite enviar notificações direcionadas a instâncias particulares do seu app.

Da mesma forma que o iOS normalmente entrega um token do dispositivo de APNs na inicialização do aplicativo, o FCM envia um token de registro por meio do método messaging:didReceiveRegistrationToken: do FIRMessagingDelegate. O SDK do FCM recupera um token novo ou existente durante a inicialização do aplicativo e sempre que o token é atualizado ou invalidado. Em todos os casos, o SDK do FCM chama messaging:didReceiveRegistrationToken: com um token válido.

Esse token pode mudar quando:

  • o app é restaurado em um novo dispositivo;
  • o usuário desinstala/reinstala o app;
  • o usuário limpa os dados do app.

Definir a delegação de mensagens

Para receber tokens de registro, implemente o protocolo de delegação de mensagens e defina a propriedade delegate do FIRMessaging depois de chamar [FIRApp configure]. Por exemplo, se o delegador do seu aplicativo estiver em conformidade com o protocolo de delegação de mensagens, você poderá configurá-lo como seu próprio delegador em application:didFinishLaunchingWithOptions:.

Swift

Messaging.messaging().delegate = self

Objective-C

[FIRMessaging messaging].delegate = self;

Como encontrar o token de registro atual

Os tokens de registro são enviados por meio do método messaging:didReceiveRegistrationToken:. Normalmente, esse método é chamado uma vez a cada inicialização do app com um token de registro. Depois dessa chamada é o momento ideal para:

  • se o token de registro for novo, enviá-lo para o servidor de aplicativos;
  • inscrever o token de registro em tópicos. Isso é necessário apenas para novas assinaturas ou em situações em que o usuário tenha reinstalado o app.

É possível recuperar o token diretamente usando token(completion:). Um erro não nulo será fornecido se a recuperação do token falhar.

Swift

Messaging.messaging().token { token, error in
  if let error = error {
    print("Error fetching FCM registration token: \(error)")
  } else if let token = token {
    print("FCM registration token: \(token)")
    self.fcmRegTokenMessage.text  = "Remote FCM registration token: \(token)"
  }
}

Objective-C

[[FIRMessaging messaging] tokenWithCompletion:^(NSString *token, NSError *error) {
  if (error != nil) {
    NSLog(@"Error getting FCM registration token: %@", error);
  } else {
    NSLog(@"FCM registration token: %@", token);
    self.fcmRegTokenMessage.text = token;
  }
}];

Você pode usar esse método a qualquer momento para acessar o token em vez de armazená-lo.

Monitorar a atualização do token

Se você quiser receber notificações sempre que o token for atualizado, forneça um delegador em conformidade com o protocolo de delegação de mensagens. O exemplo a seguir registra o delegador e adiciona o método apropriado:

Swift

func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
  print("Firebase registration token: \(String(describing: fcmToken))")

  let dataDict: [String: String] = ["token": fcmToken ?? ""]
  NotificationCenter.default.post(
    name: Notification.Name("FCMToken"),
    object: nil,
    userInfo: dataDict
  )
  // TODO: If necessary send token to application server.
  // Note: This callback is fired at each app startup and whenever a new token is generated.
}

Objective-C

- (void)messaging:(FIRMessaging *)messaging didReceiveRegistrationToken:(NSString *)fcmToken {
    NSLog(@"FCM registration token: %@", fcmToken);
    // Notify about received token.
    NSDictionary *dataDict = [NSDictionary dictionaryWithObject:fcmToken forKey:@"token"];
    [[NSNotificationCenter defaultCenter] postNotificationName:
     @"FCMToken" object:nil userInfo:dataDict];
    // TODO: If necessary send token to application server.
    // Note: This callback is fired at each app startup and whenever a new token is generated.
}

Como alternativa, você pode detectar uma NSNotification denominada kFIRMessagingRegistrationTokenRefreshNotification em vez de fornecer um método delegado. A propriedade do token tem sempre o valor do token atual.

Swizzling desativado: como mapear o token de APNs e de registro

Se você desativou o Swizzling de métodos, precisará mapear explicitamente o token de APNs ao token de registro do FCM. Modifique os métodos didRegisterForRemoteNotificationsWithDeviceToken para recuperar o token de APNs e defina a propriedade de APNSToken do FIRMessaging:

Swift

func application(application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  Messaging.messaging().apnsToken = deviceToken
}

Objective-C

// With "FirebaseAppDelegateProxyEnabled": NO
- (void)application:(UIApplication *)application
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    [FIRMessaging messaging].APNSToken = deviceToken;
}

Depois que o token de registro do FCM for gerado, você poderá acessá-lo e detectar eventos de atualização usando os mesmos métodos como se o Swizzling estivesse ativado.

Impedir a inicialização automática

Quando um token de registro do FCM é gerado, a biblioteca faz upload dos dados de configuração e do identificador para o Firebase. Se você quiser receber uma autorização explícita dos usuários antes disso, é possível impedir a geração de tokens no momento da configuração. Para isso, basta desativar o FCM. Para isso, adicione um valor de metadados a seu Info.plist (não seu GoogleService-Info.plist):

FirebaseMessagingAutoInitEnabled = NO

Para reativar o FCM, é possível fazer uma chamada de tempo de execução:

Swift

Messaging.messaging().autoInitEnabled = true

Objective-C

[FIRMessaging messaging].autoInitEnabled = YES;

Depois de definido, esse valor persiste às reinicializações do app.

Próximas etapas

Depois de configurar o cliente iOS, estará tudo pronto para adicionar o gerenciamento de mensagens e outros comportamentos mais avançados ao app. Veja estes guias para mais informações: