Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR) • 2.4 GHz band • 79ch frequency-hopping spread spectrum • main/follower architecture (1-to-max 7) • Widely used to connect digital devices and exchange information
compatible with Bluetooth Classic • 2.4 GHz band • 40ch frequency-hopping spread spectrum • Very low power consumption • main/follower architecture (1 to N*) * unde fi ned or implementation dependent
is made val socket: Socket = serverSocket.accept() val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made val socket: Socket = serverSocket.accept() val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made val socket: Socket = serverSocket.accept() val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made val socket: Socket = serverSocket.accept() val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made socket.connect( InetSocketAddress(wifiP2pInfo.groupOwnerAddress, SOCKET_PORT), SOCKET_TIMEOUT ) val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made socket.connect( InetSocketAddress(wifiP2pInfo.groupOwnerAddress, SOCKET_PORT), SOCKET_TIMEOUT ) val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made socket.connect( InetSocketAddress(wifiP2pInfo.groupOwnerAddress, SOCKET_PORT), SOCKET_TIMEOUT ) val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
is made socket.connect( InetSocketAddress(wifiP2pInfo.groupOwnerAddress, SOCKET_PORT), SOCKET_TIMEOUT ) val inputStream: InputStream = socket.getInputStream() val outputStream: OutputStream = socket.getOutputStream()
boundary • Messages may be sent and received in batches • If you keep the socket open and continue the bidirectional communication, you need a protocol. For example, put the message length in the fi rst few bytes.
= message.toByteArray(StandardCharsets.UTF_8) val length = messageBytes.size val lengthBytes = ByteBuffer.allocate(4).putInt(length).array() // writing the length of the message write(lengthBytes) // writing the message delimiter val delimiterBytes = ByteBuffer.allocate(2).putChar(':').array() write(delimiterBytes) // writing the message itself write(messageBytes) }
= message.toByteArray(StandardCharsets.UTF_8) val length = messageBytes.size val lengthBytes = ByteBuffer.allocate(4).putInt(length).array() // writing the length of the message write(lengthBytes) // writing the message delimiter val delimiterBytes = ByteBuffer.allocate(2).putChar(':').array() write(delimiterBytes) // writing the message itself write(messageBytes) }
= message.toByteArray(StandardCharsets.UTF_8) val length = messageBytes.size val lengthBytes = ByteBuffer.allocate(4).putInt(length).array() // writing the length of the message write(lengthBytes) // writing the message delimiter val delimiterBytes = ByteBuffer.allocate(2).putChar(':').array() write(delimiterBytes) // writing the message itself write(messageBytes) }
- 1) / BUFFER_SIZE var totalBytes = 0 val messageBuffer = ByteArray(length) for (i in 0 until pageSize) { val limit = if (i == pageSize - 1) length - totalBytes else BUFFER_SIZE val incomingBytes = inputStream.read(INCOMING_BUFF, 0, limit) System.arraycopy(INCOMING_BUFF, 0, messageBuffer, totalBytes, incomingBytes) totalBytes += incomingBytes Log.d(TAG, "read(): totalBytes after reading = $totalBytes") }
- 1) / BUFFER_SIZE var totalBytes = 0 val messageBuffer = ByteArray(length) for (i in 0 until pageSize) { val limit = if (i == pageSize - 1) length - totalBytes else BUFFER_SIZE val incomingBytes = inputStream.read(INCOMING_BUFF, 0, limit) System.arraycopy(INCOMING_BUFF, 0, messageBuffer, totalBytes, incomingBytes) totalBytes += incomingBytes Log.d(TAG, "read(): totalBytes after reading = $totalBytes") }
- 1) / BUFFER_SIZE var totalBytes = 0 val messageBuffer = ByteArray(length) for (i in 0 until pageSize) { val limit = if (i == pageSize - 1) length - totalBytes else BUFFER_SIZE val incomingBytes = inputStream.read(INCOMING_BUFF, 0, limit) System.arraycopy(INCOMING_BUFF, 0, messageBuffer, totalBytes, incomingBytes) totalBytes += incomingBytes Log.d(TAG, "read(): totalBytes after reading = $totalBytes") }
an access point on all devices that support Wi-Fi • Once the connection is established, it is simple TCP socket communication. Both text and binary can be sent and received • Pro's and con's to other wireless communications will be discussed later
cation for Bluetooth-based communication between device • Headset • Advanced Audio Distribution Pro fi le (A2DP) • Health Device • https://developer.android.com/guide/topics/connectivity/bluetooth/ pro fi les • This talk will NOT cover those topics
• In the OSI reference model, it is roughly equivalent to the data link layer (layer 2) • RFCOMM (Radio Frequency Communication) • A protocol that emulates the RS-232C serial port on an L2CAP. • It has packet reception con fi rmation and retransmission like TCP. • In the OSI reference model, it is roughly equivalent to the transport layer (layer 4) • RFCOMM sockets are the most common way to communicate in Android's Bluetooth API
form a main/follower relationship • Peripheral can include a small amount of payload in advertised packets e.g.) iBeacon • After connection, Central and Peripheral communicate using a method called GATT (Generic ATTribute pro le)
Central reads and writes data to and from the Peripheral • Peripheral is essentially a sensor device • A Peripheral has one or more Services. This speci es what functions the peripheral provides • A Service provides one or more Characteristics. This expresses the characteristics of the service.
Central with 4.3 or later • Android can serve as Peripheral with 5.0 or later • What's the point for Android to become Peripheral? I don't know🤷 The idea is up to you!
supported on this device return } val bluetoothManager = getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager val bluetoothAdapter = bluetoothManager.adapter if (bluetoothAdapter == null) { // Bluetooth is not supported on this device return }
true) if (!setCharacteristicNotificationResult) { return } val descriptorSetValueResult = descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE) if (!descriptorSetValueResult) { return } val writeDescriptorResult = bluetoothGatt.writeDescriptor(descriptor) if (!writeDescriptorResult) { return }
true) if (!setCharacteristicNotificationResult) { return } val descriptorSetValueResult = descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE) if (!descriptorSetValueResult) { return } val writeDescriptorResult = bluetoothGatt.writeDescriptor(descriptor) if (!writeDescriptorResult) { return }
true) if (!setCharacteristicNotificationResult) { return } val descriptorSetValueResult = descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE) if (!descriptorSetValueResult) { return } val writeDescriptorResult = bluetoothGatt.writeDescriptor(descriptor) if (!writeDescriptorResult) { return }
BluetoothGattDescriptor.PERMISSION_READ or BluetoothGattDescriptor.PERMISSION_WRITE ) val bluetoothGattCharacteristic = BluetoothGattCharacteristic( UUID_CHARACTERISTIC, BluetoothGattCharacteristic.PROPERTY_READ or BluetoothGattCharacteristic.PROPERTY_WRITE or BluetoothGattCharacteristic.PROPERTY_NOTIFY, BluetoothGattDescriptor.PERMISSION_WRITE or BluetoothGattCharacteristic.PERMISSION_READ )
// This device does not support BLE Peripheral mode. return bluetoothLeAdvertiser.startAdvertising( settingsBuilder.build(), dataBuilder.build(), responseBuilder.build(), advertiseCallback )
basic scenario, and I intentionally dropped important concept, MTU • Requests for larger MTU can be made easily, But there is no guarantee that the request will be accepted • How to handle messages larger than MTU • Central approach • Peripheral approach
Central to Peripheral is relatively straight forward bluetoothGatt.writeCharacteristic(bluetoothGattCharacteristic) • If you try to send a message with more than MTU, the Android framework will automatically try to split the message • In other words, as long as you know how to do it right, this is not dif fi cult to accomplish • This is handled by BluetoothGattServerCallback on Peripheral side
called after all preparedWrites are finished override fun onExecuteWrite(device: BluetoothDevice, requestId: Int, execute: Boolean) { super.onExecuteWrite(device, requestId, execute) val bytes = byteArrayOutputStream.toByteArray() byteArrayOutputStream.reset() val message = String(bytes, StandardCharsets.UTF_8) ... }
using Noti fi cation to send messages from Peripheral, but Noti fi cation cannot send messages larger than MTU • Noti fi cation does not automatically split messages • We need to split and send messages on our own • The minimum MTU seems to be about 20-23 bytes, but write code so that it works even if it changes dynamically depending on the situation
fi ne a protocol • The fi rst byte is the total number of chunks • The next byte is the current index of the total chunk • The remaining bytes are the payload
MIN_MTU = 20 // This will be overridden later when the exact value is known private var currentMTU = MIN_MTU override fun onMtuChanged(device: BluetoothDevice, mtu: Int) { super.onMtuChanged(device, mtu) currentMTU = mtu }
ensure that all operations are sequential • Read the of fi cial site documentation properly and make sure you return the response you need • Avoiding the infamous GATT_ERROR(133) is not a matter of needless retries or unfounded SLEEP!
.# fi MF .# 4FD ,# 4FD • TL;DR Wi-Fi is incomparably faster! • Between two Pixel 3a XL • Distance between the two units is 50cm • Average of 50 A to B and 50 B to A runs each (total 100 runs)
shows that Wi-Fi has a high packet reachability rate over long distances • Between Pixel 3a XL and BLU90 • Distance between the two units is 1, 5, 10, 20, and 30m • The graph shows the success rate of packet transmission at each distance
frequency hopping is resistant to network congestion • Decent pairing speed. Wi-Fi Direct takes a few seconds to a dozen seconds before they can connect to each other, while Bluetooth Classic takes 1-2 seconds or less
Classic had the fastest packet arrival time over short to medium distances • Between Pixel 3a XL and BLU90 • Distance between the two units is 1, 5, 10, 20, and 30m • The graph shows the TTL of packet arrival at each distance. The lower the line is located, the faster it is
peer-to-peer networking API that allows apps to easily discover, connect to, and exchange data with nearby devices in real-time, regardless of network connectivity❞ • It supports multiple network topologies such as peer-to-peer, star, and mesh, depending on the purpose • Looks like the kind of wireless communication we talked about in today's talk will be used under the hood.
srym
seike460
krpk1900
mikik0
oheyadam
riofujimon
afilina
gam0022
azuki
kno3a87
cer
syumai
keavy
panda_program
lauravandoore
addyosmani
sergeychernyshev
erikaheidi
reverentgeek
sstephenson
paigeccino
keithpitt
tanoku
morganepeng
