node - firebase cloud messaging pricing
¿Cómo enviar mensajes de dispositivo a dispositivo usando Firebase Cloud Messaging? (13)
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
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?
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);
}
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?
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 ;
});
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:
La función se activa al escribir en la ruta de la base de datos en tiempo real donde se almacenan los seguidores.
La función compone un mensaje para enviar a través de FCM.
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.
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.
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;
}
}
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 () ;
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).
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);
}
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:
- Tienes que usar la misma cuenta de Google en los dispositivos
- 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"
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.
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