โอนข้อมูลบลูทูธ

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

1. ดาวน์โหลดInputStreamและ OutputStream ที่ดูแลการรับส่งข้อมูล ผ่านซ็อกเก็ตโดยใช้ getInputStream() และ getOutputStream() ตามลำดับ

2. อ่านและเขียนข้อมูลไปยังสตรีมโดยใช้ read(byte[]) และ write(byte[])

ซึ่งมีรายละเอียดการใช้งานที่ต้องพิจารณา โดยเฉพาะอย่างยิ่ง คุณ ควรใช้ชุดข้อความเฉพาะสำหรับการอ่านจากสตรีมและเขียนไปยังสตรีมดังกล่าว ซึ่งเป็นสิ่งสำคัญเพราะทั้งเมธอด read(byte[]) และ write(byte[]) กำลังบล็อกการโทร เมธอด read(byte[]) จะบล็อกจนกว่าจะมีเงื่อนไขที่ อ่านจากสตรีม ปกติแล้วเมธอด write(byte[]) จะไม่บล็อก แต่ สามารถบล็อกการควบคุมโฟลว์ได้ถ้าอุปกรณ์ระยะไกลไม่เรียก read(byte[]) ให้เร็วพอและผลให้บัฟเฟอร์ระดับกลางจะเต็ม คุณ ควรระบุลูปหลักของคุณในชุดข้อความเฉพาะสำหรับการอ่านจาก InputStream คุณสามารถใช้วิธีสาธารณะแยกต่างหากในชุดข้อความเพื่อเริ่มเขียนไปยัง OutputStream

ตัวอย่าง

ตัวอย่างวิธีโอนข้อมูลระหว่างอุปกรณ์ 2 เครื่องมีดังนี้ เชื่อมต่อผ่านบลูทูธ

private const val TAG = "MY_APP_DEBUG_TAG"

// Defines several constants used when transmitting messages between the
// service and the UI.
const val MESSAGE_READ: Int = 0
const val MESSAGE_WRITE: Int = 1
const val MESSAGE_TOAST: Int = 2
// ... (Add other message types here as needed.)

class MyBluetoothService(
       // handler that gets info from Bluetooth service
       private val handler: Handler) {

   private inner class ConnectedThread(private val mmSocket: BluetoothSocket) : Thread() {

       private val mmInStream: InputStream = mmSocket.inputStream
       private val mmOutStream: OutputStream = mmSocket.outputStream
       private val mmBuffer: ByteArray = ByteArray(1024) // mmBuffer store for the stream

       override fun run() {
           var numBytes: Int // bytes returned from read()

           // Keep listening to the InputStream until an exception occurs.
           while (true) {
               // Read from the InputStream.
               numBytes = try {
                   mmInStream.read(mmBuffer)
               } catch (e: IOException) {
                   Log.d(TAG, "Input stream was disconnected", e)
                   break
               }

               // Send the obtained bytes to the UI activity.
               val readMsg = handler.obtainMessage(
                       MESSAGE_READ, numBytes, -1,
                       mmBuffer)
               readMsg.sendToTarget()
           }
       }

       // Call this from the main activity to send data to the remote device.
       fun write(bytes: ByteArray) {
           try {
               mmOutStream.write(bytes)
           } catch (e: IOException) {
               Log.e(TAG, "Error occurred when sending data", e)

               // Send a failure message back to the activity.
               val writeErrorMsg = handler.obtainMessage(MESSAGE_TOAST)
               val bundle = Bundle().apply {
                   putString("toast", "Couldn't send data to the other device")
               }
               writeErrorMsg.data = bundle
               handler.sendMessage(writeErrorMsg)
               return
           }

           // Share the sent message with the UI activity.
           val writtenMsg = handler.obtainMessage(
                   MESSAGE_WRITE, -1, -1, mmBuffer)
           writtenMsg.sendToTarget()
       }

       // Call this method from the main activity to shut down the connection.
       fun cancel() {
           try {
               mmSocket.close()
           } catch (e: IOException) {
               Log.e(TAG, "Could not close the connect socket", e)
           }
       }
   }
}

public class MyBluetoothService {
   private static final String TAG = "MY_APP_DEBUG_TAG";
   private Handler handler; // handler that gets info from Bluetooth service

