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

FCM Pakiet SDK wykonuje podmianę metody 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 z serwera do klienta. 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łączoną i wyłączoną podmianą metody.

Przesyłanie klucza uwierzytelniającego APNs

Prześlij klucz uwierzytelniający APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, utwórz go w Centrum dla deweloperów Apple.

  1. W konsoli Firebase otwórz Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.
  2. W sekcji Klucz uwierzytelniania APNs w Konfiguracji 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 Centrum dla deweloperów Apple) i kliknij Prześlij.

Rejestrowanie powiadomień zdalnych

Zarejestruj aplikację do odbierania powiadomień zdalnych na początku lub w wybranym momencie procesu 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 FCM SDK rejestruje instancję aplikacji w usłudze FCM i zwraca identyfikator instalacji Firebase (FID) dla instancji aplikacji klienta 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 przy uruchamianiu aplikacji, FCM udostępnia identyfikator FID do kierowania powiadomień. Pakiet SDKFCM 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 się on zmienić.

Szczegółowe informacje o tym, kiedy identyfikatory instalacji Firebase 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 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 wyłączysz automatyczną inicjację, pakiet SDK FCM nie będzie automatycznie rejestrować 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ć 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.");
}];

Wyłączone zamienianie: mapowanie tokena APNs i identyfikatora FID

Jeśli masz wyłączoną podmianę metody lub tworzysz aplikację w SwiftUI, musisz jawnie mapować tokeny 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 za pomocą tych samych metod, co w przypadku włączonego zamieniania.

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 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 odinstalowuje i ponownie instaluje aplikację
  • Użytkownik wyczyś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 w delegate 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 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. Wywołanie tej metody 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);
  }
}];

Z tej metody możesz skorzystać 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 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 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łączonego swizzlingu.

Zapobieganie automatycznej inicjalizacji

Gdy zostanie wygenerowana FCMrejestracja, 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 Info.plist (nie do 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 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 zadania konfiguracyjne dotyczące modyfikowania i wyświetlania powiadomień w APNs, a następnie dodaj interfejs API pomocnika rozszerzenia FCM w NotificationService.m. Zamiast wywoływać funkcję zwrotną za pomocą kodu self.contentHandler(self.bestAttemptContent);, wywołaj ją za pomocą kodu 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 iOS, a także dane o „wyświetleniach” (powiadomieniach widocznych dla 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: