带有c#udp客户端的简单单播android udp服务器指南

我想创建一个非常简单的android UDP Uni cast服务器和一个C#UDP客户端。我们可以在android上创建服务器吗？如果是，那么应该为c#客户端提供什么IP地址以连接android服务器

编辑：我在Android上完成了Uni cast UDP服务器，并在C#中完成了Uni cast UDP客户端。 服务器正在发送数据包，客户端正在成功接收。但事实并非如此，也没有任何错误和例外。但我不明白代码中有什么问题

安卓服务器：

public class MainActivity extends Activity {

String myIP;
final Integer myPort = 12345;

String clientIP = "192.168.1.3"; 
Integer clientPort = 54321;

byte[] inBuffer,outBuffer;

Button send, set;
EditText sendMsg, receiveMsg, cip, cp;

DatagramSocket me;

AsyncTask<Void, byte[], Void> asyncReceiver;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    send = (Button) findViewById(R.id.button1);
    sendMsg = (EditText) findViewById(R.id.editText1);
    receiveMsg = (EditText) findViewById(R.id.editText2);

    set = (Button) findViewById(R.id.button2);
    cip = (EditText) findViewById(R.id.editText3);
    cp = (EditText) findViewById(R.id.editText4);

    inBuffer = new byte[256];
    outBuffer = new byte[256];

    myIP = null;
    myIP = GetCurrentIP();

    if (myIP == null) {
        Msg("GetCurrentIP error.");
    } else {
        try {
            setTitle(myIP+"|"+InetAddress.getLocalHost());
        } catch (UnknownHostException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        if (!Bind()) {
            Msg("Bind() error.");
        } else {

            set.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    // TODO Auto-generated method stub
                    clientIP = cip.getText().toString();
                    clientPort = Integer.parseInt(cp.getText().toString());
                    Msg(clientIP+"|"+clientPort);
                }
            });

            send.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    // TODO Auto-generated method stub
                    outBuffer = sendMsg.getText().toString().getBytes();
                    SendToClient();
                }
            });

            //-----------
            asyncReceiver = new AsyncTask<Void, byte[], Void>() {

                @Override
                protected void onProgressUpdate(byte[]... values) {
                    // TODO Auto-generated method stub
                    super.onProgressUpdate(values);
                    receiveMsg.append(new String(values[0]));
                }

                @Override
                protected Void doInBackground(Void... params) {
                    // TODO Auto-generated method stub
                    try {
                        while(true){
                            inBuffer = new byte[256];
                            DatagramPacket pack = new DatagramPacket(inBuffer, inBuffer.length, InetAddress.getByName(clientIP), clientPort);
                            me.receive(pack);
                            publishProgress(inBuffer);
                            Thread.sleep(500);
                        }
                    } catch (Exception e) {
                        // TODO: handle exception
                        Msg(e.getMessage());
                    }
                    return null;
                }
            };
            //-----------
            asyncReceiver.execute(new Void[1]);
            Msg("Receiving started.");

        }
    }
}



private void SendToClient(){
    try {
        DatagramPacket pack = new DatagramPacket(outBuffer, outBuffer.length, InetAddress.getByName(clientIP), clientPort);
        me.send(pack);
        Msg("Sent successfully.");
    } catch (Exception e) {
        // TODO: handle exception
        Msg(e.getMessage());
    }
}

private boolean Bind(){
    try {
//          DatagramChannel channel = DatagramChannel.open();
//          me = channel.socket();
//          //me = new DatagramSocket();
//          SocketAddress localAddr = new InetSocketAddress(InetAddress.getByName(myIP), myPort);
//          me.bind(localAddr);
            me = new DatagramSocket(myPort, InetAddress.getByName(myIP));
            Msg("Bound Successfully.");
            return true;
        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            Msg(e.getMessage());
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            Msg(e.getMessage());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return false;
    }

private String GetCurrentIP(){
    WifiManager wifiMgr = (WifiManager) getSystemService(WIFI_SERVICE);
    return Formatter.formatIpAddress(wifiMgr.getConnectionInfo().getIpAddress());
}

public void Msg(String msg){
    Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show();
    Log.v(">>>>>", msg);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menu);
    return true;
}
}

下面是一个很好的c#android udp示例：

C#

Android

                    //send UDP packet
                    DatagramSocket UDP_packet = new DatagramSocket(SERVERPORT);
                    UDP_packet.setBroadcast(true);
                    byte[] b = "83hcX1".getBytes("UTF-8");
                    DatagramPacket outgoing = new DatagramPacket(b, b.length, getBroadcastAddress(Main.this), SERVERPORT);                  
                    UDP_packet.send(outgoing);
                    //receive UDP packet
                    boolean gogo = false;
                    while (!gogo) {                     
                        byte[] buffer = new byte[1024];
                        DatagramPacket incoming = new DatagramPacket(buffer, buffer.length);    
                        UDP_packet.receive(incoming);
                        String message = new String(incoming.getData(), 0, incoming.getLength(), "UTF-8");
                         if (message.equals("94dbF5")) {
                             gogo = true;
                             SERVER_IP = incoming.getAddress();
                         }                  
                    }               
                    UDP_packet.close();

