Blog

Chào các bạn, hôm nay mình tiếp tục chuỗi bài liên quan đến Bluetooth Classic trong Android. Bài hôm nay mình tập trung vào phần Transfer Bluetooth Data.

Sau khi bạn đã kết nối thành công với thiết bị Bluetooth, mỗi thiết bị có một BluetoothSocket được kết nối. Sau đó bạn có thể chia sẻ thông tin giữa các thiết bị bằng cách thông qua đối tượng BluetoothSocket, về cơ bản các bước đọc ghi dữ, để truyền dữ liệu như sau:

• Get InputStream và OutputStream xử lý truyền qua Socket bằng cách sử dụng getInputStream() và getOutputStream() tương ứng.
• Đọc và ghi dữ liệu vào các luồng sử dụng read(byte[]) và write(byte[]).

Mình sẽ tạo một ví dụ minh hoạ, với ứng dụng Chat giữa client và server bằng Bluetooth Classic.

Đầu tiên chúng ta tạo một Object chứa phương thức đọc, ghi. Xử lý Read, Write thông qua 2 object InputStream và OutputStream.

private val bluetoothAdapter: BluetoothAdapter = adapter
private val handler: Handler = mHandler

private lateinit var bluetoothSending: BluetoothSending

inner class BluetoothSending(bluetoothSocket: BluetoothSocket?) : Thread() {

    private val inputStream: InputStream?
    private val outputStream: OutputStream?

    init {
        var tempIn: InputStream? = null
        var tempOut: OutputStream? = null
        try {
            tempIn = bluetoothSocket?.inputStream
            tempOut = bluetoothSocket?.outputStream
        } catch (e: IOException) {
            e.printStackTrace()
        }
        inputStream = tempIn
        outputStream = tempOut
    }

    override fun run() {
        val buffer = ByteArray(1024)
        var bytes: Int

        // Keep listening to the InputStream until an exception occurs.
        while (true) {
            try {
                bytes = inputStream?.read(buffer)!!
                handler.obtainMessage(Contstants.STATE_MESSAGE_RECEIVED, bytes, -1, buffer)
                    .sendToTarget()
            } catch (e: IOException) {
                Log.e("PhongPN", "Bluetooth Reading Data Error", e)
                e.printStackTrace()
            }
        }
    }

    fun write(bytes: ByteArray?) {
        try {
            outputStream?.write(bytes)
        } catch (e: IOException) {
            Log.e("PhongPN", "Bluetooth Writing Data Error", e)
            e.printStackTrace()
        }
    }
}

Tiếp đến chúng ta tạo một Server Socket. Lắng nghe các kết nối đến nó.

inner class ServerClass : Thread() {

    private var serverSocket: BluetoothServerSocket? = null

    init {
        try {
            serverSocket =
                bluetoothAdapter.listenUsingRfcommWithServiceRecord(
                    "PhongPN Transfer Data Bluetooth Classic", UUID.fromString(
                        Contstants.UUID
                    )
                )
        } catch (e: IOException) {
            Log.e("PhongPN", "Could not listen RFCOMM Sockets", e)
            e.printStackTrace()
        }
    }

    override fun run() {
        var socket: BluetoothSocket? = null
        while (socket == null) {
            try {
                val message = Message.obtain()
                message.what = Contstants.STATE_CONNECTING
                handler.sendMessage(message)
                socket = serverSocket?.accept()
            } catch (e: IOException) {
                e.printStackTrace()
                val message = Message.obtain()
                message.what = Contstants.STATE_CONNECTION_FAILED
                handler.sendMessage(message)
            }
            if (socket != null) {
                val message = Message.obtain()
                message.what = Contstants.STATE_CONNECTED
                handler.sendMessage(message)
                bluetoothSending = BluetoothSending(socket)
                bluetoothSending.start()
                break
            }
        }
    }

    fun cancel() {
        try {
            serverSocket?.close()
        } catch (e: IOException) {
            Log.e("PhongPN", "Could not close the connect socket", e)
            e.printStackTrace()
        }
    }
}

Cuối cùng, chúng ta tạo một Client tương tác và trao đổi dữ liệu với Server Socket.

inner class ClientClass(device: BluetoothDevice) : Thread() {

    private var socket: BluetoothSocket? = null

    init {
        try {
            socket = device.createRfcommSocketToServiceRecord(UUID.fromString(Contstants.UUID))
        } catch (e: IOException) {
            Log.e("PhongPN", "Could not create RFCOMM Sockets", e)
            e.printStackTrace()
        }
    }

    override fun run() {
        try {
            socket?.connect()
            val message = Message.obtain()
            message.what = Contstants.STATE_CONNECTED
            handler.sendMessage(message)
            bluetoothSending = BluetoothSending(socket)
            bluetoothSending.start()
        } catch (e: IOException) {
            e.printStackTrace()
            val message = Message.obtain()
            message.what = Contstants.STATE_CONNECTION_FAILED
            handler.sendMessage(message)
        }
    }

    fun cancel() {
        try {
            socket?.close()
        } catch (e: IOException) {
            Log.e("PhongPN", "Could not close the connect socket", e)
            e.printStackTrace()
        }
    }
}

Chúng ta xử lý send data tới nơi hiển thị dữ liệu (View) qua đối tượng Handle.

private val handler: Handler = object : Handler(Looper.getMainLooper()) {
    override fun handleMessage(message: Message) {
        when (message.what) {
            Contstants.STATE_LISTENING -> binding.txtStatus.text = "Listening"
            Contstants.STATE_CONNECTING -> binding.txtStatus.text = "Connecting"
            Contstants.STATE_CONNECTED -> binding.txtStatus.text = "Connected"
            Contstants.STATE_CONNECTION_FAILED -> binding.txtStatus.text = "Connection Failed"
            Contstants.STATE_MESSAGE_RECEIVED -> {
                val readBuff = message.obj as ByteArray
                val tempMsg = String(readBuff, 0, message.arg1)
                binding.txtReceivedMessage.text = tempMsg
            }
        }
    }
}

Các bạn chú ý là phương thức close() của luồng cho phép bạn chấm dứt kết nối bất kỳ lúc nào bằng cách đóng BluetoothSocket. Các nên gọi phương thức này khi bạn sử dụng xong kết nối Bluetooth. Vì thế trong 2 class client vs server mình luôn có 2 hàm đó để sẵn sàng trong việc đóng kết nối.

Trên đây là chuỗi bài viết của mình liên quan đến Bluetooth Classic trong Android. Mong đâu đấy chút chia sẻ của mình có thế giúp mọi người có cái nhìn sơ qua về Bluetooth Classic, cũng như là có thể ít nhiều giúp các bạn nếu có gặp phải bài toán liên quan đến nó trong tương lai.

Cảm ơn mọi người đã theo dõi. Hẹn gặp lại trong các bài viết sắp tới.

Chào các bạn, hôm nay mình tiếp tục chuỗi bài liên quan đến Bluetooth Classic trong Android. Bài hôm nay mình tập trung vào phần Connect giữa các thiết bị Bluetooth.

Để tạo kết nối Bluetooth giữa 2 thiết bị chúng ta cần thiết lập lập kết nối giống như việc kết nối giữa máy chủ (Server) và máy khách (Client). Chúng giao tiếp với nhau thông qua RFCOMM sockets, cụ thể thông qua đối tượng BluetoothSocket Socket trong Android. Cơ chế như nhau, máy khách (Client) cung cấp Socket information khi nó mở một RFCOMM Channel đến máy chủ (Server), máy chủ (Server) nhận Socket information khi kết nối đến được Accept. Server và Client được coi là đã kết nối với nhau khi chúng có một BluetoothSocket được kết nối trên cùng một kênh RFCOMM.

Có 2 kết nối mà bạn cần quan tâm khi tạo Connect trong Bluetooth Classic

• Connect như là một Client
• Connect như là một Server

Với từng bài toán, từng requirement cụ thể thì ta sẽ sử dụng chúng theo cách phù hợp.

1. Connect như là một Client

   Cách connect đầu tiên này thường dùng cho bài toán kết nối với một thiết bị Bluetooth có sẵn. Từ đó kết nối, điều khiển, transfer dữ liệu với thiết bị đó. Đầu tiên bạn phải có được một đối tượng BluetoothDevice đại diện cho thiết bị Bluetooth. Đây là công đoạn bạn Scan (Discovery) và lấy thông thiên của thiết bị. Sau đó, bạn phải sử dụng BluetoothDevice để có được BluetoothSocket và bắt đầu kết nối.

   Các bước cụ thể như sau:

   1. Tạo một BluetoothSocket (RFCOMM Sockets) từ BluetoothDevice bằng cách gọi hàm createRfcommSocketToServiceRecord(UUID). Các bạn có hiểu UUID là một mã string, kiểu như một Port Number. Mã này của Client truyền vào hàm này, phải khớp với mã UUID mà máy chủ cấp. Thường với bài toán kết nối với thiết bị Bluetooth, thì thiết bị Bluetooth có cung cấp một chuỗi UUID chuẩn để ứng dụng có thể fix cứng dưới code và gửi lên khi tạo connect.

   2. Gọi BluetoothSocket.connect(). Sau khi gọi hàm, hệ thống sẽ thực hiện tra cứu SDP để tìm thiết bị từ xa có UUID phù hợp. Nếu tìm kiếm và khớp thành công và thiết bị từ xa chấp nhận kết nối, nó sẽ chia sẻ kênh RFCOMM để sử dụng trong quá trình kết nối và trả về phương thức connect(). Nếu kết nối không thành công hoặc nếu phương thức connect() timeout (sau khoảng 12 giây), thì phương thức này sẽ đưa ra một IOException. Bạn có thể tham khảo mã code sau

      class BluetoothClassicConnection(device: BluetoothDevice): Thread() {
      
      private val bluetoothSocket: BluetoothSocket? by lazy {
          device.createRfcommSocketToServiceRecord(UUID)
      }
      
      override fun run() {
          // Cancel discovery because it otherwise slows down the connection.
          if (BluetoothAdapter.getDefaultAdapter()?.isDiscovering == true) {
              BluetoothAdapter.getDefaultAdapter()?.cancelDiscovery()
          }
      
          try {
              bluetoothSocket?.let { socket ->
                  socket.connect()
      
                  // Handle Transfer Data 
              }
          } catch (e: IOException) {
              try {
                  bluetoothSocket?.close()
              } catch (e: IOException) {
                  Log.e(TAG, "Could not close the client socket", e)
              }
              Log.e(TAG, "Could not connect", e)
          }
      }
      
      // Closes the client socket and causes the thread to finish.
      fun cancel() {
          try {
              bluetoothSocket?.close()
          } catch (e: IOException) {
              Log.e(TAG, "Could not close the client socket", e)
          }
      }
      
      companion object {
          private const val UUID = "UUID code provide from Server Site"
       }
      }
      

   Note:

   • Việc duy trì kết nối Bluetooth Classic khá tốn tài nguyên của máy, đặc biệt như là PIN. Các bạn cần lưu ý đóng socket khi không cần dùng nữa, bằng cách gọi close() của đối tượng BluetoothSocket. Sau khi gọi Socket sẽ ngay lực tức được đóng lại và giải phóng tất cả các tài nguyên nội bộ có liên quan.
   • Chú ý đến việc huỷ Discovery() trước khi kết nối để đảm bảo việc connect được diễn ra thành công.

2. Connect như một Server

   Với loại connect này được thực hiện nếu bạn muốn connect 2 thiết bị devices với nhau. Một thiết bị trong 2 thiết bị đó phải hoạt động như một Server bằng cách nắm giữ BluetoothServerSocket. Cụ thể BluetoothServerSocket lắng nghe các kết nối, sử dụng để thu nhận kết nối bluetoothSocket (RFCOMM sockets). Khi kết nối được thiết lập, máy chủ socket không còn cần thiết nữa và có thể đóng lại thông qua hàm close().

   Các bước cụ thể như sau:

   1. Lấy thông tin BluetoothServerSocket bằng cách gọi hàm listenUsingRfcommWithServiceRecord(String, UUID).

   2. Bắt đầu lắng nghe các yêu cầu kết nối bằng cách gọi accept(). Khi thành công, accept() trả về BluetoothSocket được kết nối và sau đó chúng ta sẽ sử dụng nó để trao đổi dữ liệu với thiết bị kết nối.

      class BluetoothClassicServerConnection: Thread() {
      private val serverSocket: BluetoothServerSocket? by lazy {
          BluetoothAdapter.getDefaultAdapter()?.listenUsingInsecureRfcommWithServiceRecord(NAME, UUID)
      }
      
      private var bluetoothSocket: BluetoothSocket? = null
      
      override fun run() {
          // Keep listening until exception occurs or a socket is returned.
          var shouldLoop = true
      
          while (shouldLoop) {
              val socket: BluetoothSocket? = try {
                  bluetoothSocket = serverSocket?.accept()
              } catch (e: IOException) {
                  Log.e(TAG, "Socket's accept() method failed", e)
                  shouldLoop = false
                  null
              }
              socket?.also {
                  
                  // Handle Transfer Data  
      
                  serverSocket?.close()
                  shouldLoop = false
              }
          }
      }
      
      // Closes the connect socket and causes the thread to finish.
      fun cancel() {
          try {
              serverSocket?.close()
          } catch (e: IOException) {
              Log.e(TAG, "Could not close the connect socket", e)
          }
      }
      
      companion object {
          private const val NAME = "The name we provide the service with when it is added to the SDP (Service Discovery Protocol)"
          private const val UUID = "UUID code provide from Server Site"
        }
      }
      

   Note:

   • Khi call accept() trả về BluetoothSocket, Socket đã được kết nối. Vì vậy, không nên gọi connect(), giống như mình làm ở phía Client.

Vậy là mình cũng vừa trình bày xong phần liên quan đến Connect Bluetooth Classic trong Android. Các loại và các trường hợp sử dụng nó. Bài tiếp theo mình sẽ trình bày về việc Transfer Data (Read and Write) của Bluetooth Classic.

Hẹn gặp lại các bạn trong bài viết sắp tới.

Tiếp tục trong chuỗi bài liên quan đến Bluetooth Classic trong Android. Mình xin chia sẻ phần liên quan đến Tìm kiếm (Scanning – Discovery) và Enable discoverability thiết bị.

1. Tìm kiếm (Scanning – Discovery) thiết bị Bluetooth

   Để bắt đầu tìm kiếm (Scanning) thiết bị, hàm startDiscovery() thông qua đối tượng BluetoothAdapter được gọi. Quá trình này bất đồng bộ (asynchronous) và trả về một giá trị boolean cho biết quá trình discovery đã bắt đầu thành công hay chưa. Theo như mình tìm hiểu thì quá trình scan thường được truy vấn trong khoảng 12 giây, sau đó hiển thị output lên màn hình hoặc nơi hiển thị kết quả.

   Để nhận thông tin về từng thiết bị được quét (tìm thấy) thành công, ứng dụng của bạn phải register một BroadcastReceiver với ACTION_FOUND intent. Hệ thống sẽ broadcasts intent này cho từng thiết bị. Trong intent này sẽ chứa công tin về device thông qua các extra fields như EXTRA_DEVICE và EXTRA_CLASS.

   Cụ thể:

