CODEWITHSUNDEEP
javascripthtmlnode.jssocketssocket.io
TheFlight
TheFlight

Reputation: 33

Using Socket.io with multiple clients connecting to same server

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

Answers (3)

lmiguelmh
lmiguelmh

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

J.C. Gras
J.C. Gras

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

mkaran
mkaran

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

Related Questions