Wie sende ich Geräte-zu-Geräte-Nachrichten mit Firebase Cloud Messaging?

74

Nach dem Durchsuchen der Dokumente konnte ich keine Informationen darüber finden, wie Geräte-zu-Geräte-Nachrichten mit FCM ohne Verwendung eines externen Servers gesendet werden können.

Wenn ich beispielsweise eine Chat-Anwendung erstellen würde, müsste ich Push-Benachrichtigungen an Benutzer über ungelesene Nachrichten senden, da diese nicht immer online sind und ich keinen dauerhaften Dienst im Hintergrund habe, mit dem immer eine Verbindung besteht die Echtzeitdatenbank, weil das zu ressourcenintensiv wäre.

Wie würde ich eine Push-Benachrichtigung an einen Benutzer "A" senden, wenn ein bestimmter Benutzer "B" ihm eine Chat-Nachricht sendet? Benötige ich dafür einen externen Server oder kann dies nur mit Firebase-Servern durchgeführt werden?

Suyash
quelle
3
Ich habe FCM noch nicht verwendet, aber ich habe GCM verwendet. Angenommen, FCM ähnelt fast GCM. Gerät A sendet die Nachricht an den Server, der die Nachricht an Gerät B weiterleitet. Auschecken firebase.google.com/support/faq/#messaging-difference
j4rey
1
@ j4rey89 Ja, ich weiß, dass dies mit einem externen Server möglich ist. Ich frage, ob dies ohne möglich ist, da ich dafür zwei Server anstelle von einem warten und bezahlen müsste.
Suyash
7
@Suyash Es ist obligatorisch, einen eigenen Server zu betreiben, um FCM-Nachrichten zwischen Ihren Geräten zu senden. Wenn Sie sich Sorgen über die Kosten für den Betrieb des Servers machen, können Sie mit der Bereitstellung für Openshift Online (PaaS) oder Google AppEngine (auch PaaS) beginnen, für die ein kostenloses Kontingent gilt.
MrBrightside
2
@ j4rey89 MrBrightside: klingt nach einer Antwort. :-)
Frank van Puffelen

Antworten:

42

UPDATE: Es ist jetzt möglich, Firebase-Cloud-Funktionen als Server für die Verarbeitung von Push-Benachrichtigungen zu verwenden. Überprüfen Sie ihre Dokumentation hier

============

Gemäß den Dokumenten müssen Sie einen Server für die Verarbeitung von Push-Benachrichtigungen in der Kommunikation von Gerät zu Gerät implementieren.

Bevor Sie Client-Apps schreiben können, die Firebase Cloud Messaging verwenden, müssen Sie über einen App-Server verfügen, der die folgenden Kriterien erfüllt:

...

Sie müssen entscheiden, welche FCM-Verbindungsserverprotokolle Sie verwenden möchten, damit Ihr App-Server mit FCM-Verbindungsservern interagieren kann. Beachten Sie, dass Sie XMPP verwenden müssen, wenn Sie Upstream-Messaging von Ihren Clientanwendungen verwenden möchten. Weitere Informationen hierzu finden Sie unter Auswählen eines FCM-Verbindungsserverprotokolls .

Wenn Sie nur grundlegende Benachrichtigungen vom Server an Ihre Benutzer senden müssen. Sie können die serverlose Lösung Firebase Notifications verwenden .

Hier finden Sie einen Vergleich zwischen FCM- und Firebase-Benachrichtigungen: https://firebase.google.com/support/faq/#messaging-difference

eikooc
quelle
1
gute Antwort. Kennen Sie Tutorials oder Videos, in denen erklärt wird, wie das geht? Vielen Dank
Ben Akin
4
Siehe firebase.googleblog.com/2016/08/…
Frank van Puffelen
Könnten Sie mir bitte helfen, zu verstehen. Soweit ich weiß, muss ich HTTP verwenden und diese Nachricht an meinen Server senden, wenn ich eine direkte Nachricht von einem Verwendungszweck an einen anderen senden muss. Der nächste Server verwendet FCM, um eine Benachrichtigung an den Empfänger und damit an den Empfänger mit der ID des Absenders zu senden. Nächster Schritt Empfänger mit FCM verbinden und mit Hilfe der ID alle Daten aus der FCM-Datenbank abrufen? So?
Aleksey Timoshchenko
Perfekte Antwort, ich hatte ab diese 2 Tage recherchiert. Sehr vollständige Informationen über FCM und schwerwiegende Notwendigkeit oder nicht. Danke !.
Khang Tran
27

Es hat mir geholfen, eine HTTP-POST-Anfrage mit dem Link https://fcm.googleapis.com/fcm/send mit dem erforderlichen Header und den erforderlichen Daten zu stellen. Im folgenden Code-Snippet Constants.LEGACY_SERVER_KEYhandelt es sich um eine lokale Klassenvariable. Sie finden diese in Ihrem Firebase-Projekt Settings->Cloud Messaging->Legacy Server key. Sie müssen das Geräteregistrierungstoken übergeben, dh regTokenin dem Code-Snippet, auf das HIER verwiesen wird .

Endlich benötigen Sie die Abhängigkeit der okhttp- Bibliothek, damit dieses Snippet funktioniert.

public static final MediaType JSON
        = MediaType.parse("application/json; charset=utf-8");
private void sendNotification(final String regToken) {
    new AsyncTask<Void,Void,Void>(){
        @Override
        protected Void doInBackground(Void... params) {
            try {
                OkHttpClient client = new OkHttpClient();
                JSONObject json=new JSONObject();
                JSONObject dataJson=new JSONObject();
                dataJson.put("body","Hi this is sent from device to device");
                dataJson.put("title","dummy title");
                json.put("notification",dataJson);
                json.put("to",regToken);
                RequestBody body = RequestBody.create(JSON, json.toString());
                Request request = new Request.Builder()
                        .header("Authorization","key="+Constants.LEGACY_SERVER_KEY)
                        .url("https://fcm.googleapis.com/fcm/send")
                        .post(body)
                        .build();
                Response response = client.newCall(request).execute();
                String finalResponse = response.body().string();
            }catch (Exception e){
                //Log.d(TAG,e+"");
            }
            return null;
        }
    }.execute();

}

Wenn Sie eine Nachricht an ein bestimmtes Thema senden möchten, ersetzen Sie diese regTokenin json

json.put("to","/topics/foo-bar")

und vergessen Sie nicht, die INTERNET-Berechtigung in Ihre AndroidManifest.xml aufzunehmen.

WICHTIG : - Die Verwendung des obigen Codes bedeutet, dass sich Ihr Serverschlüssel in der Clientanwendung befindet. Dies ist gefährlich, da jemand in Ihre Anwendung eindringen und den Serverschlüssel zum Senden böswilliger Benachrichtigungen an Ihre Benutzer erhalten kann.

Brijesh Kumar
quelle
Hallo, gibt es eine Möglichkeit, die Nachrichten an einen abonnierten bestimmten Kanal zu senden?
Suchith
10
Der Nachteil ist, dass sich Ihr Serverschlüssel in der Clientanwendung befindet. Dies ist gefährlich, da jemand in Ihre Anwendung eindringen und den Serverschlüssel zum Senden böswilliger Benachrichtigungen an Ihre Benutzer erhalten kann. Deshalb sollten Sie dies niemals tun.
Kirtan403
@ kirtan403 Eine starke Verschlüsselung des Serverschlüssels auf der Clientseite könnte das verhindern ???
Mr.Popular
@ Mr.Popular Vielleicht, aber wenn jemand in der Lage ist, Ihren Code zu dekompilieren (natürlich kann er das), kann er sich das holen, was Sie zum Verschlüsseln Ihres Serverschlüssels verwenden, und Ihren Serverschlüssel erhalten. Und dann können sie Benachrichtigungen ohne Einschränkungen an jeden senden. Es ist daher eine sehr schlechte Idee, den Serverschlüssel auf der Clientseite zu platzieren. Eine sehr sehr schlechte Idee ...
Kirtan403
1
@ Tabish verwenden Sie bitte remoteMessage.getNotification (). Wir senden hier keine Daten.
Brijesh Kumar
4

Sie können dies mit der Volly Jsonobject-Anfrage tun ....

Befolgen Sie zuerst diese Schritte:

1 Kopieren Sie den Legacy-Serverschlüssel und speichern Sie ihn als Legacy_SERVER_KEY

Legacy-Serverschlüssel

Sie können im Bild sehen, wie man bekommt

2 Sie benötigen eine Volley-Abhängigkeit

kompiliere 'com.mcxiaoke.volley: library: 1.0.19'

Geben Sie hier die Bildbeschreibung ein

Code zum Senden Push: -

private void sendFCMPush() {

    String Legacy_SERVER_KEY = YOUR_Legacy_SERVER_KEY;
    String msg = "this is test message,.,,.,.";
    String title = "my title";
    String token = FCM_RECEIVER_TOKEN;

    JSONObject obj = null;
    JSONObject objData = null;
    JSONObject dataobjData = null;

    try {
        obj = new JSONObject();
        objData = new JSONObject();

        objData.put("body", msg);
        objData.put("title", title);
        objData.put("sound", "default");
        objData.put("icon", "icon_name"); //   icon_name image must be there in drawable
        objData.put("tag", token);
        objData.put("priority", "high");

        dataobjData = new JSONObject();
        dataobjData.put("text", msg);
        dataobjData.put("title", title);

        obj.put("to", token);
        //obj.put("priority", "high");

        obj.put("notification", objData);
        obj.put("data", dataobjData);
        Log.e("!_@rj@_@@_PASS:>", obj.toString());
    } catch (JSONException e) {
        e.printStackTrace();
    }

    JsonObjectRequest jsObjRequest = new JsonObjectRequest(Request.Method.POST, Constants.FCM_PUSH_URL, obj,
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    Log.e("!_@@_SUCESS", response + "");
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    Log.e("!_@@_Errors--", error + "");
                }
            }) {
        @Override
        public Map<String, String> getHeaders() throws AuthFailureError {
            Map<String, String> params = new HashMap<String, String>();
            params.put("Authorization", "key=" + Legacy_SERVER_KEY);
            params.put("Content-Type", "application/json");
            return params;
        }
    };
    RequestQueue requestQueue = Volley.newRequestQueue(this);
    int socketTimeout = 1000 * 60;// 60 seconds
    RetryPolicy policy = new DefaultRetryPolicy(socketTimeout, DefaultRetryPolicy.DEFAULT_MAX_RETRIES, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);
    jsObjRequest.setRetryPolicy(policy);
    requestQueue.add(jsObjRequest);
}

Rufen Sie einfach sendFCMPush () auf .

Rjz Satvara
quelle
Hallo, gibt es eine Möglichkeit, die Nachrichten an einen abonnierten bestimmten Kanal zu senden?
Suchith
Ja, möglicherweise müssen Sie ein Flag dafür hinzufügen und hängen davon ab, dass Sie Push an abonnierte Benutzer senden können
Rjz Satvara
@RjzSatvara was Wenn die App nicht auf dem Empfänger läuft? Wird es die Nachricht erhalten? Vielen Dank im Voraus
Jaco
1
@Jaco, es gibt keine Möglichkeit dafür. Sie müssen es auf andere Weise verwalten.
Rjz Satvara
3

1) Abonnieren Sie einen identischen Themennamen, zum Beispiel:

  • ClientA.subcribe ("to / topic_users_channel")
  • ClientB.subcribe ("to / topic_users_channel")

2) Senden Sie Nachrichten innerhalb der Anwendung

GoogleFirebase: So senden Sie Themennachrichten

Maxim Firsoff
quelle
2
Würde dies nicht weiterhin die Verwendung des Autorisierungsschlüssels auf der Clientseite erfordern? Was es unsicher macht. Ich weiß auch nicht einmal, ob es eine gute Idee ist, für jeden Benutzer ein eigenes Thema zu erstellen.
Suyash
Gute Idee, aber: Themennachrichten sind eher für den Durchsatz als für die Latenz optimiert. Richten Sie Nachrichten für eine schnelle und sichere Zustellung an einzelne Geräte oder kleine Gerätegruppen an Registrierungstoken und nicht an Themen.
Michalsx
@ Maxim Firsoff- Wie erstelle ich ein Thema über die FCM-Konsole oder auf andere Weise?
Ajay Sharma
@ AjaySharma Wie ich mich erinnere, hat die FMC-Konsole keine Tools dafür. Sie können ein Thema programmgesteuert erstellen (siehe oben meinen Pseudocode).
Maxim Firsoff
3

Ja, es ist ohne Server möglich. Sie können eine Geräterseite für Gerätegruppen erstellen und anschließend Nachrichten in der Gruppe austauschen. Es gibt jedoch Einschränkungen:

  1. Sie müssen auf den Geräten dasselbe Google-Konto verwenden
  2. Sie können keine Nachrichten mit hoher Priorität senden

Referenz: Firebase-Dokument Siehe Abschnitt "Verwalten von Gerätegruppen auf Android-Client-Apps".

greywolf82
quelle
Sie benötigen noch einen Server, um eine Gruppennachricht zu senden
abweichend
Auf keinen Fall. Jedes Gerät in der Gruppe kann eine Nachricht senden
greywolf82
aus docs: Authorization: key = API_KEY Sie benötigen noch einen Serverschlüssel. Daher ist diese Lösung nicht für die Produktion geeignet
abweichend am
Der API-Schlüssel ist das Google-Konto und die Kommunikation ist auf ein einzelnes Benutzerkonto beschränkt. Versuchen Sie vorher zu kommentieren.
greywolf82
2

Mit den Google Cloud-Funktionen können jetzt Push-Benachrichtigungen von Gerät zu Gerät ohne App-Server gesendet werden. Ich habe eine Cloud-Funktion erstellt, die ausgelöst wird, wenn eine neue Nachricht in die Datenbank aufgenommen wird

Es ist node.jsCode

'use strict';

const functions = require('firebase-functions');
const admin = require('firebase-admin'); admin.initializeApp();

exports.sendNotification = functions.database.ref('/conversations/{chatLocation}/{messageLocation}')
  .onCreate((snapshot, context) => {
      // Grab the current value of what was written to the Realtime Database.
      const original = snapshot.val();

       const toIDUser = original.toID;
       const isGroupChat = original.isGroupChat;

       if (isGroupChat) {
       const tokenss =  admin.database().ref(`/users/${toIDUser}/tokens`).once('value').then(function(snapshot) {

// Handle Promise
       const tokenOfGroup = snapshot.val()

      // get tokens from the database  at particular location get values 
       const valuess = Object.keys(tokenOfGroup).map(k => tokenOfGroup[k]);

     //console.log(' ____________ddd((999999ddd_________________ ' +  valuess );
    const payload = {
       notification: {
                 title:   original.senderName + " :- ",
                 body:    original.content
    }
  };

  return admin.messaging().sendToDevice(valuess, payload);



}, function(error) {

  console.error(error);
});

       return ;
          } else {
          // get token from the database  at particular location
                const tokenss =  admin.database().ref(`/users/${toIDUser}/credentials`).once('value').then(function(snapshot) {
                // Handle Promise
  // The Promise was "fulfilled" (it succeeded).

     const credentials = snapshot.val()



    // console.log('snapshot ......snapshot.val().name****^^^^^^^^^^^^kensPromise****** :- ', credentials.name);
     //console.log('snapshot.....****snapshot.val().token****^^^^^^^^^^^^kensPromise****** :- ', credentials.token);


     const deviceToken = credentials.token;

    const payload = {
       notification: {
                 title:   original.senderName + " :- ",
                 body:    original.content
    }
  };

  return admin.messaging().sendToDevice(deviceToken, payload);


}, function(error) {

  console.error(error);
});


          }





  return ;


    });
Vijayvir Sing Pantlia
quelle
1

Wenn Sie über ein fcm (gcm) -Token des Geräts verfügen, an das Sie eine Benachrichtigung senden möchten. Es ist nur eine Post-Anfrage, um die Benachrichtigung zu senden.

https://github.com/prashanthd/google-services/blob/master/android/gcm/gcmsender/src/main/java/gcm/play/android/samples/com/gcmsender/GcmSender.java

Prashanth Debbadwar
quelle
1
Ja, aber dies erfordert immer noch unseren eigenen externen Server, oder? Weil wir API_KEY nicht direkt in unsere Clients einbetten sollten. Meine Frage war, ob dies ohne einen externen Server möglich ist, was derzeit nicht den anderen Antworten entspricht.
Suyash
1

Mit den Google Cloud-Funktionen können jetzt Push-Benachrichtigungen von Gerät zu Gerät ohne App-Server gesendet werden.

Auf der entsprechenden Seite der Google Cloud-Funktionen:

Entwickler können Cloud-Funktionen verwenden, um Benutzer mit relevanten Informationen zu einer App zu beschäftigen und auf dem Laufenden zu halten. Stellen Sie sich beispielsweise eine App vor, mit der Benutzer die Aktivitäten des anderen in der App verfolgen können. In einer solchen App kann eine Funktion, die durch Echtzeitdatenbank-Schreibvorgänge zum Speichern neuer Follower ausgelöst wird, FCM-Benachrichtigungen (Firebase Cloud Messaging) erstellen, um die entsprechenden Benutzer darüber zu informieren, dass sie neue Follower gewonnen haben.

Beispiel:

  1. Die Funktion wird beim Schreiben in den Echtzeitdatenbankpfad ausgelöst, in dem Follower gespeichert sind.

  2. Die Funktion erstellt eine Nachricht, die über FCM gesendet werden soll.

  3. FCM sendet die Benachrichtigungsnachricht an das Gerät des Benutzers.

Hier ist ein Demo-Projekt zum Senden von Push-Benachrichtigungen von Gerät zu Gerät mit Firebase- und Google Cloud-Funktionen.

Crashalot
quelle
1

In meinem Fall verwende ich die Nachrüstung mit dieser Klasse. Nachricht:

public class Message {

    private String to;
    private String collapseKey;
    private Notification notification;
    private Data data;

    public Message(String to, String collapseKey, Notification notification, Data data) {
        this.to = to;
        this.collapseKey = collapseKey;
        this.notification = notification;
        this.data = data;
    }
}

Daten

public class Data {

    private String body;
    private String title;
    private String key1;
    private String key2;

    public Data(String body, String title, String key1, String key2) {
        this.body = body;
        this.title = title;
        this.key1 = key1;
        this.key2 = key2;
    }
}

Benachrichtigung

public class Notification {

    private String body;
    private String title;

    public Notification(String body, String title) {
        this.body = body;
        this.title = title;
    }
}

das ist der Anruf

private void sentToNotification() {
    String to = "YOUR_TOKEN";
    String collapseKey = "";
    Notification notification = new Notification("Hello bro", "title23");
    Data data = new Data("Hello2", "title2", "key1", "key2");
    Message notificationTask = new Message(to, collapseKey, notification, data);

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://fcm.googleapis.com/")//url of FCM message server
            .addConverterFactory(GsonConverterFactory.create())//use for convert JSON file into object
            .build();

    ServiceAPI api = new retrofit.create(ServiceAPI.class);

    Call<Message> call = api .sendMessage("key=YOUR_KEY", notificationTask);

    call.enqueue(new Callback<Message>() {
        @Override
        public void onResponse(Call<Message> call, retrofit2.Response<Message> response) {
            Log.d("TAG", response.body().toString());
        }

        @Override
        public void onFailure(Call<Message> call, Throwable t) {

            Log.e("TAG", t.getMessage());
        }
    });
}

unser ServiceAPi

public interface ServiceAPI {
    @POST("/fcm/send")
    Call<Message> sendMessage(@Header("Authorization") String token, @Body Message message);
}
Cabezas
quelle
1

Sie können Retrofit verwenden. Abonnieren Sie Geräte für Themen-News. Senden Sie eine Benachrichtigung von einem Gerät an ein anderes.

public void onClick(View view) {

    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
    logging.setLevel(HttpLoggingInterceptor.Level.BODY);

    OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
    httpClient.addInterceptor(new Interceptor() {
        @Override
        public okhttp3.Response intercept(Chain chain) throws IOException {
            Request original = chain.request();

            // Request customization: add request headers
            Request.Builder requestBuilder = original.newBuilder()
                    .header("Authorization", "key=legacy server key from FB console"); // <-- this is the important line
            Request request = requestBuilder.build();
            return chain.proceed(request);
        }
    });

    httpClient.addInterceptor(logging);
    OkHttpClient client = httpClient.build();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://fcm.googleapis.com")//url of FCM message server
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())//use for convert JSON file into object
            .build();

    // prepare call in Retrofit 2.0
    FirebaseAPI firebaseAPI = retrofit.create(FirebaseAPI.class);

    //for messaging server
    NotifyData notifydata = new NotifyData("Notification title","Notification body");

    Call<Message> call2 = firebaseAPI.sendMessage(new Message("topic or deviceID", notifydata));

    call2.enqueue(new Callback<Message>() {
        @Override
        public void onResponse(Call<Message> call, Response<Message> response) {

            Log.d("Response ", "onResponse");
            t1.setText("Notification sent");

        }

        @Override
        public void onFailure(Call<Message> call, Throwable t) {
            Log.d("Response ", "onFailure");
            t1.setText("Notification failure");
        }
    });
}

POJOs

public class Message {
    String to;
    NotifyData notification;

    public Message(String to, NotifyData notification) {
        this.to = to;
        this.notification = notification;
    }

}

und

public class NotifyData {
    String title;
    String body;

    public NotifyData(String title, String body ) {

        this.title = title;
        this.body = body;
    }

}

und FirebaseAPI

public interface FirebaseAPI {

    @POST("/fcm/send")
    Call<Message> sendMessage(@Body Message message);

}
eurosecom
quelle
0

Sie können dazu die Firebase-Echtzeitdatenbank verwenden. Sie können eine Datenstruktur zum Speichern von Chats erstellen und Beobachter für die Konversationsthreads für beide Benutzer hinzufügen. Es gibt immer noch eine Geräte-Server-Geräte-Architektur, aber in diesem Fall gibt es keinen zusätzlichen Server seitens der Entwickler. Dies verwendet die Firebase-Server. Sie können sich hier ein Tutorial ansehen (ignorieren Sie den UI-Teil, dies ist jedoch auch ein guter Ausgangspunkt für Chat-UI-Frameworks).

Firebase Echtzeit-Chat

DS.
quelle
3
Der Benutzer wird die App nicht ständig verwenden und wir können die Firebase-Echtzeitdatenbank nicht im Hintergrund verwenden, da eine dauerhafte Socket-Verbindung zum Server besteht, die den Akku des Geräts zu stark belastet.
Suyash
Ich kann Firebase-Nachrichten zwischen Geräten und Benachrichtigungen mithilfe der Smack Library senden. Ich implementiere keinen externen Server in meinem Android-Code. Smack verwaltet die Verbindung und das Ein- und Ausgehen von Nachrichtenzeilen mithilfe des XMPP-Protokolls.
i_o
0

Also hatte ich hier eine Idee. Siehe: Wenn sowohl der FCM als auch der GCM eine Endpoit-to-http-Anforderung haben, bei der wir einen Post-JSON mit unseren Nachrichtendaten senden können, einschließlich der Token der Geräte, auf denen diese Nachricht zugestellt werden soll.

Warum also nicht einen Beitrag mit dieser Benachrichtigung an den Firebase-Server senden, um ihn an Benutzer B zu senden? Du verstehst ?

Sie senden also die Nachricht und chatten mit einem Anrufbeitrag, um die Zustellung der Benachrichtigung sicherzustellen, wenn sich der Benutzer mit Ihrer App im Hintergrund befindet. Ich brauche es auch bald, ich werde es später testen. Was sagst du dazu?

Paulo Linhares - Packapps
quelle
2
FCM hat bereits einen Endpunkt, siehe hier . Es ist jedoch nicht möglich, es direkt in unseren Clients zu verwenden, da der Server-API-Schlüssel erforderlich ist. Und selbst wenn es öffentlich zugänglich wäre, würde es Sicherheitsprobleme verursachen, da jeder Benutzer jede FCM-Nachricht an jeden senden könnte.
Suyash
-2

Einfachster Weg:

void sendFCMPush(String msg,String token) {
    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
    logging.setLevel(HttpLoggingInterceptor.Level.BODY);

    OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
    httpClient.addInterceptor(new Interceptor() {
        @Override
        public okhttp3.Response intercept(Chain chain) throws IOException {
            Request original = chain.request();

            // Request customization: add request headers
            Request.Builder requestBuilder = original.newBuilder()
                    .header("Authorization", "key="+Const.FIREBASE_LEGACY_SERVER_KEY); // <-- this is the important line
            Request request = requestBuilder.build();
            return chain.proceed(request);
        }
    });

    httpClient.addInterceptor(logging);
    OkHttpClient client = httpClient.build();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://fcm.googleapis.com/")//url of FCM message server
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())//use for convert JSON file into object
            .build();

    // prepare call in Retrofit 2.0
    FirebaseAPI firebaseAPI = retrofit.create(FirebaseAPI.class);

    //for messaging server
    NotifyData notifydata = new NotifyData("Chatting", msg);

    Call<Message> call2 = firebaseAPI.sendMessage(new Message(token, notifydata));

    call2.enqueue(new Callback<Message>() {
        @Override
        public void onResponse(Call<Message> call, retrofit2.Response<Message> response) {
            Log.e("#@ SUCCES #E$#", response.body().toString());
        }

        @Override
        public void onFailure(Call<Message> call, Throwable t) {

            Log.e("E$ FAILURE E$#", t.getMessage());
        }
    });
}

Klasse erstellen, um ein Objekt zu erstellen:

public class Message {
String to;
NotifyData data;

public Message(String to, NotifyData data) {
    this.to = to;
    this.data = data;
}
}

Klasse erstellen, um ein Objekt zu erstellen:

public class Notification {
String title;
String message;
enter code here`enter code here`
public Notification(String title, String message) {
    this.title = title;
    this.message = message;
}
}
Sachin Shah
quelle
Die Verwendung von Const.FIREBASE_LEGACY_SERVER_KEY im clientseitigen Code ist nicht sicher. Bitte lesen Sie mindestens die anderen Antworten und Kommentare, bevor Sie Beiträge veröffentlichen.
Suyash