Archivo de la etiqueta: NodeJS

Conectarse a socket.io de NodeJS con Android

logo android

Lo primero es agregar la dependencia de la librería a nuestro archivo grade en nuestro proyecto en Android Studio.
compile 'com.github.nkzawa:socket.io-client:0.4.0'

Así en la actividad que queramos utilizar el socket creamos el objeto Socket.
Socket socket;

y algunas constantes que utilizaremos en nuestro código.

final static String URL_SOCKET = "http://localhost";
final static String MY_EVENT = "my event";
final static String PARAM_NAME = "name";
final static String PARAM_IMAGE = "image";

Instanciamos nuestra conexión al servidor pasando como parámetro la url de este mismo.

try{
  /* Instance object socket */
  socket = IO.socket(URL_SOCKET);
}catch (URISyntaxException e){
  e.printStackTrace();
}

Podemos instanciar el objecto con opciones predeterminadas para que se reconecte el socket.

IO.Options opts = new IO.Options();
opts.forceNew = true;
opts.reconnection = false;
try{
  /* Instance object socket */
  socket = IO.socket(URL_SOCKET, opts);
}catch (URISyntaxException e){
  e.printStackTrace();
}

O para utilizar conexiones SSL por defecto o como parámetro al instanciar el objeto

/* Default SSLContext for all sockets */
IO.setDefaultSSLContext(mySSLContext);

/* Set as an option */
opts = new IO.Options();
opts.sslContext = mySSLContext;
try{
  /* Instance object socket */
  socket = IO.socket(URL_SOCKET, opts);
}catch (URISyntaxException e){
  e.printStackTrace();
}

Luego creamos los eventos principales de nuestro socket: EVENT_CONNECT y EVENT_DISCONNECT, estos son los que recibirán las emisiones desde el servidor.

socket.on(Socket.EVENT_CONNECT, new Emitter.Listener(){
  @Override
  public void call(Object... args) {
    /* Our code */
  }
}).on(Socket.EVENT_DISCONNECT, new Emitter.Listener(){
  @Override
  public void call(Object... args) {
    /* Our code */      
  }
});

Y crear nuestros propios eventos listener

socket.on(MY_EVENT, new Emitter.Listener(){
  @Override
  public void call(Object... args) {
    /* Our code */      
  }
});

Con esto ya podemos abrir la conexión
socket.connect();

Además disponemos de otras funciones como para verificar el estado de la conexión.
socket.connected()

Para desconectar nuestro socket.
socket.disconnect()

Si lo que queremos es emitir eventos por nuestro socket utilizamos, enviando cadenas de texto o también datos binarios.

JSONObject obj = new JSONObject();
obj.put(PARAM_NAME, "Pablo");
obj.put(PARAM_IMAGE, new byte[42]);

/* Emit event */
socket.emit(MY_EVENT, obj)

También podemos capturar el callback que retorna el servidor

socket.emit(MY_EVENT, obj, new Ack() {
  @Override
  public void call(Object... args) {
    /* Our code */
  }
});

Y eso es todo, Saludos!

Cluster en NodeJS con ExpressJS

expressnodejs

Trabajar con Cluster es una excelente forma de mejorar el rendimiento de nuestras aplicaciones. Nodejs es mono-proceso, por lo que no podemos por ejemplo aprovechar de forma eficiente una máquina con varios nucleos. Ahora veremos como hacerlo.
Primero creamos una simple aplicación nodejs con expressjs.

[javascript]
var express = require(‘express’);
var app = express();

app.get(‘/’, function (req, res) {
res.send(‘Hello World!’);
});

app.listen(3000);
console.log(‘Application running!’);
[/javascript]

Instalamos la librería “cluster”.

sudo npm install cluster

Luego lo que hacemos es levantar un folk (proceso) por cada cpu que tenga nuestra máquina.

[javascript]
var cluster = require(‘cluster’);

if(cluster.isMaster){
var cpuCount = require(‘os’).cpus().length;
for(var i = 0; i < cpuCount; i += 1){
cluster.fork();
}
}else{
var express = require(‘express’);
var app = express();

app.get(‘/’, function (req, res) {
res.send(‘Hello World!’);
});

app.listen(3000);
console.log(‘Application running!’);
}
[/javascript]

Y listo! Y probar como anda ahora 😉
Ahora bien, si uno de nuestros “trabajadores” muere, podemos reemplazarlo fácilmente.

[javascript]
if(cluster.isMaster){

cluster.on(‘exit’, function(worker){
console.log(‘Worker ‘ + worker.id + ‘ died!’);
cluster.fork();
});
}else{
[/javascript]

Puedes encontrar la documentación completa en la página oficial de Nodejs.
Código github
Saludos!

Google Cloud Messaging con NodeJS

google-cloud-messaging

Google Cloud Messaging una de las funcionalidades más lindas que he utilizando en Android, sin tener la necesidad de tener que conectarnos cada vez al servidor, podemos mandar información a través de push a los dispositivos que tengan instalada nuestra aplicación para luego ser tratada, perfecto para notificaciones, ya que ocurre al instante. Ese post no está dedicado a explicar como funciona gcm, si lo desean pueden consultar la documentación oficial de Google para más detalles Google Developer
Entonces lo primero es crear nuestra librería con la cuál nos comunicamos en los servidores de Google, la llamaremos gcm.js

[javascript]
var request = require(‘request’);
var GCM = function(api_key) {
this._api_key = api_key;
}
GCM.prototype.send = function(msg, callback) {
request.post({
uri: ‘https://android.googleapis.com/gcm/send’,
json: msg,
headers: {
Authorization: ‘key=’ + this._api_key
}
}, function(err, response, body) {
callback(err, body);
})
}
module.exports = GCM;
[/javascript]

Recuerden que para como estamos importando ‘request’ debemos instalarla en nuestro proyecto con:

sudo npm install request

Paso seguido, creamos la función que determinará a que usuario notificaremos. Importamos el gcm.js que acabamos de crear y reemplazamos las XxxXXXxXxxXxXxXxXXxXxXxXxXxXxXxXxXx por nuestro api key (recuerden que deben dar los respectivos permisos en Google Console), para este ejemplo estoy creando un modulo llamado ‘notify’ que, apoyandome con ExpressJS, recibe a través de una consulta POST el parámetro user_id, luego en un schema llamado ‘User’ busco en mi base de datos un usuario con ese id y obtengo su gcm_id, que había guardado previamente desde el dispositivo del usuario, para poder rutear el mensaje que deseo enviar.

[javascript]
var GCM = require(‘./gcm.js’);
var gcm = new GCM(‘XxxXXXxXxxXxXxXxXXxXxXxXxXxXxXxXxXx’);

exports.notify = function(req, res){
var user_id = req.body.user_id;
User.findOne({_id: user_id}, function(err, user){
if(!err && user){
var msg = {
registration_ids: [user.gcm_id],
collapse_key: "your_collapse_key",
time_to_live: 180,
data: {
message: ‘Este es mi mensaje!’
}
};
gcm.send(msg, function(err, response){
console.log(response);
res.send(response.success);
});
}else{
res.send(‘false’);
}
});
}
[/javascript]

Y listo! Una implementación bastante sencilla de Google Cloud Message en NodeJS.
Saludos!

Calcular distancia entre dos coordenadas en javascript #nodejs

javascript_logo_unofficial-300x300

Esta función siempre está en mis proyectos donde utilizo coordenadas georeferencias (latitud y longitud), casi todos ellos son proyectos para dispositivos móviles.

function getDistanceFromLatLonInKm(lat1,lon1,lat2,lon2) {
  var R = 6371;
  var dLat = (lat2-lat1) * (Math.PI/180);
  var dLon = (lon2-lon1) * (Math.PI/180);
  var a =
    Math.sin(dLat/2) * Math.sin(dLat/2) +
    Math.cos(lat1 * (Math.PI/180)) * Math.cos(lat2 * (Math.PI/180)) *
    Math.sin(dLon/2) * Math.sin(dLon/2)
    ;
  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
  var d = R * c;
  return d;
}

Retorna la distancia en kilómetros.
Saludos!

Carga de archivos en Amazon S3 desde NodeJS

nodejs   amazon

Hace muchísimo tiempo que no escribo nada aquí!, me consumió el mundo Enterprise 🙁 pero ya estoy libre!. Ahora a lo que nos compete. Esta guía no trata del funcionamiento de Amazon S3 ni de NodeJS, ojo con eso. Comenzamos!
Primero a través de nuestra terminal instalamos la librería para conectarnos a Amazon S3

npm install aws-sdk

Luego en nuestro archivo .js importamos la librería y la configuramos con nuestras credenciales de acceso. Para finalmente crear la instancia s3 que utilizaremos para accesar al S3 de Amazon.

var aws = require('aws-sdk');
aws.config.update({
    accessKeyId: 'XXXXXXXXXXXXXXXXXXXX',
    secretAccessKey: 'XXxxXxXXXxxxXxXXXxXXxxXXxxXXXxxxx'
});
var s3 = new aws.S3();

Ahora ya podemos listar nuestros buckets.

s3.listBuckets(function(err, data){
    for(var index in data.Buckets){
        var bucket = data.Buckets[index];
        console.log("Bucket: ", bucket.Name, ' : ', bucket.CreationDate);
    }
});

Y insertar una nueva imagen. Para estos casos yo siempre mando la imagen en base64, entonces antes de guardarla en el S3 tengo que meterla a un Buffer

var image = req.body.image;
var buff = new Buffer(image.replace(/^data:image\/\w+;base64,/, ""),'base64');

Creo una variable con los parámetros para el putObject

var params = {
    Bucket: 'nombre_bucket',
    Key: 'nombre_imagen.png',
    Body: buff,
    ACL: 'public-read'
};

Un parámetro importante en la linea anterior es ACL, ‘public-read’ permite que la imagen pueda ser (como su nombre lo dice) pública.

s3.putObject(params, function(err, data){
    if(!err){
        console.log('load ok');
    }else{
        console.log('load fail');
    }
});

Y si es un archivo que tienen en su disco

var params = {Bucket: 'myBucket', Key: 'nombre_archivo.png'};
var file = require('fs').createWriteStream('/path/to/file.jpg');
s3.getObject(params).createReadStream().pipe(file);

Y eso es todo!
Comentarios y sugerencias son totalmente bienvenidos, saludos!