เชื่อมต่ออุปกรณ์บลูทูธ

หากต้องการสร้างการเชื่อมต่อระหว่างอุปกรณ์ 2 เครื่อง คุณต้องใช้ทั้งกลไกฝั่งเซิร์ฟเวอร์และฝั่งไคลเอ็นต์ เนื่องจากอุปกรณ์เครื่องหนึ่งต้องเปิดซ็อกเก็ตเซิร์ฟเวอร์ และอีกเครื่องหนึ่งต้องเริ่มการเชื่อมต่อโดยใช้ที่อยู่ MAC ของอุปกรณ์เซิร์ฟเวอร์ อุปกรณ์เซิร์ฟเวอร์และอุปกรณ์ไคลเอ็นต์แต่ละเครื่องจะได้รับ BluetoothSocket ที่จำเป็นด้วยวิธีที่แตกต่างกัน เซิร์ฟเวอร์จะได้รับข้อมูลซ็อกเก็ตเมื่อยอมรับการเชื่อมต่อขาเข้า ไคลเอ็นต์จะให้ข้อมูลซ็อกเก็ตเมื่อเปิดช่องทาง RFCOMM ไปยังเซิร์ฟเวอร์

ระบบจะถือว่าเซิร์ฟเวอร์และไคลเอ็นต์เชื่อมต่อกันเมื่อแต่ละฝ่ายมี BluetoothSocket ที่เชื่อมต่อในช่อง RFCOMM เดียวกัน เมื่อถึงจุดนี้ อุปกรณ์แต่ละเครื่องจะรับสตรีมอินพุตและเอาต์พุตได้ และการโอนข้อมูลจะเริ่มขึ้น ซึ่งจะอธิบายไว้ในส่วนเกี่ยวกับการโอนข้อมูลบลูทูธ ส่วนนี้จะอธิบายวิธีเริ่มต้นการเชื่อมต่อระหว่างอุปกรณ์ 2 เครื่อง

ตรวจสอบว่าคุณมีสิทธิ์เข้าถึงบลูทูธที่เหมาะสมและตั้งค่าแอปสำหรับบลูทูธก่อนที่จะพยายามค้นหาอุปกรณ์บลูทูธ

เทคนิคการเชื่อมต่อ

เทคนิคการติดตั้งใช้งานอย่างหนึ่งคือการเตรียมอุปกรณ์แต่ละเครื่องให้เป็นเซิร์ฟเวอร์โดยอัตโนมัติ เพื่อให้อุปกรณ์แต่ละเครื่องมีซ็อกเก็ตเซิร์ฟเวอร์ที่เปิดอยู่และคอยฟังการเชื่อมต่อ ในกรณีนี้ อุปกรณ์เครื่องใดเครื่องหนึ่งสามารถเริ่มการเชื่อมต่อกับอีกเครื่องหนึ่งและกลายเป็นไคลเอ็นต์ได้ หรืออุปกรณ์เครื่องหนึ่งสามารถโฮสต์การเชื่อมต่อและเปิดซ็อกเก็ตเซิร์ฟเวอร์ตามต้องการอย่างชัดเจน และอุปกรณ์อีกเครื่องหนึ่งจะเริ่มการเชื่อมต่อ

กล่องโต้ตอบการจับคู่บลูทูธที่แจ้งให้ผู้ใช้จับคู่กับอุปกรณ์
รูปที่ 1 กล่องโต้ตอบการจับคู่บลูทูธ

เชื่อมต่อในฐานะเซิร์ฟเวอร์

เมื่อต้องการเชื่อมต่ออุปกรณ์ 2 เครื่อง อุปกรณ์เครื่องหนึ่งต้องทำหน้าที่เป็นเซิร์ฟเวอร์โดยเปิด BluetoothServerSocket ไว้ วัตถุประสงค์ของซ็อกเก็ตเซิร์ฟเวอร์คือการรอฟังคำขอการเชื่อมต่อขาเข้าและจัดหา BluetoothSocket ที่เชื่อมต่อหลังจากยอมรับคำขอแล้ว เมื่อได้รับ BluetoothSocket จาก BluetoothServerSocket แล้ว คุณสามารถและควรทิ้ง BluetoothServerSocket เว้นแต่คุณต้องการให้อุปกรณ์ยอมรับการเชื่อมต่อเพิ่มเติม

หากต้องการตั้งค่าซ็อกเก็ตเซิร์ฟเวอร์และยอมรับการเชื่อมต่อ ให้ทำตามลำดับขั้นตอนต่อไปนี้

  1. รับ BluetoothServerSocket โดยโทรไปที่ listenUsingRfcommWithServiceRecord(String, UUID)

    สตริงคือชื่อที่ระบุได้ของบริการ ซึ่งระบบจะเขียนลงในรายการฐานข้อมูล Service Discovery Protocol (SDP) ใหม่บนอุปกรณ์โดยอัตโนมัติ ชื่อนี้เป็นชื่อที่กำหนดเองและอาจเป็นชื่อแอปของคุณก็ได้ นอกจากนี้ Universally Unique Identifier (UUID) ยังรวมอยู่ในรายการ SDP และเป็นพื้นฐานสำหรับข้อตกลงการเชื่อมต่อกับอุปกรณ์ไคลเอ็นต์ กล่าวคือ เมื่อไคลเอ็นต์พยายามเชื่อมต่อกับอุปกรณ์นี้ ไคลเอ็นต์จะมี UUID ที่ระบุบริการที่ต้องการเชื่อมต่อโดยไม่ซ้ำกัน UUID เหล่านี้ต้องตรงกันเพื่อให้ระบบยอมรับการเชื่อมต่อ

    UUID คือรูปแบบ 128 บิตที่ได้มาตรฐานสำหรับรหัสสตริงที่ใช้เพื่อระบุข้อมูลที่ไม่ซ้ำกัน UUID ใช้เพื่อระบุข้อมูลที่ต้องไม่ซ้ำกันภายในระบบหรือเครือข่าย เนื่องจากโอกาสที่ UUID จะซ้ำกันนั้นแทบจะเป็นศูนย์ โดยสร้างขึ้นอย่างอิสระโดยไม่ต้องใช้หน่วยงานกลาง ในกรณีนี้ ระบบจะใช้เพื่อระบุบริการบลูทูธของแอปโดยไม่ซ้ำกัน หากต้องการรับ UUID เพื่อใช้กับแอป คุณสามารถใช้เครื่องมือสร้าง UUID แบบสุ่มที่มีอยู่มากมายบนเว็บ จากนั้นเริ่มต้น UUID ด้วย fromString(String)

  2. เริ่มรอรับคำขอการเชื่อมต่อโดยเรียกใช้ accept()

    การดำเนินการนี้เป็นการเรียกใช้แบบบล็อก โดยจะแสดงผลเมื่อยอมรับการเชื่อมต่อหรือเกิดข้อยกเว้น ระบบจะยอมรับการเชื่อมต่อก็ต่อเมื่ออุปกรณ์ระยะไกลส่งคำขอเชื่อมต่อที่มี UUID ตรงกับ UUID ที่ลงทะเบียนไว้กับซ็อกเก็ตเซิร์ฟเวอร์ที่รอรับการเชื่อมต่อนี้ เมื่อดำเนินการสำเร็จ accept() จะแสดงผล BluetoothSocket ที่เชื่อมต่อ

  3. เว้นแต่คุณต้องการยอมรับการเชื่อมต่อเพิ่มเติม ให้เรียกใช้ close()

    การเรียกใช้เมธอดนี้จะปล่อยซ็อกเก็ตเซิร์ฟเวอร์และทรัพยากรทั้งหมด แต่จะไม่ปิด BluetoothSocket ที่เชื่อมต่อซึ่งแสดงผลโดย accept() RFCOMM ต่างจาก TCP/IP ตรงที่อนุญาตให้มีไคลเอ็นต์ที่เชื่อมต่อได้เพียง 1 รายต่อช่องสัญญาณในแต่ละครั้ง ดังนั้นในกรณีส่วนใหญ่ การเรียก close() ใน BluetoothServerSocket ทันทีหลังจากยอมรับซ็อกเก็ตที่เชื่อมต่อจึงเป็นเรื่องที่สมเหตุสมผล

เนื่องจากการเรียก accept() เป็นการเรียกที่บล็อก จึงไม่ควรเรียกใช้ในเธรด UI ของกิจกรรมหลัก การดำเนินการในชุดข้อความอื่นช่วยให้มั่นใจว่าแอปจะยังคงตอบสนองต่อการโต้ตอบอื่นๆ ของผู้ใช้ได้ โดยปกติแล้ว การทำงานทั้งหมดที่เกี่ยวข้องกับ BluetoothServerSocket หรือ BluetoothSocket ในเทรดใหม่ที่จัดการโดยแอปของคุณจะเหมาะสมกว่า หากต้องการยกเลิกการเรียกที่ถูกบล็อก เช่น accept() ให้เรียก close() ใน BluetoothServerSocket หรือ BluetoothSocket จากเทรดอื่น โปรดทราบว่าเมธอดทั้งหมดใน BluetoothServerSocket หรือ BluetoothSocket เป็นแบบ Thread-safe

ตัวอย่าง

ต่อไปนี้เป็นชุดข้อความแบบง่ายสำหรับคอมโพเนนต์เซิร์ฟเวอร์ที่ยอมรับการเชื่อมต่อขาเข้า

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

ในตัวอย่างนี้ ต้องการการเชื่อมต่อขาเข้าเพียงรายการเดียว ดังนั้นทันทีที่ยอมรับการเชื่อมต่อและได้รับ BluetoothSocket แอปจะส่ง BluetoothSocket ที่ได้รับไปยังชุดข้อความแยกต่างหาก ปิด BluetoothServerSocket และออกจากลูป

โปรดทราบว่าเมื่อ accept() แสดงผล BluetoothSocket ซ็อกเก็ตจะเชื่อมต่ออยู่แล้ว ดังนั้น คุณจึงไม่ควรเรียกใช้ connect() เหมือนที่ทำจากฝั่งไคลเอ็นต์

