Wifi P2P Android

Introduction

• L'API Level 14 introduit des fonctionnalités pour gérer des connexions Wifi entre appareils
• Il est possible de découvrir des appareils et d'établir des communications rapides
• Le principale avantage est l'absence de connexion à un réseau Wifi pour joindre des appareils
• Classe WifiP2pManager pour découvrir et se connecter à des apparei
• Des auditeurs d'événements permettent de traiter les opérations réalisées avec le manager
• Différentes intentions permettent d'identifier les événements

Broadcast Receiver

• Un broadcast receiver permet d'écouter des événements systèmes liées au Wifi
• Etendre la classe BroadcastReceiver et son constructeur
  • L'instance du manager WifiP2pManager à utiliser et l'instance WifiP2pManager.Channel récupérée à l'initialisation du manager
  • L'activité utilisant le broadcast receiver

public class WiFiDirectBroadcastReceiver extends BroadcastReceiver {
    private WifiP2pManager mManager;
    private Channel mChannel;
    private MyWiFiActivity mActivity;
    public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel,
            MyWifiActivity activity) {
        super();
        this.mManager = manager;    this.mChannel = channel;    this.mActivity = activity;
    }
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
            // Check to see if Wi-Fi is enabled and notify appropriate activity
            int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
            if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
                // Wifi P2P is enabled
            } else {
                // Wi-Fi P2P is not enabled
            }
        } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
            // Call WifiP2pManager.requestPeers() to get a list of current peers
        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
            // Respond to new connection or disconnections
        } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
            // Respond to this device's wifi state changing
        }
    }
}

Initialisation

• Indiquer la version 14 et les permissions nécessaires dans le manifeste

<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" />

• Initialiser le framework Wifi P2P

WifiP2pManager mManager;
Channel mChannel;
BroadcastReceiver mReceiver;
IntentFilter mIntentFilter;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // . . .
    mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
    mChannel = mManager.initialize(this, getMainLooper(), null);
    mReceiver = new WiFiDirectBroadcastReceiver(mManager, mChannel, this);
    mIntentFilter = new IntentFilter();
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
    // . . .
}

/* register the broadcast receiver with the intent values to be matched */
@Override
protected void onResume() {
    super.onResume();
    registerReceiver(mReceiver, mIntentFilter);
}

/* unregister the broadcast receiver */
@Override
protected void onPause() {
    super.onPause();
    unregisterReceiver(mReceiver);
}

Découvrir des appareils

• Utiliser la méthode discoverPeers() pour lancer la détection d'appareils
• Le second paramètre WifiP2pManager.ActionListener est utilisé pour notifier le succès ou l'échec
• Le broadcast receiver est notifié en cas de succès

mManager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
        // TODO
    }
    @Override
    public void onFailure(int reasonCode) {
        // TODO
    }
});

public class WiFiDirectBroadcastReceiver extends BroadcastReceiver {
    // . . .
    PeerListListener myPeerListListener;
    @Override
    public void onReceive(Context context, Intent intent) {
        // . . .
        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, myPeerListListener);
            }
        }
    }
}

Connexion avec un appareil

• Utiliser une instance WifiP2pConfig contenant les informations d'un appareil
• Utiliser l'instance WifiP2pDeviceList pour récupérer la config d'un appareil avec le PeerListListener

//obtain a peer from the WifiP2pDeviceList
WifiP2pDevice device;
WifiP2pConfig config = new WifiP2pConfig();
config.deviceAddress = device.deviceAddress;
mManager.connect(mChannel, config, new ActionListener() {

    @Override
    public void onSuccess() {
        //success logic
    }

    @Override
    public void onFailure(int reason) {
        //failure logic
    }
});