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ą. Korzystanie z usługi wykrywania usług Wi-Fi Direct (P2P) pozwala jednak wykrywać usługi urządzeń w pobliżu bezpośrednio, bez łączenia się z siecią. Możesz też reklamować usługi działające na urządzeniu. Te funkcje ułatwiają komunikację między aplikacjami, nawet jeśli nie ma sieci lokalnej ani hotspota.

Chociaż ten zestaw interfejsów API ma podobne przeznaczenie do interfejsów API Network Service Discovery opisanych w poprzedniej lekcji, ich implementacja w kodzie jest zupełnie inna. Z tego filmu dowiesz się, jak wykrywać usługi dostępne na innych urządzeniach za pomocą Wi-Fi Direct. Zajęcia są oparte na założeniu, ż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 (poziom API 33) lub nowszego, dodaj do pliku manifestu uprawnienie NEARBY_WIFI_DEVICES. 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 poprzednich uprawnień te interfejsy API wymagają też włączenia trybu lokalizacji:

Dodaj usługę lokalną

Jeśli świadczysz usługi lokalne, musisz zarejestrować je w usługach wyszukiwania. Gdy usługa lokalna zostanie zarejestrowana, platforma automatycznie odpowiada na żądania wykrywania usług pochodzące od równorzędnych sieci.

Aby utworzyć usługę lokalną:

  1. Utwórz obiekt WifiP2pServiceInfo.
  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
            }
        });
    }

Odkrywanie usług w pobliżu

Android używa metod wywołania zwrotnego, aby powiadomić aplikację o dostępnych usługach. Dlatego najpierw musisz je skonfigurować. Utwórz WifiP2pManager.DnsSdTxtRecordListener, aby nasłuchiwać przychodzących rekordów. Ten rekord może być opcjonalnie rozpowszechniany 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. Ta funkcja otrzymuje rzeczywisty opis i informacje o połączeniu. Poprzedni fragment kodu implementował obiekt Map, aby sparować adres urządzenia z nazwą partnera. Słuchający odpowiedź usługi używa tego do powiązania rekordu DNS z odpowiadającymi mu informacjami 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, to znaczy, że skończyłeś. Jeśli napotkasz problemy, pamiętaj, że wywołania asynchroniczne, które zostały wykonane, przyjmują jako argument parametr WifiP2pManager.ActionListener, a to zapewnia wywołania zwrotne wskazujące powodzenie lub niepowodzenie. Aby zdiagnozować problemy, umieść kod debugowania w miejscu onFailure(). Kod błędu podany przez metodę sugeruje problem. Możliwe wartości błędów i ich znaczenie

P2P_UNSUPPORTED
Urządzenie z aplikacją
nie obsługuje Wi-Fi Direct.
BUSY
System jest zbyt zajęty, aby przetworzyć żądanie.
ERROR
Operacja nie powiodła się z powodu błędu wewnętrznego.