马上搞定Android平台的Wi-Fi Direct开发

导语

　　移动互联网时代，很多用户趋向于将大量的资料保存在移动设备上。但在给用户带来便利的同时引发了一个新的问题——保存在移动设备上的资料该怎样共享出去？到了思考时间，普通青年这样想：折腾什么劲啊，直接用数据线不就行了；而文艺青年可能这样想：咱们建个群吧，大家有好的东西都可以共享；二逼青年不高兴了，都特么互联网时代了，来点新意，好么？直接上网盘啊，大家互相研究研究，你懂的，嘿嘿。然而我是这样想的：都特么别BB，技术要以时俱进，来个新潮点的不行么？直接上Wi-Fi Direct。好用简单不解释。那么我们就迫不及待地开始吧。

认识Wi-Fi Direct

　　Wi-Fi Direct,也叫Wi-Fi P2p，还叫Wi-Fi直连，这是它的名字。但是它和WI-Fi是什么关系呢，有一腿？我不知道。但是我们可以用我们熟悉的Wi-Fi来理解不熟悉的Wi-Fi Direct。想象这样的情景，当用Wi-F前我们必须要干什么啊，那当然是接热点啊。但是要是没有热点怎么办？没热点玩个毛啊。但是Wi-Fi Direct就可以玩，而且可以玩得很愉快。所以Wi-Fi Direct不用连接热点，也不需要。没网也能玩得high，就是这么任性。那它怎么玩啊？兄弟，知道蓝牙是怎么玩的么？不知道，唉，算了。我们还是看名字吧。p2p(peer to peer)，也就是点对点，就是我的手机是一个点，你的手机是一个点，duang~~~,一条网线（数据线）怼上了，唉，网络好了，可以玩耍了，就是怎么简单。但是为什么要用它呢？我跟它又不是太熟，跟蓝牙玩耍不好么？大声告诉你，不好。普通手机自带蓝牙传输距离是多远，不知道吧，10~13m左右，Wi-Fi Direct呢，长一倍，自己算。传输速率呢，你忍受得了蓝牙的速度么？反正我是受不了0.2M/s的速度，但是Wi-Fi Direct 7，8M/s的速度我就很喜欢了。所以，骚年，用Wi-Fi Direct吧，靠谱！

开发Wi-Fi Direct的Android应用

1、Android开发第一步——Manifest权限注册

　　涉及到Wi-Fi，当然理所应当的要用到INTERNET了。哦，不，等等。你之前不是说过，它不用网络么，怎么现在反悔了。是，我是说过它不用网络也可以玩，但是，你两台怼在一起的设备间访问，你总要有种访问方式吧，Wi-Fi Direct使用Socket，而Socket就需要INTERNET了。另外，它还需要用到CHANGE_WIFI_STATE。因为两台设备间怼上了只是一种理解，实际上，它是无线访问，而上面我没告诉你的是，Wi-Fi Direct兼容Wi-Fi。而且大部分的手机厂商都直接使用Wi-Fi模块实现的Wi-Fi Direct标准，所以它们通常是绑定在一起的。怼上了就说明连上了，连上了是不是就改变了你的Wi-Fi状态。最后，还需要ACCESS_WIFI_STATE，这个怎么理解呢，额，我不知道。自己想去，总之需要就对了。

2、创建并注册一个广播接收器

　　Android系统将Wi-Fi Direct技术封装了，当需要使用到该技术时，只需拦截相应的系统广播即可，系统会把Wi-Fi Direct的硬件状态通过广播告诉我们的，在广播中就可以获取到所需要的信息，如周围的设备列表，管理员的IP地址等信息，有了这些信息后就可以建立Socket连接，进行数据操作了。所以广播接收器可以说是这一大步骤的关键。创建广播接收器很简单，只需创建一个类继承自BroadcastReceiver，重写OnReceive()方法即可。可关键在于，在接收到广播消息后，应该怎样处理？这就得先看看会接收到些什么消息了。为此，我整理了个说明表格，如表一：

表格一 Wi-Fi Direct广播接收器侦听事件说明

WIFI_P2P_STATE_CHANGED_ACTION	指示Wi-Fi P2P是否开启或设备是否支持Wi-Fi Direct
WIFI_P2P_PEERS_CHANGED_ACTION	代表对等节点（peer）列表发生了变化
WIFI_P2P_CONNECTION_CHANGED_ACTION	表明Wi-Fi P2P的连接状态发生了改变
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION	指示设备的详细配置发生了变化

现在已经明确了，广播中会接收到的消息，所以，接下来的任务就是怎样处理这些消息。不过在开始之前，需要对一个关键类进行说明——WifiP2pManager。

