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 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. O exemplo do guia de início rápido (em inglês) disponibiliza um código de amostra dessas duas linguagens.

Swizzling de métodos no Firebase Cloud Messaging

O SDK para 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 callback 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 o app para receber notificações remotas.

Pré-requisitos

Antes de começar, é preciso configurar o ambiente com o seguinte:

  • Xcode 10.1 ou versões posteriores
  • Um projeto do Xcode segmentado para iOS 8 ou versões posteriores
  • Para projetos do Swift, Swift 3.0 ou posterior
  • O identificador de pacote do seu app
  • CocoaPods 1.4.0 ou posterior
  • Para Cloud Messaging:
    • 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

Se você ainda não tem um projeto do Xcode e quer apenas testar um recurso do Firebase, pode fazer o download de um de nossos exemplos para início rápido. Caso use um exemplo para início rápido, anote o identificador do pacote nas configurações do projeto. Você precisará dele na próxima etapa.

Adicionar o Firebase ao app

Adicione o Firebase ao seu app. Para isso, serão necessários um projeto e um arquivo de configuração do Firebase para o aplicativo. Se você quiser mais informações, consulte Noções básicas sobre projetos do Firebase.

Agora que você tem um projeto, adicione seu app para iOS a ele:

  1. Clique em Adicionar o Firebase ao app para iOS e siga as etapas de configuração. Se você estiver importando um projeto do Google, isso poderá ocorrer automaticamente. Basta fazer o download do arquivo de configuração.

  2. Quando solicitado, digite o código do pacote do app. É importante inserir essa informação ao adicionar um app ao projeto do Firebase.

  3. Adicione o arquivo de configuração do Firebase para iOS ao app:

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

      É possível fazer o download do arquivo de configuração do Firebase para iOS novamente a qualquer momento.

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

  4. Depois de adicionar o código de inicialização, execute seu app para enviar ao Console a confirmação de que você instalou o Firebase com sucesso.

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

Adicionar o SDK

Se você estiver configurando um novo projeto, é necessário instalar o SDK. Talvez você tenha feito isso durante a criação do projeto do Firebase.

Recomendamos o uso do CocoaPods para a instalação das bibliotecas. Você pode instalar o CocoaPods seguindo as instruções de instalação (em inglês). Se você prefere não usar o CocoaPods, é possível integrar as bibliotecas do SDK diretamente sem precisar dele.

Se você fizer o download e executar um dos exemplos de guia de início rápido, o projeto do Xcode e o Podfile já estarão adicionados, mas você ainda precisará instalar os pods e fazer o download do arquivo GoogleService-Info.plist. Se quiser integrar as bibliotecas do Firebase a um de seus projetos, adicione os pods das bibliotecas que quer usar.

  1. Se você ainda não tiver um projeto do Xcode, crie um agora.

  2. Crie um Podfile se ainda não tiver um:

    $ cd your-project directory
$ pod init

  3. Inclua os pods que quer instalar. Você pode incluir um pod em seu Podfile como este:

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

    Esse procedimento adicionará as bibliotecas de pré-requisitos necessárias para colocar o Firebase em funcionamento no seu aplicativo iOS, juntamente com o Google Analytics para Firebase. Os pods e as subespecificações disponíveis no momento estão listados a seguir. Essas informações também estão nos guias de configuração específicos dos recursos.

  4. Instale os pods e abra o arquivo .xcworkspace para ver o projeto no Xcode.

    $ pod install
$ open your-project.xcworkspace

  5. Faça o download de um arquivo GoogleService-Info.plist no Console do Firebase e inclua-o no seu app.

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 código da chave, disponível na seção Certificates, Identifiers & Profiles no 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 uma instância compartilhada do FirebaseApp, que é normalmente encontrada no método application:didFinishLaunchingWithOptions: do aplicativo:

    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 os métodos didRegisterForRemoteNotificationsWithDeviceToken para recuperar o token de APNs. Em seguida, defina a propriedade APNSToken de 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.

Próximas etapas

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: