Wyślij wiadomość testową do aplikacji Apple w tle

Aby rozpocząć korzystanie z FCM, zaimplementuj najprostszy przypadek użycia: wysyłanie testowego powiadomienia z  komponowania powiadomień na urządzenie programistyczne, gdy aplikacja działa w tle. Na tej stronie znajdziesz listę wszystkich kroków niezbędnych do osiągnięcia tego celu – od konfiguracji po weryfikację – może ona obejmować czynności już wykonane, jeśli masz skonfigurowaną aplikację kliencką Apple dla FCM.

Dodaj Firebase do projektu Apple

W tej sekcji znajdziesz czynności, które możesz już mieć wykonane, jeśli masz w swojej aplikacji włączone inne funkcje Firebase. W przypadku FCM musisz przesłać klucz uwierzytelniający APNs i zarejestrować się w celu otrzymywania powiadomień zdalnych.

Wymagania wstępne

• Zainstaluj te elementy:

  • Xcode 15.2 lub nowsza wersja

• Upewnij się, że Twój projekt spełnia te wymagania:

  • Twój projekt musi być kierowany na te wersje platform lub nowsze:
    • iOS 13
    • macOS 10.15
    • tvOS 13
    • watchOS 7

• Aby uruchomić aplikację, skonfiguruj fizyczne urządzenie Apple i wykonaj te czynności:

  • Uzyskaj klucz uwierzytelniający Apple Push Notification dla swojego konta Apple Developer.
  • Włącz powiadomienia push w XCode w sekcji Aplikacja > Możliwości.

• Zaloguj się w Firebase za pomocą konta Google.

Jeśli nie masz jeszcze projektu Xcode i chcesz wypróbować produkt Firebase, możesz pobrać jeden z naszych przykładów szybkiego startu.

Tworzenie projektu Firebase

Zanim dodasz Firebase do aplikacji Apple, musisz utworzyć projekt Firebase, aby połączyć go z aplikacją. Więcej informacji o projektach Firebase znajdziesz w artykule Informacje o projektach Firebase.

Zarejestruj swoją aplikację w Firebase

Aby korzystać z Firebase w aplikacji na urządzenia Apple, musisz ją zarejestrować w projekcie Firebase. Rejestrowanie aplikacji jest często nazywane „dodawaniem” aplikacji do projektu.

1. Otwórz konsolę Firebase.

2. W centrum strony „Opis” projektu kliknij ikonę iOS+, aby uruchomić proces konfiguracji.

   Jeśli masz już aplikację dodaną do projektu Firebase, kliknij Dodaj aplikację, aby wyświetlić opcje platformy.

3. W polu Identyfikator pakietu wpisz identyfikator pakietu aplikacji.

   Co to jest identyfikator pakietu i gdzie go znaleźć?

   • Identyfikator pakietu jednoznacznie identyfikuje aplikację w ekosystemie Apple.

   • Znajdź identyfikator pakietu: otwórz projekt w Xcode, wybierz aplikację najwyższego poziomu w nawigatorze projektu, a następnie wybierz kartę Ogólne.

     Wartością pola Identyfikator grupy jest identyfikator grupy (np. com.yourcompany.yourproject).

   • Pamiętaj, że w wartości identyfikatora pakietu rozróżniana jest wielkość liter i nie można jej zmienić dla tej aplikacji Firebase, gdy zostanie ona zarejestrowana w projekcie Firebase.

4. (Opcjonalnie) Wpisz inne informacje o aplikacji: nazwę skrótową aplikacji i identyfikator App Store.

   Jak nazwa aplikacji i identyfikator App Store są używane w Firebase?

   • Pseudonim aplikacji: wewnętrzny, wygodny identyfikator, który jest widoczny tylko dla Ciebie w konsoli Firebase

   • Identyfikator App Store: służy do Firebase Dynamic Linksprzekierowywania użytkowników na stronę aplikacji w App Store oraz do Google Analyticsimportowania zdarzeń konwersji do Google Ads. Jeśli Twoja aplikacja nie ma jeszcze identyfikatora App Store, możesz go dodać później w ustawieniach projektu.

5. Kliknij Zarejestruj aplikację.

Dodaj plik konfiguracji Firebase

