Inizia a utilizzare Firebase Cloud Messaging nelle app Flutter

Questa guida descrive come iniziare a utilizzare Firebase Cloud Messaging nelle app client Flutter in modo da poter inviare messaggi in modo affidabile.

A seconda della piattaforma di destinazione, dovrai eseguire alcuni passaggi di configurazione aggiuntivi obbligatori.

iOS+

Swizzling dei metodi

Per utilizzare il plug-in FCM Flutter sui dispositivi Apple, è necessario lo swizzling dei metodi. In caso contrario, le funzionalità chiave di Firebase, come la registrazione FCM non funzioneranno correttamente.

Android

Google Play Services

FCM client richiedono dispositivi con Android 7.0 o versioni successive su cui è installato Google Play Services o un emulatore con Android 7.0 con le API Google. Tieni presente che non sei limitato al deployment delle app per Android tramite Google Play Store.

Le app che si basano sull'SDK Play Services devono sempre verificare se sul dispositivo è presente un APK di Google Play Services compatibile prima di accedere alle funzionalità di Google Play Services. Ti consigliamo di farlo in due punti: nel metodo onCreate() dell'attività principale e nel metodo onResume(). Il controllo in onCreate() garantisce che l'app non possa essere utilizzata senza un controllo riuscito. Il controllo in onResume() garantisce che, se l'utente torna all'app in esecuzione tramite altri mezzi, ad esempio il pulsante Indietro, il controllo venga comunque eseguito.

Se il dispositivo non ha una versione compatibile di Google Play Services, la tua app può chiamare GoogleApiAvailability.makeGooglePlayServicesAvailable() per consentire agli utenti di scaricare Google Play Services dal Play Store.

Web

Configurare le credenziali web con FCM

L'interfaccia web di FCM utilizza credenziali web chiamate Voluntary Application Server Identification o chiavi "VAPID" per autorizzare le richieste di invio ai servizi di notifiche push web supportati. Per abbonare l'app alle notifiche push, devi associare una coppia di chiavi al tuo progetto Firebase. Puoi generare una nuova coppia di chiavi o importare quella esistente tramite la Firebase console.

Installare il plug-in FCM

1. Installa e inizializza i plug-in Firebase per Flutter se non l'hai già fatto.

2. Dalla radice del progetto Flutter, esegui il seguente comando per installare il plug-in:

   flutter pub add firebase_messaging
   

3. Al termine, ricompila l'applicazione Flutter:

   flutter run
   

Richiedere l'autorizzazione alle notifiche

Per inviare un messaggio di notifica a un dispositivo, devi registrarlo con FCM utilizzando register(). Se l'autorizzazione alle notifiche non è stata concessa, questo metodo chiederà all'utente le autorizzazioni alle notifiche. In caso contrario, fornisce l'FID tramite onRegistered in caso di esito positivo o rifiuta il futuro a causa di un errore.

// You may set the permission requests to "provisional" which allows the user to choose what type
// of notifications they would like to receive once the user receives a notification.
final notificationSettings = await FirebaseMessaging.instance.requestPermission(provisional: true);

// For apple platforms, make sure the APNS token is available before making any FCM plugin API calls
final apnsToken = await FirebaseMessaging.instance.getAPNSToken();
if (apnsToken != null) {
 // APNS token is available, make FCM plugin API requests...
}

Accedere all'ID di installazione Firebase

Abilitare la registrazione utilizzando l'ID di installazione Firebase

Per abilitare la registrazione dell'istanza dell'app con FCM utilizzando l'ID di installazione Firebase (FID), devi prima abilitare gli FID nella configurazione dell'app per le piattaforme Android e Apple (non è richiesta alcuna configurazione di attivazione statica sul web):

<meta-data android:name="firebase_messaging_installation_id_enabled"
           android:value="true" />

<key>FirebaseMessagingInstallationIdEnabled</key>
<true/>

Abbonarsi allo stream onRegistered

Per inviare un messaggio all'istanza dell'app su un dispositivo specifico, devi disporre dell' ID di installazione Firebase (FID) dell' istanza dell'app dopo che è stata registrata con FCM. L'FID viene fornito in modo asincrono tramite lo stream onRegistered.

Sulle piattaforme Android e Apple, FCM registra automaticamente l'istanza dell'app all'avvio quando l'inizializzazione automatica è abilitata (impostazione predefinita). Tuttavia, è necessaria una chiamata esplicita a register():

• Su web. Facoltativamente, puoi passare vapidKey e serviceWorkerScriptPath.
• Sulle piattaforme Android e Apple se l'inizializzazione automatica è disabilitata o dopo aver chiamato unregister(). Puoi anche chiamare register() in qualsiasi momento per attivare onRegistered con l'FID già registrato.

Abbonati sempre a onRegistered prima di chiamare register() in modo che il listener sia attivo quando viene emesso l'evento di registrazione:

final messaging = FirebaseMessaging.instance;

messaging.onRegistered
    .listen((String installationId) {
      // TODO: Send the Firebase Installation ID (FID) to your application server.
    })
    .onError((err) {
      // Error getting Firebase Installation ID.
    });

// Required on Web, and on Android/Apple if auto-initialization is disabled.
await messaging.register(
  // Optional on Web (ignored on Android and Apple platforms)
  vapidKey: "BKagOny0KF_2pCJQ3m....moL0ewzQ8rZu",
);

Lo stream onRegistered emette l'FID nei seguenti scenari:

1. Automaticamente all'avvio iniziale dell'app e alla sincronizzazione di routine sulle piattaforme Android e Apple quando l'inizializzazione automatica è abilitata.
2. Ogni volta che una chiamata register() manuale viene completata (anche se l'istanza dell'app è già registrata, onRegistered emette comunque l'FID già registrato).
3. Ogni volta che viene rilevata una modifica dell'ID di installazione Firebase e l'app viene registrata di nuovo con FCM, o sul web quando viene attivato un pushsubscriptionchange evento.

Dopo aver ottenuto l'ID di installazione Firebase (FID), invialo al server dell'app e archivialo utilizzando il metodo che preferisci.

Accedere al token di registrazione (obsoleto)

Per inviare un messaggio a un dispositivo specifico, devi conoscere il token di registrazione del dispositivo. Per recuperare il token di registrazione di un'istanza dell'app, chiama getToken(). Se l'autorizzazione alle notifiche non è stata concessa, questo metodo chiederà all'utente le autorizzazioni alle notifiche. In caso contrario, restituisce un token o rifiuta il futuro a causa di un errore.

Sulle piattaforme web, passa la chiave pubblica VAPID a getToken():

final fcmToken = await FirebaseMessaging.instance.getToken(vapidKey: "BKagOny0KF_2pCJQ3m....moL0ewzQ8rZu");

Per ricevere una notifica ogni volta che il token viene aggiornato, abbonati allo stream onTokenRefresh:

FirebaseMessaging.instance.onTokenRefresh
    .listen((fcmToken) {
      // TODO: If necessary send token to application server.

      // Note: This callback is fired at each app startup and whenever a new
      // token is generated.
    })
    .onError((err) {
      // Error getting token.
    });

Impedire l'inizializzazione automatica

Quando viene generata una registrazione FCM, la libreria carica l'identificatore e i dati di configurazione su Firebase. Se preferisci impedire la registrazione automatica, disattiva l'inizializzazione automatica in fase di build.

Quando l'inizializzazione automatica è disabilitata, puoi registrare esplicitamente l'istanza dell'app in fase di runtime chiamando register() (assicurati di abbonarti prima a onRegistered per ricevere l'ID di installazione Firebase):

await FirebaseMessaging.instance.register();

iOS

Su iOS, aggiungi un valore di metadati a Info.plist:

FirebaseMessagingAutoInitEnabled = NO

Android

Su Android, disattiva la raccolta di Analytics e l'inizializzazione automatica di FCM (devi disattivarle entrambe) aggiungendo questi valori di metadati a AndroidManifest.xml:

<meta-data
    android:name="firebase_messaging_auto_init_enabled"
    android:value="false" />
<meta-data
    android:name="firebase_analytics_collection_enabled"
    android:value="false" />

Riattivare l'inizializzazione automatica di FCM in fase di runtime

Per attivare l'inizializzazione automatica per un'istanza dell'app specifica, chiama setAutoInitEnabled():

await FirebaseMessaging.instance.setAutoInitEnabled(true);

Una volta impostato, questo valore rimane valido anche dopo il riavvio dell'app.

Inviare un messaggio di notifica di prova

1. Installa ed esegui l'app sul dispositivo di destinazione. Sui dispositivi Apple, dovrai accettare la richiesta di autorizzazione a ricevere notifiche remote.

2. Assicurati che l'app sia in background sul dispositivo.

3. Nella console Firebase, vai a DevOps e coinvolgimento > Messaggistica.

4. Crea una campagna.

   • Se è il tuo primo messaggio:

     1. Seleziona Crea la tua prima campagna.

     2. Seleziona Messaggi di notifica Firebase e poi Crea.

   • Se hai già creato campagne:

     1. Nella scheda Campagne, seleziona Nuova campagna.

     2. Fai clic su Notifiche.

5. Inserisci il testo del messaggio.

6. Seleziona Invia messaggio di prova nel riquadro a destra.

7. Nel campo con l'etichetta Aggiungi un ID di installazione Firebase o FCM token di registrazione, inserisci l'ID di installazione Firebase o il token di registrazione registrato.

8. Seleziona Test.

Dopo aver selezionato Test, il dispositivo client di destinazione, con l'app in background, dovrebbe ricevere la notifica.

Per informazioni sulla distribuzione dei messaggi alla tua app, vai alla dashboard DevOps e coinvolgimento > Messaggistica > Report nella console Firebase. Questa dashboard registra il numero di messaggi inviati e aperti su dispositivi Apple e Android, insieme ai dati per le "impressioni" (notifiche visualizzate dagli utenti) per le app Android.

Gestire l'interazione

Quando gli utenti toccano una notifica, il comportamento predefinito sia su Android sia su iOS è l'apertura dell'applicazione. Se l'applicazione viene terminata, verrà avviata e, se è in background, verrà portata in primo piano.

A seconda dei contenuti di una notifica, potresti voler gestire l'interazione dell'utente quando l'applicazione si apre. Ad esempio, se viene inviato un nuovo messaggio chat utilizzando una notifica e l'utente la seleziona, potresti voler aprire la conversazione specifica all'apertura dell'applicazione.

Il pacchetto firebase-messaging offre due modi per gestire questa interazione:

1. getInitialMessage(): Se l'applicazione viene aperta da uno stato di terminazione, questo metodo restituisce un Future contenente un RemoteMessage. Una volta utilizzato, il RemoteMessage verrà rimosso.
2. onMessageOpenedApp: unStream che pubblica un RemoteMessage quando l' applicazione viene aperta da uno stato in background.

Per assicurarti che gli utenti abbiano un'esperienza fluida, devi gestire entrambi gli scenari. Il seguente esempio di codice illustra come è possibile ottenere questo risultato:

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

class _Application extends State {
  // In this example, suppose that all messages contain a data field with the key 'type'.
  Future 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 using 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("...");
  }
}

La modalità di gestione dell'interazione dipende dalla configurazione. L'esempio mostrato in precedenza è un esempio di base di utilizzo di un StatefulWidget.

Passaggi successivi

Dopo aver completato i passaggi di configurazione, ecco alcune opzioni per procedere con FCM per Flutter:

• Inviare messaggi ai dispositivi
• Ricevere messaggi in un'app Flutter
• Inviare messaggi agli argomenti