Menggunakan Wi-Fi Langsung (P2P) untuk penemuan layanan

Tutorial pertama di class ini, Menggunakan Penemuan Layanan Jaringan, menunjukkan cara menemukan layanan yang terhubung ke jaringan lokal. Namun, penggunaan Penemuan Layanan Wi-Fi Peer-to-Peer (P2P) memungkinkan Anda untuk menemukan layanan perangkat di sekitar secara langsung, tanpa perlu tersambung ke jaringan. Anda juga dapat mengiklankan layanan yang berjalan di perangkat Anda. Kemampuan ini membantu Anda berkomunikasi antar-aplikasi, bahkan saat jaringan lokal atau hotspot tidak tersedia.

Meskipun kumpulan API ini memiliki tujuan serupa dengan API Penemuan Layanan Jaringan yang diuraikan pada tutorial sebelumnya, implementasinya dalam kode sangatlah berbeda. Tutorial ini menunjukkan cara menemukan layanan yang tersedia dari perangkat lain, menggunakan Wi-Fi P2P. Tutorial ini mengasumsikan bahwa Anda sudah memahami Wi-Fi P2P API.

Menyiapkan manifes

Untuk menggunakan Wi-Fi P2P, tambahkan izin CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION, dan INTERNET ke manifes Anda. Meskipun Wi-Fi P2P tidak memerlukan koneksi internet, Wi-Fi P2P menggunakan soket Java standar, dan penggunaannya 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.ACCESS_FINE_LOCATION"/>
        <uses-permission
            android:required="true"
            android:name="android.permission.INTERNET"/>
        ...
    

Selain izin sebelumnya, API berikut juga mewajibkan Mode Lokasi untuk diaktifkan:

Menambahkan layanan lokal

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

Untuk membuat layanan lokal:

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

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

Menemukan layanan di sekitar

Android menggunakan metode callback untuk memberi tahu aplikasi layanan yang tersedia, sehingga hal pertama yang harus dilakukan adalah menyiapkannya. Buat WifiP2pManager.DnsSdTxtRecordListener untuk memproses data yang masuk. Data ini dapat disiarkan secara opsional oleh perangkat lain. Jika ada data yang masuk, salin alamat perangkat dan informasi relevan lain yang Anda inginkan ke dalam eksternal struktur data ke metode saat ini, agar dapat diakses nanti. Contoh berikut mengasumsikan bahwa data yang mengandung kolom "buddyname" diisi dengan identitas pengguna.

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

Untuk mendapatkan informasi layanan, buat WifiP2pManager.DnsSdServiceResponseListener. Ini akan menerima informasi koneksi dan deskripsi yang sebenarnya. Cuplikan kode sebelumnya mengimplementasikan objek Map untuk menyambungkan alamat perangkat dengan nama buddy. Pemroses respons layanan menggunakannya untuk menautkan data DNS dengan informasi layanan yang sesuai. Setelah kedua pemroses diimplementasikan, tambahkan keduanya ke WifiP2pManager menggunakan metode 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);
        ...
    }
    

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

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

Terakhir, lakukan panggilan ke 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, "P2P 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, "P2P isn't supported on this device.");
                    else if(...)
                        ...
                }
            });
    

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

P2P_UNSUPPORTED
Wi-Fi P2P tidak didukung di perangkat yang menjalankan aplikasi.
BUSY
Sistem terlalu sibuk untuk memproses permintaan.
ERROR
Operasi gagal karena terjadi error internal.