Wysyłanie i odbieranie powiadomień z aplikacji Flutter za pomocą Komunikacji w chmurze Firebase (FCM)

1. Wprowadzenie

Ostatnia aktualizacja: 4.04.2022

Z tego przewodnika dowiesz się, jak za pomocą Fluttera utworzyć aplikację wieloplatformową z Komunikacją w chmurze Firebase (FCM). Napiszesz jedną część implementacji aplikacji, a potem bezproblemowo skompilujesz ją i uruchomisz na 3 platformach: Androidzie, iOS i w internecie. Dowiesz się też, jak zintegrować FCM z Flutterem oraz jak pisać kod do odbierania i wysyłania wiadomości. Na koniec w tym laboratorium kodowym przedstawiamy funkcję bloków specyficznych dla platformy w interfejsie FCM HTTP v1 API, która umożliwia wysyłanie jednej wiadomości o różnym działaniu na różnych platformach.

Wymagania wstępne

Podstawowa znajomość Fluttera.

Czego się nauczysz

• Jak skonfigurować i utworzyć aplikację Flutter.
• Jak dodać zależności FCM.
• Jak wysyłać pojedyncze wiadomości FCM do aplikacji.
• Jak wysyłać do aplikacji wiadomości FCM dotyczące tematów.

Czego potrzebujesz

• Najnowsza stabilna wersja Android Studio skonfigurowana za pomocą wtyczek Dart i Flutter.

Codelab możesz uruchomić na dowolnym z tych urządzeń:

• fizyczne urządzenie z Androidem podłączone do komputera;
• emulator Androida (patrz Uruchamianie aplikacji w emulatorze Androida);
• wybraną przeglądarkę, np. Chrome;

Opcjonalnie, aby przeprowadzić ćwiczenia w środowisku iOS, potrzebujesz urządzenia z iOS, konta Apple Developer i urządzenia z macOS z zainstalowanym Xcode.

2. Konfiguracja Fluttera

Jeśli masz już skonfigurowane środowisko programistyczne Flutter, pomiń tę sekcję.

Aby skonfigurować środowisko programistyczne Flutter, wykonaj te czynności:

1. Pobierz i zainstaluj Fluttera w swoim systemie operacyjnym: Instalacja | Flutter
2. Sprawdź, czy narzędzie Flutter zostało dodane do ścieżki.
3. Skonfiguruj edytor dla Fluttera zgodnie z instrukcjami w artykule Konfigurowanie edytora | Flutter. Pamiętaj, aby zainstalować wtyczki Flutter i Dart do edytora. W pozostałej części tego laboratorium będziesz używać Androida Studio.
4. W wierszu poleceń uruchom polecenie flutter doctor, które przeskanuje konfigurację i wyświetli listę brakujących zależności, które należy naprawić. Postępuj zgodnie z instrukcjami, aby naprawić brakujące zależności. Pamiętaj, że niektóre zależności mogą nie być konieczne. Jeśli na przykład nie zamierzasz tworzyć aplikacji na iOS, brak zależności CocoaPods nie będzie problemem.
5. Uruchom to polecenie, aby utworzyć aplikację Flutter w katalogu fcmflutter flutter create --org com.flutter.fcm --project-name fcmflutter fcmflutter, a następnie przejdź do katalogu fcmflutter.

6. W Android Studio kliknij Plik –> Otwórz, znajdź ścieżkę do aplikacji Flutter, a następnie kliknij Otwórz, aby otworzyć projekt w Android Studio. Kod aplikacji znajduje się w pliku lib/main.dart.

Na pasku narzędzi Android Studio kliknij strzałkę w dół, aby wybrać urządzenie z Androidem. Jeśli selektor docelowy jest pusty, zainstaluj wirtualne urządzenia z Androidem, przeglądarkę Chrome lub symulator iOS, jeśli wolisz uruchamiać aplikację z przeglądarki internetowej lub urządzenia z iOS. Może być konieczne ręczne uruchomienie urządzenia i odświeżenie listy, aby znaleźć urządzenie docelowe.

Aby uruchomić aplikację, kliknij Uruchom .

Gratulacje! Udało Ci się utworzyć aplikację Flutter.

3. Konfigurowanie Firebase i FlutterFire

Aby opracować aplikację, która integruje się z Komunikacją w chmurze Firebase za pomocą Fluttera, musisz mieć:

• Masz projekt Firebase.
• Działający wiersz poleceń Firebase.
• Zainstalowane FlutterFire.
• Aplikacja skonfigurowana i wygenerowana za pomocą flutterfire configure.

Utwórz projekt Firebase

Jeśli masz już projekt Firebase, możesz pominąć ten krok.

1. Zaloguj się w konsoli Firebase, korzystając ze swojego konta Google.
2. Kliknij przycisk, aby utworzyć nowy projekt, a potem wpisz jego nazwę (np. fcm4flutter).
   
3. Kliknij Dalej.
4. Po wyświetleniu monitu przeczytaj i zaakceptuj warunki usługi Firebase, a potem kliknij Dalej.
5. (Opcjonalnie) Włącz w konsoli Firebase pomoc AI (nazywaną „Gemini w Firebase”).
6. W tym samouczku nie potrzebujesz Google Analytics, więc wyłącz opcję Google Analytics.
7. Kliknij Utwórz projekt, poczekaj, aż projekt zostanie udostępniony, a następnie kliknij Dalej.

Gratulacje! Udało Ci się utworzyć projekt Firebase.

Konfigurowanie wiersza poleceń Firebase

Jeśli masz skonfigurowany wiersz poleceń Firebase, możesz pominąć ten krok.

Aby pobrać i zainstalować wiersz poleceń Firebase, zapoznaj się z informacjami o wierszu poleceń Firebase. Zaloguj się w Firebase za pomocą konta Google, wpisując to polecenie:

firebase login

Konfigurowanie FlutterFire

1. Zainstaluj wtyczkę FlutterFire za pomocą polecenia: flutter pub add firebase_core
2. Zainstaluj wtyczkę FCM: flutter pub add firebase_messaging
3. Skonfiguruj interfejs wiersza poleceń FlutterFire: dart pub global activate flutterfire_cli
4. Skonfiguruj projekt Firebase w Flutterze: flutterfire configure --project=fcm4flutter. użyj klawiszy strzałek i spacji, aby wybrać platformy, lub naciśnij Enter, aby użyć platform domyślnych.

W tym laboratorium używamy domyślnych platform (Android, iOS i internet), ale możesz wybrać tylko jedną lub dwie platformy. Jeśli pojawi się prośba o podanie identyfikatora pakietu na iOS, wpisz com.flutter.fcm.fcmflutter lub własny identyfikator pakietu na iOS w formacie [company domain name].[project name]. Po zakończeniu wykonywania polecenia odśwież stronę konsoli Firebase. Zobaczysz, że w projekcie Firebase utworzono aplikacje na wybrane platformy.

To polecenie generuje plik firebase_options.dart w katalogu lib, który zawiera wszystkie opcje wymagane do inicjowania.

Konfigurowanie Cloud Messaging na iOS

1. Otwórz stronę dla deweloperów Apple i na karcie Klucze kliknij Utwórz klucz.

2. Wpisz nazwę klucza i zaznacz Usługi Apple Push Notification (APNs).
3. Pobierz plik klucza z rozszerzeniem .p8.
4. W konsoli Firebase otwórz Ustawienia projektu i wybierz kartę Cloud Messaging.

5. Prześlij plik klucza APNs dla aplikacji na iOS na karcie Cloud Messaging. Wpisz identyfikator klucza APNs z karty Cloud Messaging oraz identyfikator zespołu, który znajdziesz w Apple Member Center.

4. Przygotowanie FCM

Zanim aplikacja będzie mogła otrzymywać wiadomości z FCM, musi:

• Zainicjuj FlutterFire.
• Poproś o uprawnienia do wyświetlania powiadomień.
• Zarejestruj się w FCM, aby uzyskać token rejestracji.

Inicjowanie

Aby zainicjować usługę, zastąp funkcję główną (lib/main.dart) tym kodem:

// core Flutter primitives
import 'package:flutter/foundation.dart';
// core FlutterFire dependency
import 'package:firebase_core/firebase_core.dart';
// generated by 

flutterfire configure

import 'firebase_options.dart';
// FlutterFire's Firebase Cloud Messaging plugin
import 'package:firebase_messaging/firebase_messaging.dart';

// TODO: Add stream controller
// TODO: Define the background message handler

Future<void> main() async {
 WidgetsFlutterBinding.ensureInitialized();
 await Firebase.initializeApp(
   options: DefaultFirebaseOptions.currentPlatform,
 );

 // TODO: Request permission
 // TODO: Register with FCM
 // TODO: Set up foreground message handler
 // TODO: Set up background message handler

 runApp(MyApp());
}

Następnie w Android Studio uruchom Tools -> Flutter -> Flutter Pub Get (Narzędzia –> Flutter –> Flutter Pub Get), aby wczytać pakiety dodane w sekcji Konfigurowanie FlutterFire i wyświetlić kod z odpowiednim ustawieniem Intellisense w Android Studio.

Spowoduje to zainicjowanie FlutterFire na bieżącej platformie DefaultFirebaseOptions.currentPlatform, która jest importowana z wygenerowanego pliku firebase_options.dart. Pamiętaj, że initializeApp to funkcja asynchroniczna, a słowo kluczowe await zapewnia, że inicjowanie zostanie zakończone przed uruchomieniem aplikacji.

Poproś o uprawnienia

Aplikacja musi poprosić użytkownika o przyznanie uprawnień do otrzymywania powiadomień. Metoda requestPermission udostępniana przez firebase_messaging wyświetla okno lub wyskakujące okienko z prośbą o przyznanie lub odmowę przyznania uprawnień.

Najpierw skopiuj ten kod do funkcji głównej pod komentarzem TODO: Request permission. Zwrócona wartość settings informuje, czy użytkownik przyznał uprawnienia. Zalecamy proszenie o uprawnienia tylko wtedy, gdy użytkownik musi skorzystać z funkcji, która wymaga dostępu (np. gdy włączy powiadomienia w ustawieniach aplikacji). W tym laboratorium kodu dla uproszczenia prosimy o zezwolenie przy uruchamianiu aplikacji.

final messaging = FirebaseMessaging.instance;

final settings = await messaging.requestPermission(
 alert: true,
 announcement: false,
 badge: true,
 carPlay: false,
 criticalAlert: false,
 provisional: false,
 sound: true,
);

 if (kDebugMode) {
   print('Permission granted: ${settings.authorizationStatus}');
 }

Następnie na pasku narzędzi Android Studio wybierz Chrome (web) w selektorze celu i ponownie uruchom aplikację.

Następnie otworzy się karta Chrome z wyskakującym okienkiem z prośbą o uprawnienia. Jeśli klikniesz Allow, w konsoli Android Studio zobaczysz log: Permission granted: AuthorizationStatus.authorized. Po zezwoleniu na prośbę o uprawnienia lub jej zablokowaniu Twoja odpowiedź jest przechowywana w przeglądarce razem z aplikacją, a wyskakujące okienko nie jest już wyświetlane. Pamiętaj, że gdy ponownie uruchomisz aplikację internetową w Android Studio, może pojawić się prośba o przyznanie uprawnień.

Rejestracja

Skopiuj ten kod do funkcji głównej pod komentarzem TODO: Register with FCM, aby zarejestrować się w FCM. Wywołanie getToken zwraca token rejestracji, którego serwer aplikacji lub zaufane środowisko serwera może używać do wysyłania wiadomości do użytkowników.

// It requests a registration token for sending messages to users from your App server or other trusted server environment.
String? token = await messaging.getToken();

if (kDebugMode) {
  print('Registration Token=$token');
}

Na pasku narzędzi Android Studio wybierz urządzenie z Androidem i uruchom aplikację. W konsoli Android Studio token rejestracyjny zostanie wydrukowany w ten sposób:

I/flutter ( 3717): Permission granted: AuthorizationStatus.authorized
I/flutter ( 3717): Registration Token=dch. . . D2P:APA9. . .kbb4

Skopiuj go do edytora tekstu, ponieważ będziesz go później używać do wysyłania wiadomości.

uses-sdk:minSdkVersion 16 cannot be smaller than version 19 declared in library [:firebase_messaging]

Dodatkowe czynności, które musisz wykonać, aby otrzymywać wiadomości w przeglądarce

Aplikacje internetowe wymagają 2 dodatkowych kroków, aby uzyskać token rejestracji i nasłuchiwać przychodzących wiadomości. Aby autoryzować wysyłanie żądań do obsługiwanych usług powiadomień push w internecie, witryna musi przekazać klucz VAPID do getToken.

Najpierw otwórz kartę Komunikacja w chmurze projektu Firebase w konsoli Firebase, przewiń w dół do sekcji Konfiguracja internetowa, aby znaleźć istniejącą parę kluczy, lub wygeneruj nową parę kluczy. Kliknij wyróżniony przycisk, aby skopiować klucz, który będzie można użyć jako vapidKey.

Następnie zastąp kod rejestracji w sekcji Registration (Rejestracja) tym kodem i zaktualizuj klucz VAPID:

// TODO: replace with your own VAPID key
 const vapidKey = "<YOUR_PUBLIC_VAPID_KEY_HERE>";

 // use the registration token to send messages to users from your trusted server environment
 String? token;

 if (DefaultFirebaseOptions.currentPlatform == DefaultFirebaseOptions.web) {
   token = await messaging.getToken(
     vapidKey: vapidKey,
   );
 } else {
   token = await messaging.getToken();
 }

 if (kDebugMode) {
   print('Registration Token=$token');
 }

Następnie utwórz plik firebase-messaging-sw.js w katalogu web/ w katalogu głównym projektu. Skopiuj poniższy kod do firebase-messaging-sw.js, aby umożliwić aplikacji internetowej odbieranie zdarzeń onMessage. Więcej informacji znajdziesz w artykule Ustawianie opcji powiadomień w skrypcie service worker.

importScripts("https://www.gstatic.com/firebasejs/9.6.10/firebase-app-compat.js");
importScripts("https://www.gstatic.com/firebasejs/9.6.10/firebase-messaging-compat.js");

// todo Copy/paste firebaseConfig from Firebase Console
const firebaseConfig = {
 apiKey: "...",
 authDomain: "...",
 databaseURL: "...",
 projectId: "...",
 storageBucket: "...",
 messagingSenderId: "...",
 appId: "...",
};

firebase.initializeApp(firebaseConfig);
const messaging = firebase.messaging();

// todo Set up background message handler

Następnie w sekcji Ustawienia projektu –> karta Ogólne przewiń w dół i znajdź Aplikacja internetowa. Skopiuj sekcję kodu firebaseConfig i wklej ją w firebase-messaging-sw.js.

Na koniec na pasku narzędzi Android Studio wybierz Chrome (web) w selektorze docelowym i uruchom aplikację. W konsoli Android Studio token rejestracji zostanie wydrukowany w ten sposób:

Debug service listening on ws://127.0.0.1:61538/BLQQ3Fg-h7I=/ws
Permission granted: AuthorizationStatus.authorized
Registration Token=fH. . .ue:APA91. . .qwt3chpv

Skopiuj token rejestracji do edytora tekstu, aby móc go później użyć do wysyłania wiadomości.

Dodatkowe czynności, które należy wykonać, aby otrzymywać wiadomości na urządzeniu z iOS

Aby otrzymywać wiadomości z FCM, na urządzeniach z iOS musisz włączyć w Xcode powiadomienia push i tryby działania w tle:

1. W Android Studio kliknij prawym przyciskiem myszy nazwę projektu, a następnie wybierz Flutter –> Open iOS module in Xcode (Otwórz moduł iOS w Xcode).
2. Po uruchomieniu Xcode włącz Powiadomienia push i Tryby działania w tle na karcie Podpisywanie i możliwości dla docelowego projektu. Więcej informacji znajdziesz w artykule Konfigurowanie aplikacji.
3. Na pasku narzędzi Android Studio wybierz urządzenie z iOS w selektorze docelowym i uruchom aplikację. Po przyznaniu uprawnień do wysyłania powiadomień token rejestracyjny zostanie wydrukowany w konsoli Android Studio.

Gratulacje, udało Ci się zarejestrować aplikację w FCM. Możesz już otrzymywać wiadomości zgodnie z opisem w następnej sekcji.

5. Odbieranie wiadomości z FCM

Konfigurowanie modułów obsługi wiadomości

Aplikacja musi obsługiwać zdarzenia onMessage, gdy wiadomości docierają, gdy aplikacja jest na pierwszym planie, oraz zdarzenia onBackgroundMessage, gdy aplikacja działa w tle.

Obsługa wiadomości na pierwszym planie

Najpierw dodaj kontroler strumienia po komentarzu TODO: Add stream controller w pliku main.dart, aby przekazywać wiadomości z obsługi zdarzeń do interfejsu.

import 'package:rxdart/rxdart.dart';
// used to pass messages from event handler to the UI
final _messageStreamController = BehaviorSubject<RemoteMessage>();

Aby dodać zależność rxdart, uruchom to polecenie w katalogu projektu: flutter pub add rxdart.

Następnie w Android Studio kliknij Tools –> Flutter –> Flutter Pub Get, aby załadować pakiet rxdart.dart i wyświetlić kod z odpowiednimi ustawieniami Intellisense w Android Studio.

Następnie dodaj moduł obsługi zdarzeń, aby nasłuchiwać wiadomości na pierwszym planie po komentarzu TODO: Set up foreground message handler. Zapisuje dzienniki i publikuje wiadomość w kontrolerze strumienia.

 FirebaseMessaging.onMessage.listen((RemoteMessage message) {
   if (kDebugMode) {
     print('Handling a foreground message: ${message.messageId}');
     print('Message data: ${message.data}');
     print('Message notification: ${message.notification?.title}');
     print('Message notification: ${message.notification?.body}');
   }

   _messageStreamController.sink.add(message);
 });

Następnie zastąp oryginalny widżet State w pliku main.dart tym kodem, który dodaje subskrybenta do kontrolera strumienia w widżecie State i wyświetla ostatnią wiadomość w widżecie.

class _MyHomePageState extends State<MyHomePage> {
 String _lastMessage = "";

 _MyHomePageState() {
   _messageStreamController.listen((message) {
     setState(() {
       if (message.notification != null) {
         _lastMessage = 'Received a notification message:'
             '\nTitle=${message.notification?.title},'
             '\nBody=${message.notification?.body},'
             '\nData=${message.data}';
       } else {
         _lastMessage = 'Received a data message: ${message.data}';
       }
     });
   });
 }

 @override
 Widget build(BuildContext context) {
   return Scaffold(
     appBar: AppBar(
       title: Text(widget.title),
     ),
     body: Center(
       child: Column(
         mainAxisAlignment: MainAxisAlignment.center,
         children: <Widget>[
           Text('Last message from Firebase Messaging:',
               style: Theme.of(context).textTheme.titleLarge),
           Text(_lastMessage, style: Theme.of(context).textTheme.bodyLarge),
         ],
       ),
     ),
   );
 }
}

Obsługa wiadomości w tle na Androidzie i iOS

Wiadomości są obsługiwane przez moduł obsługi onBackgroundMessage, gdy aplikacja działa w tle. Funkcja obsługi powinna być funkcją najwyższego poziomu. Interfejs użytkownika można aktualizować, gdy aplikacja jest przenoszona na pierwszy plan, poprzez obsługę wiadomości (patrz Obsługa interakcji) lub synchronizację z serwerem aplikacji.

Utwórz funkcję obsługi po komentarzu TODO: Define the background message handler poza funkcją główną i wywołaj ją w funkcji głównej po komentarzu TODO: Set up background message handler.

// TODO: Define the background message handler
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
 await Firebase.initializeApp();

 if (kDebugMode) {
   print("Handling a background message: ${message.messageId}");
   print('Message data: ${message.data}');
   print('Message notification: ${message.notification?.title}');
   print('Message notification: ${message.notification?.body}');
 }
}

