Wprowadzenie do Komunikacji w chmurze Firebase w aplikacjach na platformę Apple

Wybierz platformę: iOS+ Android Web Flutter Unity C++


Z tego przewodnika dowiesz się, jak rozpocząć korzystanie z Firebase Cloud Messaging w aplikacjach klienckich na platformach Apple (np. iOS) , aby móc niezawodnie wysyłać wiadomości.

W przypadku aplikacji klienckich na platformach Apple możesz otrzymywać powiadomienia i ładunki danych o rozmiarze do 4096 bajtów za pomocą interfejsu APNs Firebase Cloud Messaging.

Aby pisać kod klienta w języku Objective-C lub Swift, zalecamy używanie interfejsu API FIRMessaging. W przykładzie szybkiego startu znajdziesz przykładowy kod w obu językach.

Zanim zaczniesz, dodaj Firebase do projektu Apple.

Podmiana metody w Firebase Cloud Messaging

Pakiet SDK FCM wykonuje podmianę metody w 2 kluczowych obszarach: mapowaniu tokena APNs na identyfikator instalacji Firebase lub token rejestracji FCM oraz rejestrowaniu danych analitycznych podczas obsługi wywołania zwrotnego wiadomości wysyłanej do klienta. Deweloperzy, którzy nie chcą używać podmiany metody, mogą ją wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled w pliku Info.plist aplikacji i ustawiając jej wartość logiczną na NO. W odpowiednich sekcjach przewodników znajdziesz przykłady kodu z włączoną i wyłączoną podmianą metody.

Prześlij klucz uwierzytelniania APNs

Prześlij klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, utwórz go w Apple Developer Member Center.

  1. W konsoli Firebase otwórz Ustawienia > Ogólne. Następnie kliknij kartę Cloud Messaging.
  2. W sekcji Klucz uwierzytelniania APNs w obszarze Konfiguracja aplikacji na iOS, kliknij Prześlij, aby przesłać klucz uwierzytelniania środowiska deweloperskiego lub klucz uwierzytelniania środowiska produkcyjnego albo oba te klucze. Wymagany jest co najmniej 1 klucz.
  3. Otwórz lokalizację, w której został zapisany klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w Apple Developer Member Center) i kliknij Prześlij.

Zarejestruj się, aby otrzymywać powiadomienia zdalne

Zarejestruj aplikację, aby otrzymywać powiadomienia zdalne, podczas uruchamiania lub w wybranym momencie przepływu aplikacji. Wywołaj registerForRemoteNotifications w sposób pokazany poniżej:

Swift

UNUserNotificationCenter.current().delegate = self

let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
UNUserNotificationCenter.current().requestAuthorization(
  options: authOptions,
  completionHandler: { _, _ in }
)

application.registerForRemoteNotifications()

Objective-C

[UNUserNotificationCenter currentNotificationCenter].delegate = self;
UNAuthorizationOptions authOptions = UNAuthorizationOptionAlert |
    UNAuthorizationOptionSound | UNAuthorizationOptionBadge;
[[UNUserNotificationCenter currentNotificationCenter]
    requestAuthorizationWithOptions:authOptions
    completionHandler:^(BOOL granted, NSError * _Nullable error) {
      // ...
    }];

[application registerForRemoteNotifications];

Uzyskiwanie dostępu do identyfikatora instalacji Firebase

Domyślnie pakiet SDK FCM rejestruje instancję aplikacji w FCM i zwraca identyfikator instalacji Firebase (FID) dla instancji aplikacji klienckiej podczas uruchamiania aplikacji. Podobnie jak token urządzenia APNs, ten identyfikator FID umożliwia wysyłanie ukierunkowanych powiadomień do dowolnej instancji aplikacji.

Podobnie jak platformy Apple zwykle dostarczają token urządzenia APNs podczas uruchamiania aplikacji, FCM udostępnia identyfikator FID do kierowania powiadomień. Pakiet FCM SDK dostarcza identyfikator FID za pomocą metody FIRMessagingDelegate's messaging:didReceiveRegistration: protokołu, automatycznie monitoruje zmiany identyfikatora FID i wywołuje metodę z nowym identyfikatorem FID po wykryciu zmiany. Zalecamy regularne pobieranie i przesyłanie identyfikatora FID, ponieważ może się on zmienić po pierwszym uruchomieniu.

