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

Pierwsza lekcja w tym kursie, Korzystanie z wykrywania usług sieciowych, pokazała, jak wykrywać usługi połączone z siecią lokalną. Jednak dzięki wykrywaniu usług Wi-Fi Direct (P2P) możesz wykrywać usługi urządzeń w pobliżu bezpośrednio, bez połączenia z siecią. Możesz też reklamować usługi działające na Twoim urządzeniu. Te funkcje ułatwiają komunikację między aplikacjami, nawet gdy nie jest dostępna sieć lokalna ani hotspot.

Chociaż ten zestaw interfejsów API ma podobny cel jak interfejsy API wykrywania usług sieciowych opisane w poprzedniej lekcji, 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. Lekcja zakłada, ż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 aplikacja jest kierowana na Androida 13 (API na poziomie 33) lub nowszego, dodaj też do pliku manifestu uprawnienie NEARBY_WIFI_DEVICES. Chociaż Wi-Fi Direct nie wymaga połączenia z internetem, korzysta ze standardowych gniazd Java, a używanie ich na Androidzie wymaga 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 uprawnień wymienionych powyżej te interfejsy API wymagają również włączenia trybu lokalizacji:

Dodawanie usługi lokalnej

Jeśli udostępniasz usługę lokalną, musisz ją zarejestrować na potrzeby wykrywania usług. Po zarejestrowaniu usługi lokalnej platforma automatycznie odpowiada na żądania wykrywania usług od innych urządzeń.

Aby utworzyć usługę lokalną:

  1. Utwórz obiekt WifiP2pServiceInfo.
  2. Wprowadź do niego informacje o swojej usłudze.
  3. Wywołaj addLocalService(), aby zarejestrować usługę lokalną na potrzeby 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
            }
        });
    }

Odkrywanie usług w pobliżu

Android używa metod wywołania zwrotnego, aby powiadomić aplikację o dostępnych usługach, więc najpierw musisz je skonfigurować. Utwórz WifiP2pManager.DnsSdTxtRecordListener, aby nasłuchiwać przychodzących rekordów. Ten rekord może być opcjonalnie transmitowany przez inne urządzenia. Gdy otrzymasz powiadomienie, skopiuj adres urządzenia i inne istotne informacje do struktury danych zewnętrznej względem bieżącej metody, aby mieć do nich dostęp później. W tym przykładzie zakładamy, że rekord zawiera pole „buddyname” z 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 WifiP2pManager.DnsSdServiceResponseListener. Ten parametr otrzymuje rzeczywisty opis i informacje o połączeniu. Poprzedni fragment kodu implementował obiekt Map, aby sparować adres urządzenia z nazwą znajomego. Odbiornik odpowiedzi usługi używa go do połączenia rekordu DNS z odpowiednimi informacjami o usłudze. Po zaimplementowaniu obu obiektów nasłuchujących dodaj je do obiektu 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 addServiceRequest(). Ta metoda wymaga też detektora, który zgłasza powodzenie 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 wywołaj 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, to świetnie, gotowe! Jeśli napotkasz problemy, pamiętaj, że wywołania asynchroniczne, które zostały wykonane, przyjmują WifiP2pManager.ActionListener jako argument, co zapewnia wywołania zwrotne wskazujące na powodzenie lub niepowodzenie. Aby zdiagnozować problemy, umieść kod debugowania w pliku onFailure(). Kod błędu podany przez metodę wskazuje na 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.