void main() {
 ...

 // TODO: Set up background message handler
 FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

 runApp(MyApp());
}

Obsługa wiadomości w tle w przeglądarce

Od wersji 11.2.8 pakietu FlutterFire firebase_messaging obsługa wiadomości w tle na platformach internetowych wymaga innego procesu. Dlatego w usłudze Service Worker musisz dodać osobny moduł obsługi wiadomości web/firebase-messaging-sw.js.

messaging.onBackgroundMessage((message) => {
 console.log("onBackgroundMessage", message);
});

Konfigurowanie serwera aplikacji

1. Zaimportuj początkowy kod serwera, otwierając projekt https://github.com/FirebaseExtended/firebase_fcm_flutter/tree/main/server w Android Studio. Serwer to projekt Java oparty na Gradle, który jest zależny od pakietu SDK firebase-admin, który zapewnia funkcję wysyłania wiadomości FCM.
2. Skonfiguruj konto usługi Firebase, które umożliwi pakietowi Firebase Admin SDK autoryzowanie wywołań interfejsów API FCM. Otwórz Ustawienia projektu w konsoli Firebase i wybierz kartę Konta usługi. Wybierz „Java” i kliknij Generate new private key, aby pobrać fragment kodu konfiguracji.
3. Zmień nazwę pliku na service-account.json i skopiuj go do ścieżki src/main/resources w projekcie serwera.

Wysyłanie wiadomości testowej

W pliku FcmSender.java usługa sendMessageToFcmRegistrationToken tworzy wiadomość z powiadomieniem i ładunkiem danych. Token rejestracji jest kierowany na instancję aplikacji, do której wysyłana jest wiadomość.

private static void sendMessageToFcmRegistrationToken() throws Exception {
   String registrationToken = "REPLACE_WITH_FCM_REGISTRATION_TOKEN";
   Message message =
       Message.builder()
           .putData("FCM", "https://firebase.google.com/docs/cloud-messaging")
           .putData("flutter", "https://flutter.dev/")
           .setNotification(
               Notification.builder()
                   .setTitle("Try this new app")
                   .setBody("Learn how FCM works with Flutter")
                   .build())
           .setToken(registrationToken)
           .build();

   FirebaseMessaging.getInstance().send(message);

   System.out.println("Message to FCM Registration Token sent successfully!!");
 }

1. Skopiuj token rejestracji Androida skopiowany z sekcji Rejestracja i wklej go jako wartość zmiennej registrationToken.
2. Kliknij Uruchom , aby uruchomić funkcję główną i wysłać wiadomość do użytkownika za pomocą FCM.

Gdy aplikacja na Androida działa w tle, wiadomość pojawia się w obszarze powiadomień.

Gdy aplikacja na Androida jest na pierwszym planie, w konsoli Android Studio zobaczysz log: „Handling a foreground message” (Obsługa wiadomości na pierwszym planie). Treść wiadomości jest też wyświetlana w interfejsie, ponieważ jest on subskrybowany w kontrolerze strumienia pod kątem nowych wiadomości.

Jeśli wkleisz token rejestracji i wyślesz wiadomość z serwera aplikacji lub innego zaufanego środowiska serwera, zobaczysz podobne zachowanie:

• Gdy aplikacja internetowa działa w tle (tzn. jest ukryta za innym oknem lub aktywna jest inna karta), zobaczysz powiadomienie internetowe.

• Gdy aplikacja internetowa jest na pierwszym planie, możesz wyświetlić dziennik w konsoli Chrome, klikając prawym przyciskiem myszy stronę internetową i wybierając Inspect. Treść wiadomości jest też wyświetlana w interfejsie.

6. Wysyłanie wiadomości do tematu

Funkcja zastępowania platformy w interfejsie FCM HTTP v1 API umożliwia wysyłanie żądań wiadomości, które będą się różnie zachowywać na różnych platformach. Jednym z przypadków użycia tej funkcji jest wyświetlanie różnych treści powiadomień w zależności od platformy. Ta funkcja jest w pełni wykorzystywana, gdy kierujesz wiadomości o tematach na wiele urządzeń (które mogą obejmować różne platformy). W tej sekcji znajdziesz instrukcje, jak skonfigurować aplikację, aby otrzymywała wiadomości z tematami dostosowane do każdej platformy.

