Dodawanie powiadomień push do aplikacji na iOS

1. Wprowadzenie

Ostatnia aktualizacja: 2020-1-6

Komunikacja w chmurze Firebase (FCM) to rozwiązanie do przesyłania wiadomości na wielu platformach, które umożliwia niezawodne wysyłanie wiadomości bezpłatnie.

Za pomocą FCM możesz powiadamiać aplikację kliencką o dostępności nowych e-maili lub innych danych do synchronizacji. Możesz wysyłać wiadomości z powiadomieniami, aby zwiększać ponowne zaangażowanie i utrzymywać użytkowników. W przypadku takich zastosowań jak komunikatory internetowe wiadomość może przesyłać do aplikacji klienta ładunek o rozmiarze do 4 KB.

Jak to działa?

Wdrożenie FCM obejmuje 2 główne komponenty do wysyłania i odbierania:

1. Zaufane środowisko, takie jak Cloud Functions dla Firebase lub serwer aplikacji, w którym można tworzyć, kierować i wysyłać wiadomości.
2. Aplikacja kliencka na iOS, Androida lub internet (JavaScript), która odbiera wiadomości za pomocą odpowiedniej usługi transportu specyficznej dla platformy.

Omówienie architektury FCM

FCM korzysta z tych komponentów, które tworzą, przesyłają i odbierają wiadomości:

1. narzędzia do tworzenia próśb o wiadomości; Edytor powiadomień udostępnia interfejs GUI do tworzenia żądań powiadomień. Aby uzyskać pełną automatyzację i obsługę wszystkich typów wiadomości, musisz tworzyć żądania wiadomości w zaufanym środowisku serwera, które obsługuje pakiet Firebase Admin SDK 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 (między innymi) akceptuje żądania wiadomości, rozpowszechnia wiadomości za pomocą tematów i generuje metadane wiadomości, takie jak identyfikator wiadomości.
3. Warstwa transportowa na poziomie platformy, która kieruje wiadomość na docelowe urządzenie, obsługuje dostarczanie wiadomości i w razie potrzeby stosuje konfigurację specyficzną dla platformy. Ta warstwa transportowa obejmuje:

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

Uwaga: warstwy transportowe na poziomie platformy nie są częścią usługi FCM. Wiadomości FCM kierowane do warstwy transportowej na poziomie platformy mogą podlegać warunkom specyficznym dla tej platformy, a nie warunkom korzystania z usługi FCM. Routing wiadomości na Androida za pomocą ATL podlega Warunkom korzystania z interfejsów API Google.

4. Pakiet FCM SDK na urządzeniu użytkownika, na którym wyświetlane jest powiadomienie lub obsługiwana jest wiadomość zgodnie ze stanem aplikacji (na pierwszym planie lub w tle) i odpowiednią logiką aplikacji.

Co utworzysz

W tym ćwiczeniu dodasz powiadomienia push do przykładowej aplikacji na iOS za pomocą FCM.

Czego się nauczysz

• Subskrybowanie i anulowanie subskrypcji powiadomień push
• Jak postępować z przychodzącymi wiadomościami push
• Jak wyświetlić powiadomienie
• Jak reagować na kliknięcia powiadomień

Czego potrzebujesz

• Xcode 11.0 lub nowsze
• CocoaPods w wersji 1.9.0 lub nowszej
• Konto dewelopera Apple
• fizyczne urządzenie z iOS, na którym można uruchomić aplikację;
• Podstawowa znajomość języka Swift

2. Przygotowania

Pobierz przykładowy kod

W tym laboratorium kodowania utworzysz własną aplikację testową, ale jeśli chcesz zobaczyć i uruchomić istniejącą aplikację przykładową, możesz pobrać przykładowy kod szybkiego startu.

Próbkę możesz uzyskać na 2 sposoby:

• Sklonuj repozytorium Git:

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

• Pobierz plik ZIP:

Jeśli pobierzesz źródło jako plik ZIP, po jego rozpakowaniu otrzymasz folder główny quickstart-ios.

Pobierz kod źródłowy

Tworzenie nowej aplikacji

Utwórz własną aplikację testową, wykonując te czynności (poniższe kroki dotyczą XCode 12.3):

1. Otwórz Xcode i kliknij Create a new Xcode project (Utwórz nowy projekt w Xcode).
2. Kliknij kolejno Aplikacja i Dalej.

3. Wpisz Nazwę 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, musi być unikalny wśród wszystkich aplikacji na iOS).
7. W menu Interfejs wybierz Scenorys.
8. W menu Life Cycle (Cykl życia) wybierz UIKit App Delegate (Delegat aplikacji UIKit).
9. Wybierz Swift w sekcji Język.
10. Kliknij Dalej.

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

3. Konfigurowanie APNs

Utwórz klucz uwierzytelniający