1. Kliknij Download GoogleService-Info.plist, aby uzyskać plik konfiguracyjny platform Firebase Apple (GoogleService-Info.plist).

   Co należy wiedzieć o tym pliku konfiguracyjnym?

   • Plik konfiguracji Firebase zawiera unikalne, ale nie tajne identyfikatory projektu. Więcej informacji o tym pliku konfiguracyjnym znajdziesz w artykule Informacje o projektach Firebase.

   • W każdej chwili możesz ponownie pobrać plik konfiguracyjny Firebase.

   • Sprawdź, czy nazwa pliku konfiguracyjnego nie zawiera dodatkowych znaków, np. (2).

2. Przenieś plik konfiguracyjny do katalogu głównego projektu Xcode. Jeśli pojawi się taka prośba, wybierz opcję dodania pliku konfiguracyjnego do wszystkich miejsc docelowych.

Jeśli w projekcie masz wiele identyfikatorów pakietów, musisz powiązać każdy z nich z zarejestrowaną aplikacją w konsoli Firebase, tak aby każda aplikacja miała własny plik GoogleService-Info.plist.

Dodawanie pakietów SDK Firebase do aplikacji

Do instalacji zależności Firebase i zarządzania nimi możesz używać menedżera pakietów Swift.

1. Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > Dodaj pakiety).
2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:

  https://github.com/firebase/firebase-ios-sdk.git

3. Wybierz bibliotekę Firebase Cloud Messaging.
4. Dodaj flagę -ObjC w sekcji Inne flagi linkera w ustawieniach kompilacji docelowej.
5. Aby uzyskać optymalne wyniki w przypadku Firebase Cloud Messaging, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę z zbieraniem identyfikatorów IDFA lub bez niego.
6. Gdy to zrobisz, Xcode automatycznie zacznie wyszukiwać i pobierać zależności w tle.

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 projektu kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kartę Cloud Messaging.

2. W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij przycisk Prześlij.

3. Przejdź do lokalizacji, w której masz zapisany klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w Centrum dla deweloperów Apple) i kliknij Prześlij.

Inicjowanie Firebase w aplikacji

Musisz dodać do aplikacji kod inicjalizacji Firebase. Zaimportuj moduł Firebase i skonfiguruj współdzieloną instancję w następujący sposób:

1. Zaimportuj moduł FirebaseCore w pliku UIApplicationDelegate, a także wszystkie inne moduły Firebase, których używa delegowany obiekt aplikacji. Aby na przykład użyć właściwości Cloud Firestore i Authentication:

   SwiftUI

   import SwiftUI
   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Swift

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Objective-C

   @import FirebaseCore;
   @import FirebaseFirestore;
   @import FirebaseAuth;
   // ...
         

2. Skonfiguruj współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) w delegacie aplikacji:

   SwiftUI

   // Use Firebase library to configure APIs
   FirebaseApp.configure()

   Swift

   // Use Firebase library to configure APIs
   FirebaseApp.configure()

   Objective-C

   // Use Firebase library to configure APIs
   [FIRApp configure];

3. Jeśli używasz SwiftUI, musisz utworzyć obiekt delegujący aplikacji i dołączyć go do struktury App za pomocą funkcji UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Więcej informacji znajdziesz w instrukcjach SwiftUI.

   SwiftUI

   @main
   struct YourApp: App {
     // register app delegate for Firebase setup
     @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate
   
     var body: some Scene {
       WindowGroup {
         NavigationView {
           ContentView()
         }
       }
     }
   }
         

Rejestrowanie się na powiadomienia zdalne

UNUserNotificationCenter.current().delegate = self

let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
UNUserNotificationCenter.current().requestAuthorization(
  options: authOptions,
  completionHandler: { _, _ in }
)

application.registerForRemoteNotifications()
AppDelegate.swift

