WifiDirect （WIFIP2P）最全最详细,应用于智能硬件（智能家居，车机，无人机）等。

最新推荐文章于 2023-12-10 22:25:19 发布

唯爱丶卡卡西

最新推荐文章于 2023-12-10 22:25:19 发布

阅读量2.5w

点赞数 21

分类专栏： Android进阶文章标签： WifiP2P WifiDirect wifi直连智能硬件连接 wifi

本文链接：https://blog.csdn.net/qq_31332467/article/details/82429012

版权

Android进阶专栏收录该内容

20 篇文章 1 订阅

订阅专栏

前沿：好久没更博客了，手都快生了。不过但凡长时间的积累之后就会有精品，我希望我这一篇文章能帮助各位正在“坑里”的猿猿们。

产品：你给我调研一个手机连上无网WIFI 后能继续使用手机流量的需求。WIFI不能自动跳转和改变，（WIFI和移动流量必须同时开启）。
程序员：？？？？？纳尼？？2333333~

初听到需求，我于是去啪啪啪的搜了一圈，
搜：wifi和移动流量能同时使用么？wifi连接后，能强行使用移动流量么？等等。。。答案也是千奇百怪。有的需要改开发板，有需要用 wireless-tools 方式驱动WIFI ，通过命令启动 WIFI 模块。也有需要使用wpa_supplicant 方式驱动WIFI .可想而知，都没有权限，不符合需求。

直到遇见了WIFIP2P，一切问题迎刃而解。

背景

使用场景以及连接原理简介

wifip2p是一种点对点，一对多的角色。通俗点 Android中称之为WIFI直连，在IOS 中称之为 Airdrop（隔空投送），这种功能很强大，尤其是在智能家居，智能硬件领域。因为蓝牙的传输限制，无法满足更多的需求（比如视频数据的接收）。USB 可以满足这一点不假，但是有距离限制。而且也不是很方便。所以一般我们采用WIFI 连接。这种模式也可以。
查看WIFI网卡/手机网卡状态
如果：这时候你既要连接wifi设备，又要需要请求网络处理数据，怎么办。如今的手机我们都知道只要wifi连接，便中断手机移动数据。这一点我也已经确实的验证过。
运行 —> cmd —> adb shell —> netcfg
通过查看 rmnet0 （手机网卡）和 wlan0（WIFI连接）的状态（DOWN 和 UP）。
wifip2p作用
这时候wifip2p 的优点就显示出来的。既可以满足通信要求，又可以不影响手机网络。岂不是很nice。通过wifip2p设备可以直接通过WiFi共享文件，图片等（类似蓝牙传输），实现点对点的连接，通信（要求两设备必须位于同一网段）。在Miracast应用场景中，一台支持P2P的智能手机可直接连接上一台支持P2P的智能电视，智能手机随后将自己的屏幕，或者媒体资源传送给电视机去显示或播放。
显然，借助P2P技术，Wi-Fi设备之间的直接相连将极大拓展Wi-Fi技术的使用场景。
如何判断自己的设备是否支持wifip2p
判断设备是否支持WiFi直连是通过
PackageManager的hasSystemFeature （API）
ps：
getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_DIRECT);

代码实战

官方文档：http://developer.android.com/intl/zh-tw/guide/topics/connectivity/wifip2p.html
官方Demo： http://download.csdn.net/detail/yichigo/5516627

具体步骤
- 设置应用程序权限
- 创建一个广播接收器
- 初始化对等点的搜索
- 检查设备WIFI 是否开启，
- 只有上面的一步打开，才能开始搜索对等点
- 搜索到对等点列表，拿到列表信息
- 建立一个对等点连接

1.首先把需要的权限都配置好

    <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" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

2.需要监听WIFIP2P的广播

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.NetworkInfo;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pInfo;
import android.net.wifi.p2p.WifiP2pManager;
import android.text.TextUtils;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;


public class DirectBroadcastReceiver extends BroadcastReceiver {

    private static final String TAG = "DirectBroadcastReceiver";

    private WifiP2pManager mWifiP2pManager;

    private WifiP2pManager.Channel mChannel;
    /**是一个自定义监听 回调接口**/
    private WifiDirectActionListener mWifiDirectActionListener;

    public DirectBroadcastReceiver(WifiP2pManager wifiP2pManager, WifiP2pManager.Channel channel, DirectActionListener directActionListener) {
        mWifiP2pManager = wifiP2pManager;
        mChannel = channel;
        mDirectActionListener = directActionListener;
    }

    public static IntentFilter getIntentFilter() {
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        return intentFilter;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.e(TAG, "接收到广播： " + intent.getAction());
        if (!TextUtils.isEmpty(intent.getAction())) {
            switch (intent.getAction()) {
                /**用于指示 Wifi P2P 是否可用**/
                case WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION:
                    int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
                    if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
                        mWifiDirectActionListener.wifiP2pEnabled(true);
                    } else {
                        mWifiDirectActionListener.wifiP2pEnabled(false);
                        List<WifiP2pDevice> wifiP2pDeviceList = new ArrayList<>();
                        mWifiDirectActionListener.onPeersAvailable(wifiP2pDeviceList);
                    }
                    break;

                /**表明可用的对等点的列表发生了改变 **/
                case WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION:
                    mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {
                        @Override
                        public void onPeersAvailable(WifiP2pDeviceList peers) {
                            mWifiDirectActionListener.onPeersAvailable(peers.getDeviceList());
                        }
                    });
                    break;

                /**表示Wi-Fi对等网络的连接状态发生了改变 **/
                case WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION:
                    NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
                    if (networkInfo.isConnected()) {
                        mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {
                            @Override
                            public void onConnectionInfoAvailable(WifiP2pInfo info) {
                                if (info != null) {
                                    Log.i(TAG, "确实获取到WiFip2pinfo");
                                    //！！！这里很关键，只有真正的走到这里，才是真正的建立了P2P连接。拿到了准备建立Socket通道的必要信息。
                                } else {
                                    Log.i(TAG, "WiFip2pinfo 为null");
                                }
                                mWifiDirectActionListener.onConnectionInfoAvailable(info);
                            }
                        });
                        Log.i(TAG, "已连接P2P");
                    } else {
                        mWifiDirectActionListener.onDisconnection();
                        Log.i(TAG, "与P2P设备已断开连接");
                    }
                    break;

                /**表示该设备的配置信息发生了改变**/
                case WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION:
                    mWifiDirectActionListener.onSelfDeviceAvailable((WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));
                    break;
                default:

                    break;
            }
        }
    }

}

自定义回调监听

public interface WifiDirectActionListener extends WifiP2pManager.ChannelListener {

    void wifiP2pEnabled(boolean enabled);

    void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo);

    void onDisconnection();

    void onSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice);

    void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList);

}

3.初始化WIFIP2P的config,并且开始搜索
【！！！在我开发过程，我发现需要真正的搜索到列表，必须多台设备都处于搜索状态，否自不处于搜索的那个设备是不会出现在DeviceList中，可以尝试熄屏，后台状态。】

    private WifiP2pManager mWifiP2pManager;
    private WifiP2pManager.Channel mChannel;
    private WifiP2pDevice mWifiP2pDevice;
    private BroadcastReceiver broadcastReceiver;
    private boolean mWifiP2pEnabled = false;
    private List<WifiP2pDevice> mWifiP2pDeviceList;

  private void initConfig() {
        mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this);
        broadcastReceiver = new DirectBroadcastReceiver(mWifiP2pManager, mChannel, this);
        registerReceiver(broadcastReceiver, DirectBroadcastReceiver.getIntentFilter());
        //如果需要P2P设备列表的话，可以在这里初始化一个集合
        mWifiP2pDeviceList = new ArrayList<>();
    }

接着开始搜索列表

   mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
                    @Override
                    public void onSuccess() {
                        showToast("Success");
                    }

                    @Override
                    public void onFailure(int reasonCode) {
                        showToast("Failure");

                    }
                });

