Une fois connecté à un appareil Bluetooth, chacun d'eux dispose d'un BluetoothSocket
connecté. Vous pouvez désormais partager des informations entre les appareils. Avec BluetoothSocket
, la procédure générale de transfert de données est la suivante:
Obtenez les
InputStream
etOutputStream
qui gèrent les transmissions via le socket à l'aide degetInputStream()
et degetOutputStream()
, respectivement.Lisez et écrivez des données dans les flux à l'aide de
read(byte[])
etwrite(byte[])
.
Vous devez bien sûr prendre en compte certains détails de l'implémentation. En particulier, vous devez utiliser un thread dédié pour lire le flux et y écrire.
Ce point est important, car les méthodes read(byte[])
et write(byte[])
bloquent les appels. La méthode read(byte[])
se bloque jusqu'à ce qu'il y ait quelque chose à lire dans le flux. La méthode write(byte[])
ne se bloque généralement pas, mais elle peut bloquer le contrôle de flux si l'appareil distant n'appelle pas read(byte[])
assez rapidement et que les tampons intermédiaires sont alors saturés. Vous devez donc dédier votre boucle principale dans le thread à la lecture à partir de InputStream
.
Vous pouvez utiliser une méthode publique distincte dans le thread pour lancer des écritures dans le OutputStream
.
Exemple
Voici un exemple de transfert de données entre deux appareils connectés via 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); } } } }
Une fois que le constructeur a acquis les flux nécessaires, le thread attend que les données passent par InputStream
. Lorsque read(byte[])
renvoie des données du flux, celles-ci sont envoyées à l'activité principale à l'aide d'un membre Handler
de la classe parente. Le thread attend ensuite que davantage d'octets soient lus à partir de InputStream
.
Pour envoyer des données sortantes, appelez la méthode write()
du thread à partir de l'activité principale et transmettez les octets à envoyer. Cette méthode appelle write(byte[])
pour envoyer les données à l'appareil distant. Si une IOException
est générée lors de l'appel de write(byte[])
, le thread envoie un toast à l'activité principale, expliquant à l'utilisateur que l'appareil n'a pas pu envoyer les octets donnés à l'autre appareil (connecté).
La méthode cancel()
du thread vous permet d'arrêter la connexion à tout moment en fermant le BluetoothSocket
. Appelez toujours cette méthode lorsque vous avez terminé d'utiliser la connexion Bluetooth.
Pour une démonstration de l'utilisation des API Bluetooth, consultez l'application exemple Chat Bluetooth sur GitHub.