Nachrichten in einer Flutter-App empfangen

Je nach Gerätestatus werden eingehende Nachrichten unterschiedlich behandelt. Um diese Szenarien und die Integration von FCM in Ihre eigene Anwendung zu verstehen, ist es wichtig, die verschiedenen Zustände zu kennen, in denen sich ein Gerät befinden kann:

Status Beschreibung
Vordergrund Wenn die Anwendung geöffnet, sichtbar und in Gebrauch ist.
Hintergrund Wenn die Anwendung geöffnet, aber im Hintergrund (minimiert) ist. Dies geschieht in der Regel, wenn der Nutzer die Startbildschirmtaste auf dem Gerät gedrückt hat, über die App-Übersicht zu einer anderen App gewechselt ist oder die Anwendung in einem anderen Tab (Web) geöffnet ist.
Gekündigt Wenn das Gerät gesperrt ist oder die Anwendung nicht ausgeführt wird.

Bevor die Anwendung Nachrichten-Payloads über FCM empfangen kann, müssen einige Voraussetzungen erfüllt sein:

  • Die Anwendung muss mindestens einmal geöffnet worden sein, damit sie bei FCM registriert werden kann.
  • Wenn der Nutzer die App unter iOS über den App-Switcher schließt, muss sie manuell wieder geöffnet werden, damit Hintergrundnachrichten wieder funktionieren.
  • Wenn der Nutzer die App auf einem Android-Gerät über die Geräteeinstellungen erzwingt, muss sie manuell wieder geöffnet werden, damit Nachrichten wieder funktionieren.
  • Im Web müssen Sie mit Ihrem Web-Push-Zertifikat ein Token (mit getToken()) angefordert haben.

Berechtigung zum Empfangen von Nachrichten anfordern

Unter iOS, macOS, im Web und unter Android 13 oder höher müssen Sie zuerst die Einwilligung des Nutzers einholen, bevor FCM-Nutzlasten auf seinem Gerät empfangen werden können.

Das Paket firebase_messaging bietet eine einfache API zum Anfordern von Berechtigungen über die Methode requestPermission. Diese API akzeptiert eine Reihe von benannten Argumenten, die den Typ der Berechtigungen definieren, die Sie anfordern möchten. Dazu gehört beispielsweise, ob Nachrichten mit Benachrichtigungs-Nutzlasten einen Ton auslösen oder Nachrichten über Siri vorgelesen werden können. Standardmäßig werden mit der Methode sinnvolle Standardberechtigungen angefordert. Die Referenz-API enthält eine vollständige Dokumentation dazu, wofür die einzelnen Berechtigungen benötigt werden.

Rufen Sie die Methode in Ihrer Anwendung auf, um zu beginnen. Unter iOS wird ein natives Modal angezeigt, im Web wird der native API-Ablauf des Browsers ausgelöst:

FirebaseMessaging messaging = FirebaseMessaging.instance;

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

print('User granted permission: ${settings.authorizationStatus}');

Mit der authorizationStatus-Eigenschaft des NotificationSettings-Objekts, das von der Anfrage zurückgegeben wird, kann die allgemeine Entscheidung des Nutzers ermittelt werden:

  • authorized: Der Nutzer, dem die Berechtigung gewährt wurde.
  • denied: Der Nutzer, dem die Berechtigung verweigert wurde.
  • notDetermined: Der Nutzer hat noch nicht ausgewählt, ob er die Berechtigung erteilen möchte.
  • provisional: Der Nutzer, dem die vorläufige Berechtigung gewährt wurde

Die anderen Attribute für NotificationSettings geben zurück, ob eine bestimmte Berechtigung auf dem aktuellen Gerät aktiviert, deaktiviert oder nicht unterstützt wird.

Nachdem die Berechtigung erteilt wurde und die verschiedenen Arten von Gerätestatus verstanden wurden, kann Ihre Anwendung nun mit der Verarbeitung der eingehenden FCM-Nutzlasten beginnen.

Nachrichtenverarbeitung

Je nach aktuellem Status Ihrer Anwendung erfordern eingehende Nutzlasten verschiedener Nachrichtentypen unterschiedliche Implementierungen:

Vordergrundnachrichten

