### 思路回顧
[【1】手機連接WIFI模塊](http://blog.csdn.net/u010924834/article/details/49668623)
【2】UDP通信對WIFI模塊發送指令，以和WIFI模塊保持連接狀態
【3】UDP通信對WIFI模塊發送指令，讓其搜索可用的無線網，返回WIFI列表
【4】發送指令，讓WIFI模塊接入指定路由
【5】手機連接路由
【6】發送指令，獲得WIFI模塊的動態IP地址
### UDP通信線程類
~~~
package com.jczb.smartlife.common;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import android.os.Handler;
import android.os.Message;
import com.jczb.smartlife.common.Tool;
public class GetInfoThread extends Thread {
private Handler handler;
private DatagramSocket socket;
private int msgType;
private final String IP = "255.255.255.255";//廣播地址
private int PORT = 26000;
/**
* 48899端口：C32x系列的端口，用戶可以用AT指令更改
* 49000端口：除C32x系列，其他WIFI模塊的端口
* 1902端口：有人掌控寶系列產品的端口
*/
private int targetPort = 49000 ;
private boolean receive = true;
/**
*
* @param handler 傳入監聽此線程的Handler
* @param intMsg 傳入監聽的消息類型
*/
public GetInfoThread(Handler handler,int msgType) {
this.handler = handler;
this.msgType=msgType;
init();
}
public void init(){
try {
socket = new DatagramSocket(null);
socket.setBroadcast(true);
socket.setReuseAddress(true);
socket.bind(new InetSocketAddress(PORT));
} catch (SocketException e) {
e.printStackTrace();
sendErrorMsg("Search Thread init fail");
return;
}
}
public void run() {
if (socket == null) {
return;
}
try {
byte[] data = new byte[1024];
//創建一個空的DatagramPacket對象
DatagramPacket revPacket = new DatagramPacket(data, data.length);
while (receive) {
//服務端接收數據
socket.receive(revPacket);
if(null!=handler){
byte[] realData = new byte[revPacket.getLength()];
System.arraycopy(data, 0, realData,0, realData.length);
Message msg =handler.obtainMessage(msgType,realData);
handler.sendMessage(msg);
}
}
} catch (Exception e) {
e.printStackTrace();
socket.close();
}
}
public void close() {
if (socket == null)
return;
socket.close();
}
private void sendErrorMsg(String info){
}
/**
* 發送數據
* @param msg
*/
public void sendMsg(byte[] msg) {
if (socket != null) {
try {
System.out.println("targetPort------------------->"+targetPort);
DatagramPacket sendPacket = new DatagramPacket(msg, msg.length,
InetAddress.getByName(IP), targetPort);
socket.send(sendPacket);
} catch (UnknownHostException e) {
e.printStackTrace();
System.out.println("發送失敗");
} catch (IOException e) {
e.printStackTrace();
System.out.println("發送失敗");
}
}
}
public void setReceive(boolean receive) {
this.receive = receive;
}
public void setTargetPort(int targetPort) {
this.targetPort = targetPort;
}
public void setMsgType(int msgType){
this.msgType=msgType;
}
}
~~~
### 發送消息的線程類
~~~
/**
* 發送消息的隊列，每次發送數據時，只需要調用putMsg(byte[] data)方法
*
* @author usr_liujinqi
*
*/
private class SendMsgThread extends Thread {
// 發送消息的隊列
private Queue<byte[]> sendMsgQuene = new LinkedList<byte[]>();
// 是否發送消息
private boolean send = true;
private GetInfoThread ss;
public SendMsgThread(GetInfoThread ss) {
this.ss = ss;
}
public synchronized void putMsg(byte[] msg) {
// 喚醒線程
if (sendMsgQuene.size() == 0)
notify();
sendMsgQuene.offer(msg);
}
public void run() {
synchronized (this) {
while (send) {
// 當隊列里的消息發送完畢后，線程等待
while (sendMsgQuene.size() > 0) {
byte[] msg = sendMsgQuene.poll();
if (ss != null)
ss.sendMsg(msg);
}
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void setSend(boolean send) {
this.send = send;
}
}
~~~
### 應用
【舉例】發送搜索WIFI模塊的指令
~~~
//1.用戶獲得溫控器中WIFI模塊的WIFI模塊的IP地址,MAC地址,模塊名稱的指令
private final byte[] getInfoCode=new byte[]{(byte)0x48,0x46,0x2D,0x41,0x31,0x31,0x41,0x53,0x53,0x49,0x53,0x54,0x48,0x52,0x45,0x41,0x44};
public static final int REC_Module=0x04;//搜索WIFI模塊的信息（包括IP、Mac、名稱）
//實例化一個線程，用戶獲得模塊信息（IP，Mac，名稱）
//參數為監聽為此線程的Handler，以及接收成功后，給Handler發送的消息類型
getInfoThread = new GetInfoThread(handler,Tool.REC_Module);
getInfoThread.start();
//發送消息的線程
smt = new SendMsgThread(getInfoThread);
smt.start();
//設置發送的目的端口號
getInfoThread.setTargetPort(Integer.parseInt("48899"));
smt.putMsg(getInfoCode);
~~~
> WIFI模塊在接收到指令后，就會回復信息，以下的Handler就是針對回復過來的信息進行解析處理等操作。
~~~
//處理消息的Handler
private Handler handler= new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case Tool.REC_Module:// 解析接收到的數據
//設置發送的目的端口號
getInfoThread.setTargetPort(Integer.parseInt("48899"));
getInfoThread.setMsgType(Tool.REC_OK);
smt.putMsg(okCode);
SetServer();
SetDHCP();
byte[] data = (byte[]) msg.obj;
//將十進制的數據轉化成十六進制數據
String strTemp= Tool.bytesToHexString(data);
//將十六進制的字符串去掉空格之后進行解析
String strdecode=Tool.DecodeHex(strTemp.replace(" ", ""));
//取出IP，Mac地址，模塊名稱
decodeIP(strdecode);
Toast.makeText(ConnectWifiActivity.this, "獲得WIFI模塊名稱成功！"+ModuleName, Toast.LENGTH_SHORT).show();
break;
case Tool.REC_Server:
byte[] dataServer = (byte[])msg.obj;
//將十進制的數據轉化成十六進制數據
String strServer= Tool.bytesToHexString(dataServer);
if("2b 6f 6b 0d 0a 0d 0a ".equals(strServer)){
Toast.makeText(ConnectWifiActivity.this, "設置服務器成功！", Toast.LENGTH_SHORT).show();
}
break;
case Tool.REC_SSID:
byte[] dataSSID=(byte[])msg.obj;
Tool.bytesToHexString(dataSSID);
decodeData(dataSSID);
break;
case Tool.REC_AT:
byte[] dataID = (byte[]) msg.obj;
//將十進制的數據轉化成十六進制數據
String strTempID= Tool.bytesToHexString(dataID);
//將十六進制的字符串去掉空格之后進行解析
String strdecodeID=Tool.DecodeHex(strTempID.replace(" ", ""));
break;
case Tool.REC_DHCP:
byte[] dataDHCP = (byte[])msg.obj;
//將十進制的數據轉化成十六進制數據
String strDHCP= Tool.bytesToHexString(dataDHCP);
if("2b 6f 6b 0d 0a 0d 0a ".equals(strDHCP)){
Toast.makeText(ConnectWifiActivity.this, "設置DHCP網絡參數成功！", Toast.LENGTH_SHORT).show();
}
break;
default:
byte[] data1 = (byte[]) msg.obj;
//將十進制的數據轉化成十六進制數據
String strTemp1= Tool.bytesToHexString(data1);
Toast.makeText(ConnectWifiActivity.this, strTemp1, Toast.LENGTH_SHORT).show();
break;
}
}
};
~~~
### 總結
凡是需要對WIFI模塊發送指令的，就需要用到上述的兩個線程類，還有一個對返回信息進行處理的Handler。只是發送的指令的code不一樣，如上述表示的是搜索WIFI模塊的十六進制的指令。不管WIFI模塊在AP模式下還是STA模式，通信的最開始步驟都是先搜索模塊，然后獲得它的IP和Mac之后，立即回復+ok指令，就可以保持連接狀態。
### Demo下載
[UDP通信發送指令Demo](http://download.csdn.net/detail/u010924834/9271385)