W tej sekcji znajdziesz informacje o tym, jak wygenerować klucz uwierzytelniania dla identyfikatora aplikacji z włączonymi powiadomieniami push. Jeśli masz już klucz, możesz go użyć zamiast generować nowy.

Aby utworzyć klucz uwierzytelniający:

1. Na koncie dewelopera otwórz Certyfikaty, identyfikatory i profile, a następnie Klucze.

2. W prawym górnym rogu kliknij przycisk Dodaj (+).

3. Wpisz opis klucza uwierzytelniania APNs
4. W sekcji Usługi kluczy zaznacz pole wyboru APNs i kliknij Dalej.

5. Kliknij Zarejestruj, a potem Pobierz. Zapisz klucz w bezpiecznym miejscu. Jest to jednorazowe pobieranie, a klucza nie można później odzyskać.

Tworzenie identyfikatora aplikacji

Identyfikator aplikacji to identyfikator, który jednoznacznie identyfikuje aplikację. Zgodnie z konwencją jest on reprezentowany przez odwróconą domenę.

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

6. Wybierz Aplikacja i kliknij Dalej.

7. Aby utworzyć nowy identyfikator aplikacji:
8. Wpisz nazwę identyfikatora aplikacji.
9. Wpisz identyfikator zespołu. Ta wartość musi być zgodna z identyfikatorem zespołu na karcie Członkostwo.
10. W sekcji Sufiks identyfikatora aplikacji wybierz Jawny identyfikator aplikacji, a następnie wpisz Identyfikator pakietu.
11. W sekcji Usługi aplikacji sprawdź, czy jest zaznaczona opcja Powiadomienia push.
12. Kliknij Dalej i sprawdź, czy wpisane dane są prawidłowe:
13. Wartość Identyfikator powinna być zgodna z konkatenacją wartości identyfikatora zespołu i identyfikatora pakietu.
14. Powiadomienia push powinny być konfigurowalne.
15. Aby utworzyć identyfikator aplikacji, kliknij Zarejestruj.

Tworzenie profilu

Aby testować aplikację w trakcie jej tworzenia, musisz mieć profil dewelopera, który autoryzuje urządzenia do uruchamiania aplikacji, która nie została jeszcze opublikowana w App Store.

1. Otwórz Apple Developer Member Center i się zaloguj.
2. Otwórz Certyfikaty, identyfikatory i profile.
3. W menu u góry po lewej stronie wybierz iOS, tvOS, watchOS, jeśli nie jest jeszcze wybrany, a następnie przejdź do Profili.
4. Kliknij przycisk +, aby utworzyć nowy profil.
5. Jako typ profilu administracyjnego wybierz iOS App Development, a następnie kliknij Continue (Dalej).

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

10. Kliknij Download (Pobierz), aby zapisać profil administracyjny na Macu.

11. Aby zainstalować plik profilu administracyjnego, kliknij go dwukrotnie.

4. Dodawanie Firebase do projektu na iOS

Tworzenie projektu w Firebase

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

1. W konsoli Firebase kliknij Dodaj projekt, a następnie wybierz lub wpisz Nazwę projektu.

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

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

Firebase automatycznie przypisuje unikalny identyfikator do Twojego projektu w Firebase. Więcej informacji o tym, jak Firebase używa identyfikatora projektu, znajdziesz w artykule Projekty w Firebase.

Uwaga: po udostępnieniu przez Firebase zasobów dla Twojego projektu w Firebase nie możesz zmienić identyfikatora projektu. Aby użyć konkretnego identyfikatora, musisz edytować identyfikator projektu na tym etapie konfiguracji.

3. Kliknij Dalej.
4. Skonfiguruj Google Analytics w projekcie, aby optymalnie korzystać 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, czy chcesz użyć istniejącego konta Google Analytics, czy utworzyć nowe. 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 dla Twojego projektu w Firebase. Po zakończeniu procesu otworzy się strona przeglądu projektu w Firebase w konsoli Firebase.

Rejestrowanie aplikacji w Firebase

Mając projekt w Firebase, możesz dodać do niego swoją aplikację na iOS.

Więcej informacji o sprawdzonych metodach i kwestiach, które należy wziąć pod uwagę podczas dodawania aplikacji do projektu w Firebase, w tym o obsłudze wielu wariantów kompilacji, znajdziesz w artykule Informacje o projektach Firebase.

1. Otwórz konsolę Firebase.
2. W centrum strony przeglądu projektu kliknij ikonę iOS, aby uruchomić proces konfiguracji.

Jeśli aplikacja została już dodana do projektu w Firebase, kliknij Dodaj aplikację, aby wyświetlić opcje platformy.

