Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

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

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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 impostazioni aggiuntive necessarie per ciascuna piattaforma.

Configura Firebase e FCM SDK

Androide

  1. Se non lo 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 di Firebase C++ SDK, incluso il consiglio di utilizzare CMake per creare l'app.

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

  2. Crea un oggetto App Firebase, passando nell'ambiente JNI e nell'attività:

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

  3. Definire una classe che implementi l' 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 dei servizi di Google Play dovrebbero verificare la presenza di un APK dei servizi di Google Play compatibile sul dispositivo prima di accedere alle funzionalità. Per ulteriori informazioni, consulta Verifica dell'APK dei servizi di Google Play .

iOS+

  1. È necessario un certificato APN valido. Se non ne hai già uno, assicurati di crearne uno nell'Apple Developer Member Center .
  2. Se non lo hai già fatto, aggiungi Firebase al tuo progetto C++ . Quindi, per impostare il tuo progetto per FCM:
    1. Nel Podfile del tuo progetto, aggiungi la dipendenza FCM:
      pod 'FirebaseMessaging'
    2. Trascina i firebase.framework e firebase_messaging.framework nel tuo progetto Xcode dall'SDK C++ di Firebase .
  3. Configura il tuo progetto Xcode per abilitare le notifiche push:

    1. Selezionare il progetto dall'area Navigatore .
    2. Selezionare la destinazione del progetto dall'area Editor .
    3. Selezionare la scheda Generale dall'area Editor .

      1. Scorri verso il basso fino a Framework e librerie collegate , quindi fai clic sul pulsante + per aggiungere framework.
      2. Nella finestra che appare, scorri fino a UserNotifications.framework , fai clic su quella voce, quindi fai clic su Aggiungi .

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

    4. Selezionare la scheda Funzionalità dall'area Editor .

      1. Attiva le notifiche push .
      2. Scorri verso il basso fino a Modalità sfondo , quindi attivalo .
      3. Seleziona Notifiche remote in Modalità sfondo .
  4. Crea un oggetto App Firebase:

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

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

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

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

Accedi al token di registrazione del dispositivo

Dopo 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 dovrebbe essere definito nella classe che implementa firebase::messaging::Listener .

Se vuoi scegliere come target quel dispositivo specifico, avrai bisogno dell'accesso a questo token.

Nota sulla consegna dei messaggi su Android

Quando l'app non è affatto in esecuzione e un utente tocca una notifica, il messaggio non viene, per impostazione predefinita, instradato 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 alla richiamata della libreria C++, è necessario eseguire l'override del metodo onNewIntent in Activity e passare l' 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 hanno il contenuto del relativo campo di notifica utilizzato per popolare la notifica della barra delle applicazioni, ma il contenuto della notifica non verrà comunicato a FCM. Cioè, Message::notification sarà un null.

In sintesi:

Stato dell'app Notifica Dati Tutti e due
Primo piano OnMessageReceived OnMessageReceived OnMessageReceived
Sfondo Area di notifica OnMessageReceived Notifica: barra delle applicazioni
Dati: in extra dell'intento.

Gestione dei messaggi personalizzata su Android

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

Sostituisci i metodi ListenerService .

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

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

class MyListenerService extends ListenerService {

Sostituendo il metodo ListenerService.onMessageReceived , puoi eseguire azioni basate sull'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 alcuni altri metodi che vengono usati meno frequentemente. Anche questi possono essere sovrascritti, per ulteriori informazioni vedere 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 che le classi personalizzate sono state scritte, 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> , 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 ListenerService di default di FCM. Questo manifest viene normalmente unito al manifest specifico del progetto, che è il modo in cui ListenerService è in grado di essere eseguito. Questo ListenerService deve essere sostituito con il servizio di ascolto csom. Ciò si ottiene rimuovendo il ListenerService predefinito e aggiungendo il servizio personalizzato, che può essere eseguito con le seguenti righe del file AndroidManifest.xml dei 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 di Firebase C++ SDK (dalla 7.1.0 in poi) 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 del dispositivo. Quando viene generato un token, la libreria carica l'identificatore e i dati di configurazione su Firebase. Se desideri ottenere un consenso esplicito prima di utilizzare il token, puoi impedire la generazione in fase di configurazione disabilitando FCM (e su Android, Analytics). Per fare ciò, aggiungi un valore di metadati al tuo Info.plist (non al tuo GoogleService-Info.plist ) su piattaforme Apple o al tuo AndroidManifest.xml su Android:

Androide

<?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>

Veloce

FirebaseMessagingAutoInitEnabled = NO

Per riattivare FCM, puoi effettuare una chiamata di runtime:

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

Questo valore persiste tra i riavvii dell'app una volta impostato.

FCM consente di inviare messaggi contenenti un collegamento diretto alla tua app. Per ricevere messaggi che contengono un link diretto, devi aggiungere un nuovo filtro intento all'attività che gestisce i link diretti per la tua app. Il filtro dell'intento dovrebbe catturare i link diretti 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 più flessibile il filtro dell'intento. Per 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 collegamento allo schema e all'host specificati, la tua app avvierà l'attività con questo filtro di intenti per gestire il collegamento.

Prossimi passi

Dopo aver configurato l'app client, sei pronto per inviare messaggi downstream e di argomento con Firebase. Per ulteriori informazioni, vedere questa funzionalità dimostrata nell'esempio di avvio rapido che è possibile scaricare, eseguire ed esaminare.

Per aggiungere un altro comportamento più avanzato alla tua app, consulta le guide per l'invio di messaggi da un server di app:

Tieni presente che avrai bisogno di un'implementazione del server per utilizzare queste funzionalità.