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
iriikeita
kennethanceyer
shouth
ryounasso
masuda220
hiroya0601
twada
ivargrimstad
hiro_xre
nrslib
yanagii
taiyow
eileencodes
geeforr
cassininazir
nonsquared
garrettdimon
mojombo
lynnandtonic
holman
speakerdeck
philhawksworth
jrom
