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

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?

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

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.

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'

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 .

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

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".

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 ;


    });

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

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.

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

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

}

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

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?

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