feat: mtu exchange interface update

services/ble/ClaimingGattClientAdapter.cpp

@@ -178,16 +178,21 @@ namespace services
         PerformDescriptorOperation();
     }
 
-    uint16_t ClaimingGattClientAdapter::EffectiveMaxAttMtuSize() const
+    uint16_t ClaimingGattClientAdapter::EffectiveAttMtuSize() const
     {
-        return AttMtuExchangeObserver::Subject().EffectiveMaxAttMtuSize();
+        return AttMtuExchangeObserver::Subject().EffectiveAttMtuSize();
     }
 
-    void ClaimingGattClientAdapter::MtuExchange()
+    void ClaimingGattClientAdapter::MtuExchange(const infra::Function<void(OperationStatus)>& onDone)
     {
+        mtuExchangeOnDone = onDone;
         attMtuExchangeClaimer.Claim([this]()
             {
-                AttMtuExchangeObserver::Subject().MtuExchange();
+                GattClientObserver::Subject().MtuExchange([this](OperationStatus result)
+                    {
+                        attMtuExchangeClaimer.Release();
+                        mtuExchangeOnDone(result);
+                    });
             });
     }
 
@@ -222,14 +227,12 @@ namespace services
             });
     }
 
-    void ClaimingGattClientAdapter::ExchangedMaxAttMtuSize()
+    void ClaimingGattClientAdapter::ExchangedAttMtuSize()
     {
         infra::Subject<AttMtuExchangeObserver>::NotifyObservers([](auto& observer)
             {
-                observer.ExchangedMaxAttMtuSize();
+                observer.ExchangedAttMtuSize();
             });
-
-        attMtuExchangeClaimer.Release();
     }
 
     void ClaimingGattClientAdapter::DeviceDiscovered(const GapAdvertisingReport& deviceDiscovered)

services/ble/ClaimingGattClientAdapter.hpp

@@ -2,6 +2,7 @@
 #define SERVICES_GATT_CLIENT_DECORATOR_HPP
 
 #include "infra/event/ClaimableResource.hpp"
+#include "infra/util/AutoResetFunction.hpp"
 #include "infra/util/Function.hpp"
 #include "optional"
 #include "services/ble/Gap.hpp"
@@ -17,6 +18,7 @@ namespace services
         : public GattClientDiscovery
         , public GattClientCharacteristicOperations
         , public AttMtuExchange
+        , public GattClientMtuExchange
         , private GattClientObserver
         , private AttMtuExchangeObserver
         , private GapCentralObserver
@@ -38,9 +40,11 @@ namespace services
         void EnableIndication(AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone) override;
         void DisableIndication(AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone) override;
 
+        // Implementation of GattClientMtuExchange
+        virtual void MtuExchange(const infra::Function<void(OperationStatus)>& onDone) override;
+
         // Implementation of AttMtuExchange
-        uint16_t EffectiveMaxAttMtuSize() const override;
-        void MtuExchange() override;
+        uint16_t EffectiveAttMtuSize() const override;
 
     private:
         // Implementation of GattClientObserver
@@ -54,7 +58,7 @@ namespace services
         void IndicationReceived(AttAttribute::Handle handle, infra::ConstByteRange data, const infra::Function<void()>& onDone) override;
 
         // Implementation of AttMtuExchangeObserver
-        void ExchangedMaxAttMtuSize() override;
+        void ExchangedAttMtuSize() override;
 
         // Implementation of GapCentralObserver
         void DeviceDiscovered(const GapAdvertisingReport& deviceDiscovered) override;
@@ -115,14 +119,16 @@ namespace services
 
             CharacteristicOperation(Operation operation, AttAttribute::Handle handle)
                 : operation(operation)
-                , handle(handle){};
+                , handle(handle)
+            {}
 
             Operation operation;
             AttAttribute::Handle handle;
         };
 
         std::optional<std::variant<DiscoveredService, DiscoveredCharacteristic, DiscoveredDescriptor, HandleRange>> discoveryContext;
         std::optional<CharacteristicOperation> characteristicOperationContext;
+        infra::AutoResetFunction<void(OperationStatus)> mtuExchangeOnDone;
 
         infra::ClaimableResource resource;
         infra::ClaimableResource::Claimer characteristicOperationsClaimer{ resource };

services/ble/Gatt.cpp

@@ -108,6 +108,16 @@ namespace services
     {
         return 0;
     }
+
+    uint16_t AttMtuExchangeImpl::EffectiveAttMtuSize() const
+    {
+        return attMtu;
+    }
+
+    void AttMtuExchangeImpl::SetAttMtu(uint16_t value)
+    {
+        attMtu = value;
+    }
 }
 
 namespace infra

services/ble/Gatt.hpp

@@ -5,6 +5,7 @@
 #include "infra/util/EnumCast.hpp"
 #include "infra/util/Observer.hpp"
 #include "services/ble/Att.hpp"
+#include <cstdint>
 
 namespace services
 {
@@ -115,20 +116,33 @@ namespace services
         : public infra::Observer<AttMtuExchangeObserver, AttMtuExchange>
     {
     public:
-        using infra::Observer<AttMtuExchangeObserver, AttMtuExchange>::Observer;
+        using Observer::Observer;
 
-        virtual void ExchangedMaxAttMtuSize() = 0;
+        virtual void ExchangedAttMtuSize() = 0;
     };
 
     class AttMtuExchange
         : public infra::Subject<AttMtuExchangeObserver>
     {
+    protected:
+        ~AttMtuExchange() = default;
+
     public:
-        virtual uint16_t EffectiveMaxAttMtuSize() const = 0;
-        virtual void MtuExchange() = 0;
+        virtual uint16_t EffectiveAttMtuSize() const = 0;
+    };
 
-    protected:
-        static constexpr uint16_t defaultMaxAttMtuSize = 23;
+    class AttMtuExchangeImpl
+        : public AttMtuExchange
+    {
+    public:
+        virtual ~AttMtuExchangeImpl() = default;
+        uint16_t EffectiveAttMtuSize() const override;
+        void SetAttMtu(uint16_t value);
+
+        static constexpr uint16_t defaultAttMtuSize = 23;
+
+    private:
+        uint16_t attMtu = defaultAttMtuSize;
     };
 
     inline GattCharacteristic::PropertyFlags operator|(GattCharacteristic::PropertyFlags lhs, GattCharacteristic::PropertyFlags rhs)

services/ble/GattClient.hpp

@@ -129,6 +129,12 @@ namespace services
         virtual void StartDescriptorDiscovery(AttAttribute::Handle handle, AttAttribute::Handle endHandle) = 0;
     };
 
+    class GattClientMtuExchange
+    {
+    public:
+        virtual void MtuExchange(const infra::Function<void(OperationStatus)>& onDone) = 0;
+    };
+
     class GattClient;
 
     class GattClientObserver
@@ -163,6 +169,8 @@ namespace services
         virtual void DisableNotification(AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone) = 0;
         virtual void EnableIndication(AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone) = 0;
         virtual void DisableIndication(AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone) = 0;
+
+        virtual void MtuExchange(const infra::Function<void(OperationStatus)>& onDone) = 0;
     };
 }
 

services/ble/test/TestClaimingGattClientAdapter.cpp

@@ -91,17 +91,21 @@ TEST_F(ClaimingGattClientAdapterTest, should_call_descriptor_discovered)
 
 TEST_F(ClaimingGattClientAdapterTest, should_call_mtu_exchange)
 {
-    EXPECT_CALL(attMtuExchange, EffectiveMaxAttMtuSize()).WillOnce(testing::Return(200));
-    EXPECT_EQ(200, adapter.EffectiveMaxAttMtuSize());
+    EXPECT_CALL(attMtuExchange, EffectiveAttMtuSize()).WillOnce(testing::Return(200));
+    EXPECT_EQ(200, adapter.EffectiveAttMtuSize());
 
-    EXPECT_CALL(attMtuExchange, MtuExchange());
-    adapter.MtuExchange();
+    infra::Function<void(services::OperationStatus)> storedOnDone;
+    EXPECT_CALL(gattClient, MtuExchange(testing::_)).WillOnce(testing::SaveArg<0>(&storedOnDone));
+
+    infra::VerifyingFunction<void(services::OperationStatus)> onDone{ services::OperationStatus::success };
+    adapter.MtuExchange(onDone);
     ExecuteAllActions();
+    storedOnDone(services::OperationStatus::success);
 
-    EXPECT_CALL(attMtuExchangeObserver, ExchangedMaxAttMtuSize());
+    EXPECT_CALL(attMtuExchangeObserver, ExchangedAttMtuSize());
     attMtuExchange.NotifyObservers([](auto& observer)
         {
-            observer.ExchangedMaxAttMtuSize();
+            observer.ExchangedAttMtuSize();
         });
 }
 
@@ -158,17 +162,14 @@ TEST_F(ClaimingGattClientAdapterTest, can_write_without_response_while_awaiting_
 
 TEST_F(ClaimingGattClientAdapterTest, should_release_claimer_when_disconnected)
 {
-    EXPECT_CALL(attMtuExchange, EffectiveMaxAttMtuSize()).WillOnce(testing::Return(200));
-    EXPECT_EQ(200, adapter.EffectiveMaxAttMtuSize());
-
-    EXPECT_CALL(attMtuExchange, MtuExchange());
-    adapter.MtuExchange();
+    EXPECT_CALL(gattClient, MtuExchange(testing::_));
+    adapter.MtuExchange([](auto) {});
     ExecuteAllActions();
 
     gapCentral.ChangeState(services::GapState::standby);
 
-    EXPECT_CALL(attMtuExchange, MtuExchange());
-    adapter.MtuExchange();
+    EXPECT_CALL(gattClient, MtuExchange(testing::_));
+    adapter.MtuExchange([](auto) {});
     ExecuteAllActions();
 }
 

services/ble/test/TestGatt.cpp

@@ -108,4 +108,13 @@ TEST(GattInsertionOperatorUuidTest, uuid_overload_operator)
     stream << "Uuid16: " << services::AttAttribute::Uuid(uuid16) << ", Uuid128: " << services::AttAttribute::Uuid(uuid128);
 
     EXPECT_EQ("Uuid16: [42], Uuid128: [100f0e0d0c0b0a090807060504030201]", stream.Storage());
-}
+}
+
+TEST(GattTest, UpdateAttMtuExchangeTest)
+{
+    services::AttMtuExchangeImpl exchange{};
+
+    EXPECT_THAT(exchange.EffectiveAttMtuSize(), testing::Eq(services::AttMtuExchangeImpl::defaultAttMtuSize));
+    exchange.SetAttMtu(0);
+    EXPECT_THAT(exchange.EffectiveAttMtuSize(), testing::Eq(0));
+}

services/ble/test_doubles/GattClientMock.hpp

@@ -96,6 +96,7 @@ namespace services
         MOCK_METHOD(void, DisableNotification, (AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone), (override));
         MOCK_METHOD(void, EnableIndication, (AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone), (override));
         MOCK_METHOD(void, DisableIndication, (AttAttribute::Handle handle, const infra::Function<void(OperationStatus)>& onDone), (override));
+        MOCK_METHOD(void, MtuExchange, (const infra::Function<void(OperationStatus)>& onDone), (override));
     };
 }
 

services/ble/test_doubles/GattMock.hpp

@@ -10,8 +10,7 @@ namespace services
         : public AttMtuExchange
     {
     public:
-        MOCK_METHOD(uint16_t, EffectiveMaxAttMtuSize, (), (const override));
-        MOCK_METHOD(void, MtuExchange, (), (override));
+        MOCK_METHOD(uint16_t, EffectiveAttMtuSize, (), (const override));
     };
 
     class AttMtuExchangeObserverMock
@@ -20,7 +19,7 @@ namespace services
     public:
         using AttMtuExchangeObserver::AttMtuExchangeObserver;
 
-        MOCK_METHOD(void, ExchangedMaxAttMtuSize, (), (override));
+        MOCK_METHOD(void, ExchangedAttMtuSize, (), (override));
     };
 }