Menggunakan Wi-Fi Langsung (P2P) untuk penemuan layanan

Pelajaran pertama di kelas ini, Menggunakan Layanan Jaringan Discovery, menampilkan cara menemukan layanan yang terhubung ke jaringan lokal. Namun, menggunakan Penemuan Layanan Wi-Fi Langsung (P2P) memungkinkan Anda menemukan layanan perangkat di sekitar secara langsung, tanpa terhubung ke jaringan. Anda juga dapat mengiklankan layanan yang sedang berjalan di perangkat Anda. Kemampuan ini membantu Anda berkomunikasi antar-aplikasi, bahkan ketika tidak ada jaringan lokal atau {i>hotspot<i} yang tersedia.

Meskipun kumpulan API ini memiliki tujuan serupa dengan Penemuan Layanan Jaringan API yang diuraikan di tutorial sebelumnya, mengimplementasikannya dalam kode sangat berbeda. Pelajaran ini menunjukkan cara menemukan layanan yang tersedia dari perangkat lain, menggunakan Wi-Fi Langsung. Pelajaran ini mengasumsikan bahwa Anda sudah familier dengan Wi-Fi Langsung API.

Menyiapkan manifes

Untuk menggunakan Wi-Fi P2P, tambahkan CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION, dan INTERNET izin akses ke manifes Anda. Jika aplikasi Anda menargetkan Android 13 (API level 33) atau yang lebih baru, tambahkan juga NEARBY_WIFI_DEVICES, izin akses ke manifes Anda. Meskipun Wi-Fi Langsung tidak memerlukan koneksi internet, ia menggunakan soket Java standar, dan menggunakannya di Android memerlukan izin yang diminta.

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

Selain izin sebelumnya, API berikut ini juga membutuhkan Mode Lokasi agar dapat diaktifkan:

• discoverPeers
• discoverServices
• requestPeers

Menambahkan layanan lokal

Jika Anda menyediakan layanan lokal, Anda harus mendaftarkannya untuk penemuan layanan. Setelah layanan lokal Anda terdaftar, framework secara otomatis merespons permintaan penemuan layanan dari peer.

Untuk membuat layanan lokal:

1. Buat Objek WifiP2pServiceInfo.
2. Isi dengan informasi tentang layanan Anda.
3. Panggil addLocalService() untuk mendaftarkan lokal untuk penemuan layanan.

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

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

Menemukan layanan di sekitar

Android menggunakan metode callback untuk memberi tahu aplikasi tentang layanan yang tersedia, sehingga hal pertama yang harus dilakukan adalah menyiapkannya. Buat WifiP2pManager.DnsSdTxtRecordListener yang akan diproses catatan yang masuk. Secara opsional, rekaman ini dapat disiarkan oleh perangkat. Jika ada pesan masuk, salin alamat perangkat dan alamat email lainnya informasi relevan yang Anda inginkan ke dalam struktur data di luar kondisi saat ini , sehingga Anda dapat mengaksesnya nanti. Contoh berikut mengasumsikan bahwa rekaman berisi "buddyname" kolom yang diisi dengan identitas pengguna.

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

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

Untuk mendapatkan informasi layanan, buat WifiP2pManager.DnsSdServiceResponseListener. Ini menerima deskripsi aktual dan informasi koneksi. Kode sebelumnya cuplikan menerapkan objek Map untuk menyambungkan alamat perangkat dengan buddy nama. Pemroses respons layanan menggunakan ini untuk menautkan catatan DNS dengan informasi layanan yang sesuai. Setelah keduanya diimplementasikan, tambahkan pemroses tersebut ke WifiP2pManager menggunakan metode setDnsSdResponseListeners().

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

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

Sekarang buat permintaan layanan dan panggil addServiceRequest(). Metode ini juga memerlukan pemroses untuk melaporkan keberhasilan atau kegagalan.

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

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

Terakhir, lakukan panggilan ke discoverServices().

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

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

Jika semua berjalan lancar, artinya Anda selesai. Selamat! Jika Anda mengalami masalah, ingatlah bahwa panggilan asinkron yang Anda lakukan melakukan WifiP2pManager.ActionListener sebagai argumen, dan ini memberi Anda callback yang menunjukkan keberhasilan atau kegagalan. Untuk mendiagnosis masalah, masukkan kode proses debug di onFailure(). Kode error yang disediakan oleh petunjuk metode pada masalah tersebut. Berikut adalah kemungkinan nilai error dan apa artinya

P2P_UNSUPPORTED

Wi-Fi Langsung tidak didukung di perangkat yang menjalankan aplikasi.

BUSY

Sistem terlalu sibuk untuk memproses permintaan.

ERROR

Operasi gagal karena terjadi error internal.