Utiliser le Wi-Fi Direct (P2P) pour la détection de services

La première leçon de cette classe, Utiliser la détection de services réseau, vous a montré comment identifier les services connectés à un réseau local. Toutefois, la détection de services via Wi-Fi Direct (P2P) vous permet de détecter directement les services des appareils à proximité, sans être connectés à un réseau. Vous pouvez également annoncer les services exécutés sur votre appareil. Ces fonctionnalités vous aident à communiquer entre les applications, même lorsqu'aucun réseau local ou point d'accès n'est disponible.

Bien que cet ensemble d'API ait un objectif semblable à celui des API de détection de services réseau décrites dans une leçon précédente, leur implémentation dans le code est très différente. Cette leçon vous explique comment découvrir les services disponibles depuis d'autres appareils à l'aide de Wi-Fi Direct. Dans cette leçon, nous partons du principe que vous connaissez déjà l'API Wi-Fi Direct.

Configurer le fichier manifeste

Pour utiliser le Wi-Fi P2P, ajoutez les autorisations CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION et INTERNET à votre fichier manifeste. Si votre application cible Android 13 (niveau d'API 33) ou une version ultérieure, ajoutez également l'autorisation NEARBY_WIFI_DEVICES à votre fichier manifeste. Même si Wi-Fi Direct ne nécessite pas de connexion Internet, il utilise des sockets Java standards et leur utilisation sous Android nécessite les autorisations demandées.

<manifest xmlns:android="http://schemas.android.com/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"/>
    <!-- If your app targets Android 13 (API level 33)
         or higher, you must declare the NEARBY_WIFI_DEVICES permission. -->
    <uses-permission
        android:name="android.permission.NEARBY_WIFI_DEVICES"
        <!-- If your app derives location information from Wi-Fi APIs,
             don't include the "usesPermissionFlags" attribute. -->
        android:usesPermissionFlags="neverForLocation" />
    <uses-permission
        android:required="true"
        android:name="android.permission.ACCESS_FINE_LOCATION"
        <!-- If any feature in your app relies on precise location information,
             don't include the "maxSdkVersion" attribute. -->
        android:maxSdkVersion="32" />
    ...

Outre les autorisations ci-dessus, les API suivantes nécessitent l'activation du mode de localisation:

Ajouter un service local

Si vous fournissez un service local, vous devez l'enregistrer pour la détection de services. Une fois votre service local enregistré, le framework répond automatiquement aux requêtes de détection de services des pairs.

Pour créer un service local:

  1. Créez un objet WifiP2pServiceInfo.
  2. Remplissez-le avec les informations concernant votre service.
  3. Appelez addLocalService() pour enregistrer le service local à des fins de détection de services.

Kotlin

    private fun startRegistration() {
        //  Create a string map containing information about your service.
        val record: Map<String, String> = mapOf(
                "listenport" to SERVER_PORT.toString(),
                "buddyname" to "John Doe${(Math.random() * 1000).toInt()}",
                "available" to "visible"
        )

        // Service information.  Pass it an instance name, service type
        // _protocol._transportlayer , and the map containing
        // information other devices will want once they connect to this one.
        val serviceInfo =
                WifiP2pDnsSdServiceInfo.newInstance("_test", "_presence._tcp", record)

        // Add the local service, sending the service info, network channel,
        // and listener that will be used to indicate success or failure of
        // the request.
        manager.addLocalService(channel, serviceInfo, object : WifiP2pManager.ActionListener {
            override fun onSuccess() {
                // Command successful! Code isn't necessarily needed here,
                // Unless you want to update the UI or add logging statements.
            }

            override fun onFailure(arg0: Int) {
                // Command failed.  Check for P2P_UNSUPPORTED, ERROR, or BUSY
            }
        })
    }

Java

    private void startRegistration() {
        //  Create a string map containing information about your service.
        Map record = new HashMap();
        record.put("listenport", String.valueOf(SERVER_PORT));
        record.put("buddyname", "John Doe" + (int) (Math.random() * 1000));
        record.put("available", "visible");

        // Service information.  Pass it an instance name, service type
        // _protocol._transportlayer , and the map containing
        // information other devices will want once they connect to this one.
        WifiP2pDnsSdServiceInfo serviceInfo =
                WifiP2pDnsSdServiceInfo.newInstance("_test", "_presence._tcp", record);

        // Add the local service, sending the service info, network channel,
        // and listener that will be used to indicate success or failure of
        // the request.
        manager.addLocalService(channel, serviceInfo, new ActionListener() {
            @Override
            public void onSuccess() {
                // Command successful! Code isn't necessarily needed here,
                // Unless you want to update the UI or add logging statements.
            }

            @Override
            public void onFailure(int arg0) {
                // Command failed.  Check for P2P_UNSUPPORTED, ERROR, or BUSY
            }
        });
    }

Découvrir les services à proximité

Android utilise des méthodes de rappel pour avertir votre application des services disponibles. La première chose à faire est donc de les configurer. Créez un WifiP2pManager.DnsSdTxtRecordListener pour écouter les enregistrements entrants. Cet enregistrement peut éventuellement être diffusé par d'autres appareils. Lorsqu'un utilisateur arrive, copiez l'adresse de l'appareil et toute autre information pertinente que vous souhaitez dans une structure de données externe à la méthode actuelle, afin de pouvoir y accéder ultérieurement. L'exemple suivant suppose que l'enregistrement contient un champ "buddyname", renseigné avec l'identité de l'utilisateur.

Kotlin

private val buddies = mutableMapOf<String, String>()
...
private fun discoverService() {
    /* Callback includes:
     * fullDomain: full domain name: e.g. "printer._ipp._tcp.local."
     * record: TXT record dta as a map of key/value pairs.
     * device: The device running the advertised service.
     */
    val txtListener = DnsSdTxtRecordListener { fullDomain, record, device ->
        Log.d(TAG, "DnsSdTxtRecord available -$record")
        record["buddyname"]?.also {
            buddies[device.deviceAddress] = it
        }
    }
}

Java

final HashMap<String, String> buddies = new HashMap<String, String>();
...
private void discoverService() {
    DnsSdTxtRecordListener txtListener = new DnsSdTxtRecordListener() {
        @Override
        /* Callback includes:
         * fullDomain: full domain name: e.g. "printer._ipp._tcp.local."
         * record: TXT record dta as a map of key/value pairs.
         * device: The device running the advertised service.
         */

        public void onDnsSdTxtRecordAvailable(
                String fullDomain, Map record, WifiP2pDevice device) {
                Log.d(TAG, "DnsSdTxtRecord available -" + record.toString());
                buddies.put(device.deviceAddress, record.get("buddyname"));
            }
        };
}

Pour obtenir les informations sur le service, créez un WifiP2pManager.DnsSdServiceResponseListener. Celle-ci recevra la description réelle et les informations de connexion. L'extrait de code précédent a implémenté un objet Map pour associer une adresse d'appareil au nom du collègue. L'écouteur de réponse du service l'utilise pour associer l'enregistrement DNS aux informations de service correspondantes. Une fois les deux écouteurs implémentés, ajoutez-les à WifiP2pManager à l'aide de la méthode setDnsSdResponseListeners().

Kotlin

private fun discoverService() {
    ...

    val servListener = DnsSdServiceResponseListener { instanceName, registrationType, resourceType ->
        // Update the device name with the human-friendly version from
        // the DnsTxtRecord, assuming one arrived.
        resourceType.deviceName = buddies[resourceType.deviceAddress] ?: resourceType.deviceName

        // Add to the custom adapter defined specifically for showing
        // wifi devices.
        val fragment = fragmentManager
                .findFragmentById(R.id.frag_peerlist) as WiFiDirectServicesList
        (fragment.listAdapter as WiFiDevicesAdapter).apply {
            add(resourceType)
            notifyDataSetChanged()
        }

        Log.d(TAG, "onBonjourServiceAvailable $instanceName")
    }

    manager.setDnsSdResponseListeners(channel, servListener, txtListener)
    ...
}

Java

private void discoverService() {
...

    DnsSdServiceResponseListener servListener = new DnsSdServiceResponseListener() {
        @Override
        public void onDnsSdServiceAvailable(String instanceName, String registrationType,
                WifiP2pDevice resourceType) {

                // Update the device name with the human-friendly version from
                // the DnsTxtRecord, assuming one arrived.
                resourceType.deviceName = buddies
                        .containsKey(resourceType.deviceAddress) ? buddies
                        .get(resourceType.deviceAddress) : resourceType.deviceName;

                // Add to the custom adapter defined specifically for showing
                // wifi devices.
                WiFiDirectServicesList fragment = (WiFiDirectServicesList) getFragmentManager()
                        .findFragmentById(R.id.frag_peerlist);
                WiFiDevicesAdapter adapter = ((WiFiDevicesAdapter) fragment
                        .getListAdapter());

                adapter.add(resourceType);
                adapter.notifyDataSetChanged();
                Log.d(TAG, "onBonjourServiceAvailable " + instanceName);
        }
    };

    manager.setDnsSdResponseListeners(channel, servListener, txtListener);
    ...
}

À présent, créez une requête de service et appelez addServiceRequest(). Cette méthode utilise également un écouteur pour signaler la réussite ou l'échec.

Kotlin

        serviceRequest = WifiP2pDnsSdServiceRequest.newInstance()
        manager.addServiceRequest(
                channel,
                serviceRequest,
                object : WifiP2pManager.ActionListener {
                    override fun onSuccess() {
                        // Success!
                    }

                    override fun onFailure(code: Int) {
                        // Command failed.  Check for P2P_UNSUPPORTED, ERROR, or BUSY
                    }
                }
        )

Java

        serviceRequest = WifiP2pDnsSdServiceRequest.newInstance();
        manager.addServiceRequest(channel,
                serviceRequest,
                new ActionListener() {
                    @Override
                    public void onSuccess() {
                        // Success!
                    }

                    @Override
                    public void onFailure(int code) {
                        // Command failed.  Check for P2P_UNSUPPORTED, ERROR, or BUSY
                    }
                });

Enfin, appelez discoverServices().

Kotlin

        manager.discoverServices(
                channel,
                object : WifiP2pManager.ActionListener {
                    override fun onSuccess() {
                        // Success!
                    }

                    override fun onFailure(code: Int) {
                        // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY
                        when (code) {
                            WifiP2pManager.P2P_UNSUPPORTED -> {
                                Log.d(TAG, "Wi-Fi Direct isn't supported on this device.")
                            }
                        }
                    }
                }
        )

Java

        manager.discoverServices(channel, new ActionListener() {

            @Override
            public void onSuccess() {
                // Success!
            }

            @Override
            public void onFailure(int code) {
                // Command failed.  Check for P2P_UNSUPPORTED, ERROR, or BUSY
                if (code == WifiP2pManager.P2P_UNSUPPORTED) {
                    Log.d(TAG, "Wi-Fi Direct isn't supported on this device.");
                else if(...)
                    ...
            }
        });

Si tout se passe bien, Hourra, vous avez terminé ! Si vous rencontrez des problèmes, n'oubliez pas que les appels asynchrones que vous avez effectués utilisent WifiP2pManager.ActionListener comme argument, ce qui vous fournit des rappels indiquant la réussite ou l'échec. Pour diagnostiquer les problèmes, placez le code de débogage dans onFailure(). Le code d'erreur fourni par la méthode indique le problème. Voici les valeurs d'erreur possibles et leur signification

P2P_UNSUPPORTED
Wi-Fi Direct n'est pas compatible avec l'appareil sur lequel l'application est exécutée.
BUSY
Le système est trop occupé pour traiter la requête.
ERROR
L'opération a échoué en raison d'une erreur interne.