Android实践 -- Android Wi-Fi 直连_wifi直连安卓程序开发

Android Wi-Fi 直连

Wi-Fi直连是Android 4.0(API level 14)或更高的版本的才加入的新功能，使用Wi-Fi直连相关的
API可以发现并连接支持Wi-Fi直连的设备，连接之后设备之间可以通信，传输的距离比蓝牙的传输距离
要远很多

API 概述

• Wi-Fi直连的方法
  类WifiP2pManager提供了一些方法来使用Wi-Fi直连的相关的接口来发现连接设备

* Wi-Fi直连的监听
类WifiP2pManager中也提供了很多的监听接口，计时的通知当前的 activity相关的搜索和连接的
结果

* Wi-Fi直连的Intent

创建Wi-Fi直连的应用

• 初始化设置

  首先要保证设置支持Wi-Fi直连相关的协议，如果支持，我们就可以获得WifiP2pManager的实例，创建并注册相关的广播，使用相关的
  api
  在AndroidManifest中必须声明相关的权限,Wi-Fi直连是在api level 14及更高的版本才能使用，还要声明android:minSdkVersion="14"

  <uses-sdk android:minSdkVersion="14" />
  <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" />
  1
  2
  3
  4
  5
  6

• 初始化WifiP2pManager的实例，并注册相关的广播，监听Wi-Fi直连的状态

  private WifiP2pManager mManager;
  private Channel mChannel;
  private IntentFilter directFilter;
  private WiFiDirectReceiver directReceiver ;
  
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
  
    mManager = (WifiP2pManager)this.getSystemService(Context.WIFI_P2P_SERVICE);
    mChannel = mManager.initialize(this, this.getMainLooper(), null);
    directReceiver = new WiFiDirectReceiver(mManager, mChannel, this);
  
    directFilter = new IntentFilter();
    directFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
    directFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
    directFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
    directFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
  
  }
  
  //注册广播监听
  @Override
  protected void onResume() {
    super.onResume();
    this.registerReceiver(directReceiver, directFilter);
  }
  
  //取消注册
  @Override
  protected void onPause() {
    super.onPause();
    this.unregisterReceiver(directReceiver);
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35

  广播接受

  public class WiFiDirectReceiver extends BroadcastReceiver{
  
    private WifiP2pManager mManager;
    private Channel mChannel;
    private MainActivity mActivity;
    private PeerListListener mListener;
    private WifiP2pConfig mConfig = new WifiP2pConfig();
  
    public WiFiDirectReceiver(){}
  
    public WiFiDirectReceiver(WifiP2pManager manager,Channel channel,MainActivity activity){
        this.mManager = manager;
        this.mChannel = channel;
        this.mActivity = activity;
  
    }
  
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Log.e("tag", "===============wifi direct action: "+action);
        if(action.equals(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)){
            int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
            if(state == WifiP2pManager.WIFI_P2P_STATE_ENABLED){
                //打开
            }else if(state == WifiP2pManager.WIFI_P2P_STATE_DISABLED){
                //关闭
            }
        }else if(action.equals(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)){
  
        }else if(action.equals(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)){
  
        }else if(action.equals(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)){
  
        }
    }
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38

• 发现设备

  在调用之后initialize()方法之后，会触发WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION的广播，在BroadcastReceiver
  中，如果WifiP2pManager.WIFI_P2P_STATE_ENABLED的状态已经打开，在BroadcastReceiver调用discoverPeers方法,如果发现设备
  会回调onSuccess方法

  mManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
  @Override
                      public void onSuccess() {
                          Log.e("wuth", "===================discovery success");
                      }
  
                      @Override
                      public void onFailure(int reason) {
                          Log.e("wuth", "===================discovery failed");
                      }
  });
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  如果发现设备，系统会触发WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION这个广播，在这个广播中可以调用requestPeers方法可以列出所有的
  设备

  if(null != mManager){
              mManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {
  
                  @Override
                  public void onPeersAvailable(WifiP2pDeviceList peers) {
                      Log.e("tag", "==================peers list size: "+peers.getDeviceList().size());
                      for(WifiP2pDevice device: peers.getDeviceList()){
                          Log.e("tag", "==================device addr: "+device.deviceName+" name: "+device.deviceName);
  
                      }
                  }
              });
          }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 连接设备

  对于已经发现的设备我们可以调用connect()方法连接，需要初始化WifiP2pConfig,并设置config的deviceAddress

  private WifiP2pConfig mConfig = new WifiP2pConfig();  
  mConfig.deviceAddress = device.deviceAddress;
                          mManager.connect(mChannel, mConfig, new WifiP2pManager.ActionListener() {
                              @Override
                              public void onSuccess() {
                                  Log.e("wuth", "==============connnect success");
                              }
  
                              @Override
                              public void onFailure(int reason) {
                                  Log.e("wuth", "=================connect failed");
                              }
                          });
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

  连接成功会回调onSuccess方法

  传输数据待续。。。