Usar o Wi-Fi Direct (P2P) para descoberta de serviços

A primeira lição nesta aula, Como usar a descoberta de serviços de rede, mostrou como descobrir serviços que estão conectados a uma rede local. No entanto, a descoberta de serviços via Wi-Fi ponto a ponto (P2P) permite que você descubra os serviços de dispositivos próximos diretamente, sem precisar se conectar a uma rede. Você também pode anunciar os serviços em execução no seu dispositivo. Esses recursos ajudarão você na comunicação entre apps, mesmo quando nenhuma rede local ou ponto de acesso estiver disponível.

Embora esse conjunto de APIs tenha uma finalidade semelhante à das APIs de descobertas de serviço de rede descritas em uma lição anterior, a implementação delas no código é muito diferente. Esta lição mostra como descobrir serviços disponíveis em outros dispositivos usando o Wi-Fi P2P. A lição pressupõe que você já esteja familiarizado com a API Wi-Fi P2P.

Configurar o manifesto

Para usar o Wi-Fi P2P, adicione as permissões CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION e INTERNET ao seu manifesto. Embora o Wi-Fi P2P não precise de uma conexão de Internet, ele usa soquetes Java padrão. Para usá-los no Android, as permissões solicitadas são necessárias.

    <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.ACCESS_FINE_LOCATION"/>
        <uses-permission
            android:required="true"
            android:name="android.permission.INTERNET"/>
        ...
    

Além das permissões anteriores, as seguintes APIs também exigem que o Modo de localização esteja ativado:

Adicionar um serviço local

Se você estiver fornecendo um serviço local, será necessário registrá-lo na descoberta de serviços. Depois que o serviço local for registrado, o framework responderá automaticamente às solicitações de descoberta de serviços dos apps semelhantes.

Para criar um serviço local:

  1. Crie um objeto WifiP2pServiceInfo.
  2. Preencha-o com informações sobre seu serviço.
  3. Chame addLocalService() para registrar o serviço local na descoberta de serviços.

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

Descobrir serviços nas proximidades

O Android usa métodos de callback para notificar seu aplicativo sobre os serviços disponíveis. Portanto, a primeira coisa a fazer é defini-los. Crie um WifiP2pManager.DnsSdTxtRecordListener para detectar registros de entrada. Esse registro pode ser transmitido de forma opcional por outros dispositivos. Quando algum surgir, copie o endereço do dispositivo e qualquer outra informação relevante que você quiser para uma estrutura de dados externa ao método atual para que você possa acessá-lo posteriormente. O exemplo a seguir considera que o registro contém um campo “buddyname”, preenchido com a identidade do usuário.

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

Para acessar as informações de serviço, crie um WifiP2pManager.DnsSdServiceResponseListener. Ele recebe a descrição real e as informações de conexão. O snippet de código anterior implementou um objeto Map para parear o endereço de um dispositivo com o nome do amigo. O listener de resposta do serviço usará isso para vincular o registro DNS às informações de serviço correspondentes. Uma vez que ambos listeners forem implementados, adicione-os ao WifiP2pManager usando o método 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);
        ...
    }
    

Agora, crie uma solicitação de serviço e chame addServiceRequest(). Esse método também usa um listener para informar o sucesso ou a falha.

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

Por fim, faça a chamada para 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, "P2P 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, "P2P isn't supported on this device.");
                    else if(...)
                        ...
                }
            });
    

Se tudo correr bem, você já terminou. Se houver problemas, lembre-se de que as chamadas assíncronas que você fez precisam de um WifiP2pManager.ActionListener como argumento, e isso fornece callbacks indicando sucesso ou falha. Para diagnosticar problemas, coloque a depuração do código em onFailure(). O código de erro fornecido pelo método indica o problema. Veja os possíveis valores de erro e o que eles significam

P2P_UNSUPPORTED
O Wi-Fi P2P não é compatível com o dispositivo que executa o app.
BUSY
O sistema está ocupado demais para processar a solicitação.
ERROR
A operação falhou devido a um erro interno.