Wenn Sie Nachrichten verarbeiten möchten, während Ihre Anwendung im Vordergrund ausgeführt wird, hören Sie auf den onMessage-Stream.

FirebaseMessaging.onMessage.listen((RemoteMessage message) {
  print('Got a message whilst in the foreground!');
  print('Message data: ${message.data}');

  if (message.notification != null) {
    print('Message also contained a notification: ${message.notification}');
  }
});

Der Stream enthält ein RemoteMessage mit verschiedenen Informationen zur Nutzlast, z. B. woher sie stammt, die eindeutige ID, die Sendezeit und ob sie eine Benachrichtigung enthält. Da die Nachricht abgerufen wurde, während sich Ihre Anwendung im Vordergrund befindet, können Sie direkt auf den Status und Kontext Ihrer Flutter-Anwendung zugreifen.

Nachrichten im Vordergrund und Benachrichtigungen

Benachrichtigungen, die eingehen, während die App im Vordergrund ausgeführt wird, werden standardmäßig weder auf Android- noch auf iOS-Geräten angezeigt. Es ist jedoch möglich, dieses Verhalten zu überschreiben:

  • Unter Android müssen Sie einen Benachrichtigungskanal mit hoher Priorität erstellen.
  • Unter iOS können Sie die Präsentationsoptionen für die Anwendung aktualisieren.

Hintergrundnachrichten

Die Verarbeitung von Hintergrundnachrichten unterscheidet sich auf nativen (Android und Apple) und webbasierten Plattformen.

Apple-Plattformen und Android

Hintergrundnachrichten verarbeiten, indem Sie einen onBackgroundMessage-Handler registrieren. Wenn Nachrichten empfangen werden, wird ein Isolat erstellt (nur Android, für iOS/macOS ist kein separates Isolat erforderlich). So können Sie Nachrichten auch dann verarbeiten, wenn Ihre Anwendung nicht ausgeführt wird.

Beachten Sie bei der Implementierung Ihres Hintergrund-Message-Handlers Folgendes:

  1. Es darf keine anonyme Funktion sein.
  2. Es muss sich um eine Funktion der obersten Ebene handeln (z.B. keine Klassenmethode, die eine Initialisierung erfordert).
  3. Wenn Sie Flutter-Version 3.3.0 oder höher verwenden, muss der Message-Handler direkt über der Funktionsdeklaration mit @pragma('vm:entry-point') annotiert werden. Andernfalls wird er möglicherweise beim Tree Shaking für den Release-Modus entfernt.
@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // If you're going to use other Firebase services in the background, such as Firestore,
  // make sure you call `initializeApp` before using other Firebase services.
  await Firebase.initializeApp();

  print("Handling a background message: ${message.messageId}");
}

void main() {
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
  runApp(MyApp());
}

Da der Handler in einem eigenen Isolat außerhalb des Kontextes Ihrer Anwendung ausgeführt wird, ist es nicht möglich, den Anwendungsstatus zu aktualisieren oder UI-beeinträchtigende Logik auszuführen. Sie können jedoch Logik wie HTTP-Anfragen ausführen, E/A-Vorgänge ausführen (z.B. lokalen Speicher aktualisieren) und mit anderen Plug-ins kommunizieren.

Wir empfehlen, die Logik so schnell wie möglich zu vervollständigen. Wenn Sie lange, intensive Aufgaben ausführen, kann sich das auf die Geräteleistung auswirken und dazu führen, dass das Betriebssystem den Prozess beendet. Wenn die Ausführung von Tasks länger als 30 Sekunden dauert, wird der Prozess möglicherweise automatisch vom Gerät beendet.

Web

Schreiben Sie im Web einen JavaScript-Service Worker, der im Hintergrund ausgeführt wird. Verwenden Sie den Service Worker, um Hintergrundnachrichten zu verarbeiten.

Erstellen Sie dazu eine neue Datei in Ihrem Verzeichnis web und nennen Sie sie firebase-messaging-sw.js:

// Please see this file for the latest firebase-js-sdk version:
// https://github.com/firebase/flutterfire/blob/main/packages/firebase_core/firebase_core_web/lib/src/firebase_sdk_version.dart
importScripts("https://www.gstatic.com/firebasejs/10.7.0/firebase-app-compat.js");
importScripts("https://www.gstatic.com/firebasejs/10.7.0/firebase-messaging-compat.js");

firebase.initializeApp({
  apiKey: "...",
  authDomain: "...",
  databaseURL: "...",
  projectId: "...",
  storageBucket: "...",
  messagingSenderId: "...",
  appId: "...",
});

const messaging = firebase.messaging();

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

In der Datei müssen sowohl das App- als auch das Messaging-SDK importiert, Firebase initialisiert und die Variable messaging verfügbar gemacht werden.

Als Nächstes muss der Worker registriert werden. Registrieren Sie den Worker in der Datei index.html, indem Sie das Tag <script> ändern, mit dem Flutter gebootstrapped wird:

<script src="flutter_bootstrap.js" async>
  if ('serviceWorker' in navigator) {
    window.addEventListener('load', function () {
      navigator.serviceWorker.register('firebase-messaging-sw.js', {
        scope: '/firebase-cloud-messaging-push-scope',
      });
    });
  }
</script>

Wenn Sie das alte Vorlagensystem verwenden, können Sie den Worker registrieren, indem Sie das <script>-Tag, mit dem Flutter gebootstrapped wird, so ändern:

<html>
<body>
  <script>
      var serviceWorkerVersion = null;
      var scriptLoaded = false;
      function loadMainDartJs() {
        if (scriptLoaded) {
          return;
        }
        scriptLoaded = true;
        var scriptTag = document.createElement('script');
        scriptTag.src = 'main.dart.js';
        scriptTag.type = 'application/javascript';
        document.body.append(scriptTag);
      }

      if ('serviceWorker' in navigator) {
        // Service workers are supported. Use them.
        window.addEventListener('load', function () {
          // Register Firebase Messaging service worker.
          navigator.serviceWorker.register('firebase-messaging-sw.js', {
            scope: '/firebase-cloud-messaging-push-scope',
          });

          // Wait for registration to finish before dropping the <script> tag.
          // Otherwise, the browser will load the script multiple times,
          // potentially different versions.
          var serviceWorkerUrl =
            'flutter_service_worker.js?v=' + serviceWorkerVersion;

          navigator.serviceWorker.register(serviceWorkerUrl).then((reg) => {
            function waitForActivation(serviceWorker) {
              serviceWorker.addEventListener('statechange', () => {
                if (serviceWorker.state == 'activated') {
                  console.log('Installed new service worker.');
                  loadMainDartJs();
                }
              });
            }
            if (!reg.active && (reg.installing || reg.waiting)) {
              // No active web worker and we have installed or are installing
              // one for the first time. Simply wait for it to activate.
              waitForActivation(reg.installing ?? reg.waiting);
            } else if (!reg.active.scriptURL.endsWith(serviceWorkerVersion)) {
              // When the app updates the serviceWorkerVersion changes, so we
              // need to ask the service worker to update.
              console.log('New service worker available.');
              reg.update();
              waitForActivation(reg.installing);
            } else {
              // Existing service worker is still good.
              console.log('Loading app from service worker.');
              loadMainDartJs();
            }
          });

          // If service worker doesn't succeed in a reasonable amount of time,
          // fallback to plaint <script> tag.
          setTimeout(() => {
            if (!scriptLoaded) {
              console.warn(
                'Failed to load app from service worker. Falling back to plain <script> tag.'
              );
              loadMainDartJs();
            }
          }, 4000);
        });
      } else {
        // Service workers not supported. Just drop the <script> tag.
        loadMainDartJs();
      }
  </script>
</body>

Starten Sie als Nächstes Ihre Flutter-Anwendung neu. Der Worker wird registriert und alle Hintergrundnachrichten werden über diese Datei verarbeitet.

Interaktionen verarbeiten

Da Benachrichtigungen ein sichtbarer Hinweis sind, interagieren Nutzer häufig mit ihnen (durch Tippen). Standardmäßig wird die Anwendung sowohl unter Android als auch unter iOS geöffnet. Wenn die Anwendung beendet wird, wird sie gestartet. Wenn sie im Hintergrund ausgeführt wird, wird sie in den Vordergrund gebracht.

Je nach Inhalt einer Benachrichtigung möchten Sie möglicherweise die Interaktion des Nutzers beim Öffnen der Anwendung verarbeiten. Wenn beispielsweise eine neue Chatnachricht über eine Benachrichtigung gesendet wird und der Nutzer darauf tippt, möchten Sie möglicherweise die entsprechende Unterhaltung öffnen, wenn die Anwendung geöffnet wird.

Das firebase-messaging-Paket bietet zwei Möglichkeiten, diese Interaktion zu verarbeiten:

  • getInitialMessage(): Wenn die Anwendung aus einem beendeten Zustand heraus geöffnet wird, wird ein Future mit einem RemoteMessage zurückgegeben. Nach der Verwendung wird die RemoteMessage entfernt.
  • onMessageOpenedApp: Ein Stream, das ein RemoteMessage postet, wenn die Anwendung aus dem Hintergrund geöffnet wird.

Wir empfehlen, beide Szenarien zu berücksichtigen, um eine reibungslose Nutzererfahrung zu gewährleisten. Im folgenden Codebeispiel wird gezeigt, wie das geht:

class Application extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _Application();
}

class _Application extends State<Application> {
  // It is assumed that all messages contain a data field with the key 'type'
  Future<void> setupInteractedMessage() async {
    // Get any messages which caused the application to open from
    // a terminated state.
    RemoteMessage? initialMessage =
        await FirebaseMessaging.instance.getInitialMessage();

    // If the message also contains a data property with a "type" of "chat",
    // navigate to a chat screen
    if (initialMessage != null) {
      _handleMessage(initialMessage);
    }

    // Also handle any interaction when the app is in the background via a
    // Stream listener
    FirebaseMessaging.onMessageOpenedApp.listen(_handleMessage);
  }

  void _handleMessage(RemoteMessage message) {
    if (message.data['type'] == 'chat') {
      Navigator.pushNamed(context, '/chat',
        arguments: ChatArguments(message),
      );
    }
  }

  @override
  void initState() {
    super.initState();

    // Run code required to handle interacted messages in an async function
    // as initState() must not be async
    setupInteractedMessage();
  }

  @override
  Widget build(BuildContext context) {
    return Text("...");
  }
}

Wie Sie mit der Interaktion umgehen, hängt von der Einrichtung Ihrer Anwendung ab. Das obige Beispiel zeigt eine einfache Illustration mit einem StatefulWidget.

Nachrichten lokalisieren

Sie haben zwei Möglichkeiten, lokalisierte Strings zu senden:

  • Speichern Sie die bevorzugte Sprache jedes Nutzers auf Ihrem Server und senden Sie für jede Sprache benutzerdefinierte Benachrichtigungen.
  • Lokalisierte Strings in Ihre App einbetten und die nativen Gebietsschemaeinstellungen des Betriebssystems verwenden

So verwenden Sie die zweite Methode:

Android

  1. Geben Sie Ihre Nachrichten in der Standardsprache in resources/values/strings.xml an:

    <string name="notification_title">Hello world</string>
<string name="notification_message">This is a message</string>

  2. Geben Sie die übersetzten Nachrichten im Verzeichnis values-language an. Geben Sie beispielsweise französische Nachrichten in resources/values-fr/strings.xml an:

    <string name="notification_title">Bonjour le monde</string>
<string name="notification_message">C'est un message</string>

  3. Verwenden Sie in der Server-Payload anstelle der Schlüssel title, message und body die Schlüssel title_loc_key und body_loc_key für Ihre lokalisierte Mitteilung und legen Sie sie auf das Attribut name der Mitteilung fest, die Sie anzeigen möchten.

    Die Nutzlast der Nachricht würde so aussehen:

    {
  "android": {
     "notification": {
       "title_loc_key": "notification_title",
       "body_loc_key": "notification_message"
     }
  }
}

iOS

  1. Geben Sie Ihre Nachrichten in der Standardsprache in Base.lproj/Localizable.strings an:

    "NOTIFICATION_TITLE" = "Hello World";
"NOTIFICATION_MESSAGE" = "This is a message";

  2. Geben Sie die übersetzten Nachrichten im Verzeichnis language.lproj an. Geben Sie beispielsweise französische Nachrichten in fr.lproj/Localizable.strings an:

    "NOTIFICATION_TITLE" = "Bonjour le monde";
"NOTIFICATION_MESSAGE" = "C'est un message";

    Die Nutzlast der Nachricht würde so aussehen:

    {
  "apns": {
     "payload": {
       "alert": {
         "title-loc-key": "NOTIFICATION_TITLE",
         "loc-key": "NOTIFICATION_MESSAGE"
       }
     }
  }
}

Export von Daten zur Nachrichtenzustellung aktivieren

Sie können Ihre Nachrichtendaten zur weiteren Analyse in BigQuery exportieren. Mit BigQuery können Sie die Daten mit BigQuery SQL analysieren, sie zu einem anderen Cloud-Anbieter exportieren oder für Ihre benutzerdefinierten ML-Modelle verwenden. Ein Export nach BigQuery umfasst alle verfügbaren Daten für Nachrichten, unabhängig vom Nachrichtentyp oder davon, ob die Nachricht über die API oder den Benachrichtigungs-Composer gesendet wird.

Um den Export zu aktivieren, folgen Sie zuerst der Anleitung hier und dann dieser Anleitung:

Android

Sie können den folgenden Code verwenden:

await FirebaseMessaging.instance.setDeliveryMetricsExportToBigQuery(true);

iOS

Bei iOS müssen Sie AppDelegate.m durch den folgenden Inhalt ersetzen.

#import "AppDelegate.h"
#import "GeneratedPluginRegistrant.h"
#import <Firebase/Firebase.h>

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [GeneratedPluginRegistrant registerWithRegistry:self];
  // Override point for customization after application launch.
  return [super application:application didFinishLaunchingWithOptions:launchOptions];
}

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)userInfo
          fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  [[FIRMessaging extensionHelper] exportDeliveryMetricsToBigQueryWithMessageInfo:userInfo];
}

@end

Web

Für Web müssen Sie Ihren Service Worker ändern, um die Version 9 des SDK verwenden zu können. Die Version 9 muss gebündelt werden. Sie benötigen also einen Bundler wie esbuild, damit der Service Worker funktioniert. In der Beispiel-App sehen Sie, wie das geht.

Nach der Migration zum v9 SDK können Sie den folgenden Code verwenden:

import {
  experimentalSetDeliveryMetricsExportedToBigQueryEnabled,
  getMessaging,
} from 'firebase/messaging/sw';
...

const messaging = getMessaging(app);
experimentalSetDeliveryMetricsExportedToBigQueryEnabled(messaging, true);

Vergessen Sie nicht, yarn build auszuführen, um die neue Version Ihres Service Workers in den Ordner web zu exportieren.

Bilder in Benachrichtigungen auf iOS-Geräten anzeigen

Damit auf Apple-Geräten eingehende FCM-Benachrichtigungen Bilder aus der FCM-Nutzlast anzeigen können, müssen Sie eine zusätzliche Benachrichtigungsdienst-Erweiterung hinzufügen und Ihre App für die Verwendung dieser Erweiterung konfigurieren.

Wenn Sie die Firebase-Telefonauthentifizierung verwenden, müssen Sie Ihrem Podfile den Firebase Auth-Pod hinzufügen.

Schritt 1: Benachrichtigungsdienst-Erweiterung hinzufügen

  1. Klicken Sie in Xcode auf File > New > Target… (Datei > Neu > Ziel…).
  2. In einem Modal wird eine Liste möglicher Ziele angezeigt. Scrollen Sie nach unten oder verwenden Sie den Filter, um Notification Service Extension (Notification Service-Erweiterung) auszuwählen. Klicken Sie auf Weiter.
  3. Fügen Sie einen Produktnamen hinzu (verwenden Sie „ImageNotification“, um dieser Anleitung zu folgen), wählen Sie entweder Swift oder Objective-C aus und klicken Sie auf Fertigstellen.
  4. Klicken Sie auf Aktivieren, um das Schema zu aktivieren.

Schritt 2: Ziel dem Podfile hinzufügen

Swift

Achten Sie darauf, dass Ihre neue Erweiterung Zugriff auf das FirebaseMessaging-Swift-Paket hat, indem Sie es Ihrem Runner-Ziel hinzufügen:

  1. Fügen Sie das Firebase Apple Platforms SDK über den Navigator hinzu: File > Add Package Dependencies... (Datei > Paketabhängigkeiten hinzufügen).

  2. Suchen Sie nach der Paket-URL oder geben Sie sie ein: https://github.com/firebase/firebase-ios-sdk

  3. Zu Projekt Runner hinzufügen: Paket hinzufügen

  4. Wählen Sie „FirebaseMessaging“ aus und fügen Sie es dem Ziel „ImageNotification“ hinzu: Paket hinzufügen

Objective-C

Achten Sie darauf, dass Ihre neue Erweiterung Zugriff auf den Firebase/Messaging-Pod hat. Fügen Sie ihn dazu in die Podfile-Datei ein:

  1. Öffnen Sie das Podfile über den Navigator: Pods > Podfile

  2. Scrollen Sie zum Ende der Datei und fügen Sie Folgendes hinzu:

    target 'ImageNotification' do
  use_frameworks!
  pod 'Firebase/Auth' # Add this line if you are using FirebaseAuth phone authentication
  pod 'Firebase/Messaging'
end

  3. Installieren oder aktualisieren Sie Ihre Pods mit pod install aus dem Verzeichnis ios oder macos.

Schritt 3: Erweiterungshilfe verwenden

An diesem Punkt sollte alles noch normal laufen. Im letzten Schritt wird das Erweiterungshilfsprogramm aufgerufen.

Swift

  1. Wählen Sie im Navigator Ihre ImageNotification-Erweiterung aus.

  2. Öffnen Sie die Datei NotificationService.swift.

  3. Ersetzen Sie den Inhalt von NotificationService.swift durch:

    import UserNotifications
import FirebaseMessaging

class NotificationService: UNNotificationServiceExtension {

    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)

        Messaging.serviceExtension().populateNotificationContent(bestAttemptContent!, withContentHandler: contentHandler)
    }

    override func serviceExtensionTimeWillExpire() {
        if let contentHandler = contentHandler, let bestAttemptContent = bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }
}

Objective-C

  1. Wählen Sie im Navigator Ihre ImageNotification-Erweiterung aus.

  2. Öffnen Sie die Datei NotificationService.m.

  3. Importieren Sie FirebaseMessaging.h oben in der Datei direkt nach NotificationService.h, wie unten dargestellt.

    Ersetzen Sie den Inhalt von NotificationService.m durch:

    #import "NotificationService.h"
#import "FirebaseMessaging.h"
#import <FirebaseAuth/FirebaseAuth-Swift.h> // Add this line if you are using FirebaseAuth phone authentication
#import <UIKit/UIKit.h> // Add this line if you are using FirebaseAuth phone authentication

@interface NotificationService () <NSURLSessionDelegate>

@property(nonatomic) void (^contentHandler)(UNNotificationContent *contentToDeliver);
@property(nonatomic) UNMutableNotificationContent *bestAttemptContent;

@end

@implementation NotificationService

/* Uncomment this if you are using Firebase Auth
- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  if ([[FIRAuth auth] canHandleURL:url]) {
    return YES;
  }
  return NO;
}

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
  for (UIOpenURLContext *urlContext in URLContexts) {
    [FIRAuth.auth canHandleURL:urlContext.URL];
  }
}
*/

- (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
    self.contentHandler = contentHandler;
    self.bestAttemptContent = [request.content mutableCopy];

    // Modify the notification content here...
    [[FIRMessaging extensionHelper] populateNotificationContent:self.bestAttemptContent withContentHandler:contentHandler];
}

- (void)serviceExtensionTimeWillExpire {
    // Called just before the extension will be terminated by the system.
    // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
    self.contentHandler(self.bestAttemptContent);
}

@end

Schritt 4: Bild zur Nutzlast hinzufügen

Sie können jetzt ein Bild in die Nutzlast Ihrer Benachrichtigung einfügen. In der iOS-Dokumentation finden Sie Informationen zum Erstellen einer Sendeanfrage. Die maximale Bildgröße von 300 KB wird vom Gerät erzwungen.