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 platformę Apple (np. iOS), aby niezawodnie wysyłać wiadomości.

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

Aby napisać kod klienta w języku Objective-C lub Swift, zalecamy użycie interfejsu FIRMessaging API. Przykładowy krótki przewodnik zawiera przykładowy kod w obu językach.

Zanim zaczniesz, dodaj Firebase do projektu Apple.

Podmiana metody w Firebase Cloud Messaging

FCM Pakiet SDK wykonuje zamianę metod w 2 głównych obszarach: mapowaniu tokena APNs na identyfikator instalacji Firebase lub FCM token rejestracji oraz rejestrowaniu danych analitycznych podczas obsługi wywołania zwrotnego wiadomości wysyłanej do aplikacji. Programiści, którzy nie chcą korzystać z zamiany metod, mogą ją wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled w pliku Info.plist aplikacji i ustawiając jej wartość logiczną na NO. Odpowiednie sekcje przewodników zawierają przykłady kodu z włączonym i wyłączonym zamienianiem metod.

Prześlij klucz uwierzytelniający 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ę Komunikacja w chmurze.
  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 element.
  3. Przejdź do lokalizacji, 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.

Rejestrowanie powiadomień zdalnych

Zarejestruj aplikację do otrzymywania powiadomień zdalnych na początku lub w odpowiednim momencie procesu aplikacji. Wywołaj funkcję 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 rejestruje instancję aplikacji w usłudze FCM i zwraca identyfikator instalacji Firebase (FID) dla instancji aplikacji klienta podczas uruchamiania aplikacji.FCM 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 przy uruchamianiu aplikacji, FCM udostępnia identyfikator FID do kierowania powiadomień. Pakiet SDK FCM dostarcza FID za pomocą metody FIRMessagingDelegate messaging:didReceiveRegistration:, automatycznie monitoruje zmiany FID i wywołuje metodę z nowym FID po wykryciu zmiany. Zalecamy regularne pobieranie i przesyłanie identyfikatora FID, ponieważ po początkowym uruchomieniu może on ulec zmianie.

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 FCM za pomocą identyfikatora instalacji Firebase (FID), dodaj ten flagę metadanych do pliku Info.plist, a nie do pliku GoogleService-Info.plist:

FirebaseMessagingInstallationIdEnabled = YES

Ustawianie delegata do obsługi wiadomości

Aby otrzymywać identyfikatory FID, zaimplementuj protokół delegata wiadomości i ustaw właściwość delegate obiektu FIRMessaging po wywołaniu funkcji [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 samego siebie.

Swift

Messaging.messaging().delegate = self

Objective-C

[FIRMessaging messaging].delegate = self;

Zaimplementuj metodę didReceiveRegistration

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

  • Jeśli identyfikator FID nie został 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 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 przy wyłączonej automatycznej inicjalizacji

Jeśli automatyczna inicjalizacja jest wyłączona, pakiet SDK FCM nie zarejestruje automatycznie instancji aplikacji w usłudze FCM podczas uruchamiania aplikacji. Aby wywołać rejestrację i przesyłanie identyfikatora FID za pomocą metody messaging:didReceiveRegistration:, musisz wywołać funkcję register przy uruchamianiu 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łączone zamienianie metod lub tworzysz aplikację w SwiftUI, musisz jawnie przypisać token APNs do identyfikatorów 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 za pomocą tych samych metod, co w przypadku włączonego zamieniania.

Uzyskiwanie dostępu do tokena rejestracji

Domyślnie pakiet SDK FCM generuje token rejestracyjny 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 przy uruchamianiu aplikacji, FCM udostępnia token rejestracji za pomocą metody FIRMessagingDelegatemessaging:didReceiveRegistrationToken:. 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. W każdym przypadku pakiet FCM SDK wywołuje funkcję messaging:didReceiveRegistrationToken: z prawidłowym tokenem.

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

  • Aplikacja zostanie przywrócona na nowym urządzeniu.
  • Użytkownik odinstaluje lub ponownie zainstaluje aplikację
  • Użytkownik czyści dane aplikacji.

Ustawianie delegata do obsługi wiadomości

Aby otrzymywać tokeny rejestracji, zaimplementuj protokół delegata wiadomości i ustaw właściwość FIRMessaging obiektu delegate po wywołaniu funkcji [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 samego siebie.

Swift

Messaging.messaging().delegate = self

Objective-C

[FIRMessaging messaging].delegate = self;

Pobieranie bieżącego tokena rejestracji

Tokeny rejestracji są dostarczane metodą messaging:didReceiveRegistrationToken:. Ta metoda jest zwykle wywoływana raz na uruchomienie aplikacji z tokenem rejestracji. Gdy ta metoda jest wywoływana, jest to idealny moment na:

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

Token możesz pobrać bezpośrednio za pomocą funkcji token(completion:). Jeśli pobieranie tokena nie powiedzie się z jakiegokolwiek powodu, zwracany jest 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);
  }
}];

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 przesyłania wiadomości. W tym przykładzie rejestrujemy delegata i dodajemy 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ę delegowania, możesz nasłuchiwać zdarzenia NSNotification o nazwie kFIRMessagingRegistrationTokenRefreshNotification. Właściwość tokena zawsze ma bieżącą wartość tokena.

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

Jeśli masz wyłączoną podmianę metody lub tworzysz aplikację w SwiftUI, musisz jawnie przypisać token APNs do tokena 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 rejestracyjnego FCM możesz uzyskać do niego dostęp i nasłuchiwać zdarzeń odświeżania za pomocą tych samych metod, co w przypadku włączonego zamieniania.

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 regionu Info.plist (nie do regionu GoogleService-Info.plist):

FirebaseMessagingAutoInitEnabled = NO

Aby ponownie włączyć FCM, możesz wykonać wywołanie w czasie działania programu:

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 wyświetlanie na urządzeniach 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 pomocnika rozszerzenia FCM w NotificationService.m. Zamiast kończyć wywołanie zwrotne za pomocą self.contentHandler(self.bestAttemptContent);, zakończ je za pomocą 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 wiadomości z powiadomieniem

  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 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. Wybierz Wiadomości z powiadomieniami 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 kliknij Wyślij wiadomość testową.

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

  8. Kliknij Przetestuj.

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

Aby uzyskać wgląd w dostarczanie wiadomości do aplikacji, otwórz panel DevOps i zaangażowanie > Wiadomości > Raporty w Firebase konsoli. Ten panel rejestruje liczbę wysłanych i otwartych wiadomości na urządzeniach z Androidem i Apple, a także dane dotyczące „wyświetleń” (powiadomień widzianych przez użytkowników) w przypadku aplikacji na Androida.

Dalsze kroki

Po wykonaniu czynności konfiguracyjnych możesz skorzystać z tych opcji, aby kontynuować korzystanie z FCM na platformach Apple: