Android WiFi开发教程（三）——WiFi热点数据传输

在上一篇文章中介绍了WiFi的搜索和连接，如果你还没阅读过，建议先阅读上一篇Android WiFi开发教程（二）——WiFi的搜索和连接。本篇接着简单介绍手机上如何通过WiFi热点进行数据传输。

跟蓝牙通讯一样，WiFi热点数据传输也是要运用到Socket。这里我创建了两个线程ConnectThread和ListenerThread，分别去处理数据传输和监听连接。

ConnectThread

**
 * 连接线程
 * Created by 坤 on 2016/9/7.
 */
public class ConnectThread extends Thread{

    private final Socket socket;
    private Handler handler;
    private InputStream inputStream;
    private OutputStream outputStream;

    public ConnectThread(Socket socket, Handler handler){
        setName("ConnectThread");
        this.socket = socket;
        this.handler = handler;
    }

    @Override
    public void run() {
        if(socket==null){
            return;
        }
        handler.sendEmptyMessage(MainActivity.DEVICE_CONNECTED);
        try {
            //获取数据流
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();

            byte[] buffer = new byte[1024];
            int bytes;
            while (true){
                //读取数据
                bytes = inputStream.read(buffer);
                if (bytes > 0) {
                    final byte[] data = new byte[bytes];
                    System.arraycopy(buffer, 0, data, 0, bytes);

                    Message message = Message.obtain();
                    message.what = MainActivity.GET_MSG;
                    Bundle bundle = new Bundle();
                    bundle.putString("MSG",new String(data));
                    message.setData(bundle);
                    handler.sendMessage(message);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 发送数据
     */
    public void sendData(String msg){
        if(outputStream!=null){
            try {
                outputStream.write(msg.getBytes());
                Message message = Message.obtain();
                message.what = MainActivity.SEND_MSG_SUCCSEE;
                Bundle bundle = new Bundle();
                bundle.putString("MSG",new String(msg));
                message.setData(bundle);
                handler.sendMessage(message);
            } catch (IOException e) {
                e.printStackTrace();
                Message message = Message.obtain();
                message.what = MainActivity.SEND_MSG_ERROR;
                Bundle bundle = new Bundle();
                bundle.putString("MSG",new String(msg));
                message.setData(bundle);
                handler.sendMessage(message);
            }
        }
    }
}

在ConnectThread的构造中，传入了Socket和Handler。Socket用来获取数据以及发送数据，Handler用来更新UI了。在run方法中，我们从Socket中获取到了输入流和输出流，然后循环地读取InputStream的数据，当读取到数据时，则通过Handler将数据更新到UI上。在sendData方法中主要是通过OutputStream写入数据，然后将写入结果通过Handler更新到UI上。

ListenerThread

/**
 * 监听线程
 * Created by 坤 on 2016/9/7.
 */
public class ListenerThread extends Thread{

    private ServerSocket serverSocket = null;
    private Handler handler;
    private int port;
    private Socket socket;

    public ListenerThread(int port, Handler handler){
        setName("ListenerThread");
        this.port = port;
        this.handler = handler;
        try {
            serverSocket=new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void run() {
        while (true){
            try {
                //阻塞，等待设备连接
                socket = serverSocket.accept();
                Message message = Message.obtain();
                message.what = MainActivity.DEVICE_CONNECTING;
                handler.sendMessage(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public Socket getSocket() {
        return socket;
    }
}

监听线程处理的逻辑就比较简单，通过端口号获取ServerSocket后调用accept（）阻塞线程，直到有设备连接上后就通过Handler更新UI。这里需要注意的是连接上的设备的端口号必须与这里的端口号相同。接着我们看看Hander获取到消息后做了哪些处理。

private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case DEVICE_CONNECTING:
                    connectThread = new ConnectThread(listenerThread.getSocket(),handler);
                    connectThread.start();
                    break;
                    ... ...
            }
        }
    };

可以看到Handler获取到数据后，通过listenerThread.getSocket()将获取到Socket和handler一同创建了ConnectThread实例。

接下来就是用这两个线程来处理数据传输了。

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ... ...
        listenerThread = new ListenerThread(PORT, handler);
        listenerThread.start();
    }

在onCreate中我们创建ListenerThread并启动它，让它监听是否有设备连接上来。当然这里需要先开启WiFi热点后才会有设备连接上来。这是开启热点并等待设备连接的情况。当然我们也可以主动去连接其他开启着热点的设备。

在监听WiFi连接情况的广播接收者中加入下面的代码

if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
                    WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
                    final WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                    text_state.setText("已连接到网络:" + wifiInfo.getSSID());

                    if (wifiInfo.getSSID().equals(WIFI_HOTSPOT_SSID)) {
                        //如果当前连接到的wifi是热点,则开启连接线程
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                try {
                                    ArrayList<String> connectedIP = getConnectedIP();
                                    for (String ip : connectedIP) {
                                        if (ip.contains(".")) {

                                            Socket socket = new Socket(ip, PORT);
                                            connectThread = new ConnectThread(socket, handler);
                                            connectThread.start();
                                        }
                                    }

                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }).start();
                    }
                } else {
                    ...
                    }
            }

这里本地固定了其他设备WiFi热点的SSID,如果当前连接的WiFi的SSID跟我们之前保存的SSID一致，则证明我们连上了我们需要的WiFi热点。然后通过getConnectedIP（）获取WiFi热点的IP地址，通过这个IP地址和端口号创建一个Socket，然后创建ConnectThread来处理数据传输。到这里我们可以看到，PORT和SSID这两个数据是需要两个设备事先协议好的。

最后再看看Handler完整的代码

private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case DEVICE_CONNECTING:
                    connectThread = new ConnectThread(listenerThread.getSocket(),handler);
                    connectThread.start();
                    break;
                case DEVICE_CONNECTED:
                    textview.setText("设备连接成功");
                    break;
                case SEND_MSG_SUCCSEE:
                    textview.setText("发送消息成功:" + msg.getData().getString("MSG"));
                    break;
                case SEND_MSG_ERROR:
                    textview.setText("发送消息失败:" + msg.getData().getString("MSG"));
                    break;
                case GET_MSG:
                    textview.setText("收到消息:" + msg.getData().getString("MSG"));
                    break;
            }
        }
    };

至此，WiFi热点数据传输也就介绍完了。如果有什么疑问，欢迎和本人一起探讨。

最后附上源码地址

——————————————————————————————

github

csdn