Wprowadzenie do Komunikacji w chmurze Firebase


Ten przewodnik zawiera informacje o konfigurowaniu Firebase Cloud Messaging w aplikacjach klienckich na urządzenia mobilne i w internecie, aby można było niezawodnie wysyłać wiadomości. W przypadku środowisk serwerowych zapoznaj się z sekcją Środowisko serwerowe i FCM.

Konfigurowanie aplikacji klienckiej Firebase Cloud Messaging na platformach Apple

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 Objective-C lub Swift, zalecamy użycie interfejsu FIRMessaging API. Przykład szybkiego startu 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 zamianę metod w 2 głównych obszarach: mapowaniu tokena APNs na token rejestracji FCM i przechwytywaniu danych analitycznych podczas obsługi wywołania zwrotnego wiadomości wysyłanej do urządzenia. Programiści, którzy wolą nie używać zamiany, mogą ją wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled do pliku Info.plist aplikacji i ustawiając jej wartość na NO (wartość logiczna). W odpowiednich sekcjach przewodników znajdziesz 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 Centrum dla deweloperów Apple.

  1. W projekcie w Firebase konsoli kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kliknij kartę Cloud Messaging.

  2. W sekcji Klucz uwierzytelniania APNs w Konfiguracji aplikacji na iOS kliknij przycisk 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 programistów Apple) i kliknij Prześlij.

Rejestrowanie powiadomień zdalnych

Zarejestruj aplikację do otrzymywania powiadomień zdalnych podczas uruchamiania lub w odpowiednim momencie przepływu 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()

AppDelegate.swift

Objective-C

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

[application registerForRemoteNotifications];
AppDelegate.m

Dostęp 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 odinstalowuje i ponownie instaluje aplikację
  • Użytkownik czyści dane aplikacji.

Ustawianie osoby upoważnionej do wysyłania 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 przesyłania 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 FCM registration token: \(error)")
  } else if let token = token {
    print("FCM registration token: \(token)")
    self.fcmRegTokenMessage.text  = "Remote FCM registration token: \(token)"
  }
}

Objective-C

[[FIRMessaging messaging] tokenWithCompletion:^(NSString *token, NSError *error) {
  if (error != nil) {
    NSLog(@"Error getting FCM registration token: %@", error);
  } else {
    NSLog(@"FCM registration token: %@", token);
    self.fcmRegTokenMessage.text = token;
  }
}];

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))")

  let dataDict: [String: String] = ["token": fcmToken ?? ""]
  NotificationCenter.default.post(
    name: Notification.Name("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.
}

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

Zamiast podawać metodę delegowania, możesz nasłuchiwać zdarzenia NSNotification o nazwiekFIRMessagingRegistrationTokenRefreshNotification. Właściwość tokena zawsze ma bieżącą wartość tokena.

Swizzling wyłączony: mapowanie tokena APNs i tokena rejestracji

Jeśli masz wyłączone zamienianie metod 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 FCM tokena rejestracyjnego 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.

Zapobieganie automatycznej inicjalizacji

Gdy generowany jest FCM token rejestracji, biblioteka przesyła identyfikator i dane konfiguracyjne do Firebase. Jeśli chcesz najpierw uzyskać wyraźną zgodę użytkowników, możesz zapobiec generowaniu tokenów w momencie konfiguracji, 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 programu:

Swift

Messaging.messaging().autoInitEnabled = true

Objective-C

[FIRMessaging messaging].autoInitEnabled = YES;

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

Wysyłanie wiadomości z powiadomieniem

  1. Zainstaluj i uruchom aplikację na urządzeniu docelowym. Na urządzeniach Apple zaakceptuj prośbę o zezwolenie na otrzymywanie powiadomień zdalnych.
  2. Sprawdź, czy aplikacja działa w tle na urządzeniu.
  3. W konsoli Firebase otwórz stronę Wiadomości.
  4. Jeśli to Twoja pierwsza wiadomość, kliknij Utwórz pierwszą kampanię.
    1. Wybierz Wiadomości z powiadomieniami Firebase i kliknij Utwórz.
  5. W przeciwnym razie na karcie Kampanie kliknij Nowa kampania, a potem Powiadomienia.
  6. Wpisz tekst wiadomości.
  7. W panelu po prawej stronie kliknij Wyślij wiadomość testową.
  8. W polu Dodaj token rejestracji wpisz token rejestracji.FCM
  9. Kliknij Przetestuj.

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

Aby uzyskać informacje o dostarczaniu wiadomości do aplikacji, otwórz FCMpanel raportowania, który rejestruje liczbę wysłanych i otwartych wiadomości na urządzeniach z Androidem i iOS.

Dalsze kroki

Po skonfigurowaniu klienta Apple możesz zacząć odbierać i wysyłać wiadomości do użytkowników: