Finalmente, el c\u00f3digo del WebSocket en NodeJS es sencillo y eficiente, lo que facilita su mantenimiento y expansi\u00f3n seg\u00fan sea necesario.<\/p>\n\n\n\n
Android<\/h2>\n\n\n\n
La aplicaci\u00f3n Android tiene una UI muy sencilla, que incluye:<\/p>\n\n\n\n
- \n
- Un campo para agregar la URL del WebSocket.<\/li>\n\n\n\n
- Un texto que muestra el ID del dispositivo para identificarlo en el backend.<\/li>\n\n\n\n
- Dos botones: uno para conectar y otro para desconectar.<\/li>\n<\/ul>\n\n\n\n
![\"SmsUI\"](\"https:\/\/80bits.blog\/wp-content\/uploads\/2024\/06\/smsgatewayshot01-300x300.jpg\")
SmsUI<\/figcaption><\/figure>\n\n\n\n La aplicaci\u00f3n est\u00e1 desarrollada con Jetpack Compose<\/a>, por lo que es sencilla de entender a nivel UI. Por lo tanto, solo explicar\u00e9 las partes m\u00e1s esenciales del c\u00f3digo.<\/p>\n\n\n\n
Conexi\u00f3n a websocket<\/h3>\n\n\n\n
La parte central del c\u00f3digo es la conexi\u00f3n al servicio de WebSocket para esto use la librer\u00eda
OkHttp<\/code>, agregarla es tan simple como poner esto en las dependencias de graddle.<\/p>\n\n\n\nTal vez en el futuro cambie esta opci\u00f3n y la conexi\u00f3n sea mediante Mqtt, ya que tengo un servidor para ello<\/a><\/p>\n\n\n\n
implementation(\"com.squareup.okhttp3:okhttp:4.12.0\")\n<\/code><\/pre>\n\n\n\nHay una clase llamada
WebSocketManager<\/code>. Esta clase tiene una funci\u00f3n llamadastart<\/code>, que recibe dos par\u00e1metros: la URL (direcci\u00f3n y puerto) hacia donde se conectar\u00e1 el WebSocket y un ID. Este ID debe ser \u00fanico dentro del backend de WebSocket, por lo que se genera un UUID v4 para este fin.<\/p>\n\n\n\nprivate var client: OkHttpClient = OkHttpClient() \nprivate var webSocket: WebSocket? = null \nprivate var connectionStatus: CompletableFuture? = null\n\nfun start(url: String, id: String): Boolean { \n return try { \n connectionStatus = CompletableFuture() \n val request = Request.Builder().url(\"ws:\/\/$url?id=$id\").build() \n webSocket = client.newWebSocket(request, MyWebSocketListener(listener)) \n return connectionStatus!!.get() \n } catch (e: Exception) { \n false \n } \n}\n<\/code><\/pre>\n\n\n\nComo se puede ver en el c\u00f3digo anterior, la conexi\u00f3n es bastante sencilla. Hay dos partes esenciales: la primera es que, para crear el WebSocket y conectarse a \u00e9l, se necesita enviar al m\u00e9todo
newWebSocket<\/code> un objetoRequest<\/code> que se crea b\u00e1sicamente con la URL y una implementaci\u00f3n de la interfazWebSocketListener<\/code>, que en este caso es mi clase llamadaMyWebSocketListener<\/code>.<\/p>\n\n\n\nLa diferencia aqu\u00ed radica en que, en el constructor de
MyWebSocketListener<\/code>, env\u00edo otra interfaz que puede ser implementada para propagar como callback el m\u00e9todoonMessage<\/code> de la interfazWebSocketListener<\/code> de OkHttp.<\/p>\n\n\n\ninterface MessageListener { \n fun onMessage(message: SmsModel) \n}\n<\/code><\/pre>\n\n\n\nEsta interface la uso para propagar el menaje que llega dentro del m\u00e9todo
onMessage<\/code>.<\/p>\n\n\n\nprivate inner class MyWebSocketListener(private val callback: MessageListener)\n<\/code><\/pre>\n\n\n\noverride fun onMessage(webSocket: WebSocket, text: String) { \n try { \n println(\"Message received: $text\") \n val gson = Gson() \n val message = gson.fromJson(text, SmsModel::class.java) \n println(\"Message received: $message\") \n callback.onMessage(message) \n } catch (e: Exception) { \n println(\"Message received: $text\") \n } \n}\n<\/code><\/pre>\n\n\n\nAl final del m\u00e9todo se llama a
callback.onMessage<\/code>, al que se le env\u00eda un objeto de tipoSmsModel<\/code>, que se crea a partir del string de tipo JSON que recibe desde el WebSocket usando la librer\u00edaGson<\/code>.<\/p>\n\n\n\nimplementation(\"com.google.code.gson:gson:2.11.0\")\n<\/code><\/pre>\n\n\n\ndata class SmsModel( \n val number: String, \n val text: String \n)\n<\/code><\/pre>\n\n\n\nEsta interface solo sirve para poder propagar el mensaje y no implementar toda la interface
WebSocketListener<\/code> en otro lugar.<\/p>\n\n\n\nComo \u00faltimo detalle, tengo un objeto llamado
connectionStatus = CompletableFuture()<\/code>. Esto lo \u00fanico que hace es bloquear el hilo actual desde donde se llama a la claseWebSocketManager<\/code> para saber si el WebSocket se conect\u00f3 o no. Debido a que, como pueden ver, la conexi\u00f3n se maneja en una interfaz y callback, esto es un m\u00e9todo asincr\u00f3nico y quer\u00eda convertirlo en sincr\u00f3nico para que desde la interfaz se sepa si la conexi\u00f3n se realiz\u00f3 o no.<\/p>\n\n\n\nCompletableFuture<\/a><\/p>\n\n\n\n
Servicio persistente<\/h3>\n\n\n\n
Una vez que se tiene el c\u00f3digo para la conexi\u00f3n al backend, lo que necesitamos es crear un servicio en Android que persista en segundo plano para estar recibiendo los mensajes del WebSocket y enviar los SMS. Este servicio debe funcionar tanto si el sistema est\u00e1 en otra app como si est\u00e1 con la pantalla apagada.<\/p>\n\n\n\n
Para lograr esto en Android, tenemos que crear un servicio implementando la clase abstracta
Service<\/code>.<\/p>\n\n\n\nEsta implementaci\u00f3n la hice en la clase
ForegroundService<\/code>, donde la conexi\u00f3n al WebSocket se maneja en el m\u00e9todoonStartCommand<\/code>. Pero para que el servicio funcione de manera persistente, se necesitan hacer dos cosas:<\/p>\n\n\n\n- \n
NotificationChannel<\/code>:<\/strong> Es un canal de notificaci\u00f3n necesario a partir de Android 8.0 para agrupar y categorizar notificaciones con configuraciones espec\u00edficas.<\/li>\n\n\n\nNotification<\/code>:<\/strong> Es el contenido visible de la notificaci\u00f3n que ves en la barra de notificaciones y que contiene el mensaje que deseas mostrar al usuario.<\/li>\n<\/ul>\n\n\n\nAl final, la notificaci\u00f3n debe pasarse al m\u00e9todo
startForeground<\/code> junto con un ID de identificaci\u00f3n para que el sistema mantenga el servicio de manera persistente y no cierre el proceso.<\/p>\n\n\n\nPara ejecutar este servicio, deber\u00e1 crearse un Intent. En el c\u00f3digo, se hace de la siguiente manera:<\/p>\n\n\n\n
viewModel.onIdChange(UUID.randomUUID().toString()) \nval serviceIntent = Intent(context, ForegroundService::class.java) \nserviceIntent.putExtra(context.getString(R.string.extra_url), viewModel.urlText) \nserviceIntent.putExtra(context.getString(R.string.extra_id), viewModel.id) \ncontext.startService(serviceIntent)\n<\/code><\/pre>\n\n\n\nLo relevante est\u00e1 en la segunda l\u00ednea, donde se pasa la referencia de la clase
ForegroundService<\/code> al Intent. Una vez se tiene el objeto Intent, se env\u00eda usando el contexto actual mediante la \u00faltima l\u00ednea con el m\u00e9todostartService<\/code>.<\/p>\n\n\n\nLas otras l\u00edneas son datos que se env\u00edan al servicio mediante
Extras<\/code>. Estos datos incluyen el ID y la URL que necesito para que el WebSocket se conecte al servicio. Estos datos se env\u00edan al servicio y del servicio al objeto de WebSocket para su conexi\u00f3n.<\/p>\n\n\n\nEnv\u00edo de mensajes<\/h3>\n\n\n\n
El env\u00edo de mensajes es bastante simple, pero se necesitan algunos permisos en el dispositivo para poder hacerlo. Adem\u00e1s, el c\u00f3digo que implement\u00e9 solo funciona para la API 31 en adelante. Esto se debe a que mis snippets de c\u00f3digo para esta funcionalidad estaban desfasados y quer\u00eda implementar m\u00e9todos m\u00e1s nuevos.<\/p>\n\n\n\n
En todo caso, la implementaci\u00f3n es realmente sencilla y pueden ver c\u00f3mo funciona la clase SmsManager aqu\u00ed<\/a>.<\/p>\n\n\n\n
Mi clase
SmsService<\/code> tiene un solo m\u00e9todo que essendSms<\/code> y eso es todo:<\/p>\n\n\n\nfun sendSms(message: SmsModel) { \n \n if (ContextCompat.checkSelfPermission( \n context, \n \"android.permission.SEND_SMS\" \n ) == PackageManager.PERMISSION_GRANTED \n ) { \n \n if (message.number.isNotEmpty() && message.text.isNotEmpty()) { \n val subscriptionManager = \n context.getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE) as SubscriptionManager \n val subscriptionId = \n subscriptionManager.activeSubscriptionInfoList[0].subscriptionId \n val smsManager = context.getSystemService(SmsManager::class.java) \n .createForSubscriptionId(subscriptionId) \n smsManager.sendTextMessage(message.number, null, message.text, null, null) \n } \n } \n}\n<\/code><\/pre>\n\n\n\nLas nuevas APIs para el env\u00edo de mensajes requieren que se verifiquen los permisos de env\u00edo de SMS antes de usarlas. Como pueden ver en el c\u00f3digo, esto se realiza antes de generar un env\u00edo.<\/p>\n\n\n\n
Este m\u00e9todo no tiene un mecanismo para saber si el mensaje se envi\u00f3 o no, por lo que, si el env\u00edo falla, no se puede saber de ninguna forma actualmente.<\/p>\n\n\n\n
Para implementar un mecanismo, hay que crear un Intent de tipo Broadcast. En el futuro, tal vez haga eso, para que en caso de que el SMS no se env\u00ede, se notifique al WebSocket y se intente nuevamente.<\/p>\n\n\n\n
WebSocket en NodeJS<\/h2>\n\n\n\n
No entrar\u00e9 en detalles t\u00e9cnicos sobre el c\u00f3digo del WebSocket, ya que es realmente sencillo de implementar en NodeJS y a\u00fan m\u00e1s sencillo es el c\u00f3digo que escrib\u00ed.<\/p>\n\n\n\n
const WebSocket = require('ws');\n\nconst { v4: uuidv4 } = require('uuid');\n\nconst { URL } = require('url');\n\nconst getRandomElementFromSet = set => {\n\nconst arr = Array.from(set).filter(item => item.id !== 'host');\n\nreturn arr[Math.floor(Math.random() * arr.length)];\n\n};\n\nconst wss = new WebSocket.Server({ port: 8080 });\nlet clients = new Set();\n\nwss.on('connection', (ws, req) => {\n\nclients.add(ws);\n\nconst url = new URL(req.url, `http:\/\/${req.headers.host}`);\n\nconst deviceId = url.searchParams.get('id');\n\nif (deviceId === null || deviceId === undefined || deviceId === '') {\n\nws.id = uuidv4();\n\n}\n\nelse {\n\nws.id = deviceId;\n\n}\n\nws.on('message', message => {\n\nconsole.log(`Received message ${message} from connection ${ws.id}`); \n\nconst messages = JSON.parse(message);\n\nif (!messages) {\n\nconsole.log('No messages');\n\nreturn;\n\n}\n\nmessages.forEach(m => {\n\nconst randomClient = getRandomElementFromSet(clients);\n\nif (!randomClient) {\n\nconsole.log('No clients connected');\n\nreturn;\n\n}\n\nif (randomClient.readyState === WebSocket.OPEN) {\n\nconst messageToSend = JSON.stringify(m);\n\nrandomClient.send(`${messageToSend}`);\n\nconsole.log(`Sent message ${messageToSend} to connection ${randomClient.id}`);\n\n}\n\nelse {\n\nconsole.log(`Client ${randomClient.id} is not connected`);\n\nclients.delete(randomClient);\n\n}\n\n});\n\n});\n\nws.on('close', (code, reason) => {\n\nconsole.log(`Connection ${ws.id} closed. Code: ${code}. Reason: ${reason}`);\n\nclients.delete(ws);\n\n});\n\nconsole.log(ws.id);\n\n});\n<\/code><\/pre>\n\n\n\nSimplemente se genera una escucha para conexiones WebSocket en el puerto 8080. Cuando un cliente nuevo (la app) se conecta al sistema, se obtiene su ID y se asigna ese ID como una propiedad en el objeto de WebSocket. Si no tiene un ID, se genera un UUID al azar y se agrega a un conjunto de clientes.<\/p>\n\n\n\n
Hay un ID que se espera que sea llamado
host<\/code>. Este ser\u00eda el servidor que enviar\u00e1 los mensajes a los clientes. Por cada mensaje que se env\u00ede, se obtiene un cliente aleatorio y se le env\u00eda el mensaje para que la app lo reciba y env\u00ede el SMS.<\/p>\n\n\n\nEl host deber\u00e1 enviar un string de tipo JSON, que deber\u00e1 ser un array de objetos con dos propiedades, tal como en este ejemplo:<\/p>\n\n\n\n
[\n{\n\"number\": \"123456\",\n\n\"text\": \"hola\"\n}\n]\n<\/code><\/pre>\n\n\n\nCon esto, nos aseguramos de que se puedan enviar muchos mensajes en una sola llamada y que se env\u00eden desde distintos dispositivos conectados.<\/p>\n\n\n\n
Nota: El env\u00edo es aleatorio, por lo que la distribuci\u00f3n y la probabilidad de que se usen todos los tel\u00e9fonos conectados de manera homog\u00e9nea no est\u00e1n aseguradas de ning\u00fan modo.<\/p>\n\n\n\n
Para asegurar el uso equitativo de los dispositivos, lo mejor ser\u00eda implementar un mecanismo de planificaci\u00f3n como Round-Robin<\/a>.<\/p>\n\n\n\n
Repositorio<\/h1>\n\n\n\n