simplernble 1.2.1-dev126 → 1.2.1-dev129

package/cpp/HybridSimpleRnBLE.cpp

@@ -92,6 +92,10 @@ std::shared_ptr<Promise<bool>> HybridSimpleRnBLE::bluetoothEnabled() {
     return run<bool>(lifecycle(), [] { return SimpleBLE::Adapter::bluetooth_enabled(); });
 }
 
+bool HybridSimpleRnBLE::getNegotiateMtu() { return SimpleBLE::Config::Android::negotiate_mtu; }
+
+void HybridSimpleRnBLE::setNegotiateMtu(bool enabled) { SimpleBLE::Config::Android::negotiate_mtu = enabled; }
+
 ConnectionPriorityRequest HybridSimpleRnBLE::getConnectionPriorityRequest() {
     return convert_back(PRIORITIES, SimpleBLE::Config::Android::connection_priority_request);
 }

package/cpp/HybridSimpleRnBLE.hpp

@@ -16,6 +16,8 @@ class HybridSimpleRnBLE : public HybridSimpleRnBLESpec {
     std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridAdapterHandleSpec>>>> getAdapters() override;
     std::shared_ptr<Promise<bool>> bluetoothEnabled() override;
 
+    bool getNegotiateMtu() override;
+    void setNegotiateMtu(bool enabled) override;
     ConnectionPriorityRequest getConnectionPriorityRequest() override;
     void setConnectionPriorityRequest(ConnectionPriorityRequest request) override;
     void resetConfig() override;

package/lib/config.d.ts

@@ -3,6 +3,8 @@ export type ConnectionPriorityRequest = 'disabled' | 'balanced' | 'high' | 'lowP
 export interface AndroidConfig {
     /** Requested after each connection; 'disabled' leaves Android's default. */
     connectionPriorityRequest: ConnectionPriorityRequest;
+    /** Negotiate MTU on connect. Defaults to true. */
+    negotiateMtu: boolean;
 }
 /**
  * App-wide settings of each backend. Set them before the first call that

package/lib/config.js

@@ -17,8 +17,17 @@ exports.Config = Object.freeze({
                 throw new TypeError(`connectionPriorityRequest must be one of ${PRIORITIES.join(', ')}`);
             native_1.native.connectionPriorityRequest = value;
         },
+        get negotiateMtu() {
+            return native_1.native.negotiateMtu;
+        },
+        set negotiateMtu(value) {
+            if (typeof value !== 'boolean')
+                throw new TypeError('negotiateMtu must be a boolean');
+            native_1.native.negotiateMtu = value;
+        },
         reset() {
             native_1.native.connectionPriorityRequest = 'disabled';
+            native_1.native.negotiateMtu = true;
         },
     }),
     resetAll() {

package/lib/specs/SimpleRnBLE.nitro.d.ts

@@ -114,6 +114,7 @@ export interface SimpleRnBLE extends Native {
     getAdapters(): Promise<AdapterHandle[]>;
     bluetoothEnabled(): Promise<boolean>;
     connectionPriorityRequest: ConnectionPriorityRequest;
+    negotiateMtu: boolean;
     resetConfig(): void;
     logLevel: number;
     setLogCallback(callback: ((entry: LogEntry) => void) | undefined): void;

package/native/VERSION

@@ -1 +1 @@
-1.2.1-dev126
+1.2.1-dev129

package/native/simpleble/include/simpleble/Config.h

@@ -47,8 +47,12 @@ namespace Android {
     enum class ConnectionPriorityRequest { DISABLED = -1, BALANCED = 0, HIGH = 1, LOW_POWER = 2, DCK = 3 };
 
     extern SIMPLEBLE_EXPORT ConnectionPriorityRequest connection_priority_request;
+    extern SIMPLEBLE_EXPORT bool negotiate_mtu;
 
-    static void reset() { connection_priority_request = ConnectionPriorityRequest::DISABLED; }
+    static void reset() {
+        connection_priority_request = ConnectionPriorityRequest::DISABLED;
+        negotiate_mtu = true;
+    }
 }  // namespace Android
 
 namespace Dongl {

package/native/simpleble/src/Config.cpp

@@ -16,6 +16,7 @@ namespace Config {
 
     namespace Android {
         ConnectionPriorityRequest connection_priority_request = ConnectionPriorityRequest::DISABLED;
+        bool negotiate_mtu = true;
     }  // namespace Android
 
     namespace Dongl {

package/native/simpleble/src/backends/android/PeripheralAndroid.cpp

@@ -26,6 +26,7 @@ PeripheralAndroid::PeripheralAndroid(Android::BluetoothDevice device) : _device(
             // If a connection has been established, request service discovery.
             _gatt.discoverServices();
         } else {
+            _connection_pending = false;
             // If a connection has been lost, close the GATT object.
             _gatt.close();
             SAFE_CALLBACK_CALL(callback_on_disconnected_);
@@ -34,10 +35,33 @@ PeripheralAndroid::PeripheralAndroid(Android::BluetoothDevice device) : _device(
     });
 
     _btGattCallback.set_callback_onServicesDiscovered([this]() {
-        // Once services have been discovered, store them and notify the user.
         _services = _gatt.getServices();
-        SAFE_CALLBACK_CALL(callback_on_connected_);
-        _connection_cv.notify_all();
+
+        // Android can report a retained ACL connection's MTU during discovery.
+        // Request it only when needed, after discovery and before completing connect.
+        if (Config::Android::negotiate_mtu && !_mtu_observed) {
+            if (_gatt.requestMtu(517)) {
+                return;
+            }
+
+            SIMPLEBLE_LOG_WARN("Failed to start MTU negotiation; using the last known ATT MTU");
+        }
+
+        _complete_connection();
+    });
+
+    _btGattCallback.set_callback_onMtuChanged([this](int status) {
+        if (status == 0) {
+            _mtu_observed = true;
+        }
+
+        if (_btGattCallback.services_discovered) {
+            if (status != 0 && _connection_pending) {
+                SIMPLEBLE_LOG_WARN("MTU negotiation failed; using the last known ATT MTU");
+            }
+
+            _complete_connection();
+        }
     });
 }
 
@@ -84,10 +108,18 @@ int16_t PeripheralAndroid::rssi() { return rssi_; }
 
 int16_t PeripheralAndroid::tx_power() { return tx_power_; }
 
-uint16_t PeripheralAndroid::mtu() { return _btGattCallback.mtu; }
+uint16_t PeripheralAndroid::mtu() {
+    if (!is_connected()) {
+        return 0;
+    }
+
+    return _btGattCallback.mtu.load() - 3;
+}
 
 void PeripheralAndroid::connect() {
     _btGattCallback.mtu = 23;
+    _connection_pending = true;
+    _mtu_observed = false;
     _gatt = _device.connectGatt(false, _btGattCallback);
 
     // Wait for the connection to be confirmed.
@@ -95,7 +127,7 @@ void PeripheralAndroid::connect() {
     std::unique_lock<std::mutex> lock(_connection_mutex);
     bool connected = _connection_cv.wait_for(lock, 8s, [this]() { return is_connected(); });
     if (!connected) {
-        throw SimpleBLE::Exception::OperationFailed("Failed to connect to device");
+        _handle_connection_timeout();
     }
 }
 
@@ -110,7 +142,9 @@ void PeripheralAndroid::disconnect() {
     }
 }
 
-bool PeripheralAndroid::is_connected() { return _btGattCallback.connected && _btGattCallback.services_discovered; }
+bool PeripheralAndroid::is_connected() {
+    return _btGattCallback.connected && _btGattCallback.services_discovered && !_connection_pending;
+}
 
 bool PeripheralAndroid::is_connectable() { return connectable_; }
 
@@ -334,6 +368,29 @@ void PeripheralAndroid::set_callback_on_disconnected(std::function<void()> on_di
     }
 }
 
+void PeripheralAndroid::_complete_connection() {
+    bool connection_pending = _connection_pending.exchange(false);
+    if (!connection_pending) {
+        return;
+    }
+
+    SAFE_CALLBACK_CALL(callback_on_connected_);
+    _connection_cv.notify_all();
+}
+
+void PeripheralAndroid::_handle_connection_timeout() {
+    bool waiting_for_mtu = _btGattCallback.services_discovered && _connection_pending;
+    _btGattCallback.connected = false;
+    _btGattCallback.services_discovered = false;
+    _connection_pending = false;
+    _gatt.disconnect();
+    _gatt.close();
+    if (waiting_for_mtu) {
+        throw SimpleBLE::Exception::OperationFailed("Timed out waiting for MTU negotiation");
+    }
+    throw SimpleBLE::Exception::OperationFailed("Failed to connect to device");
+}
+
 // NOTE: This approach to retrieve the characteristic and descriptor objects is not ideal, as it involves
 //       iterating on Java objects and returning a copy of the desired object. This will be improved in the future
 //       if performance becomes a bottleneck.

package/native/simpleble/src/backends/android/PeripheralAndroid.h

@@ -10,6 +10,7 @@
 #include <types/android/bluetooth/le/ScanResult.h>
 #include <bridge/BluetoothGattCallback.h>
 
+#include <atomic>
 #include <condition_variable>
 #include <map>
 #include <mutex>
@@ -77,10 +78,15 @@ class PeripheralAndroid : public PeripheralBase {
     std::mutex _disconnection_mutex;
     std::condition_variable _connection_cv;
     std::condition_variable _disconnection_cv;
+    std::atomic<bool> _connection_pending = false;
+    std::atomic<bool> _mtu_observed = false;
 
     kvn::safe_callback<void()> callback_on_connected_;
     kvn::safe_callback<void()> callback_on_disconnected_;
 
+    void _complete_connection();
+    void _handle_connection_timeout();
+
     Android::BluetoothGattCharacteristic _fetch_characteristic(const BluetoothUUID& service_uuid,
                                                                const BluetoothUUID& characteristic_uuid);
     Android::BluetoothGattDescriptor _fetch_descriptor(const BluetoothUUID& service_uuid,

package/native/simpleble/src/backends/android/bridge/BluetoothGattCallback.cpp

@@ -69,6 +69,14 @@ void BluetoothGattCallback::set_callback_onServicesDiscovered(std::function<void
     }
 }
 
+void BluetoothGattCallback::set_callback_onMtuChanged(std::function<void(int)> callback) {
+    if (callback) {
+        _callback_onMtuChanged.load(callback);
+    } else {
+        _callback_onMtuChanged.unload();
+    }
+}
+
 void BluetoothGattCallback::set_callback_onCharacteristicChanged(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> characteristic,
                                                                  std::function<void(std::vector<uint8_t>)> callback) {
     if (callback) {
@@ -229,7 +237,13 @@ void BluetoothGattCallback::jni_onConnectionStateChangeCallback(SimpleJNI::Objec
 
     BluetoothGattCallback* obj = GET_CALLBACK_OBJECT_OR_RETURN(thiz_obj);
     const bool connected = new_state == 2;
-    obj->connected = connected;
+    bool was_connected = obj->connected.exchange(connected);
+
+    // Some Android stacks repeat the connected event. Start connection setup only once.
+    if (connected && was_connected) {
+        return;
+    }
+
     if (!connected) {
         // Services need to be rediscovered on the next connection.
         obj->services_discovered = false;
@@ -313,9 +327,13 @@ void BluetoothGattCallback::jni_onMtuChangedCallback(SimpleJNI::Object<SimpleJNI
     BluetoothGattCallback* obj = GET_CALLBACK_OBJECT_OR_RETURN(thiz_obj);
     if (status != 0) {
         SIMPLEBLE_LOG_ERROR(fmt::format("MTU change failed with GATT status {}", status));
-        return;
+    } else if (mtu < 23 || mtu > 517) {
+        SIMPLEBLE_LOG_ERROR(fmt::format("Invalid ATT MTU {}", mtu));
+        status = -1;
+    } else {
+        obj->mtu = mtu;
     }
-    obj->mtu = mtu;
+    SAFE_CALLBACK_CALL(obj->_callback_onMtuChanged, status);
 }
 
 void BluetoothGattCallback::jni_onPhyReadCallback(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> thiz_obj, jint tx_phy, jint rx_phy, jint status) {

package/native/simpleble/src/backends/android/bridge/BluetoothGattCallback.h

@@ -21,6 +21,7 @@ class BluetoothGattCallback {
 
     void set_callback_onConnectionStateChange(std::function<void(bool)> callback);
     void set_callback_onServicesDiscovered(std::function<void(void)> callback);
+    void set_callback_onMtuChanged(std::function<void(int)> callback);
 
     void set_callback_onCharacteristicChanged(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> characteristic,
                                               std::function<void(std::vector<uint8_t> value)> callback);
@@ -84,6 +85,7 @@ class BluetoothGattCallback {
 
     kvn::safe_callback<void(bool)> _callback_onConnectionStateChange;
     kvn::safe_callback<void()> _callback_onServicesDiscovered;
+    kvn::safe_callback<void(int)> _callback_onMtuChanged;
 
     kvn::safe_map<SimpleJNI::Object<SimpleJNI::GlobalRef, jobject>, kvn::safe_callback<void(std::vector<uint8_t>)>, SimpleJNI::ObjectComparator<SimpleJNI::GlobalRef, jobject>>
         _callback_onCharacteristicChanged;
@@ -100,4 +102,4 @@ class BluetoothGattCallback {
 
 }  // namespace Bridge
 }  // namespace Android
-}  // namespace SimpleBLE
+}  // namespace SimpleBLE

package/native/simpleble/src/backends/android/types/android/bluetooth/BluetoothGatt.cpp

@@ -19,6 +19,7 @@ jmethodID BluetoothGatt::_method_setCharacteristicNotification = nullptr;
 jmethodID BluetoothGatt::_method_writeCharacteristic = nullptr;
 jmethodID BluetoothGatt::_method_writeDescriptor = nullptr;
 jmethodID BluetoothGatt::_method_requestConnectionPriority = nullptr;
+jmethodID BluetoothGatt::_method_requestMtu = nullptr;
 // Define the JNI descriptor
 const SimpleJNI::JNIDescriptor BluetoothGatt::descriptor{
     "android/bluetooth/BluetoothGatt", // Java class name
@@ -34,7 +35,8 @@ const SimpleJNI::JNIDescriptor BluetoothGatt::descriptor{
         {"setCharacteristicNotification", "(Landroid/bluetooth/BluetoothGattCharacteristic;Z)Z", &_method_setCharacteristicNotification},
         {"writeCharacteristic", "(Landroid/bluetooth/BluetoothGattCharacteristic;)Z", &_method_writeCharacteristic},
         {"writeDescriptor", "(Landroid/bluetooth/BluetoothGattDescriptor;)Z", &_method_writeDescriptor},
-        {"requestConnectionPriority", "(I)Z", &_method_requestConnectionPriority}
+        {"requestConnectionPriority", "(I)Z", &_method_requestConnectionPriority},
+        {"requestMtu", "(I)Z", &_method_requestMtu}
     }};
 
 const SimpleJNI::AutoRegister<BluetoothGatt> BluetoothGatt::registrar{&descriptor};
@@ -111,5 +113,10 @@ bool BluetoothGatt::requestConnectionPriority(int connectionPriority) {
     return _obj.call_boolean_method(_method_requestConnectionPriority, connectionPriority);
 }
 
+bool BluetoothGatt::requestMtu(int mtu) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_requestMtu, mtu);
+}
+
 }  // namespace Android
 }  // namespace SimpleBLE

package/native/simpleble/src/backends/android/types/android/bluetooth/BluetoothGatt.h

@@ -42,7 +42,7 @@ class BluetoothGatt {
     // void readPhy();
     // bool readRemoteRssi();
     bool requestConnectionPriority(int connectionPriority);
-    // bool requestMtu(int mtu);
+    bool requestMtu(int mtu);
     bool setCharacteristicNotification(BluetoothGattCharacteristic characteristic, bool enable);
     // void setPreferredPhy(int txPhy, int rxPhy, int phyOptions);
     bool writeCharacteristic(BluetoothGattCharacteristic characteristic);
@@ -66,6 +66,7 @@ class BluetoothGatt {
     static jmethodID _method_writeCharacteristic;
     static jmethodID _method_writeDescriptor;
     static jmethodID _method_requestConnectionPriority;
+    static jmethodID _method_requestMtu;
     // JNI descriptor for auto-registration
     static const SimpleJNI::JNIDescriptor descriptor;
     static const SimpleJNI::AutoRegister<BluetoothGatt> registrar;

package/nitrogen/generated/shared/c++/HybridSimpleRnBLESpec.cpp

@@ -16,6 +16,8 @@ namespace margelo::nitro::simplernble {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridGetter("connectionPriorityRequest", &HybridSimpleRnBLESpec::getConnectionPriorityRequest);
       prototype.registerHybridSetter("connectionPriorityRequest", &HybridSimpleRnBLESpec::setConnectionPriorityRequest);
+      prototype.registerHybridGetter("negotiateMtu", &HybridSimpleRnBLESpec::getNegotiateMtu);
+      prototype.registerHybridSetter("negotiateMtu", &HybridSimpleRnBLESpec::setNegotiateMtu);
       prototype.registerHybridGetter("logLevel", &HybridSimpleRnBLESpec::getLogLevel);
       prototype.registerHybridSetter("logLevel", &HybridSimpleRnBLESpec::setLogLevel);
       prototype.registerHybridMethod("getBackends", &HybridSimpleRnBLESpec::getBackends);

package/nitrogen/generated/shared/c++/HybridSimpleRnBLESpec.hpp

@@ -62,6 +62,8 @@ namespace margelo::nitro::simplernble {
       // Properties
       virtual ConnectionPriorityRequest getConnectionPriorityRequest() = 0;
       virtual void setConnectionPriorityRequest(ConnectionPriorityRequest connectionPriorityRequest) = 0;
+      virtual bool getNegotiateMtu() = 0;
+      virtual void setNegotiateMtu(bool negotiateMtu) = 0;
       virtual double getLogLevel() = 0;
       virtual void setLogLevel(double logLevel) = 0;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simplernble",
-  "version": "1.2.1-dev126",
+  "version": "1.2.1-dev129",
   "description": "SimpleBLE for React Native: a cross-platform Bluetooth Low Energy library for iOS and Android",
   "keywords": [
     "react-native",

package/prebuilt/release/include/simpleble/Config.h

@@ -47,8 +47,12 @@ namespace Android {
     enum class ConnectionPriorityRequest { DISABLED = -1, BALANCED = 0, HIGH = 1, LOW_POWER = 2, DCK = 3 };
 
     extern SIMPLEBLE_EXPORT ConnectionPriorityRequest connection_priority_request;
+    extern SIMPLEBLE_EXPORT bool negotiate_mtu;
 
-    static void reset() { connection_priority_request = ConnectionPriorityRequest::DISABLED; }
+    static void reset() {
+        connection_priority_request = ConnectionPriorityRequest::DISABLED;
+        negotiate_mtu = true;
+    }
 }  // namespace Android
 
 namespace Dongl {

package/src/config.ts

@@ -8,6 +8,8 @@ const PRIORITIES: readonly ConnectionPriorityRequest[] = ['disabled', 'balanced'
 export interface AndroidConfig {
   /** Requested after each connection; 'disabled' leaves Android's default. */
   connectionPriorityRequest: ConnectionPriorityRequest;
+  /** Negotiate MTU on connect. Defaults to true. */
+  negotiateMtu: boolean;
 }
 
 /**
@@ -26,8 +28,16 @@ export const Config: {
       if (!PRIORITIES.includes(value)) throw new TypeError(`connectionPriorityRequest must be one of ${PRIORITIES.join(', ')}`);
       native.connectionPriorityRequest = value;
     },
+    get negotiateMtu(): boolean {
+      return native.negotiateMtu;
+    },
+    set negotiateMtu(value: boolean) {
+      if (typeof value !== 'boolean') throw new TypeError('negotiateMtu must be a boolean');
+      native.negotiateMtu = value;
+    },
     reset(): void {
       native.connectionPriorityRequest = 'disabled';
+      native.negotiateMtu = true;
     },
   }),
   resetAll(): void {

package/src/specs/SimpleRnBLE.nitro.ts

@@ -142,6 +142,7 @@ export interface SimpleRnBLE extends Native {
   bluetoothEnabled(): Promise<boolean>;
 
   connectionPriorityRequest: ConnectionPriorityRequest;
+  negotiateMtu: boolean;
   resetConfig(): void;
 
   logLevel: number;