使用 WiFi 建立 P2P 连接
编写: - 原文:
Wi-Fi 点对点（P2P）API 允许应用程序在无需连接到网络和热点的情况下连接到附近的设备。（Android Wi-Fi P2P 使用
验证程序进行编译）。Wi-Fi P2P 技术使得应用程序可以快速发现附近的设备并与之交互。相比于蓝牙技术，Wi-Fi P2P 的优势是具有较大的连接范围。
本节主要内容是使用 Wi-Fi P2P 技术发现并连接到附近的设备。
配置应用权限
使用 Wi-Fi P2P 技术，需要添加 ， 以及
三种权限到应用的 manifest 文件。Wi-Fi P2P 技术虽然不需要访问互联网，但是它会使用标准的 Java socket（需要
权限）。下面是使用 Wi-Fi P2P 技术需要申请的权限。
&manifest xmlns:android="/apk/res/android"
package="com.example.android.nsdchat"
&uses-permission
android:required="true"
android:name="android.permission.ACCESS_WIFI_STATE"/&
&uses-permission
android:required="true"
android:name="android.permission.CHANGE_WIFI_STATE"/&
&uses-permission
android:required="true"
android:name="android.permission.INTERNET"/&
设置广播接收器（BroadCast Receiver）和 P2P 管理器
使用 Wi-Fi P2P 的时候，需要侦听当某个事件出现时发出的broadcast intent。在应用中，实例化一个 ，并将其设置为侦听下列事件：
　　指示　Wi-Fi P2P　是否开启
　　代表对等节点（peer）列表发生了变化
　　表明Wi-Fi P2P的连接状态发生了改变
　　指示设备的详细配置发生了变化
private final IntentFilter intentFilter = new IntentFilter();
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Indicates a change in the Wi-Fi P2P status.
intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
// Indicates a change in the list of available peers.
intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
// Indicates the state of Wi-Fi P2P connectivity has changed.
intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
// Indicates this device's details have changed.
intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
在　　方法的最后，需要获得　　的实例，并调用它的　 方法。该方法将返回
我们的应用将在后面使用该对象连接 Wi-Fi P2P 框架。
Channel mC
public void onCreate(Bundle savedInstanceState) {
mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
mChannel = mManager.initialize(this, getMainLooper(), null);
接下来，创建一个新的
类侦听系统中 Wi-Fi P2P 状态的变化。在
方法中，加入对上述四种不同 P2P 状态变化的处理。
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
// Determine if Wifi P2P mode is enabled or not, alert
// the Activity.
int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
activity.setIsWifiP2pEnabled(true);
activity.setIsWifiP2pEnabled(false);
} else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
// The peer list has changed!
We should probably do something about
} else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
// Connection state changed!
We should probably do something about
} else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
DeviceListFragment fragment = (DeviceListFragment) activity.getFragmentManager()
.findFragmentById(R.id.frag_list);
fragment.updateThisDevice((WifiP2pDevice) intent.getParcelableExtra(
WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));
最后，在主 activity 开启时，加入注册 intent filter 和 broadcast receiver 的代码，并在 activity 暂停或关闭时，注销它们。上述做法最好放在 onResume() 和 onPause() 方法中。
/** register the BroadcastReceiver with the intent values to be matched */
public void onResume() {
super.onResume();
receiver = new WiFiDirectBroadcastReceiver(mManager, mChannel, this);
registerReceiver(receiver, intentFilter);
public void onPause() {
super.onPause();
unregisterReceiver(receiver);
初始化对等节点发现（Peer Discovery）
开始搜寻附近带有 Wi-Fi P2P 的设备。该方法需要以下参数：
上节中调用 WifiP2pManager 的 initialize() 函数获得的
接口的实现，包括了当系统成功和失败发现所调用的方法。
mManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
public void onSuccess() {
// Code for when the discovery initiation is successful goes here.
// No services have actually been discovered yet, so this method
// can often be left blank.
Code for peer discovery goes in the
// onReceive method, detailed below.
public void onFailure(int reasonCode) {
// Code for when the discovery initiation fails goes here.
// Alert the user that something went wrong.
需要注意的是，这仅仅表示对Peer发现（Peer Discovery）完成初始化。 方法开启了发现过程并且立即返回。系统会通过调用 WifiP2pManager.ActionListener 中的方法通知应用对等节点发现过程初始化是否正确。同时，对等节点发现过程本身仍然继续运行，直到一条连接或者一个 P2P 小组建立。
获取对等节点列表
在完成对等节点发现过程的初始化后，我们需要进一步获取附近的对等节点列表。第一步是实现
接口。该接口提供了 Wi-Fi P2P 框架发现的对等节点信息。下列代码实现了相应功能：
private List peers = new ArrayList();
private PeerListListener peerListListener = new PeerListListener() {
public void onPeersAvailable(WifiP2pDeviceList peerList) {
// Out with the old, in with the new.
peers.clear();
peers.addAll(peerList.getDeviceList());
// If an AdapterView is backed by this data, notify it
// of the change.
For instance, if you have a ListView of available
// peers, trigger an update.
((WiFiPeerListAdapter) getListAdapter()).notifyDataSetChanged();
if (peers.size() == 0) {
Log.d(WiFiDirectActivity.TAG, "No devices found");
接下来，完善 Broadcast Receiver 的 onReceiver() 方法。
方法获取对等节点列表。我们需要将 WifiP2pManager.PeerListListener 传递给 receiver。一种方法是在 broadcast receiver 的构造函数中，将对象作为参数传入。
public void onReceive(Context context, Intent intent) {
else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
// Request available peers from the wifi p2p manager. This is an
// asynchronous call and the calling activity is notified with a
// callback on PeerListListener.onPeersAvailable()
if (mManager != null) {
mManager.requestPeers(mChannel, peerListListener);
Log.d(WiFiDirectActivity.TAG, "P2P peers changed");
现在，一个带有
action 的 intent 将触发应用对 Peer 列表的更新。
连接一个对等节点
为了连接到一个对等节点，我们需要创建一个新的
对象，并将要连接的设备信息从表示我们想要连接设备的
拷贝到其中。然后调用
public void connect() {
// Picking the first device found on the network.
WifiP2pDevice device = peers.get(0);
WifiP2pConfig config = new WifiP2pConfig();
config.deviceAddress = device.deviceA
config.wps.setup = WpsInfo.PBC;
mManager.connect(mChannel, config, new ActionListener() {
public void onSuccess() {
// WiFiDirectBroadcastReceiver will notify us. Ignore for now.
public void onFailure(int reason) {
Toast.makeText(WiFiDirectActivity.this, "Connect failed. Retry.",
Toast.LENGTH_SHORT).show();
在本段代码中的
实现仅能通知我们初始化的成功或失败。想要监听连接状态的变化，需要实现
接口。接口中的
回调函数会在连接状态发生改变时通知应用程序。当有多个设备同时试图连接到一台设备时（例如多人游戏或者聊天群），这一台设备将被指定为“群主”（group owner）。
public void onConnectionInfoAvailable(final WifiP2pInfo info) {
// InetAddress from WifiP2pInfo struct.
InetAddress groupOwnerAddress = info.groupOwnerAddress.getHostAddress());
// After the group negotiation, we can determine the group owner.
if (info.groupFormed && info.isGroupOwner) {
// Do whatever tasks are specific to the group owner.
// One common case is creating a server thread and accepting
// incoming connections.
} else if (info.groupFormed) {
// The other device acts as the client. In this case,
// you'll want to create a client thread that connects to the group
此时，回头继续完善 broadcast receiver 的 onReceive() 方法，并修改对 [WIFI_P2P_CONNECTION_CHANGED_ACTION]() intent 的监听部分的代码。当接收到该 intent 时，调用
方法。此方法为异步，所以结果将会被我们提供的
} else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
if (mManager == null) {
NetworkInfo networkInfo = (NetworkInfo) intent
.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
if (networkInfo.isConnected()) {
// We are connected with the other device, request connection
// info to find group owner IP
mManager.requestConnectionInfo(mChannel, connectionListener);　　移动互联网时代，很多用户趋向于将大量的资料保存在移动设备上。但在给用户带来便利的同时引发了一个新的问题&&保存在移动设备上的资料该怎样共享出去？到了思考时间，普通青年这样想：折腾什么劲啊，直接用数据线不就行了；而文艺青年可能这样想：咱们建个群吧，大家有好的东西都可以共享；二逼青年不高兴了，都特么互联网时代了，来点新意，好么？直接上网盘啊，大家互相研究研究，你懂的，嘿嘿。然而我是这样想的：都特么别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，国际惯例，到了上源码的时间了。
1 import android.content.BroadcastR
2 import android.content.C
3 import android.content.I
4 import android.net.NetworkI
5 import android.net.wifi.p2p.WifiP2pM
* Created by Andy on .
11 public class WifiDirectReceiver extends BroadcastReceiver {
private HandlerActivity handlerA
private WifiP2pM
public WifiDirectReceiver(){}
public WifiDirectReceiver(HandlerActivity handlerActivity,WifiP2pManager manager) {
this.handlerActivity=handlerA
this.manager=
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);
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);
handlerActivity.onConnectDisabled();
}else if(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)){
/*当前设备发生变化*/
1 import android.app.AlertD
3 import android.app.F
4 import android.app.FragmentM
5 import android.app.FragmentT
6 import android.content.C
7 import android.content.DialogI
8 import android.content.I
9 import android.content.IntentF
10 import android.net.wifi.p2p.WifiP2pC
11 import android.net.wifi.p2p.WifiP2pDeviceL
12 import android.net.wifi.p2p.WifiP2pI
13 import android.net.wifi.p2p.WifiP2pM
14 import android.os.B
15 import android.widget.T
17 import com.mob.lee.fastair.BaseA
18 import com.mob.lee.fastair.R;
19 import com.mob.lee.fastair.home.HomeF
20 import com.mob.lee.fastair.utils.ActivityControllerU
21 import com.mob.lee.fastair.utils.WifiP2pU
23 import java.net.InetA
25 import butterknife.ButterK
* Created by Andy on .
30 public class HandlerActivity extends BaseActivity
implements WifiP2pManager.PeerListListener,
WifiP2pManager.ConnectionInfoListener{
private WifiP2pManager mM
private WifiP2pManager.Channel mC
private IntentFilter mF
private WifiDirectReceiver mWifiDirectR
private boolean
private Fragment currentF
protected void initView() {
setContentView(R.layout.activity);
ButterKnife.inject(this);
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);
66 　　　　 /*开启设备发现*/
mManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
public void onSuccess() {
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() {
public void onClick(DialogInterface dialog, int which) {
}).show();
86 　　　　 /*注册广播*/
mWifiDirectReceiver = new WifiDirectReceiver(this, mManager);
registerReceiver(mWifiDirectReceiver, mFilter);
protected void onDestroy() {
super.onDestroy();
94 　　　　　 /*动态注册的广播必须解注册*/
unregisterReceiver(mWifiDirectReceiver);
if(connected) {
97 　　　　　　　/*现在我不用了，但是还连着，我不高兴，移除吧，下次再连*/
mManager.removeGroup(mChannel, new WifiP2pManager.ActionListener() {
public void onSuccess() {
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) {
114 　　　　 /*设备是否支持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() {
public void onClick(DialogInterface dialog, int which) {
}).show();
public WifiP2pManager.Channel getChannel() {
132 　　 /*发现周围设备了*/
public void onPeersAvailable(WifiP2pDeviceList peers) {
if(currentFragment instanceof DiscoverFragment) {
((DiscoverFragment)currentFragment).findDeviceList(peers.getDeviceList());
140 　　 /*连接设备*/
public void connectDevice(WifiP2pConfig config){
mManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {
public void onSuccess() {
Toast.makeText(HandlerActivity.this, R.string.toast_connectSuccess, Toast.LENGTH_SHORT).show();
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() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}).show();
163 　　 /*连接完成，获取管理员的IP,跳转界面*/
public void onConnectionInfoAvailable(WifiP2pInfo info) {
InetAddress address = null;
boolean isGroupOwner = false;
if (info.groupFormed && info.isGroupOwner) {
address = info.groupOwnerA
isGroupOwner = true;
} else if (info.groupFormed) {
address = info.groupOwnerA
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;
189 　　public void setCurrentFragment(Fragment fragment){
currentFragment=
FragmentManager manager=getFragmentManager();
FragmentTransaction transaction = manager.beginTransaction();
transaction.replace(R.id.activity_content, fragment);
1 import android.app.AlertD
2 import android.content.DialogI
3 import android.net.wifi.WpsI
4 import android.net.wifi.p2p.WifiP2pC
5 import android.net.wifi.p2p.WifiP2pD
6 import android.os.B
7 import android.view.LayoutI
8 import android.view.V
9 import android.view.ViewG
10 import android.widget.ImageV
11 import android.widget.RadioG
12 import android.widget.TextV
14 import com.mob.lee.fastair.BaseA
15 import com.mob.lee.fastair.BaseF
16 import com.mob.lee.fastair.R;
17 import com.mob.lee.scanview.ScanL
19 import java.util.ArrayL
20 import java.util.C
22 import butterknife.ButterK
23 import butterknife.InjectV
* Created by Andy on .
28 public class DiscoverFragment extends BaseFragment{
@InjectView(R.id.fragment_discover_scanlayout)
ScanLayout mScanL
private WifiP2pD
private ArrayList&WifiP2pDevice& mD
private boolean isBeginC
protected View initView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view=inflater.inflate(R.layout.fragment_discover,container,false);
ButterKnife.inject(this, view);
protected void setListener(View view, Bundle saveInstanceState) {
/*连接某台设备*/
mScanLayout.setOnItemClickListener(new ScanLayout.OnItemClickListener() {
public void onItemClick(View view, int position) {
device = mDevices.get(position);
WifiP2pConfig config = new WifiP2pConfig();
config.deviceAddress = device.deviceA
config.wps.setup = WpsInfo.PBC;
((HandlerActivity) getActivity()).connectDevice(config);
isBeginConnection=true;
protected void setting(Bundle saveInstanceState) {
((BaseActivity)getActivity()).setToolbar(R.id.fragment_discover_toolbar, R.string.base_findDevice);
public void onResume() {
super.onResume();
mScanLayout.startScan();
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() {
public void onClick(DialogInterface dialog, int which) {
getActivity().finish();
}).show();
} else if(isBeginConnection){
for(WifiP2pDevice device:devices){
if(mDevices.contains(device)){
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);
阅读(...) 评论()