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

Wybierz platformę: iOS+ Android Sieć 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 Objective-C lub Swift, zalecamy używanie interfejsu FIRMessaging API. 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 token rejestracji FCM oraz rejestrowaniu danych Analytics podczas obsługi wywołania zwrotnego wiadomości wysyłanej do klienta. Programiści, którzy nie chcą używać podmiany metody, mogą ją wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled w pliku Info.plist aplikacji i ustawiając ją na NO (wartość logiczna). 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ę 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 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 w ścieżce 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()

MigratedSnippets.swift

Objective-C

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

[application registerForRemoteNotifications];
ObjCMigratedSnippets.m

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 metodę 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 na uruchomienie aplikacji z tokenem rejestracji. Gdy ta metoda jest wywoływana, jest to idealny moment, aby:

  • jeśli token rejestracji jest nowy, wysłać 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. Poniższy 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.
}
MigratedSnippets.swift

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

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

Wyłączona podmiana metody: 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 FCM rejestracji. Zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) aby pobrać token APNs, a następnie ustaw Messaging's apnsToken właściwość:

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 zostanie wygenerowany token rejestracji FCM, biblioteka prześle identyfikator i dane konfiguracyjne do Firebase. Jeśli chcesz najpierw uzyskać wyraźną zgodę użytkowników, możesz zapobiec generowaniu tokena 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ć funkcję 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 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 prawym panelu kliknij Wyślij wiadomość testową.

  7. W polu Dodaj token rejestracji wpisz token rejestracji.FCM

  8. Kliknij Testuj.

Gdy klikniesz Testuj, 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 rejestruje liczbę wiadomości wysłanych i otwartych 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: