Dodawanie powiadomień push do aplikacji na iOS

1. Wprowadzenie

Ostatnia aktualizacja: 6.01.2020

Komunikacja w chmurze Firebase (FCM) to wieloplatformowe rozwiązanie do obsługi wiadomości, które pozwala na niezawodne wysyłanie wiadomości bezpłatnie.

Przy użyciu FCM możesz powiadomić aplikację kliencką, że dostępne są nowe e-maile lub inne dane do zsynchronizowania. Możesz wysyłać powiadomienia, aby zachęcać użytkowników do ponownego zaangażowania i utrzymania. Na przykład w przypadku korzystania z czatu wiadomość może przesłać do aplikacji klienckiej ładunek o wielkości do 4 KB.

Jak to działa?

Implementacja w FCM obejmuje 2 główne komponenty związane z wysyłaniem i odbieraniem:

1. Zaufane środowisko, takie jak Cloud Functions dla Firebase lub serwer aplikacji, w którym możesz tworzyć, kierować i wysyłać wiadomości.
2. Aplikacja kliencka na iOS, Androida lub internetowa (JavaScript) umożliwiająca odbieranie wiadomości za pośrednictwem odpowiedniej usługi transportowej zależnej od platformy.

Omówienie architektury FCM

FCM wykorzystuje ten zestaw komponentów, które tworzą, transportują i odbierają wiadomości:

1. narzędzia do tworzenia i kompilowania żądań wiadomości, Edytor powiadomień udostępnia opartą na GUI opcję tworzenia żądań powiadomień. Aby zapewnić pełną automatyzację i obsługę wszystkich typów wiadomości, musisz utworzyć żądania wiadomości w zaufanym środowisku serwera, które obsługuje pakiet SDK Firebase Admin lub protokoły serwera FCM. Może to być Cloud Functions dla Firebase, Google App Engine lub Twój własny serwer aplikacji.
2. Backend FCM, który (wraz z innymi funkcjami) akceptuje żądania wiadomości, przeprowadza zwielokrotnienie wiadomości za pomocą tematów i generuje metadane wiadomości, takie jak identyfikator wiadomości.
3. Warstwa transportu na poziomie platformy, która kieruje wiadomość do urządzenia docelowego, obsługuje dostarczanie wiadomości i w razie potrzeby stosuje konfigurację specyficzną dla platformy. Warstwa transportowa obejmuje:

• Warstwa transportowa Androida (ATL) na urządzeniach z Androidem z Usługami Google Play
• Usługa Apple Push Notification (APN) na urządzeniach z iOS
• Protokół Web push dla aplikacji internetowych

Uwaga: warstwy transportu na poziomie platformy są poza usługą FCM. Wiadomości FCM kierowane do warstwy transportu na poziomie platformy mogą podlegać warunkom specyficznym dla tej platformy, a nie warunkom korzystania z usługi FCM. Routing wiadomości na Androidzie przez ATL podlega Warunkom korzystania z interfejsów API Google.

4. Pakiet SDK FCM na urządzeniu użytkownika, na którym wyświetla się powiadomienie lub wiadomość jest obsługiwana zgodnie ze stanem aplikacji na pierwszym planie/w tle oraz odpowiedniej logiki aplikacji.

Co utworzysz

W ramach tego ćwiczenia w programie dodasz powiadomienia push do przykładowej aplikacji na iOS przy użyciu FCM.

Czego się nauczysz

• Jak zasubskrybować wiadomości push i anulować ich subskrypcję
• Obsługa przychodzących wiadomości push
• Jak wyświetlić powiadomienie
• Jak reagować na kliknięcia powiadomień

Czego potrzebujesz

• Xcode w wersji 11.0 lub nowszej
• CocoaPods w wersji 1.9.0 lub nowszej
• Konto dewelopera Apple
• fizyczne urządzenie z iOS, na którym aplikacja ma działać;
• Podstawowa wiedza o języku Swift

2. Przygotowanie

Pobierz przykładowy kod

W ramach tego ćwiczenia w Codelabs stworzysz własną aplikację testową, ale jeśli chcesz zobaczyć i uruchomić istniejącą przykładową aplikację, możesz pobrać przykładowy kod krótkiego wprowadzenia.

Próbkę można pobrać na 2 sposoby:

• Sklonuj repozytorium Git:

$ git clone https://github.com/firebase/quickstart-ios.git

• Pobierz plik ZIP:

Jeśli pobierzesz plik źródłowy jako plik ZIP, rozpakowanie go spowoduje utworzenie folderu głównego quickstart-ios.

Pobieranie kodu źródłowego

Tworzenie nowej aplikacji

Utwórz własną aplikację testową, wykonując te czynności (instrukcje znajdziesz w pakiecie XCode w wersji 12.3):

1. Otwórz XCode i wybierz Utwórz nowy projekt Xcode.
2. Wybierz Aplikacja i kliknij Dalej.

3. Wpisz Product Name (Nazwa produktu) (np. MessagingExample)
4. Wybierz Zespół (jeśli nie masz utworzonego zespołu, skonfiguruj go na koncie dewelopera Apple).
5. Wpisz identyfikator organizacji (np. com.your-name)
6. Wpisz identyfikator pakietu (np. com.your-name.MessagingExample, powinien być niepowtarzalny wśród wszystkich aplikacji na iOS).
7. Wybierz Scenorys z menu Interface.
8. W menu Life Cycle (Cykl życia) wybierz UIKit App Delegate.
9. Jako Język wybierz Swift.
10. Kliknij Dalej.

Identyfikator pakietu będzie potrzebny podczas tworzenia klucza APN i rejestrowania aplikacji w projekcie Firebase.

3. Konfigurowanie APN-ów

Tworzenie klucza uwierzytelniania

W tej sekcji opisujemy, jak wygenerować klucz uwierzytelniania dla identyfikatora aplikacji, w którym włączono powiadomienia push. Jeśli masz już klucz, możesz go użyć zamiast generować nowy.

Aby utworzyć klucz uwierzytelniania:

1. Na koncie dewelopera przejdź do sekcji Certyfikaty, identyfikatory Profile i kliknij Klucze.

2. Kliknij przycisk Dodaj (+) w prawym górnym rogu.

3. Wpisz opis klucza uwierzytelniania APNs
4. W sekcji Key Services (Usługi kluczy) zaznacz pole wyboru punktów APN, a potem kliknij Dalej.

5. Kliknij Zarejestruj, a następnie Pobierz. Zapisz klucz w bezpiecznym miejscu. Jest to pobieranie jednorazowe, którego nie można później pobrać.

Tworzenie identyfikatora aplikacji

Identyfikator aplikacji to unikalny identyfikator aplikacji. Zgodnie z konwencją jest ona reprezentowana przez odwróconą domenę.

1. Otwórz Apple Developer Member Center i zaloguj się.
2. Otwórz Certyfikaty, identyfikatory i profile.
3. Kliknij Identyfikatory.
4. Kliknij przycisk +, aby utworzyć nowy identyfikator aplikacji.
5. Zaznacz opcję Identyfikatory aplikacji i kliknij Dalej.

6. Kliknij kolejno Aplikacja i Dalej.

7. Aby utworzyć nowy identyfikator aplikacji:
8. Wpisz nazwę identyfikatora aplikacji.
9. Wpisz identyfikator zespołu. Ta wartość musi pasować do identyfikatora zespołu na karcie Członkostwo.
10. W sekcji Sufiks identyfikatora aplikacji wybierz Jawny identyfikator aplikacji, a potem wpisz identyfikator pakietu.
11. W sekcji Usługi aplikacji sprawdź, czy Powiadomienia push są zaznaczone.
12. Kliknij Dalej i sprawdź, czy dane są prawidłowe:
13. Wartość parametru Identifier powinna być zgodna z konkatenacją wartości identyfikatora zespołu i identyfikatora pakietu.
14. Powiadomienia push powinny mieć opcję Configurable
15. Kliknij Zarejestruj, aby utworzyć identyfikator aplikacji.

Tworzenie profilu

Aby przetestować aplikację w trakcie programowania, potrzebujesz profilu do programowania, który pozwoli na autoryzowanie urządzeń do uruchamiania aplikacji, która nie została jeszcze opublikowana w App Store.

1. Otwórz Apple Developer Member Center i zaloguj się.
2. Otwórz Certyfikaty, identyfikatory i profile.
3. W menu w lewym górnym rogu kliknij iOS, tvOS, watchOS (jeśli nie jest zaznaczone), a potem kliknij Profile.
4. Kliknij przycisk +, aby utworzyć nowy profil.
5. Jako typ profilu obsługi administracyjnej wybierz Tworzenie aplikacji na iOS i kliknij Dalej.

6. W menu wybierz identyfikator aplikacji, którego chcesz użyć, a potem kliknij Dalej.
7. Wybierz certyfikat programowania na iOS dla identyfikatora aplikacji wybranego w poprzednim kroku, a potem kliknij Dalej.
8. Wybierz urządzenia z iOS, które chcesz uwzględnić w profilu obsługi administracyjnej, a następnie kliknij Dalej. Zaznacz wszystkie urządzenia, których chcesz użyć do przeprowadzenia testu.
9. Wpisz nazwę tego profilu obsługi administracyjnej (np. MessagingExampleProfile) i kliknij Wygeneruj.

10. Kliknij Pobierz, aby zapisać profil obsługi administracyjnej na Macu.

11. Kliknij dwukrotnie plik profilu obsługi administracyjnej, aby go zainstalować.

4. Dodaję Firebase do projektu iOS

Tworzenie projektu Firebase

Zanim dodasz Firebase do swojej aplikacji na iOS, musisz utworzyć projekt Firebase i połączyć ją ze swoją aplikacją na iOS. Więcej informacji o projektach Firebase znajdziesz w artykule Omówienie projektów Firebase.

1. W konsoli Firebase kliknij Dodaj projekt i wybierz lub wpisz nazwę projektu.

Jeśli masz już projekt Google Cloud Platform (GCP), możesz go wybrać z menu, aby dodać do niego zasoby Firebase.

2. (Opcjonalnie) Jeśli tworzysz nowy projekt, możesz edytować jego identyfikator.

Firebase automatycznie przypisuje unikalny identyfikator do projektu Firebase. W artykule „Omówienie projektów Firebase” dowiesz się, jak Firebase używa identyfikatora projektu.

Uwaga: gdy Firebase udostępni zasoby projektu Firebase, nie można już zmienić jego identyfikatora. Aby używać konkretnego identyfikatora, musisz zmodyfikować identyfikator projektu na tym etapie konfiguracji.

3. Kliknij Dalej.
4. Skonfiguruj Google Analytics w swoim projekcie, aby zapewnić optymalny komfort korzystania z jednej z tych usług Firebase:

• Firebase Crashlytics
• Prognozy Firebase
• Komunikacja w chmurze Firebase
• Wysyłanie wiadomości w aplikacji Firebase
• Zdalna konfiguracja Firebase
• Testy A/B Firebase

Gdy pojawi się odpowiedni komunikat, wybierz opcję korzystania z dotychczasowego konta Google Analytics lub utwórz nowe konto. Jeśli zdecydujesz się utworzyć nowe konto, wybierz lokalizację raportowania Analytics, a następnie zaakceptuj ustawienia udostępniania danych i warunki korzystania z Google Analytics w swoim projekcie.

5. Kliknij Utwórz projekt (lub Dodaj Firebase, jeśli używasz istniejącego projektu GCP).

Firebase automatycznie udostępnia zasoby projektu Firebase. Po zakończeniu tego procesu otworzy się strona przeglądu Twojego projektu Firebase w konsoli Firebase.

Rejestrowanie aplikacji w Firebase

Po utworzeniu projektu Firebase możesz dodać do niego swoją aplikację na iOS.

W artykule Informacje o projektach Firebase znajdziesz więcej informacji o sprawdzonych metodach i kwestii związanych z dodawaniem aplikacji do projektu Firebase, w tym o obsłudze wielu wariantów kompilacji.

1. Otwórz konsolę Firebase.
2. Aby uruchomić przepływ pracy konfiguracji, na środku strony przeglądu projektu kliknij ikonę iOS.

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

3. W polu Identyfikator pakietu na iOS wpisz identyfikator pakietu aplikacji.
4. (Opcjonalnie) Podaj inne informacje o aplikacji: Pseudonim aplikacji i Identyfikator sklepu z aplikacjami.
5. Kliknij Zarejestruj aplikację.

Dodawanie pliku konfiguracji Firebase

1. Kliknij Download GoogleService-Info.plist, aby uzyskać plik konfiguracyjny Firebase na iOS (GoogleService-Info.plist).
2. Przenieś plik konfiguracji do katalogu głównego projektu Xcode. Jeśli pojawi się taka prośba, wybierz opcję dodania pliku konfiguracyjnego do wszystkich środowisk docelowych.

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

Zamknij XCode.

Dodawanie pakietów SDK Firebase do aplikacji

Do zainstalowania bibliotek Firebase zalecamy użycie CocoaPods. Jeśli jednak nie chcesz używać CocoaPods, możesz zintegrować platformy SDK bezpośrednio lub skorzystać z Menedżera pakietów Swift w wersji beta.

1. Utwórz plik Podfile, jeśli jeszcze go nie masz. Jeśli używasz przykładowego krótkiego wprowadzenia, projekt Xcode i plik Podfile (z podami) są już dostępne.

$ cd MessagingExample
$ pod init

2. Dodaj do pliku Podfile pody Firebase, których chcesz używać w swojej aplikacji.

Do aplikacji na iOS możesz dodać dowolne obsługiwane usługi Firebase.

W przykładowym krótkim wprowadzeniu dodaliśmy pakiety SDK Google Analytics i Firebase Cloud Messaging.

# Add the Firebase pod for Google Analytics
pod 'Firebase/Analytics'

# Add the pod for Firebase Cloud Messaging
pod 'Firebase/Messaging'

3. Zainstaluj pody, a następnie otwórz plik .xcworkspace, aby wyświetlić projekt w Xcode:

$ pod install

4. Otwórz MessagingExample.xcworkspace i w konsoli Firebase kliknij Dalej.

Zainicjowanie Firebase w aplikacji

Musisz dodać do swojej aplikacji kod inicjowania Firebase.

Zaimportuj moduł Firebase i skonfiguruj udostępnioną instancję (w przykładzie z krótkim wprowadzeniem moduł Firebase został już zaimportowany).

1. Zaimportuj moduł Firebase w UIApplicationDelegate:

AppDelegate.swift

import UIKit
import Firebase // Add this line

2. Skonfiguruj współdzielone wystąpienie FirebaseApp, zwykle za pomocą metody application:didFinishLaunchingWithOptions: aplikacji:

AppDelegate.swift

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  FirebaseApp.configure() // Add this line
  return true
}

3. W konsoli Firebase kliknij Dalej.
4. Pakiety SDK Firebase zostały dodane do aplikacji. Kliknij Przejdź do konsoli.

5. Konfigurowanie klienta FCM

Prześlij klucz uwierzytelniania APNs

Prześlij swój klucz uwierzytelniania APNs do Firebase.

1. W swoim projekcie w konsoli Firebase kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie otwórz kartę Komunikacja w chmurze.
2. W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij przycisk Prześlij.
3. Przejdź do lokalizacji, w której został zapisany klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny na stronie Certificates, Identifiers &Profiles (Certyfikaty, identyfikatory i profile) w Apple Developer Member Center), a następnie kliknij Prześlij.

Rejestracja do korzystania z powiadomień zdalnych

Przy uruchamianiu lub w wybranym momencie przepływu aplikacji zarejestruj ją w celu odbierania powiadomień zdalnych.

W przykładowym krótkim wprowadzeniu identyfikator registerForRemoteNotifications został już dodany.

AppDelegate.swift

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  FirebaseApp.configure()
  // [START register for remote notifications]
  if #available(iOS 10.0, *) {
    // For iOS 10 display notification (sent via APNS)
    UNUserNotificationCenter.current().delegate = self
        
    let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
    UNUserNotificationCenter.current().requestAuthorization(options: authOptions, completionHandler: {_, _ in })
  } else {
    let settings: UIUserNotificationSettings = UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
    application.registerUserNotificationSettings(settings)
  }

  application.registerForRemoteNotifications()
  // [END register for remote notifications]
  return true
}

Przypisz właściwość przedstawiciela UNUserNotificationCenter, dodając te wiersze na końcu pliku AppDelegate.swift.

AppDelegate.swift

@available(iOS 10, *)
extension AppDelegate : UNUserNotificationCenterDelegate {

  // Receive displayed notifications for iOS 10 devices.
  func userNotificationCenter(_ center: UNUserNotificationCenter,
                              willPresent notification: UNNotification,
    withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    let userInfo = notification.request.content.userInfo

    // Print full message.
    print(userInfo)

    // Change this to your preferred presentation option
    completionHandler([[.alert, .sound]])
  }

  func userNotificationCenter(_ center: UNUserNotificationCenter,
                              didReceive response: UNNotificationResponse,
                              withCompletionHandler completionHandler: @escaping () -> Void) {
    let userInfo = response.notification.request.content.userInfo

    // Print full message.
    print(userInfo)

    completionHandler()
  }
}

Ustawianie osoby, której przekazano dostęp do wiadomości

Aby otrzymywać tokeny rejestracji, zaimplementuj protokół przekazywania wiadomości i ustaw właściwość delegate interfejsu FIRMessaging po wywołaniu [FIRApp configure]. Jeśli na przykład użytkownik, któremu przekazano dostęp do aplikacji, jest zgodny z protokołem przesyłania wiadomości, możesz ustawić w application:didFinishLaunchingWithOptions: swoją osobę przekazującą (w przykładzie z krótkim wprowadzeniem jest to już ustawione).

AppDelegate.swift

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  FirebaseApp.configure()
  Messaging.messaging().delegate = self // Add this line
  // [START register for remote notifications]
  if #available(iOS 10.0, *) {
    // For iOS 10 display notification (sent via APNS)
    UNUserNotificationCenter.current().delegate = self
        
    let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
    UNUserNotificationCenter.current().requestAuthorization(options: authOptions, completionHandler: {_, _ in })
  } else {
    let settings: UIUserNotificationSettings = UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
    application.registerUserNotificationSettings(settings)
  }

  application.registerForRemoteNotifications()
  // [END register for remote notifications]
  return true
}

Przypisz właściwość przedstawiciela FIRMessaging, dodając te wiersze na końcu pliku AppDelegate.swift.

AppDelegate.swift

extension AppDelegate : MessagingDelegate {
  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)
  }
}

Dodaj uprawnienia

Funkcja powiadomień push została dodana w sekcji Create an App ID, ale musisz dodać ją także w XCode, wykonując następujące czynności (poniżej znajdziesz instrukcje XCode 12.3):

1. Kliknij nazwę projektu w obszarze Nawigator (Nawigator).
2. Kliknij Podpisz i Możliwości.
3. Kliknij + Funkcja.

4. Kliknij dwukrotnie Tryby w tle.
5. Ponownie kliknij + Funkcja.
6. Kliknij dwukrotnie Powiadomienia push.
7. Zaznacz Powiadomienia zdalne w sekcji Tryby w tle.

6. Wyślij wiadomość z powiadomieniem

Aby wysłać wiadomość testową:

1. Zainstaluj i uruchom aplikację na urządzeniu docelowym. Aby otrzymywać zdalne powiadomienia, musisz zaakceptować prośbę o zgodę.
2. Uzyskaj token rejestracji z logu XCode.

3. Upewnij się, że aplikacja na urządzeniu działa w tle.
4. Otwórz edytor powiadomień i wybierz Nowe powiadomienie.
5. Wpisz tekst wiadomości.
6. Kliknij Wyślij wiadomość testową.
7. W polu Dodaj token rejestracji FCM wpisz token rejestracji uzyskany w kroku 2.
8. Kliknij Przetestuj.

Gdy klikniesz Przetestuj, w centrum powiadomień powinno pojawić się powiadomienie na docelowym urządzeniu klienckim (z aplikacją w tle).

Więcej informacji o dostarczaniu wiadomości do Twojej aplikacji znajdziesz w panelu raportowania FCM, który rejestruje liczbę wiadomości wysłanych i otwartych na urządzeniach z iOS i Androidem.

7. Gratulacje

Gratulacje, wiadomość testowa została wysłana.

Jest o wiele więcej funkcji i konfiguracji w FCM, takich jak subskrypcja tematów.

Jeśli Cię Cię interesują, zajrzyj do oficjalnego dokumentu dla deweloperów.

Co dalej?

Zapoznaj się z niektórymi z tych ćwiczeń z programowania.

• Zaawansowane funkcje Androida w Kotlin 01.2:Komunikacja w chmurze Firebase na Androida

Więcej informacji

• Oficjalny dokument Firebase Cloud Messaging