Utilizzare Wi-Fi Direct (P2P) per il rilevamento dei servizi

La prima lezione di questo corso, Using Network Service Discovery, ti ha mostrato come trovare servizi connessi a una rete locale. Tuttavia, utilizzando Wi-Fi Direct (P2P) Service Discovery ti consente di scoprire i servizi dei dispositivi nelle vicinanze senza essere connessi a una rete. Puoi anche pubblicizzare i servizi in esecuzione sul tuo dispositivo. Queste funzionalità ti aiutano a comunicare tra le app anche quando non è disponibile una rete locale o un hotspot.

Sebbene questo insieme di API abbia lo stesso scopo delle API Network Service Discovery descritte in una lezione precedente, la loro implementazione nel codice è molto diversa. Questa lezione mostra come trovare i servizi disponibili da altri dispositivi, usando Wi-Fi Direct. In questa lezione si presuppone che tu abbia già familiarità con API Wi-Fi Direct.

Configurare il manifest

Per usare il Wi-Fi P2P, aggiungi CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION, e INTERNET le autorizzazioni per il file manifest. Se la tua app ha come target Android 13 (livello API 33) o versioni successive, aggiungi anche l'autorizzazione NEARBY_WIFI_DEVICES al file manifest. Anche se Wi-Fi Direct non richiede una Connessione Internet, utilizza socket Java standard e li utilizza in Android richiede le autorizzazioni richieste.

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

Oltre alle autorizzazioni precedenti, anche le API seguenti richiedono l'abilitazione della modalità di geolocalizzazione:

Aggiungere un servizio locale

Se fornisci un servizio locale, devi registrarti per Service Discovery. Una volta registrato il servizio locale, il framework risponde automaticamente alle richieste di Service Discovery dei peer.

Per creare un servizio locale:

  1. Crea un oggetto WifiP2pServiceInfo.
  2. Inserisci le informazioni sul tuo servizio.
  3. Chiama il numero addLocalService() per registrare per il rilevamento dei servizi.

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

Scoprire i servizi nelle vicinanze

Android utilizza metodi di callback per informare la tua applicazione dei servizi disponibili, quindi la prima cosa da fare è configurarli. Crea un WifiP2pManager.DnsSdTxtRecordListener per ascoltare i record in arrivo. Questo record può essere trasmesso facoltativamente da altri dispositivi mobili. Quando ne arriva uno, copia l'indirizzo del dispositivo e le altre informazioni pertinenti che ti interessano in una struttura di dati esterna al metodo corrente, in modo da potervi accedere in un secondo momento. L'esempio seguente presuppone che il record contenga un campo "buddyname", compilato con l'identità dell'utente.

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

Per ottenere le informazioni sul servizio, crea un WifiP2pManager.DnsSdServiceResponseListener. Questo riceve la descrizione e le informazioni di connessione effettive. Il codice precedente Lo snippet ha implementato un oggetto Map per accoppiare l'indirizzo di un dispositivo all'amico nome. Il listener di risposte del servizio lo utilizza per collegare il record DNS con le informazioni sul servizio corrispondenti. Una volta implementati entrambi gli ascoltatori, aggiungili a WifiP2pManager utilizzando il metodo 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);
    ...
}

Ora crea una richiesta di servizio e chiama addServiceRequest(). Questo metodo richiede anche un listener per segnalare l'esito positivo o negativo.

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

Infine, effettua la chiamata a 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(...)
                    ...
            }
        });

Se tutto va bene, hai finito. Se riscontri problemi, ricorda che le chiamate asincrone che hai eseguito accettano un WifiP2pManager.ActionListener come argomento e ti forniscono callback che indicano l'esito positivo o negativo. Per diagnosticare i problemi, inserisci il codice di debug in onFailure(). Il codice di errore forniti dai suggerimenti del metodo in merito al problema. Ecco i possibili valori di errore e il relativo significato

P2P_UNSUPPORTED
Wi-Fi Direct non è supportato sul dispositivo su cui è in esecuzione l'app.
BUSY
Il sistema è troppo occupato per elaborare la richiesta.
ERROR
L'operazione non è riuscita a causa di un errore interno.