class LegacyPairingFlowBluetoothDeviceReceiver(
    private val mListener: Listener
) : BroadcastReceiver() {

    companion object {
        private const val RESTART_DISCOVERY_DELAY = 5_000L // ms
    }

    private val handler = Handler(Looper.getMainLooper())
    private val restartDiscovery = Runnable {
        if (!cancelScan) {
            BluetoothAdapter.getDefaultAdapter()?.startDiscovery()
        }
    }

    var cancelScan: Boolean = false
        set(value) {
            field = value
            if (value) {
                handler.removeCallbacks(restartDiscovery)
            }
        }

    override fun onReceive(context: Context, intent: Intent) {
        val state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)
        if (state == BluetoothAdapter.STATE_ON && !cancelScan) {
            BluetoothAdapter.getDefaultAdapter()?.startDiscovery()
        }

        val action = intent.action
        if (BluetoothDevice.ACTION_FOUND == action) {
            val device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE) as? BluetoothDevice
            if (device != null) {
                mListener.onFoundBluetoothDevice(device)
            }
        } else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED == action) {
            mListener.onDiscoveryStarted()
        } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED == action) {
            if (!cancelScan) {
                handler.postDelayed(restartDiscovery, RESTART_DISCOVERY_DELAY)
            }
            mListener.onDiscoveryFinished()
        }

        if (BluetoothAdapter.STATE_ON == state) {
            mListener.onBluetoothStateOn()
        }
    }

    interface Listener {
        fun onFoundBluetoothDevice(device: BluetoothDevice)

        fun onDiscoveryStarted()

        fun onDiscoveryFinished()

        fun onBluetoothStateOn() {}
    }
}

Để bắt đầu kết nối với thiết bị Bluetooth, bạn gọi getAddress() của BluetoothDevice để truy xuất địa chỉ MAC được liên kết.

Note: Thực hiện tìm kiếm (gọi discovery) thiết bị tiêu tốn rất nhiều tài nguyên. Sau khi bạn đã tìm thấy một thiết bị để kết nối, hãy chắc chắn rằng bạn dừng việc tìm kiếm lại bằng function cancelDiscovery() trước khi thử connect với thiết bị đó. Ngoài ra, bạn không nên thực hiện tìm kiếm (gọi discovery) khi được kết nối với thiết bị vì quá trình tìm kiếm làm giảm đáng kể băng thông khả dụng cho bất kỳ kết nối hiện có.

2. Enable discoverability

   Nếu bạn chỉ cần kết nối từ ứng dụng của bạn với một thiết bị Bluetooth, transfer data với chúng thì bạn không cần phải Enable discoverability của thiết bị. Enable discoverability chỉ cần thiết khi bạn muốn ứng dụng của mình là một host a server socket chấp nhận các kết nối đến, vì các thiết bị Bluetooth phải có thể khám phá các thiết bị khác trước khi khởi động kết nối với các thiết bị khác.

   Để thực hiện điều đó, chúng ta gọi hàm startActivityForResult(Intent, int) với action Intent tương ứng là ACTION_REQUEST_DISCOVERABLE. Theo mặc định, thiết bị có thể được discover trong hai phút. Bạn có thể xác định thời lượng khác, tối đa một giờ, bằng cách thêm EXTRA_DISCOVERABLE_DURATION extra cho Intent đó.

    val requestCode = 1;
    val discoverableIntent: Intent = Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE).apply {
       putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 500)
    }
    startActivityForResult(discoverableIntent, requestCode)

Note: Nếu Bluetooth chưa được bật trên thiết bị, thì việc Enable discoverability sẽ tự động bật Bluetooth.

Bài tiếp theo mình sẽ trình bày về việc Connect và Transfer giữa ứng dụng và thiết bị Bluetooth. Hẹn gặp lại các bạn ở bài viết sắp tới.