Menghubungkan perangkat Bluetooth

Untuk membuat koneksi antara dua perangkat, Anda harus menerapkan mekanisme sisi server dan sisi klien karena satu perangkat harus membuka soket server, dan perangkat lainnya harus memulai koneksi menggunakan alamat MAC perangkat server. Perangkat server dan perangkat klien masing-masing mendapatkan BluetoothSocket yang diperlukan dengan cara yang berbeda. Server menerima informasi soket saat koneksi masuk diterima. Klien memberikan informasi soket saat membuka saluran RFCOMM ke server.

Server dan klien dianggap terhubung satu sama lain jika masing-masing memiliki BluetoothSocket yang terhubung di saluran RFCOMM yang sama. Pada tahap ini, setiap perangkat dapat memperoleh aliran input dan output, dan transfer data dapat dimulai, yang dibahas di bagian tentang mentransfer data Bluetooth. Bagian ini menjelaskan cara memulai koneksi antara dua perangkat.

Pastikan Anda memiliki izin Bluetooth yang sesuai dan menyiapkan aplikasi untuk Bluetooth sebelum mencoba menemukan perangkat Bluetooth.

Teknik koneksi

Salah satu teknik implementasinya adalah dengan otomatis menyiapkan setiap perangkat sebagai server sehingga setiap perangkat memiliki soket server yang terbuka dan memproses koneksi. Dalam hal ini, salah satu perangkat dapat memulai koneksi dengan perangkat lain dan menjadi klien. Atau, satu perangkat dapat secara eksplisit menghosting koneksi dan membuka soket server sesuai permintaan, dan perangkat lainnya memulai koneksi.

Dialog penyambungan Bluetooth yang meminta pengguna untuk menyambungkan dengan perangkat.
Gambar 1. Dialog penyambungan Bluetooth.

Terhubung sebagai server

Jika Anda ingin menghubungkan dua perangkat, salah satunya harus bertindak sebagai server dengan menyimpan BluetoothServerSocket terbuka. Tujuan soket server adalah untuk memproses permintaan koneksi masuk dan menyediakan BluetoothSocket yang terhubung setelah permintaan diterima. Saat BluetoothSocket diperoleh dari BluetoothServerSocket, BluetoothServerSocket dapat—dan harus—dibuang, kecuali jika Anda ingin perangkat menerima lebih banyak koneksi.

Untuk menyiapkan soket server dan menerima koneksi, selesaikan urutan langkah berikut:

  1. Dapatkan BluetoothServerSocket dengan memanggil listenUsingRfcommWithServiceRecord(String, UUID).

    String ini adalah nama layanan Anda yang dapat diidentifikasi, yang otomatis ditulis oleh sistem ke entri database Service Discovery Protocol (SDP) baru di perangkat. Nama ini bersifat arbitrer dan dapat berupa nama aplikasi Anda. Universally Unique Identifier (UUID) juga disertakan dalam entri SDP dan menjadi dasar perjanjian koneksi dengan perangkat klien. Artinya, saat klien mencoba terhubung dengan perangkat ini, klien membawa UUID yang secara unik mengidentifikasi layanan yang ingin dihubungkan. UUID ini harus cocok agar koneksi dapat diterima.

    UUID adalah format 128-bit standar untuk ID string yang digunakan untuk mengidentifikasi informasi secara unik. UUID digunakan untuk mengidentifikasi informasi yang harus unik dalam sistem atau jaringan karena probabilitas UUID berulang secara efektif adalah nol. Kunci ini dibuat secara independen, tanpa menggunakan otoritas terpusat. Dalam hal ini, UUID digunakan untuk mengidentifikasi layanan Bluetooth aplikasi Anda secara unik. Untuk mendapatkan UUID yang akan digunakan dengan aplikasi, Anda dapat menggunakan salah satu dari banyak generator UUID acak di web, lalu melakukan inisialisasi UUID dengan fromString(String).

  2. Mulai dengarkan permintaan koneksi dengan memanggil accept().

    Ini adalah panggilan pemblokiran. Metode ini akan ditampilkan saat koneksi telah diterima atau terjadi pengecualian. Koneksi hanya diterima jika perangkat jarak jauh telah mengirim permintaan koneksi yang berisi UUID yang cocok dengan yang terdaftar di soket server pemroses ini. Jika berhasil, accept() akan menampilkan BluetoothSocket yang terhubung.

  3. Kecuali jika Anda ingin menerima koneksi tambahan, panggil close().

    Panggilan metode ini merilis soket server dan semua resource-nya, tetapi tidak menutup BluetoothSocket yang terhubung yang telah ditampilkan oleh accept(). Tidak seperti TCP/IP, RFCOMM hanya mengizinkan satu klien yang terhubung per saluran dalam satu waktu, sehingga dalam sebagian besar kasus, sebaiknya panggil close() pada BluetoothServerSocket segera setelah menerima soket yang terhubung.

Karena panggilan accept() adalah panggilan pemblokiran, jangan jalankan di UI thread aktivitas utama. Menjalankannya di thread lain akan memastikan bahwa aplikasi Anda masih dapat merespons interaksi pengguna lainnya. Biasanya, sebaiknya lakukan semua pekerjaan yang melibatkan BluetoothServerSocket atau BluetoothSocket di thread baru yang dikelola oleh aplikasi Anda. Untuk membatalkan panggilan yang diblokir seperti accept(), panggil close() pada BluetoothServerSocket atau BluetoothSocket dari thread lain. Perhatikan bahwa semua metode pada BluetoothServerSocket atau BluetoothSocket aman untuk thread.

Contoh

Berikut adalah thread yang disederhanakan untuk komponen server yang menerima koneksi masuk:

Kotlin

private inner class AcceptThread : Thread() {

   private val mmServerSocket: BluetoothServerSocket? by lazy(LazyThreadSafetyMode.NONE) {
       bluetoothAdapter?.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID)
   }

   override fun run() {
       // Keep listening until exception occurs or a socket is returned.
       var shouldLoop = true
       while (shouldLoop) {
           val socket: BluetoothSocket? = try {
               mmServerSocket?.accept()
           } catch (e: IOException) {
               Log.e(TAG, "Socket's accept() method failed", e)
               shouldLoop = false
               null
           }
           socket?.also {
               manageMyConnectedSocket(it)
               mmServerSocket?.close()
               shouldLoop = false
           }
       }
   }

   // Closes the connect socket and causes the thread to finish.
   fun cancel() {
       try {
           mmServerSocket?.close()
       } catch (e: IOException) {
           Log.e(TAG, "Could not close the connect socket", e)
       }
   }
}

Java

private class AcceptThread extends Thread {
   private final BluetoothServerSocket mmServerSocket;

   public AcceptThread() {
       // Use a temporary object that is later assigned to mmServerSocket
       // because mmServerSocket is final.
       BluetoothServerSocket tmp = null;
       try {
           // MY_UUID is the app's UUID string, also used by the client code.
           tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
       } catch (IOException e) {
           Log.e(TAG, "Socket's listen() method failed", e);
       }
       mmServerSocket = tmp;
   }

   public void run() {
       BluetoothSocket socket = null;
       // Keep listening until exception occurs or a socket is returned.
       while (true) {
           try {
               socket = mmServerSocket.accept();
           } catch (IOException e) {
               Log.e(TAG, "Socket's accept() method failed", e);
               break;
           }

           if (socket != null) {
               // A connection was accepted. Perform work associated with
               // the connection in a separate thread.
               manageMyConnectedSocket(socket);
               mmServerSocket.close();
               break;
           }
       }
   }

   // Closes the connect socket and causes the thread to finish.
   public void cancel() {
       try {
           mmServerSocket.close();
       } catch (IOException e) {
           Log.e(TAG, "Could not close the connect socket", e);
       }
   }
}

Dalam contoh ini, hanya satu koneksi masuk yang diinginkan, jadi segera setelah koneksi diterima dan BluetoothSocket diperoleh, aplikasi akan meneruskan BluetoothSocket yang diperoleh ke thread terpisah, menutup BluetoothServerSocket, dan keluar dari loop.

Perhatikan bahwa saat accept() menampilkan BluetoothSocket, soket sudah terhubung. Oleh karena itu, Anda tidak boleh memanggil connect(), seperti yang Anda lakukan dari sisi klien.

Metode manageMyConnectedSocket() khusus aplikasi dirancang untuk memulai thread untuk mentransfer data, yang dibahas dalam topik tentang mentransfer data Bluetooth.

Biasanya, Anda harus menutup BluetoothServerSocket segera setelah selesai memproses koneksi masuk. Dalam contoh ini, close() dipanggil segera setelah BluetoothSocket diperoleh. Anda mungkin juga ingin menyediakan metode publik di thread yang dapat menutup BluetoothSocket pribadi jika Anda perlu berhenti memproses di soket server tersebut.

Terhubung sebagai klien

Untuk memulai koneksi dengan perangkat jarak jauh yang menerima koneksi pada soket server terbuka, Anda harus mendapatkan objek BluetoothDevice yang mewakili perangkat jarak jauh terlebih dahulu. Untuk mempelajari cara membuat BluetoothDevice, lihat Menemukan perangkat Bluetooth. Kemudian, Anda harus menggunakan BluetoothDevice untuk mendapatkan BluetoothSocket dan memulai koneksi.