InetAddress getBroadcastAddress(Context context) throws IOException {
    WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    DhcpInfo dhcp = wifi.getDhcpInfo();
    if (dhcp == null) {
          return null;
        }
    int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
    byte[] quads = new byte[4];
    for (int k = 0; k < 4; k++)
      quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
    return InetAddress.getByAddress(quads);
}

//发送UDP数据包
DatagramSocket UDP_数据包=新DatagramSocket（服务器端口）；
UDP_数据包.setBroadcast（true）；
字节[]b=“83hcX1”.getBytes（“UTF-8”）；
DatagramPacket outgoing=新的DatagramPacket（b，b.length，getBroadcastAddress（Main.this），SERVERPORT）；
UDP_数据包发送（传出）；
//接收UDP数据包
布尔gogo=false；
而（！gogo）{
字节[]缓冲区=新字节[1024]；
DatagramPacket incoming=新的DatagramPacket（buffer，buffer.length）；
UDP_数据包接收（传入）；
字符串消息=新字符串（incoming.getData（），0，incoming.getLength（），“UTF-8”）；
if（message.equals（“94dbF5”））{
果戈=真；
SERVER_IP=incoming.getAddress（）；
}                  
}               
UDP_数据包。关闭（）；
InetAddress getBroadcastAddress（上下文上下文）引发IOException{
WifiManager wifi=（WifiManager）context.getSystemService（context.wifi\u SERVICE）；
DhcpInfo dhcp=wifi.getDhcpInfo（）；
如果（dhcp==null）{
返回null；
}
int broadcast=（dhcp.ipAddress&dhcp.netmask）|~dhcp.netmask；
字节[]四元组=新字节[4]；
对于（int k=0；k<4；k++）
四元组[k]=（字节）（（广播>>k*8）和0xFF）；
返回InetAddress.getByAddress（quads）；
}

一些路由器（可能5%）阻止UDP广播，所以。。。小心点

获取Android（服务器）IP:

InetAddress getBroadcastAddress(Context context) throws IOException {
        WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        DhcpInfo dhcp = wifi.getDhcpInfo();
        if (dhcp == null) {
              return null;
            }
        int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
        byte[] quads = new byte[4];
        for (int k = 0; k < 4; k++)
          quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
        return InetAddress.getByAddress(quads);
    }

InetAddress getBroadcastAddress（上下文上下文）引发IOException{
WifiManager wifi=（WifiManager）context.getSystemService（context.wifi\u SERVICE）；
DhcpInfo dhcp=wifi.getDhcpInfo（）；
如果（dhcp==null）{
返回null；
}
int broadcast=（dhcp.ipAddress&dhcp.netmask）|~dhcp.netmask；
字节[]四元组=新字节[4]；
对于（int k=0；k<4；k++）
四元组[k]=（字节）（（广播>>k*8）和0xFF）；
返回InetAddress.getByAddress（quads）；
}

我做了大量的研究，尝试了大量的代码，但都没有成功。现在是凌晨2点，我对此感到厌倦，不想写这么大的材料，请简单回答我应该向c#客户提供什么ip

                    //send UDP packet
                    DatagramSocket UDP_packet = new DatagramSocket(SERVERPORT);
                    UDP_packet.setBroadcast(true);
                    byte[] b = "83hcX1".getBytes("UTF-8");
                    DatagramPacket outgoing = new DatagramPacket(b, b.length, getBroadcastAddress(Main.this), SERVERPORT);                  
                    UDP_packet.send(outgoing);
                    //receive UDP packet
                    boolean gogo = false;
                    while (!gogo) {                     
                        byte[] buffer = new byte[1024];
                        DatagramPacket incoming = new DatagramPacket(buffer, buffer.length);    
                        UDP_packet.receive(incoming);
                        String message = new String(incoming.getData(), 0, incoming.getLength(), "UTF-8");
                         if (message.equals("94dbF5")) {
                             gogo = true;
                             SERVER_IP = incoming.getAddress();
                         }                  
                    }               
                    UDP_packet.close();

InetAddress getBroadcastAddress(Context context) throws IOException {
    WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    DhcpInfo dhcp = wifi.getDhcpInfo();
    if (dhcp == null) {
          return null;
        }
    int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
    byte[] quads = new byte[4];
    for (int k = 0; k < 4; k++)
      quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
    return InetAddress.getByAddress(quads);
}

InetAddress getBroadcastAddress(Context context) throws IOException {
        WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        DhcpInfo dhcp = wifi.getDhcpInfo();
        if (dhcp == null) {
              return null;
            }
        int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
        byte[] quads = new byte[4];
        for (int k = 0; k < 4; k++)
          quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
        return InetAddress.getByAddress(quads);
    }