Firebase Cloud Messaging का उपयोग कर डिवाइस संदेश भेजने के लिए उपकरण कैसे भेजें?




firebase-cloud-messaging (9)

डॉक्स की खोज करने के बाद मुझे बाहरी सर्वर के उपयोग के बिना एफसीएम का उपयोग करके डिवाइस संदेश भेजने के तरीके के बारे में कोई जानकारी नहीं मिली।

उदाहरण के लिए, यदि मैं एक चैट एप्लिकेशन बना रहा था, तो मुझे बिना पढ़े संदेशों के बारे में उपयोगकर्ताओं को पुश नोटिफिकेशन भेजने की आवश्यकता होगी क्योंकि वे हर समय ऑनलाइन नहीं होंगे और मेरी पृष्ठभूमि में लगातार सेवा नहीं हो सकती है जो हमेशा जुड़े रहेंगे। वास्तविक समय डेटाबेस क्योंकि यह बहुत भारी संसाधन होगा।

तो मैं एक उपयोगकर्ता "ए" को एक धक्का अधिसूचना कैसे भेजूंगा जब एक निश्चित उपयोगकर्ता "बी" उसे एक चैट संदेश भेजता है? क्या मुझे इसके लिए एक बाहरी सर्वर की आवश्यकता है या यह सिर्फ फायरबेस सर्वर के साथ किया जा सकता है?



Google क्लाउड फ़ंक्शंस यह संभव बनाता है कि ऐप सर्वर के बिना डिवाइस-टू-डिवाइस से पुश सूचनाएं भेजें। मैंने क्लाउड फ़ंक्शन बनाया है जो डेटाबेस में नया संदेश जोड़ने पर ट्रिगर होता है

यह node.js कोड है

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


    });

आप Retrofit का उपयोग कर सकते हैं। समाचारों के लिए उपकरणों की सदस्यता लें। एक डिवाइस से दूसरे में नोटिफिकेशन भेजें।

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

}

तथा

public class NotifyData {
String title;
String body;

public NotifyData(String title, String body ) {

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

}

और फायरबेसएपीआई

public interface FirebaseAPI {

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

}

आप इसे Volly Jsonobject अनुरोध का उपयोग करके कर सकते हैं ...।

पहले इस चरण का पालन करें:

1 लीगेसी सर्वर कुंजी की प्रतिलिपि बनाएँ और इसे Legacy_SERVER_KEY के रूप में संग्रहीत करें

विरासत सर्वर कुंजी

आप तस्वीर में देख सकते हैं कि कैसे प्राप्त करें

2 आपको वॉली निर्भरता की आवश्यकता है

संकलन 'com.mcxiaoke.volley: पुस्तकालय: 1.0.19'

पुश भेजने के लिए कोड: -

    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("[email protected]@[email protected]@_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("[email protected]@_SUCESS", response + "");
                        }
                    },
                    new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError error) {
                            Log.e("[email protected]@_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);
}

बस कॉल sendFCMPush () ;


ऐसा करने के लिए आप फायरबेस रियलटाइम डेटाबेस का उपयोग कर सकते हैं। आप चैट को संग्रहीत करने के लिए डेटा संरचना बना सकते हैं और दोनों उपयोगकर्ताओं के लिए वार्तालाप थ्रेड के लिए पर्यवेक्षक जोड़ सकते हैं। यह अभी भी डिवाइस - सर्वर - डिवाइस आर्किटेक्चर करता है, लेकिन इस मामले में डेवलपर्स के हिस्से पर कोई अतिरिक्त सर्वर नहीं है। यह फायरबेस सर्वर का उपयोग करता है। आप यहां एक ट्यूटोरियल देख सकते हैं (यूआई भाग को नजरअंदाज करें, हालांकि, यह चैट यूआई फ्रेमवर्क के लिए एक अच्छा शुरुआती बिंदु है)।

फायरबेस रियलटाइम चैट


मेरे मामले में मैं इस वर्ग संदेश के साथ retrofit उपयोग करता हूं:

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

डेटा

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

अधिसूचना

public class Notification {

    private String body;
    private String title;

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

यह पुकार है

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

हमारी ServiceAPi

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

सबसे सरल तरीका:

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

ऑब्जेक्ट बनाने के लिए क्लास बनाएँ:

public class Message {
String to;
NotifyData data;

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

ऑब्जेक्ट बनाने के लिए क्लास बनाएँ:

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

हां, यह बिना किसी सर्वर के संभव है। आप डिवाइस समूह क्लाइंट साइड बना सकते हैं और फिर आप समूह में संदेशों का आदान-प्रदान करते हैं। हालाँकि सीमाएँ हैं:

  1. आपको उपकरणों पर समान Google खाते का उपयोग करना होगा
  2. आप उच्च प्राथमिकता वाले संदेश नहीं भेज सकते

संदर्भ: Firebase doc "एंड्रॉइड क्लाइंट ऐप्स पर उपकरण समूह प्रबंधित करना" अनुभाग देखें


अद्यतन: पुश सूचनाओं को संभालने के लिए सर्वर के रूप में फायरबेस क्लाउड फ़ंक्शन का उपयोग करना अब संभव है। here उनके प्रलेखन की जाँच here

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

डॉक्स के अनुसार आपको डिवाइस से डिवाइस संचार में पुश सूचनाओं को संभालने के लिए एक सर्वर को लागू करना होगा

फायरबेस क्लाउड मैसेजिंग का उपयोग करने वाले क्लाइंट ऐप्स को लिखने से पहले, आपके पास एक ऐप सर्वर होना चाहिए जो निम्नलिखित मानदंडों को पूरा करता है:

...

आपको यह तय करने की आवश्यकता होगी कि एफसीएम कनेक्शन सर्वर प्रोटोकॉल (ओं) को आप एफसीएम कनेक्शन सर्वरों के साथ बातचीत करने के लिए अपने ऐप सर्वर को सक्षम करने के लिए उपयोग करना चाहते हैं। ध्यान दें कि यदि आप अपने क्लाइंट एप्लिकेशन से अपस्ट्रीम मैसेजिंग का उपयोग करना चाहते हैं, तो आपको XMPP का उपयोग करना होगा। इसके बारे में अधिक विस्तृत चर्चा के लिए, एक FCM कनेक्शन सर्वर प्रोटोकॉल चुनना

यदि आपको केवल सर्वर से अपने उपयोगकर्ताओं को बुनियादी सूचनाएं भेजने की आवश्यकता है। आप उनके सर्वर रहित समाधान, फायरबेस नोटिफिकेशन का उपयोग कर सकते हैं।

एफसीएम और फायरबेस नोटिफिकेशन के बीच यहां एक तुलना देखें: firebase.google.com/support/faq/#messaging-difference





firebase-cloud-messaging