หากต้องการสร้างการเชื่อมต่อระหว่างอุปกรณ์ 2 เครื่อง คุณต้องใช้ทั้งกลไกฝั่งเซิร์ฟเวอร์และฝั่งไคลเอ็นต์ เนื่องจากอุปกรณ์เครื่องหนึ่งต้องเปิดซ็อกเก็ตเซิร์ฟเวอร์ และอีกเครื่องหนึ่งต้องเริ่มการเชื่อมต่อโดยใช้ที่อยู่ MAC ของอุปกรณ์เซิร์ฟเวอร์ อุปกรณ์เซิร์ฟเวอร์และอุปกรณ์ไคลเอ็นต์แต่ละเครื่องจะได้รับ BluetoothSocket ที่จำเป็นด้วยวิธีที่แตกต่างกัน เซิร์ฟเวอร์จะได้รับข้อมูลซ็อกเก็ตเมื่อยอมรับการเชื่อมต่อขาเข้า ไคลเอ็นต์จะให้ข้อมูลซ็อกเก็ตเมื่อเปิดช่องทาง RFCOMM ไปยังเซิร์ฟเวอร์
ระบบจะถือว่าเซิร์ฟเวอร์และไคลเอ็นต์เชื่อมต่อกันเมื่อแต่ละฝ่ายมี BluetoothSocket ที่เชื่อมต่อในช่อง RFCOMM เดียวกัน เมื่อถึงจุดนี้ อุปกรณ์แต่ละเครื่องจะรับสตรีมอินพุตและเอาต์พุตได้ และการโอนข้อมูลจะเริ่มขึ้น ซึ่งจะอธิบายไว้ในส่วนเกี่ยวกับการโอนข้อมูลบลูทูธ ส่วนนี้จะอธิบายวิธีเริ่มต้นการเชื่อมต่อระหว่างอุปกรณ์ 2 เครื่อง
ตรวจสอบว่าคุณมีสิทธิ์เข้าถึงบลูทูธที่เหมาะสมและตั้งค่าแอปสำหรับบลูทูธก่อนที่จะพยายามค้นหาอุปกรณ์บลูทูธ
เทคนิคการเชื่อมต่อ
เทคนิคการติดตั้งใช้งานอย่างหนึ่งคือการเตรียมอุปกรณ์แต่ละเครื่องให้เป็นเซิร์ฟเวอร์โดยอัตโนมัติ เพื่อให้อุปกรณ์แต่ละเครื่องมีซ็อกเก็ตเซิร์ฟเวอร์ที่เปิดอยู่และคอยฟังการเชื่อมต่อ ในกรณีนี้ อุปกรณ์เครื่องใดเครื่องหนึ่งสามารถเริ่มการเชื่อมต่อกับอีกเครื่องหนึ่งและกลายเป็นไคลเอ็นต์ได้ หรืออุปกรณ์เครื่องหนึ่งสามารถโฮสต์การเชื่อมต่อและเปิดซ็อกเก็ตเซิร์ฟเวอร์ตามต้องการอย่างชัดเจน และอุปกรณ์อีกเครื่องหนึ่งจะเริ่มการเชื่อมต่อ
เชื่อมต่อในฐานะเซิร์ฟเวอร์
เมื่อต้องการเชื่อมต่ออุปกรณ์ 2 เครื่อง อุปกรณ์เครื่องหนึ่งต้องทำหน้าที่เป็นเซิร์ฟเวอร์โดยเปิด BluetoothServerSocket ไว้
วัตถุประสงค์ของซ็อกเก็ตเซิร์ฟเวอร์คือการรอฟังคำขอการเชื่อมต่อขาเข้าและจัดหา BluetoothSocket ที่เชื่อมต่อหลังจากยอมรับคำขอแล้ว เมื่อได้รับ BluetoothSocket จาก BluetoothServerSocket แล้ว คุณสามารถและควรทิ้ง BluetoothServerSocket เว้นแต่คุณต้องการให้อุปกรณ์ยอมรับการเชื่อมต่อเพิ่มเติม
หากต้องการตั้งค่าซ็อกเก็ตเซิร์ฟเวอร์และยอมรับการเชื่อมต่อ ให้ทำตามลำดับขั้นตอนต่อไปนี้
รับ
BluetoothServerSocketโดยโทรไปที่listenUsingRfcommWithServiceRecord(String, UUID)สตริงคือชื่อที่ระบุได้ของบริการ ซึ่งระบบจะเขียนลงในรายการฐานข้อมูล Service Discovery Protocol (SDP) ใหม่บนอุปกรณ์โดยอัตโนมัติ ชื่อนี้เป็นชื่อที่กำหนดเองและอาจเป็นชื่อแอปของคุณก็ได้ นอกจากนี้ Universally Unique Identifier (UUID) ยังรวมอยู่ในรายการ SDP และเป็นพื้นฐานสำหรับข้อตกลงการเชื่อมต่อกับอุปกรณ์ไคลเอ็นต์ กล่าวคือ เมื่อไคลเอ็นต์พยายามเชื่อมต่อกับอุปกรณ์นี้ ไคลเอ็นต์จะมี UUID ที่ระบุบริการที่ต้องการเชื่อมต่อโดยไม่ซ้ำกัน UUID เหล่านี้ต้องตรงกันเพื่อให้ระบบยอมรับการเชื่อมต่อ
UUID คือรูปแบบ 128 บิตที่ได้มาตรฐานสำหรับรหัสสตริงที่ใช้เพื่อระบุข้อมูลที่ไม่ซ้ำกัน UUID ใช้เพื่อระบุข้อมูลที่ต้องไม่ซ้ำกันภายในระบบหรือเครือข่าย เนื่องจากโอกาสที่ UUID จะซ้ำกันนั้นแทบจะเป็นศูนย์ โดยสร้างขึ้นอย่างอิสระโดยไม่ต้องใช้หน่วยงานกลาง ในกรณีนี้ ระบบจะใช้เพื่อระบุบริการบลูทูธของแอปโดยไม่ซ้ำกัน หากต้องการรับ UUID เพื่อใช้กับแอป คุณสามารถใช้เครื่องมือสร้าง
UUIDแบบสุ่มที่มีอยู่มากมายบนเว็บ จากนั้นเริ่มต้น UUID ด้วยfromString(String)เริ่มรอรับคำขอการเชื่อมต่อโดยเรียกใช้
accept()การดำเนินการนี้เป็นการเรียกใช้แบบบล็อก โดยจะแสดงผลเมื่อยอมรับการเชื่อมต่อหรือเกิดข้อยกเว้น ระบบจะยอมรับการเชื่อมต่อก็ต่อเมื่ออุปกรณ์ระยะไกลส่งคำขอเชื่อมต่อที่มี UUID ตรงกับ UUID ที่ลงทะเบียนไว้กับซ็อกเก็ตเซิร์ฟเวอร์ที่รอรับการเชื่อมต่อนี้ เมื่อดำเนินการสำเร็จ
accept()จะแสดงผลBluetoothSocketที่เชื่อมต่อเว้นแต่คุณต้องการยอมรับการเชื่อมต่อเพิ่มเติม ให้เรียกใช้
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 และเริ่มการเชื่อมต่อ
ขั้นตอนพื้นฐานมีดังนี้
ใช้
BluetoothDeviceเพื่อรับBluetoothSocketโดยโทรไปที่createRfcommSocketToServiceRecord(UUID)เมธอดนี้จะเริ่มต้นออบเจ็กต์
BluetoothSocketที่ช่วยให้ไคลเอ็นต์เชื่อมต่อกับBluetoothDeviceได้ UUID ที่ส่งที่นี่ต้องตรงกับ UUID ที่อุปกรณ์เซิร์ฟเวอร์ใช้เมื่อเรียกใช้listenUsingRfcommWithServiceRecord(String, UUID)เพื่อเปิดBluetoothServerSocketหากต้องการใช้ UUID ที่ตรงกัน ให้ฮาร์ดโค้ดสตริง UUID ลงในแอป แล้วอ้างอิงจากทั้งโค้ดฝั่งเซิร์ฟเวอร์และฝั่งไคลเอ็นต์เริ่มการเชื่อมต่อโดยโทรหา
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()เสมอ การดำเนินการนี้จะปิดซ็อกเก็ตที่เชื่อมต่อทันทีและปล่อยทรัพยากรภายในที่เกี่ยวข้องทั้งหมด