Po połączeniu z urządzeniem Bluetooth każde z nich będzie miało połączone urządzenie BluetoothSocket. Teraz można udostępniać informacje
między urządzeniami. Ogólna procedura przenoszenia danych przy użyciu BluetoothSocket wygląda tak:
Pobierz parametry
InputStreamiOutputStream, które obsługują transmisję przez gniazdo, za pomocą odpowiedniogetInputStream()igetOutputStream().Odczytywanie i zapisywanie danych w strumieniach za pomocą usług
read(byte[])iwrite(byte[]).
Oczywiście trzeba wziąć pod uwagę szczegóły implementacji. W szczególności do czytania ze strumienia i pisania w nim używaj osobnego wątku.
To ważne, ponieważ metody read(byte[]) i write(byte[]) blokują połączenia. Metoda read(byte[]) blokuje się, dopóki ze strumienia nie będzie czegoś do odczytania. Metoda write(byte[]) zwykle nie blokuje się, ale może blokować kontrolę przepływu, jeśli urządzenie zdalne nie wywołuje funkcji read(byte[]) wystarczająco szybko, co spowoduje zapełnienie buforów pośrednich. Dlatego główna pętla w wątku powinna być przeznaczona do czytania z zasobów InputStream.
Do inicjowania zapisu w interfejsie OutputStream możesz używać w wątku osobnej metody publicznej.
Przykład
Poniżej znajdziesz przykład przenoszenia danych między dwoma urządzeniami połączonymi przez 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);
}
}
}
}
Gdy konstruktor pozyska niezbędne strumienie, wątek czeka na przekazanie danych przez InputStream. Gdy read(byte[]) zwraca dane ze strumienia, dane są wysyłane do głównej aktywności za pomocą użytkownika Handler z klasy nadrzędnej. Wątek czeka na odczytanie kolejnych bajtów z InputStream.
Aby wysyłać dane wychodzące, wywołujesz metodę write() wątku z głównej aktywności i przekazujesz bajty, które mają zostać wysłane. Ta metoda wywołuje metodę write(byte[]), aby wysłać dane na urządzenie zdalne. Jeśli podczas wywoływania metody write(byte[]) zostanie zgłoszony obiekt IOException, wątek wysyła tost do działania głównego, wyjaśniając użytkownikowi, że urządzenie nie może wysłać podanych bajtów do innego (połączonego) urządzenia.
Metoda cancel() wątku pozwala zakończyć połączenie w dowolnym momencie przez zamknięcie interfejsu BluetoothSocket. Zawsze wywołuj tę metodę
po zakończeniu połączenia Bluetooth.
Instrukcję korzystania z interfejsów API Bluetooth znajdziesz w przykładowej aplikacji do obsługi czatu Bluetooth w serwisie GitHub.