Kết nối thiết bị Bluetooth

Để tạo kết nối giữa hai thiết bị, bạn phải triển khai cả cơ chế phía máy chủ và phía máy khách vì một thiết bị phải mở điểm cuối máy chủ và thiết bị còn lại phải bắt đầu kết nối bằng địa chỉ MAC của thiết bị máy chủ. Thiết bị máy chủ và thiết bị máy khách đều nhận được BluetoothSocket cần thiết theo nhiều cách. Máy chủ nhận được thông tin về cổng khi chấp nhận một kết nối đến. Ứng dụng cung cấp thông tin về cổng kết nối khi mở kênh RFCOMM đến máy chủ.

Máy chủ và ứng dụng được coi là kết nối với nhau khi mỗi máy chủ và ứng dụng đều có một BluetoothSocket được kết nối trên cùng một kênh RFCOMM. Tại thời điểm này, mỗi thiết bị có thể lấy luồng đầu vào và đầu ra, đồng thời có thể bắt đầu chuyển dữ liệu. Điều này được thảo luận trong phần chuyển dữ liệu Bluetooth. Phần này mô tả cách bắt đầu kết nối giữa hai thiết bị.

Đảm bảo bạn có quyền Bluetooth thích hợp và thiết lập ứng dụng cho Bluetooth trước khi cố gắng tìm thiết bị Bluetooth.

Kỹ thuật kết nối

Một kỹ thuật triển khai là tự động chuẩn bị từng thiết bị làm máy chủ để mỗi thiết bị đều có một điểm cuối máy chủ mở và lắng nghe các kết nối. Trong trường hợp này, một trong hai thiết bị có thể bắt đầu kết nối với thiết bị còn lại và trở thành ứng dụng. Ngoài ra, một thiết bị có thể lưu trữ kết nối một cách rõ ràng và mở một điểm cuối máy chủ theo yêu cầu, còn thiết bị kia sẽ bắt đầu kết nối.

Hộp thoại ghép nối Bluetooth nhắc người dùng ghép nối với một thiết bị.
Hình 1. Hộp thoại ghép nối Bluetooth.

Kết nối với tư cách là máy chủ

Khi bạn muốn kết nối hai thiết bị, một thiết bị phải đóng vai trò là máy chủ bằng cách giữ một BluetoothServerSocket đang mở. Mục đích của điểm cuối máy chủ là theo dõi các yêu cầu kết nối đến và cung cấp một BluetoothSocket đã kết nối sau khi yêu cầu được chấp nhận. Khi BluetoothSocket được lấy từ BluetoothServerSocket, bạn có thể (và nên) loại bỏ BluetoothServerSocket, trừ phi bạn muốn thiết bị chấp nhận thêm kết nối.

Để thiết lập điểm cuối máy chủ và chấp nhận kết nối, hãy hoàn thành trình tự các bước sau:

  1. Nhận BluetoothServerSocket bằng cách gọi listenUsingRfcommWithServiceRecord(String, UUID).

    Chuỗi này là tên có thể nhận dạng của dịch vụ mà hệ thống tự động ghi vào một mục nhập cơ sở dữ liệu mới của Giao thức khám phá dịch vụ (SDP) trên thiết bị. Tên này là tuỳ ý và có thể chỉ đơn giản là tên ứng dụng của bạn. Giá trị nhận dạng riêng biệt chung (UUID) cũng được đưa vào mục SDP và tạo cơ sở cho thoả thuận kết nối với thiết bị khách. Tức là khi ứng dụng khách cố gắng kết nối với thiết bị này, ứng dụng khách sẽ mang theo một UUID giúp xác định duy nhất dịch vụ mà ứng dụng khách muốn kết nối. Các UUID này phải khớp với nhau thì kết nối mới được chấp nhận.

    UUID là định dạng 128 bit chuẩn hoá cho mã nhận dạng chuỗi dùng để nhận dạng thông tin một cách riêng biệt. UUID được dùng để xác định thông tin cần phải là duy nhất trong một hệ thống hoặc mạng vì xác suất UUID bị lặp lại gần như bằng không. Nó được tạo độc lập mà không cần sử dụng một cơ quan quản lý tập trung. Trong trường hợp này, mã nhận dạng này được dùng để xác định duy nhất dịch vụ Bluetooth của ứng dụng. Để lấy mã nhận dạng duy nhất (UUID) dùng cho ứng dụng, bạn có thể sử dụng một trong nhiều trình tạo UUID ngẫu nhiên trên web, sau đó khởi động mã nhận dạng duy nhất (UUID) bằng fromString(String).

  2. Bắt đầu theo dõi các yêu cầu kết nối bằng cách gọi accept().

    Đây là lệnh gọi chặn. Phương thức này trả về khi một kết nối được chấp nhận hoặc khi xảy ra ngoại lệ. Kết nối chỉ được chấp nhận khi thiết bị từ xa đã gửi yêu cầu kết nối chứa UUID khớp với UUID đã đăng ký với điểm cuối máy chủ nghe này. Khi thành công, accept() sẽ trả về một BluetoothSocket đã kết nối.

  3. Trừ phi bạn muốn chấp nhận các kết nối khác, hãy gọi close().

    Lệnh gọi phương thức này sẽ giải phóng điểm cuối máy chủ và tất cả tài nguyên của điểm cuối, nhưng không đóng BluetoothSocket đã kết nối được accept() trả về. Không giống như TCP/IP, RFCOMM chỉ cho phép một ứng dụng khách được kết nối trên mỗi kênh tại một thời điểm, vì vậy, trong hầu hết các trường hợp, bạn nên gọi close() trên BluetoothServerSocket ngay sau khi chấp nhận một ổ cắm đã kết nối.

Vì lệnh gọi accept() là lệnh gọi chặn, nên đừng thực thi lệnh gọi này trong luồng giao diện người dùng của hoạt động chính. Việc thực thi trong một luồng khác đảm bảo rằng ứng dụng của bạn vẫn có thể phản hồi các hoạt động tương tác khác của người dùng. Thông thường, bạn nên thực hiện tất cả công việc liên quan đến BluetoothServerSocket hoặc BluetoothSocket trong một luồng mới do ứng dụng quản lý. Để huỷ một lệnh gọi bị chặn (chẳng hạn như accept()), hãy gọi close() trên BluetoothServerSocket hoặc BluetoothSocket từ một luồng khác. Xin lưu ý rằng tất cả phương thức trên BluetoothServerSocket hoặc BluetoothSocket đều an toàn cho luồng.

Ví dụ

Sau đây là một luồng đơn giản cho thành phần máy chủ chấp nhận các kết nối đến:

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

Trong ví dụ này, chỉ có một kết nối đến được mong muốn, vì vậy, ngay khi kết nối được chấp nhận và BluetoothSocket được thu nạp, ứng dụng sẽ chuyển BluetoothSocket đã thu nạp sang một luồng riêng, đóng BluetoothServerSocket và thoát khỏi vòng lặp.

Lưu ý rằng khi accept() trả về BluetoothSocket, ổ cắm đã được kết nối. Do đó, bạn không nên gọi connect() như khi gọi từ phía máy khách.

Phương thức manageMyConnectedSocket() dành riêng cho ứng dụng được thiết kế để bắt đầu luồng chuyển dữ liệu, được thảo luận trong chủ đề về chuyển dữ liệu Bluetooth.

Thông thường, bạn nên đóng BluetoothServerSocket ngay khi hoàn tất việc nghe các kết nối đến. Trong ví dụ này, close() được gọi ngay khi có được BluetoothSocket. Bạn cũng nên cung cấp một phương thức công khai trong luồng của mình để có thể đóng BluetoothSocket riêng tư trong trường hợp bạn cần ngừng nghe trên điểm cuối máy chủ đó.

Kết nối với tư cách là khách hàng

Để bắt đầu kết nối với một thiết bị từ xa đang chấp nhận kết nối trên một điểm cuối máy chủ đang mở, trước tiên, bạn phải có được một đối tượng BluetoothDevice đại diện cho thiết bị từ xa đó. Để tìm hiểu cách tạo BluetoothDevice, hãy xem phần Tìm thiết bị Bluetooth. Sau đó, bạn phải sử dụng BluetoothDevice để lấy BluetoothSocket và bắt đầu kết nối.

Quy trình cơ bản như sau:

  1. Sử dụng BluetoothDevice, lấy BluetoothSocket bằng cách gọi createRfcommSocketToServiceRecord(UUID).

    Phương thức này khởi chạy một đối tượng BluetoothSocket cho phép ứng dụng kết nối với BluetoothDevice. UUID được truyền ở đây phải khớp với UUID mà thiết bị máy chủ sử dụng khi gọi listenUsingRfcommWithServiceRecord(String, UUID) để mở BluetoothServerSocket. Để sử dụng UUID phù hợp, hãy cố định giá trị trong mã chuỗi UUID vào ứng dụng, sau đó tham chiếu chuỗi đó từ cả mã máy chủ và mã ứng dụng.

  2. Bắt đầu kết nối bằng cách gọi connect(). Xin lưu ý rằng phương thức này là một lệnh gọi chặn.

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

Vì connect() là một lệnh gọi chặn, nên bạn phải luôn thực hiện quy trình kết nối này trong một luồng tách biệt với luồng hoạt động chính (giao diện người dùng).

Ví dụ

Sau đây là ví dụ cơ bản về một luồng ứng dụng khởi tạo kết nối 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);
       }
   }
}

Lưu ý rằng trong đoạn mã này, cancelDiscovery() được gọi trước khi nỗ lực kết nối xảy ra. Bạn phải luôn gọi cancelDiscovery() trước connect(), đặc biệt là vì cancelDiscovery() thành công bất kể quá trình khám phá thiết bị có đang diễn ra hay không. Nếu ứng dụng của bạn cần xác định xem quá trình khám phá thiết bị có đang diễn ra hay không, bạn có thể kiểm tra bằng cách sử dụng isDiscovering().

Phương thức manageMyConnectedSocket() dành riêng cho ứng dụng được thiết kế để bắt đầu luồng chuyển dữ liệu, được thảo luận trong phần chuyển dữ liệu Bluetooth.

Khi bạn hoàn tất BluetoothSocket, hãy luôn gọi close(). Thao tác này sẽ ngay lập tức đóng cổng kết nối và giải phóng tất cả tài nguyên nội bộ có liên quan.