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

Die erste Lektion in diesem Kurs: Netzwerkdienst verwenden Discovery-Kampagne, wie Dienste gefunden werden, die mit einem lokalen Netzwerk verbunden sind. Wenn Sie jedoch Mit Wi-Fi Direct (P2P) Service Discovery kannst du die Dienste von Geräten in der Nähe finden ohne Netzwerkverbindung. Sie können auch für die Dienstleistungen auf Ihrem Gerät ausgeführt wird. 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 mithilfe von 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

Zur Verwendung von WLAN-P2P musst du die CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION, und INTERNET Berechtigungen für Ihr Manifest. Wenn Ihre App auf Android 13 (API-Level 33) oder höher ausgerichtet ist, fügen Sie außerdem den NEARBY_WIFI_DEVICES, für dein Manifest. Auch wenn für Wi‑Fi Direct keine Internetverbindung erforderlich ist, werden standardmäßige Java-Sockets verwendet. Für die Verwendung dieser Sockets unter 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 automatisch auf Diensterkennungsanfragen von Peers.

So erstellen Sie einen lokalen Dienst:

  1. Erstellen: WifiP2pServiceInfo-Objekt.
  2. Fügen Sie Informationen zu Ihrem Dienst hinzu.
  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 finden

Android verwendet Rückrufmethoden, um Ihre Anwendung über verfügbare Dienste zu informieren. müssen Sie als Erstes diese einrichten. Erstellen Sie einen WifiP2pManager.DnsSdTxtRecordListener, um eingehende Einträge zu überwachen. Dieser Datensatz kann optional von anderen Geräten übertragen werden. Wenn ein Gerät eingeht, kopiere die Geräteadresse und alle anderen relevante Informationen in eine Datenstruktur außerhalb der aktuellen um später darauf zugreifen zu 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"));
            }
        };
}

Erstellen Sie zum Abrufen der Dienstinformationen eine WifiP2pManager.DnsSdServiceResponseListener. Dieses die eigentliche Beschreibung und Verbindungsinformationen. Vorheriger Code Snippet hat ein Map-Objekt implementiert, um eine Geräteadresse mit dem Buddy zu koppeln Namen. Der Dienstantwort-Listener verwendet diese Informationen, um den DNS-Eintrag mit den entsprechenden Dienstinformationen zu verknüpfen. Nachdem Sie beide Listener implementiert haben, fügen Sie sie WifiP2pManager mit der Methode setDnsSdResponseListeners() 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 nun eine Dienstanfrage und rufen Sie addServiceRequest() auf. Bei dieser Methode wird auch ein Listener benötigt, um Erfolg oder Misserfolg 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(...)
                    ...
            }
        });

Geschafft! Wenn Probleme auftreten, denken Sie daran, dass die asynchronen Aufrufe, die Sie vorgenommen haben, WifiP2pManager.ActionListener als Argument und erhalten Sie Callbacks, die auf Erfolg oder Misserfolg hinweisen. Fügen Sie onFailure() Debugging-Code hinzu, um Probleme zu diagnostizieren. Der von der Methode bereitgestellte Fehlercode weist auf das Problem hin. Mögliche 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 ausgelastet, um die Anfrage zu verarbeiten.
ERROR
Der Vorgang ist aufgrund eines internen Fehlers fehlgeschlagen.