Subskrybowanie tematu z poziomu klienta

Aby zasubskrybować temat, wywołaj metodę messaging.subscribeToTopic na końcu funkcji głównej w pliku main.dart aplikacji na Fluttera.

// subscribe to a topic.
const topic = 'app_promotion';
await messaging.subscribeToTopic(topic);

[Opcjonalnie] Subskrybowanie tematu z serwera na potrzeby internetu

Jeśli nie tworzysz aplikacji na platformę internetową, możesz pominąć tę sekcję.

Pakiet FCM JS SDK nie obsługuje obecnie subskrypcji tematów po stronie klienta. Zamiast tego możesz zasubskrybować temat za pomocą interfejsu API do zarządzania tematami po stronie serwera z pakietu Admin SDK. Ten kod pokazuje subskrypcję tematów po stronie serwera za pomocą pakietu Java Admin SDK.

 private static void subscribeFcmRegistrationTokensToTopic() throws Exception {
   List<String> registrationTokens =
       Arrays.asList(
           "REPLACE_WITH_FCM_REGISTRATION_TOKEN"); // TODO: add FCM Registration Tokens to
   // subscribe
   String topicName = "app_promotion";

   TopicManagementResponse response =     FirebaseMessaging.getInstance().subscribeToTopic(registrationTokens, topicName);
   System.out.printf("Num tokens successfully subscribed %d", response.getSuccessCount());
 }

Otwórz serwer aplikacji i kliknij Uruchom , aby uruchomić funkcję główną w pliku FcmSubscriptionManager.java:

Wysyłanie wiadomości z zastąpieniami platformydo tematu

Możesz teraz wysłać komunikat zastępujący platformę tematu. W tym fragmencie kodu:

• Tworzysz prośbę o wysłanie z podstawową wiadomością i tytułem „A new app is available”.
• Wiadomość generuje powiadomienie wyświetlane z tytułem „A new app is available” na platformach iOS i internetowych.
• Komunikat generuje powiadomienie wyświetlane na urządzeniach z Androidem z tytułem „A new Android app is available”.

private static void sendMessageToFcmTopic() throws Exception {
   String topicName = "app_promotion";

   Message message =
       Message.builder()
           .setNotification(
               Notification.builder()
                   .setTitle("A new app is available")
                   .setBody("Check out our latest app in the app store.")
                   .build())
           .setAndroidConfig(
               AndroidConfig.builder()
                   .setNotification(
                       AndroidNotification.builder()
                           .setTitle("A new Android app is available")
                           .setBody("Our latest app is available on Google Play store")
                           .build())
                   .build())
           .setTopic("app_promotion")
           .build();

   FirebaseMessaging.getInstance().send(message);

   System.out.println("Message to topic sent successfully!!");
 }

W głównej funkcji pliku FcmSender.java usuń komentarz z wiersza sendMessageToFcmTopic();. Kliknij Uruchom , aby wysłać wiadomość do tematu.

7. Podsumowanie i dalsze kroki

Podsumowując, wiesz już, jak tworzyć angażujące aplikacje na wiele platform za pomocą Fluttera i FCM, w tym jak skonfigurować środowisko, zintegrować zależności oraz odbierać i wysyłać wiadomości. Więcej informacji znajdziesz w tych materiałach:

Ćwiczenia z programowania

• Więcej informacji o tym, jak Flutter współpracuje z innymi usługami Firebase, w tym o uwierzytelnianiu użytkowników i synchronizowaniu danych, znajdziesz w artykule Poznaj Firebase w Flutterze.
• Więcej informacji o FCM, w tym o wiadomościach w aplikacji i tematach, znajdziesz w tych artykułach: Wysyłanie wiadomości do użytkowników za pomocą FCM i FIAM oraz Pierwsza wiadomość push do wielu odbiorców z użyciem tematów FCM.

References

• stronie Firebase,
• Witryna Flutter
• Widżety FlutterFire Firebase Flutter
• Kanał Firebase w YouTube
• Kanał Flutter w YouTube