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

In der ersten Lektion dieses Kurses, Netzwerkdiensterkennung verwenden, haben Sie gelernt, wie Sie Dienste erkennen, die mit einem lokalen Netzwerk verbunden sind. Mit der Wi-Fi Direct-Diensterkennung (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 für die auf Ihrem Gerät ausgeführten Dienste werben. 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 sehr unterschiedlich. 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 bereits mit der Wi-Fi Direct API vertraut sind.

Manifest einrichten

Wenn Sie Wi‑Fi 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. Für Wi‑Fi Direct ist zwar keine Internetverbindung erforderlich, aber es werden standardmäßige 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" />
    ...

Neben den oben genannten Berechtigungen ist für die folgenden APIs auch die Aktivierung des Standortmodus erforderlich:

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, reagiert das Framework automatisch auf Dienstermittlungsanfragen von Peers.

So erstellen Sie einen lokalen Dienst:

  1. Erstellen Sie ein WifiP2pServiceInfo-Objekt.
  2. Füllen Sie es mit Informationen zu Ihrem Dienst aus.
  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
            }
        });
    }

Dienste in der Nähe entdecken

Android verwendet Callback-Methoden, um Ihre Anwendung über verfügbare Dienste zu informieren. Richten Sie diese also als Erstes ein. Erstellen Sie einen WifiP2pManager.DnsSdTxtRecordListener, um eingehende Datensätze zu überwachen. Dieser Datensatz kann optional von anderen Geräten übertragen werden. Wenn eine 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 Datensatz 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 eine WifiP2pManager.DnsSdServiceResponseListener, um die Dienstinformationen abzurufen. 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 Buddy-Namen zu verknüpfen. Der Listener für Dienstantworten verwendet dies, um den DNS-Eintrag mit den entsprechenden Dienstinformationen zu verknüpfen. Sobald beide Listener implementiert sind, fügen Sie sie dem 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 Serviceanfrage und rufen Sie addServiceRequest() auf. Diese Methode verwendet auch einen Listener, 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 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 asynchronen Aufrufe, die Sie ausgeführt haben, ein WifiP2pManager.ActionListener als Argument verwenden. Dadurch erhalten Sie Rückrufe, die Erfolg oder Misserfolg angeben. Um Probleme zu diagnostizieren, fügen Sie Debugging-Code in onFailure() ein. Der von der Methode bereitgestellte Fehlercode gibt einen Hinweis auf das Problem. Hier finden Sie 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 bearbeiten.
ERROR
 Der Vorgang ist aufgrund eines internen Fehlers fehlgeschlagen.