　　这个类负责管理Wi-Fi对等设备。它让应用可以发现可用的对等设备，设置对等设备的连接以及查询对等设备的列表。需要注意的是，WifiP2pManager对应用请求都是采用的异步处理，所以需要使用到比较多的回调.它的大致工作过程是，首先通过Context的getSystemService方法获取WifiP2pManager对象，紧接着需要用WifiP2pManager对象的initialize方法对它进行初始化，初始化完成会返回另一个关键参数— WifiP2pManager.Channel，之后的发现，连接操作都需要它的参与才能完成。初始化完成后，就可以调用discoverPeers方法进行设备搜寻了。当搜寻到设备后会以广播的形式通知应用，应用获取到通知后，需要调用WifiP2pManager对象的requestPeers方法获取可用的设备列表。当获取到可用列表后，会以回调的方式通知监听在WifiP2pManager对象上的onPeersAvailable方法，这里就可以获取到相应的设备列表信息，用户就可以选择其中一台设备，继续调用WifiP2pManager对象的connect方法连接设备了，连接成功后，依旧会通知监听在WifiP2pManager对象上的回调，调用onConnectionInfoAvailable方法，这里就可以获取到管理员的IP信息，管理员是谁等信息，之后就是Socket的事了。

　　明确了WifiP2pManager的角色，接下来就可以处理广播消息了。首先，WIFI_P2P_STATE_CHANGED_ACTION这个动作很好处理，因为它携调用带的消息比较单一，就是给出当前设备是否支持Wi-Fi Direct标准，或者Wi-Fi Direct功能是否开启。所以当接收到这个消息后，可以针对相应的消息，通知Activity显示相应的对话框，通知用户即可，因为这些信息不是软件能够处理的。其次，当收到WIFI_P2P_PEERS_CHANGED_ACTION消息时，说明系统已经扫描到相应的设备了，需要把获取这些信息，通知Activity进行相应处理即可。获取的操作就是上面提到过的WifiP2pManager，调用WifiP2pManager.requestPeers方法来请求列表。接着处理WIFI_P2P_CONNECTION_CHANGED_ACTION，这个消息说明了Activity已经调用了connect方法了，所以这个消息封装的都是连接状态的一些信息，所以这里需要做的就是判断连接是否是可用的，如果可用，就将可用信息获取出来，传递给Activity处理。最后来处理WIFI_P2P_THIS_DEVICE_CHANGED_ACTION消息，这个消息其实通常情况下是可以不用处理的，如果想处理也只需在Activity中更新本机设备信息就行了。至此，广播接收器中的处理都已经结束了，有了它，Activity中的处理就很容易了。

　　Activity的操作流程也很清晰，其实就是将前面提到的WifiP2pManager的流程拆分出来了，Activity的作用就是注册广播，接收广播传过来的消息并处理，在必要时解注册广播即可。注册广播需要创建IntentFilter对象，并添加表一中的所有动作，调用Context.registerReceiver。然后就是WifiP2pManager的上场时间了，具体的流程前面已经描述了，所以这里只是着重描述一下三个关键点。首先是discoverPeers，启动设备发现，系统会自动处理相关的操作，扫描结束后会以广播的形式通知应用，这一步很关键，没有这一步，后面的步骤都不会进行。之后需要Activity实现相应的监听器回调——WifiP2pManager.PeerListListener，当周围设备信息可用时，并且执行了requestPeers后，会回调onPeersAvailable方法，该方法会传进来WifiP2pDeviceList对象，调用WifiP2pDeviceList.getDeviceList()就可以获取到扫描到的设备列表，接下来就可以选取其中一个设备进行connect()操作了。这一步还是需要设置监听器 WifiP2pManager.ConnectionInfoListener，当连接状态可用时会触发 onConnectionInfoAvailable()方法，在这里通过参数WifiP2pInfo就可以拿到IP地址，谁是组管理员等信息，之后就可以用这些信息建立Socket连接，从而进行数据操作了。假如是管理员就应该创建一个服务线程等待组成员连接进来，假如是普通的用户则创建Socket连接到管理员的设备，连接建立成功后，可以用IO操作数据了。

3、数据传送

　　其实上面已经说过了，当 onConnectionInfoAvailable()方法调用时，这时候两台设备已经怼上了。但是怼上了，总有台设备是服务器吧，不然怎么玩。服务器的地址可以用传进来的参数WifiP2pInfo对象的groupOwnerAddress查到，自己是不是服务器也可以通过WifiP2pInfo.isGroupOwner确定。至此，就是玩Socket的事了。别告诉我你不会，假如真是不会的话，建议你先看看怎么玩Socket。因为这个高级玩法目前你还驾驭不了。ok，国际惯例，到了上源码的时间了。

