Wi-Fi Direct (P2P) für die Diensterkennung verwenden

In der ersten Lektion dieses Kurses, Netzwerkdiensterkennung verwenden, haben Sie gelernt, wie Sie Dienste finden, die mit einem lokalen Netzwerk verbunden sind. Mit der Diensterkennung von Wi‑Fi Direct (P2P) können Sie jedoch die Dienste von Geräten in der Nähe direkt erkennen, ohne mit einem Netzwerk verbunden zu sein. Sie können auch die Dienste bewerben, die auf Ihrem Gerät laufen. Mit diesen Funktionen können Sie auch dann zwischen Apps kommunizieren, wenn kein lokales Netzwerk oder Hotspot verfügbar ist.

Diese APIs ähneln in ihrer Funktion den in einer früheren Lektion beschriebenen APIs zur Netzwerkdiensterkennung, ihre Implementierung im Code unterscheidet sich jedoch stark. In dieser Lektion erfahren Sie, wie Sie mit Wi-Fi Direct auf anderen Geräten verfügbare Dienste finden. In dieser Lektion wird davon ausgegangen, dass Sie mit der Wi‑Fi Direct API vertraut sind.

Manifest einrichten

Wenn Sie WLAN-P2P verwenden möchten, fügen Sie Ihrem Manifest die Berechtigungen CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION und INTERNET hinzu. Wenn Ihre App auf Android 13 (API-Level 33) oder höher ausgerichtet ist, fügen Sie Ihrem Manifest auch die Berechtigung NEARBY_WIFI_DEVICES hinzu. Auch wenn für Wi-Fi Direct keine Internetverbindung erforderlich ist, werden dafür Standard-Java-Sockets verwendet. Für deren Verwendung in Android sind die angeforderten Berechtigungen erforderlich.

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

Neben den oben genannten Berechtigungen muss für die folgenden APIs auch der Standortmodus aktiviert sein:

Lokalen Dienst hinzufügen

Wenn Sie einen lokalen Dienst anbieten, müssen Sie ihn für die Dienstermittlung registrieren. Sobald Ihr lokaler Dienst registriert ist, antwortet das Framework automatisch auf Anfragen zur Dienstermittlung von Peers.

So erstellen Sie einen lokalen Dienst:

  1. Erstellen Sie ein WifiP2pServiceInfo-Objekt.
  2. Geben Sie darin Informationen zu Ihrer Dienstleistung ein.
  3. Rufen Sie addLocalService() auf, um den lokalen Dienst für die Diensterkennung zu registrieren.

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

Dienstleistungen in der Nähe entdecken

Android verwendet Rückrufmethoden, um Ihre Anwendung über verfügbare Dienste zu informieren. Sie müssen diese also zuerst einrichten. Erstellen Sie einen WifiP2pManager.DnsSdTxtRecordListener, um eingehende Einträge zu überwachen. Dieser Datensatz kann optional von anderen Geräten übertragen werden. Wenn eine solche Nachricht eingeht, kopieren Sie die Geräteadresse und alle anderen relevanten Informationen in eine Datenstruktur außerhalb der aktuellen Methode, damit Sie später darauf zugreifen können. Im folgenden Beispiel wird davon ausgegangen, dass der Datensatz ein Feld „buddyname“ enthält, das mit der Identität des Nutzers ausgefüllt ist.

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

Wenn Sie die Dienstinformationen abrufen möchten, erstellen Sie eine WifiP2pManager.DnsSdServiceResponseListener. Hier werden die tatsächliche Beschreibung und die Verbindungsinformationen empfangen. Im vorherigen Code-Snippet wurde ein Map-Objekt implementiert, um eine Geräteadresse mit dem Namen des Buddys zu verknüpfen. Der Dienstantwort-Listener verwendet diese Informationen, um den DNS-Eintrag mit den entsprechenden Dienstinformationen zu verknüpfen. Nachdem beide Listener implementiert wurden, fügen Sie sie mit der Methode setDnsSdResponseListeners() dem WifiP2pManager hinzu.

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

Erstellen Sie jetzt einen Serviceauftrag und rufen Sie addServiceRequest() an. Diese Methode nimmt auch einen Listener an, um Erfolg oder Fehler zu melden.

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

Rufen Sie abschließend discoverServices() an.

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

Wenn alles gut geht, sind Sie fertig. Wenn Probleme auftreten, denken Sie daran, dass die von Ihnen ausgeführten asynchronen Aufrufe WifiP2pManager.ActionListener als Argument annehmen. Dadurch erhalten Sie Callbacks, die Erfolg oder Misserfolg anzeigen. Fügen Sie onFailure() Debugging-Code hinzu, um Probleme zu diagnostizieren. Der von der Methode bereitgestellte Fehlercode weist auf das Problem hin. Hier sind die möglichen Fehlerwerte und ihre Bedeutung:

P2P_UNSUPPORTED
 Wi‑Fi Direct wird auf dem Gerät, auf dem die App ausgeführt wird, nicht unterstützt.
BUSY
Das System ist zu beschäftigt, um die Anfrage zu verarbeiten.
ERROR
Der Vorgang ist aufgrund eines internen Fehlers fehlgeschlagen.