Diese Seite wurde von der Cloud Translation API übersetzt.

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

In der ersten Lektion dieses Kurses, Netzwerkdiensterkennung verwenden, wurde gezeigt, wie Sie Dienste finden, die mit einem lokalen Netzwerk verbunden sind. Mit Wi-Fi Direct (P2P) Service Discovery 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 auf Ihrem Gerät ausgeführten Dienste anbieten. Diese Funktionen helfen Ihnen bei der Kommunikation zwischen Anwendungen, auch wenn kein lokales Netzwerk oder kein lokaler Hotspot verfügbar ist.

Diese APIs haben einen ähnlichen Zweck wie die APIs zur Erkennung von Netzwerkdiensten, die in einer vorherigen Lektion beschrieben wurden. Die Implementierung im Code unterscheidet sich jedoch stark. In dieser Lektion erfahren Sie, wie Sie mit Wi-Fi Direct Dienste finden, die auf anderen Geräten verfügbar sind. In dieser Lektion wird davon ausgegangen, dass Sie mit der Wi-Fi Direct API vertraut sind.

Manifest einrichten

Fügen Sie Ihrem Manifest die Berechtigungen CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION und INTERNET hinzu, um WLAN-P2P zu verwenden. Wenn deine App auf Android 13 (API-Level 33) oder höher ausgerichtet ist, füge deinem Manifest auch die Berechtigung NEARBY_WIFI_DEVICES hinzu. Für Wi-Fi Direct ist zwar keine Internetverbindung erforderlich, dafür werden aber standardmäßige Java-Sockets verwendet, und die Verwendung dieser in Android erfordert die angeforderten Berechtigungen.

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

Zusätzlich zu den oben genannten Berechtigungen muss für die folgenden APIs auch der Standortmodus aktiviert werden:

Lokale Dienstleistung hinzufügen

Wenn Sie einen lokalen Dienst bereitstellen, müssen Sie ihn für die Diensterkennung registrieren. Sobald Ihr lokaler Dienst registriert ist, antwortet das Framework automatisch auf Diensterkennungsanfragen von Peers.

So erstellen Sie einen lokalen Dienst:

Erstellen Sie ein WifiP2pServiceInfo-Objekt.
Geben Sie Informationen zu Ihrer Dienstleistung ein.
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 finden

Android verwendet Callback-Methoden, um Ihre App über verfügbare Dienste zu informieren. Daher müssen Sie diese zuerst einrichten. Erstellen Sie einen WifiP2pManager.DnsSdTxtRecordListener, der auf eingehende Datensätze wartet. Dieser Eintrag kann optional von anderen Geräten übertragen werden. Wenn eine Person eingeht, kopieren Sie die Geräteadresse und alle anderen relevanten Informationen, die Sie benötigen, in eine Datenstruktur außerhalb der aktuellen Methode, damit Sie später darauf zugreifen können. Im folgenden Beispiel wird davon ausgegangen, dass der Eintrag das Feld „buddyname“ mit der Identität des Nutzers enthält.

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

Erstellen Sie einen WifiP2pManager.DnsSdServiceResponseListener, um die Dienstinformationen abzurufen. Diese empfängt die tatsächliche Beschreibung und Verbindungsinformationen. Im vorherigen Code-Snippet wurde ein Map-Objekt zum Koppeln einer Geräteadresse mit dem Buddy-Namen implementiert. Der Dienstantwort-Listener verknüpft damit den DNS-Eintrag mit den entsprechenden Dienstinformationen. Sobald beide Listener implementiert sind, fügen Sie sie mit der Methode setDnsSdResponseListeners() zu 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 eine Dienstanfrage und rufen Sie addServiceRequest() auf. Bei dieser Methode wird auch ein Listener benötigt, um den 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() auf.

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 läuft, haben Sie es geschafft! Wenn Probleme auftreten, denken Sie daran, dass die von Ihnen durchgeführten asynchronen Aufrufe ein WifiP2pManager.ActionListener als Argument verwenden. Dadurch erhalten Sie Callbacks, die Erfolg oder Misserfolg anzeigen. Fügen Sie Debugging-Code in onFailure() ein, 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 läuft, nicht unterstützt.
BUSY: Das System ist zu ausgelastet, um die Anfrage zu verarbeiten.
ERROR: Der Vorgang ist aufgrund eines internen Fehlers fehlgeschlagen.