העברת נתוני Bluetooth

לאחר שהתחברתם בהצלחה ל-Bluetooth מכשיר, כל אחד לאחד מהם יש חיבור BluetoothSocket. מעכשיו אפשר לשתף מידע בין מכשירים. באמצעות BluetoothSocket, כדי להעביר את הנתונים:

1. משתמשים ב-InputStream OutputStream שמטפל בשידורים דרך השקע באמצעות getInputStream() וגם getOutputStream(), בהתאמה.

2. קריאה וכתיבה של נתונים במקורות הנתונים באמצעות read(byte[]) ו- write(byte[])

כמובן שיש להביא בחשבון את פרטי ההטמעה. באופן ספציפי, צריך להשתמש בשרשור ייעודי לקריאה מהזרם ולכתיבה אליו. הפעולה הזו חשובה כי גם השיטה read(byte[]) וגם השיטה write(byte[]) חוסמים שיחות. שיטת read(byte[]) חוסמת עד שיש משהו לקרוא מהזרם. השיטה write(byte[]) לא חוסמת בדרך כלל, אבל היא אפשרות לחסום לבקרת זרימה אם המכשיר המחובר לרשת אחרת לא שולח קריאה אל read(byte[]) מספיק מהר וכתוצאה מכך, מאגרי הנתונים הזמניים יתמלאו. אז אתם צריך להקצות את הלולאה הראשית בשרשור לקריאה מה-InputStream. אפשר להשתמש בשיטה ציבורית נפרדת בשרשור כדי להתחיל כתיבה OutputStream

דוגמה

הדוגמה הבאה מראה איך מעבירים נתונים בין שני מכשירים מחובר באמצעות Bluetooth:

Kotlin

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

Java

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

אחרי שה-constructor מקבל את הזרמים הדרושים, ה-thread ממתין לנתונים כדי לעבור דרך InputStream. כאשר הערך של read(byte[]) מוחזר עם נתונים מ: הזרם, הנתונים נשלחים לפעילות הראשית באמצעות חבר Handler מכיתת ההורה. השרשור לאחר מכן ימתין לקריאת בייטים נוספים מה-InputStream.

כדי לשלוח נתונים יוצאים צריך להפעיל את השיטה write() של השרשור הראשי פעילות ולהעביר את הבייטים שיישלחו. השיטה הזו מפעילה את write(byte[]) ל- שליחת הנתונים למכשיר המרוחק. אם המספר IOException יישלף במהלך ביצוע השיחה write(byte[]), השרשור שולח הודעה חיונית לפעילות הראשית, כדי להסביר למשתמש שהמכשיר לא הצליח לשלוח את הבייטים הנתונים מכשיר (מחובר).

השיטה cancel() של השרשור מאפשרת לסיים את החיבור בכל שלב הזמן על ידי סגירת BluetoothSocket. יש להפעיל את השיטה הזו תמיד לאחר שמסיימים באמצעות חיבור ה-Bluetooth.

להדגמת השימוש בממשקי Bluetooth API, ראו דוגמה ל-Bluetooth Chat אפליקציה ב-GitHub.