node-qwebchannel/mod3.js

nada

var ws = require("nodejs-websocket")

var isListening = false;
var id = 0;
var interfaces = {};

// Serialize object and return it in JSON form
function serializeObject(object) {
    var methods = [];
    var signals = [];

    for (var key in object) {
	if (typeof object[key] == "function") {
	    methods.push(key);
	} else if (typeof object[key] == "object") {
	    signals.push(key);
	}
    }

    return {
	methods: function() { return methods.map(function(key) { return [ key, methods.indexOf(key) + 1 ]; });  }(),
	signals: function() { return signals.map(function(key) { return [ key, signals.indexOf(key) + 1 ]; });  }(),
	properties: []
    }
}

function initializeObject(object) {
}

module.exports = {
    listen: function(host, port) {
	ws.createServer(function(socket) {
	    socket.on('text', function(text) {
		isListening = true;

		try {
		    var message = JSON.parse(text);
		    console.log(message);
		    switch (message.type) {
		    case 3: // INIT
			var data = {};

			for (var interface in interfaces) {
			    data = Object.assign(data, { [interface]: serializeObject(interfaces[interface]) });
			}

			socket.sendText(JSON.stringify({ data: data, id: message.id, type: 10 }));
			
			break;

		    case 4: // IDLE
			break;
		    case 6: // INVOKEMETHOD
			if (typeof interfaces[message.object] == "undefined") {
			    console.error("Object " + message.object + " not found!");
			    break;
			}

			var methods = [];
			
			for (var key in interfaces[message.object]) {
			    if (typeof interfaces[message.object][key] == "function") {
				methods.push(interfaces[message.object][key]);
			    }
			}

			if (message.method > methods.length) {
			    console.error("Method index " + message.method + " not found in object " + message.object + "!");
			    break;
			}

			if (methods[message.method - 1].length != message.args.length) {
			    console.error("Invalid number of arguments");
			    break;
			}
			
			methods[message.method - 1].apply(interfaces[message.object], message.args);

			break;
			
		    case 7: // CONNECTTOSIGNAL
			var signals = [];
			
			for (var key in interfaces[message.object]) {
			    if (typeof interfaces[message.object][key] == "object") {
				signals.push(interfaces[message.object][key]);
			    }
			}

			signals[message.signal - 1].socket = socket;
		    }
		} catch (e) {
		   console.error("Failed to parse message received from the client: " + e);
		}
	    });
	}).listen(port, host);
    },

    registerInterface: function(interfaceName, interfaceObject) {
	if (isListening) {
	    console.error("Cannot register interface " + interfaceName + " while listening");
	    return false;
	}
	
	if (typeof interfaces[interfaceName] != "undefined") {
	    console.error("The interface " + interfaceName + " is already registered!");
	    return false;
	}

	interfaces[interfaceName] = interfaceObject;

	var signalIndex = -1;
	
	for (var key in interfaceObject) {
	    if (typeof interfaceObject[key] == "object") {
		interfaceObject[key].emit = interfaceObject[key].emit.bind({ interfaceName: interfaceName, signalName: key, signalIndex: ++signalIndex + 1 });
	    }
	}

	console.log("merda");
	return interfaceObject;
    },

    method: function(callback) {
	return callback;
    },

    signal: {
	emit: function() {
	    var message = { object: this.interfaceName, signal: this.signalIndex, args: Array.prototype.slice.call(arguments), type: 1 };
	    interfaces[this.interfaceName][this.signalName].socket.sendText(JSON.stringify(message));
	}
    }
}