Configurare un'app client Firebase Cloud Messaging con C++

Per scrivere l'app client Firebase Cloud Messaging multipiattaforma con C++, utilizza l'API Firebase Cloud Messaging. L'SDK C++ funziona sia per le piattaforme Android che Apple, con alcune configurazioni aggiuntive richieste per ciascuna piattaforma.

Configura Firebase e l'SDK FCM

Android

  1. Se non l'hai ancora fatto, aggiungi Firebase al tuo progetto C++.

    • Nelle istruzioni di configurazione collegate, esamina i requisiti di dispositivo e app per l'utilizzo dell'SDK Firebase C++, inclusa la raccomandazione di utilizzare CMake per creare la tua app.

    • Nel file build.gradle a livello di progetto, assicurati di includere il repository Maven di Google nelle sezioni buildscript e allprojects.

  2. Crea un oggetto app Firebase, passando l'ambiente JNI e l'attività: 

    app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);

  3. Definisci una classe che implementi l'interfaccia firebase::messaging::Listener.

  4. Inizializza FCM, passando l'app e un listener creato: 

    ::firebase::messaging::Initialize(app, listener);

  5. Le app che si basano sull'SDK Google Play Services devono verificare la presenza di un APK Google Play Services compatibile sul dispositivo prima di accedere alle funzionalità. Per saperne di più, consulta Controllare l'APK di Google Play Services.

iOS+

  1. Se non l'hai ancora fatto, aggiungi Firebase al tuo progetto C++. Poi, per configurare il progetto per FCM:
    1. Nel Podfile del progetto, aggiungi la dipendenza FCM: 
      pod 'FirebaseMessaging'
    2. Trascina i framework firebase.framework e firebase_messaging.framework nel progetto Xcode dall'SDK Firebase C++.

  2. Carica la chiave di autenticazione del servizio APN su Firebase. Se non hai ancora una chiave di autenticazione APNs, assicurati di crearne una nel Centro membri sviluppatori Apple.

    1. All'interno del progetto nella console Firebase, seleziona l'icona a forma di ingranaggio, seleziona Impostazioni progetto e poi la scheda Cloud Messaging.

    2. In Chiave di autenticazione APN nella sezione Configurazione app iOS, fai clic sul pulsante Carica.

    3. Sfoglia fino alla posizione in cui hai salvato la chiave, selezionala e fai clic su Apri. Aggiungi l'ID chiave (disponibile nel Developer Member Center di Apple) e fai clic su Carica.

  3. Configura il progetto Xcode per attivare le notifiche push:

    1. Seleziona il progetto dall'area di navigazione.
    2. Seleziona la destinazione del progetto dall'area dell'editor.

    3. Seleziona la scheda Generali nell'area dell'editor.

      1. Scorri verso il basso fino a Framework e librerie collegati, poi fai clic sul pulsante + per aggiungere framework.

      2. Nella finestra visualizzata, scorri fino a UserNotifications.framework, fai clic sulla voce e poi su Aggiungi.

        Questo framework viene visualizzato solo in Xcode v8 e versioni successive ed è richiesto da questa libreria.

    4. Seleziona la scheda Funzionalità nell'area dell'editor.

      1. Imposta l'opzione Notifiche push su On.
      2. Scorri verso il basso fino a Modalità in background, quindi attiva l'opzione On.
      3. Seleziona Notifiche remote in Modalità in background.

  4. Crea un oggetto Firebase App: 

    app = ::firebase::App::Create(::firebase::AppOptions());

  5. Definisci una classe che implementi l'interfaccia firebase::messaging::Listener.

  6. Inizializza Firebase Cloud Messaging passando l'app e un listener costruito: 

    ::firebase::messaging::Initialize(app, listener);

Accedere al token di registrazione del dispositivo

Al momento dell'inizializzazione della libreria Firebase Cloud Messaging, viene richiesto un token di registrazione per l'istanza dell'app client. L'app riceverà il token con il callback OnTokenReceived, che deve essere definito nella classe che implementa firebase::messaging::Listener.

Se vuoi scegliere come target quel dispositivo specifico, devi avere accesso a questo token.

Nota sulla consegna dei messaggi su Android

Quando l'app non è in esecuzione e un utente tocca una notifica, il messaggio non viene instradato per impostazione predefinita tramite i callback integrati di FCM. In questo caso, i payload dei messaggi vengono ricevuti tramite un intent Intent utilizzato per avviare l'applicazione. Per fare in modo che FCM inoltri questi messaggi in arrivo al callback della libreria C++, devi eseguire l'override del metodo onNewIntent nella tua attività e passare Intent a MessageForwardingService.

import com.google.firebase.messaging.MessageForwardingService;

class MyActivity extends Activity {
  private static final String TAG = "MyActvity";

  @Override
  protected void onNewIntent(Intent intent) {
    Log.d(TAG, "A message was sent to this app while it was in the background.");
    Intent message = new Intent(this, MessageForwardingService.class);
    message.setAction(MessageForwardingService.ACTION_REMOTE_INTENT);
    message.putExtras(intent);
    message.setData(intent.getData());
    // For older versions of Firebase C++ SDK (< 7.1.0), use `startService`.
    // startService(message);
    MessageForwardingService.enqueueWork(this, message);
  }
}

I messaggi ricevuti mentre l'app è in background utilizzano il contenuto del campo di notifica per popolare la notifica della barra delle applicazioni, ma il contenuto della notifica non verrà comunicato a FCM. ovvero Message::notification sarà un valore nullo.

In sintesi:

Stato dell'app Notifica Dati Entrambe
Primo piano OnMessageReceived OnMessageReceived OnMessageReceived
Contesto Barra delle applicazioni OnMessageReceived Notifica: barra delle notifiche
Dati: negli extra dell'intent.

Gestione dei messaggi personalizzati su Android

Per impostazione predefinita, le notifiche inviate all'app vengono trasmesse a ::firebase::messaging::Listener::OnMessageReceived, ma in alcuni casi potresti voler ignorare il comportamento predefinito. Per farlo su Android, devi scrivere classi personalizzate che estendono com.google.firebase.messaging.cpp.ListenerService e aggiornare il AndroidManifest.xml del progetto.

Override ListenerService Methods.

ListenerService è la classe Java che intercetta i messaggi in arrivo inviati all'app e li indirizza alla libreria C++. Quando l'app è in primo piano (o quando l'app è in background e riceve un payload solo dati), i messaggi passeranno attraverso uno dei callback forniti in questa classe. Per aggiungere un comportamento personalizzato alla gestione dei messaggi, devi estendere FCM ListenerService predefinito:

import com.google.firebase.messaging.cpp.ListenerService;

class MyListenerService extends ListenerService {

Eseguendo l'override del metodo ListenerService.onMessageReceived, puoi eseguire azioni in base all'oggetto RemoteMessage ricevuto e ottenere i dati del messaggio:

@Override
public void onMessageReceived(RemoteMessage message) {
  Log.d(TAG, "A message has been received.");
  // Do additional logic...
  super.onMessageReceived(message);
}

ListenerService ha anche altri metodi utilizzati meno frequentemente. Anche questi possono essere sostituiti. Per maggiori informazioni, consulta il riferimento FirebaseMessagingService.

@Override
public void onDeletedMessages() {
  Log.d(TAG, "Messages have been deleted on the server.");
  // Do additional logic...
  super.onDeletedMessages();
}

@Override
public void onMessageSent(String messageId) {
  Log.d(TAG, "An outgoing message has been sent.");
  // Do additional logic...
  super.onMessageSent(messageId);
}

@Override
public void onSendError(String messageId, Exception exception) {
  Log.d(TAG, "An outgoing message encountered an error.");
  // Do additional logic...
  super.onSendError(messageId, exception);
}

Aggiorna AndroidManifest.xml

Una volta scritte le classi personalizzate, devono essere incluse in AndroidManifest.xml per avere effetto. Assicurati che il manifest includa gli strumenti di unione dichiarando l'attributo appropriato all'interno del tag <manifest>, come segue:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.google.firebase.messaging.cpp.samples"
    xmlns:tools="http://schemas.android.com/tools">

Nell'archivio firebase_messaging_cpp.aar è presente un file AndroidManifest.xml che dichiara il ListenerService predefinito di FCM. Questo manifest viene normalmente unito al manifest specifico del progetto, in modo che ListenerService possa essere eseguito. ListenerService deve essere sostituito con il servizio di listener personalizzato. A questo scopo, rimuovi il servizio ListenerService predefinito e aggiungi il servizio personalizzato, operazione che puoi eseguire con le seguenti righe del file AndroidManifest.xml dei tuoi progetti:

<service android:name="com.google.firebase.messaging.cpp.ListenerService"
         tools:node="remove" />
 
<service android:name="com.google.firebase.messaging.cpp.samples.MyListenerService"
         android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT"/>
  </intent-filter>
</service>

Le nuove versioni dell'SDK Firebase C++ (7.1.0 e successive) utilizzano JobIntentService, che richiede modifiche aggiuntive nel file AndroidManifest.xml.

<service android:name="com.google.firebase.messaging.MessageForwardingService"
     android:permission="android.permission.BIND_JOB_SERVICE"
     android:exported="false" >
</service>

Impedisci l'inizializzazione automatica

FCM genera un token di registrazione per il targeting dei dispositivi. Quando viene generato un token, la libreria carica l'identificatore e i dati di configurazione su Firebase. Se vuoi ottenere un consenso esplicito prima di utilizzare il token, puoi impedire la generazione al momento della configurazione disattivando FCM (e su Android, Analytics). Per farlo, aggiungi un valore dei metadati al tuo Info.plist (non al tuo GoogleService-Info.plist) sulle piattaforme Apple o al tuo AndroidManifest.xml su Android:

Android

<?xml version="1.0" encoding="utf-8"?>
<application>
  <meta-data android:name="firebase_messaging_auto_init_enabled"
             android:value="false" />
  <meta-data android:name="firebase_analytics_collection_enabled"
             android:value="false" />
</application>

Swift

FirebaseMessagingAutoInitEnabled = NO

Per riattivare FCM, puoi effettuare una chiamata di runtime:

::firebase::messaging::SetTokenRegistrationOnInitEnabled(true);

Una volta impostato, questo valore viene mantenuto anche dopo il riavvio dell'app.

FCM consente l'invio di messaggi contenenti un link diretto alla tua app. Per ricevere messaggi contenenti un link diretto, devi aggiungere un nuovo filtro per intent all'attività che gestisce i link diretti per la tua app. Il filtro per intent deve intercettare i link diretti del tuo dominio. Se i tuoi messaggi non contengono un link diretto, questa configurazione non è necessaria. In AndroidManifest.xml:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="http"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="https"/>
</intent-filter>

È anche possibile specificare un carattere jolly per rendere più flessibile il filtro per intent. Ad esempio:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="*.example.com" android:scheme="http"/>
  <data android:host="*.example.com" android:scheme="https"/>
</intent-filter>

Quando gli utenti toccano una notifica contenente un link allo schema e all'host che specifichi, la tua app avvia l'attività con questo filtro per intent per gestire il link.

Passaggi successivi

Dopo aver configurato l'app client, puoi inviare messaggi downstream e per argomento con Firebase. Per saperne di più, guarda la dimostrazione di questa funzionalità nell'esempio di avvio rapido, che puoi scaricare, eseguire e rivedere.

Per aggiungere altri comportamenti più avanzati alla tua app, consulta le guide per l'invio di messaggi da un server app:

Tieni presente che per utilizzare queste funzionalità è necessaria un'implementazione lato server.