4、秀代码

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.NetworkInfo;
import android.net.wifi.p2p.WifiP2pManager;

/**
 * Created by Andy on 2016/5/10.
 */

public class WifiDirectReceiver extends BroadcastReceiver {
    private HandlerActivity handlerActivity;
    private WifiP2pManager manager;

    public WifiDirectReceiver(){}

    public WifiDirectReceiver(HandlerActivity handlerActivity,WifiP2pManager manager) {
        this.handlerActivity=handlerActivity;
        this.manager=manager;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        String action=intent.getAction();
        if(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)){
            /*判断wifi p2p是否可用*/
            int state=intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE,-1);
            if(state==WifiP2pManager.WIFI_P2P_STATE_ENABLED){
                handlerActivity.setIsWifiP2pEnabled(true);
            }else {
                handlerActivity.setIsWifiP2pEnabled(false);
            }
        }else if(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)){
            /*可用设备列表发生变化，*/
            manager.requestPeers(handlerActivity.getChannel(),handlerActivity);
        }else if(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)){
            /*连接状态发生变化*/
            NetworkInfo info=intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
            if(info.isConnected()){
                manager.requestConnectionInfo(handlerActivity.getChannel(),handlerActivity);
            }else{
                handlerActivity.onConnectDisabled();
            }
        }else if(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)){
            /*当前设备发生变化*/
        }
    }
}

import android.app.AlertDialog;

import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pInfo;
import android.net.wifi.p2p.WifiP2pManager;
import android.os.Bundle;
import android.widget.Toast;

import com.mob.lee.fastair.BaseActivity;
import com.mob.lee.fastair.R;
import com.mob.lee.fastair.home.HomeFragment;
import com.mob.lee.fastair.utils.ActivityControllerUtil;
import com.mob.lee.fastair.utils.WifiP2pUtils;

import java.net.InetAddress;

import butterknife.ButterKnife;

/**
 * Created by Andy on 2016/5/10.
 */
public class HandlerActivity extends BaseActivity
        implements WifiP2pManager.PeerListListener,
        WifiP2pManager.ConnectionInfoListener{

    private WifiP2pManager mManager;
    private WifiP2pManager.Channel mChannel;
    private IntentFilter mFilter;
    private WifiDirectReceiver mWifiDirectReceiver;

    private boolean connected;

    private Fragment currentFragment;

    @Override
    protected void initView() {
        setContentView(R.layout.activity);
        ButterKnife.inject(this);
    }

    @Override
    protected void setting(Bundle savedInstanceState) {
        setCurrentFragment(new DiscoverFragment());

        mFilter = new IntentFilter();
        /*指示wifi p2p的状态变化*/
        mFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        /*指示可用节点列表的变化*/
        mFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        /*指示连接状态的变化*/
        mFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        /*指示当前设备发生变化*/
        mFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);

        /*初始化wifi p2p的控制器*/
        mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        mChannel = mManager.initialize(this, getMainLooper(), null);
　　　　 /*开启设备发现*/
        mManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
            }
　　
            @Override
            public void onFailure(int reason) {
                new AlertDialog.Builder(HandlerActivity.this)
                        .setTitle(R.string.tips_error)
                        .setMessage(WifiP2pUtils.getWifiP2pFailureReson(reason))
                        .setPositiveButton(R.string.tips_ok, new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                finish();
                            }
                        }).show();
            }
        });

　　　　 /*注册广播*/
        mWifiDirectReceiver = new WifiDirectReceiver(this, mManager);
        registerReceiver(mWifiDirectReceiver, mFilter);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
　　　　　 /*动态注册的广播必须解注册*/
        unregisterReceiver(mWifiDirectReceiver);
        if(connected) {
　　　　　　　/*现在我不用了，但是还连着，我不高兴，移除吧，下次再连*/
            mManager.removeGroup(mChannel, new WifiP2pManager.ActionListener() {
                @Override
                public void onSuccess() {

                }

                @Override
                public void onFailure(int reason) {
                    Toast.makeText(HandlerActivity.this, getResources().getString(R.string.toast_removeFalid) + WifiP2pUtils.getWifiP2pFailureReson(reason), Toast.LENGTH_SHORT).show();
                }
            });
        }
    }


    public void setIsWifiP2pEnabled(boolean enabled) {
　　　　 /*设备是否支持Wi-Fi Direct或者打开开关，通知一下*/
        if (!enabled) {
            new AlertDialog.Builder(this)
                    .setTitle(R.string.tips_error)
                    .setMessage(R.string.tips_disabled_wifi_p2p)
                    .setPositiveButton(R.string.tips_ok, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            finish();
                        }
                    }).show();
        }
    }

    public WifiP2pManager.Channel getChannel() {
        return mChannel;
    }

