Produtos Casos de uso Preços Documentos Suporte
Ir para o console

Configurar um app cliente do Firebase Cloud Messaging no iOS

Para aplicativos de cliente iOS, você pode implementar o Firebase Cloud Messaging de duas maneiras complementares:

  • Receber mensagens básicas de push de até 4 KB pela interface de APNs do Firebase Cloud Messaging.

  • Enviar mensagens upstream ou receber payloads de dados downstream de até 4 KB em apps em primeiro plano.

Para escrever o código de cliente em Objective-C ou Swift, recomendamos usar a API FIRMessaging. Os exemplos de início rápido disponibilizam um código de amostra dessas duas linguagens.

Swizzling de métodos no Firebase Cloud Messaging

O SDK do FCM executa o método Swizzling 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 do retorno de chamada 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 NÃO (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 projeto do iOS

Se você já ativou outros recursos do Firebase para seu app, é provável que tenha concluído as tarefas abordadas nesta seção. Especificamente para o FCM, será necessário fazer upload da chave de autenticação de APNs e registrar-se para receber notificações remotas.

Pré-requisitos

  • Instale o Xcode 10.1 ou versões posteriores.

  • Instale o CocoaPods 1.4.0 ou versões posteriores.

  • Abra seu projeto no Xcode.

    • Seu projeto precisa segmentar o iOS 8 ou versões posteriores.

    • Os projetos do Swift precisam usar a versão 3.0 ou versões posteriores.

  • Configure um dispositivo físico com iOS ou o simulador iOS para executar seu app.

    • Para o Cloud Messaging, você precisará de:

      • um dispositivo físico com iOS;
      • uma chave de autenticação de notificação push da Apple para sua conta de desenvolvedor da Apple;
      • No Xcode, ative as notificações push em App > Recursos.

    • Para todos os outros produtos do Firebase, é possível usar um dispositivo físico com iOS ou o simulador de iOS.

  • Faça login no Firebase usando sua Conta do Google.

Se você ainda não tiver um projeto Xcode, faça o download de um dos nossos exemplos de início rápido, se quiser apenas testar um produto do Firebase.

Criar um projeto do Firebase

Antes de adicionar o Firebase ao seu projeto de app para iOS, é preciso criar um projeto do Firebase e conectá-lo ao seu app para iOS. Consulte Noções básicas sobre projetos do Firebase para mais informações.

Registre seu app com o Firebase

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

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

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

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

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

    • Para encontrar esse ID, abra seu app no Xcode e acesse a guia Geral no diretório de nível superior Runner. O valor do campo Identificador do pacote é o ID do pacote do iOS (por exemplo, com.yourcompany.yourproject).

  3. (Opcional) Insira outras informações do app conforme solicitado pelo fluxo de trabalho de configuração.

  4. Clique em Registrar app.

Adicionar um arquivo de configuração do Firebase

  1. Clique em Fazer o download do GoogleService-Info.plist para receber 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 do Xcode. Quando solicitado, selecione adicionar o arquivo de configuração a todos os destinos.

Se você tiver vários IDs de pacote no seu projeto, é preciso associá-los a um app registrado no Console do Firebase para que cada app tenha seu próprio arquivo GoogleService-Info.plist.

Adicionar SDKs do Firebase ao seu app

Recomendamos o uso do CocoaPods para instalar as bibliotecas do Firebase. No entanto, se você prefere não usar CocoaPods, é possível integrar os frameworks do SDK diretamente.

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

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

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

    cd your-project-directory
    pod init

  2. No seu Podfile, adicione os pods que você quer usar no app.

    pod 'Firebase/Core'
pod 'Firebase/Messaging'

    Este pod incluirá as bibliotecas de pré-requisitos necessárias para executar o Firebase no app para iOS.

  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 tem uma chave de autenticação de APNs, consulte Configurar APNs com o FCM.

  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 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 seção Certificados, Identificadores e Perfis do Apple Developer Member Center, e clique em 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 a instância compartilhada FirebaseApp, normalmente no método application:didFinishLaunchingWithOptions: do seu 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 o registerForRemoteNotifications da seguinte maneira:

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()

AppDelegate.swift

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];
AppDelegate.m

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 de segmentação 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 FIRMessagingDelegate do messaging:didReceiveRegistrationToken:. 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.

O token de registro 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 delegado de mensagens e defina a propriedade FIRMessaging do delegate depois de chamar [FIRApp configure]. Por exemplo, se o delegado do seu aplicativo estiver em conformidade com o protocolo de delegação de mensagens, você pode configurá-lo como seu próprio delegado 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 por inicialização de 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 inscrições ou em situações em que o usuário tenha reinstalado o app.

Você pode recuperar o token diretamente usando instanceIDWithHandler:. Esse retorno de chamada fornece um InstanceIDResult, que contém o token. Um erro não nulo é exibido se a recuperação de InstanceID falhar.

Swift

InstanceID.instanceID().instanceID { (result, error) in
  if let error = error {
    print("Error fetching remote instance ID: \(error)")
  } else if let result = result {
    print("Remote instance ID token: \(result.token)")
    self.instanceIDTokenMessage.text  = "Remote InstanceID token: \(result.token)"
  }
}

Objective-C

[[FIRInstanceID instanceID] instanceIDWithHandler:^(FIRInstanceIDResult * _Nullable result,
                                                    NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error fetching remote instance ID: %@", error);
  } else {
    NSLog(@"Remote instance ID token: %@", result.token);
    NSString* message =
      [NSString stringWithFormat:@"Remote InstanceID token: %@", result.token];
    self.instanceIDTokenMessage.text = message;
  }
}];

Geralmente, o token está disponível localmente, portanto, esse método não abre uma conexão de rede. Você pode usar esse método a qualquer momento para acessar o token em vez de armazená-lo.

Monitorar a atualização de token

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

Swift

func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String) {
  print("Firebase registration token: \(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.
}
AppDelegate.swift

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.
}
AppDelegate.m

Você também 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 para o token de registro do FCM. Modifique o método didRegisterForRemoteNotificationsWithDeviceToken para recuperar o token de APNs e defina a propriedade APNSToken do FIRMessaging:

Swift

func application(application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
  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 ouvir eventos de atualização usando os mesmos métodos como se o Swizzling estivesse ativado.

Importar tokens de APNs de usuário existentes

Se você tem uma base de usuários para os quais gostaria de permitir acesso ao app cliente do FCM, use a API batchImport fornecida pelo código da instância. Com essa API, você pode importar em massa tokens de APNs do iOS existentes para o FCM, mapeando-os para novos tokens de registro válidos.

Impedir a inicialização automática

O FCM gera um código de instância, que é usado como um token de registro no FCM. Quando ele é gerado, a biblioteca faz upload dos dados de configuração e do identificador para o Firebase.Se você quer receber uma confirmação antes de usar o código da instância, é possível impedir a geração dele desativando o FCM. Para fazer isso, adicione um valor de metadados ao Info.plist (não ao 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.

A seguir

Depois de configurar seu cliente iOS, você estará pronto para adicionar o gerenciamento de mensagens e outro comportamento mais avançado ao app. Consulte estes guias para mais informações: