Android Wifi热点 数据传输Socket 通信

版权声明：转载必须注明本文转自黄淑媛的博客: http://blog.csdn.net/imshuyuan https://blog.csdn.net/Imshuyuan/article/details/80019335

首先，描述下功能，两个手机，其中一个手机开热点，另外一个手机连接热点，2个手机间数据通信（不需要流量）。简述一下原理：开热点的手机相当于路由器，连接的手机作为客户端，获取路由器的IP建立Socket 连接，开始双方通信。

一、服务器端：

开热点的作为服务器端

初始化数据：

    public static final int DEVICE_CONNECTING = 1;//有设备正在连接热点
    public static final int DEVICE_CONNECTED  = 2;//有设备连上热点
    public static final int SEND_MSG_SUCCSEE  = 3;//发送消息成功
    public static final int SEND_MSG_ERROR    = 4;//发送消息失败
    public static final int GET_MSG           = 6;//获取新消息
    private TextView      text_state;
    private WifiManager   wifiManager;
    /**
     * 连接线程
     */
    private ConnectThread connectThread;


    /**
     * 监听线程
     */
    private ListenerThread listenerThread;
    /**
     * 热点名称
     */
    private static final String WIFI_HOTSPOT_SSID = "TEST";
    /**
     * 端口号
     */
    private static final int    PORT              = 54321;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        findViewById(R.id.create_wifi).setOnClickListener(this);
        findViewById(R.id.close_wifi).setOnClickListener(this);
        findViewById(R.id.send).setOnClickListener(this);
        text_state = (TextView) findViewById(R.id.receive);


        wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        /**
         * 先开启监听线程，在开启连接
         */
        listenerThread = new ListenerThread(PORT, handler);
        listenerThread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //        开启连接线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress());
                    //本地路由开启通信
                    String ip = getWifiApIpAddress();
                    if (ip != null) {
                    } else {
                        ip = "192.168.43.1";
                    }
                    Socket socket = new Socket(ip, PORT);
                    connectThread = new ConnectThread(MainActivity.this, socket, handler);
                    connectThread.start();

                } catch (IOException e) {
                    e.printStackTrace();
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            text_state.setText("创建通信失败");
                        }
                    });

                }
            }
        }).start();


    }

创建wifi 热点，之后开启Socket 监听线程

 /**
     * 创建Wifi热点
     */
    private void createWifiHotspot() {
        if (wifiManager.isWifiEnabled()) {
            //如果wifi处于打开状态，则关闭wifi,
            wifiManager.setWifiEnabled(false);
        }
        final WifiConfiguration config = new WifiConfiguration();
        config.SSID = WIFI_HOTSPOT_SSID;
        config.preSharedKey = "123456789";
        config.hiddenSSID = false;
        config.allowedAuthAlgorithms
                .set(WifiConfiguration.AuthAlgorithm.OPEN);//开放系统认证
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
        config.allowedPairwiseCiphers
                .set(WifiConfiguration.PairwiseCipher.TKIP);
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
        config.allowedPairwiseCiphers
                .set(WifiConfiguration.PairwiseCipher.CCMP);
        config.status = WifiConfiguration.Status.ENABLED;
        //通过反射调用设置热点

        //192.168.43.59
        //        Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress() +
        //                "\n");
        try {
            Method method = wifiManager.getClass().getMethod(
                    "setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
            boolean enable = (Boolean) method.invoke(wifiManager, config, true);
            if (enable) {
                text_state.setText("热点已开启 SSID:" + WIFI_HOTSPOT_SSID + " password:123456789");


                //        开启连接线程
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress()
                            );
                            String ip = getWifiApIpAddress();
                            if (ip != null) {
                            } else {
                                //一般Android手机默认路由是
                                ip = "192.168.43.1";
                            }
                            //本地路由开启通信
                            Socket socket = new Socket(ip, PORT);
                            connectThread = new ConnectThread(MainActivity.this, socket, handler);
                            connectThread.start();


                        } catch (IOException e) {
                            e.printStackTrace();
                            runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    text_state.setText("创建通信失败");
                                }
                            });

                        }
                    }
                }).start();
                Thread.sleep(1000);

                //                listenerThread = new ListenerThread(PORT, handler);
                //                listenerThread.start();
            } else {
                text_state.setText("创建热点失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            text_state.setText("创建热点失败");
        }
    }

