Android UDP 通信总结 （终于从坑中爬起来了）
2018.08.02
最近做的项目要求为：一端为电视端，一端为手机端，实现电视端与手机端通过UDP进行通信。
解释：就是两个机器在同一个局域网内（即两端连接的同一个WiFi），可以通过UDP，一端将信息通过局域网散播出去后，在同一个局域网内的所有设备都能接收到信息，只不过，另一端对接收到的信息进行处理，这样就完成了UDP通信。发送信息方只负责发送信息，另一方只负责接收信息，两方还可以互相发送和接收信息，反正互不干扰，谁都不会管对方是否接收到信息。
写的比较好的文章：https://blog.csdn.net/ITermeng/article/details/73482669?locationNum=9&fps=1。
想要了解更多关于UDP与TCP的基础知识，请看https://www.jianshu.com/p/cc62e070a6d2。
UDP通信步骤：
1、建立连接的IP地址和端口号，IP即是你想要发送的地址，端口号则要选用闲置端口就是向8000~9000这样的端口号。
2、建立DatagramSocket sendSocket/receiveSocket ，用于发送和接受数据报文包。
3、创建报文包DatagramPacket sendPackage/receivePackage，将发送或接收的内容打包。
4、通过sendSocket.send(sendPackage)或者receiveSocket.receive(receivePackage)，则完成了基于Socket的UDP通信。
注意事项：
1.同一端如果既要发送消息又想接收消息，一定要将发送的socket和接收的socket分开。不能用一个socket既接收信息，又发送信息，这样一定会造成阻塞。
2.接收线程中，一定要有 while（true）{ if(标志何时结束) 代码块 } 这样的方式，不然，在接收信息时，一定会造成阻塞，就是只能接收到一次信息。
3.本来想开一个线程进行接收数据和发送数据，真的是太混乱了，所以大家还是开两个线程吧。。。。
具体代码：
服务端：
package com.example.admin.learnUdpCommunicateServer;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;
/**
* @author zhou.jn
*/
public class UdpSocketServerActivity extends Activity {
private static final String TAG = "SocketAutoConnectServer";
private static String IP;
private static int BROADCAST_PORT = 9999;
private static String BROADCAST_IP = "255.255.255.255";
private InetAddress inetAddress = null;
private BroadcastThread broadcastThread;
private DatagramSocket sendSocket = null;
private DatagramSocket receiveSocket = null;
private Button sendUDPBrocast;
private volatile boolean isRuning = true;
private TextView ipInfo;
private Button btn_send;
private EditText et_sendInfo;
private String sendContent;
private TextView tv_receive;
private List ipList = new ArrayList<>();
private Button btnClear;
private ReceiveThread receiveThread;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
initView();
initIp();
initThread();
try {
inetAddress = InetAddress.getByName(BROADCAST_IP);
} catch (Exception e) {
e.printStackTrace();
}
}
private void initThread() {
broadcastThread = new BroadcastThread();
broadcastThread.start();
receiveThread = new ReceiveThread();
receiveThread.start();
}
private void initIp() {
//Wifi状态判断
WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
if (wifiManager.isWifiEnabled()) {
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
IP = getIpString(wifiInfo.getIpAddress());
ipInfo.append(IP);
System.out.println("IP IP:" + IP);
}
}
private void initView() {
ipInfo = (TextView) findViewById(R.id.ip_info);
sendUDPBrocast = (Button) findViewById(R.id.sendUDPBrocast);
tv_receive = findViewById(R.id.tv_receive);
et_sendInfo = findViewById(R.id.et_sendContent);
btn_send = findViewById(R.id.btn_sendInfo);
try {
receiveSocket = new DatagramSocket(BROADCAST_PORT);
} catch (SocketException e) {
e.printStackTrace();
}
btn_send.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
sendMessageToThread(broadcastThread.mhandler);
}
});
btnClear = findViewById(R.id.btnClear);
btnClear.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
tv_receive.setText("");
}
});
sendUDPBrocast.setOnClickListener(new SendUDPBrocastListener());
}
private void sendMessageToThread(Handler mhandler) {
Message msg = Message.obtain();
sendContent = et_sendInfo.getText().toString();
msg.obj = sendContent;
msg.what = 1;
mhandler.sendMessage(msg);
}
/**
* 将获取到的int型ip转成string类型
*/
private String getIpString(int i) {
return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "."
+ ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
}
@SuppressLint("HandlerLeak")
Handler myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 1: {
if (!msg.obj.equals(IP)) {
if (!isExistIp(msg.obj.toString())) {
ipList.add(msg.obj.toString());
}
tv_receive.append(msg.obj.toString() + " 接收到信息 " + "\n");
}
}
break;
default:
break;
}
}
};
public class SendUDPBrocastListener implements OnClickListener {
@Override
public void onClick(View v) {
if (isRuning) {
isRuning = false;
sendUDPBrocast.setText("发送广播");
System.out.println("现在停止广播..");
} else {
isRuning = true;
sendUDPBrocast.setText("停止广播");
System.out.println("现在发送广播..");
}
}
}
public class BroadcastThread extends Thread {
private Handler mhandler = null;
@SuppressLint("HandlerLeak")
@Override
public void run() {
Looper.prepare();
mhandler = new Handler() {
@Override
public void handleMessage(Message msg) {
String message = (String) msg.obj;
byte[] data = message.getBytes();
DatagramPacket dpSend = null;
dpSend = new DatagramPacket(data, data.length, inetAddress, BROADCAST_PORT);
try {
double start = System.currentTimeMillis();
for (int i = 0 ; i < 15; i ++) {
sendSocket = new DatagramSocket();
sendSocket.send(dpSend);
sendSocket.close();
Thread.sleep(80);
Log.i(TAG, "sendMessage: data " + new String(data));
}
double end = System.currentTimeMillis();
double times = end - start;
Log.i(TAG, "receive: executed time is : "+ times +"ms");
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Looper.loop();
}
}
private boolean isExistIp(String revIp) {
if (ipList != null && ipList.size() > 0) {
for (String ip : ipList) {
if (ip != revIp) {
return false;
}
}
}
return false;
}
private class ReceiveThread extends Thread {
@Override
public void run() {
while (true) {
if (isRuning) {
byte[] receiveData = new byte[1024];
DatagramPacket dpReceive = null;
ipList.clear();
dpReceive = new DatagramPacket(receiveData, receiveData.length);
try {
receiveSocket.receive(dpReceive);
} catch (IOException e) {
e.printStackTrace();
}
String recIp = dpReceive.getAddress().toString().substring(1);
if (dpReceive != null) {
Message revMessage = Message.obtain();
revMessage.what = 1;
revMessage.obj = recIp;
Log.i(TAG, "handleMessage: receive ip" + recIp);
myHandler.sendMessage(revMessage);
}
}
}
}
}
@Override
protected void onDestroy() {
super.onDestroy();
isRuning = false;
receiveSocket.close();
System.out.println("UDP Server程序退出,关掉socket,停止广播");
finish();
}
} 客户端代码：
package com.example.admin.learnudpcommunicateclent;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import com.example.admin.udpclient.R;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
/**
* @author zhou.jn
*/
public class SocketClientActivity extends Activity {
private static int BROADCAST_PORT = 9999;
private static final String TAG = "SocketConnectActivity";
private TextView ipInfo;
private static String IP;
private boolean isRunning = true;
private Button btnBack;
private DatagramSocket receiveSocket = null;
private DatagramSocket sendSocket = null;
private DatagramPacket dpReceive = null;
private SendThread sendThread;
private String previousContent = new String();
private Button btnClear;
private String receiveIp;
private String sendIp;
@SuppressLint("HandlerLeak")
Handler myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 1:
Log.i(TAG, "run handleMessage: ");
ipInfo.append(msg.obj.toString() + "\n");
/**通过确认该客户端已经接收到信息后，再将自己的ip号码发送出去*/
new Thread(){
@Override
public void run() {
try {
Thread.sleep(1500);
/**开一个将前一次接收的内容置为空的线程，解决发送端两次发送相同的信息，接收端他可能就不会做处理的问题*/
previousContent = " ";
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
sendFeedBackToServer(sendThread.mHandler, msg.obj.toString());
break;
case 2:
ipInfo.append(msg.obj.toString());
default:
break;
}
}
};
private void sendFeedBackToServer(Handler mHandler, String ip) {
Message msg = new Message();
msg.obj = ip;
msg.what = 1;
mHandler.sendMessage(msg);
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
ipInfo = findViewById(R.id.ip_info);
btnBack = findViewById(R.id.btnBack);
btnBack.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
finish();
}
});
btnClear = findViewById(R.id.btnClear);
btnClear.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
ipInfo.setText("");
}
});
ReceiveThread receiveThread = new ReceiveThread();
WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
if (wifiManager.isWifiEnabled()) {
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
IP = getIpString(wifiInfo.getIpAddress());
System.out.println("本机IP is :" + IP);
}
try {
receiveSocket = new DatagramSocket(BROADCAST_PORT);
sendThread = new SendThread();
sendThread.start();
receiveThread.start();
} catch (Exception e1) {
e1.printStackTrace();
}
}
/**
* 将获取到的int型ip转成string类型
*/
private String getIpString(int i) {
return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "."
+ ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
}
private class ReceiveThread extends Thread {
@SuppressLint("LongLogTag")
@Override
public void run() {
while (true) {
if (isRunning) {
String receiveContent = null;
byte[] buf = new byte[1024];
dpReceive = new DatagramPacket(buf, buf.length);
try {
receiveSocket.receive(dpReceive);
receiveContent = new String(buf, 0, dpReceive.getLength());
Log.i(TAG, "run: receive message " + receiveContent);
Log.i(TAG, "run: " + dpReceive.getAddress().toString());
receiveIp = dpReceive.getAddress().toString().substring(1);
if (receiveIp != IP) {
sendIp = receiveIp;
}
Log.i(TAG, "run:1 previousContent " + previousContent + " receiveContent " + receiveContent);
if (!previousContent.equals(receiveContent) && !IP.equals(receiveIp)) {
Message msg = myHandler.obtainMessage();
msg.obj = "服务器：" + sendIp + "发送的内容为：" + receiveContent;
msg.what = 1;
myHandler.sendMessage(msg);
}
previousContent = receiveContent;
Log.i(TAG, "run:2 previousContent " + previousContent + " receiveContent " + receiveContent);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
private class SendThread extends Thread {
private Handler mHandler;
@SuppressLint("HandlerLeak")
@Override
public void run() {
Looper.prepare();
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
DatagramPacket dpSend = null;
byte[] ip = IP.getBytes();
try {
if (receiveIp != IP) {
InetAddress inetAddress = InetAddress.getByName(sendIp);
dpSend = new DatagramPacket(ip, ip.length, inetAddress, BROADCAST_PORT);
}
} catch (UnknownHostException e) {
e.printStackTrace();
}
try {
String sendData = new String(ip, 0, dpSend.getLength());
sendSocket = new DatagramSocket();
sendSocket.send(dpSend);
Log.i(TAG, "run: send message : " + sendData);
sendSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
Looper.loop();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
receiveSocket.close();
isRunning = false;
System.out.println("UDP Client程序退出,关掉socket,停止广播");
finish();
}
}刚开始做这个项目的疑惑及解决办法：
问题一：用一个DatagramSocket进行发送并接收信息，会不会有问题。
答：确实很有问题，所以一定要开（1+n）个DatagramSocket啊，同志们！一个DatagramSocket用于接收信息，另外n个是每次发送新消息的时候就新建一个DatagramSocket进行发送，发送后进行关闭。
问题二：当发送信息的时候，是想着每发送一个信息，就要关闭一个信息。可我想着发送完信息关闭后，接着又要发送消息怎么办？
答：每次新建DatagramSocket再进行关闭就可以啦！
问题三：想在客户端接收到信息后，发送给服务端告诉他我接收到信息了~，可是接收方只要监听端口就可以，不用IP的，那要如何获取接收端的IP呢？
答：通过接收数据包的dpReceive.getAddress()可以获取，并且它的格式为“/10.0.12.53”，所以要取子字符串subString(1)进行获取。
问题四：接收信息的时候咋能接收到自己发送的信息？
答：确实可以接收到自己发送的信息。。。。所以需要自行进行过滤处理，不要接收自己发送的信息，不然是不是会显得很傻。。
项目讲解：
服务器端：我怕客户端接收不到信息，所以我就发了15次信息，并且每次间隔80ms，这样客户端再接收不到信息，俺也没办法了，每次发送信息的时间大约为1200多ms，这么长时间总能接到一条吧，老兄！
发送端拨号为4个255，听说这样是可以发送给局域网，反正IP是个随意的大数就行，比如244.244.0.1都行~
客 户 端：服务器这老兄给我发这么多条相同的信息，我还每条都处理，是不是很傻！所以就进行判断我是不是重复接收了客户端的相同信息，如果相同，处理一次就够了。。。。
ps：UDP中没什么客户端，服务端，只是接收方，发送方而已，我只是这么称呼他们。。。
源码地址：https://download.csdn.net/download/weixin_37716758/10582295（优化的）
源码地址：https://download.csdn.net/download/weixin_37716758/10580690（带有APK）