Android wifi点对点连接 wifi点对点传输

转载

智能创新梦想家 2023-11-27 15:16:11

文章标签 Android wifi点对点连接 android java 网络客户端 文章分类 Android 移动开发

Wifi P2p的描述

Wifi P2P 是在 Android 4.0 以及更高版本系统中加入的功能，通过 Wifi P2P 可以在不连接网络的情况下，直接与配对的设备进行数据交换。相对于蓝牙，Wifi P2P 的搜索速度和传输速度更快，传输距离更远,底部的通讯原理是通过Binder通讯

二、Wifi P2p的开发步骤

1.在 AndroidManifest 中声明相关权限（网络和文件读写权限）

2.获取 WifiP2pManager ，注册相关广播监听Wifi直连的状态变化

3.指定某一台设备为服务器（用来接收文件），创建群组并作为群主存在，在指定端口监听客户端的连接请求，等待客户端发起连接请求以及文件传输请求

4.客户端（用来发送文件）主动搜索附近的设备，加入到服务器创建的群组，获取服务器的IP地址，向其发起文件传输请求

三、声明权限

Wifi P2P 技术并不会访问网络，但由于会使用到 Java Socket，所以需要申请网络权限。

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

四、注册广播

与 Wifi P2P 相关的广播有以下几个：

WIFI_P2P_STATE_CHANGED_ACTION（用于指示 Wifi P2P 是否可用）
WIFI_P2P_PEERS_CHANGED_ACTION（对等节点列表发生了变化）
WIFI_P2P_CONNECTION_CHANGED_ACTION（ Wifi P2P 的连接状态发生了改变）
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION（本设备的设备信息发生了变化）

当收到 WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION 广播时，可以判断当前 Wifi P2P是否可用

int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);

if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {

    mDirectActionListener.wifiP2pEnabled(true);

} else {

    mDirectActionListener.wifiP2pEnabled(false);                

}

当收到 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION 广播时，意味设备周围的可用设备列表发生了变化，可以通过 requestPeers 方法得到可用的设备列表，之后就可以选择当中的某一个设备进行连接操作

mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {

    @Override

    public void onPeersAvailable(WifiP2pDeviceList peers) {

        mDirectActionListener.onPeersAvailable(peers.getDeviceList());

    }

});

当收到 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION 广播时，意味着 Wifi P2P 的连接状态发生了变化，可能是连接到了某设备，或者是与某设备断开了连接

NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);

if (networkInfo.isConnected()) {

    mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {

        @Override

        public void onConnectionInfoAvailable(WifiP2pInfo info) {

            mDirectActionListener.onConnectionInfoAvailable(info);

        }

    });

    Log.e(TAG, "已连接p2p设备");

} else {

    mDirectActionListener.onDisconnection();

    Log.e(TAG, "与p2p设备已断开连接");

}

如果是与某设备连接上了，则可以通过 requestConnectionInfo 方法获取到连接信息

当收到 WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION 广播时，则可以获取到本设备变化后的设备信息

(WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE)

可以看出 Wifi P2P 的接口高度异步化，到现在已经用到了三个系统的回调函数，一个用于 WifiP2pManager 的初始化，两个用于在广播中异步请求数据，为了简化操作，此处统一使用一个自定义的回调函数，方法含义与系统的回调函数一致

public interface DirectActionListener extends WifiP2pManager.ChannelListener {


    void wifiP2pEnabled(boolean enabled);

    void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo);

    void onDisconnection();

    void onSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice);

    void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList);
}

五、服务器端创建群组

假设当设备A搜索到了设备B，并与设备B连接到了一起，此时系统会自动创建一个群组（Group）并随机指定一台设备为群主（GroupOwner）。此时，对于两台设备来说，群主的IP地址是可知的（系统回调函数中有提供），但客户端的IP地址需要再来通过其他方法来主动获取。例如，可以在设备连接成功后，客户端主动发起对服务器端的Socket连接请求，服务器端在指定端口监听客户端的连接请求，当连接成功后，服务器端就可以获取到客户端的IP地址了此处为了简化操作，直接指定某台设备作为服务器端（群主），即直接指定某台设备用来接收文件

因此，服务器端要主动创建群组，并等待客户端的连接

wifiP2pManager.createGroup(channel, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
        Log.e(TAG, "createGroup onSuccess");

        dismissLoadingDialog();

        showToast("onSuccess");
    }
     @Override

     public void onFailure(int reason) {

        Log.e(TAG, "createGroup onFailure: " + reason);

        dismissLoadingDialog();

        showToast("onFailure");
    }
});

此处，使用 IntentService 在后台监听客户端的 Socket 连接请求，并通过输入输出流来传输文件。此处的代码比较简单，就只是在指定端口一直堵塞监听客户端的连接请求，获取待传输的文件信息模型 FileTransfer ，之后就进行实际的数据传输

@Override

    protected void onHandleIntent(Intent intent) {

        clean();

         try {

            serverSocket = new ServerSocket();

            serverSocket.setReuseAddress(true);

            serverSocket.bind(new InetSocketAddress(PORT));

            Socket client = serverSocket.accept();

            Log.e(TAG, "客户端IP地址 : " + client.getInetAddress().getHostAddress());

            inputStream = client.getInputStream();

            bos = new ByteArrayOutputStream()

            byte buf[] = new byte[512];

            int len;

            while ((len = inputStream.read(buf)) != -1) {

                bos.write(buf,0,len);

            }

            String str = bos.toString();

            serverSocket.close();

            inputStream.close();

            bos.close();

            serverSocket = null;

            inputStream = null;
bos = null;

            Log.e(TAG, "文件接收成功"+str);

        } catch (Exception e) {

            Log.e(TAG, "文件接收 Exception: " + e.getMessage());

        } finally {

            clean();
            //再次启动服务，等待客户端下次连接

            startService(new Intent(this, WifiServerService.class));
        }
    }

因为客户端可能会多次发起连接请求，所以当此处文件传输完成后（不管成功或失败），都需要重新 startService ，让服务再次堵塞等待客户端的连接请求

六、客户端加入群组并发起向服务端发起请求

需要实现 DirectActionListener 接口首先，需要先注册P2P广播，以便获取周边设备信息以及连接状态

@Override

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_send_file);
        initView();
        mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this);
        broadcastReceiver = new DirectBroadcastReceiver(mWifiP2pManager, mChannel, this);
        registerReceiver(broadcastReceiver, DirectBroadcastReceiver.getIntentFilter());
    }

通过 discoverPeers 方法搜索周边设备，回调函数用于通知方法是否调用成功
mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
       showToast("Success");
    }
    @Override
    public void onFailure(int reasonCode) {
        showToast("Failure");
        loadingDialog.cancel();
     }

});

当搜索结束后，系统就会触发 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION 广播，此时就可以调用 requestPeers 方法获取设备列表信息，此处用 RecyclerView 展示列表，在 onPeersAvailable 方法刷新列表

mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {
    @Override
    public void onPeersAvailable(WifiP2pDeviceList peers) {
       mDirectActionListener.onPeersAvailable(peers.getDeviceList());
    }

});
    @Override
    public void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList) {
        Log.e(TAG, "onPeersAvailable :" + wifiP2pDeviceList.size());
        this.wifiP2pDeviceList.clear();
        this.wifiP2pDeviceList.addAll(wifiP2pDeviceList);
        deviceAdapter.notifyDataSetChanged();
        loadingDialog.cancel();
    }

之后，通过点击事件选中群主（服务器端）设备，通过 connect 方法请求与之进行连接

private void connect() {
    WifiP2pConfig config = new WifiP2pConfig();
    if (config.deviceAddress != null && mWifiP2pDevice != null) {
        config.deviceAddress = mWifiP2pDevice.deviceAddress;
        config.wps.setup = WpsInfo.PBC;
        showLoadingDialog("正在连接 " + mWifiP2pDevice.deviceName);
        mWifiP2pManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
               Log.e(TAG, "connect onSuccess");
            }
            @Override

            public void onFailure(int reason) {
                showToast("连接失败 " + reason);
                dismissLoadingDialog();
            }
        });
    }
}

此处依然无法通过函数函数来判断连接结果，需要依靠系统发出的 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION 方法来获取到连接结果，在此处可以通过 requestConnectionInfo 获取到组连接信息，信息最后通过 onConnectionInfoAvailable 方法传递出来，在此可以判断当前设备是否为群主

@Override

public void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo) {

   if (wifiP2pInfo.groupFormed && !wifiP2pInfo.isGroupOwner) {
        this.wifiP2pInfo = wifiP2pInfo;
    }

}

至此服务器端和客户端已经通过 Wifi P2P 连接在了一起，客户端也获取到了服务器端的IP地址，此时客户端就可以给服务端发送请求了
消息的发送操作放到 AsyncTask 中处理，将服务器端的IP地址作为参数传进来
 public class WifiClientTask extends AsyncTask<String, Integer, Boolean> {
    private FileTransfer fileTransfer;

    private static final int PORT = 4786;

    private static final String TAG = "WifiClientTask";

    public WifiClientTask(FileTransfer fileTransfer) {

        this.fileTransfer = fileTransfer;
    }
    @Override

   protected Boolean doInBackground(String... strings) {
        Socket socket = null;
        OutputStream outputStream = null;
        try {
           socket = new Socket();
           socket.connect((new InetSocketAddress(strings[0], PORT)), 1000);
            outputStream = socket.getOutputStream();
            outputStream.write(fileTransfer.getStatus.getBytes())
            outputStream.close();
            socket.close();
            outputStream = null;
            socket = null;
           Log.e(TAG, "文件发送成功");
            return true;
        } catch (Exception e) {
            Log.e(TAG, "文件发送异常 Exception: " + e.getMessage());
        } finally {
           if (outputStream != null) {
               try {
                    outputStream.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }
            }
        
           if (socket != null) {
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。