服务器端获取本地路由：

   public String getWifiApIpAddress() {
        try {
            for (Enumeration<NetworkInterface> en = NetworkInterface
                    .getNetworkInterfaces(); en.hasMoreElements(); ) {
                NetworkInterface intf = en.nextElement();
                if (intf.getName().contains("wlan")) {
                    for (Enumeration<InetAddress> enumIpAddr = intf
                            .getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                        InetAddress inetAddress = enumIpAddr.nextElement();
                        if (!inetAddress.isLoopbackAddress()
                                && (inetAddress.getAddress().length == 4)) {
                            Log.d("Main", inetAddress.getHostAddress());
                            return inetAddress.getHostAddress();
                        }
                    }
                }
            }
        } catch (SocketException ex) {
            Log.e("Main", ex.toString());
        }
        return null;
    }

关闭热点

 /**
     * 关闭WiFi热点
     */
    public void closeWifiHotspot() {
        try {
            Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
            method.setAccessible(true);
            WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
            Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
            method2.invoke(wifiManager, config, false);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        text_state.setText("热点已关闭");
    }

ListenerThread 监听线程

import android.os.Handler;
import android.os.Message;
import android.util.Log;

import com.example.syhuang.wifiserver.MainActivity;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 监听线程
 * Created by syh on 2018/4/3
 */
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);//监听本机的12345端口
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void run() {
        while (true) {
            try {
                Log.i("ListennerThread", "阻塞");
                //阻塞，等待设备连接
                if (serverSocket != null)
                    socket = serverSocket.accept();
                Message message = Message.obtain();
                message.what = MainActivity.DEVICE_CONNECTING;
                handler.sendMessage(message);
            } catch (IOException e) {
                Log.i("ListennerThread", "error:" + e.getMessage());
                e.printStackTrace();
            }
        }
    }

    public Socket getSocket() {
        return socket;
    }
}

ConnectThread 连接线程

package com.example.syhuang.wifiserver.thread;

import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import com.example.syhuang.wifiserver.MainActivity;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.text.DecimalFormat;

/**
 * 连接线程
 * Created by syhuang on 2018/4/3
 */
public class ConnectThread extends Thread {

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

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

    @Override
    public void run() {
/*        if(activeConnect){
//            socket.c
        }*/
        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);
                }
                //                DataInputStream dis = null;
                //                FileOutputStream fos = null;
                //                try {
                //                    dis = new DataInputStream(inputStream);
                //
                //                    // 文件名和长度
                //                    String fileName = dis.readUTF();
                //                    if (!fileName.equals("")) {
                //                        long fileLength = dis.readLong();
                //                        Log.i("ConnectThread", "======== 文件接收 [File Name：" + fileName + "] " +
                //                                "[Size：" + getFormatFileSize(fileLength) + "] ========");
                //                        File directory = new File(Environment.getExternalStorageDirectory() + "/");
                //                        if (!directory.exists()) {
                //                            directory.mkdir();
                //                        } else {
                //                        }
                //                        File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName);
                //                        fos = new FileOutputStream(file);
                //
                //                        // 开始接收文件
                //                        byte[] bytesA = new byte[1024];
                //                        int length = 0;
                //                        int progress = 0;
                //                        while ((length = dis.read(bytesA, 0, bytesA.length)) != -1) {
                //                            Log.i("ConnectThread", length + "...");
                //                            fos.write(bytesA, 0, length);
                //                            fos.flush();
                //                            progress += length;
                //                            Log.i("ConnectThread", "| " + (100 * progress / file.length()) + "% |");
                //                        }
                //                        Log.i("ConnectThread", "文件传输完成");
                //
                //                        Message message = Message.obtain();
                //                        message.what = MainActivity.GET_MSG;
                //                        Bundle bundle = new Bundle();
                //                        bundle.putString("MSG", new String("接收到文件：" + file.getAbsolutePath()));
                //                        message.setData(bundle);
                //                        handler.sendMessage(message);
                //                    } else {
                //                        //读取数据
                //                        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);
                //
                //                            Log.i("ConnectThread", "读取到数据:" + new String(data));
                //                        }
                //                    }


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

    /**
     * 格式化文件大小
     *
     * @param length
     * @return
     */
    private String getFormatFileSize(long length) {
        DecimalFormat df = new DecimalFormat("#0.0");
        double size = ((double) length) / (1 << 30);
        if (size >= 1) {
            return df.format(size) + "GB";
        }
        size = ((double) length) / (1 << 20);
        if (size >= 1) {
            return df.format(size) + "MB";
        }
        size = ((double) length) / (1 << 10);
        if (size >= 1) {
            return df.format(size) + "KB";
        }
        return length + "B";
    }

    public static boolean copyFile(InputStream inputStream, OutputStream out) {
        byte buf[] = new byte[1024];
        int len;
        try {
            while ((len = inputStream.read(buf)) != -1) {
                out.write(buf, 0, len);

            }
            out.close();
            //            inputStream.close();
        } catch (IOException e) {

            return false;
        }
        return true;
    }

    /**
     * 发送数据
     */
    public void sendData(String msg) {
        Log.i("ConnectThread", "发送数据:" + (outputStream == null));
        if (outputStream != null) {
            try {
                outputStream.write(msg.getBytes());
                Log.i("ConnectThread", "发送消息：" + msg);
                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);
            }
        }
    }

}

