wake-up-neo.com

Firebase onMessageReceived wird nicht aufgerufen, wenn die App im Hintergrund läuft

Ich arbeite mit Firebase und teste das Senden von Benachrichtigungen von meinem Server an meine App, während sich die App im Hintergrund befindet. Die Benachrichtigung wird erfolgreich gesendet. Sie wird sogar im Benachrichtigungscenter des Geräts angezeigt. Wenn die Benachrichtigung jedoch angezeigt wird oder sogar darauf geklickt wird, wird die onMessageReceived-Methode in meinem FCMessagingService nie aufgerufen. 

Als ich dies getestet habe, während sich meine App im Vordergrund befand, wurde die Methode onMessageReceived aufgerufen, und alles funktionierte einwandfrei. Das Problem tritt auf, wenn die App im Hintergrund ausgeführt wird.

Ist das beabsichtigte Verhalten oder gibt es eine Möglichkeit, das Problem zu beheben?

Hier ist mein 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"));
        }
    }
}
172
Cyogenos

Dies funktioniert wie beabsichtigt. Benachrichtigungsnachrichten werden nur dann an Ihren onMessageReceived-Rückruf übermittelt, wenn sich Ihre App im Vordergrund befindet. Wenn sich Ihre App im Hintergrund befindet oder geschlossen ist, wird im Benachrichtigungscenter eine Benachrichtigungsmeldung angezeigt, und alle Daten dieser Nachricht werden an die Absicht übergeben, die als Ergebnis des Benutzerabbruchs auf die Benachrichtigung gestartet wird.

Sie können eine click_action angeben, um die Absicht anzugeben, die gestartet werden soll, wenn der Benutzer auf die Benachrichtigung tippt. Die Hauptaktivität wird verwendet, wenn keine click_action angegeben ist.

Wenn die Absicht gestartet ist, können Sie die verwenden

getIntent().getExtras();

ein Set abrufen, das alle mit der Benachrichtigungsnachricht gesendeten Daten enthält.

Weitere Informationen zur Benachrichtigung finden Sie unter docs .

105
Arthur Thompson

Entferne das notification-Feld vollständig von deiner Serveranfrage. Senden Sie nur dataund behandeln Sie es in onMessageReceived(). Andernfalls wird Ihre onMessageReceived() nicht ausgelöst, wenn sich die App im Hintergrund befindet oder beendet wird.

Vergessen Sie nicht, das "priority": "high"-Feld in Ihre Benachrichtigungsanfrage aufzunehmen. Laut Dokumentation: Datennachrichten werden mit einer normalen Priorität gesendet, daher werden sie nicht sofort ankommen. Es könnte auch das Problem sein. 

Hier sende ich vom Server

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

So können Sie Ihre Daten in onMessageReceived(RemoteMessage message) wie folgt empfangen ... Sagen wir, ich muss eine ID bekommen

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

diese Methode handleIntent () wurde abgeschrieben, sodass die Bearbeitung einer Benachrichtigung wie folgt erfolgen kann:

  1. Vordergrundzustand: Durch Klicken auf die Benachrichtigung wird die Aktivität des ausstehenden Intents aufgerufen, die Sie beim Erstellen einer Benachrichtigung programmgesteuert bereitstellen, da sie normalerweise mit der Daten-Nutzlast der Benachrichtigung erstellt wird.

  2. Hintergrund/Status "Killed" - Hier erstellt das System selbst eine Benachrichtigung basierend auf der Benachrichtigungsnutzlast. Wenn Sie auf diese Benachrichtigung klicken, gelangen Sie zur Starter-Aktivität der Anwendung, in der Sie Intent-Daten in jeder beliebigen Lebenszyklusmethode abrufen können.

61
manas.abrol

Ich hatte das gleiche Problem. Es ist einfacher, die "Datennachricht" anstelle der "Benachrichtigung" zu verwenden. Die Datennachricht lädt immer die Klasse onMessageReceived.

In dieser Klasse können Sie eine eigene Benachrichtigung mit dem Benachrichtigungsgenerator vornehmen.

Beispiel:

 @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());
    }
26
Koot

Hier sind klarere Konzepte über die Firebase-Nachricht. Ich habe es von ihrem Support-Team gefunden.

Firebase hat drei Nachrichtentypen:

Benachrichtigungsnachrichten: Die Benachrichtigungsnachricht funktioniert im Hintergrund oder Vordergrund. Wenn sich die App im Hintergrund befindet, werden Benachrichtigungsmeldungen an die Taskleiste gesendet. Wenn sich die App im Vordergrund befindet, werden Nachrichten von onMessageReceived() oder didReceiveRemoteNotification callbacks verarbeitet. Dies sind im Wesentlichen sogenannte Anzeigemeldungen.

Datennachrichten: Auf Android-Plattformen können Datennachrichten im Hintergrund und Vordergrund arbeiten. Die Datennachricht wird von onMessageReceived () verarbeitet. Eine plattformspezifische Anmerkung wäre hier: Unter Android kann die Datennutzlast in dem Intent abgerufen werden, das zum Starten Ihrer Aktivität verwendet wird. Wenn Sie "click_action":"launch_Activity_1" haben, können Sie diese Absicht nur über getIntent() von Activity_1 abrufen.

Nachrichten mit Benachrichtigungs- und Datennutzlasten: Im Hintergrund empfangen Apps die Benachrichtigungsnutzdaten im Benachrichtigungsbereich und behandeln die Datennutzlasten nur, wenn der Benutzer die Benachrichtigung antippt. Im Vordergrund empfängt Ihre App ein Nachrichtenobjekt mit beiden verfügbaren Nutzdaten. Zweitens wird der Parameter click_action häufig in der Benachrichtigungsnutzlast und nicht in der Datennutzlast verwendet. Bei Verwendung in Data Payload wird dieser Parameter als benutzerdefiniertes Schlüssel-Wert-Paar behandelt. Daher müssen Sie eine benutzerdefinierte Logik implementieren, damit sie wie beabsichtigt funktioniert.

Außerdem empfehle ich Ihnen, die Methode onMessageReceived (siehe Datennachricht) zu verwenden, um das Datenpaket zu extrahieren. Nach Ihrer Logik habe ich das Bündelobjekt überprüft und den erwarteten Dateninhalt nicht gefunden. Hier ist ein Hinweis auf einen ähnlichen Fall, der für mehr Klarheit sorgen könnte.

Für weitere Informationen besuchen Sie meinen diesen Thread

21

Gemäß der Firebase Cloud Messaging-Dokumentation - Wenn Aktivität im Vordergrund steht, wird onMessageReceived aufgerufen. Wenn sich Aktivität im Hintergrund befindet oder geschlossen ist, wird im Benachrichtigungscenter eine Benachrichtigung über die Aktivität des App Launchers angezeigt. Sie können Ihre benutzerdefinierte Aktivität beim Klicken auf Benachrichtigung aufrufen, wenn sich Ihre App im Hintergrund befindet.

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

Methodentyp-POST

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

Körper/Nutzlast:

{ "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)"
} 

Und damit können Sie in Ihrer App folgenden Code in Ihrer Aktivität hinzufügen, um aufgerufen zu werden:

<intent-filter>
                <action Android:name="OPEN_ACTIVITY_1" />
                <category Android:name="Android.intent.category.DEFAULT" />
            </intent-filter>
20
Ankit Adlakha

Wenn sich die App im Hintergrundmodus befindet oder inaktiv (beendet) ist und Sie click on Notification wählen, sollten Sie in LaunchScreen nach der Payload suchen (in meinem Fall ist MainActivity.Java der Startbildschirm).

Also in MainActivity.Java on onCreate check für Extras :

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

Überschreiben Sie die handleIntent-Methode der FirebaseMessageService-Funktion für mich.

hier der Code 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);
    }
}

und das ist der Code 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);
    }
}
8
t3h Exi

Ich habe das gleiche Problem. Wenn die App im Vordergrund ist, wird mein Hintergrunddienst ausgelöst, bei dem ich meine Datenbank basierend auf dem Benachrichtigungstyp aktualisieren kann .. __ Die Anwendung geht jedoch in den Hintergrund . 

Hier ist meine Lösung, um die App im Hintergrund zu identifizieren und Ihren Hintergrunddienst auszulösen.

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);
        }
      }
    }
  }
}

In der 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>

Diese Lösung wurde in der neuesten Version von Android 8.0 getestet. Vielen Dank

8

Die Launcher-Aktivität in Ihrer App wird standardmäßig gestartet, wenn sich Ihre App im Hintergrund befindet und Sie auf die Benachrichtigung klicken.

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

Wenn sich die App im Hintergrund befindet, behandelt Fire-Base standardmäßig die Benachrichtigung. Wenn wir jedoch unsere benutzerdefinierte Benachrichtigung möchten, müssen wir unsere Serverseite ändern, die für das Senden unserer benutzerdefinierten Daten verantwortlich ist (Datennutzlast).

Entfernen Sie die Benachrichtigungsnutzdaten vollständig von Ihrer Serveranfrage. Senden Sie nur Daten und behandeln Sie sie in onMessageReceived (). Andernfalls wird onMessageReceived nicht ausgelöst, wenn sich die App im Hintergrund befindet oder beendet wird.

jetzt sieht Ihr serverseitiges Code-Format so aus,

{
  "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
  }
}

NOTE: Siehe diese Zeile im obigen Code
"text": "John Doe hat einen Kontakt in der Gruppe Contact Exchange freigegeben" In Data payload sollten Sie den Parameter "text" anstelle der Parameter "body" oder "message" für die Beschreibung der Nachricht oder was immer Sie möchten, verwenden Verwenden Sie Text.

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());
            }
        }
    }
3
Hiren

onMessageReceived (RemoteMessage remoteMessage) Methode, die basierend auf den folgenden Fällen aufgerufen wird.

  • FCM-Antwort Mit Benachrichtigung und Datenblock :

{" bis ": "Geräte-Token-Liste", " Benachrichtigung " : {"Body": "Body Ihrer Benachrichtigung", "title": "Title Ihrer Benachrichtigung"}, " data ": {"body ":" Text Ihrer Benachrichtigung in Daten "," title ":" Titel Ihrer Benachrichtigung in Titel "," key_1 ":" Wert für key_1 "," image_url ":" www.abc.com/xyz.jpeg ", "key_2": "Wert für key_2"}}

  1. App im Vordergrund:

onMessageReceived (RemoteMessage remoteMessage) aufgerufen, zeigt LargeIcon und BigPicture in der Benachrichtigungsleiste an. Wir können den Inhalt sowohl vom Benachrichtigungs- als auch vom Datenblock lesen

  1. App im Hintergrund:

onMessageReceived (RemoteMessage remoteMessage) wird nicht aufgerufen, die Taskleiste empfängt die Nachricht und liest den Text und den Titel aus der Benachrichtigung blockieren und zeigt die Standardnachricht und den Titel in der Benachrichtigungsleiste an.

  • FCM-Antwort Mit nur Daten Block:

In diesem Fall entfernen Sie Benachrichtigungsblöcke von json

{" bis ": "Geräte-Token-Liste", " Daten " : {"Body": "Body Ihrer Benachrichtigung in Daten", "title": "Title Ihrer Benachrichtigung in Titel", "key_1": "Value for key_1", "image_url": "www.abc.com/xyz .jpeg "," key_2 ":" Wert für key_2 "}}

  1. App im Vordergrund:

onMessageReceived (RemoteMessage remoteMessage) aufgerufen, zeigt LargeIcon und BigPicture in der Benachrichtigungsleiste an. Wir können den Inhalt sowohl vom Benachrichtigungs- als auch vom Datenblock lesen

  1. App im Hintergrund:

onMessageReceived (RemoteMessage remoteMessage) wird aufgerufen, die Taskleiste erhält die Nachricht nicht, da eine Benachrichtigung Schlüssel ist nicht in der Antwort. Zeigt LargeIcon und BigPicture in der Benachrichtigungsleiste an

Code

 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());


}

Referenzlink:

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

3
vishnuc156

entsprechend der Lösung von t3h Exi möchte ich hier den Clean-Code posten. Legen Sie es einfach in MyFirebaseMessagingService ab und alles funktioniert gut, wenn sich die App im Hintergrundmodus befindet. Sie müssen mindestens com.google.firebase kompilieren: 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);
    }
}
2
Frank

Nennen Sie dies einfach in onCreate-Methode Ihrer MainActivity: 

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

Versuche dies:

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);
    }
}
2
user3587828

Hervorzuheben ist die Tatsache, dass Sie die Datennachricht (data key) verwenden müssen, um den onMessageReceived-Handler auch dann aufrufen zu können, wenn sich die App im Hintergrund befindet. Sie sollten keinen anderen Benachrichtigungsnachrichtenschlüssel in Ihrer Payload enthalten. Andernfalls wird der Handler nicht ausgelöst, wenn sich die App im Hintergrund befindet.

Es wird hier erwähnt (aber in der FCM-Dokumentation nicht so betont):

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

Verwenden Sie Ihren App-Server und die FCM-Server-API: Legen Sie nur den data-Schlüssel fest. Kann sein entweder zusammenlegbar oder nicht zusammenlegbar.

1
n_y

Wenn Ihr Problem mit der Anzeige von Big Image zusammenhängt, d. H. Wenn Sie Push-Benachrichtigungen mit einem Bild von der Firebase-Konsole senden, wird das Bild nur angezeigt, wenn sich die App im Vordergrund befindet. Die Lösung für dieses Problem ist das Senden einer Push-Nachricht mit nur Datenfeld. Etwas wie das:

{ "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" }
1
Arun

Das Backend, mit dem ich arbeite, verwendet Benachrichtigungsnachrichten und keine Datennachrichten. Nachdem ich alle Antworten gelesen hatte, versuchte ich, die Extras aus dem Bündel der Absichten abzurufen, die mit der gestarteten Aktivität verbunden sind. Unabhängig davon, welche Tasten ich aus getIntent().getExtras(); abzurufen versuchte, war der Wert immer null.

Endlich habe ich jedoch eine Möglichkeit gefunden, Daten mithilfe von Benachrichtigungsnachrichten zu senden und von der Absicht abzurufen.

Der Schlüssel hier ist das Hinzufügen der Datennutzdaten zur Benachrichtigungsnachricht.

Beispiel:

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

Danach können Sie Ihre Daten auf folgende Weise abrufen:

intent.getExtras().getString("title") ist message_title

und intent.getExtras().getString("message") ist message_body

Referenz

1
Vito Valov

Ich hatte das gleiche Problem und grub weiter darüber nach. Wenn sich die App im Hintergrund befindet, wird eine Benachrichtigungsnachricht an die Taskleiste gesendet, ABER eine data-Nachricht wird an onMessageReceived() gesendet.
Siehe https://firebase.google.com/docs/cloud-messaging/downstream#monitor-token-generation_3
und https://github.com/firebase/quickstart-Android/blob/master/messaging/app/src/main/Java/com/google/firebase/quickstart/fcm/MyFirebaseMessagingService.Java

Um sicherzustellen, dass die Nachricht, die Sie senden, angezeigt wird, sagen die Dokumente: "Verwenden Sie Ihren App-Server und die FCM-Server-API: Legen Sie nur den Datenschlüssel fest. Kann entweder zusammenklappbar oder nicht zusammenklappbar sein."
Siehe https://firebase.google.com/docs/cloud-messaging/concept-options#notifications_and_data_messages

1
Eric B.

Ich hatte dieses Problem (die App möchte sich nicht beim Benachrichtigungsklick öffnen, wenn sich die App im Hintergrund befindet oder geschlossen ist), und das Problem war ein ungültiger click_action im Benachrichtigungstext. Versuchen Sie es zu entfernen oder in etwas Gültiges zu ändern.

1
Octavian Lari

Wenn eine Nachricht empfangen wird und sich Ihre App im Hintergrund befindet, wird die Benachrichtigung an die Zusatzfunktion der Hauptaktivität gesendet.

Sie können den zusätzlichen Wert in der Funktion oncreate () oder onresume () der Hauptaktivität überprüfen.

Sie können nach Feldern wie Daten, Tabelle usw. (in der Benachrichtigung angegebenen Feldern) suchen.

ich habe zum Beispiel mit Daten als Schlüssel gesendet

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);
        }

}
0
Sanjeev S

Es gibt 2 Typen von Firebase Push-Benachrichtigungen:

1- Benachrichtigungsnachricht (Display message) -> -- 1.1 Wenn Sie diese Variante wählen, erstellt das Betriebssystem eine Benachrichtigung, wenn sich die App in Background befindet, und übergibt die Daten in der intent. Dann muss der Client mit diesen Daten umgehen.

- 1.2 Wenn sich die App in Foreground befindet, wird die Benachrichtigung über callback-function in der FirebaseMessagingService empfangen, und der Client kann damit umgehen.

2- Datennachrichten (bis zu 4 KByte Daten) -> Diese Nachrichten werden verwendet, um nur Daten an den Client zu senden (im Hintergrund), und es ist Sache des Clients, diese für beide Fälle im Hintergrund/Vordergrund über die Callback-Funktion in FirebaseMessagingService auszuführen

Dies entspricht den offiziellen Dokumenten: https://firebase.google.com/docs/cloud-messaging/concept-options

0
Balflear

Es gibt zwei Arten von Nachrichten: Benachrichtigungsnachrichten und Datennachrichten ... Wenn Sie nur eine Datennachricht senden, ist dies ohne Benachrichtigungsobjekt in Ihrer Nachrichtenzeichenfolge. Es wird aufgerufen, wenn sich Ihre App im Hintergrund befindet.

0
Shongsu