安卓UDP通信

Question

我在这个网站上读了很多有关如何在Android中接收UDP数据包的帖子。然而，这些方法对我都无效！

一些基本信息：

我正在我的HTC Incredible（Android 2.2）上进行测试，使用的是3G网络（不是wifi或其他任何东西）。这里没有涉及到模拟器。

我的代码很简单：

1. 我的服务器（运行在我的电脑上）正在监听端口8752上的UDP流量。
2. 我的Android应用程序在一个随机端口上打开DatagramSocket，并向我的服务器发送一个带有此端口的数据包。
3. 然后我保存这些信息（从接收到的数据包中获取的InetAddress和端口号）。
4. 我尝试从我的服务器（同样是在我的电脑上）发送一个UDP数据包到我的Android应用程序（运行在我的手机上），但它不起作用。

//Server code to initialize the UDP socket (snippet)
public void init() {
    datagram_server_socket = new DatagramSocket(port,local_addr);
    datagram_server_socket.setSoTimeout(1000);
}

//发送数据包到服务器的ANDROID应用代码片段

public void connect() {
    Random r = new Random(System.currentTimeMillis());
    int udp_port = 0;
    while(true){
        try {
            udp_port = r.nextInt(1000)+8000;
            udp_port = 8000;
            comm_skt = new DatagramSocket(udp_port);
            Log.i("ServerWrapper", "UDP Listening on port: " + udp_port);
            break;
        } catch(SocketException e) {
            Log.e("ServerWrapper", "Could not bind to port " + udp_port);
        }
    }
    byte[] sdata = new byte[4+tid.length];
    i = 0;
    sdata[i++] = (byte)(0XFF&(udp_port>>24));
    sdata[i++] = (byte)(0XFF&(udp_port>>16));
    sdata[i++] = (byte)(0XFF&(udp_port>>8));
    sdata[i++] = (byte)(0XFF&(udp_port));
    for(byte b: tid){
        sdata[i++] = b;
    }
    DatagramPacket pkt = new DatagramPacket(sdata, sdata.length, 
                                InetAddress.getByName(hostname), port);
    comm_skt.send(pkt);
}

//Server's UDP socket listening code
public void serverUDPListener() {
    try {
        datagram_server_socket.receive(rpkt);
        int port = 0;
        byte[] rdata = rpkt.getData();
        port += rdata[0]<<24;
        port += rdata[1]<<16;
        port += rdata[2]<<8;
        port += (0XFF)&rdata[3];
        byte[] tid = new byte[rdata.length];
        for(int i = 4; i < rdata.length && rdata[i] > 0; i++) {
            tid[i-4] = rdata[i];
        }
        String thread_id = new String(tid).trim();
        for(int i = 0; i < threads.size(); i++) {
        ClientThread t = threads.get(i);
        if(t.getThreadId().compareTo(thread_id) == 0) {
            t.setCommSocket(rpkt, port);
        } else {
            System.err.println("THREAD ID " + thread_id + " COULD NOT BE FOUND");
        }
        }
    } catch (IOException e) {
        if(!(e instanceof SocketException) && !(e instanceof SocketTimeoutException))
        log.warning("Error while listening for an UDP Packet.");
    }
}

//Corresponds to the setCommSocket call above to save the IP and Port of the incoming UDP packet on the server-end
public void setCommSocket(DatagramPacket pkt, int port) {
    comm_ip = pkt.getAddress();
    comm_port = pkt.getPort(); //Try the port from the packet?
}

//Sends an UDP packet from the SERVER to the ANDROID APP
public void sendIdle() {
    if(comm_ip != null) {
        System.err.println("Sent IDLE Packet (" + comm_ip.getHostAddress() + ":" + comm_port + ")");
        DatagramPacket spkt = new DatagramPacket(new byte[]{1, ProtocolWrapper.IDLE}, 2, comm_ip, comm_port);
        DatagramSocket skt;
        try {
            skt = new DatagramSocket();
            skt.send(spkt);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

目前，我的应用程序使用的端口号是8000，但奇怪的是每次测试我的程序时（并查看保存在我的服务器上的IP/端口），数据包来自的端口始终是33081。我在我的Android应用程序中不断监听UDP流量的线程，但代码从未执行过“receive(packet)”部分：

public void AndroidUDPListener() {
    while(true) {
        synchronized(stop) {
        if(stop) return;
        }
        byte[] recieve_data = new byte[64];
        DatagramPacket rpkt = new DatagramPacket(recieve_data, recieve_data.length);
        try {
        if(comm_skt == null) 
                continue;
        comm_skt.receive(rpkt);
        byte[] data = rpkt.getData();
        switch(data[1]) {
            case IDLE:
            if(ocl != null) ocl.onCompletion(null);
            break;
            case KEEP_ALIVE:
            break;
        }
        } catch (Exception e) {
        if(!(e instanceof SocketException) && !(e instanceof SocketTimeoutException))
                Log.w("ServerWrapper", "Error while listening for an UDP Packet.");
        }
    }
}

有人看到我的代码存在问题吗？还是我需要在应用程序上设置某些权限/设置？我已启用互联网通信。

示例输出（使用数据包getPort（）中的端口）：

Android App - 现在在端口8000上监听UDP流量 Android App - 发送数据包到服务器 服务器-从XXXXXX：33081接收到数据包 服务器-向XXXXXX：33081发送IDLE数据包

示例输出（使用数据包数据中的端口）：

Android App - 现在在端口8000上监听UDP流量 Android App - 发送数据包到服务器 服务器-从XXXXXX：8000接收到数据包 服务器-向XXXXXX：8000发送IDLE数据包

Android应用程序从这两个端口都未收到任何UDP流量。

- someone1

---

你能在两台桌面电脑/笔记本电脑上运行它吗（不使用你的安卓手机）？如果你能排除手机是问题，那么我们可以假设这是你代码的问题。 - Kiril

我成功地将我的手机连接到了WiFi网络，并通过这种方式使UDP数据包工作（使用我的机器的直接IP作为主机名，使用外部DNS名称无法工作）。我还让我的朋友在他家测试了我编写的一个程序，模拟Android应用程序的网络调用（使用外部DNS名称），并且它可以正常工作（经过一些端口转发和强制非随机UDP端口）。我希望这能澄清问题是我的代码引起的。 - someone1

Answer 1

很抱歉没有及时更新。问题已如下修复：

我需要将DatagramSocket存储到每个线程中。监听套接字也应该是服务器和客户端之间继续通信的套接字。以下是更新后的代码片段。

线程上的新套接字注册代码：

public void setCommSocket(DatagramPacket pkt, int port, DatagramSocket skt)
{
  comm_ip = pkt.getAddress();
  comm_port = pkt.getPort();
  synchronized(comm_pkt) {
    comm_pkt = pkt;
  }
  comm_skt = skt;
}

新的服务器监听代码：

public void UDPListen() {
        while(true) {
            synchronized(stop) {
                if(stop)
                    break;
            }

            byte[] recieve_data = new byte[64];
            DatagramPacket rpkt = new DatagramPacket(recieve_data, recieve_data.length);
            try {
                datagram_server_socket.receive(rpkt);
                int port = 0;
                byte[] rdata = rpkt.getData();
                port += rdata[0]<<24;
                port += rdata[1]<<16;
                port += rdata[2]<<8;
                port += (0XFF)&rdata[3];
                byte[] tid = new byte[rdata.length];
                for(int i = 4; i < rdata.length && rdata[i] > 0; i++)
                {
                    tid[i-4] = rdata[i];
                }
                String thread_id = new String(tid).trim();
                for(int i = 0; i < threads.size(); i++) {
                    ClientThread t = threads.get(i);
                    if(t.getThreadId().compareTo(thread_id) == 0)
                    {
                        t.setCommSocket(rpkt, port, datagram_server_socket);
                    } else {
                        System.err.println("THREAD ID " + thread_id + " COULD NOT BE FOUND");
                    }
                }
            } catch (IOException e) {
                if(!(e instanceof SocketException) && !(e instanceof SocketTimeoutException))
                    log.warning("Error while listening for an UDP Packet.");
            } finally {
                for(int i = 0; i < threads.size(); i++) {
                    ClientThread t = threads.get(i);
                    t.sendKeepAlive();
                }
            }
        }
    }

服务器/线程的结构进行了一些更新（我将不会细说）。这里重要的是，用于接收数据包的套接字被重用以向客户端发送数据。此外，实际的数据包也被重新使用以发送数据回去：

public void sendIdle() {
        if(comm_ip != null) {
            synchronized(comm_pkt) {
                try {
                    comm_pkt.setData(new byte[]{1, ProtocolWrapper.IDLE});
                    comm_skt.send(comm_pkt);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }

以下是我的包装类相关部分，显示了每个线程所持有的内容：

public class PeerWrapper {

    private InetAddress ipaddress;
    private Integer port;
    private Socket client_socket;
    private InetAddress comm_ip;
    private DatagramSocket comm_skt;
    private DatagramPacket comm_pkt;
    private int comm_port;
    private byte status;

- someone1

Answer 2

我曾经遇到过类似的问题。在Android上有两个套接字（发送/监听），而在PC服务器上又有两个套接字（发送/监听）。手机会使用其未知的监听套接字地址向PC的已知监听套接字ping，以便PC可以回复。由于套接字从未收到任何内容，因此我所做的一切似乎都无法获取监听套接字的地址。

这是我的解决方案：Android: java.net.DatagramSocket.bind: Invalid Argument Exception。使用通道创建套接字，然后在null上进行绑定。现在我可以使用手机上的发送套接字发送一个包含监听套接字端口的数据包（IP相同）到PC，使用.getLocalPort()获取该端口。PC读取byte[]，获取端口，并将数据包发送回手机的监听端口。

- Flynny75

---

你好，感谢你的回答。我不确定它是否能解决我的问题，但是我在一年前完成了这个项目（并解决了我的问题），现在没有时间测试它是否有效。 - someone1

Answer 3

安卓系统有入站防火墙

您需要使用第一个udop洞穴打孔相同的sock对象和计时器

- rtdff