   // Defines several constants used when transmitting messages between the
   // service and the UI.
   private interface MessageConstants {
       public static final int MESSAGE_READ = 0;
       public static final int MESSAGE_WRITE = 1;
       public static final int MESSAGE_TOAST = 2;

       // ... (Add other message types here as needed.)
   }

   private class ConnectedThread extends Thread {
       private final BluetoothSocket mmSocket;
       private final InputStream mmInStream;
       private final OutputStream mmOutStream;
       private byte[] mmBuffer; // mmBuffer store for the stream

       public ConnectedThread(BluetoothSocket socket) {
           mmSocket = socket;
           InputStream tmpIn = null;
           OutputStream tmpOut = null;

           // Get the input and output streams; using temp objects because
           // member streams are final.
           try {
               tmpIn = socket.getInputStream();
           } catch (IOException e) {
               Log.e(TAG, "Error occurred when creating input stream", e);
           }
           try {
               tmpOut = socket.getOutputStream();
           } catch (IOException e) {
               Log.e(TAG, "Error occurred when creating output stream", e);
           }

           mmInStream = tmpIn;
           mmOutStream = tmpOut;
       }

       public void run() {
           mmBuffer = new byte[1024];
           int numBytes; // bytes returned from read()

           // Keep listening to the InputStream until an exception occurs.
           while (true) {
               try {
                   // Read from the InputStream.
                   numBytes = mmInStream.read(mmBuffer);
                   // Send the obtained bytes to the UI activity.
                   Message readMsg = handler.obtainMessage(
                           MessageConstants.MESSAGE_READ, numBytes, -1,
                           mmBuffer);
                   readMsg.sendToTarget();
               } catch (IOException e) {
                   Log.d(TAG, "Input stream was disconnected", e);
                   break;
               }
           }
       }

       // Call this from the main activity to send data to the remote device.
       public void write(byte[] bytes) {
           try {
               mmOutStream.write(bytes);

               // Share the sent message with the UI activity.
               Message writtenMsg = handler.obtainMessage(
                       MessageConstants.MESSAGE_WRITE, -1, -1, mmBuffer);
               writtenMsg.sendToTarget();
           } catch (IOException e) {
               Log.e(TAG, "Error occurred when sending data", e);

               // Send a failure message back to the activity.
               Message writeErrorMsg =
                       handler.obtainMessage(MessageConstants.MESSAGE_TOAST);
               Bundle bundle = new Bundle();
               bundle.putString("toast",
                       "Couldn't send data to the other device");
               writeErrorMsg.setData(bundle);
               handler.sendMessage(writeErrorMsg);
           }
       }

       // Call this method from the main activity to shut down the connection.
       public void cancel() {
           try {
               mmSocket.close();
           } catch (IOException e) {
               Log.e(TAG, "Could not close the connect socket", e);
           }
       }
   }
}

หลังจากที่เครื่องมือสร้างได้สตรีมที่จำเป็นแล้ว เทรดจะรอข้อมูล ต้องผ่าน InputStream เมื่อ read(byte[]) แสดงผลพร้อมข้อมูลจาก สตรีม ระบบจะส่งข้อมูลไปยังกิจกรรมหลักโดยใช้สมาชิก Handler จากชั้นเรียนหลัก ชุดข้อความ จากนั้นจะรอให้มีการอ่านไบต์จาก InputStream เพิ่ม

หากต้องการส่งข้อมูลขาออก ให้เรียกใช้เมธอด write() ของชุดข้อความจาก กิจกรรมและส่งต่อในจำนวนไบต์ที่จะส่ง วิธีนี้เรียกใช้ write(byte[]) ไปยัง ส่งข้อมูลไปยังอุปกรณ์ระยะไกล หากมี ระบบโยน IOException ขณะโทร write(byte[]) ชุดข้อความจะส่งข้อความโทสต์ไปยังกิจกรรมหลักเพื่ออธิบายกับ ผู้ใช้ที่อุปกรณ์ไม่สามารถส่งไบต์ที่ระบุไปให้อีกเครื่องได้ อุปกรณ์ (เชื่อมต่อแล้ว)

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

สำหรับการสาธิตการใช้ Bluetooth API โปรดดูตัวอย่าง Bluetooth Chat แอป ใน GitHub