如果写了Adapter 就可以直接看到列表有多少个对等点。同样也可以直接在广播中打log

 case WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION:
 ？？？？？
 break；

同时，我们可以获取到当前设备的一些基本信息。在广播

case WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION:
     mDirectActionListener.onSelfDeviceAvailable((WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));
    break;

    @Override
    public void onSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice) {
        Log.i(TAG, "DeviceName: " + wifiP2pDevice.deviceName);
        Log.i(TAG, "DeviceAddress: " + wifiP2pDevice.deviceAddress);
        Log.i(TAG, "Status: " + wifiP2pDevice.status);
      //注意这里的 wifiP2pDevice.status 并不是真正的连接状态，但是如果P2P连接成功，这里的状态一定是 wifiP2pDevice.status ==0 。后面总结会具体讲述
    }

先贴出一张API参数信息。
这里写图片描述

4.在接着就是连接P2P
注意：这里很值得说一说。我们调用manager中的connect方法，
①如果连接之前没有创建一个组，系统会自动创建一个组，并且随机分配谁是GroupOwner即谁是组长，
②创建一个组，谁创建谁就是组长。
③这也关系到谁是客户端谁是服务器，

为什么要重点提示谁是组长？因为这里有坑，就是组长只有接受数据的能力，非组长拥有发送数据的能力。并不是谁都可以随便发送和接收，因为Socket 建立需要IP，而WIFIP2P 连接后并不能获取到客户机的IP。只能获取到组长的IP 。也就是 wifiP2pInfo.groupOwnerAddress.getHostAddress()

PS: 一开始我也不知道问题出在那里，后来就查到大家都有这种问题。
https://bbs.csdn.net/topics/390780179/

最近在研究wifi direct
，主要是通过IWIFIP2PManager类来操作，但是我发现，当成功建立连接后，好像从ConnectInfo中（WIFIP2PInfo）中只能获取GroupOwner的IpAddress，并没有API可以提供其他Device的IpAdress。这个会导致上层应用无法获得对端Ip地址，而无法传递数据等。由于在不同的场景下，任何设备都有可能是GroupOwner，而我们除了GroupOwner的Ip
Address外，还希望能获取对端以及Group中所有成员的Ip Address，包括自己的Ip Address.

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

                @Override
                public void onFailure(int reason) {
                    Log.e(TAG, "connect fail");
                }
            });
        }
    }

主动创建组长

    private void createroup() {
        mWifiP2pManager.createGroup(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.e(TAG, "createGroup onSuccess");
                showToast("onSuccess");
            }

            @Override
            public void onFailure(int reason) {
                Log.e(TAG, "createGroup onFailure: " + reason);
                showToast("onFailure");
            }
        });
    }

同样，断开连接就是移除组就可以了。

    private void disconnect() {
        mWifiP2pManager.removeGroup(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onFailure(int reasonCode) {
                Log.i(TAG, "disconnect onFailure:" + reasonCode);
            }

            @Override
            public void onSuccess() {
                Log.i(TAG, "disconnect onSuccess");
            }
        });
    }

4.数据连接阶段，非组长（群主）代码
开启异步操作。

  new WifiClientTask(this, fileTransfer).execute(wifiP2pInfo.groupOwnerAddress.getHostAddress());
/**这里的 fileTransfer 就是需要传输的 Object 自定义个Bean 就好 ,重写 Serializable
    而wifiP2pInfo.groupOwnerAddress.getHostAddress() 就是组IP**/

public class WifiClientTask extends AsyncTask<String, Integer, Boolean> {

    private ProgressDialog progressDialog;

    private FileTransfer fileTransfer;

    private static final int PORT = 4786;

    private static final String TAG = "WifiClientTask";

    public WifiClientTask(Context context, FileTransfer fileTransfer) {
        this.fileTransfer = fileTransfer;
        progressDialog = new ProgressDialog(context);
        progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        progressDialog.setCancelable(false);
        progressDialog.setCanceledOnTouchOutside(false);
        progressDialog.setTitle("正在发送文件");
        progressDialog.setMax(100);
    }

    @Override
    protected void onPreExecute() {
        progressDialog.show();
    }

