Firebase onMessageRicevuto non chiamato quando l'app in background

Sto lavorando con Firebase e sto testando l'invio di notifiche alla mia app dal mio server mentre l'app è in background. La notifica viene inviata correttamente, viene persino visualizzata nel centro notifiche del dispositivo, ma quando viene visualizzata la notifica o anche se faccio clic su di essa, il metodo onMessageReceived all'interno del mio FCMessagingService non viene mai chiamato.

Quando l'ho provato mentre la mia app era in primo piano, veniva chiamato il metodo onMessageReceived e tutto funzionava bene. Il problema si verifica quando l'app è in esecuzione in background.

È questo comportamento previsto o esiste un modo per risolverlo?

Ecco il mio FBMessagingService:

import android.util.Log;

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class FBMessagingService extends FirebaseMessagingService {

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        Log.i("PVL", "MESSAGE RECEIVED!!");
        if (remoteMessage.getNotification().getBody() != null) {
            Log.i("PVL", "RECEIVED MESSAGE: " + remoteMessage.getNotification().getBody());
        } else {
            Log.i("PVL", "RECEIVED MESSAGE: " + remoteMessage.getData().get("message"));
        }
    }
}

Funziona come previsto, i messaggi di notifica vengono recapitati al callback onMessageReceived solo quando l'app è in primo piano. Se la tua app è in background o chiusa, nel centro di notifica viene visualizzato un messaggio di notifica e tutti i dati di quel messaggio vengono passati all'intento che viene avviato a seguito del tocco dell'utente sulla notifica.

È possibile specificare una click_action per indicare l'intenzione che deve essere avviata quando la notifica viene toccata dall'utente. L'attività principale viene utilizzata se non viene specificata alcuna click_action.

Quando viene avviato l'intento è possibile utilizzare il

getIntent().getExtras();

per recuperare un set che includa tutti i dati inviati insieme al messaggio di notifica.

Per ulteriori informazioni sul messaggio di notifica, consultare la documentazione .

Rimuoverenotification completamente il campo dalla richiesta del server. Invia solodata e gestiscilo onMessageReceived()altrimentionMessageReceived() non verrai attivato quando l'app è in background o uccisa.

Non dimenticare di includere il "priority": "high"campo nella richiesta di notifica. Secondo la documentazione: i messaggi di dati vengono inviati con una priorità normale, quindi non arriveranno all'istante; potrebbe anche essere il problema.

Ecco cosa sto inviando dal server

{
  "data":{
    "id": 1,
    "missedRequests": 5
    "addAnyDataHere": 123
  },
  "to": "fhiT7evmZk8:APA91bFJq7Tkly4BtLRXdYvqHno2vHCRkzpJT8QZy0TlIGs......",
  "priority": "high"
}

Quindi puoi ricevere i tuoi dati in onMessageReceived(RemoteMessage message)questo modo .... diciamo che devo ottenere un ID

Object obj = message.getData().get("id");
        if (obj != null) {
            int id = Integer.valueOf(obj.toString());
        }

questo metodo handleIntent () è stato ammortizzato, quindi la gestione di una notifica può essere eseguita come di seguito:

1. Stato in primo piano: il clic della notifica passerà all'attività dell'intento in sospeso che si sta fornendo durante la creazione di una notifica in modo pro- grammatico in quanto generalmente creata con il payload di dati della notifica.

2. Background / Killed State - Qui, il sistema stesso crea una notifica basata sul payload della notifica e facendo clic su tale notifica si accederà all'attività di avvio dell'applicazione in cui è possibile recuperare facilmente i dati Intent in uno dei metodi del ciclo di vita.

Ecco concetti più chiari sul messaggio Firebase. L'ho trovato dal loro team di supporto.

Firebase ha tre tipi di messaggi :

Messaggi di notifica : il messaggio di notifica funziona in background o in primo piano. Quando l'app è in background, i messaggi di notifica vengono recapitati nella barra delle applicazioni. Se l'app è in primo piano, i messaggi vengono gestiti onMessageReceived()o didReceiveRemoteNotificationrichiamate. Questi sono essenzialmente i cosiddetti messaggi display.

Messaggi di dati : sulla piattaforma Android, il messaggio di dati può funzionare in background e in primo piano. Il messaggio di dati verrà gestito da onMessageReceived (). Una nota specifica della piattaforma qui sarebbe: Su Android, il payload dei dati può essere recuperato nell'intento utilizzato per avviare l'attività. Per elaborare, se lo hai "click_action":"launch_Activity_1", puoi recuperare questo intento getIntent()solo da Activity_1.

Messaggi con payload di notifica e dati : quando sono in background, le app ricevono il payload di notifica nell'area di notifica e gestiscono il payload di dati solo quando l'utente tocca la notifica. In primo piano, l'app riceve un oggetto messaggio con entrambi i payload disponibili. In secondo luogo, il parametro click_action viene spesso utilizzato nel payload delle notifiche e non nel payload dei dati. Se utilizzato all'interno del payload di dati, questo parametro verrebbe trattato come coppia chiave-valore personalizzata e pertanto sarà necessario implementare la logica personalizzata affinché funzioni come previsto.

Inoltre, ti consiglio di usare il metodo onMessageReceived (vedi messaggio Dati) per estrarre il pacchetto di dati. Dalla tua logica, ho controllato l'oggetto bundle e non ho trovato il contenuto previsto dei dati. Ecco un riferimento a un caso simile che potrebbe fornire maggiore chiarezza.

Dal lato server, la notifica Firebase dovrebbe essere il seguente formato :

Il lato server deve inviare l' oggetto "notifica" . Mancanza di oggetto "notifica" nel mio TargetActivitynon ho ricevuto il messaggio utilizzando getIntent().

Il formato del messaggio corretto è indicato di seguito:

{
 "data": {
  "body": "here is body",
  "title": "Title"
 },
"notification": {
  "body": "here is body",
  "title": "Title",
  "click_action": "YOUR_ACTION"
 },
 "to": "ffEseX6vwcM:APA91bF8m7wOF MY FCM ID 07j1aPUb"
}

Ecco concetti più chiari sul messaggio Firebase. L'ho trovato dal loro team di supporto.

Per maggiori informazioni visita il mio questo thread e questo thread

Ho avuto lo stesso problema. È più semplice utilizzare il "messaggio dati" anziché la "notifica". Il messaggio di dati carica sempre la classe onMessageReceived.

In quella classe puoi effettuare la tua notifica con il notificationbuilder.

Esempio:

 @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        sendNotification(remoteMessage.getData().get("title"),remoteMessage.getData().get("body"));
    }

    private void sendNotification(String messageTitle,String messageBody) {
        Intent intent = new Intent(this, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this,0 /* request code */, intent,PendingIntent.FLAG_UPDATE_CURRENT);

        long[] pattern = {500,500,500,500,500};

        Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);

        NotificationCompat.Builder notificationBuilder = (NotificationCompat.Builder) new NotificationCompat.Builder(this)
                .setSmallIcon(R.drawable.ic_stat_name)
                .setContentTitle(messageTitle)
                .setContentText(messageBody)
                .setAutoCancel(true)
                .setVibrate(pattern)
                .setLights(Color.BLUE,1,1)
                .setSound(defaultSoundUri)
                .setContentIntent(pendingIntent);

        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        notificationManager.notify(0 /* ID of notification */, notificationBuilder.build());
    }

Secondo la documentazione di Firebase Cloud Messaging: se l'attività è in primo piano, verrà chiamato onMessageReceived. Se l'attività è in background o chiusa, nel centro di notifica viene visualizzato un messaggio di notifica per l'attività di avvio delle app. Puoi chiamare la tua attività personalizzata al clic della notifica se l'app è in background chiamando l'API del servizio di riposo per la messaggistica Firebase come:

URL- https://fcm.googleapis.com/fcm/send

Tipo di metodo: POST

Header- Content-Type:application/json
Authorization:key=your api key

Corpo / Carico utile:

{ "notification": {
    "title": "Your Title",
    "text": "Your Text",
     "click_action": "OPEN_ACTIVITY_1" // should match to your intent filter
  },
    "data": {
    "keyname": "any value " //you can get this data as extras in your activity and this data is optional
    },
  "to" : "to_id(firebase refreshedToken)"
} 

E con questo nella tua app puoi aggiungere il codice qui sotto nella tua attività da chiamare:

<intent-filter>
                <action android:name="OPEN_ACTIVITY_1" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>

Metodo onMessageReceived (RemoteMessage remoteMessage) chiamato in base ai seguenti casi.

• Risposta FCM Con notifica e blocco dati :

{
  
"to": "device token list",
  "notification": {
    "body": "Body of Your Notification",
    "title": "Title of Your Notification"
  },
  "data": {
    "body": "Body of Your Notification in Data",
    "title": "Title of Your Notification in Title",
    "key_1": "Value for key_1",
    "image_url": "www.abc.com/xyz.jpeg",
    "key_2": "Value for key_2"
  }
}

1. App in primo piano:

onMessageReceived (RemoteMessage remoteMessage) chiamato, mostra LargeIcon e BigPicture nella barra di notifica. Siamo in grado di leggere il contenuto sia dalla notifica che dal blocco dati

2. App in background:

onMessageReceived (RemoteMessage remoteMessage) non chiamato, la barra delle applicazioni riceverà il messaggio e leggerà il corpo e il titolo dal blocco di notifica e mostrerà il messaggio e il titolo predefiniti nella barra di notifica.

• Risposta FCM Con solo blocco dati :

In questo caso, rimuovere i blocchi di notifica da json

{
  
"to": "device token list",
  "data": {
    "body": "Body of Your Notification in Data",
    "title": "Title of Your Notification in Title",
    "key_1": "Value for key_1",
    "image_url": "www.abc.com/xyz.jpeg",
    "key_2": "Value for key_2"
  }
}

Soluzione per chiamare onMessageReceived ()

1. App in primo piano:

onMessageReceived (RemoteMessage remoteMessage) chiamato, mostra LargeIcon e BigPicture nella barra di notifica. Siamo in grado di leggere il contenuto sia dalla notifica che dal blocco dati

2. App in background:

onMessageReceived (RemoteMessage remoteMessage) chiamato, la barra delle applicazioni non riceverà il messaggio perché la chiave di notifica non è nella risposta. Mostra LargeIcon e BigPicture nella barra delle notifiche

Codice

 private void sendNotification(Bitmap bitmap,  String title, String 
    message, PendingIntent resultPendingIntent) {

    NotificationCompat.BigPictureStyle style = new NotificationCompat.BigPictureStyle();
    style.bigPicture(bitmap);

    Uri defaultSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);

    NotificationManager notificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
    String NOTIFICATION_CHANNEL_ID = mContext.getString(R.string.default_notification_channel_id);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel notificationChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, "channel_name", NotificationManager.IMPORTANCE_HIGH);

        notificationManager.createNotificationChannel(notificationChannel);
    }
    Bitmap iconLarge = BitmapFactory.decodeResource(mContext.getResources(),
            R.drawable.mdmlogo);
    NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(mContext, NOTIFICATION_CHANNEL_ID)
            .setSmallIcon(R.drawable.mdmlogo)
            .setContentTitle(title)
            .setAutoCancel(true)
            .setSound(defaultSound)
            .setContentText(message)
            .setContentIntent(resultPendingIntent)
            .setStyle(style)
            .setLargeIcon(iconLarge)
            .setWhen(System.currentTimeMillis())
            .setPriority(Notification.PRIORITY_MAX)
            .setChannelId(NOTIFICATION_CHANNEL_ID);


    notificationManager.notify(1, notificationBuilder.build());


}

Link di riferimento:

https://firebase.google.com/docs/cloud-messaging/android/receive

Ho avuto lo stesso problema. Se l'app è in primo piano, attiva il mio servizio in background dove posso aggiornare il mio database in base al tipo di notifica. Tuttavia, l'app passa in secondo piano: il servizio di notifica predefinito si occuperà di mostrare la notifica all'utente.

Ecco la mia soluzione per identificare l'app in background e attivare il servizio in background,

public class FirebaseBackgroundService extends WakefulBroadcastReceiver {

  private static final String TAG = "FirebaseService";

