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 ogni piattaforma.
Configura Firebase e l'SDK FCM
Android
Se non l'hai già fatto, aggiungi Firebase al tuo progetto C++.
Nelle istruzioni di configurazione collegate, rivedi il dispositivo e l'app requisiti per l'utilizzo dell'SDK C++ Firebase, tra cui consiglio di utilizzare CMake per creare la tua app.
Nel file
build.gradle
a livello di progetto, assicurati di includere Repository Maven di Google inbuildscript
eallprojects
sezioni.
Creare un oggetto App Firebase, passando nell'ambiente JNI e Attività:
app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);
Definisci una classe che implementi l'interfaccia
firebase::messaging::Listener
.Inizializza FCM passando l'app e un Listener creato:
::firebase::messaging::Initialize(app, listener);
Le app che si basano sull'SDK Google Play Services devono verificare sul dispositivo la presenza di un APK di Google Play Services compatibile prima di accedere alle funzionalità. Per saperne di più, consulta Verifica la presenza di APK Google Play Services.
iOS+
- Se non lo hai già fatto,
aggiungi Firebase al tuo progetto C++. Poi,
per configurare il tuo progetto per FCM:
- Nel podfile del progetto, aggiungi la dipendenza FCM:
pod 'FirebaseMessaging'
- Trascina i framework
firebase.framework
efirebase_messaging.framework
nel progetto Xcode dall'SDK Firebase C++.
- Nel podfile del progetto, aggiungi la dipendenza FCM:
Carica la chiave di autenticazione del servizio APN su Firebase. Se non disponi già di una chiave di autenticazione del servizio APN, assicurati di crearne una nella Centro membri per gli sviluppatori Apple.
-
All'interno del progetto nella console Firebase, seleziona l'icona a forma di ingranaggio, seleziona Impostazioni progetto e poi la scheda Cloud Messaging.
-
In Chiave di autenticazione del servizio APN in Configurazione app per iOS, fai clic sul pulsante Carica.
-
Vai alla posizione in cui hai salvato la chiave, selezionala e fai clic su Apri. Aggiungi l'ID chiave per la chiave (disponibile nel Centro membri Apple Developer) e fai clic su Carica.
-
Configura il tuo progetto Xcode per abilitare le notifiche push:
- Seleziona il progetto dall'Area di navigazione.
- Seleziona la destinazione del progetto dall'area di modifica.
Seleziona la scheda Generali dall'area Editor.
- Scorri verso il basso fino a Framework e librerie collegati, quindi fai clic su il pulsante + per aggiungere framework.
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 è richiesti da questa libreria.
Seleziona la scheda Funzionalità dall'area Editor.
- Imposta Notifiche push su On.
- Scorri verso il basso fino a Modalità in background, quindi imposta l'opzione su On.
- Seleziona Notifiche remote in Modalità in background.
Crea un oggetto app Firebase:
app = ::firebase::App::Create(::firebase::AppOptions());
Definisci una classe che implementa
firebase::messaging::Listener
a riga di comando.Inizializza Firebase Cloud Messaging passando l'app e un Listener creato:
::firebase::messaging::Initialize(app, listener);
Accedere al token di registrazione del dispositivo
All'inizializzazione della libreria Firebase Cloud Messaging, viene richiesto un token di registrazione per l'istanza dell'app client. L'app riceverà il token con
Callback OnTokenReceived
, che deve essere definito nella classe che implementa
firebase::messaging::Listener
.
Se vuoi scegliere come target quel dispositivo specifico, dovrai accedere 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 inoltrato 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 sostituire il 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 quando l'app è in background hanno i contenuti del loro campo di notifica utilizzati per compilare la notifica della barra delle app, ma questi contenuti non verranno comunicati a FCM. Vale a dire che
Message::notification
sarà un valore nullo.
In sintesi:
Stato dell'app | Notifica | Dati | Entrambe |
---|---|---|---|
Primo piano | OnMessageReceived |
OnMessageReceived |
OnMessageReceived |
Contesto | Barra delle app | OnMessageReceived |
Notifica: barra delle applicazioni Dati: sotto forma di extra dell'intento. |
Gestione personalizzata dei messaggi su Android
Per impostazione predefinita, le notifiche inviate all'app vengono trasmesse a
::firebase::messaging::Listener::OnMessageReceived
, ma in alcuni casi potresti
voler sostituire il comportamento predefinito. Per farlo su Android devi:
e scrivere classi personalizzate che si estendono
com.google.firebase.messaging.cpp.ListenerService
e aggiornare
AndroidManifest.xml
del progetto.
Sostituisci i metodi ListenerService
.
ListenerService
è la classe Java che intercetta i messaggi in arrivo inviati all'app e li inoltra alla libreria C++. Quando l'app è in primo piano
(o quando è 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 ListenerService
predefinito di FCM:
import com.google.firebase.messaging.cpp.ListenerService; class MyListenerService extends ListenerService {
Sostituendo il metodo ListenerService.onMessageReceived
, puoi eseguire azioni in base all'oggetto RemoteMessage ricevuto e recuperare 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
offre anche alcuni altri metodi, che vengono utilizzati con minore frequenza.
Anche questi possono essere sostituiti. Per ulteriori informazioni, consulta la documentazione di riferimento di 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 scritti, i tipi personalizzati devono essere inclusi nel
AndroidManifest.xml
affinché vengano applicati. 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 una AndroidManifest.xml
che dichiara il ListenerService
predefinito di FCM. Questo file manifest
vengono normalmente uniti al manifest specifico del progetto, che è il modo in cui
ListenerService
può essere eseguito. Questo ListenerService
deve essere sostituito con
il servizio di ascolto cusom. Si ottiene rimuovendo il valore predefinito
ListenerService
e aggiungere il servizio personalizzato, operazione che può essere eseguita con
segui le righe del file AndroidManifest.xml
del progetto:
<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++ (dalla 7.1.0 in poi) 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>
Impedire l'inizializzazione automatica
FCM genera un token di registrazione per il targeting per dispositivo.
Quando viene generato un token, la libreria carica su Firebase i dati di configurazione e l'identificatore. Se vuoi ricevere un'email esplicita
prima di utilizzare il token, puoi impedire la generazione in fase di configurazione
disattivazione di 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 rimane invariato dopo i riavvii dell'app.
Gestione di Messaggi con link diretti su Android
FCM consente di inviare 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 rilevare 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 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 specificati, 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 di downstream e di argomento con Firebase. Per saperne di più, guarda la dimostrazione di questa funzionalità nel esempio di avvio rapido che puoi scaricare, eseguire e esaminare.
Per aggiungere altri comportamenti più avanzati alla tua app, consulta le guide per l'invio messaggi da un server di app:
Tieni presente che avrai bisogno di implementazione del server per fare uso le funzionalità di machine learning.