　　 /*发现周围设备了*/
    @Override
    public void onPeersAvailable(WifiP2pDeviceList peers) {
        if(currentFragment instanceof DiscoverFragment) {
            ((DiscoverFragment)currentFragment).findDeviceList(peers.getDeviceList());
        }
    }

　　 /*连接设备*/
    public void connectDevice(WifiP2pConfig config){
        mManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Toast.makeText(HandlerActivity.this, R.string.toast_connectSuccess, Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onFailure(int reason) {
                new AlertDialog.Builder(HandlerActivity.this)
                        .setTitle(R.string.tips_error)
                        .setMessage(WifiP2pUtils.getWifiP2pFailureReson(reason))
                        .setPositiveButton(R.string.tips_ok, new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                            }
                        }).show();
            }
        });
    }

　　 /*连接完成，获取管理员的IP,跳转界面*/
    @Override
    public void onConnectionInfoAvailable(WifiP2pInfo info) {
        InetAddress address = null;
        boolean isGroupOwner = false;
        if (info.groupFormed && info.isGroupOwner) {
            address = info.groupOwnerAddress;
            isGroupOwner = true;
        } else if (info.groupFormed) {
            address = info.groupOwnerAddress;
            isGroupOwner = false;
        }
        if (null != address) {
            Intent preIntent = getIntent();
            preIntent.putExtra("address", address.getHostAddress());
            preIntent.putExtra("isGroupOwner", isGroupOwner);
            Fragment fragment=null;
            setCurrentFragment(fragment);
            connected=true;
        }
    }

    public void onConnectDisabled(){
        connected=false;
    }

　　public void setCurrentFragment(Fragment fragment){
        currentFragment=fragment;
        FragmentManager manager=getFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.replace(R.id.activity_content, fragment);
        transaction.commit();
    }

}

import android.app.AlertDialog;
import android.content.DialogInterface;
import android.net.wifi.WpsInfo;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.RadioGroup;
import android.widget.TextView;

import com.mob.lee.fastair.BaseActivity;
import com.mob.lee.fastair.BaseFragment;
import com.mob.lee.fastair.R;
import com.mob.lee.scanview.ScanLayout;

import java.util.ArrayList;
import java.util.Collection;

import butterknife.ButterKnife;
import butterknife.InjectView;

/**
 * Created by Andy on 2016/5/10.
 */
public class DiscoverFragment extends BaseFragment{
    @InjectView(R.id.fragment_discover_scanlayout)
    ScanLayout mScanLayout;

    private WifiP2pDevice device;
    private ArrayList<WifiP2pDevice> mDevices;
    private boolean isBeginConnection;

    @Override
    protected View initView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view=inflater.inflate(R.layout.fragment_discover,container,false);
        ButterKnife.inject(this, view);
        return view;
    }

    @Override
    protected void setListener(View view, Bundle saveInstanceState) {
        /*连接某台设备*/
        mScanLayout.setOnItemClickListener(new ScanLayout.OnItemClickListener() {
            @Override
            public void onItemClick(View view, int position) {
                device = mDevices.get(position);
                WifiP2pConfig config = new WifiP2pConfig();
                config.deviceAddress = device.deviceAddress;
                config.wps.setup = WpsInfo.PBC;
                ((HandlerActivity) getActivity()).connectDevice(config);
                isBeginConnection=true;
            }
        });
    }

    @Override
    protected void setting(Bundle saveInstanceState) {
        ((BaseActivity)getActivity()).setToolbar(R.id.fragment_discover_toolbar, R.string.base_findDevice);
    }

    @Override
    public void onResume() {
        super.onResume();
        mScanLayout.startScan();
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        ButterKnife.reset(this);
    }

    /*发现了设备，显示设备列表*/
    public void findDeviceList(Collection<WifiP2pDevice> devices) {
        if ((null == mDevices)) {
            mDevices=new ArrayList<>();
        }
        mScanLayout.stopScan();
        if (0 == devices.size()) {
            new AlertDialog.Builder(getActivity())
                    .setTitle(R.string.tips_error)
                    .setMessage(R.string.tips_scan_failed)
                    .setPositiveButton(R.string.tips_ok, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            getActivity().finish();
                        }
                    }).show();
        } else if(isBeginConnection){
            return;
        }else{
            for(WifiP2pDevice device:devices){
                if(mDevices.contains(device)){
                    continue;
                }
                mDevices.add(device);
                View view = LayoutInflater.from(getActivity()).inflate(R.layout.item_scan, null);
                ((TextView) view.findViewById(R.id.item_scan_name)).setText(device.deviceName);
                mScanLayout.addView(view);
            }
        }
    }
}