    @Override
    protected Boolean doInBackground(String... strings) {
        fileTransfer.setMd5(Md5Util.getMd5(new File(fileTransfer.getFilePath())));
        Log.i(TAG, "文件的MD5码值是：" + fileTransfer.getMd5());
        Socket socket = null;
        OutputStream outputStream = null;
        ObjectOutputStream objectOutputStream = null;
        InputStream inputStream = null;
        try {
            socket = new Socket();
            socket.bind(null);
            Log.i(TAG, "IP:" + strings[0] + "PORT:" + PORT);
            socket.connect((new InetSocketAddress(strings[0], PORT)), 10000);
            outputStream = socket.getOutputStream();
            objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(fileTransfer);
            inputStream = new FileInputStream(new File(fileTransfer.getFilePath()));
            long fileSize = fileTransfer.getFileLength();
            long total = 0;
            byte buf[] = new byte[512];
            int len;
            while ((len = inputStream.read(buf)) != -1) {
                outputStream.write(buf, 0, len);
                total += len;
                int progress = (int) ((total * 100) / fileSize);
                publishProgress(progress);
                Log.i(TAG, "文件发送进度：" + progress);
            }
            outputStream.close();
            objectOutputStream.close();
            inputStream.close();
            socket.close();
            outputStream = null;
            objectOutputStream = null;
            inputStream = null;
            socket = null;
            Log.i(TAG, "文件发送成功");
            return true;
        } catch (Exception e) {
            Log.i(TAG, "文件发送异常 Exception: " + e.getMessage());
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (objectOutputStream != null) {
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        progressDialog.setProgress(values[0]);
    }

    @Override
    protected void onPostExecute(Boolean aBoolean) {
        progressDialog.cancel();
        Log.i(TAG, "onPostExecute: " + aBoolean);
    }

}

而Socket.accept 等待方开启IntentService

public class WifiServerService extends IntentService {

    private static final String TAG = "WifiServerService";

    public interface OnProgressChangListener {

        //当传输进度发生变化时
        void onProgressChanged(FileTransfer fileTransfer, int progress);

        //当传输结束时
        void onTransferFinished(File file);

    }

    private ServerSocket serverSocket;

    private InputStream inputStream;

    private ObjectInputStream objectInputStream;

    private FileOutputStream fileOutputStream;

    private OnProgressChangListener progressChangListener;

    private static final int PORT = 4786;

    public class MyBinder extends Binder {
        public WifiServerService getService() {
            return WifiServerService.this;
        }
    }

    public WifiServerService() {
        super("WifiServerService");
        Log.i(TAG, "WifiServerService");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate");
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind");
        return new MyBinder();
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.i(TAG, "onHandleIntent");
        clean();
        File file = null;
        try {
            serverSocket = new ServerSocket();
            serverSocket.setReuseAddress(true);
            serverSocket.bind(new InetSocketAddress(PORT));
            Socket client = serverSocket.accept();
            Log.i(TAG, "客户端IP地址 : " + client.getInetAddress().getHostAddress());
            inputStream = client.getInputStream();
            objectInputStream = new ObjectInputStream(inputStream);
            /**如果你写的是2个程序，尽管FileTransfer一样，但是也要注意包名，其实只要Socket 连接通，客户端IP 拿到，就达到了目标。**/
            FileTransfer fileTransfer = (FileTransfer) objectInputStream.readObject();
            Log.i(TAG, "待接收的文件: " + fileTransfer);
            String name = new File(fileTransfer.getFilePath()).getName();
            //将文件存储至指定位置
            file = new File(Environment.getExternalStorageDirectory() + "/" + name);
            fileOutputStream = new FileOutputStream(file);
            byte buf[] = new byte[512];
            int len;
            long total = 0;
            int progress;
            while ((len = inputStream.read(buf)) != -1) {
                fileOutputStream.write(buf, 0, len);
                total += len;
                progress = (int) ((total * 100) / fileTransfer.getFileLength());
                Log.i(TAG, "文件接收进度: " + progress);
                if (progressChangListener != null) {
                    progressChangListener.onProgressChanged(fileTransfer, progress);
                }
            }
            serverSocket.close();
            inputStream.close();
            objectInputStream.close();
            fileOutputStream.close();
            serverSocket = null;
            inputStream = null;
            objectInputStream = null;
            fileOutputStream = null;
            Log.i(TAG, "文件接收成功，文件的MD5码是：" + Md5Util.getMd5(file));
        } catch (Exception e) {
            Log.i(TAG, "文件接收 Exception: " + e.getMessage());
        } finally {
            clean();
            if (progressChangListener != null) {
                progressChangListener.onTransferFinished(file);
            }
            //再次启动服务，等待客户端下次连接
            startService(new Intent(this, WifiServerService.class));
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        clean();
    }

    public void setProgressChangListener(OnProgressChangListener progressChangListener) {
        this.progressChangListener = progressChangListener;
    }

    private void clean() {
        if (serverSocket != null) {
            try {
                serverSocket.close();
                serverSocket = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (inputStream != null) {
            try {
                inputStream.close();
                inputStream = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (objectInputStream != null) {
            try {
                objectInputStream.close();
                objectInputStream = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileOutputStream != null) {
            try {
                fileOutputStream.close();
                fileOutputStream = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

其实Demo 我也是从githup上拿到的。但是同样我也将我自己遇到的坑总结了一翻，彻底明白了WIFIP2P 。
https://github.com/leavesC/WifiP2P

总结【精华】

WIFIP2P连接成功后，要注意，只有非群主才能向群主发送Socket建立，并能成功发送数据。
~~~~~
原因：当成功建立连接后，从WIFIP2PInfo中只能获取GroupOwner的IpAddress，并没有API可以提供其他Device的IpAdress。这个会导致上层应用无法获得对端Ip地址，而无法传递数据等。由于在不同的场景下，任何设备都有可能是GroupOwner，而我们除了GroupOwner的Ip Address外，还希望能获取对端以及Group中所有成员的Ip Address，包括自己的Ip Address.
WIFIP2P 建连后（connect方法），如果连接之前没有创建一个组，系统会自动创建一个组，并且随机分配谁是GroupOwner即谁是组长，这也关系到谁是客户端谁是服务器.
~~~~~
问题：这有个坑，非常大的几率他会一直锁定一个Device 为群主，不管是A 连接B ，还是B 连接 A, 还是A 连接C。所以一定要确定 wifiinfo 中
wifiP2pInfo.groupFormed——–一定要为true ，这样wifiinfo才包含有用信息
wifiP2pInfo.isGroupOwner——–一定要为false，是非群主，见1.才有可能发送信息。
~~~~~
如何解决：API 也有方法提供
调用 wifiP2pManager.createGroup(channel, new WifiP2pManager.ActionListener() {}，在未连接p2p 之前，在你想要当做服务器的（AP）的机子上提前 createGroup，并在开始连接。就可以结局随机组长的问题。
WifiP2pDevice 的意思是【本机设备信息】，所以千万不要误以为是获取到的是另外一台设备的设备信息。
其中常用有：
wifiP2pDevice.deviceName 本设备名字
wifiP2pDevice.deviceAddress 本设备的MAC地址
wifiP2pDevice.status 设备连接状态
~~~~~
重点！！！千万不要以为 wifiP2pDevice.status
（0是连接，1是邀请中，3是未连接，但是可用，4是不可用）
为0的时候就是连接了，问题在于：p2p连接了，status 一定为0，但是status 为0 ，p2p不一定真正的连接了。这种情况在连接【智能设备】的时候容易出现，我就在此被坑了。真正的wifip2p 连接成功，必须要在
WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION
广播中获得为true
intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO).isConnected()
并且通过
mWifiP2pManager.requestConnectionInfo(?,?);的回调监听，拿到wifiinfo的实体，且不为空。才算的上你真正的加入p2p组。
至此，wifip2p 连接问题的问题点基本已经解决。真正连接后p2p 后就要建立Socket连接。一般是没有问题的，有问题也只有2点

1.）文件路径没有获取到，我们通过intent 获取到的一般是 Uri
content://com.android.providers.media.documents/document/image%3A63
而我们想要的是文件绝对路径
/data/hw_init/version/region_comm/china/media/Pre-loaded/Pictures/01-04.jpg
这样才能通过 File file = new File(path); 文件。
所以注意这一点路径转换过程是否为空
~~
2.）socket 服务器等待方 serverSocket.accept();
其实也只是要保证是否在等待。
楼主使用的是Githup的Demo ，其中serverSocket.accept(); 是在intentservice 的
onHandleIntent 中开启的，这个intentservice 的开启有2种方式，startService 和
bindService 一般我们喜欢使用bindService ，毕竟数据接收后需要处理，通知UI 线程。
但是bingService 的生命周期是不走 onHandleIntent. 而 startService 是走的。具体看我另外一篇博客对Service 和IntentService 的解释。（下面是链接）
https://blog.csdn.net/qq_31332467/article/details/82430638
在开发过程中发现，WIFIP2P连接，必须双向设备都处于discoverPeers状态中，如果一方不在该状态中，则另一方根本拿不到设备列表，拿不到就谈不了最基本的连接

后记

因为我连接的硬件是车机，车机开发板中有很多问题，可能对Android开发板做了修改，我这边就遇到2个问题：

1.一个车机是有WIFI ，但是却没有直连模块，问了供货商，他们说没改过。可是开了广播后，无论如何都拿不到广播，根本连onReceive 都没走。那就什么都不用谈了，列表都拿不到，还说什么。
2.换了一台车机（另一个供货商的），这个就很顺利的拿到了列表。果然供应商都是。。。。但是这个更坑，让我白高兴了一场。

顺利拿到了列表，也顺利连接上了，只是mWifiP2pManager.connect（）中回调成功。我以为连接OK，就开始Socket建连，可无论如何都是提示 Connection refusal！
我怎么就不明白，难道开发商的车机觉得我的客户端IP 非法，给我拒绝了？
一直就认为是套接字的问题。后来才发现，其实根本就没连接上，关键在广播中的

 case WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION:
                    NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
                    if (networkInfo.isConnected()) {
                        mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {
                            @Override
                            public void onConnectionInfoAvailable(WifiP2pInfo info) {
                                if (info != null) {
                                  /**！！！！只有真正的走到这里才是真正连接！！！！**/
                                } else {
                                    Log.i(TAG, "WiFip2pinfo 为null");
                                }
                                mDirectActionListener.onConnectionInfoAvailable(info);
                            }
                        });
                        Log.i(TAG, "已连接P2P");
                    } else {
                        mDirectActionListener.onDisconnection();
                        Log.i(TAG, "与P2P设备已断开连接");
                    }
                    break;

然后在赋值WifiP2pInfo 的时候，更要注意：

 @Override
    public void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo) {  

        Log.i(TAG, "onConnectionInfoAvailable groupFormed: " + wifiP2pInfo.groupFormed);
        Log.i(TAG, "onConnectionInfoAvailable isGroupOwner: " + wifiP2pInfo.isGroupOwner);
        Log.i(TAG, "onConnectionInfoAvailable getHostAddress: " + wifiP2pInfo.groupOwnerAddress.getHostAddress());
       /**必须if条件成立才可以开启 AsyncTask**/
        if (wifiP2pInfo.groupFormed && !wifiP2pInfo.isGroupOwner) {
            Log.e(TAG, "F-Z-C-G");
            this.wifiP2pInfo = wifiP2pInfo;
        }
    }

本章完结

唯爱丶卡卡西

关注

21
点赞
踩
116

收藏

觉得还不错? 一键收藏
8
评论
WifiDirect （WIFIP2P）最全最详细,应用于智能硬件（智能家居，车机，无人机）等。

产品：你给我调研一个手机连上无网WIFI 后能继续使用手机流量的需求。WIFI不能自动跳转和改变，（WIFI和移动流量必须同时开启）。程序员：？？？？？纳尼？？2333333~
复制链接

扫一扫