3. W polu Identyfikator pakietu na iOS wpisz identyfikator pakietu aplikacji.
4. (Opcjonalnie) wpisz inne informacje o aplikacji: pseudonim aplikacji i identyfikator App Store.
5. Kliknij Zarejestruj aplikację.

Dodawanie pliku konfiguracyjnego Firebase

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

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

Zamknij Xcode.

Dodaj do aplikacji pakiety SDK Firebase

Do instalowania bibliotek Firebase zalecamy używanie CocoaPods. Jeśli jednak nie chcesz używać CocoaPods, możesz zintegrować struktury pakietu SDK bezpośrednio lub skorzystać z wersji beta Swift Package Manager.

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

$ cd MessagingExample
$ pod init

2. Do pliku Podfile dodaj pody Firebase, których chcesz używać w aplikacji.

Do aplikacji na iOS możesz dodać dowolną z obsługiwanych usług Firebase.

W przykładowym projekcie szybkiego startu dodano pakiety SDK Google Analytics i Komunikacji w chmurze Firebase (FCM).

# 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.

Inicjowanie Firebase w aplikacji

Musisz dodać do aplikacji kod inicjowania Firebase.

Zaimportuj moduł Firebase i skonfiguruj udostępnioną instancję (w przykładowym programie szybkiego startu moduł Firebase jest już zaimportowany).

1. Zaimportuj moduł Firebase w UIApplicationDelegate:

AppDelegate.swift

import UIKit
import Firebase // Add this line

2. Skonfiguruj udostępnioną instancję FirebaseApp, zwykle w metodzie 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 zostaną dodane do aplikacji. Kliknij Przejdź do konsoli.

5. Konfigurowanie klienta FCM

Prześlij klucz uwierzytelniania APNs

Prześlij klucz uwierzytelniania APNs do Firebase.

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

2. W sekcji Klucz uwierzytelniania APNs w obszarze Konfiguracja aplikacji Apple kliknij przycisk Prześlij, aby przesłać klucz uwierzytelniania środowiska deweloperskiego lub produkcyjnego albo oba te klucze. Trzeba podać co najmniej 1 formę kontaktu.

3. Przejdź do lokalizacji, w której został zapisany klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w sekcji Certificates, Identifiers & Profiles w Apple Developer Member Center) i kliknij Prześlij.

Rejestracja powiadomień zdalnych

Zarejestruj aplikację do otrzymywania powiadomień zdalnych podczas uruchamiania lub w odpowiednim momencie w jej działaniu.

W przykładzie szybkiego startu element registerForRemoteNotifications jest 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 UNUserNotificationCenterwłaściwość delegata, 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 delegata do obsługi wiadomości

Aby otrzymywać tokeny rejestracji, zaimplementuj protokół delegata wiadomości i ustaw właściwość FIRMessaging delegate po wywołaniu [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 (w przykładowym projekcie szybkiego startu jest on już ustawiony).

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 FIRMessagingwłaściwość delegata, 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)
  }
}

Dodawanie uprawnień

W sekcji Tworzenie identyfikatora aplikacji dodano funkcję powiadomień push, ale musisz też dodać tę funkcję w XCode, wykonując te czynności (poniższe czynności dotyczą XCode 12.3):

1. W obszarze nawigacji kliknij nazwę projektu.
2. Kliknij Podpisywanie i możliwości.
3. Kliknij + Możliwość.

4. Kliknij dwukrotnie Tryby działania w tle.
5. Ponownie kliknij + Możliwość.
6. Kliknij dwukrotnie Powiadomienia push.
7. W sekcji Tryby działania w tle zaznacz Powiadomienia zdalne.

6. Wysyłanie wiadomości z powiadomieniem

Aby wysłać wiadomość testową, wykonaj te czynności:

1. Zainstaluj i uruchom aplikację na urządzeniu docelowym. Musisz zaakceptować prośbę o zezwolenie na otrzymywanie powiadomień zdalnych.
2. Uzyskaj token rejestracji z logu XCode.

3. Sprawdź, czy aplikacja działa w tle na urządzeniu.
4. Otwórz edytor powiadomień i kliknij 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.

Po kliknięciu Test (Testuj) urządzenie klienta, na które kierujesz reklamę (z aplikacją działającą w tle), powinno otrzymać powiadomienie w centrum powiadomień.

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

7. Gratulacje

Gratulacje. Wiadomość testowa została wysłana.

W FCM jest dostępnych wiele innych funkcji i konfiguracji, takich jak subskrypcja tematu.

Jeśli Cię to interesuje, zapoznaj się z oficjalnym dokumentem dla deweloperów.

Co dalej?

Zapoznaj się z tymi ćwiczeniami.

• Zaawansowany Android w Kotlinie 01.2:Android Komunikacja w chmurze Firebase (FCM)

Więcej informacji

• Oficjalny dokument dotyczący Komunikacji w chmurze Firebase