เมธอด manageMyConnectedSocket() สำหรับแอปโดยเฉพาะได้รับการออกแบบมาเพื่อเริ่มต้นชุดข้อความสำหรับการโอนข้อมูล ซึ่งจะกล่าวถึงในหัวข้อเกี่ยวกับการโอนข้อมูลบลูทูธ

โดยปกติแล้ว คุณควรปิด BluetoothServerSocket ทันทีที่ฟังการเชื่อมต่อขาเข้าเสร็จแล้ว ในตัวอย่างนี้ ระบบจะเรียกใช้ close() ทันทีที่ได้รับ BluetoothSocket นอกจากนี้ คุณอาจต้องระบุเมธอดสาธารณะในเธรดที่สามารถปิด BluetoothSocket ส่วนตัวได้ในกรณีที่คุณต้องหยุดฟังในซ็อกเก็ตเซิร์ฟเวอร์นั้น

เชื่อมต่อในฐานะลูกค้า

หากต้องการเริ่มต้นการเชื่อมต่อกับอุปกรณ์ระยะไกลที่ยอมรับการเชื่อมต่อในซ็อกเก็ตเซิร์ฟเวอร์แบบเปิด คุณต้องรับออบเจ็กต์ BluetoothDevice ที่แสดงถึงอุปกรณ์ระยะไกลก่อน ดูวิธีสร้าง BluetoothDevice ได้ที่หัวข้อค้นหาอุปกรณ์บลูทูธ จากนั้นคุณต้องใช้ BluetoothDevice เพื่อรับ BluetoothSocket และเริ่มการเชื่อมต่อ

ขั้นตอนพื้นฐานมีดังนี้

  1. ใช้ BluetoothDevice เพื่อรับ BluetoothSocket โดยโทรไปที่ createRfcommSocketToServiceRecord(UUID)

    เมธอดนี้จะเริ่มต้นออบเจ็กต์ BluetoothSocket ที่ช่วยให้ไคลเอ็นต์เชื่อมต่อกับ BluetoothDevice ได้ UUID ที่ส่งที่นี่ต้องตรงกับ UUID ที่อุปกรณ์เซิร์ฟเวอร์ใช้เมื่อเรียกใช้ listenUsingRfcommWithServiceRecord(String, UUID) เพื่อเปิด BluetoothServerSocket หากต้องการใช้ UUID ที่ตรงกัน ให้ฮาร์ดโค้ดสตริง UUID ลงในแอป แล้วอ้างอิงจากทั้งโค้ดฝั่งเซิร์ฟเวอร์และฝั่งไคลเอ็นต์

  2. เริ่มการเชื่อมต่อโดยโทรหา connect() โปรดทราบว่าเมธอดนี้เป็นการเรียกแบบบล็อก

    หลังจากไคลเอ็นต์เรียกใช้เมธอดนี้ ระบบจะทำการค้นหา SDP เพื่อค้นหาอุปกรณ์ระยะไกลที่มี UUID ที่ตรงกัน หากการค้นหาสำเร็จและอุปกรณ์ระยะไกลยอมรับการเชื่อมต่อ อุปกรณ์จะแชร์ช่อง RFCOMM เพื่อใช้ระหว่างการเชื่อมต่อ และเมธอด connect() จะแสดงผล หากการเชื่อมต่อไม่สำเร็จหรือเมธอด connect() หมดเวลา (หลังจากผ่านไปประมาณ 12 วินาที) เมธอดจะแสดง IOException

เนื่องจาก connect() เป็นการเรียกใช้แบบบล็อก คุณจึงควรดำเนินการตามขั้นตอนการเชื่อมต่อนี้ในเธรดที่แยกจากเธรดกิจกรรมหลัก (UI) เสมอ

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างพื้นฐานของชุดข้อความไคลเอ็นต์ที่เริ่มต้นการเชื่อมต่อบลูทูธ

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

โปรดทราบว่าในข้อมูลโค้ดนี้ ระบบจะเรียกใช้ cancelDiscovery() ก่อนที่จะพยายามเชื่อมต่อ คุณควรเรียกใช้ cancelDiscovery() ก่อน connect() เสมอ โดยเฉพาะอย่างยิ่งเนื่องจาก cancelDiscovery() จะทำงานสำเร็จไม่ว่าการค้นหาอุปกรณ์จะดำเนินอยู่หรือไม่ก็ตาม หากแอปของคุณต้องการตรวจสอบว่าการค้นหาอุปกรณ์กำลังดำเนินอยู่หรือไม่ คุณสามารถตรวจสอบได้โดยใช้ isDiscovering()

เมธอด manageMyConnectedSocket() สำหรับแอปโดยเฉพาะได้รับการออกแบบมาเพื่อเริ่มต้นชุดข้อความสำหรับการโอนข้อมูล ซึ่งจะกล่าวถึงในส่วนเกี่ยวกับการโอนข้อมูลบลูทูธ

เมื่อคุณทำBluetoothSocketเสร็จแล้ว ให้โทรหาclose()เสมอ การดำเนินการนี้จะปิดซ็อกเก็ตที่เชื่อมต่อทันทีและปล่อยทรัพยากรภายในที่เกี่ยวข้องทั้งหมด