Prosedur dasarnya adalah sebagai berikut:

  1. Dengan menggunakan BluetoothDevice, dapatkan BluetoothSocket dengan memanggil createRfcommSocketToServiceRecord(UUID).

    Metode ini menginisialisasi objek BluetoothSocket yang memungkinkan klien terhubung ke BluetoothDevice. UUID yang diteruskan di sini harus cocok dengan UUID yang digunakan oleh perangkat server saat memanggil listenUsingRfcommWithServiceRecord(String, UUID) untuk membuka BluetoothServerSocket-nya. Untuk menggunakan UUID yang cocok, hard code string UUID ke dalam aplikasi Anda, lalu referensikan dari kode server dan klien.

  2. Mulai koneksi dengan memanggil connect(). Perhatikan bahwa metode ini adalah panggilan pemblokiran.

    Setelah klien memanggil metode ini, sistem akan melakukan pencarian SDP untuk menemukan perangkat jarak jauh dengan UUID yang cocok. Jika pencarian berhasil dan perangkat jarak jauh menerima koneksi, perangkat tersebut akan membagikan saluran RFCOMM untuk digunakan selama koneksi, dan metode connect() akan ditampilkan. Jika koneksi gagal, atau jika waktu tunggu metode connect() habis (setelah sekitar 12 detik), metode akan menampilkan IOException.

Karena connect() adalah panggilan pemblokiran, Anda harus selalu melakukan prosedur koneksi ini di thread yang terpisah dari thread aktivitas utama (UI).

Contoh

Berikut adalah contoh dasar thread klien yang memulai koneksi Bluetooth:

Kotlin

private inner class ConnectThread(device: BluetoothDevice) : Thread() {

   private val mmSocket: BluetoothSocket? by lazy(LazyThreadSafetyMode.NONE) {
       device.createRfcommSocketToServiceRecord(MY_UUID)
   }

   public override fun run() {
       // Cancel discovery because it otherwise slows down the connection.
       bluetoothAdapter?.cancelDiscovery()

       mmSocket?.let { socket ->
           // Connect to the remote device through the socket. This call blocks
           // until it succeeds or throws an exception.
           socket.connect()

           // The connection attempt succeeded. Perform work associated with
           // the connection in a separate thread.
           manageMyConnectedSocket(socket)
       }
   }

   // Closes the client socket and causes the thread to finish.
   fun cancel() {
       try {
           mmSocket?.close()
       } catch (e: IOException) {
           Log.e(TAG, "Could not close the client socket", e)
       }
   }
}

Java

private class ConnectThread extends Thread {
   private final BluetoothSocket mmSocket;
   private final BluetoothDevice mmDevice;

   public ConnectThread(BluetoothDevice device) {
       // Use a temporary object that is later assigned to mmSocket
       // because mmSocket is final.
       BluetoothSocket tmp = null;
       mmDevice = device;

       try {
           // Get a BluetoothSocket to connect with the given BluetoothDevice.
           // MY_UUID is the app's UUID string, also used in the server code.
           tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
       } catch (IOException e) {
           Log.e(TAG, "Socket's create() method failed", e);
       }
       mmSocket = tmp;
   }

   public void run() {
       // Cancel discovery because it otherwise slows down the connection.
       bluetoothAdapter.cancelDiscovery();

       try {
           // Connect to the remote device through the socket. This call blocks
           // until it succeeds or throws an exception.
           mmSocket.connect();
       } catch (IOException connectException) {
           // Unable to connect; close the socket and return.
           try {
               mmSocket.close();
           } catch (IOException closeException) {
               Log.e(TAG, "Could not close the client socket", closeException);
           }
           return;
       }

       // The connection attempt succeeded. Perform work associated with
       // the connection in a separate thread.
       manageMyConnectedSocket(mmSocket);
   }

   // Closes the client socket and causes the thread to finish.
   public void cancel() {
       try {
           mmSocket.close();
       } catch (IOException e) {
           Log.e(TAG, "Could not close the client socket", e);
       }
   }
}

Perhatikan bahwa dalam cuplikan ini, cancelDiscovery() dipanggil sebelum upaya koneksi terjadi. Anda harus selalu memanggil cancelDiscovery() sebelum connect(), terutama karena cancelDiscovery() berhasil, terlepas dari apakah penemuan perangkat sedang berlangsung atau tidak. Jika aplikasi Anda perlu menentukan apakah penemuan perangkat sedang berlangsung, Anda dapat memeriksa menggunakan isDiscovering().

Metode manageMyConnectedSocket() khusus aplikasi dirancang untuk memulai thread untuk mentransfer data, yang dibahas di bagian tentang mentransfer data Bluetooth.

Setelah selesai dengan BluetoothSocket, selalu panggil close(). Tindakan ini akan segera menutup soket yang terhubung dan merilis semua resource internal terkait.