[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

Aby wysłać wiadomość na konkretne urządzenie, musisz znać jego token rejestracji. Aby ukończyć ten samouczek, musisz wpisać token w polu w  kompozytorze powiadomień. Po jego pobraniu skopiuj go lub zapisz w bezpiecznym miejscu.

Domyślnie pakiet SDK FCM generuje token rejestracji dla instancji aplikacji klienckiej przy uruchamianiu aplikacji. Podobnie jak w przypadku tokena urządzenia APN ten token umożliwia wysyłanie ukierunkowanych powiadomień do dowolnego konkretnego wystąpienia aplikacji.

Podobnie jak platformy Apple zwykle dostarczają token urządzenia APN po uruchomieniu aplikacji, FCM dostarcza token rejestracji za pomocą metody FIRMessagingDelegatemessaging:didReceiveRegistrationToken:. Pakiet FCM SDK pobiera nowy lub istniejący token podczas uruchamiania aplikacji oraz za każdym razem, gdy token zostanie zaktualizowany lub unieważniony. W każdym przypadku pakiet FCM SDK wywołuje funkcję messaging:didReceiveRegistrationToken: z poprawnym tokenem.

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

• Aplikacja jest przywracana na nowym urządzeniu
• Użytkownik odinstaluje/ponownie zainstaluje aplikację.
• Użytkownik czyści dane aplikacji.

Konfigurowanie delegata do obsługi wiadomości

Aby otrzymywać tokeny rejestracji, zaimplementuj protokół obsługi wiadomości i po wywołaniu funkcji [FIRApp configure] ustaw właściwość delegate obiektu FIRMessaging. Jeśli na przykład Twój pełnomocnik do aplikacji jest zgodny z protokołem przesyłania komunikatów, możesz go ustawić w application:didFinishLaunchingWithOptions: na siebie.

Messaging.messaging().delegate = self

[FIRMessaging messaging].delegate = self;

Pobieranie bieżącego tokena rejestracji

Tokeny rejestracji są dostarczane za pomocą metody messaging:didReceiveRegistrationToken:. Ta metoda jest wywoływana zwykle raz na rozpoczęcie aplikacji za pomocą tokena rejestracji. Wywołanie tej metody to idealny moment na:

• Jeśli token rejestracji jest nowy, prześlij go na serwer aplikacji.
• Subskrybuj token rejestracji w tematach. 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 pobranie tokena nie powiodło się w jakikolwiek sposób, zgłaszany jest błąd inny niż null.

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

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

W każdej chwili możesz użyć tej metody, aby uzyskać dostęp do tokena zamiast go przechowywać.

Monitorowanie odświeżania tokena

Aby otrzymywać powiadomienia za każdym razem, gdy token zostanie zaktualizowany, podaj przedstawiciela zgodnego z protokołem przekazywania. W tym przykładzie rejestrujemy delegata i dodajemy odpowiednią metodę delegata:

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

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

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

Wysyłanie wiadomości z powiadomieniem

1. Zainstaluj i uruchom aplikację na urządzeniu docelowym. Na urządzeniach Apple musisz zaakceptować prośbę o zezwolenie na otrzymywanie powiadomień zdalnych.

2. Upewnij się, że aplikacja na urządzeniu działa w tle.

3. W konsoli Firebase otwórz stronę Komunikacja.

4. Jeśli to Twoja pierwsza wiadomość, kliknij Utwórz pierwszą kampanię.

   1. Kliknij kolejno Wiadomości powiadomień Firebase i Utwórz.

5. Jeśli nie, na karcie Kampanie wybierz Nowa kampania, a potem Powiadomienia.

6. Wpisz tekst wiadomości. Pozostałe pola są opcjonalne.

7. W panelu po prawej stronie wybierz Wyślij wiadomość testową.

8. W polu Dodaj token rejestracji FCM wpisz token rejestracji uzyskany w poprzedniej sekcji tego przewodnika.

9. Kliknij Przetestuj.

Po wybraniu opcji Test wybrane urządzenie klienta (z aplikacją działającą w tle) powinno otrzymać powiadomienie.

Informacje o dostarczaniu wiadomości do Twojej aplikacji znajdziesz w panelu raportowania FCM, który rejestruje liczbę wysłanych i otwartych wiadomości na urządzeniach Apple i z Androidem oraz dane o „wyświetleniach” (powiadomieniach widocznych dla użytkowników) w aplikacjach na Androida.

Dalsze kroki

Aby dodać do aplikacji inne, bardziej zaawansowane funkcje niż tylko wiadomości z powiadomieniami, zapoznaj się z tymi artykułami:

• Otrzymywanie wiadomości w aplikacji klienta Apple
• Wysyłanie wiadomości na wiele urządzeń