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

Z pierwszej lekcji tego kursu, Wykrywanie usług sieciowych, dowiedzieliśmy się, jak wykrywać usługi połączone z siecią lokalną. Wykrywanie usług Wi-Fi Direct (P2P) umożliwia jednak bezpośrednie wykrywanie usług na urządzeniach w pobliżu bez połączenia z siecią. Możesz też reklamować usługi działające na Twoim urządzeniu. Te możliwości ułatwiają komunikację między aplikacjami, nawet gdy nie ma sieci lokalnej ani hotspota.

Ten zestaw interfejsów API jest podobny do interfejsów API wykrywania usług sieciowych opisanych w poprzedniej lekcji, ale ich implementacja w kodzie jest zupełnie inna. Z tej lekcji dowiesz się, jak wykrywać usługi dostępne na innych urządzeniach za pomocą Wi-Fi Direct. Zakładamy, że znasz już interfejs API Wi-Fi Direct.

Konfigurowanie pliku manifestu

Aby korzystać z Wi-Fi P2P, dodaj do pliku manifestu uprawnienia CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION, i INTERNET. Jeśli Twoja aplikacja jest kierowana na Androida 13 (API na poziomie 33) lub nowszego, dodaj też do pliku manifestu uprawnienie NEARBY_WIFI_DEVICES. Mimo że Wi-Fi Direct nie wymaga połączenia z internetem, używa 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 wymienionych wyżej uprawnień te interfejsy API wymagają też włączenia trybu lokalizacji:

Dodawanie usługi lokalnej

Jeśli świadczysz usługę lokalną, musisz ją zarejestrować w celu wykrywania usług. Gdy usługa lokalna jest zarejestrowana, platforma automatycznie odpowiada na żądania wykrywania usług od urządzeń równorzędnych.

Aby utworzyć usługę lokalną:

  1. Utwórz obiekt WifiP2pServiceInfo.
  2. Wypełnij go informacjami o swojej usłudze.
  3. Aby zarejestrować usługę lokalną w celu wykrywania usług, wywołaj metodę addLocalService().

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

Wykrywanie usług w pobliżu

Android używa metod wywołania zwrotnego do powiadamiania aplikacji o dostępnych usługach, więc najpierw musisz je skonfigurować. Utwórz element WifiP2pManager.DnsSdTxtRecordListener, aby nasłuchiwać przychodzące rekordy. Ten rekord może być opcjonalnie rozgłaszany przez inne urządzenia. Gdy taki rekord nadejdzie, skopiuj adres urządzenia i inne istotne informacje do struktury danych zewnętrznej względem bieżącej metody, aby móc uzyskać do nich dostęp później. W tym przykładzie zakładamy, że rekord zawiera pole „buddyname” wypełnione tożsamością 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 element WifiP2pManager.DnsSdServiceResponseListener. Otrzymuje on rzeczywisty opis i informacje o połączeniu. Poprzedni fragment kodu implementował obiekt Map, aby powiązać adres urządzenia z nazwą znajomego. Odbiornik odpowiedzi usługi używa go do powiązania rekordu DNS z odpowiednimi informacjami o usłudze. Gdy oba odbiorniki zostaną zaimplementowane, 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 zapytanie o usługę i wywołaj metodę addServiceRequest(). Ta metoda przyjmuje też odbiornik, który informuje o powodzeniu lub niepowodzeniu.

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 wywołaj metodę 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, gratulacje – gotowe! Jeśli napotkasz problemy, pamiętaj, że wywołane przez Ciebie asynchroniczne wywołania przyjmują jako argument element WifiP2pManager.ActionListener, który udostępnia wywołania zwrotne wskazujące powodzenie lub niepowodzenie. Aby zdiagnozować problemy, umieść kod debugowania w onFailure(). Kod błędu podany przez metodę wskazuje problem. Oto możliwe wartości błędów i ich znaczenie

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.