Android客户端自动发现C＃服务器 [英] Android client finding C# server automatically
问题描述
我的Android客户端试图寻找网络中的C＃服务器...
My Android client is trying to find C# server in the network...
这是的程序：结果
0服务器正在监听UDP包结果
1.客户端发送UDP数据包，并开始监听响应结果
2.服务器收到UDP数据包，如果包是由客户端发送，服务器发送新的UDP数据包到客户端的结果
3.客户端收到UDP包
This is the procedure:
0. Server is listening for the UDP packet
1. Client sends UDP packet and starts listening for response
2. Server receive UDP packet, and if packet is sent by client, server is sending new UDP packet to client
3. Client receive UDP packet
C＃服务器code：
//receive UDP packet
int port = (int)float.Parse(Variables.port_key);
UdpClient UDP_receive = new UdpClient(port);
IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
IPAddress from_addr = null;
Boolean gogo = false;
ExecuteCommand("Receiving...");
while (!gogo)
{
Byte[] receiveBytes = UDP_receive.Receive(ref RemoteIpEndPoint);
string returnData = Encoding.UTF8.GetString(receiveBytes);
if (returnData.ToString() == "83hcX1")
{
gogo = true;
}
from_addr = RemoteIpEndPoint.Address;
ExecuteCommand("Package received: " + returnData.ToString());
}
ExecuteCommand("Out of loop");
UDP_receive.Close();
ExecuteCommand("UDP_receive closed");
//send UDP packet
UdpClient UDP_send = new UdpClient();
IPEndPoint ipEndPoint = new IPEndPoint(from_addr, port);
Byte[] sendBytes = Encoding.UTF8.GetBytes("94dbF5");
UDP_send.Send(sendBytes, sendBytes.Length, ipEndPoint);
ExecuteCommand("Package sent");
UDP_send.Close();
ExecuteCommand("UDP_send closed");
这是结果：结果
接收...结果
包装好评：83hcX1结果
出循环结果的
UDP_receive关闭结果
包发送结果
UDP_send关闭
This is the result:
Receiving...
Package received: 83hcX1
Out of loop
UDP_receive closed
Package sent
UDP_send closed
（所以...我认为，服务器code是OK ......）
(So... I think that servers code is OK...)
现在的结果
android.java客户code：结果
PS。这code是应用程序启动后自动执行。
Now the
android.java client code:
PS. this code is executed automatically after the app starts.
int port = SERVERPORT;
//send UDP packet
DatagramSocket UDP_send = new DatagramSocket();
byte[] b = "83hcX1".getBytes("UTF-8");
DatagramPacket outgoing = new DatagramPacket(b, b.length, getBroadcastAddress(Main.this), port);
UDP_send.send(outgoing);
Log.e("UDP", "Package sent");
UDP_send.close();
Log.e("UDP", "UDP_send closed");
//receive UDP packet
DatagramSocket UDP_receive = new DatagramSocket(port);
boolean gogo = false;
Log.e("UDP", "Receiving...");
while (!gogo) {
byte[] buffer = new byte[1000];
DatagramPacket incoming = new DatagramPacket(buffer, buffer.length);
UDP_receive.receive(incoming);
String message = new String(incoming.getData(), 0, incoming.getLength(), "UTF-8");
Log.e("Received", incoming.getPort() + "" + incoming.getAddress() + message);
if (message.equals("94dbF5")) {
Log.e("UDP", "Same");
gogo = true;
}else {
Log.e("UDP", "Not same!");
}
}
Log.e("UDP", "I'm out of loop");
UDP_receive.close();
Log.e("UDP", "UDP_receive closed");
结果：结果
第一次启动后：结果
07-10 22：35：04.017：E / UDP（4638）：包发送结果
07-10 22：35：04.027：E / UDP（4638）：UDP_send关闭结果
07-10 22：35：04.047：E / UDP（4638）：在收到...
Result:
After first start:
07-10 22:35:04.017: E/UDP(4638): Package sent
07-10 22:35:04.027: E/UDP(4638): UDP_send closed
07-10 22:35:04.047: E/UDP(4638): Receiving...
如果我重新启动应用程序，我得到这个：结果
07-10 22：45：05.327：E /接收的（4638）：42283 / 192.168.3.1883hcX1结果
07-10 22：45：05.327：E / UDP（4638）：包发送结果
07-10 22：45：05.327：E / UDP（4638）：UDP_send关闭结果
07-10 22：45：05.347：E / UDP（4638）：不一样的结果
07-10 22：45：05.347：E / UDP（4638）：java.net.BindException：使用地址已
If I restart app I get this:
07-10 22:45:05.327: E/Received(4638): 42283/192.168.3.1883hcX1
07-10 22:45:05.327: E/UDP(4638): Package sent
07-10 22:45:05.327: E/UDP(4638): UDP_send closed
07-10 22:45:05.347: E/UDP(4638): Not same!
07-10 22:45:05.347: E/UDP(4638): java.net.BindException: Address already in use
如果我重新启动应用程序和服务器：结果
07-10 22：47：36.447：E /接收的（4638）：57895 / 192.168.3.1883hcX1结果
07-10 22：47：36.467：E / UDP（4638）：不一样的结果
07-10 22：47：36.477：E / UDP（4638）：包发送结果
07-10 22：47：36.477：E / UDP（4638）：UDP_send关闭结果
07-10 22：47：36.487：E /接收的（4638）： 61420 / 192.168.3.1094dbF5 结果
07-10 22：47：36.497：E / UDP（4638）：java.net.BindException：地址已在使用结果
07-10 22：47：36.507：E / UDP（4638）：相同的结果
07-10 22：47：36.507：E / UDP（4638）：我出循环结果的
07-10 22：47：36.527：E / UDP（4638）：UDP_receive关闭
If I restart app and server:
07-10 22:47:36.447: E/Received(4638): 57895/192.168.3.1883hcX1
07-10 22:47:36.467: E/UDP(4638): Not same!
07-10 22:47:36.477: E/UDP(4638): Package sent
07-10 22:47:36.477: E/UDP(4638): UDP_send closed
07-10 22:47:36.487: E/Received(4638): 61420/192.168.3.1094dbF5
07-10 22:47:36.497: E/UDP(4638): java.net.BindException: Address already in use
07-10 22:47:36.507: E/UDP(4638): Same
07-10 22:47:36.507: E/UDP(4638): I'm out of loop
07-10 22:47:36.527: E/UDP(4638): UDP_receive closed
我知道我做错了相关的端口（因为我得到java.net.BindException：地址已在使用 - 错误），但什么？
为什么我得到的结果我想（ 61420 / 192.168.3.1094dbF5 ）后，才应用和服务器的第二次创业？
I know that I'm doing something wrong related to ports (because I get java.net.BindException: Address already in use - error), but what?? Why do I get the result I want (61420/192.168.3.1094dbF5) only after second start of app and server?
推荐答案
解决了！结果
这是一个工作的例子：
Solved!
This is a working example:
C＃服务器
//receive UDP packet
int port = (int)float.Parse(Variables.port_key);
UdpCient UDP_packet = new UdpClient(port);
UDP_packet.EnableBroadcast = true;
IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
IPAddress from_addr = null;
Boolean gogo = false;
while (!gogo)
{
Byte[] receiveBytes = UDP_packet.Receive(ref RemoteIpEndPoint);
string returnData = Encoding.UTF8.GetString(receiveBytes);
if (returnData.ToString() == "83hcX1")
{
gogo = true;
}
from_addr = RemoteIpEndPoint.Address;
}
//send UDP packet
IPEndPoint ipEndPoint = new IPEndPoint(from_addr, port);
Byte[] sendBytes = Encoding.UTF8.GetBytes("94dbF5");
UDP_packet.Send(sendBytes, sendBytes.Length, ipEndPoint);
UDP_packet.Close();
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();
现在您可以连接到服务器地址（SERVER_IP）。结果
另外，我读了一些路由器（也许5％）阻止UDP广播，所以......要小心。
Now you can connect to server address (SERVER_IP).
Also, I read that some routers (maybe 5%) block UDP broadcast, so... be careful.
如果有人看到任何错误，请张贴。
If someone see any error, please post it.
编辑：
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);
}
这篇关于Android客户端自动发现C＃服务器的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
