[Darwin] Implement multiple read and subscribe

src/darwin/Framework/CHIP/MTRBaseDevice.mm

@@ -76,12 +76,15 @@
 NSString * const MTRArrayValueType = @"Array";
 
 class MTRDataValueDictionaryCallbackBridge;
+template <typename DecodableValueType> class BufferedReadClientCallback;
+class MTRDataValueDictionaryDecodableType;
 
 @interface MTRReadClientContainer : NSObject
 @property (nonatomic, readwrite) app::ReadClient * readClientPtr;
 @property (nonatomic, readwrite) app::AttributePathParams * pathParams;
 @property (nonatomic, readwrite) app::EventPathParams * eventPathParams;
 @property (nonatomic, readwrite) uint64_t deviceID;
+@property (nonatomic, readwrite) BufferedReadClientCallback<MTRDataValueDictionaryDecodableType> * callbackPtr;
 - (void)onDone;
 @end
 
@@ -158,6 +161,10 @@ static void PurgeReadClientContainers(
                     Platform::MemoryFree(container.eventPathParams);
                     container.eventPathParams = nullptr;
                 }
+                if (container.callbackPtr != nullptr) {
+                    Platform::Delete(container.callbackPtr);
+                    container.callbackPtr = nullptr;
+                }
             }
             [listToDelete removeAllObjects];
             if (completion) {
@@ -240,6 +247,10 @@ - (void)onDone
         Platform::MemoryFree(_eventPathParams);
         _eventPathParams = nullptr;
     }
+    if (_callbackPtr) {
+        Platform::Delete(_callbackPtr);
+        _callbackPtr = nullptr;
+    }
     PurgeCompletedReadClientContainers(_deviceID);
 }
 
@@ -259,6 +270,10 @@ - (void)dealloc
         Platform::MemoryFree(_eventPathParams);
         _eventPathParams = nullptr;
     }
+    if (_callbackPtr) {
+        Platform::Delete(_callbackPtr);
+        _callbackPtr = nullptr;
+    }
 }
 @end
 
@@ -748,7 +763,7 @@ CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
     static void OnSuccessFn(void * context, id value) { DispatchSuccess(context, value); }
 };
 
-template <typename DecodableValueType> class BufferedReadClientCallback final : public app::ReadClient::Callback {
+template <typename DecodableValueType> class BufferedReadClientCallback : public app::ReadClient::Callback {
 public:
     using OnSuccessAttributeCallbackType
         = std::function<void(const ConcreteAttributePath & aPath, const DecodableValueType & aData)>;
@@ -765,25 +780,36 @@ CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
         OnErrorCallbackType aOnError, OnDoneCallbackType aOnDone,
         OnSubscriptionEstablishedCallbackType aOnSubscriptionEstablished = nullptr,
         OnDeviceResubscriptionScheduledCallbackType aOnDeviceResubscriptionScheduled = nullptr)
-        : mAttributePathParamsList(aAttributePathParamsList)
-        , mAttributePathParamsSize(aAttributePathParamsSize)
-        , mEventPathParamsList(aEventPathParamsList)
-        , mEventPathParamsSize(aEventPathParamsSize)
-        , mOnAttributeSuccess(aOnAttributeSuccess)
+        : mOnAttributeSuccess(aOnAttributeSuccess)
         , mOnEventSuccess(aOnEventSuccess)
         , mOnError(aOnError)
         , mOnDone(aOnDone)
         , mOnSubscriptionEstablished(aOnSubscriptionEstablished)
         , mOnDeviceResubscriptionScheduled(aOnDeviceResubscriptionScheduled)
         , mBufferedReadAdapter(*this)
     {
+        if (aAttributePathParamsList != nullptr) {
+            mAttributePathParamsList
+                = Platform::MakeMemoryUnique<app::AttributePathParams>(aAttributePathParamsSize, sizeof(AttributePathParams));
+            memcpy(
+                mAttributePathParamsList.get(), aAttributePathParamsList, aAttributePathParamsSize * sizeof(AttributePathParams));
+            mAttributePathParamsSize = aAttributePathParamsSize;
+        }
+
+        if (aEventPathParamsList != nullptr) {
+            mEventPathParamsList = Platform::MakeMemoryUnique<app::EventPathParams>(aEventPathParamsSize, sizeof(EventPathParams));
+            memcpy(mEventPathParamsList.get(), aEventPathParamsList, aEventPathParamsSize * sizeof(EventPathParams));
+            mEventPathParamsSize = aEventPathParamsSize;
+        }
     }
 
     ~BufferedReadClientCallback()
     {
         // Ensure we release the ReadClient before we tear down anything else,
         // so it can call our OnDeallocatePaths properly.
         mReadClient = nullptr;
+        mAttributePathParamsList = nullptr;
+        mEventPathParamsList = nullptr;
     }
 
     app::BufferedReadCallback & GetBufferedCallback() { return mBufferedReadAdapter; }
@@ -809,9 +835,9 @@ void OnAttributeData(
 
         VerifyOrExit(aStatus.IsSuccess(), err = aStatus.ToChipError());
         VerifyOrExit(
-            std::find_if(mAttributePathParamsList, mAttributePathParamsList + mAttributePathParamsSize,
+            std::find_if(mAttributePathParamsList.get(), mAttributePathParamsList.get() + mAttributePathParamsSize,
                 [aPath](app::AttributePathParams & pathParam) -> bool { return pathParam.IsAttributePathSupersetOf(aPath); })
-                != mAttributePathParamsList + mAttributePathParamsSize,
+                != mAttributePathParamsList.get() + mAttributePathParamsSize,
             err = CHIP_ERROR_SCHEMA_MISMATCH);
         VerifyOrExit(apData != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
 
@@ -834,11 +860,11 @@ void OnEventData(const EventHeader & aEventHeader, TLV::TLVReader * apData, cons
 
         VerifyOrExit(mEventPathParamsList != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
 
-        VerifyOrExit(std::find_if(mEventPathParamsList, mEventPathParamsList + mEventPathParamsSize,
+        VerifyOrExit(std::find_if(mEventPathParamsList.get(), mEventPathParamsList.get() + mEventPathParamsSize,
                          [aEventHeader](app::EventPathParams & pathParam) -> bool {
                              return pathParam.IsEventPathSupersetOf(aEventHeader.mPath);
                          })
-                != mEventPathParamsList + mEventPathParamsSize,
+                != mEventPathParamsList.get() + mEventPathParamsSize,
             err = CHIP_ERROR_SCHEMA_MISMATCH);
         VerifyOrExit(apData != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
 
@@ -887,8 +913,8 @@ void OnDeallocatePaths(chip::app::ReadPrepareParams && aReadPrepareParams) overr
     OnDeviceResubscriptionScheduledCallbackType mOnDeviceResubscriptionScheduled;
     app::BufferedReadCallback mBufferedReadAdapter;
     Platform::UniquePtr<app::ReadClient> mReadClient;
-    app::AttributePathParams * mAttributePathParamsList;
-    app::EventPathParams * mEventPathParamsList;
+    Platform::MemoryUniquePtr<app::AttributePathParams> mAttributePathParamsList;
+    Platform::MemoryUniquePtr<app::EventPathParams> mEventPathParamsList;
     size_t mAttributePathParamsSize;
     size_t mEventPathParamsSize;
 };
@@ -979,32 +1005,25 @@ - (void)readAttributePaths:(NSArray<MTRAttributeRequestPath *> * _Nullable)attri
                 }
             };
 
-            AttributePathParams * attributePathParamsList = nullptr;
-            EventPathParams * eventPathParamsList = nullptr;
+            Platform::MemoryUniquePtr<AttributePathParams> attributePathParamsList = nullptr;
+            Platform::MemoryUniquePtr<EventPathParams> eventPathParamsList = nullptr;
 
             if (attributes != nil) {
                 size_t count = 0;
                 attributePathParamsList
-                    = static_cast<AttributePathParams *>(Platform::MemoryCalloc([attributes count], sizeof(AttributePathParams)));
+                    = Platform::MakeMemoryUnique<AttributePathParams>([attributes count], sizeof(AttributePathParams));
                 VerifyOrReturnError(attributePathParamsList != nullptr, CHIP_ERROR_NO_MEMORY);
                 for (MTRAttributeRequestPath * attribute in attributes) {
-                    [attribute convertToAttributePathParams:attributePathParamsList[count++]];
+                    [attribute convertToAttributePathParams:attributePathParamsList.get()[count++]];
                 }
             }
 
             if (events != nil) {
                 size_t count = 0;
-                eventPathParamsList
-                    = static_cast<EventPathParams *>(Platform::MemoryCalloc([events count], sizeof(EventPathParams)));
-                if (eventPathParamsList == nullptr) {
-                    if (attributePathParamsList != nullptr) {
-                        Platform::MemoryFree(attributePathParamsList);
-                        attributePathParamsList = nullptr;
-                    }
-                    return CHIP_ERROR_NO_MEMORY;
-                }
+                eventPathParamsList = Platform::MakeMemoryUnique<EventPathParams>([events count], sizeof(EventPathParams));
+                VerifyOrReturnError(eventPathParamsList != nullptr, CHIP_ERROR_NO_MEMORY);
                 for (MTREventRequestPath * event in events) {
-                    [event convertToEventPathParams:eventPathParamsList[count++]];
+                    [event convertToEventPathParams:eventPathParamsList.get()[count++]];
                 }
             }
 
@@ -1013,31 +1032,25 @@ - (void)readAttributePaths:(NSArray<MTRAttributeRequestPath *> * _Nullable)attri
 
             chip::app::ReadPrepareParams readParams(session);
             [params toReadPrepareParams:readParams];
-            readParams.mpAttributePathParamsList = attributePathParamsList;
+            readParams.mpAttributePathParamsList = attributePathParamsList.get();
             readParams.mAttributePathParamsListSize = [attributePaths count];
-            readParams.mpEventPathParamsList = eventPathParamsList;
+            readParams.mpEventPathParamsList = eventPathParamsList.get();
             readParams.mEventPathParamsListSize = [eventPaths count];
 
-            auto onDone = [resultArray, interactionStatus, bridge, successCb, failureCb, attributePathParamsList,
-                              eventPathParamsList](BufferedReadClientCallback<MTRDataValueDictionaryDecodableType> * callback) {
+            auto onDone = [resultArray, interactionStatus, bridge, successCb, failureCb](
+                              BufferedReadClientCallback<MTRDataValueDictionaryDecodableType> * callback) {
                 if (*interactionStatus != CHIP_NO_ERROR) {
                     // Failure
                     failureCb(bridge, *interactionStatus);
                 } else {
                     // Success
                     successCb(bridge, resultArray);
                 }
-                if (attributePathParamsList != nullptr) {
-                    Platform::MemoryFree(attributePathParamsList);
-                }
-                if (eventPathParamsList != nullptr) {
-                    Platform::MemoryFree(eventPathParamsList);
-                }
                 chip::Platform::Delete(callback);
             };
 
             auto callback = chip::Platform::MakeUnique<BufferedReadClientCallback<MTRDataValueDictionaryDecodableType>>(
-                attributePathParamsList, readParams.mAttributePathParamsListSize, eventPathParamsList,
+                attributePathParamsList.get(), readParams.mAttributePathParamsListSize, eventPathParamsList.get(),
                 readParams.mEventPathParamsListSize, onAttributeSuccessCb, onEventSuccessCb, onFailureCb, onDone, nullptr);
             VerifyOrReturnError(callback != nullptr, CHIP_ERROR_NO_MEMORY);
 
@@ -1437,6 +1450,7 @@ - (void)subscribeToAttributePaths:(NSArray<MTRAttributeRequestPath *> * _Nullabl
                    readParams.mEventPathParamsListSize = eventPathSize;
 
                    auto onDone = [container](BufferedReadClientCallback<MTRDataValueDictionaryDecodableType> * callback) {
+                       container.callbackPtr = nullptr;
                        [container onDone];
                        // Make sure we delete callback last, because doing that actually destroys our
                        // lambda, so we can't access captured values after that.
@@ -1477,6 +1491,7 @@ - (void)subscribeToAttributePaths:(NSArray<MTRAttributeRequestPath *> * _Nullabl
 
                    // Read clients will be purged when deregistered.
                    container.readClientPtr = readClient;
+                   container.callbackPtr = callback.get();
                    AddReadClientContainer(container.deviceID, container);
                    callback.release();
                }];

src/lib/support/CHIPMem.h

@@ -175,15 +175,30 @@ struct Deleter
     void operator()(T * p) { Delete(p); }
 };
 
+template <typename T>
+struct MemoryFreer
+{
+    void operator()(T * p) { MemoryFree(p); }
+};
+
 template <typename T>
 using UniquePtr = std::unique_ptr<T, Deleter<T>>;
 
+template <typename T>
+using MemoryUniquePtr = std::unique_ptr<T, MemoryFreer<T>>;
+
 template <typename T, typename... Args>
 inline UniquePtr<T> MakeUnique(Args &&... args)
 {
     return UniquePtr<T>(New<T>(std::forward<Args>(args)...));
 }
 
+template <typename T>
+inline MemoryUniquePtr<T> MakeMemoryUnique(size_t num, size_t size)
+{
+    return MemoryUniquePtr<T>(static_cast<T *>(MemoryCalloc(num, size)));
+}
+
 template <typename T>
 using SharedPtr = std::shared_ptr<T>;