二、客户端

客户端连接到热点,代码差不多，初始化数据部分顺序不一样，先开启连接线程，在开启监听线程，获取路由器IP 地址有差别。其他基本一样。

wifi获取 已连接网络路由 路由ip地址

    /**
     * wifi获取 已连接网络路由  路由ip地址
     * @param context
     * @return
     */
    private static String getWifiRouteIPAddress(Context context) {
        WifiManager wifi_service = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        DhcpInfo dhcpInfo = wifi_service.getDhcpInfo();
        //        WifiInfo wifiinfo = wifi_service.getConnectionInfo();
        //        System.out.println("Wifi info----->" + wifiinfo.getIpAddress());
        //        System.out.println("DHCP info gateway----->" + Formatter.formatIpAddress(dhcpInfo.gateway));
        //        System.out.println("DHCP info netmask----->" + Formatter.formatIpAddress(dhcpInfo.netmask));
        //DhcpInfo中的ipAddress是一个int型的变量，通过Formatter将其转化为字符串IP地址
        String routeIp = Formatter.formatIpAddress(dhcpInfo.gateway);
        Log.i("route ip", "wifi route ip：" + routeIp);

        return routeIp;
    }

初始化

 public static final int DEVICE_CONNECTING = 1;//有设备正在连接热点
    public static final int DEVICE_CONNECTED  = 2;//有设备连上热点
    public static final int SEND_MSG_SUCCSEE  = 3;//发送消息成功
    public static final int SEND_MSG_ERROR    = 4;//发送消息失败
    public static final int GET_MSG           = 6;//获取新消息

    private TextView      text_state;
    /**
     * 连接线程
     */
    private ConnectThread connectThread;


    /**
     * 监听线程
     */
    private ListenerThread listenerThread;

    /**
     * 热点名称
     */
    private static final String WIFI_HOTSPOT_SSID = "TEST";
    /**
     * 端口号
     */
    private static final int    PORT              = 54321;
    private WifiManager wifiManager;

    private TextView status_init;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.send).setOnClickListener(this);
        findViewById(R.id.connect).setOnClickListener(this);
        findViewById(R.id.fileButton).setOnClickListener(this);
        wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);

        //检查Wifi状态
        if (!wifiManager.isWifiEnabled())
            wifiManager.setWifiEnabled(true);
        text_state = (TextView) findViewById(R.id.status_info);
        status_init = (TextView) findViewById(R.id.status_init);


        status_init.setText("已连接到：" + wifiManager.getConnectionInfo().getSSID() +
                "\nIP:" + getIp()
                + "\n路由：" + getWifiRouteIPAddress(MainActivity.this));

        //        initBroadcastReceiver();
        //        开启连接线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Socket socket = new Socket(getWifiRouteIPAddress(MainActivity.this), PORT);
                    connectThread = new ConnectThread(socket, handler);
                    connectThread.start();
                } catch (IOException e) {
                    e.printStackTrace();
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            text_state.setText("通信连接失败");
                        }
                    });

                }
            }
        }).start();


        listenerThread = new ListenerThread(PORT, handler);
        listenerThread.start();
    }

服务器和客户端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:
                    text_state.setText("设备连接成功");
                    break;
                case SEND_MSG_SUCCSEE:
                    text_state.setText("发送消息成功:" + msg.getData().getString("MSG"));
                    break;
                case SEND_MSG_ERROR:
                    text_state.setText("发送消息失败:" + msg.getData().getString("MSG"));
                    break;
                case GET_MSG:
                    text_state.setText("收到消息:" + msg.getData().getString("MSG"));
                    break;
            }
        }
    };

源码传送门

参考文章：

Android 连接Wifi和创建Wifi热点 demo - CSDN博客
Android WiFi开发 （一）扫描、连接、信息 - CSDN博客
Android/安卓开发之WIFI的基本应用 - CSDN博客
Android设备之间通过Wifi通信 - sowhat4999 - 博客园
Android WiFi开发教程（三）——WiFi热点数据传输 - CSDN博客
【Android】Android手机通过wifi进行数据传输 - CSDN博客
android wifi 点对点传输 - 简书
android WIFI Socket 文件传输 - Android移动开发技术文章_手机开发 - 红黑联盟
Android 实现无网络传输文件用户5207283611新浪博客
wifi direct—深入理解Wi-Fi P2P - CSDN博客
(高效开发)Android手机间使用socket进行文件互传实例 - CSDN博客
Android仿茄子快传-实现面对面快传功能 - CSDN博客
安卓手机wifi面对面快传的实现 - CSDN博客