Używaj Wi-Fi Direct (P2P) do wykrywania usług

W pierwszym ćwiczeniu tej lekcji, Wykorzystanie wykrywania usługi sieciowej, pokazaliśmy, jak wykrywać usługi połączone z siecią lokalną. Korzystając jednak z metody Wykrywanie usług Wi-Fi Direct (P2P) umożliwia wykrywanie usług urządzeń w pobliżu bezpośrednio, bez połączenia z siecią. Możesz również reklamować usługi, który działa na Twoim urządzeniu. Funkcje te ułatwiają komunikację między aplikacjami, nawet jeśli nie ma dostępu do sieci lokalnej ani hotspotu.

Chociaż ten zestaw interfejsów API jest podobny do wykrywania usług sieciowych Implementacja interfejsów API w kodzie bardzo się różni. Z tej lekcji dowiesz się, jak odkrywać usługi dostępne na innych urządzeniach, przy użyciu Wi-Fi Direct. W ramach lekcji zakładamy, że znasz już Interfejs API Wi-Fi Direct.

Konfigurowanie pliku manifestu

Aby korzystać z Wi-Fi P2P, dodaj CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION, i INTERNET uprawnienia dostępu do pliku manifestu. Jeśli Twoja aplikacja jest kierowana na Androida 13 (poziom interfejsu API 33) lub nowszego, dodaj też NEARBY_WIFI_DEVICES, dostęp do pliku manifestu. Mimo że Wi-Fi Direct nie wymaga połączenia z internetem, korzysta ze standardowych gniazd Java, a ich używanie w Androidzie wymaga żądanych uprawnień.

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

Oprócz tych uprawnień, te interfejsy API wymagają też włączenia trybu lokalizacji:

Dodaj usługę lokalną

Jeśli świadczysz usługę lokalną, musisz ją zarejestrować wykrywanie usług. Gdy usługa lokalna zostanie zarejestrowana, platforma automatycznie odpowiada na żądania wykrywania usług od innych urządzeń.

Aby utworzyć lokalną usługę:

  1. Utwórz WifiP2pServiceInfo obiekt.
  2. Wprowadź do niego informacje o swojej usłudze.
  3. Zadzwoń pod numer addLocalService(), aby zarejestrować lokalną usługę w celu wykrywania usług.

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

Odkryj usługi w pobliżu

Android używa metod wywołania zwrotnego do powiadamiania aplikacji o dostępnych usługach, musisz je skonfigurować. Utwórz WifiP2pManager.DnsSdTxtRecordListener, aby nasłuchiwać przychodzących rekordów. Ten rekord może być opcjonalnie nadawany przez inne urządzenia. Gdy pojawi się nowe urządzenie, skopiuj jego adres i inne istotne informacje do struktury danych zewnętrznej w stosunku do bieżącej metody, aby mieć do nich dostęp później. W tym przykładzie zakładamy, że rekord zawiera pole „buddyname”, w którym podana jest tożsamość użytkownika.

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

Aby uzyskać informacje o usłudze, utwórz WifiP2pManager.DnsSdServiceResponseListener. Ten otrzymuje rzeczywisty opis i informacje o połączeniu. Poprzedni kod fragment kodu implementował obiekt Map, aby sparować adres urządzenia ze znajomym imię i nazwisko. Detektor odpowiedzi usługi używa go do połączenia rekordu DNS z odpowiednie informacje o usłudze. Po zaimplementowaniu obu listenerów dodaj je do WifiP2pManager za pomocą metody setDnsSdResponseListeners().

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

Teraz utwórz zgłoszenie serwisowe i zadzwoń do addServiceRequest(). W przypadku tej metody detektor zgłasza sukces lub niepowodzenie.

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

Na koniec zadzwoń pod numer discoverServices().

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

Jeśli wszystko pójdzie dobrze, hura, to już wszystko. W razie problemów pamiętaj, że wykonywane przez Ciebie wywołania asynchroniczne przyjmują WifiP2pManager.ActionListener jako argument, oraz uzyskasz wywołania zwrotne wskazujące na powodzenie lub niepowodzenie. Aby zdiagnozować problemy, umieść kod debugowania w miejscu onFailure(). Kod błędu zgodnie ze wskazówkami dotyczącymi danego zadania. Oto możliwe wartości błędów i ich znaczeniu

P2P_UNSUPPORTED
 Wi-Fi Direct nie jest obsługiwane na urządzeniu, na którym działa aplikacja.
BUSY
System jest zbyt zajęty, aby przetworzyć żądanie.
ERROR
Operacja nie powiodła się z powodu błędu wewnętrznego.