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 zacząć korzystać z Firebase Cloud Messaging w aplikacjach klienckich na platformie Apple (np. iOS), aby niezawodnie wysyłać wiadomości.

W przypadku aplikacji klienckich Apple możesz otrzymywać powiadomienia i ładunki danych o rozmiarze do 4096 bajtów przez interfejs Firebase Cloud Messaging APNs.

Aby napisać kod klienta w języku Objective-C lub Swift, zalecamy użycie interfejsu API FIRMessaging. Przykład krótkiego wprowadzenia zawiera 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: mapowanie tokena APNs na identyfikator instalacji Firebase lub token rejestracji FCM oraz rejestrowanie danych analitycznych podczas obsługi wywołania zwrotnego wiadomości downstream. Deweloperzy, którzy nie chcą używać swizzlingu, mogą go wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled w pliku Info.plist aplikacji i ustawiając ją na wartość logiczną NO. Odpowiednie sekcje przewodników zawierają przykłady kodu z włączoną i wyłączoną podmianą metody.

Przesyłanie klucza 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 kliknij Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.
  2. W sekcji Klucz uwierzytelniania APNs w obszarze Konfiguracja aplikacji na iOS kliknij Prześlij, aby przesłać klucz uwierzytelniania programistycznego lub klucz uwierzytelniania produkcyjnego (albo oba te klucze). Trzeba podać co najmniej 1 formę kontaktu.
  3. Przejdź do lokalizacji, w której zapisano klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w Apple Developer Member Center) i kliknij Prześlij.

Rejestrowanie powiadomień zdalnych

Zarejestruj aplikację do otrzymywania powiadomień zdalnych podczas uruchamiania lub w wybranym momencie działania aplikacji. Wywołaj registerForRemoteNotifications w ten sposób:

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

Dostęp 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 powiadomień kierowanych do dowolnej instancji aplikacji.

Podobnie jak platformy Apple zwykle dostarczają token urządzenia APNs podczas uruchamiania aplikacji, FCM udostępnia identyfikator FID na potrzeby kierowania powiadomień. Pakiet SDK FCM dostarcza identyfikator FID za pomocą metody messaging:didReceiveRegistration: interfejsu FIRMessagingDelegate, 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 on ulec zmianie po pierwszym uruchomieniu.

Szczegółowe informacje 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 umożliwić rejestrowanie instancji aplikacji w usłudze FCM za pomocą identyfikatora instalacji Firebase (FID), dodaj do pliku Info.plist (nie do pliku GoogleService-Info.plist) tę flagę metadanych:

FirebaseMessagingInstallationIdEnabled = YES

Ustawianie przedstawiciela ds. wiadomości

Aby otrzymywać identyfikatory FID, zaimplementuj protokół delegowania wiadomości i ustaw właściwość delegate obiektu FIRMessaging po wywołaniu [FIRApp configure]. Jeśli na przykład delegat aplikacji jest zgodny z protokołem delegata wiadomości, możesz ustawić delegata w application:didFinishLaunchingWithOptions: na 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 przy każdym uruchomieniu aplikacji z identyfikatorem FID. Po wywołaniu tej metody możesz wykonać te działania:

  • Jeśli identyfikator FID nie został jeszcze wysłany na serwer lub został wysłany niedawno, wyślij go na serwer aplikacji.
  • Jeśli subskrypcja jest nowa lub użytkownik ponownie zainstalował aplikację, zasubskrybuj tematy za pomocą identyfikatora FID.

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ęczne rejestrowanie, gdy automatyczna inicjalizacja jest wyłączona

Jeśli wyłączysz automatyczną inicjalizację, pakiet SDK FCM nie będzie automatycznie rejestrować instancji aplikacji w FCM podczas uruchamiania aplikacji. Aby aktywować rejestrację i dostarczanie 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.");
}];

Swizzling wyłączony: mapowanie tokena APNs i identyfikatora FID

Jeśli masz wyłączoną podmianę metody lub tworzysz aplikację SwiftUI, musisz bezpośrednio zmapować token APNs na identyfikatory instalacji Firebase (FID). Zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:), aby pobrać token APNs, a następnie ustaw właściwość apnsToken obiektu 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, korzystając z tych samych metod co w przypadku włączonego swizzlingu.

Uzyskiwanie dostępu do tokena rejestracji (wycofane)

