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

In der ersten Lektion dieses Kurses, Network Service Discovery verwenden, hast du gelernt, wie du Dienste findest, die mit einem lokalen Netzwerk verbunden sind. Mit der 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 Dienste bewerben, die auf Ihrem Gerät ausgeführt werden. Diese Funktionen ermöglichen die Kommunikation zwischen Apps, auch wenn kein lokales Netzwerk oder Hotspot verfügbar ist.

Diese APIs haben einen ähnlichen Zweck wie die Network Service Discovery APIs, die in einer vorherigen Lektion beschrieben wurden. Die Implementierung im Code ist jedoch ganz anders. In dieser Lektion erfährst du, wie du mithilfe von Wi-Fi Direct Dienste findest, die von anderen Geräten angeboten werden. In dieser Lektion wird davon ausgegangen, dass du bereits mit der Wi-Fi Direct API vertraut bist.

Manifest einrichten

Wenn du Wi-Fi P2P verwenden möchtest, füge deinem 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. Obwohl für Wi-Fi Direct keine Internetverbindung erforderlich ist, werden Standard-Java-Sockets verwendet. Für die Verwendung dieser Sockets 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" />
    ...

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

Lokalen Dienst hinzufügen

Wenn Sie einen lokalen Dienst bereitstellen, müssen Sie ihn für die Service Discovery registrieren. Sobald Ihr lokaler Dienst registriert ist, reagiert das Framework automatisch auf Service Discovery-Anfragen von Peers.

So erstellen Sie einen lokalen Dienst:

  1. Erstellen Sie ein WifiP2pServiceInfo-Objekt.
  2. Geben Sie Informationen zu Ihrem Dienst ein.
  3. Rufen Sie addLocalService() auf, um den lokalen Dienst für Service Discovery 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
            }
        });
    }

Dienste in der Nähe entdecken

Android verwendet Callback-Methoden, um Ihre Anwendung über verfügbare Dienste zu benachrichtigen. Daher müssen Sie diese zuerst einrichten. Erstellen Sie einen WifiP2pManager.DnsSdTxtRecordListener, um auf eingehende Datensätze zu warten. Dieser Datensatz kann optional von anderen Geräten übertragen werden. Wenn eine eingeht, kopiere die Geräteadresse und alle anderen relevanten Informationen, die du benötigst, in eine Datenstruktur außerhalb der aktuellen Methode, damit du später darauf zugreifen kannst. Im folgenden Beispiel wird davon ausgegangen, dass der Eintrag ein Feld „buddyname“ enthält, das mit der Identität des Nutzers gefü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 einen WifiP2pManager.DnsSdServiceResponseListener, um die Dienstinformationen abzurufen. Diese erhält die eigentliche Beschreibung und die Verbindungsinformationen. Im vorherigen Code-Snippet wurde ein Map-Objekt implementiert, um eine Geräteadresse mit dem Buddy-Namen zu verknüpfen. Der Dienstantwort-Listener verwendet diese, 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 eine Dienstanfrage und rufen Sie addServiceRequest() auf. Diese Methode verwendet auch einen Listener, 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 schließlich 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 geht, sind Sie fertig. Wenn Probleme auftreten, denken Sie daran, dass die von Ihnen ausgeführten asynchronen Aufrufe ein WifiP2pManager.ActionListener als Argument verwenden. Dadurch erhalten Sie Callbacks, die auf Erfolg oder Fehler hinweisen. Fügen Sie zur Diagnose von Problemen Debugging-Code in onFailure() ein. 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 ausgelastet, um die Anfrage zu verarbeiten.
ERROR
Der Vorgang ist aufgrund eines internen Fehlers fehlgeschlagen.