Wie man mit der Benachrichtigung arbeitet, wenn die App im Hintergrund in Firebase läuft

Hier ist mein manifest

    <service android:name=".fcm.PshycoFirebaseMessagingServices">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>

    <service android:name=".fcm.PshycoFirebaseInstanceIDService">
        <intent-filter>
            <action android:name="com.google.firebase.INSTANCE_ID_EVENT" />
        </intent-filter>
    </service>

Wenn die app im hintergrund läuft, und die Benachrichtigung kommt dann die Standard Meldung kommt und nicht mit meinem code von onMessageReceived.

Hier ist mein onMessageReceived code. Dies ruft, wenn meine app läuft auf Vordergrund, und nicht, wenn app im hintergrund. Wie um diesen code auszuführen, wenn die app im hintergrund zu?

//[START receive_message]
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    //TODO(developer): Handle FCM messages here.
    //If the application is in the foreground handle both data and notification messages here.
    //Also if you intend on generating your own notifications as a result of a received FCM
    //message, here is where that should be initiated. See sendNotification method below.
    data = remoteMessage.getData();
    String title = remoteMessage.getNotification().getTitle();
    String message = remoteMessage.getNotification().getBody();
    String imageUrl = (String) data.get("image");
    String action = (String) data.get("action");
    Log.i(TAG, "onMessageReceived: title : "+title);
    Log.i(TAG, "onMessageReceived: message : "+message);
    Log.i(TAG, "onMessageReceived: imageUrl : "+imageUrl);
    Log.i(TAG, "onMessageReceived: action : "+action);

    if (imageUrl == null) {
        sendNotification(title,message,action);
    } else {
        new BigPictureNotification(this,title,message,imageUrl,action);
    }
}
//[END receive_message]

InformationsquelleAutor der Frage Parth Patel | 2016-06-08

428

1. Warum ist das passiert?

Es gibt zwei Arten von Nachrichten, die in FCM (FB Cloud Messaging):
1. Display-Meldungen: Diese Nachrichten-trigger die onMessageReceived() callback nur, wenn Ihre app in Vordergrund
2. Daten-Nachrichten: Thesen-Nachrichten-trigger die onMessageReceived() Rückruf auchwenn Ihre app in Vordergrund - /hintergrund - /getötet
FB team noch nicht entwickelt, eine Benutzeroberfläche zu senden data-messages um Ihre Geräte, noch.

2. Wie?

Um dies zu erreichen, müssen Sie eine POST die folgende URL:

POST https://fcm.googleapis.com/fcm/send

Und die folgenden überschriften:
- Schlüssel: Content-TypeWert: application/json
- Schlüssel: AuthorizationWert: key=<your-server-key>
Körper mit Themen:
```
{
    "to": "/topics/my_topic",
    "data": {
        "my_custom_key": "my_custom_value",
        "my_custom_key2": true
     }
}
```
Oder wenn Sie möchten, senden Sie es an bestimmte Geräte:
```
{
    "data": {
        "my_custom_key": "my_custom_value",
        "my_custom_key2": true
     },
    "registration_ids": ["{device-token}","{device2-token}","{device3-token}"]
}
```
HINWEIS: sicher Sein, dass Sie nicht hinzufügen JSON-Schlüssel notification

HINWEIS:Um Ihre server-Schlüssel, können Sie es in der FB-Konsole: Your project -> settings -> Project settings -> Cloud messaging -> Server Key

3. Wie man mit den push-notification-Nachricht?

Dies ist, wie Sie mit der Nachricht:
```
@Override
public void onMessageReceived(RemoteMessage remoteMessage) { 
     Map<String, String> data = remoteMessage.getData();
     String myCustomKey = data.get("my_custom_key");

     //Manage data
}
```
InformationsquelleAutor der Antwort Antonio

Machen FB-Bibliothek zu nennen, Ihre onMessageReceived() in den folgenden Fällen

App im Vordergrund
App im hintergrund
App wurde getötet

müssen Sie nicht JSON-Schlüssel "Meldung" in Ihrer Anfrage an FB-API, sondern "Daten", siehe unten.

Wird die folgende Meldung wird nicht rufen Sie Ihren onMessageReceived ()wenn Ihre app im hintergrund oder getötet zu werden, und Sie können nicht passen Sie Ihre Mitteilung.

{
   "to": "/topics/journal",
   "notification": {
   "title" : "title",
   "text": "data!",
   "icon": "ic_notification"
    }
}

sondern mit diesem arbeiten

{
  "to": "/topics/dev_journal",
   "data": {
       "text":"text",
       "title":"",
       "line1":"Journal",
       "line2":"刊物"
   }
}

Grundsätzlich wird die Nachricht gesendet, der in der argument-RemoteMessage zusammen mit Ihren Daten-Objekt als Map, dann können Sie verwalten die Meldung im onMessageReceived wie in der snippet hier

@Override
public void onMessageReceived(RemoteMessage remoteMessage) { 
     Map<String, String> data = remoteMessage.getData();

     //you can get your text message here.
     String text= data.get("text");


     NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)
        //optional, this is to make beautiful icon
             .setLargeIcon(BitmapFactory.decodeResource(
                                    getResources(), R.mipmap.ic_launcher))  
        .setSmallIcon(smallIcon)  //mandatory
      .......
    /*You can read more on notification here:
    https://developer.android.com/training/notify-user/build-notification.html
    https://www.youtube.com/watch?v=-iog_fmm6mE
    */
}

InformationsquelleAutor der Antwort Teerakiat Chitawattanarat

Ich fühle mich wie alle Antworten sind unvollständig aber alle von Ihnen haben etwas, das Sie brauchen, um eine Meldung Bearbeiten, die Daten, wenn die app im hintergrund läuft.

Befolgen Sie diese Schritte und Sie werden in der Lage, Ihre Benachrichtigungen, wenn die app im hintergrund.

1.Hinzufügen eines intent-filter wie dieser:

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

zu einer Aktivität, die Sie Bearbeiten möchten, die Daten der Meldung.

Senden von Benachrichtigungen mit dem folgenden format:

{ 
 "notification" : {
        "click_action" : ".MainActivity", 
        "body" : "new Symulti update !", 
        "title" : "new Symulti update !", 
        "icon" : "ic_notif_symulti" }, 
 "data": { ... },
 "to" : "c9Vaa3ReGdk:APA91bH-AuXgg3lDN2WMcBrNhJZoFtYF9" }

Hier der Schlüssel ist, fügen Sie

"click_action" : ".MainActivity"

wo .MainActivity ist die Tätigkeit mit dem Vorsatz-filter, den Sie in Schritt 1 Hinzugefügt haben.

Get "Daten" Informationen aus der Benachrichtigung in der onCreate ".MainActivity":

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //get notification data info
    Bundle bundle = getIntent().getExtras();
    if (bundle != null) {
       //bundle must contain all info sent in "data" field of the notification
    }
}

Und das sollte alles sein, was Sie tun müssen. Ich hoffe, das hilft jemandem 🙂

InformationsquelleAutor der Antwort Daniel S.

26

Laut docs

Nachrichten verarbeiten, in eine hintergrund-app

Wenn die app im hintergrund, Android leitet Benachrichtigung
Nachrichten an den system-tray. Ein Benutzer Tippen Sie auf die Benachrichtigung, öffnet sich die
app launcher standardmäßig.

Dies schließt Nachrichten enthalten sowohl die Benachrichtigung und die Daten
Nutzlast. In diesen Fällen wird die Benachrichtigung zugestellt, um das Gerät
system-tray, und das Daten-payload wird in die extras der
Absicht des launchers Aktivität.

Wenn Sie möchten, öffnen Sie Ihre app und führen Sie eine bestimmte Aktion festlegen
click_action in die Nutzdaten der Benachrichtigung und Karte an, die der Absicht
filter in der Aktivität, die Sie starten möchten. Zum Beispiel, setzen Sie
click_action zu OPEN_ACTIVITY_1 zum auslösen eines intent-filter wie die
Folgendes:
```
 <intent-filter>   <action android:name="OPEN_ACTIVITY_1" />  
 <category android:name="android.intent.category.DEFAULT" />
 </intent-filter>
```
Edit :

