Reputation: 33
Server-
var dgram = require('dgram');
var client= dgram.createSocket('udp4');
/** @requires socket.io */
var io = require('socket.io')(http);
/** Array of clients created to keep track of who is listening to what*/
var clients = [];
io.sockets.on('connection', function(socket, username){
/** printing out the client who joined */
console.log('New client connected (id=' + socket.id + ').');
/** pushing new client to client array*/
clients.push(socket);
/** listening for acknowledgement message */
client.on('message', function( message, rinfo ){
/** creating temp array to put data in */
var temp = [];
/**converting data bit to bytes */
var number= req.body.size * 2
/** acknowledgement message is converted to a string from buffer */
var message = message.toString();
/** cutting hex string to correspong to requested data size*/
var data = message.substring(0, number);
/** converting that data to decimal */
var data = parseInt(data, 16);
/** adding data to data array */
temp[0] = data
/** emitting message to html page */
socket.emit('temp', temp);
});
/** listening if client has disconnected */
socket.on('disconnect', function() {
clients.splice(clients.indexOf(client), 1);
console.log('client disconnected (id=' + socket.id + ').');
clearInterval(loop);
});
});
}
});
Client-
var socket = io.connect('192.168.0.136:3000');
socket.on(temp', function(temp){
var temp= temp.toString();
var message= temp.split(',').join("<br>");
$('#output').html('<output>' + message + '</output>');
});
When a client connects, a random number called temp is emitted to the client. The above code works when one client connects to the server. Now how can you set a new connection each time? So that if one tab is opened, it gets its own random message back, while when another tab opens, it gets its own random message back.
Upvotes: 3
Views: 19797
Reputation: 3232
From what I've seen in the code there is always one socket for each namespace (the namespace is the path part of the URI). So you can't create new sockets for the same namespace because they all will be using the same socket.
A solution is to use dynamic namespaces with regular expressions:
Server
io.of(/^\/path\/([0-9a-fA-F-]+)$/).on('connection', (socket) => {
console.log(`${socket.nsp?.name}: new connection with id '${socket.id}'`);
const namespace = socket.nsp?.name;
socket.on('event_for_server', ...);
io.of(namespace).emit('event_for_client', ...);
socket.disconnect();
});
Client (java)
final String uuid = UUID.randomUUID().toString();
final Socket socket = IO.socket("http://.../path/" + uuid, options);
socket.on("connect", args -> {
socket.emit("event_for_server", ...);
});
socket.on("event_for_client", args -> {
...
});
Upvotes: 0
Reputation: 5442
You can use the Broadcasting messages.
Broadcasting means sending a message to everyone else except for the socket that starts it.
Server:
var io = require('socket.io')(80);
io.on('connection', function (socket) {
socket.broadcast.emit('user connected');
});
Upvotes: 3
Reputation: 2718
You could try something like this: Server side:
// you have your socket ready and inside the on('connect'...) you handle a register event where the client passes an id if one exists else you create one.
socket.on('register', function(clientUuid){ // a client requests registration
var id = clientUuid == null? uuid.v4() : clientUuid; // create an id if client doesn't already have one
var nsp;
var ns = "/" + id;
socket.join(id);
var nsp = app.io.of(ns); // create a room using this id that is only for this client
clientToRooms[ns] = nsp; // save it to a dictionary for future use
// set up what to do on connection
nsp.on('connection', function(nsSocket){
console.log('someone connected');
nsSocket.on('Info', function(data){
// just an example
});
});
Client side:
// you already have declared uuid, uuidSocket and have connected to the socket previously so you define what to do on register:
socket.on("register", function(data){
if (uuid == undefined || uuidSocket == undefined) {// first time we get id from server
//save id to a variable
uuid = data.uuid;
// save to localstorage for further usage (optional - only if you want one client per browser e.g.)
localStorage.setItem('socketUUID', uuid);
uuidSocket = io(serverHost + "/" + uuid); // set up the room --> will trigger nsp.on('connect',... ) on the server
uuidSocket.on("Info", function(data){
//handle on Info
});
// initiate the register from the client
socket.emit("register", uuid);
Upvotes: 3