Configurar um aplicativo cliente Firebase Cloud Messaging em plataformas Apple

Para aplicativos cliente da Apple, você pode receber notificações e cargas de dados de até 4.000 bytes pela interface de APNs do Firebase Cloud Messaging.

Para escrever seu código de cliente em Objective-C ou Swift, recomendamos que você use a API FIRMessaging . O exemplo de início rápido fornece código de amostra para ambos os idiomas.

Método swizzling no Firebase Cloud Messaging

O SDK do FCM executa o método swizzling em duas áreas principais: mapear seu token de APNs para o token de registro do FCM e capturar dados de análise durante o tratamento de retorno de chamada de mensagem downstream . Os desenvolvedores que preferem não usar o swizzling podem desativá-lo adicionando o sinalizador FirebaseAppDelegateProxyEnabled no arquivo Info.plist do aplicativo e definindo-o como NO (valor booleano). As áreas relevantes dos guias fornecem exemplos de código, com e sem o método swizzling ativado.

Adicione o Firebase ao seu projeto da Apple

Se ainda não o fez, adicione o Firebase ao seu projeto da Apple .

Carregue sua chave de autenticação de APNs

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

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

2. Na chave de autenticação de APNs na configuração do aplicativo iOS , clique no botão Upload .

3. Navegue até o local onde você salvou sua chave, selecione-a e clique em Abrir . Adicione o ID da chave para a chave (disponível no Apple Developer Member Center ) e clique em Carregar .

Registre-se para notificações remotas

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

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

Acesse o token de registro

Por padrão, o SDK do FCM gera um token de registro para a instância do aplicativo cliente na inicialização do aplicativo. Semelhante ao token do dispositivo APNs, esse token permite que você envie notificações direcionadas para qualquer instância específica do seu aplicativo.

Da mesma forma que as plataformas Apple normalmente entregam um token de dispositivo APNs na inicialização do aplicativo, o FCM fornece um token de registro por meio do método messaging:didReceiveRegistrationToken: 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.

O token de registro pode mudar quando:

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

Definir o delegado de mensagens

Para receber tokens de registro, implemente o protocolo de delegação de mensagens e defina a propriedade delegate de FIRMessaging após chamar [FIRApp configure] . Por exemplo, se o delegado de seu aplicativo estiver em conformidade com o protocolo de delegado de mensagens, você poderá definir o delegado em application:didFinishLaunchingWithOptions: para ele mesmo.

Messaging.messaging().delegate = self

[FIRMessaging messaging].delegate = self;

Buscando o token de registro atual

Os tokens de registro são entregues por meio do método messaging:didReceiveRegistrationToken: . Esse método é chamado geralmente uma vez por aplicativo iniciado com o token de registro. Quando este método é chamado, é o momento ideal para:

• Se o token de registro for novo, envie-o para o servidor de aplicativos.
• Assine o token de registro nos tópicos. Isso é necessário apenas para novas assinaturas ou para situações em que o usuário reinstalou o aplicativo.

Você pode recuperar o token diretamente usando token(completion:) . Um erro não nulo é fornecido se a recuperação do token falhar de alguma forma.

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)"
  }
}

[[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 atualização de token

Para ser notificado sempre que o token for atualizado, forneça um delegado em conformidade com o protocolo de delegado de mensagens. O exemplo a seguir registra o delegado e adiciona o método de delegado apropriado:

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

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

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

Swizzling desativado: mapeando seu token de APNs e token de registro

Se você desativou o swizzling de métodos ou está criando um aplicativo SwiftUI, precisará mapear explicitamente seu token de APNs para o token de registro do FCM. Implemente o método application(_:didRegisterForRemoteNotificationsWithDeviceToken:) para recuperar o token APNs e, em seguida, defina a propriedade apnsToken do Messaging :

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

// 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 os eventos de atualização usando os mesmos métodos com o swizzling ativado.

Impedir a inicialização automática

Quando um token de registro do FCM é gerado, a biblioteca carrega o identificador e os dados de configuração para o Firebase. Se você deseja obter um opt-in explícito dos usuários primeiro, pode impedir a geração de token no momento da configuração desabilitando o FCM. Para fazer isso, adicione um valor de metadados ao seu Info.plist (não ao seu GoogleService-Info.plist ):

FirebaseMessagingAutoInitEnabled = NO

Para reativar o FCM, você pode fazer uma chamada de tempo de execução:

Messaging.messaging().autoInitEnabled = true

[FIRMessaging messaging].autoInitEnabled = YES;

Esse valor persiste nas reinicializações do aplicativo depois de definido.

Próximos passos

Depois de configurar seu cliente Apple, você estará pronto para adicionar manipulação de mensagens e outros comportamentos mais avançados ao seu aplicativo. Consulte estes guias para obter mais informações:

• Receba mensagens em um aplicativo da Apple
• Enviar mensagens de tópico
• Enviar para grupos de dispositivos