现在有个需求是，App与智能硬件进行UDP通讯，进行数据交互。
着手展开编写android代码，百度UDP通讯。其实还是比较简单的，并不是很困难。这是因为有现成的东西可以拿来用，那就是 DatagramSocket 。
我基于这个又重新封装一下，可以当做工具来用，实现UDP广播单播与接收消息。
注释写的还可以，直接上代码
工具类
package com.bt.mi.utils;
import android.annotation.SuppressLint;
import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
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;
public class SocketUtils {
private static final String TAG = "SocketUtils";
private static String IP;//记录本机IP
private static Integer BROADCAST_PORT = 62535;//端口号，最大65535
private static String BROADCAST_IP = "255.255.255.255"; //向此IP发送则为广播
private InetAddress inetAddress = null;//地址
private BroadcastThread broadcastThread;//发送消息的线程
private DatagramSocket sendSocket = null;//发送消息的socket
private ReceiveThread receiveThread;//接收消息的线程
private DatagramSocket receiveSocket = null;//接收消息的socket
private volatile boolean isRuning = true;//标志
private List<String> ipList = new ArrayList<>();//记录维护IP列表，但是我没用到
private ReceiveCallBack callBack;//设置接收消息回调
/**
* 返回状态，是否接收消息
* @return
*/
public boolean isReceiveing() {
return isRuning;
}
/***
* 设置状态开始
*/
public void startReceive() {
isRuning = true;
}
/***
* 设置状态停止
*/
public void stopReceive() {
isRuning = false;
}
/**
* 销毁
* 其实单例也不需要注销，初始化一次保持全生命周期即可
* 没想好其他的方式，小伙伴多多建议修改
*/
public void destroy() {
isRuning = false;
if (receiveSocket != null && !receiveSocket.isClosed())
receiveSocket.close();
if (sendSocket != null && !sendSocket.isClosed())
sendSocket.close();
sendSocket = null;
receiveSocket = null;
receiveThread = null;
broadcastThread = null;
}
/**
* 获取单例对象
*/
private static class SingletonClassInstance {
private static final SocketUtils instance = new SocketUtils();
}
private SocketUtils() {
}
public static SocketUtils getInstance() {
return SingletonClassInstance.instance;
}
/**
* 回调接口，需要实现此接口进行接收消息
*/
public interface ReceiveCallBack {
void receiveMsg(String message);
}
/**
* 获取本机IP
*
* @return
*/
public String getLocalIP() {
return IP;
}
/**
* 设置监听端口
*
* @param port
*/
public void setReceivePort(Integer port) {
BROADCAST_PORT = port;
}
/**
* 初始化
* 考虑是不是可以直接放到单例里去
* 但是Context和callback也不是每次获取单例都要设置，所以没有放到一起
*/
public void init(Context context, ReceiveCallBack callBack) {
try {
receiveSocket = new DatagramSocket(BROADCAST_PORT);//监听接收消息，设置监听端口
} catch (SocketException e) {
e.printStackTrace();
}
initIp(context);
receiveThread = new ReceiveThread();
receiveThread.start();
broadcastThread = new BroadcastThread();
broadcastThread.start();
this.callBack = callBack;
try {
inetAddress = InetAddress.getByName(BROADCAST_IP);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 发送广播
*
* @param message
*/
public void sendBroadcast(String message) {
sendUnicast(message, BROADCAST_IP);
}
/**
* 发送单播
* 实际用到的是handler机制进行线程通讯发送
*
* @param message
* @param ip
*/
public void sendUnicast(String message, String ip) {
try {
inetAddress = InetAddress.getByName(ip);
} catch (Exception e) {
e.printStackTrace();
}
Message msg = Message.obtain();
msg.obj = message;
msg.what = 1;
broadcastThread.mhandler.sendMessage(msg);
}
private void initIp(Context context) {
//Wifi状态判断
// WifiManager.MulticastLock lock;
WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
if (wifiManager.isWifiEnabled()) {
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
IP = getIpString(wifiInfo.getIpAddress());
// ipInfo.append(IP);
System.out.println("IP IP:" + IP);
}
// lock = wifiManager.createMulticastLock("udpservice");
}
/**
* 接收消息的handler，通过接口回调出去消息内容
*/
@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());
}
if (callBack != null)
callBack.receiveMsg(msg.obj.toString());
}
}
break;
default:
break;
}
}
};
/**
* 接收消息的线程类，继承Thread
* 循环接收数据。DatagramPacket是收发的数据包
* receive方法接收消息，receiveSocket初始化在init方法中
* 收到消息使用Handler传递出去
*/
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);
}
}
}
}
}
/**
* 发送消息的线程类
* 使用Looper.loop();循环读取队列，一直监听消息
* 根据message内容构建DatagramPacket 发送消息的数据包，inetAddress初始化在调用发送消息方法时设置，端口也是固定的
* 记录打印发送耗时
*/
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();
sendSocket = new DatagramSocket();
sendSocket.send(dpSend);
sendSocket.close();
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();
}
}
};
Looper.loop();
}
}
private boolean isExistIp(String revIp) {
if (ipList != null && ipList.size() > 0 && revIp != null) {
for (String ip : ipList) {
if (ip == revIp) {
return true;
}
}
}
return false;
}
/**
* 将获取到的int型ip转成string类型
*/
private String getIpString(int i) {
return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "."
+ ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
}
}Activity使用
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.bt.mi.R;
import com.bt.mi.utils.SocketUtils;
/**
* UDP通讯activity
* 其实 这个activity也很简单，总共三个按钮，一个输入框，两个输出的textView
* 实现输入发送消息，接收消息功能
*/
public class UdpSocketServerActivity extends Activity implements SocketUtils.ReceiveCallBack {
private static final String TAG = "SocketAutoConnectServer";
private Button sendUDPBrocast;
private TextView ipInfo;
private Button btn_send;
private EditText et_sendInfo;
private TextView tv_receive;
private Button btnClear;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
SocketUtils.getInstance().init(this, this);//初始化连接对象
initView();
ipInfo.append(SocketUtils.getInstance().getLocalIP());//获取显示本机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);
btn_send.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
SocketUtils.getInstance().sendUnicast(et_sendInfo.getText().toString(), "192.168.137.84");//发送消息，单播
// SocketUtils.getInstance().sendBroadcast(et_sendInfo.getText().toString());//发送广播消息
}
});
btnClear = findViewById(R.id.btnClear);
btnClear.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
tv_receive.setText("");
}
});
sendUDPBrocast.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (SocketUtils.getInstance().isReceiveing()) {
SocketUtils.getInstance().stopReceive();//绑定按钮事件，是否开启接收消息
sendUDPBrocast.setText("接收广播");
System.out.println("现在停止接收广播..");
} else {
SocketUtils.getInstance().startReceive();
sendUDPBrocast.setText("停止接收");
System.out.println("现在接收广播..");
}
}
});
}
/**
* 接收到消息的回调方法，可以使用匿名内部类进行接收，也可以实现接口
* @param message
*/
@Override
public void receiveMsg(String message) {
tv_receive.append(message + " 接收到信息 " + "\n");
}
@Override
protected void onDestroy() {
super.onDestroy();
SocketUtils.getInstance().destroy();//注销。其实单例也不需要注销，初始化一次保持全生命周期即可
System.out.println("UDP Server程序退出,关掉socket,停止广播");
finish();
}
}布局文件
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<Button
android:id="@+id/sendUDPBrocast"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="停止广播"/>
<TextView
android:id="@+id/ip_info"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:textSize="20dip"
android:text="服务端自身IP: " />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:text="发送的内容"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<EditText
android:id="@+id/et_sendContent"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
</LinearLayout>
<Button
android:id="@+id/btn_sendInfo"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:text="send"/>
<Button
android:id="@+id/btnClear"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:text="clear"/>
<TextView
android:id="@+id/tv_receive"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=""/>
</LinearLayout>权限
最后，一定要注意权限！一定要注意权限！一定要注意权限！
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.INTERNET" />好的，到此为止结束了。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
