导语
移动互联网时代，很多用户趋向于将大量的资料保存在移动设备上。但在给用户带来便利的同时引发了一个新的问题——保存在移动设备上的资料该怎样共享出去？到了思考时间，普通青年这样想：折腾什么劲啊，直接用数据线不就行了；而文艺青年可能这样想：咱们建个群吧，大家有好的东西都可以共享；二逼青年不高兴了，都特么互联网时代了，来点新意，好么？直接上网盘啊，大家互相研究研究，你懂的，嘿嘿。然而我是这样想的：都特么别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 P2P是否开启或设备是否支持Wi-Fi Direct |
|
|
WIFI_P2P_PEERS_CHANGED_ACTION |
|
|
|
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);
}
}
}
}