Cómo usar Wi-Fi directo (P2P) para el descubrimiento de servicios

En la primera lección de esta clase, Cómo usar el descubrimiento de servicios de red, se mostró cómo descubrir los servicios que están conectados a una red local. Sin embargo, el descubrimiento de servicios de Wi-Fi directo (P2P) te permite descubrir los servicios de dispositivos cercanos de forma directa, sin estar conectado a una red. También puedes anunciar los servicios que se ejecutan en tu dispositivo. Estas funciones te ayudan a comunicarte entre apps, incluso cuando no hay una red local o un hotspot disponibles.

Si bien este conjunto de APIs tiene un propósito similar al de las APIs de descubrimiento de servicios de red que se describieron en una lección anterior, su implementación en el código es muy diferente. En esta lección, se muestra cómo detectar servicios disponibles desde otros dispositivos mediante Wi-Fi directo. En la lección, se supone que ya estás familiarizado con la API de Wi-Fi directo.

Cómo configurar el manifiesto

Para usar Wi-Fi P2P, agrega los permisos CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION y INTERNET a tu manifiesto. Si tu app se orienta a Android 13 (nivel de API 33) o versiones posteriores, agrega también el permiso NEARBY_WIFI_DEVICES a tu manifiesto. Si bien Wi-Fi directo no requiere una conexión a Internet, utiliza sockets estándar de Java, que en Android requieren los permisos solicitados.

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

Además de los permisos mencionados, las siguientes API también requieren que se habilite el Modo de ubicación:

• discoverPeers
• discoverServices
• requestPeers

Cómo agregar un servicio local

Si proporcionas un servicio local, debes registrarlo para el descubrimiento del servicio. Una vez que se registra el servicio local, el framework responde de forma automática a las solicitudes de descubrimiento de servicios de los pares.

Para crear un servicio local, sigue estos pasos:

1. Crea un objeto WifiP2pServiceInfo.
2. Llénalo con información sobre tu servicio.
3. Llama a addLocalService() a fin de registrar el servicio local para el descubrimiento de servicios.

    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
            }
        })
    }

    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
            }
        });
    }

Cómo descubrir servicios cercanos

Android usa métodos de devolución de llamada para notificar a tu aplicación sobre los servicios disponibles, por lo que lo primero que debes hacer es configurarlos. Crea un WifiP2pManager.DnsSdTxtRecordListener para escuchar los registros entrantes. De manera opcional, otros dispositivos pueden transmitir este registro. Cuando entre una, copia la dirección del dispositivo y cualquier otra información relevante que desees en una estructura de datos externa al método actual, para poder acceder a ella más tarde. En el siguiente ejemplo, se supone que el registro contiene un campo "buddyname", que contiene la identidad del usuario.

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
        }
    }
}

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"));
            }
        };
}

Para obtener la información del servicio, crea un WifiP2pManager.DnsSdServiceResponseListener. Así, se recibe la descripción real y la información de conexión. En el fragmento de código anterior, se implementó un objeto Map para vincular la dirección de un dispositivo con el nombre del contacto. El objeto de escucha de respuesta del servicio usa esto para vincular el registro DNS con la información del servicio correspondiente. Una vez que se implementen ambos objetos de escucha, agrégalos a WifiP2pManager con el método setDnsSdResponseListeners().

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)
    ...
}

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);
    ...
}

Ahora crea una solicitud de servicio y llama a addServiceRequest(). Este método también requiere que un objeto de escucha informe si la solicitud se realizó correctamente o no.

        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
                    }
                }
        )

        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
                    }
                });

Por último, realiza la llamada a discoverServices().

        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.")
                            }
                        }
                    }
                }
        )

        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 todo sale bien, ¡listo! Si tienes problemas, recuerda que las llamadas asíncronas que realizaste toman un WifiP2pManager.ActionListener como argumento, y esto te proporciona devoluciones de llamada que indican el éxito o el fracaso. Para diagnosticar problemas, coloca el código de depuración en onFailure(). El código de error que proporciona el método sugiere el problema. Estos son los posibles valores de error y su significado

P2P_UNSUPPORTED

: Wi-Fi directo no es compatible con el dispositivo donde se ejecuta la app.

BUSY

El sistema está demasiado ocupado para procesar la solicitud.

ERROR

La operación falló debido a un error interno.