Więcej informacji o tym, kiedy identyfikatory FID są ponownie wydawane i jak je ręcznie monitorować, znajdziesz w artykule Monitorowanie cyklu życia identyfikatora instalacji Firebase.

Włączanie rejestracji za pomocą identyfikatora instalacji Firebase

Aby włączyć rejestrowanie instancji aplikacji w FCM za pomocą identyfikatora instalacji Firebase (FID), dodaj do pliku Info.plist (nie do pliku GoogleService-Info.plist) tę flagę metadanych:

FirebaseMessagingInstallationIdEnabled = YES

Ustawianie delegata obsługi wiadomości

Aby otrzymywać identyfikatory FID, zaimplementuj protokół delegata obsługi wiadomości i ustaw właściwość delegate FIRMessaging po wywołaniu [FIRApp configure]. Jeśli na przykład delegat aplikacji jest zgodny z protokołem delegata obsługi wiadomości , możesz ustawić delegata w application:didFinishLaunchingWithOptions: na samego siebie.

Swift

Messaging.messaging().delegate = self

Objective-C

[FIRMessaging messaging].delegate = self;

Implementowanie metody didReceiveRegistration

Po zakończeniu rejestracji instancje aplikacji są kierowane za pomocą identyfikatora FID. Aby otrzymać identyfikator FID po rejestracji, zaimplementuj metodę messaging:didReceiveRegistration:. Ta metoda jest zwykle wywoływana raz podczas uruchamiania aplikacji z identyfikatorem FID. Gdy ta metoda jest wywoływana, możesz wykonać te czynności:

  • Jeśli nie masz jeszcze identyfikatora FID na serwerze lub został on wysłany niedawno, wyślij go na serwer aplikacji.
  • Jeśli subskrypcja jest nowa lub użytkownik ponownie zainstalował aplikację, zasubskrybuj identyfikator FID w tematach.

Swift

func messaging(_ messaging: Messaging, didReceiveRegistration installationId: String?) {
  print("Firebase Installation ID: \(String(describing: installationId))")
  // Note: This callback is fired at each app startup.

  if let installationId = installationId {
    // Send the Firebase Installation ID to your app server.
    sendRegistrationToServer(installationId)
  }
}

Objective-C

- (void)messaging:(FIRMessaging *)messaging didReceiveRegistration:(nullable NSString *)installationId {
  NSLog(@"Firebase Installation ID: %@", installationId);
  // Note: This callback is fired at each app startup.

  if (installationId != nil) {
    // Send the Firebase Installation ID to your app server.
    [self sendRegistrationToServer:installationId];
  }
}

Ręczna rejestracja, gdy automatyczna inicjalizacja jest wyłączona

Jeśli automatyczna inicjalizacja jest wyłączona, pakiet SDK FCM nie zarejestruje automatycznie instancji aplikacji w FCM podczas uruchamiania aplikacji. Aby wywołać rejestrację i dostarczenie identyfikatora FID za pomocą metody messaging:didReceiveRegistration:, musisz wywołać register podczas uruchamiania aplikacji:

Swift

// Trigger manual registration if auto-initialization is turned off.
Messaging.messaging().register { error in
    if let error = error {
        // Handle the error
        print("Failed registering: \(error)")
        return
    }
    // Registration was successful. FID is delivered through the messaging:didReceiveRegistration: method.
    print("Successfully registered.")
}

Objective-C

// Trigger manual registration if auto-initialization is turned off.
[[FIRMessaging messaging] registerWithCompletion:^(NSError * _Nullable error) {
    if (error) {
        // Handle the error
        NSLog(@"Failed registering: %@", error);
        return;
    }
    // Registration was successful. FID is delivered through the messaging:didReceiveRegistration: method.
    NSLog(@"Successfully registered.");
}];

Podmiana metody wyłączona: mapowanie tokena APNs i identyfikatora FID

Jeśli podmiana metody jest wyłączona lub tworzysz aplikację SwiftUI, musisz jawnie zmapować token APNs na identyfikatory instalacji Firebase (FID). Aby pobrać token APNs, zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:), a następnie ustaw właściwość apnsToken Messaging:

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

