Jak wysyłać wiadomości z urządzenia do urządzenia za pomocą wiadomości Firebase Cloud?

Wymyśliłem TAK:-
Wykonanie żądania HTTP POST z linkiem " https://fcm.googleapis.com/fcm/send " z wymaganym nagłówkiem i danymi, do których odwołuje się tutaj .
Stałe.LEGACY_SERVER_KEY jest zmienną klasy lokalnej, można ją znaleźć w Ustawieniach projektu Firebase-- > wiadomości w chmurze-- > klucz serwera starszego. Musisz przekazać Token rejestracji urządzenia (reg_token) w poniższym fragmencie kodu, o którym mowa tutaj.
Jednak potrzebujesz okhttp zależności od biblioteki w celu wykonania tego kawałka.

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

}

Dalej jeśli chcesz wysłać wiadomość do konkretnego tematu, zamień 'regToken' w json tak jak to

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

I w końcu nie zapomnij dodać uprawnień internetowych w AndroidManifest.xml.

Ważne: - użycie powyższego kodu oznacza, że twój klucz serwera znajduje się w aplikacji klienckiej. Jest to niebezpieczne, ponieważ ktoś może zagłębić się w Twoją aplikację i uzyskać klucz serwera, aby wysyłać złośliwe powiadomienia do użytkowników.

Tak, można to zrobić bez żadnego serwera. Możesz utworzyć grupę urządzeń po stronie klienta, a następnie wymieniać wiadomości w grupie. Istnieją jednak ograniczenia:

1. musisz używać tego samego konta Google na urządzeniach
2. nie możesz wysyłać wiadomości o wysokim priorytecie

1) Subskrybuj identyczną nazwę tematu, na przykład:

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

2) wysyłanie wiadomości wewnątrz aplikacji

GoogleFirebase : jak wysyłać wiadomości tematyczne

Jeśli posiadasz token fcm (gcm) urządzenia, do którego chcesz wysłać powiadomienie. To tylko prośba o wysłanie powiadomienia.

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

Możesz użyć doposażenia. Subskrybuj wiadomości tematyczne. Wysyłanie powiadomień z jednego urządzenia na drugie.

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

}

I

public class NotifyData {
String title;
String body;

public NotifyData(String title, String body ) {

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

}

I FirebaseAPI

public interface FirebaseAPI {

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

}

Możesz to zrobić używając Volly jsonobject request....

Wykonaj najpierw następujące kroki:

1 skopiuj klucz serwera starszego i zapisz go jako Legacy_SERVER_KEY

Klucz serwera starszego

Możesz zobaczyć na zdjęciu jak uzyskać

2 You need Volley dependency

Compile ' com.mcxiaoke.volley: library: 1.0.19 "

Kod do send 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);
}

Po Prostu Zadzwoń sendFCMPush();

Funkcje Google Cloud umożliwiają teraz wysyłanie powiadomień push z urządzenia do urządzenia bez serwera aplikacji.

Z odpowiedniej strony w Google Cloud Functions:

Programiści mogą korzystać z funkcji Chmury, aby utrzymać zaangażowanie użytkowników i do Data zawierająca istotne informacje o aplikacji. Rozważmy na przykład aplikacja, która pozwala użytkownikom śledzić swoje działania w aplikacji. W takiej aplikacji funkcja wyzwalana przez bazę danych w czasie rzeczywistym zapisuje do sklep nowi Obserwujący mogą tworzyć wiadomości Firebase Cloud (FCM) powiadomienia informujące odpowiednich użytkowników o tym, że uzyskali nowi wyznawcy.

Przykład:

1. Funkcja uruchamia zapis do ścieżki bazy danych w czasie rzeczywistym, w której przechowywane są osoby śledzące.

2. Funkcja tworzy wiadomość do wysłania za pośrednictwem FCM.

3. FCM wysyła wiadomość z powiadomieniem na urządzenie użytkownika.

Oto demo projekt do wysyłania powiadomień push od urządzenia do urządzenia za pomocą funkcji Firebase i Google Cloud.

Możesz użyć firebase realtime database, aby to zrobić. Możesz utworzyć strukturę danych do przechowywania czatów i dodawać obserwatorów dla wątków konwersacji dla obu użytkowników. Nadal ma architekturę device - server - device, ale w tym przypadku nie ma dodatkowego serwera po stronie deweloperów. Korzysta z serwerów firebase. Możesz sprawdzić samouczek tutaj (zignoruj część interfejsu użytkownika, chociaż jest to również dobry punkt wyjścia dla frameworków interfejsu czatu).

Firebase Realtime Chat

Więc mam pomysł. Zobacz: jeśli FCM, podobnie jak GCM, ma żądanie endpoit do http, gdzie możemy wysłać post json z naszymi danymi wiadomości, w tym token (y) urządzeń, które chcemy, aby ta wiadomość została dostarczona.

Więc dlaczego nie wysłać posta na serwer Firebase z tym powiadomieniem do użytkownika B? rozumiesz ?

Tak więc, można wysłać wiadomość i czat z pocztą połączeń, aby zapewnić dostarczenie powiadomienia, jeśli użytkownik jest z aplikacji w tle. Ja też jestem w potrzebie wkrótce, przetestuję później. O czym ty mówisz?

Funkcje Google Cloud umożliwiają teraz wysyłanie powiadomień push z urządzenia do urządzenia bez serwera aplikacji. Zrobiłem funkcję cloud, która jest wyzwalana, gdy nowa wiadomość jest dodawana do bazy danych

Jest to node.js kod

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


    });

Najprostszy sposób:

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

Create Class to make Object:

public class Message {
String to;
NotifyData data;

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

Create Class to make Object:

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