Understanding Core Bluetooth and BLE MTU Size in iOS 16: A Cause for Concern?

Understanding Core Bluetooth and BLE MTU Size

Core Bluetooth (CB) is a framework developed by Apple for building Bluetooth Low Energy (BLE) applications on iOS, macOS, watchOS, and tvOS devices. One of the key aspects of CB is its support for BLE, which allows devices to communicate over short ranges using low-power radio frequencies.

BLE MTU Size

The Maximum Transmission Unit (MTU) size refers to the maximum amount of data that can be transmitted in a single BLE packet. In BLE, the MTU size determines the size of the payload that can be sent between devices during communication. The MTU size is usually set to a value that balances the trade-off between data transmission efficiency and power consumption.

In Core Bluetooth, the default MTU size for BLE connections is 23 bytes for iOS devices and 247 bytes for most other platforms (including Android and Linux-based systems). However, this value can be adjusted by the application using the setMTU method of the CBPeripheral class or the setMaximumTransmissionUnit method of the CBPeripheralManager class.

The Problem with iOS 16

The question at hand revolves around an issue observed in iOS 16 and later versions. It appears that the MTU size sent by the iPhone is reduced to 77 bytes when using iOS 16, compared to the expected maximum value of 185 bytes. This change has significant implications for BLE applications, as it can lead to data transmission errors and reduced performance.

Understanding the Problem

The problem described in the question seems related to a bug or regression introduced in iOS 16. However, without diving deeper into the source code or Apple’s documentation, it is challenging to understand exactly what changed in iOS 16 that causes this issue.

One possible explanation for this change could be related to the Bluetooth protocol itself or a change in the way Core Bluetooth handles BLE connections. It might also be a result of an optimization or improvement made by Apple to reduce power consumption.

Possible Causes

There are several possible causes for this behavior:

Optimization: Apple might have optimized the Bluetooth protocol on iOS devices to use smaller MTU sizes, potentially reducing power consumption.
Bug Fix: It is also possible that the issue is a bug fix introduced in iOS 16, intended to improve the stability of BLE connections but causing this unexpected behavior.
Configuration Change: Some changes in the Core Bluetooth configuration or API might be responsible for this change.

Reproducing the Problem

The question describes an issue observed on iPhone devices running iOS 15 and later versions, including iOS 16 and iOS 16.0.2. The problem can be reproduced by using the same phone and iOS version with different BLE peripherals connected to it.

It is also worth noting that restarting the phone seems to temporarily fix the problem, and the MTU response from the iPhone reverts back to 185 bytes. However, after a few connections, the iPhone starts sending 77 bytes again.

Workarounds

Given the limitations of Core Bluetooth, there are limited options for overcoming this issue. Here are some potential workarounds:

Use a different BLE peripheral: If possible, use a different BLE peripheral that is compatible with iOS devices and supports the expected maximum MTU size.
Adjust the MTU size manually: Some Core Bluetooth APIs allow manual adjustment of the MTU size during connection establishment. However, this might not always be feasible or recommended.

Conclusion

In conclusion, this issue seems to be a bug or regression in iOS 16 and later versions, causing the MTU size sent by the iPhone to decrease to 77 bytes when using BLE connections. While there are limited options for overcoming this issue, restarting the phone can temporarily fix the problem.

It is worth noting that Apple has since fixed this issue on iOS 16.1 and other subsequent versions of iOS.