Po zarejestrowaniu identyfikatora FID możesz uzyskać do niego dostęp i nasłuchiwać zdarzeń odświeżania za pomocą tych samych metod co w przypadku włączonej podmiany metody.

Uzyskiwanie dostępu do tokena rejestracji

Domyślnie pakiet SDK FCM generuje token rejestracji dla instancji aplikacji klienckiej podczas uruchamiania aplikacji. Podobnie jak token urządzenia APNs, ten token umożliwia wysyłanie ukierunkowanych powiadomień do dowolnej instancji aplikacji.

Podobnie jak platformy Apple zwykle dostarczają token urządzenia APNs podczas uruchamiania aplikacji, FCM udostępnia token rejestracji za pomocą metody messaging:didReceiveRegistrationToken: protokołu FIRMessagingDelegate's. Pakiet SDK FCM pobiera nowy lub istniejący token podczas pierwszego uruchomienia aplikacji oraz za każdym razem, gdy token jest aktualizowany lub unieważniany. We wszystkich przypadkach pakiet SDK FCM wywołuje messaging:didReceiveRegistrationToken: z prawidłowym tokenem.

Token rejestracji może się zmienić, gdy:

  • aplikacja zostanie przywrócona na nowym urządzeniu;
  • użytkownik odinstaluje i ponownie zainstaluje aplikację;
  • użytkownik wyczyści dane aplikacji.

Ustawianie delegata obsługi wiadomości

Aby otrzymywać tokeny rejestracji, zaimplementuj protokół delegata obsługi wiadomości i ustaw właściwość FIRMessaging's delegate po wywołaniu [FIRApp configure]. Jeśli na przykład delegat aplikacji jest zgodny z protokołem delegata obsługi wiadomości , możesz ustawić delegata w application:didFinishLaunchingWithOptions: na samego siebie.

Swift

Messaging.messaging().delegate = self

Objective-C

[FIRMessaging messaging].delegate = self;

Pobieranie bieżącego tokena rejestracji

Tokeny rejestracji są dostarczane za pomocą metody messaging:didReceiveRegistrationToken:. Ta metoda jest zwykle wywoływana raz podczas uruchamiania aplikacji z tokenem rejestracji. Gdy ta metoda jest wywoływana, jest to idealny moment, aby:

  • jeśli token rejestracji jest nowy, wyślij go na serwer aplikacji;
  • zasubskrybować token rejestracji w tematach. Jest to wymagane tylko w przypadku nowych subskrypcji lub sytuacji, w których użytkownik ponownie zainstalował aplikację.

Możesz pobrać token bezpośrednio za pomocą token(completion:). Jeśli pobieranie tokena nie powiedzie się z jakiegokolwiek powodu, zostanie zwrócony błąd inny niż null.

Swift

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

Objective-C

[[FIRMessaging messaging] tokenWithCompletion:^(NSString * _Nullable token, NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error fetching the remote FCM registration token: %@", error);
  } else {
    NSLog(@"Remote FCM registration token: %@", token);
    NSString* message =
      [NSString stringWithFormat:@"FCM registration token: %@", token];
    // display message
    NSLog(@"%@", message);
  }
}];

Zamiast przechowywać token, możesz w każdej chwili użyć tej metody, aby uzyskać do niego dostęp.

Monitorowanie odświeżania tokena

Aby otrzymywać powiadomienia o każdej aktualizacji tokena, podaj delegata zgodnego z protokołem delegata obsługi wiadomości. Ten przykład rejestruje delegata i dodaje odpowiednią metodę delegata:

Swift

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

Zamiast podawać metodę delegata, możesz też nasłuchiwać NSNotification o nazwie kFIRMessagingRegistrationTokenRefreshNotification. Właściwość token zawsze ma bieżącą wartość tokena.

Podmiana metody wyłączona: mapowanie tokena APNs i tokena rejestracji

Jeśli podmiana metody jest wyłączona lub tworzysz aplikację SwiftUI, musisz jawnie zmapować token APNs na token rejestracji FCM. Aby pobrać token APNs, zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) w celu pobrania tokenu APNs, a następnie ustaw właściwość Messaging's apnsToken:

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

Po wygenerowaniu tokena rejestracji FCM możesz uzyskać do niego dostęp i nasłuchiwać zdarzeń odświeżania za pomocą tych samych metod co w przypadku włączonej podmiany metody.