  @Override
  public void onReceive(Context context, Intent intent) {
    Log.d(TAG, "I'm in!!!");

    if (intent.getExtras() != null) {
      for (String key : intent.getExtras().keySet()) {
        Object value = intent.getExtras().get(key);
        Log.e("FirebaseDataReceiver", "Key: " + key + " Value: " + value);
        if(key.equalsIgnoreCase("gcm.notification.body") && value != null) {
          Bundle bundle = new Bundle();
          Intent backgroundIntent = new Intent(context, BackgroundSyncJobService.class);
          bundle.putString("push_message", value + "");
          backgroundIntent.putExtras(bundle);
          context.startService(backgroundIntent);
        }
      }
    }
  }
}

Nel manifest.xml

<receiver android:exported="true" android:name=".FirebaseBackgroundService" android:permission="com.google.android.c2dm.permission.SEND">
            <intent-filter>
                <action android:name="com.google.android.c2dm.intent.RECEIVE" />
            </intent-filter>
        </receiver>

Ho provato questa soluzione nell'ultima versione di Android 8.0. Grazie

Se l'app è in modalità background o inattiva (uccisa) e fai clic su Notifica , dovresti controllare il payload in LaunchScreen (nel mio caso la schermata di avvio è MainActivity.java).

Quindi in MainActivity.java su onCreate controlla gli extra :

    if (getIntent().getExtras() != null) {
        for (String key : getIntent().getExtras().keySet()) {
            Object value = getIntent().getExtras().get(key);
            Log.d("MainActivity: ", "Key: " + key + " Value: " + value);
        }
    }

Ignora il handleIntentMetodo delle FirebaseMessageServiceopere per me.

qui il codice in C # (Xamarin)

public override void HandleIntent(Intent intent)
{
    try
    {
        if (intent.Extras != null)
        {
            var builder = new RemoteMessage.Builder("MyFirebaseMessagingService");

            foreach (string key in intent.Extras.KeySet())
            {
                builder.AddData(key, intent.Extras.Get(key).ToString());
            }

            this.OnMessageReceived(builder.Build());
        }
        else
        {
            base.HandleIntent(intent);
        }
    }
    catch (Exception)
    {
        base.HandleIntent(intent);
    }
}

e questo è il codice in Java

public void handleIntent(Intent intent)
{
    try
    {
        if (intent.getExtras() != null)
        {
            RemoteMessage.Builder builder = new RemoteMessage.Builder("MyFirebaseMessagingService");

            for (String key : intent.getExtras().keySet())
            {
                builder.addData(key, intent.getExtras().get(key).toString());
            }

            onMessageReceived(builder.build());
        }
        else
        {
            super.handleIntent(intent);
        }
    }
    catch (Exception e)
    {
        super.handleIntent(intent);
    }
}

Per impostazione predefinita, l' attività di avvio nella tua app verrà avviata quando l'app è in background e fai clic sulla notifica, se hai qualche parte di dati con la tua notifica puoi gestirla nella stessa attività come segue,

if(getIntent().getExtras()! = null){
  //do your stuff
}else{
  //do that you normally do
}

Se l'app è in background Fire-base mediante notifica di gestione predefinita Ma se vogliamo una nostra notifica personalizzata, dobbiamo cambiare il nostro lato server, che è responsabile per l'invio dei nostri dati personalizzati (payload dei dati)

Rimuovere completamente il payload di notifica dalla richiesta del server. Invia solo dati e gestiscili in onMessageReceived (), altrimenti onMessageReceived non verrà attivato quando l'app è in background o uccisa.

ora, il formato del codice lato server è simile a,

{
  "collapse_key": "CHAT_MESSAGE_CONTACT",
  "data": {
    "loc_key": "CHAT_MESSAGE_CONTACT",
    "loc_args": ["John Doe", "Contact Exchange"],
    "text": "John Doe shared a contact in the group Contact Exchange",
    "custom": {
      "chat_id": 241233,
      "msg_id": 123
    },
    "badge": 1,
    "sound": "sound1.mp3",
    "mute": true
  }
}

NOTA : vedere questa riga nel codice
"testo" sopra : "John Doe ha condiviso un contatto nel gruppo Scambio di contatti" nel payload dei dati, è necessario utilizzare il parametro "testo" anziché i parametri "corpo" o "messaggio" per la descrizione del messaggio o qualsiasi altra cosa vuoi usare il testo.

onMessageReceived ()

@Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        Log.e(TAG, "From: " + remoteMessage.getData().toString());

        if (remoteMessage == null)
            return;

        // Check if message contains a data payload.
        if (remoteMessage.getData().size() > 0) {
           /* Log.e(TAG, "Data Payload: " + remoteMessage.getData().toString());*/
            Log.e(TAG, "Data Payload: " + remoteMessage);

            try {

                Map<String, String> params = remoteMessage.getData();
                JSONObject json = new JSONObject(params);
                Log.e("JSON_OBJECT", json.toString());


                Log.e(TAG, "onMessageReceived: " + json.toString());

                handleDataMessage(json);
            } catch (Exception e) {
                Log.e(TAG, "Exception: " + e.getMessage());
            }
        }
    }

Basta chiamare questo nel metodo onCreate di MainActivity:

if (getIntent().getExtras() != null) {
           // Call your NotificationActivity here..
            Intent intent = new Intent(MainActivity.this, NotificationActivity.class);
            startActivity(intent);
        }

secondo la soluzione di t3h Exi vorrei pubblicare qui il codice pulito. Basta inserirlo in MyFirebaseMessagingService e tutto funziona bene se l'app è in modalità background. Devi almeno compilare com.google.firebase: firebase-messaging: 10.2.1

 @Override
public void handleIntent(Intent intent)
{
    try
    {
        if (intent.getExtras() != null)
        {
            RemoteMessage.Builder builder = new RemoteMessage.Builder("MyFirebaseMessagingService");

            for (String key : intent.getExtras().keySet())
            {
                builder.addData(key, intent.getExtras().get(key).toString());
            }



           onMessageReceived(builder.build());
        }
        else
        {
            super.handleIntent(intent);
        }
    }
    catch (Exception e)
    {
        super.handleIntent(intent);
    }
}

Prova questo:

public void handleIntent(Intent intent) {
    try {
        if (intent.getExtras() != null) {
            RemoteMessage.Builder builder = new RemoteMessage.Builder("MyFirebaseMessagingService");
            for (String key : intent.getExtras().keySet()) {
            builder.addData(key, intent.getExtras().get(key).toString());
        }
            onMessageReceived(builder.build());
        } else {
            super.handleIntent(intent);
        }
    } catch (Exception e) {
        super.handleIntent(intent);
    }
}

Ho riscontrato questo problema (l'app non vuole aprirsi quando si fa clic su notifica se l'app è in background o chiusa) e il problema non è valido click_actionnel corpo della notifica, provare a rimuoverlo o modificarlo in qualcosa di valido.

Il punto che merita di essere messo in evidenza è che devi usare il messaggio dati - solo chiave dati - per far chiamare il gestore onMessageReceived anche quando l'app è in background. Non dovresti avere altre chiavi di messaggi di notifica nel tuo payload, altrimenti il ​​gestore non verrà attivato se l'app è in background.

È menzionato (ma non così enfatizzato nella documentazione FCM) qui:

https://firebase.google.com/docs/cloud-messaging/concept-options#notifications_and_data_messages

Usa il tuo app server e l'API del server FCM: imposta solo la chiave dati . Può essere pieghevole o non pieghevole.

Il backend con cui sto lavorando sta usando i messaggi di notifica e non i messaggi di dati. Quindi, dopo aver letto tutte le risposte, ho cercato di recuperare gli extra dal pacchetto dell'intento che viene all'attività avviata. Ma non importa da quali chiavi ho cercato di recuperaregetIntent().getExtras(); , il valore era sempre nullo.

Tuttavia, ho finalmente trovato il modo di inviare dati utilizzando i messaggi di notifica e recuperarli dall'intento.

La chiave qui è aggiungere il payload di dati al messaggio di notifica.

Esempio:

{
    "data": {
        "message": "message_body",
        "title": "message_title"
    },
    "notification": {
        "body": "test body",
        "title": "test title"
    },
    "to": "E4An.."
}

Dopo aver fatto ciò, sarai in grado di ottenere le tue informazioni in questo modo:

intent.getExtras().getString("title") sarà message_title

e intent.getExtras().getString("message") lo saràmessage_body

Riferimento

Se il tuo problema è legato alla visualizzazione di Big Image, ad esempio se stai inviando una notifica push con un'immagine dalla console di Firebase e visualizza l'immagine solo se l'app in primo piano. La soluzione a questo problema è inviare un messaggio push con solo campo dati. Qualcosa come questo:

{ "data": { "image": "https://static.pexels.com/photos/4825/red-love-romantic-flowers.jpg", "message": "Firebase Push Message Using API" "AnotherActivity": "True" }, "to" : "device id Or Device token" }

Quando il messaggio viene ricevuto e l'app è in background, la notifica viene inviata agli intenti extra dell'attività principale.

È possibile verificare il valore aggiuntivo nella funzione oncreate () o onresume () dell'attività principale.

Puoi controllare i campi come dati, tabella ecc. (Quello specificato nella notifica)

per esempio ho inviato usando i dati come chiave

public void onResume(){
    super.onResume();
    if (getIntent().getStringExtra("data")!=null){
            fromnotification=true;
            Intent i = new Intent(MainActivity.this, Activity2.class);
            i.putExtra("notification","notification");
            startActivity(i);
        }

}

Stavo avendo lo stesso problema e ho approfondito ulteriormente questo aspetto. Quando l'app è in background, un messaggio di notifica viene inviato nell'area di notifica , MA viene inviato un messaggio di dati a onMessageReceived()
Vedere https://firebase.google.com/docs/cloud-messaging/downstream#monitor-token-generation_3
e https://github.com/firebase/quickstart-android/blob/master/messaging/app/src/main/java/com/google/firebase/quickstart/fcm/MyFirebaseMessagingService.java

Per garantire che il messaggio che stai inviando, i documenti dicono: " Usa il tuo app server e l'API del server FCM: imposta solo la chiave dati. Può essere comprimibile o non comprimibile " .
Vedi https://firebase.google.com/ docs / cloud-messaging / concept-options # notifications_and_data_messages

Esistono due tipi di messaggi: messaggi di notifica e messaggi di dati. Se si invia solo un messaggio di dati, cioè senza oggetto di notifica nella stringa del messaggio. Sarebbe invocato quando l'app in background.

Controlla la risposta di @Mahesh Kavathiya. Per il mio caso, nel codice server ha solo questo:

{
"notification": {
  "body": "here is body",
  "title": "Title",
 },
 "to": "sdfjsdfonsdofoiewj9230idsjkfmnkdsfm"
}

Devi cambiare in:

{
 "data": {
  "body": "here is body",
  "title": "Title",
  "click_action": "YOUR_ACTION"
 },
"notification": {
  "body": "here is body",
  "title": "Title"
 },
 "to": "sdfjsdfonsdofoiewj9230idsjkfmnkdsfm"
}

Quindi, nel caso in cui l'app in Background, l'intento di attività predefinito extra ottenga "dati"

In bocca al lupo!

Sostituisci il metodo OnCreate di FirebaseMessagingService. Viene chiamato quando l'app è in background:

public override void OnCreate()
{
    // your code
    base.OnCreate();
}

Esistono 2 tipi di notifiche push di Firebase :

1- Messaggio di notifica (Visualizza messaggio) -> - 1.1 Se si sceglie questa variante, il sistema operativo crea automaticamente una notifica se l'app è in background e passa i dati in intent. Quindi spetta al client gestire questi dati.

- 1.2 Se l'app è in primo piano, la notifica verrà ricevuta tramite callback-functionin FirebaseMessagingServicee spetta al client gestirla.

2- Messaggi di dati (fino a 4k di dati) -> Questi messaggi vengono utilizzati per inviare solo dati al client (in silenzio) e spetta al client gestirli per entrambi i casi in background / in primo piano tramite la funzione di callback in FirebaseMessagingService

Questo è secondo i documenti ufficiali: https://firebase.google.com/docs/cloud-messaging/concept-options