Seltsames Verhalten mit Datagram in UDP empfangen Funktion in Android

Question

Ich versuche, einen UDP-Test zu implementieren, um darüber zu lernen. Ich habe eine Server-Anwendung in C# für Windows und eine Client-App für Android.

Ich versuche, einen hausgemachten Suchdienst zu implementieren. Der Server wartet kontinuierlich auf UDP-Pakete mit einer festen Zeichenfolge ("LazyRemote"). Wenn es diese Zeichenfolge empfängt, sendet es eine andere Zeichenfolge an den Client ("LazyRemote_192.168.1.17: 2016") Ich habe mit Wireshark überprüft, dass die Daten in beide Richtungen gesendet korrekt sind, aber ich empfange etwas falsch in der Clientanwendung .

Der Code für Android ist dies:

buttonConnect.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View arg0) { 

      progress.show(); 
      //This code is executed when user clicks connect button. As it could be a long running operation, it's executed in a new thread to avoid blocking UI 
      Thread thread = new Thread(new Runnable() { 
       @Override 
       public void run() { 

        String ipAddress = ""; 
        SocketClass my_socketClass = new SocketClass(); 
        InetAddress UDPaddress = my_socketClass.getBroadcastAddress(); 
        int UDPport = 15000; 

        if(initializationDone == false){ 
         initializationDone = true; 

         try { 
          socket_send = new DatagramSocket(); 
          socket_send.setBroadcast(true); 
          socket_send.setSoTimeout(6000); 
          socket_receive = new DatagramSocket(UDPport, InetAddress.getByName("0.0.0.0")); 
         } catch (Exception e) { 
          e.printStackTrace(); 
         } 
        } 

        try { 

         byte[] send_buff = "LazyRemote".getBytes(); 
         DatagramPacket sendPacket = new DatagramPacket(send_buff, send_buff.length,UDPaddress,UDPport); 
         socket_send.send(sendPacket); 

        }catch (Exception ex){ 

         showToast("Imposible enviar primer ack"); 
        } 


        byte[] receive_buff = new byte[30]; 
        DatagramPacket receivePacket = new DatagramPacket(receive_buff, receive_buff.length); 

        try { 

         socket_receive.receive(receivePacket); 
         String receivedData = new String(receivePacket.getData(), "UTF-8"); 
         if (receivedData.contains("LazyRemote")) { 


          SocketClass my_socket = new SocketClass(receivePacket.getAddress().toString().substring(1), 2016); 
          SocketClass.ConnectionStatus connectionStatus = my_socket.establishConnection(); 

          //Remove progressdialog after establishConnection finishes. 
          progress.dismiss(); 

          //Check connection status. 
          if (connectionStatus.status == true) { 

           Thread.sleep(1000); 
           socket_receive.close(); 
           socket_send.close(); 
           Intent intent = new Intent(MainActivity.this, ActionPerformer.class); 
           startActivity(intent); 
           finish(); 
          } 
         } 
        } catch (Exception ex) { 
         progress.dismiss(); 
         showToast("No se han encontrado servidores"); 
        } 
        //mLock.release(); 
       } 
      }); 
      thread.start(); 
     } 
    }); 

Das Problem ist, dass Empfangsfunktion funktioniert, aber es falsche Daten empfängt. (Es empfängt die gleiche Zeichenfolge, die der Client an den Server sendet, um die Entschlüsselung zu initialisieren ("LazyRemote")).

Es muss ein dummer Fehler sein, aber ich kann es nicht lösen. Danke vielmals.

Answer 1

Ihr UDP-gesendetes Paket kann auch von Ihrem Client-Socket empfangen werden, wenn Sie denselben Port abhören, an den Sie senden. Sie müssen diese Daten nur aus Ihrem Datenanalysecode filtern. Sie sollten sehen können, dass die Quelladresse mit der Client-IP-Adresse übereinstimmt.