Zapobieganie automatycznej inicjalizacji

Gdy generowana jest rejestracja FCM, biblioteka przesyła identyfikator i dane konfiguracyjne do Firebase. Jeśli chcesz najpierw uzyskać wyraźną zgodę użytkowników, możesz zapobiec automatycznej rejestracji podczas konfigurowania, wyłączając FCM. Aby to zrobić, dodaj wartość metadanych do pliku Info.plist (nie do pliku GoogleService-Info.plist):

FirebaseMessagingAutoInitEnabled = NO

Aby ponownie włączyć FCM, możesz wywołać:

Swift

Messaging.messaging().autoInitEnabled = true

Objective-C

[FIRMessaging messaging].autoInitEnabled = YES;

Po ustawieniu ta wartość jest zachowywana po ponownym uruchomieniu aplikacji.

Konfigurowanie rozszerzenia usługi powiadomień

Aby wysyłać powiadomienia zawierające obrazy na urządzenia Apple, musisz dodać rozszerzenie usługi powiadomień. To rozszerzenie umożliwia urządzeniom wyświetlanie obrazów dostarczanych w ładunku powiadomienia. Jeśli nie planujesz wysyłać obrazów w powiadomieniach, możesz pominąć ten krok.

Aby dodać rozszerzenie usługi, wykonaj wymagane zadania konfiguracyjne związane z modyfikowaniem i wyświetlaniem powiadomień w APNs, a następnie dodaj interfejs API pomocnika rozszerzenia FCM w NotificationService.m. W szczególności zamiast kończyć wywołanie zwrotne za pomocą self.contentHandler(self.bestAttemptContent);, zakończ je za pomocą FIRMessaging extensionHelper w sposób pokazany poniżej:

@interface NotificationService () <NSURLSessionDelegate>
@property(nonatomic) void (^contentHandler)(UNNotificationContent *contentToDeliver);
@property(nonatomic) UNMutableNotificationContent *bestAttemptContent;
@end

@implementation NotificationService

- (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
    self.contentHandler = contentHandler;
self.bestAttemptContent = [request.content mutableCopy];

    // Modify the notification content here as you want
self.bestAttemptContent.title = [NSString stringWithFormat:@"%@ [modified]",
self.bestAttemptContent.title];

  // Call FIRMessaging extension helper API.
  [[FIRMessaging extensionHelper] populateNotificationContent:self.bestAttemptContent
withContentHandler:contentHandler];

}
...

Wysyłanie powiadomienia

  1. Zainstaluj i uruchom aplikację na urządzeniu docelowym. Na urządzeniach Apple zaakceptuj prośbę o zgodę na otrzymywanie powiadomień zdalnych.

  2. Sprawdź, czy aplikacja działa w tle na urządzeniu.

  3. W konsoli Firebase otwórz DevOps i zaangażowanie > Wiadomości

  4. Utwórz kampanię.

    • Jeśli to Twoja pierwsza wiadomość:

      1. Kliknij Utwórz pierwszą kampanię.

      2. Kliknij Wiadomości z powiadomieniami Firebase i Utwórz.

    • Jeśli masz już utworzone kampanie:

      1. Na karcie Kampanie kliknij Nowa kampania.

      2. Kliknij Powiadomienia.

  5. Wpisz tekst wiadomości.

  6. W panelu po prawej stronie kliknij Wyślij wiadomość testową.

  7. W polu oznaczonym Dodaj identyfikator instalacji Firebase lub FCM token rejestracji wpisz token rejestracji.

  8. Kliknij Przetestuj.

Po kliknięciu Przetestuj urządzenie docelowe z aplikacją działającą w tle powinno otrzymać powiadomienie.

Aby uzyskać informacje o dostarczaniu wiadomości do aplikacji, w konsoli Firebase otwórz DevOps i zaangażowanie > Wiadomości > Raporty. Ten panel informacyjny rejestruje liczbę wysłanych i otwartych wiadomości na urządzeniach Apple i Android oraz dane o „wyświetleniach” (powiadomieniach widzianych przez użytkowników) w przypadku aplikacji na Androida.

Dalsze kroki

Po wykonaniu czynności konfiguracyjnych możesz przejść do korzystania z FCM na platformach Apple: