Ir para o console

Enviar uma mensagem de teste a um app para iOS em segundo plano

Para começar a usar o FCM, crie o caso de uso mais simples: enviar uma mensagem de notificação do Editor do Notificações a um dispositivo de desenvolvimento específico quando o app estiver em segundo plano. Esta página descreve todas as etapas para fazer isso, desde a configuração até a verificação. Talvez ela aborde etapas que você já concluiu, se configurou um app cliente do iOS para o FCM.

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.

Observe que se você estiver usando um dos exemplos de início rápido, o projeto 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 uma instância compartilhada do 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()

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

Para enviar uma mensagem a um dispositivo específico, é necessário saber o token de registro dele. Como você precisa informar o token em um campo do Editor do Notificações para concluir este tutorial, copie e armazene-o em local seguro após a recuperação.

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

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

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.

Enviar uma mensagem de notificação

  1. Instale e execute o app no dispositivo de destino. Você precisará aceitar a solicitação de permissão para receber notificações remotas.

  2. Verifique se o app está em segundo plano no dispositivo.

  3. Abra o Editor do Notificações e selecione Nova mensagem.

  4. Digite o texto da mensagem.

  5. Selecione Testar no seu dispositivo.

  6. No campo Token de registro FCM, insira o token de registro obtido na seção anterior deste guia.

  7. Clique em Testar.

Depois de clicar em Testar, o dispositivo cliente de destino que tem o app em segundo plano receberá a notificação na central de notificações.

Para ver insights sobre a entrega de mensagens ao seu aplicativo, consulte o painel de relatórios do FCM, que registra o número de mensagens enviadas e abertas em dispositivos iOS e Android, juntamente com os dados de "impressões" (notificações vistas pelos usuários) para apps para Android.

Próximas etapas

Para ir além das notificações e adicionar outros comportamentos mais avançados ao seu app, consulte: