Inizia a utilizzare Firebase Cloud Messaging nelle app C++

Seleziona la piattaforma:

iOS+ Android Web Flutter Unity C++

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

Per scrivere la tua 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 ogni piattaforma. Per scoprire di più su come l'SDK C++ per iOS e Android funziona con FCM, consulta Informazioni su Firebase per C++.

Configura Firebase e l'SDK FCM

Android

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

   • Nelle istruzioni di configurazione collegate, esamina i requisiti del dispositivo e dell'app per l'utilizzo dell'SDK Firebase C++, incluso il consiglio di utilizzare CMake per creare l'app.

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

   Importante: assicurati di aggiungere la libreria firebase_messaging al file CMakeLists.txt.

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 implementa l'interfaccia firebase::messaging::Listener.

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

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

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

iOS+

1. Se non l'hai già 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 tuo 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 APN, assicurati di crearne una nell'Apple Developer Member Center.

   1. Nella console Firebase, vai a Impostazioni > Generali. Poi, fai clic sulla scheda Cloud Messaging.
   2. In Chiave di autenticazione APN in Configurazione app per iOS, fai clic su Carica per caricare la chiave di autenticazione di sviluppo o la chiave di autenticazione di produzione o entrambe. È obbligatorio indicarne almeno uno.
   3. Vai alla posizione in cui hai salvato la chiave, selezionala e fai clic su Apri. Aggiungi l'ID chiave per la chiave (disponibile nel Member Center di Apple Developer) e fai clic su Carica.

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

   1. Seleziona il progetto dall'area di navigazione.
   2. Seleziona la destinazione del progetto nell'area Editor.

   3. Seleziona la scheda Generali nell'area Editor.

      1. Scorri fino a Linked Frameworks and Libraries (Framework e librerie collegati), poi fai clic sul pulsante + per aggiungere i 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 Capabilities (Funzionalità) nell'Editor area (Area editor).

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

4. Crea un oggetto app Firebase:

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

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

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

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

Accedi all'ID di installazione Firebase

Nota: Firebase Cloud Messaging sta passando dai token di registrazione FCM agli ID installazione di Firebase (FID) per il targeting di singole istanze di app.

Abilita la registrazione utilizzando l'ID di installazione Firebase

Per consentire la registrazione dell'istanza dell'app con FCM utilizzando l'ID installazione di Firebase (FID), devi prima attivare i FID nella configurazione dell'app per le piattaforme Android e Apple:

Android

Aggiungi il seguente elemento <meta-data> all'interno dell'elemento <application> del tuo AndroidManifest.xml:

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

Swift

Aggiungi la chiave FirebaseMessagingInstallationIdEnabled al tuo Info.plist e impostala su YES:

FirebaseMessagingInstallationIdEnabled = YES

Implementa il listener onRegistrationReceived

Durante l'inizializzazione della libreria Firebase Cloud Messaging, l'istanza dell'app client viene registrata per ricevere messaggi utilizzando un ID installazione di Firebase (FID). L'app riceverà l'FID con il callback OnRegistrationReceived, che deve essere definito nell'implementazione di firebase::messaging::Listener:

class MyListener : public firebase::messaging::Listener {
 public:
  void OnRegistrationReceived(const char* installation_id) override {
    LogMessage("Received Firebase Installation ID: %s", installation_id);
    // TODO: Send the Firebase Installation ID (FID) to your app server to
    // target this device for messages.
  }
};

Se vuoi scegliere come target l'istanza dell'app specifica, invia l'ID installazione Firebase al server dell'app e memorizzalo utilizzando il metodo che preferisci.

Registra manualmente quando l'inizializzazione automatica è disattivata

Puoi anche attivare manualmente la registrazione con FCM in fase di runtime utilizzando Register():

// Manually register with FCM
firebase::Future<void> register_future = firebase::messaging::Register();
register_future.OnCompletion([](const firebase::Future<void>& future) {
  if (future.status() == firebase::kFutureStatusComplete &&
      future.error() == 0) {
    // Note: The registered Firebase Installation ID is delivered to the
    // OnRegistrationReceived callback.
    LogMessage("Registered with FCM");
  }
});

Accedi al token di registrazione FCM (ritirato)

Attenzione: questa funzionalità è deprecata. Utilizza gli ID installazione di Firebase, poiché questo metodo verrà rimosso in una release futura.

Durante l'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 l'istanza dell'app specifica, 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, per impostazione predefinita il messaggio non viene indirizzato tramite i callback integrati di FCM. In questo caso, i payload dei messaggi vengono ricevuti tramite un 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 i contenuti del campo di notifica per compilare la notifica della barra delle applicazioni, ma i contenuti della notifica non verranno comunicati a FCM. In altre parole, Message::notification sarà un valore null.

In sintesi:

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

Gestione dei messaggi personalizzati su Android

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

Esegui l'override dei metodi ListenerService

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 è in background e riceve un payload di soli dati), i messaggi passano attraverso uno dei callback forniti in questa classe. Per aggiungere un comportamento personalizzato alla gestione dei messaggi, devi estendere il ListenerService predefinito di FCM:

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 che vengono utilizzati meno di frequente. Anche questi possono essere sostituiti. Per saperne di più, 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 essere applicate. Assicurati che il manifest includa gli strumenti di unione dichiarando l'attributo appropriato all'interno del tag <manifest>, in questo modo:

<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, il che consente l'esecuzione di ListenerService. ListenerService deve essere sostituito con il servizio listener personalizzato. Per farlo, rimuovi il servizio ListenerService predefinito e aggiungi il servizio personalizzato. Puoi farlo con le seguenti righe nel 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 ulteriori modifiche 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 delle istanze dell'app. Quando viene generato un token, la libreria carica l'identificatore e i dati di configurazione su Firebase. Se vuoi ottenere un'attivazione esplicita prima di utilizzare il token, puoi impedire la generazione al momento della configurazione disattivando FCM (e Analytics su Android). 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::SetRegistrationOnInitEnabled(true);

Nota: SetTokenRegistrationOnInitEnabled è deprecato; utilizza SetRegistrationOnInitEnabled.

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

Messaggi con deep link su Android

FCM consente di inviare messaggi contenenti un deep link alla tua app. Per ricevere messaggi contenenti un deep link, devi aggiungere un nuovo filtro per intent all'attività che gestisce i deep link per la tua app. Il filtro per intent deve rilevare i deep link del tuo dominio. Se i tuoi messaggi non contengono un deep link, 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 il filtro per intent più flessibile. 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 avvierà l'attività con questo filtro per intent per gestire il link.

Passaggi successivi

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

• Invia messaggi ai dispositivi
• Ricevi messaggi in un'app C++
• Invia messaggi agli argomenti