Wysyłaj i odbieraj powiadomienia dotyczące aplikacji Flutter za pomocą Firebase Cloud Messaging

1. Wstęp

Ostatnia aktualizacja : 2022-04-04

To ćwiczenie z programowania przeprowadzi Cię przez proces tworzenia wieloplatformowej aplikacji przy użyciu Firebase Cloud Messaging (FCM) przy użyciu Flutter. Napiszesz jeden fragment implementacji aplikacji, a następnie zbudujesz ją i uruchomisz bezproblemowo na trzech platformach: Android, iOS i web. Dowiesz się również, jak zintegrować FCM z Flutterem i jak napisać kod do odbierania i wysyłania wiadomości. Na koniec podczas zajęć z programowania przedstawiono funkcję blokowania specyficzną dla platformy interfejsu API FCM HTTP v1, która pozwala wysłać jedną wiadomość, która ma różne zachowania na różnych platformach.

Warunek wstępny

Podstawowa znajomość Fluttera.

Czego się dowiesz

• Jak skonfigurować i utworzyć aplikację Flutter.
• Jak dodać zależności FCM.
• Jak wysyłać pojedyncze wiadomości FCM do swojej aplikacji.
• Jak wysyłać wiadomości tematyczne FCM do swojej aplikacji.

Co będziesz potrzebował

• Najnowsza stabilna wersja Android Studio skonfigurowana z wtyczkami Dart i Flutter.

Ćwiczenia z programowania możesz uruchomić przy użyciu dowolnego z następujących urządzeń:

• Fizyczne urządzenie z Androidem podłączone do Twojego komputera.
• Emulator Androida (zobacz Uruchamianie aplikacji na emulatorze Androida ).
• Wybrana przeglądarka, np. Chrome.

Opcjonalnie, aby uruchomić zajęcia z programowania przy użyciu platformy iOS, potrzebujesz urządzenia z systemem iOS, konta Apple Developer i urządzenia macOS z zainstalowanym XCode.

2. Konfiguracja trzepotania

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

Aby skonfigurować środowisko programistyczne Flutter, wykonaj następujące kroki:

1. Pobierz i zainstaluj Flutter dla swojego systemu operacyjnego: Zainstaluj | Trzepotanie
2. Upewnij się, że narzędzie Flutter zostało dodane do ścieżki.
3. Skonfiguruj edytor dla Flutter, jak pokazano w Konfigurowanie edytora | Flutter Pamiętaj, aby zainstalować wtyczki Flutter i Dart dla swojego edytora. Przez resztę zajęć z programowania będziesz korzystać z Android Studio.
4. Z wiersza poleceń uruchom flutter doctor , który przeskanuje konfigurację i wyświetli listę brakujących zależności, które należy naprawić. Postępuj zgodnie z instrukcjami, aby naprawić wszelkie ważne brakujące zależności. Należy pamiętać, że niektóre zależności mogą nie być konieczne. Na przykład, jeśli nie zamierzasz programować dla systemu iOS, brakująca zależność CocoaPods nie będzie problemem blokującym.
5. Uruchom to polecenie, aby utworzyć aplikację Flutter w katalogu fcmflutter flutter create --org com.flutter.fcm --project-name fcmflutter fcmflutter , a następnie zmień katalogi na fcmflutter .

6. W Android Studio przejdź do Plik -> Otwórz , znajdź ścieżkę swojej 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 systemem Android. Jeśli selektor celu jest pusty, zainstaluj wirtualne urządzenia z Androidem lub przeglądarkę Chrome lub symulator iOS, jeśli wolisz uruchamiać aplikację z przeglądarki internetowej lub urządzenia iOS. Może być konieczne ręczne uruchomienie urządzenia i odświeżenie listy, aby znaleźć urządzenie docelowe.

Kliknij Uruchom aby uruchomić aplikację.

Gratulacje! Pomyślnie utworzyłeś aplikację Flutter.

3. Konfiguracja Firebase i FlutterFire

Aby opracować aplikację integrującą się z Firebase Cloud Messaging przy użyciu Flutter, potrzebujesz:

• Projekt Firebase.
• Działający interfejs CLI Firebase.
• Instalacja 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. Jeśli masz konto Google, otwórz Firebase i zaloguj się na swoje konto Google, a następnie kliknij Przejdź do konsoli .
2. W konsoli Firebase kliknij Dodaj projekt . Postępuj zgodnie z instrukcjami, aby utworzyć projekt. Nie zaznaczaj opcji Włącz Google Analytics dla tego projektu, ponieważ nie będziesz go używać w tym projekcie.
3. Po utworzeniu projektu przejdź do Ustawień projektu , klikając ikonę koła zębatego obok Przeglądu projektu .

Identyfikator projektu służy do jednoznacznej identyfikacji projektu i może różnić się od nazwy projektu . Identyfikator projektu zostanie później użyty do skonfigurowania FlutterFire.

Gratulacje! Pomyślnie utworzyłeś projekt Firebase.

Skonfiguruj interfejs wiersza polecenia Firebase

Jeśli masz skonfigurowany interfejs CLI Firebase, możesz pominąć ten krok.

Przejdź do dokumentacji Firebase CLI , aby pobrać i zainstalować Firebase CLI. Zaloguj się do Firebase za pomocą swojego konta Google za pomocą następującego polecenia:

firebase login

Skonfiguruj 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 CLI FlutterFire: dart pub global activate flutterfire_cli
4. Skonfiguruj projekt Firebase na Flutter: flutterfire configure --project=fcm4flutter. Użyj klawiszy strzałek i spacji, aby wybrać platformy lub naciśnij klawisz Enter, aby użyć platform domyślnych.

W tym laboratorium z programowania używane są platformy domyślne (Android, iOS i Internet), ale możesz wybrać tylko jedną lub dwie platformy. Jeśli pojawi się monit o podanie identyfikatora pakietu iOS, wpisz com.flutter.fcm.fcmflutter lub własny identyfikator pakietu iOS w formacie [company domain name].[project name] . Po wykonaniu polecenia odśwież stronę konsoli Firebase. Zobaczysz, że stworzył aplikacje dla wybranych platform w ramach projektu Firebase.

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

Skonfiguruj usługę Wiadomości w chmurze dla systemu iOS

1. Przejdź do strony programisty Apple i kliknij opcję Utwórz klucz na karcie Klucze .

2. Wprowadź nazwę klucza i sprawdź usługi Apple Push Notifications (APN) .
3. Pobierz plik klucza z rozszerzeniem .p8 .
4. W konsoli Firebase przejdź do Ustawień projektu projektu i wybierz kartę Wiadomości w chmurze .

5. Prześlij plik klucza APNs dla aplikacji na iOS na karcie Wiadomości w chmurze . Wprowadź identyfikator klucza APNs na karcie Wiadomości w chmurze oraz identyfikator zespołu, który można znaleźć w centrum członkostwa Apple.

4. Przygotowanie FCM

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

• Zainicjuj FlutterFire.
• Poproś o uprawnienia do powiadomień.
• Zarejestruj się w FCM, aby otrzymać token rejestracyjny.

Inicjalizacja

Aby zainicjować usługę, zastąp funkcję główną ( lib/main.dart ) następującym 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 uruchom Narzędzia -> Flutter -> Flutter Pub Wejdź do Android Studio, aby załadować pakiety dodane podczas konfiguracji FlutterFire i wyświetl kod z odpowiednim ustawieniem Intellisense w Android Studio.

Spowoduje to inicjowanie FlutterFire dla bieżącej platformy DefaultFirebaseOptions.currentPlatform , która jest importowana z wygenerowanego pliku firebase_options.dart . Należy pamiętać, że initializeApp jest funkcją asynchroniczną, a await kluczowe Wait zapewnia zakończenie inicjalizacji przed uruchomieniem aplikacji.

Prośba o pozwolenie

Aplikacja musi zapytać użytkownika o zgodę na otrzymywanie powiadomień. Metoda requestPermission udostępniana przez firebase_messaging wyświetla okno dialogowe lub wyskakujące okienko z monitem o zezwolenie lub odmowę pozwolenia.

Najpierw skopiuj ten kod do funkcji głównej pod komentarzem TODO: Request permission . Zwrócone settings informują, czy użytkownik udzielił pozwolenia. Zalecamy prosić o pozwolenie tylko wtedy, gdy użytkownik musi skorzystać z funkcji wymagającej dostępu (np. gdy użytkownik włączy powiadomienia w ustawieniach aplikacji). W tym ćwiczeniu z programowania prosimy o pozwolenie na uruchomienie aplikacji dla uproszczenia.

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) z selektora docelowego, a następnie uruchom aplikację ponownie.

Następnie otwiera się karta Chrome z wyskakującym okienkiem z prośbą o pozwolenie. Jeśli klikniesz Allow , w konsoli Android Studio zobaczysz dziennik: Permission granted: AuthorizationStatus.authorized . Po zezwoleniu lub zablokowaniu prośby o pozwolenie Twoja odpowiedź zostanie zapisana wraz z aplikacją w przeglądarce, a wyskakujące okienko nie będzie już wyświetlane. Pamiętaj, że po ponownym uruchomieniu aplikacji internetowej w Android Studio może zostać ponownie wyświetlony monit o pozwolenie.

Rejestracja

Skopiuj ten kod do głównej funkcji pod komentarzem TODO: Register with FCM , aby zarejestrować się w FCM. Wywołanie getToken zwraca token rejestracji, którego może używać serwer aplikacji lub środowisko zaufanego serwera 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 systemem Android i uruchom aplikację. W konsoli Android Studio token rejestracji jest drukowany w następujący 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 kroki, aby odbierać wiadomości w Internecie

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

Najpierw otwórz kartę Cloud Messaging projektu Firebase w konsoli Firebase, przewiń w dół do sekcji konfiguracji sieciowej , aby znaleźć istniejącą parę kluczy lub wygeneruj nową parę kluczy. Kliknij podświetlony przycisk, aby skopiować klucz i wykorzystać go jako klucz vapidKey.

Następnie zamień kod rejestracyjny w sekcji Rejestracja na ten kod, a następnie zaktualizuj vapidKey:

// 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 poniżej katalogu web/ w katalogu głównym projektu. Skopiuj poniższy plik do firebase-messaging-sw.js , aby zezwolić aplikacji internetowej na odbieranie zdarzeń onMessage . Aby uzyskać więcej informacji, zobacz Ustawianie opcji powiadomień w procesie roboczym usługi .

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 obszarze Ustawienia projektu -> zakładka Ogólne przewiń w dół i znajdź aplikację internetową , skopiuj sekcję kodu firebaseConfig i wklej ją do pliku firebase-messaging-sw.js .

Na koniec na pasku narzędzi Android Studio wybierz Chrome (web) w selektorze celu i uruchom aplikację. W konsoli Android Studio token rejestracji jest drukowany w następujący 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 później używać go do wysyłania wiadomości.

Dodatkowe kroki, aby odbierać wiadomości na iOS

Aby odbierać wiadomości od FCM, urządzenia iOS muszą włączyć powiadomienia push i tryby tła w Xcode:

1. W Android Studio kliknij prawym przyciskiem myszy nazwę projektu, a następnie wybierz Flutter -> Otwórz moduł iOS w Xcode .
2. Po uruchomieniu Xcode włącz powiadomienia push i tryby tła na karcie Podpisywanie i możliwości dla celu projektu. Aby uzyskać więcej informacji, zobacz Konfigurowanie aplikacji .
3. Na pasku narzędzi Android Studio wybierz urządzenie iOS w selektorze obiektów docelowych i uruchom aplikację. Po udzieleniu zgody na powiadomienie token rejestracji jest drukowany w konsoli Android Studio.

Gratulacje, pomyślnie zarejestrowałeś swoją aplikację w FCM. Możesz już odbierać wiadomości, jak opisano w następnej sekcji.

5. Odbieraj wiadomości od FCM

Skonfiguruj programy obsługi wiadomości

Aplikacja musi obsługiwać zdarzenia onMessage w przypadku nadejścia wiadomości, gdy aplikacja jest w trybie pierwszego planu, 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ć komunikaty z modułu obsługi zdarzeń do interfejsu użytkownika.

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 tę komendę z katalogu projektu: flutter pub add rxdart .

Następnie uruchom Narzędzia -> Flutter -> Flutter Pub Wejdź do Android Studio, aby załadować pakiet rxdart.dart i wyświetlić kod z odpowiednimi ustawieniami Intellisense w Android Studio.

Następnie dodaj procedurę obsługi zdarzeń, aby nasłuchiwać wiadomości na pierwszym planie po komentarzu TODO: Set up foreground message handler . Drukuje dzienniki i publikuje komunikat do kontrolera 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 widget Stan w pliku main.dart tym kodem, który doda subskrybenta do kontrolera strumienia w widżecie Stan i wyświetli ostatni komunikat 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 dla Androida/iOS

Wiadomości są obsługiwane przez procedurę obsługi onBackgroundMessage , gdy aplikacja działa w tle. Procedura obsługi powinna być funkcją najwyższego poziomu. Interfejs użytkownika można zaktualizować, gdy aplikacja zostanie przeniesiona na pierwszy plan, poprzez obsługę komunikatów (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 dla Internetu

Począwszy od wersji 11.2.8 FlutterFire firebase_messaging , obsługa wiadomości w tle na platformach internetowych wymaga innego przepływu. Dlatego musisz dodać osobną procedurę obsługi wiadomości w pliku service worker web/firebase-messaging-sw.js .

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

Skonfiguruj serwer aplikacji

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

Wyślij wiadomość testową

W pliku FcmSender.java sendMessageToFcmRegistrationToken tworzy komunikat powiadomienia z ładunkiem danych. Token rejestracji jest przeznaczony dla instancji 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 systemu Android skopiowany z sekcji Rejestracja i wklej go do wartości zmiennej registrationToken .
2. Kliknij Uruchom aby uruchomić główną funkcję i wysłać wiadomość do użytkownika poprzez FCM.

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

Gdy aplikacja na Androida jest na pierwszym planie, w konsoli Android Studio zobaczysz dziennik: „Obsługa wiadomości na pierwszym planie”. Treść wiadomości jest również wyświetlana w interfejsie użytkownika, ponieważ interfejs użytkownika jest 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 (tj. jest ukryta w innym oknie 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 witrynę i wybierając Inspect . Treść wiadomości jest również wyświetlana w interfejsie użytkownika.

6. Wyślij wiadomość tematyczną

Funkcja zastępowania platformy interfejsu API FCM HTTP v1 umożliwia, aby żądanie wysłania komunikatu zachowywało się inaczej na różnych platformach. Jednym z przypadków użycia tej funkcji jest wyświetlanie innej treści powiadomień w zależności od platformy. Ta funkcja jest najpełniej wykorzystywana w przypadku kierowania komunikatów tematycznych na wiele urządzeń (które mogą obejmować wiele platform). W tej sekcji opisano kroki, które należy wykonać, aby Twoja aplikacja otrzymywała komunikat tematyczny dostosowany do każdej platformy.

Subskrybuj temat od klienta

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

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

[Opcjonalnie] Subskrybuj temat z serwera internetowego

Możesz pominąć tę sekcję, jeśli nie tworzysz na platformie internetowej.

Zestaw SDK FCM JS obecnie nie obsługuje subskrypcji tematów po stronie klienta. Zamiast tego możesz subskrybować, korzystając z interfejsu API zarządzania tematami po stronie serwera pakietu Admin SDK. Ten kod ilustruje 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 opcję Uruchom aby uruchomić główną funkcję w pliku FcmSubscriptionManager.java :

Wyślij wiadomość zawierającą komunikaty o zastąpieniu platformy do tematu

Teraz możesz wysłać wiadomość o zastąpieniu platformy tematycznej. W poniższym fragmencie kodu:

• Tworzysz żądanie wysłania z podstawową wiadomością i tytułem „ A new app is available ”.
• Wiadomość generuje powiadomienie na wyświetlaczu o tytule „ A new app is available ” na iOS i platformach internetowych.
• Wiadomość generuje powiadomienie na wyświetlaczu o tytule „ A new Android app is available ” na urządzeniach z Androidem.

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 sendMessageToFcmTopic(); . Kliknij Uruchom , aby wysłać wiadomość tematyczną.

7. Podsumowanie i co dalej

Podsumowując, wiesz już, jak tworzyć aplikacje wieloplatformowe przy użyciu Flutter i FCM, co obejmuje konfigurację środowiska, integrację zależności oraz odbieranie i wysyłanie wiadomości. Aby zanurkować głębiej, zapoznaj się z następującymi materiałami:

Zajęcia z kodowania

• Aby dowiedzieć się więcej o tym, jak Flutter współpracuje z innymi produktami Firebase, w tym o uwierzytelnianiu użytkowników i synchronizowaniu danych, zobacz Poznaj Firebase dla Flutter .
• Aby dowiedzieć się więcej o FCM, w tym o komunikatach i tematach w aplikacji: Użyj FCM i FIAM do wysyłania wiadomości do użytkowników oraz Twoja pierwsza wiadomość push w trybie multiemisji przy użyciu tematów FCM

Bibliografia

• Witryna Firebase
• Witryna Flutter
• Widżety FlutterFire Firebase Flutter
• Kanał YouTube Firebase
• Kanał Fluttera na YouTubie