I need my UDP server to send a package to all clients.

Server code:

while (true) {

      byte[] buf = new byte[256];
      DatagramPacket packet = new DatagramPacket(buf, buf.length);

      try {
        socket.receive(packet);
      } catch (Exception e) {
        System.err.println(e.getMessage());
      }
      System.out.print("O servidor recebeu um pacote do endereco " + packet.getAddress() + "\n");

      // Reenviar pro cliente
      InetAddress ed = packet.getAddress();
      int portad = packet.getPort();
      //manda de volta para o cliente.
      packet = new DatagramPacket(buf, buf.length, ed, portad);
      try {
        socket.send(packet);
      } catch (Exception e) {
        System.err.println(e.getMessage());
      }
    }

Client Send:

private void startStreaming() {

        Log.i(TAG, "Starting the background thread to stream the audio data");

        Thread streamThread = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    while (falando == true) {
                        record.startRecording();
                        byte lin[] = new byte[BUFFER_SIZE];
                        am.setMode(AudioManager.MODE_IN_COMMUNICATION);
                        // read the data into the buffer
                        record.read(lin, 0, BUFFER_SIZE);
                        InetAddress group = InetAddress.getByName(groupIp); //Keep this as the same multicast ip as in your client
                        DatagramPacket packet = new DatagramPacket(lin, lin.length, group, port);
                        //Envia o audio
                        try {
                            socket.send(packet);
                            Log.d(TAG, "Enviando audio");
                        } catch (Exception e) {
                            System.err.println(e.getMessage());
                        }
                    }
                } catch (Exception e) {
                    Log.e(TAG, "Exception: " + e);
                }
            }
        });

        // start the thread
        streamThread.start();
    }

client listen

private void comecarEscutar() {

        Thread listenThread = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    byte lin[] = new byte[BUFFER_SIZE+=4096];
                    while (true) {
                        // read the data into the buffer
                        record.read(lin, 0, BUFFER_SIZE);
                        InetAddress group = InetAddress.getByName(groupIp);
                        DatagramPacket packet = new DatagramPacket(lin, lin.length, group, port);

                        //Recebe o Audio
                        try {
                            socket.receive(packet);
                            track.write(packet.getData(), 0, BUFFER_SIZE);
                            Log.d(TAG, "Reproduzindo Audio");
                            track.play();
                        } catch (Exception e) {
                            System.err.println(e.getMessage());
                        }
                    }
                } catch (Exception e) {
                    Log.e(TAG, "Exception: " + e);
                }
            }
        });

        // start the thread
        listenThread.start();
    }

In addition I would also like tips for optimizing the audio, which runs in real time

@undefined Okay, any tips to improve the loss of audio packages?

@undefined I did not use any tools, I just know that the audio was going normally and giving playback in real time when speaking and listening on the same thread, after I made a thread just to listen to the audio it almost doesn’t reach the client, hardly to understand the audio .

@undefined after many tests, I realized that the customer only receives the package if it is localhost? Can you tell me why this happens? I changed the server and put a thread, it is sending right on localhost, but when the server is run on an external machine (VPS) it is unable to return packages to the client. Am I doing something wrong?

EDIT:

Network tests via wireshark show that the packet is being sent via ssh to the client, so that must be why it is not receiving it.

CODE SERVER

class Server {

    static int port = 50005; // Porta para receber do cliente
    static int listen = 50010; // Porta para registrar o cliente
    static int removePort = 50011; // Porta para remover o cliente
    static int listenerPort = 50015; // Porta para enviar pro cliente
    static DatagramSocket serverSocket, listenSocket, removeSocket, broadcastSocket;
    static byte[] receiveData, listenData, removeData;
    static DatagramPacket receivePacket, listenPacket, removePacket;
    static ArrayList<String> listeners = new ArrayList<String>();
    static boolean active = true;


    public static void main(String args[]) throws Exception {
        //Definir o soquete do datagrama de recebimento
        serverSocket = new DatagramSocket(port);
        listenSocket = new DatagramSocket(listen);
        removeSocket = new DatagramSocket(removePort);

        //Define Broadcasting socket
        broadcastSocket = new DatagramSocket();

        //Define data size, 1400 is best sound rate so far
        receiveData = new byte[1400];
        listenData = new byte[256];
        removeData = new byte[256];

        //Definir o objeto DatagramPacket
        receivePacket = new DatagramPacket(receiveData, receiveData.length);
        listenPacket = new DatagramPacket(listenData, listenData.length);
        removePacket = new DatagramPacket(removeData, removeData.length);

        // Recebendo dados
        Thread t = new Thread() {
            @Override public void run() {
                getPackets();
            }
        };
        t.start();

        // Esperando Conexão
        Thread l = new Thread() {
            @Override public void run() {
                listen();
            }
        };
        l.start();

        // Esperando desconectar
        Thread r = new Thread() {
            @Override public void run() {
                remove();
            }
        };
        r.start();
    }

    /***
     * Function that gets the audio data packets
     * saves them, and outputs the audio to the speakers.
     */
    public static void getPackets() {
        while (active) {
            try {
                //Aguarde até o pacote ser recebido
                serverSocket.receive(receivePacket);
                System.out.println("Receiving Data");
                //Enviar dados
                sendData(receivePacket.getData());
            } catch (IOException e) {
            
            }
        }
    }

    /***
     * Função que escuta se houver alguma conexão feita com
     * a porta do ouvinte e cria um soquete de datagrama para transmitir áudio
     * para quem se conecta
     */
    
    public static void listen() {
        while (active) {
            try {
                //Wait until packet is received
                listenSocket.receive(listenPacket);
                listeners.add(listenPacket.getAddress().getHostAddress());
                System.out.println("Client received");

            } catch (IOException e) {
                if(active) {
                    listen();
                }
            }
        }
    }

    public static void remove() {
        while (active) {
            try {
                //Wait until packet is received
                removeSocket.receive(removePacket);
                listeners.remove(getUser(removePacket.getAddress().getHostAddress()));
                System.out.println("Client logout");

            } catch (IOException e) {
                if(active) {
                    listen();
                }
            }
        }
    }

    public static int getUser(String ed) {
        try {
            for (int i = 0; i < listeners.size(); i++) {
                if(listeners.get(i).equals(ed)) {
                    return i;
                }
            }
        } catch (Exception e) {
            //If it failed to send don't do anything
            e.printStackTrace();
        }
        return -1;
    }

    public static void sendData(byte[] data) {
        try {
            for (int i = 0; i < listeners.size(); i++) {
                InetAddress destination = InetAddress.getByName(listeners.get(i));
                broadcastSocket.send(new DatagramPacket(data, data.length, destination, listenerPort));
                System.out.println("Sending Data to ip " + destination + " port " + listenerPort);
            }
        } catch (Exception e) {
            //If it failed to send don't do anything
            e.printStackTrace();
        }
    }
}

@undefined There is the problem even though the encoding was done all in UDP, for some reason the server sends it back when the packet is in the VPS via ssh. At localhost it sends the packet normally.