Trasferire i dati Bluetooth

Dopo essersi connesso correttamente a un dispositivo Bluetooth dispositivo, ciascuno uno ha un BluetoothSocket Ora puoi condividere informazioni tra dispositivi. Con l'BluetoothSocket, le regole di trasferimento dei dati è la seguente:

1. Scarica InputStream e OutputStream che gestiscono le trasmissioni attraverso la presa usando getInputStream() e getOutputStream(), rispettivamente.

2. Leggere e scrivere dati nei flussi utilizzando read(byte[]) e write(byte[]).

Ci sono, ovviamente, i dettagli di implementazione da considerare. In particolare, dovresti usare un thread dedicato per leggere nello stream e scrivere. Questo è importante perché sia i metodi read(byte[]) che write(byte[]) bloccano le chiamate. Il metodo read(byte[]) si blocca finché non ci sono elementi da dal flusso. Il metodo write(byte[]) di solito non blocca, ma può bloccare il controllo del flusso se il dispositivo remoto non chiama read(byte[]) abbastanza rapidamente e, di conseguenza, i buffer intermedi si riempiono. Quindi, dedica il loop principale del thread alla lettura dall'InputStream. Puoi utilizzare un metodo pubblico separato nel thread per avviare scritture nel OutputStream.

Esempio

Di seguito è riportato un esempio di come è possibile trasferire dati tra due dispositivi connesso tramite Bluetooth:

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

Dopo che il costruttore ha acquisito i flussi necessari, il thread attende i dati provenienti da InputStream. Quando viene restituito read(byte[]) con i dati provenienti da lo stream, i dati vengono inviati all'attività principale utilizzando Handler del corso principale. Il thread quindi attende la lettura di altri byte da InputStream.

Per inviare dati in uscita, chiama il metodo write() del thread dall'interfaccia principale e passare i byte da inviare. Questo metodo chiama write(byte[]) a inviare i dati al dispositivo remoto. Se IOException viene lanciato durante la chiamata write(byte[]), il thread invia un toast all'attività principale, spiegando a all'utente che il dispositivo non ha potuto inviare i byte specificati all'altro dispositivo (connesso).

Il metodo cancel() del thread ti consente di terminare la connessione in qualsiasi volta chiudendo BluetoothSocket. Al termine, chiama sempre questo metodo usando la connessione Bluetooth.

Per una dimostrazione dell'utilizzo delle API Bluetooth, vedi l'esempio di chat Bluetooth app su GitHub.