Domyślnie pakiet SDK FCM generuje token rejestracji dla instancji aplikacji klienckiej podczas jej uruchamiania. Podobnie jak token urządzenia APNs, ten token umożliwia wysyłanie powiadomień kierowanych 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: klasy FIRMessagingDelegate. Pakiet SDK FCM pobiera nowy lub istniejący token podczas początkowego uruchamiania 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 odinstalowuje lub ponownie instaluje aplikację.
  • użytkownik wyczyści dane aplikacji;

Ustawianie przedstawiciela ds. wiadomości

Aby otrzymywać tokeny rejestracji, zaimplementuj protokół delegowania wiadomości i ustaw właściwość delegate obiektu FIRMessaging po wywołaniu [FIRApp configure]. Jeśli na przykład delegat aplikacji jest zgodny z protokołem delegata wiadomości, możesz ustawić delegata w application:didFinishLaunchingWithOptions: na 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 na uruchomienie aplikacji z tokenem rejestracji. Wywołanie tej metody to idealny moment na:

  • Jeśli token rejestracji jest nowy, wyślij go na serwer aplikacji.
  • Subskrybuj token rejestracji do tematów. Jest to wymagane tylko w przypadku nowych subskrypcji lub sytuacji, gdy użytkownik ponownie zainstalował aplikację.

Token możesz pobrać bezpośrednio za pomocą funkcji token(completion:). Jeśli pobieranie tokena nie powiedzie się, zostanie wyświetlony błąd o wartości innej 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);
  }
}];

Możesz użyć tej metody w dowolnym momencie, aby uzyskać dostęp do tokena, zamiast go przechowywać.

Monitorowanie odświeżania tokena

Aby otrzymywać powiadomienia o każdej aktualizacji tokena, podaj obiekt delegowany zgodny z protokołem obiektu delegowanego do obsługi wiadomości. W tym przykładzie rejestrujemy przedstawiciela i dodajemy odpowiednią metodę:

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

Możesz też nasłuchiwać zdarzenia NSNotification o nazwie kFIRMessagingRegistrationTokenRefreshNotification zamiast podawać metodę delegowaną. Właściwość tokena zawsze ma bieżącą wartość tokena.

Wyłączone podmienianie: mapowanie tokena APNs i tokena rejestracji

Jeśli masz wyłączoną podmianę metody lub tworzysz aplikację SwiftUI, musisz wyraźnie zmapować token APNs na token rejestracji FCM. Zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:), aby pobrać token APNs, a następnie ustaw właściwość apnsToken obiektu 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 wygenerowaniu tokena rejestracji FCM możesz uzyskać do niego dostęp i nasłuchiwać zdarzeń odświeżania, korzystając z tych samych metod co przy włączonym swizzlingu.

Zapobieganie automatycznej inicjalizacji

Po wygenerowaniu rejestracji FCM biblioteka przesyła identyfikator i dane konfiguracji do Firebase. Jeśli chcesz najpierw uzyskać wyraźną zgodę użytkowników, możesz uniemożliwić automatyczną rejestrację podczas konfiguracji, 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 wykonać wywołanie w czasie działania:

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 czynności konfiguracyjne związane z modyfikowaniem i wyświetlaniem powiadomień w APNs, a następnie dodaj interfejs API FCM extension helper w pliku NotificationService.m. Zamiast wywołania zwrotnego z self.contentHandler(self.bestAttemptContent); użyj FIRMessaging extensionHelper, jak pokazano 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 przyznanie uprawnień do otrzymywania powiadomień zdalnych.

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

  3. W konsoli Firebase kliknij DevOps i zaangażowanie > Komunikacja.

  4. Utworzenie kampanii.

    • Jeśli to Twoja pierwsza wiadomość:

      1. Kliknij Utwórz pierwszą kampanię.

      2. Wybierz Powiadomienia Firebase i kliknij 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 wybierz Wyślij wiadomość testową.

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

  8. Kliknij Przetestuj.

Gdy klikniesz Test, docelowe urządzenie klienta z aplikacją działającą w tle powinno otrzymać powiadomienie.

Aby uzyskać statystyki dotyczące dostarczania wiadomości do aplikacji, otwórz panel DevOps & Engagement (DevOps i zaangażowanie) > Messaging (Przesyłanie wiadomości) > Reports (Raporty) w konsoli Firebase. Ten panel rejestruje liczbę wiadomości wysłanych i otwartych na urządzeniach Apple i urządzeniach z Androidem, a także dane dotyczące „wyświetleń” (powiadomień wyświetlonych użytkownikom) w aplikacjach na Androida.

Dalsze kroki

Po wykonaniu czynności konfiguracyjnych możesz kontynuować korzystanie z FCM na platformach Apple na kilka sposobów: