node - firebase cloud messaging pricing

¿Cómo enviar mensajes de dispositivo a dispositivo usando Firebase Cloud Messaging?

Question

Después de buscar en los documentos, no pude encontrar ninguna información sobre cómo enviar mensajes de dispositivo a dispositivo utilizando FCM sin el uso de un servidor externo.

Por ejemplo, si estaba creando una aplicación de chat, tendría que enviar notificaciones automáticas a los usuarios sobre mensajes no leídos, ya que no estarán en línea todo el tiempo y no puedo tener un servicio persistente en segundo plano que siempre esté conectado a la base de datos en tiempo real porque eso requeriría demasiados recursos.

Entonces, ¿cómo enviaría una notificación push a un usuario "A" cuando un determinado usuario "B" le envía un mensaje de chat? ¿Necesito un servidor externo para esto o puedo hacerlo solo con servidores Firebase?

Answer 1

1) suscriba un nombre de tema idéntico, por ejemplo:

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

2) enviar mensajes dentro de la aplicación

GoogleFirebase: cómo enviar mensajes de tema

Answer 2

En mi caso, utilizo la retrofit con esta clase Mensaje:

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

Datos

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

Notificación

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

esta es la llamada

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

nuestro ServiceAPi

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

Answer 3

Entonces tuve una idea aquí. Consulte: Si el FCM, así como el GCM, tiene una solicitud de punto final para http donde podemos enviar una publicación json con nuestros datos de mensaje, incluidos los tokens de dispositivos en los que queremos que se entregue este mensaje.

Entonces, ¿por qué no enviar una publicación al servidor Firebase con esta notificación para que se entregue al usuario B? tú entiendes ?

Por lo tanto, envía el mensaje y chatea con una publicación de llamada para garantizar la entrega de la notificación si el usuario está con su aplicación en segundo plano. También lo necesito pronto, lo probaré más tarde. ¿Sobre qué dices?

Answer 4

Google Cloud Functions ahora permite enviar notificaciones push de dispositivo a dispositivo sin un servidor de aplicaciones. He hecho la función de nube que se activa cuando se agrega un nuevo mensaje en la base de datos

Es el código de 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 ;
});

Answer 5

Google Cloud Functions ahora permite enviar notificaciones push de dispositivo a dispositivo sin un servidor de aplicaciones.

here en Google Cloud Functions:

Los desarrolladores pueden usar Cloud Functions para mantener a los usuarios interesados ​​y actualizados con información relevante sobre una aplicación. Considere, por ejemplo, una aplicación que permita a los usuarios seguir las actividades de los demás en la aplicación. En dicha aplicación, una función activada por las escrituras de Realtime Database para almacenar nuevos seguidores podría crear notificaciones de Firebase Cloud Messaging (FCM) para que los usuarios apropiados sepan que han ganado nuevos seguidores.

Ejemplo:

1. La función se activa al escribir en la ruta de la base de datos en tiempo real donde se almacenan los seguidores.

2. La función compone un mensaje para enviar a través de FCM.

3. FCM envía el mensaje de notificación al dispositivo del usuario.

Aquí hay un proyecto de demostración para enviar notificaciones push de dispositivo a dispositivo con Firebase y Google Cloud Functions.

Answer 6

Hacer una solicitud HTTP POST con el enlace https://fcm.googleapis.com/fcm/send con el encabezado y los datos requeridos me ayudó. En el fragmento de código siguiente Constants.LEGACY_SERVER_KEY LEGACY_SERVER_KEY es una variable de clase local, puede encontrarla en la Settings->Cloud Messaging->Legacy Server key proyecto Firebase- Settings->Cloud Messaging->Legacy Server key en la nube- Settings->Cloud Messaging->Legacy Server key . regToken pasar el token de registro del dispositivo, es decir, regToken en el fragmento de código a continuación referenciado HERE.

Por fin necesita la dependencia de la biblioteca okhttp para que este fragmento funcione.

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

Además, si desea enviar un mensaje a un tema en particular, reemplace regToken en json como este

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

y no olvide agregar permiso de INTERNET en su AndroidManifest.xml.

IMPORTANTE : - El uso del código anterior significa que la clave del servidor reside en la aplicación cliente. Eso es peligroso ya que alguien puede profundizar en su aplicación y obtener la clave del servidor para enviar notificaciones maliciosas a sus usuarios.

Answer 7

La forma más simple:

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

Crear clase para hacer objeto:

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

Crear clase para hacer objeto:

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

Answer 8

Puede hacerlo utilizando la solicitud Volly Jsonobject ...

siga estos pasos primero:

1 copie la clave del servidor heredado y guárdelo como Legacy_SERVER_KEY

Clave de servidor heredado

puedes ver en la imagen como llegar

2 Necesitas dependencia de Volley

compile ''com.mcxiaoke.volley: biblioteca: 1.0.19''

Código para enviar 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);
}

Simplemente llame a sendFCMPush () ;

Answer 9

Puede usar la base de datos en tiempo real de firebase para hacerlo. Puede crear una estructura de datos para almacenar chats y agregar observadores para los hilos de conversación de ambos usuarios. Todavía tiene arquitectura de dispositivo - servidor - dispositivo, pero en este caso no hay servidor adicional por parte de los desarrolladores. Esto usa los servidores firebase. Puede consultar un tutorial aquí (ignore la parte de la interfaz de usuario, aunque también es un buen punto de partida para los marcos de interfaz de usuario de chat).

Chat en tiempo real de Firebase

Answer 10

Puedes usar Retrofit. Suscriba dispositivos a las noticias temáticas. Enviar notificaciones de un dispositivo a otro.

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

y

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

y FirebaseAPI

public interface FirebaseAPI {
@POST("/fcm/send")
Call<Message> sendMessage(@Body Message message);
}

Answer 11

Sí, es posible hacerlo sin ningún servidor. Puede crear un grupo de dispositivos del lado del cliente y luego intercambiar mensajes en el grupo. Sin embargo, hay limitaciones:

1. Tienes que usar la misma cuenta de Google en los dispositivos
2. No puedes enviar mensajes de alta prioridad

Referencia: documento de Firebase Consulte la sección "Administración de grupos de dispositivos en aplicaciones cliente de Android"

Answer 12

Si tiene un token fcm (gcm) del dispositivo al que desea enviar una notificación. Es solo una solicitud posterior para enviar la notificación.

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

Answer 13

ACTUALIZACIÓN: ahora es posible usar las funciones de la nube de Firebase como servidor para manejar las notificaciones push. Mira su documentación here

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

De acuerdo con los documentos, debe implementar un servidor para manejar las notificaciones push en la comunicación de dispositivo a dispositivo.

Antes de poder escribir aplicaciones cliente que usan Firebase Cloud Messaging, debe tener un servidor de aplicaciones que cumpla con los siguientes criterios:

...

Deberá decidir qué protocolo (s) de servidor de conexión FCM desea utilizar para permitir que su servidor de aplicaciones interactúe con los servidores de conexión FCM. Tenga en cuenta que si desea usar la mensajería ascendente de sus aplicaciones cliente, debe usar XMPP. Para una discusión más detallada de esto, vea Elegir un protocolo de servidor de conexión FCM .

Si solo necesita enviar notificaciones básicas a sus usuarios desde el servidor. Puede usar su solución sin servidor, Notificaciones de Firebase .

Vea una comparación aquí entre las notificaciones de FCM y Firebase: firebase.google.com/support/faq/#messaging-difference