Android UDP连接发送请求和接受请求的例子

UDP请求的发送

<span style="font-size:14px;">import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.util.Log;

import com.changhong.electric_controll.UDPResponseCallback;
import com.changhong.electric_controll.util.ByteUtils;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;

public class UDPBroadCast extends Thread {
private MulticastSocket sender = null;
private DatagramSocket datagramSocket=null;
private DatagramPacket dj = null;
private InetAddress group = null;
private UDPReceiveAndTCPSend mUDPReceiveAndTCPSnd;

private UDPResponseCallback callback; //自定义接口，用于处理接收到的UDP结果，主要是调用它唯一的方法onResponse,提高结果处理的灵活性

public String LocalIP;

public int DEFAULT_PORT=12426;

private byte[] data = new byte[1024]; //用于发送udp的byte数组

private boolean isudpsendfinished=false;

private Context mContext;

public UDPBroadCast(Context context,byte[] dataString, UDPResponseCallback callback) {
mContext=context;
this.data = dataString;
this.callback=callback;
}

@Override
public void run() {
try {
if(datagramSocket==null){
datagramSocket = new DatagramSocket(null);
datagramSocket.setReuseAddress(true);
datagramSocket.bind(new InetSocketAddress(DEFAULT_PORT));
}
sender = new MulticastSocket();
LocalIP=getWIFIIP(mContext);
LocalIP=getBoradcastIP(LocalIP);
Log.i("Data","LocalIp="+LocalIP);
group = InetAddress.getByName(LocalIP); //这个是我客户端的IP地址，也可以是客户端所在的网段的广播地址，也可以是虚拟广播地址
if(data.length != 0) {
dj = new DatagramPacket(data, data.length, group,DEFAULT_PORT); //端口号可以自己随便定,发送至的端口号

datagramSocket.send(dj); //发送UDP广播
Log.i("Data", "发送的内容是" + ByteUtils.bytesToHexString(data));
datagramSocket.close();
isudpsendfinished=true;
ReUDPAndSenTCP(); //用于接收UDP响应的线程
}

} catch(IOException e) {
Log.i("Data","UDPBroadCast已经挂啦");
e.printStackTrace();
}
}

public void onStop() {
Log.i("Data","datagramSocket是否连接="+datagramSocket.isConnected()+"，是否关闭="+datagramSocket.isClosed());
if (!datagramSocket.isConnected() || datagramSocket.isClosed()) {
Log.i("Data", "datagramSocket已关闭");
datagramSocket.close();
}
this.interrupt();
Log.i("Data", "线程停止");
}

public void ReUDPAndSenTCP(){
if(isudpsendfinished){
if( mUDPReceiveAndTCPSnd == null) {
mUDPReceiveAndTCPSnd = new UDPReceiveAndTCPSend(callback);
mUDPReceiveAndTCPSnd.start();
}
}
}

public String getLocalIpAddress()
{
try
{
for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();)
{
NetworkInterface intf = en.nextElement();
for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();)
{
InetAddress inetAddress = enumIpAddr.nextElement();
if (!inetAddress.isLoopbackAddress())
{
return inetAddress.getHostAddress().toString();
}
}
}
}
catch (SocketException ex)
{
Log.e("Data","WifiPreference IpAddress"+ ex.toString());
}
return null;
}

public String getBoradcastIP(String IP){

String temp=IP.substring(0,11); //因为这是一个b类地址
Log.i("Data","temp="+temp);
StringBuffer buffer=new StringBuffer();
buffer.append(temp);
buffer.append("255");
return buffer.toString();

}

public String getWIFIIP(Context context){
WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
int ipAddress = wifiInfo.getIpAddress();
String SSID=wifiInfo.getSSID();
Log.i("Data","SSID="+SSID);
String IPAddress=intToIp(ipAddress); //获取WIFI的IP地址
return IPAddress;
}

public String intToIp(int i) {
return (( i & 0xFF)+ "."+ ((i >> 8 ) & 0xFF) + "."
+ ((i >> 16 ) & 0xFF) + "." +((i >> 24 ) & 0xFF )); }
}
</span>

UDP接收服务器响应内容
<span style="font-size:14px;">import android.util.Log;

import com.changhong.electric_controll.UDPResponseCallback;
import com.changhong.electric_controll.connect.entity.entity.UDPAccept;
import com.changhong.electric_controll.connect.entity.parser.UDPDataParser;
import com.changhong.electric_controll.util.ByteUtils;

import org.apache.http.conn.util.InetAddressUtils;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.net.Socket;
import java.net.SocketException;
import java.util.Enumeration;

/*接收udp多播 并 发送tcp 连接*/
public class UDPReceiveAndTCPSend extends Thread {
UDPResponseCallback mUDPResponseCallback;

public DatagramSocket datagramSocket=null;

public DatagramPacket dp;

public UDPDataParser mUDPParser;

public UDPAccept mUDPAccept;

public String mIPaddress;

public String mPort;

public int DEFAULT_PORT=12426;

public StringBuffer sb;

public UDPReceiveAndTCPSend(UDPResponseCallback callback){
this.mUDPResponseCallback=callback;
mUDPParser=new UDPDataParser();

}
@Override
public void run() {
byte[] data = new byte[1024];
try {
if(datagramSocket==null) {
datagramSocket=new DatagramSocket(null);
datagramSocket.setReuseAddress(true);
datagramSocket.bind(new InetSocketAddress(DEFAULT_PORT));
}
} catch (Exception e) {
e.printStackTrace();
}
while (true) {
try {
dp = new DatagramPacket(data, data.length);
if (datagramSocket != null) {
datagramSocket.receive(dp);
}
} catch (Exception e) {
Log.i("Data","UDPReceeive 已经挂啦");
e.printStackTrace();
}
if(dp != null){
String response= ByteUtils.bytesToHexString(dp.getData());
Log.i("Data", "UDP response = " + response);
byte[] data1=dp.getData();
mUDPAccept=mUDPParser.analysis(data1);
if(mUDPAccept != null) {
mIPaddress = mUDPParser.setIPAddress(mUDPAccept.getIPAddress());
mPort =mUDPParser.setPort(mUDPAccept.getPort());
}
Log.i("Data", "The Ip=" + mIPaddress);
Log.i("Data","The Port = "+mPort);
if (mIPaddress != null) {
final String quest_ip = dp.getAddress().toString().substring(1); //从UDP包中解析出IP地址
String host_ip = getLocalHostIp(); //若udp包的ip地址 是 本机的ip地址的话，丢掉这个包(不处理)
if ((!host_ip.equals("")) && host_ip.equals(quest_ip.substring(1))) {
continue;
}
if(mIPaddress.equals("0.0.0.0")){
mUDPResponseCallback.onResponse(null,false);
}
sb=new StringBuffer();
sb.append(mIPaddress);
sb.append(",");
sb.append(mPort);
Log.i("Data","UDP result="+sb.toString());
mUDPResponseCallback.onResponse(sb.toString(), true); //将IP地址传递回去
datagramSocket.close();
break;
}

}

}
}

public String getLocalHostIp() {
String ipaddress = "";
try {
Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
// 遍历所用的网络接口
while (en.hasMoreElements()) {
NetworkInterface nif = en.nextElement();// 得到每一个网络接口绑定的所有ip
Enumeration<InetAddress> inet = nif.getInetAddresses();
// 遍历每一个接口绑定的所有ip
while (inet.hasMoreElements()) {
InetAddress ip = inet.nextElement();
if (!ip.isLoopbackAddress()
&& InetAddressUtils.isIPv4Address(ip
.getHostAddress())) {
return ip.getHostAddress();
}
}
}
}
catch(SocketException e)
{
Log.e("Data", "获取本地ip地址失败");
e.printStackTrace();
}
return ipaddress;
}

}
</span>
用到的自定义接口UDPResponseCallback.java

<span style="font-size:14px;">public interface UDPResponseCallback {

public void onResponse(String response,boolean isSuccess);

}</span><strong style="font-size: 12pt;">
</strong>

在Activity中通过点击按钮发送和接收响应并处理响应内容

import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.Intent;

import android.os.Bundle;

import android.os.CountDownTimer;
import android.os.Handler;
import android.os.Message;
import android.provider.Settings;
import android.support.v7.app.ActionBarActivity;

import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.changhong.electric_controll.connect.entity.parser.UDPDataParser;
import com.changhong.electric_controll.util.ByteUtils;
import com.changhong.electric_controll.thread.UDPBroadCast;
import com.changhong.electric_controll.util.WifiUtil;

public class MainActivity extends ActionBarActivity implements View.OnClickListener{

private String TAG="MainActivity";

private TextView result_text;

private Button submit;

private Button cancel;

private AlertDialog wifiConfigDialig;

private ProgressDialog mProgressDialog;

public UDPBroadCast mUDPBroadCast;    //UDP连接线程

public boolean ifTCPSendFinished=false;   //用来判断TCP连接是否完成

public byte[] sendData;     //存放发送的UDP数据

private final static int DisProcess = 0x123;

private SocketTimeCounter timeCounter;    //计时器

private static final int TIME_MILLIS=60*1000;

public Handler mhandler=new Handler(){
public void handleMessage(Message msg){
switch(msg.what){
case DisProcess:
disAsynProgressDialog();
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initview();
}

/**
* 初始化控件
**/
private void initview() {

//result_text = (TextView) findViewById(R.id.result);

submit = (Button) findViewById(R.id.start_config);

cancel = (Button) findViewById(R.id.cancel_config);

submit.setOnClickListener(this);

cancel.setOnClickListener(this);
}

/**发送UDP广播并接收UDP广播，从中解析出IP地址
*
* OnResponse用于处理接收到的UDP包的内容
*
* **/

public void SenUDPBroadCast(byte[] sendBytes){
if(mUDPBroadCast != null){
mUDPBroadCast.onStop();
mUDPBroadCast=null;
}
mUDPBroadCast = new UDPBroadCast(MainActivity.this,sendBytes, new UDPResponseCallback() {
@Override
public void onResponse(String response,boolean isSuccess) {
try {
if(TextUtils.isEmpty(response)){
return;
}
if(!isSuccess){
Log.i("Data","MainActivity 连接失败，请重新连接");
disAsynProgressDialog();
showToast("连接失败，请重新连接");
stopTimeCounter();
return ;
}
Log.i("Data","设置显示信息");
String IPAddress=response.split(",")[0];
String Port=response.split(",")[1];
Log.i("Data", "MainActivity IP=" + IPAddress);
Log.i("Data", "MainActivity Port=" + Port);
ifTCPSendFinished=true;
disAsynProgressDialog();

Intent intent=new Intent(MainActivity.this, ShowInfoActivity.class);
intent.putExtra(ShowInfoActivity.IPADDRESS,IPAddress);
intent.putExtra(ShowInfoActivity.PORT,Port);
startActivity(intent);
MainActivity.this.finish();

}catch(Exception e){
e.printStackTrace();
}
}
});
mUDPBroadCast.start();
}

/**
* 点击配置按钮之后的后续操作
**/
public void submit() {
//这里写对数组byte的初始化
sendData=new UDPDataParser().build();
Log.i("Data", "发送的数据是" + ByteUtils.bytesToHexString(sendData));
startTimeCounter(TIME_MILLIS,TIME_MILLIS/2);     //开启计时器
SenUDPBroadCast(sendData);    //开始UDP连接
showAsyncProgressDialog("正在连接设备...",true);
}

/**
* toast提示
**/
public void showToast(String toastmessage) {
Toast.makeText(this, toastmessage, Toast.LENGTH_SHORT).show();
}

/**
* 数据加载小菊花
*
* @param msg      内容
* @param isCancel 是否允许关闭 true - 允许  false - 不允许
*/
public void showAsyncProgressDialog(final String msg, final boolean isCancel) {
runOnUiThread(new Runnable() {
@Override
public void run() {
try {
if (mProgressDialog == null) {
mProgressDialog = new ProgressDialog(MainActivity.this);
}
if (mProgressDialog.isShowing()) {
return;
}
mProgressDialog.setMessage(msg);
mProgressDialog.setCancelable(isCancel);
mProgressDialog.setCanceledOnTouchOutside(false);
mProgressDialog.setOnCancelListener(null);
mProgressDialog.show();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* 隐藏数据加载的进度小菊花
**/
public void disAsynProgressDialog() {

try {
if (mProgressDialog != null || mProgressDialog.isShowing()) {
runOnUiThread(
new Runnable() {
@Override
public void run() {
mProgressDialog.dismiss();
}
}
);
}
} catch (Exception e) {
e.printStackTrace();
}
}

public void onDestroy(){
super.onDestroy();
Log.i("Data","MainActivity 执行OnDestroy方法");
mUDPBroadCast.onStop();
stopTimeCounter();
}

/**关闭计时器**/
public void stopTimeCounter(){
if (null != timeCounter) {
Log.i("Data", "stop Timeout Counter");
timeCounter.cancel();
timeCounter = null;
}
}
/**开启计数器**/
public void startTimeCounter(int Millis,int interval){
stopTimeCounter();   //如果计时器已经开启，先关闭原来的，再重新开启
Log.i("Data","启动计时器");
timeCounter=new SocketTimeCounter(Millis,interval);
timeCounter.start();
}
@Override
public void onClick(View v) {

switch(v.getId()){
case R.id.start_config:
submit();
break;
case R.id.cancel_config:
break;
}
}

/**计时器**/
private class SocketTimeCounter extends CountDownTimer {

public SocketTimeCounter(int millistime,int interval){
super(millistime,interval);
}

@Override
public void onTick(long millisUntilFinished) {

}

@Override
public void onFinish() {
if(!ifTCPSendFinished){
if(!MainActivity.this.isFinishing()) {
disAsynProgressDialog();
mUDPBroadCast.onStop();
showToast("连接超时");
}
}
}
}

}