Basierend auf dieser thread :

Kann nicht festgelegt werden, click_action Nutzlast mit FB-Konsole. Sie könnten versuchen, den Test mit dem curl-Befehl oder einen benutzerdefinierten http-server
```
curl --header "Authorization: key=<YOUR_KEY_GOES_HERE>" 
     --header Content-Type:"application/json" https://fcm.googleapis.com/fcm/send  
     -d "{\"to\":\"/topics/news\",\"notification\": 
         {\"title\": \"Click Action Message\",\"text\": \"Sample message\",
            \"click_action\":\"OPEN_ACTIVITY_1\"}}"
```
InformationsquelleAutor der Antwort Shubhank
17

Laut der FB-Dokumentation in senden downstream mit FBes gibt 2 Art der Nutzlast :
1. Daten
  
  Dieser parameter gibt den benutzerdefinierten Schlüssel-Wert-Paare von der message-payload.
  Client-app ist verantwortlich für die Verarbeitung der Daten-Nachrichten. Nachrichten haben nur benutzerdefinierte Schlüssel-Wert-Paare.
2. Benachrichtigung
  
  Dieser parameter gibt die vordefinierten, für den Benutzer sichtbaren Schlüssel-Wert-Paare der die Nutzdaten der Benachrichtigung. FCM zeigt automatisch die Meldung an die end-user-Geräte auf den Namen des Kunden app. Notification-Nachrichten haben einen vordefinierten Satz von Benutzer-sichtbare Tasten.
Sind, wenn Sie im Vordergrund Sie können die Daten innerhalb FCM mit onMessageReceived()können Sie sich Ihre Daten aus Daten Nutzlast.
```
data = remoteMessage.getData();
String customData = (String) data.get("customData");
```
Sind, wenn Sie in den hintergrund, FCM erscheint die Meldung im system-tray auf der Grundlage der Informationen aus Benachrichtigung Nutzlast. Titel, Nachricht und das Symbol verwendet, für die Benachrichtigung im system-tray aus der Benachrichtigung Nutzlast.
```
{
  "notification": {
        "title" : "title",
        "body"  : "body text",
        "icon"  : "ic_notification"
       }
}
```
Diese Benachrichtigung Nutzlast verwendet werden, wenn Sie wollen automactically zeigt Benachrichtigungen auf der Taskleiste, wenn die app im hintergrund.
Um benachrichtigt zu Daten, wenn die app im hintergrund, sollten Sie click_action innen Benachrichtigung Nutzlast.

Wenn Sie möchten, öffnen Sie Ihre app und führen Sie eine bestimmte Aktion [während im hintergrund], Satz click_action in die Nutzdaten der Benachrichtigung, und ordnen Sie Sie zu einer Vorsatz-filter in der Aktivität, die Sie starten möchten. Legen Sie beispielsweise click_action zu OPEN_ACTIVITY_1 zum auslösen eines intent-filter wie folgt:
```
<intent-filter>
  <action android:name="OPEN_ACTIVITY_1" />
  <category android:name="android.intent.category.DEFAULT" />
</intent-filter>
```
Setzen, die intent-filter auf Ihrem manifest, inside application-tag. Wenn Sie auf die Benachrichtigung, öffnet sich die app und gehen Sie direkt zu der Aktivität, die Sie definieren, in click_action, in diesem Fall "OPEN_ACTIVTY_1".
Und in dieser Aktivität können Sie die Daten durch :
```
Bundle b = getIntent().getExtras();
String someData = b.getString("someData");
```
Ich bin mit FCM für meine android-app und verwenden Sie beide der Nutzlast.
Hier ist das Beispiel-JSON bin ich mit :
```
{
  "to": "FCM registration ID",
  "notification": {
    "title" : "title",
    "body"  : "body text",
    "icon"  : "ic_notification"
   },
   "data": {
     "someData"  : "This is some data",
     "someData2" : "etc"
   }
}
```
InformationsquelleAutor der Antwort Hendy Evan
13

Da die display-messages die gesendet werden von der FB-Benachrichtigung UI funktioniert nur, wenn die app im Vordergrund. Für data-messagesist es erforderlich, einen POST-Aufruf an FCM

Schritte
1. Installieren Sie Advanced Rest Client Für Google Chrome Erweiterung
2. Fügen Sie die folgenden überschriften
  
  Schlüssel: Content-Type, Wert: application/json
  
  Schlüssel: Autorisierung, Wert: key="server-Schlüssel"
3. Fügen Sie den Körper
  - Wenn Sie mit Themen :
    
    { "to" : "/topics/topic_name", "data": { "key1" : "value1", "key2" : "value2", } }
  - Wenn Sie mit Registrierungs-id :
    
    { "registration_ids" : "[{"id"},{id1}]", "data": { "key1" : "value1", "key2" : "value2", } }
Thats it!. Jetzt hören onMessageReceived Rückruf wie üblich.
```
@Override
public void onMessageReceived(RemoteMessage remoteMessage) { 
     Map<String, String> data = remoteMessage.getData();
     String value1 = data.get("key1");
     String value2 = data.get("key2");
}
```
InformationsquelleAutor der Antwort Anirudh Ramanan

Erfassen Sie die Nachricht im hintergrund, die Sie benötigen, um ein BroadcastReceiver

public class FirebaseDataReceiver extends WakefulBroadcastReceiver {

    private final String TAG = "FirebaseDataReceiver";

    public void onReceive(Context context, Intent intent) {
        Log.d(TAG, "I'm in!!!");
        Bundle dataBundle = intent.getBundleExtra("data");
        Log.d(TAG, dataBundle.toString());
    }
}

und fügen Sie diese zu Ihrem manifest:

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

InformationsquelleAutor der Antwort Romulano

12
```
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {

}
```
nicht aufgerufen wird, jedes mal, wenn es aufgerufen wird, nur wenn app ist im forground

es ist eine Methode überschreiben diese Methode wird aufgerufen, jedes mal , egal welche app im Vordergrund oder im hintergrund oder getötet werden, aber diese Methode ist mit dieser FB-api version

dies ist die version u importieren von gradle
```
compile 'com.google.firebase:firebase-messaging:10.2.1'
```
dies ist die Methode,
```
@Override
public void handleIntent(Intent intent) {
    super.handleIntent(intent);

    //you can get ur data here 
    //intent.getExtras().get("your_data_key") 


}
```
vorherigen FB-api dieser Methode war es nicht so in diesem Fall
fire base behandeln, selbst wenn die app im hintergrund läuft .... jetzt haben Sie u diese Methode
was auch immer u wollen ... u kannst es hier in diesem Methode .....

wenn Sie mit der vorherigen version als Standard-Aktivität wird gestartet
in diesem Fall kann u get data gleicher Weise
```
if(getIntent().getExtras() != null && getIntent().getExtras().get("your_data_key") != null) {
String strNotificaiton = getIntent().getExtras().get("your_data_key").toString();
```
//do was auch immer u wollen ....
}

in der Regel ist dies die Struktur vom server bekommen wir in der Benachrichtigung
```
{
    "notification": {
        "body": "Cool offers. Get them before expiring!",
        "title": "Flat 80% discount",
        "icon": "appicon",
        "click_action": "activity name" //optional if required.....
    },
    "data": {
        "product_id": 11,
        "product_details": "details.....",
        "other_info": "......."
    }
}
```
es ist bis zu u, wie u wollen, zu geben, die Daten-Taste oder u wollen mit der Meldung etwas u geben kann .......
was auch immer u wird hier mit derselben Taste u wird an diese Daten kommen .........

gibt es einige Fälle, wenn u r nicht zu senden klicken Sie auf Aktion in diesem Fall, wenn u klicken Sie auf Benachrichtigung default-Aktivität wird geöffnet , aber wenn u wollen, öffnen Sie Ihre spezifische Aktivität, wenn app ist im hintergrund-u aufrufen können, Ihre Aktivität von dieser handleIntent Methode, denn diese wird immer dann aufgerufen, wenn

InformationsquelleAutor der Antwort Avinash Jadaun
6

Hier gibt es mehr klare Konzepte über FB-Nachricht. Ich fand es von Ihrem support-team.

FB hat drei message-Typen:

Benachrichtigungen : Benachrichtigung funktioniert auf den hintergrund oder den Vordergrund. Wenn app ist im hintergrund-Benachrichtigungen geliefert werden, die system-tray. Wenn die app im Vordergrund ist, die Nachrichten werden behandelt, indem onMessageReceived() oder didReceiveRemoteNotification Rückrufe. Dies sind im wesentlichen die so genannten Display-Meldungen.

Daten-Nachrichten: Auf Android-Plattform, Daten-Nachricht arbeiten können hintergrund-und Vordergrund. Die Daten-Nachricht wird von onMessageReceived(). Eine Plattform-spezifische note wäre hier: Auf Android, die Daten-Nutzlast kann abgerufen werden in der Absicht verwendet, um starten Sie Ihre Aktivität. Zu erarbeiten, wenn Sie "click_action":"launch_Activity_1" können Sie abrufen, diese Absicht durch getIntent() von nur Activity_1.

Nachrichten mit beiden Benachrichtigungs-und Daten-payloads: Wenn im hintergrund apps erhalten die Nutzdaten der Benachrichtigung in der notification tray, und verarbeiten nur die Daten -, payload ' wenn der Benutzer tippt auf die Benachrichtigung. Wenn Sie im Vordergrund ist, erhält Ihre app ein message-Objekt mit beiden Nutzlasten zur Verfügung. Zweitens, die click_action parameter wird Häufig verwendet, in notification payload und nicht im Daten -, payload'. Wenn im Daten -, payload, dieser parameter würde behandelt werden als benutzerdefinierte Schlüssel-Wert-paar, und deshalb würden Sie brauchen, zu implementieren benutzerdefinierte Logik für Sie zu arbeiten, wie beabsichtigt.

Außerdem empfehle ich Ihnen die Verwendung onMessageReceived - Methode (siehe Daten-Nachricht) zum extrahieren der Daten-bundle. Aus deiner Logik, ich habe das bundle-Objekt und nicht das gefunden haben, erwartet Daten. Hier ist ein Verweis auf einen ähnlichen Fall, der vielleicht mehr Klarheit.

Für mehr info besuchen Sie meine dieser thread

InformationsquelleAutor der Antwort Md. Sajedul Karim
6

2017 fortgeschrieben Antwort

Hier ist eine klare Antwort aus der docs in Bezug auf diese:

InformationsquelleAutor der Antwort pulp_fiction
5

Laut der docs: Mai 17, 2017

Wenn Ihre app in der hintergrundAndroid
leitet Benachrichtigungen an den system-tray. Ein Benutzer Tippen Sie auf die
Benachrichtigung öffnet die app launcher standardmäßig.

Dies schließt Nachrichten ein, die beide Benachrichtigung und die Daten Nutzlast
(und alle Nachrichten gesendet, die aus den Meldungen in der Konsole). In diesen
Fällen, wird die Benachrichtigung zugestellt auf dem Gerät im system-tray und
der Daten-payload wird in den extras von der Absicht Ihrer
launcher Aktivität.

Also sollten Sie beide der payload notification + Daten:
```
{
  "to": "FCM registration ID",
  "notification": {
    "title" : "title",
    "body"  : "body text",
    "icon"  : "ic_notification"
   },
   "data": {
     "someData"  : "This is some data",
     "someData2" : "etc"
   }
}
```
Gibt es keine Notwendigkeit zu verwenden click_action.Sie sollten nur exras von der Absicht, auf LAUNCHER Aktivität
```
<activity android:name=".MainActivity">
        <intent-filter>
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
</activity>
```
Java-code sollte auf der onCreate-Methode auf MainActivity :
```
Intent intent = getIntent();
if (intent != null && intent.getExtras() != null) {
    Bundle extras = intent.getExtras();
    String someData= extras.getString("someData");
    String someData2 = extras.getString("someData2");
}
```
Können Sie testen, sowohl von der payload notification + Daten aus FB-Benachrichtigungen-Konsole . Vergessen Sie nicht, füllen Sie benutzerdefinierte Datenfelder auf den Abschnitt "Erweiterte Optionen"

InformationsquelleAutor der Antwort Mihuilk
4

Dachte ich, die Szenarien,

Wenn app ist im Vordergrund
onMessageReceived() Methode wird aufgerufen, aus dem FirebaseService.Also die pendingIntent definiert in der service-Klasse aufgerufen werden.

Und wenn app ist im hintergrunderste Aktivität genannt wird.

Nun, wenn Sie eine splash Aktivitätdann muss beachten Sie die splashactivity aufgerufen werden, sonst, wenn es keine splashActivity, dann, was die erste Tätigkeit ist, aufgerufen werden.

Dann müssen Sie prüfen, getIntent() der firstActivity um zu sehen, ob es irgendwelche bundle .wenn alles in Ordnung ist, sehen Sie bundle gibt es mit Werten gefüllt. Wenn der Wert in Daten tag gesendet vom server sieht so aus,
```
"data": {
    "user_name": "arefin sajib",
    "value": "user name notification"
  }
```
Dann in der ersten Aktivität werden Sie sehen,
es gibt einen gültigen Willenserklärungen( getIntent() ist nicht null) , gültig bündeln und innen-bundle , gibt es das ganze JSON oben erwähnt mit Daten als Schlüssel.

Für dieses Szenario, code für die Extraktion der Wert wird so Aussehen,
```
    if(getIntent()!=null){
            Bundle bundle = getIntent().getExtras();
            if (bundle != null) {
                try {
                   JSONObject object = new JSONObject(bundle.getStringExtra("data"));
String user_name = object.optString("user_name");

                } catch (JSONException e) {
                    e.printStackTrace();
                }


            }
        }
```
InformationsquelleAutor der Antwort Shamsul Arefin Sajib
3

Einfache Zusammenfassung, wie diese
- wenn Ihre app ausgeführt wird;
```
onMessageReceived()
```
ist Trigger.
- wenn Ihre app nicht ausgeführt wird (getötet durch streichen) ;
```
onMessageReceived()
```
nicht ausgelöst und geliefert direkt. Wenn Sie irgendwelche speziell Schlüssel-Wert-paar. Sie don' t arbeiten, weil der onMessageReceived() funktioniert nicht.

Ich' ve gefunden, auf diese Weise;

Im launcher Aktivität, setzen Sie dieser Logik,
```
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState, R.layout.activity_splash);

    if (getIntent().getExtras() != null && getIntent().getExtras().containsKey("PACKAGE_NAME")) {

        //do what you want

        //and this for killing app if we dont want to start
        android.os.Process.killProcess(android.os.Process.myPid());

    } else {

        //continue to app
    }
}
```
in diesem if-block, suchen für Ihre Schlüssel laut FB-UI.

In diesem Beispiel meine Schlüssel und Wert wie oben; (sorry für die Sprache =))

Wenn mein code funktioniert, ich bekomme "com.rda.Hinweis".
```
android.os.Process.killProcess(android.os.Process.myPid());
```
mit dieser Codezeile, Schloss ich die Anwendung und öffnen Sie Google-Play-Markt

happy coding =)

InformationsquelleAutor der Antwort Arda
2

Benachrichtigung entfernen Nutzlast vollständig von Ihrem server anfordern. Senden nur Daten und behandeln es in onMessageReceived() sind, sonst onMessageReceived wird nicht ausgelöst, wenn die app im hintergrund läuft oder getötet.

Hier ist, was ich bin, das versenden vom server:
```
{
  "data":{
    "id": 1,
    "missedRequests": 5
    "addAnyDataHere": 123
  },
  "to": "fhiT7evmZk8:APA91bFJq7Tkly4BtLRXdYvqHno2vHCRkzpJT8QZy0TlIGs......"
}
```
So erhalten Sie Ihre Daten in onMessageReceived(RemoteMessage message) so aus: (lassen Sie s sagen, ich habe die id)
```
Object obj = message.getData().get("id");
        if (obj != null) {
            int id = Integer.valueOf(obj.toString());
        }
```
Und auf ähnliche Weise können Sie alle Daten, die Sie gesendet haben, vom server innerhalb onMessageReceived().

InformationsquelleAutor der Antwort Zohab Ali
2

Der einfache Weg, um Nachrichten zu senden, auch wenn die app in hintergrund und Vordergrund, die als Folge von:-
Senden Sie eine Nachricht mithilfe von API -, Sie können ein tool namens AdvancedREST Client, es ist eine chrome-Erweiterung, und senden einer Nachricht mit den folgenden Parametern.

Rest-client-tool Link: https://chrome.google.com/webstore/detail/advanced-rest-client/hgmloofddffdnphfgcellkdfbfbjeloo

verwenden Sie diese url ein:- https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Autorisierung:key=Dein-Server-Schlüssel Aus oder Authoization-Taste(siehe unten ref)
```
{ "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"
}
```
Autorisierungs-Schlüssel kann erworben werden durch den Besuch der Google-Entwickler-Konsole, und klicken Sie auf Anmeldeinformationen-Taste auf der linken Menü für Ihr Projekt. Unter den API-Schlüssel angegeben, wird der server-key wird Ihren Autorisierungs-key.

Und Sie brauchen, um tokenID der Empfänger in der "to" - Abschnitt der POST-Anforderung gesendet mit API.

InformationsquelleAutor der Antwort Syed Danish Haider

Dank an Euch Alle für Eure Antworten. Aber ich löste dies durch senden von Nachricht anstatt Benachrichtigung.
Server-code

<?php
$url = "https://fcm.googleapis.com/fcm/send";
$token = "C-l6T_a7HouUK****";
$serverKey = "AAAAaOcKS00:********";
define( 'API_ACCESS_KEY', $serverKey );
$registrationIds = array($token);
//prep the bundle

$msg = array

(
 'message'  => 'here is a message. message',
 'title'        => 'This is a title. title',
 'subtitle' => 'This is a subtitle. subtitle',
 'tickerText'   => 'Ticker text here...Ticker text here...Ticker text 
 here',
 'vibrate'  => 1,
 'sound'        => 1,
 'largeIcon'    => 'large_icon',
 'smallIcon'    => 'small_icon'

);

$fields = array

(
  'registration_ids'    => $registrationIds,
  'data'            => $msg

);
$headers = array

(
  'Authorization: key=' . API_ACCESS_KEY,
 'Content-Type: application/json'

);


$ch = curl_init();

curl_setopt( $ch,CURLOPT_URL, 'https://android.googleapis.com/gcm/send' 
);

curl_setopt( $ch,CURLOPT_POST, true );

curl_setopt( $ch,CURLOPT_HTTPHEADER, $headers );

curl_setopt( $ch,CURLOPT_RETURNTRANSFER, true );

curl_setopt( $ch,CURLOPT_SSL_VERIFYPEER, false );

curl_setopt( $ch,CURLOPT_POSTFIELDS, json_encode( $fields ) );

$result = curl_exec($ch );

curl_close( $ch );

echo $result;

?>

Und fing die Daten in onMessageReceived

public class MyFirebaseMessagingService extends FirebaseMessagingService     {

  private static final String TAG = "MyFirebaseMsgService";

@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    Log.d(TAG, "From: " + remoteMessage.getFrom());

    //Check if message contains a data payload.
    if (remoteMessage.getData().size() > 0) {
        Log.d(TAG, "Message data payload: " + remoteMessage.getData());

      sendNotification(remoteMessage.getData().get("message"));
     }
   //Check if message contains a notification payload.
    else if (remoteMessage.getNotification() != null) {
        Log.d(TAG, "Message Notification Body: " + remoteMessage.getNotification().getBody());
    sendNotification(remoteMessage.getNotification().getBody());
    }


}
   private void sendNotification(String messageBody) {
    Intent intent = new Intent(this, Notify.class).putExtra("msg",messageBody);
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
            PendingIntent.FLAG_ONE_SHOT);

    String channelId = "idddd";
    Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
    NotificationCompat.Builder notificationBuilder =
            new NotificationCompat.Builder(MyFirebaseMessagingService.this)
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setContentTitle("FCM Message")
                    .setContentText(messageBody)
                    .setAutoCancel(true)
                    .setSound(defaultSoundUri)
                    .setContentIntent(pendingIntent);

    NotificationManager notificationManager =
            (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

    notificationManager.notify(0 /* ID of notification */, notificationBuilder.build());
}
}

InformationsquelleAutor der Antwort Android Sanaullah

1

habe ich E-mail-fcm-support und geben Sie mir Lösung.
fcm support-mail erhalten, auf 14-12-2017

ich sende Benachrichtigung mit Daten Nutzlast durch fcm-Konsole.
onMessageReceived () - Aufruf nur die app im Vordergrund(aktuelle geöffnete app), wenn die app im hintergrund Daten kommt die Meldung nur durch die Absicht Wert im launcher Aktivität.
ich habe fügen Sie einige Schritt können Sie verstehen einfach .

ersten ich bin dem senden von Benachrichtigungen mit den Daten durch die FB-Konsole

diese notifiaction kommen, perfekt, wenn app ist offen, dass bedeutet, forground app .

aber wenn die app nicht geöffnet ist zu dieser Zeit Meldung kommt, die Daten aber nicht erhalten onMessageReceived () - Methode.
dieses problem, das ich gefunden haben, neue Lösung , diesen code unten auf meinem Haupt-launcher-Aktivität. ich erhalte Daten, wenn die Benachrichtigung kommt und die app im hintergrund und der Benutzer Tippen Sie auf die Benachrichtigung.

diesen code habe ich auf meinem Haupt-Aktivität
```
if (getIntent().getExtras() != null) {

        for (String key : getIntent().getExtras().keySet()) {
            String value = getIntent().getExtras().getString(key);

            if (key.equals("chirag")) {
                //Intent intent = new Intent(this, AnotherActivity.class);
                //intent.putExtra("value", value);
                //startActivity(intent);
                //finish();
                txtMsg.setText(value+" :- this is notification .");

            }

        }
    }
    else {

    }
```
aber app-hintergrund und mehr als eine Meldung kommen , in dieser Zeit jede separate Benachrichtigung . aber ich will Posteingang-Stil-Benachrichtigung.

InformationsquelleAutor der Antwort Android_Rocks

Juni 2018 Antwort -

Müssen Sie sicherstellen, dass es nicht eine "Meldung" Schlüsselwort irgendwo in der Nachricht. Nur sind "Daten", und die app wird in der Lage sein zu handhaben, die Nachricht in onMessageReceived, auch wenn im hintergrund oder getötet werden.

Mit Cloud-Funktionen:

const message = {
    token: token_id,   //obtain device token id by querying data in firebase
    data: {
       title: "my_custom_title",
       body:  "my_custom_body_message"
       }
    }


return admin.messaging().send(message).then(response => {
    //handle response
});

Dann in Ihre onMessageReceived(), in Ihrer Klasse, die sich com.google.FB.messaging.FirebaseMessagingService :

if (data != null) {
  Log.d(TAG, "data title is: " + data.get("title");
  Log.d(TAG, "data body is: " + data.get("body");
}

//build notification using the body, title, and whatever else you want.

InformationsquelleAutor der Antwort Jeff Padgett

-3

Ich erfahren habe das gleiche problem und kompiliert die FB Bibliothek und es verhindert das senden von Benachrichtigungen, wenn die Anwendung im hintergrund

*Bibliothek
https://github.com/erdalceylan/com-google-firebase-messaging

 dependencies {
        compile 'com.google.firebase:firebase-core:11.2.0'
        compile 'com.github.erdalceylan:com-google-firebase-messaging:v1-11.2.0'
    }

@WorkerThread
public void onMessageReceived(RemoteMessage var1) {
  //your app is in background or foreground all time calling
}

hoffe, dass hilft. Viel Glück

InformationsquelleAutor der Antwort Erdal CEYLAN

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

1. Warum ist das passiert?

2. Wie?

3. Wie man mit den push-notification-Nachricht?

2017 fortgeschrieben Antwort