[chip-tool] Add subscribe-all command (#20868)

* [chip-tool] Update read-all command such that an arbitrary number of attributes/events can be used

* [chip-tool] Add subscribe-all command to chip-tool

* Update generated code

examples/chip-tool/commands/clusters/ReportCommand.h

@@ -418,7 +418,20 @@ class ReadAll : public ReadCommand
 public:
     ReadAll(CredentialIssuerCommands * credsIssuerConfig) : ReadCommand("read-all", credsIssuerConfig)
     {
-        AddArgument("fabric-filtered", 0, 1, &mFabricFiltered);
+        AddArgument("cluster-ids", 0, UINT32_MAX, &mClusterIds,
+                    "Comma-separated list of cluster ids to read from (e.g. \"6\" or \"8,0x201\").\n  Allowed to be 0xFFFFFFFF to "
+                    "indicate a wildcard cluster.");
+        AddArgument("attribute-ids", 0, UINT32_MAX, &mAttributeIds,
+                    "Comma-separated list of attribute ids to read (e.g. \"0\" or \"1,0xFFFC,0xFFFD\").\n  Allowed to be "
+                    "0xFFFFFFFF to indicate a wildcard attribute.");
+        AddArgument("event-ids", 0, UINT32_MAX, &mEventIds,
+                    "Comma-separated list of event ids to read (e.g. \"0\" or \"1,2,3\").\n  Allowed to be "
+                    "0xFFFFFFFF to indicate a wildcard event.");
+        AddArgument("fabric-filtered", 0, 1, &mFabricFiltered,
+                    "Boolean indicating whether to do a fabric-filtered read. Defaults to true.");
+        AddArgument("data-versions", 0, UINT32_MAX, &mDataVersions,
+                    "Comma-separated list of data versions for the clusters being read.");
+        AddArgument("event-min", 0, UINT64_MAX, &mEventNumber);
         ReadCommand::AddArguments();
     }
 
@@ -432,9 +445,62 @@ class ReadAll : public ReadCommand
 
     CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
     {
-        return ReadCommand::ReadAll(device, endpointIds, mFabricFiltered);
+        return ReadCommand::ReadAll(device, endpointIds, mClusterIds, mAttributeIds, mEventIds, mFabricFiltered, mDataVersions,
+                                    mEventNumber);
+    }
+
+private:
+    std::vector<chip::ClusterId> mClusterIds;
+    std::vector<chip::AttributeId> mAttributeIds;
+    std::vector<chip::EventId> mEventIds;
+
+    chip::Optional<bool> mFabricFiltered;
+    chip::Optional<std::vector<chip::DataVersion>> mDataVersions;
+    chip::Optional<chip::EventNumber> mEventNumber;
+};
+
+class SubscribeAll : public SubscribeCommand
+{
+public:
+    SubscribeAll(CredentialIssuerCommands * credsIssuerConfig) : SubscribeCommand("subscribe-all", credsIssuerConfig)
+    {
+        AddArgument("cluster-ids", 0, UINT32_MAX, &mClusterIds,
+                    "Comma-separated list of cluster ids to read from (e.g. \"6\" or \"8,0x201\").\n  Allowed to be 0xFFFFFFFF to "
+                    "indicate a wildcard cluster.");
+        AddArgument("attribute-ids", 0, UINT32_MAX, &mAttributeIds,
+                    "Comma-separated list of attribute ids to read (e.g. \"0\" or \"1,0xFFFC,0xFFFD\").\n  Allowed to be "
+                    "0xFFFFFFFF to indicate a wildcard attribute.");
+        AddArgument("event-ids", 0, UINT32_MAX, &mEventIds,
+                    "Comma-separated list of event ids to read (e.g. \"0\" or \"1,2,3\").\n  Allowed to be "
+                    "0xFFFFFFFF to indicate a wildcard event.");
+        AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval,
+                    "The requested minimum interval between reports. Sets MinIntervalFloor in the Subscribe Request.");
+        AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval,
+                    "The requested maximum interval between reports. Sets MaxIntervalCeiling in the Subscribe Request.");
+        AddArgument("fabric-filtered", 0, 1, &mFabricFiltered,
+                    "Boolean indicating whether to do a fabric-filtered read. Defaults to true.");
+        AddArgument("event-min", 0, UINT64_MAX, &mEventNumber);
+        AddArgument("keepSubscriptions", 0, 1, &mKeepSubscriptions,
+                    "false - Terminate existing subscriptions from initiator.\n  true - Leave existing subscriptions in place.");
+        SubscribeCommand::AddArguments();
+    }
+
+    ~SubscribeAll() {}
+
+    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
+    {
+        return SubscribeCommand::SubscribeAll(device, endpointIds, mClusterIds, mAttributeIds, mEventIds, mMinInterval,
+                                              mMaxInterval, mFabricFiltered, mEventNumber, mKeepSubscriptions);
     }
 
 private:
+    std::vector<chip::ClusterId> mClusterIds;
+    std::vector<chip::AttributeId> mAttributeIds;
+    std::vector<chip::EventId> mEventIds;
+
+    uint16_t mMinInterval;
+    uint16_t mMaxInterval;
     chip::Optional<bool> mFabricFiltered;
+    chip::Optional<chip::EventNumber> mEventNumber;
+    chip::Optional<bool> mKeepSubscriptions;
 };

examples/chip-tool/templates/commands.zapt

@@ -138,6 +138,7 @@ void registerClusterAny(Commands & commands, CredentialIssuerCommands * credsIss
         make_unique<ReadEvent>(credsIssuerConfig),       //
         make_unique<SubscribeEvent>(credsIssuerConfig),     //
         make_unique<ReadAll>(credsIssuerConfig),         //
+        make_unique<SubscribeAll>(credsIssuerConfig),         //
     };
 
     commands.Register(clusterName, clusterCommands);

src/app/tests/suites/commands/interaction_model/InteractionModel.cpp

@@ -449,35 +449,129 @@ void InteractionModelReports::CleanupReadClient(ReadClient * aReadClient)
         mReadClients.end());
 }
 
-CHIP_ERROR InteractionModelReports::ReadAll(DeviceProxy * device, std::vector<EndpointId> endpointIds,
-                                            const Optional<bool> & fabricFiltered)
+CHIP_ERROR InteractionModelReports::ReportAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
+                                              std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
+                                              std::vector<chip::EventId> eventIds,
+                                              chip::app::ReadClient::InteractionType interactionType, uint16_t minInterval,
+                                              uint16_t maxInterval, const chip::Optional<bool> & fabricFiltered,
+                                              const chip::Optional<std::vector<chip::DataVersion>> & dataVersions,
+                                              const chip::Optional<chip::EventNumber> & eventNumber,
+                                              const chip::Optional<bool> & keepSubscriptions)
 {
+    const size_t endpointCount  = endpointIds.size();
+    const size_t clusterCount   = clusterIds.size();
+    const size_t attributeCount = attributeIds.size();
+    const size_t eventCount     = eventIds.size();
+
+    // TODO Add data version supports
+    // TODO Add isUrgents supports
+
+    VerifyOrReturnError(endpointCount > 0 && endpointCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(clusterCount > 0 && clusterCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(attributeCount > 0 && attributeCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(eventCount > 0 && eventCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
+
+    const bool hasSameIdsCount = (clusterCount == (attributeCount + eventCount)) && (clusterCount == endpointCount);
+    if (!hasSameIdsCount)
+    {
+        ChipLogError(chipTool,
+                     "\nCommand targetting a combination of attribute and event paths needs to have has many clusters and "
+                     "endpoints than the number of attribute and events combined.\n"
+                     "For example if there are 2 attributes and 1 event, the command expects 3 clusters and 3 endpoints.\n"
+                     "Clusters and endpoints ids will be consumed first to populate the attribute paths of the request, and then "
+                     "to populate the event paths of the request.\n\n"
+                     "For example the following arguments:\n"
+                     "\tcluster-ids: 6,6,0X28\n"
+                     "\tendpoint-ids: 1,1,0\n"
+                     "\tattribute-ids: 0,0x4001\n"
+                     "\tevent-ids: 0\n"
+                     "\n"
+                     "will create the following paths:\n"
+                     "\t{cluster: 6, endpoint: 1, attribute: 0}\n"
+                     "\t{cluster: 6, endpoint: 1, attribute: 0x4001}\n"
+                     "\t{cluster: 0x28, endpoint: 0, event: 0}\n");
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
     AttributePathParams attributePathParams[kMaxAllowedPaths];
     EventPathParams eventPathParams[kMaxAllowedPaths];
 
-    auto pathsCount = endpointIds.size();
-    VerifyOrReturnError(pathsCount > 0 && pathsCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
-
+    size_t attributeIndex = 0;
+    size_t eventIndex     = 0;
+    size_t pathsCount     = clusterCount;
     for (size_t i = 0; i < pathsCount; i++)
     {
-        auto endpointId                    = endpointIds.at(i);
-        attributePathParams[i].mEndpointId = endpointId;
-        eventPathParams[i].mEndpointId     = endpointId;
+        auto clusterId  = clusterIds.at(i);
+        auto endpointId = endpointIds.at(i);
+
+        if (attributeIndex < attributeIds.size())
+        {
+            auto attributeId = attributeIds.at(attributeIndex);
+
+            if (endpointId != kInvalidEndpointId)
+            {
+                attributePathParams[attributeIndex].mEndpointId = endpointId;
+            }
+
+            if (clusterId != kInvalidClusterId)
+            {
+                attributePathParams[attributeIndex].mClusterId = clusterId;
+            }
+
+            if (attributeId != kInvalidAttributeId)
+            {
+                attributePathParams[attributeIndex].mAttributeId = attributeId;
+            }
+
+            attributeIndex++;
+        }
+        else if (eventIndex < eventIds.size())
+        {
+            auto eventId = eventIds.at(eventIndex);
+
+            if (endpointId != kInvalidEndpointId)
+            {
+                eventPathParams[eventIndex].mEndpointId = endpointId;
+            }
+
+            if (clusterId != kInvalidClusterId)
+            {
+                eventPathParams[eventIndex].mClusterId = clusterId;
+            }
+
+            if (eventId != kInvalidEventId)
+            {
+                eventPathParams[eventIndex].mEventId = eventId;
+            }
+
+            eventIndex++;
+        }
     }
 
     ReadPrepareParams params(device->GetSecureSession().Value());
     params.mpEventPathParamsList        = eventPathParams;
-    params.mEventPathParamsListSize     = pathsCount;
+    params.mEventPathParamsListSize     = eventCount;
+    params.mEventNumber                 = eventNumber;
     params.mpAttributePathParamsList    = attributePathParams;
-    params.mAttributePathParamsListSize = pathsCount;
+    params.mAttributePathParamsListSize = attributeCount;
 
     if (fabricFiltered.HasValue())
     {
         params.mIsFabricFiltered = fabricFiltered.Value();
     }
 
+    if (interactionType == ReadClient::InteractionType::Subscribe)
+    {
+        params.mMinIntervalFloorSeconds   = minInterval;
+        params.mMaxIntervalCeilingSeconds = maxInterval;
+        if (keepSubscriptions.HasValue())
+        {
+            params.mKeepSubscriptions = keepSubscriptions.Value();
+        }
+    }
+
     auto client = std::make_unique<ReadClient>(InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
-                                               mBufferedReadAdapter, ReadClient::InteractionType::Read);
+                                               mBufferedReadAdapter, interactionType);
     ReturnErrorOnFailure(client->SendRequest(params));
     mReadClients.push_back(std::move(client));
     return CHIP_NO_ERROR;

src/app/tests/suites/commands/interaction_model/InteractionModel.h

@@ -108,7 +108,35 @@ class InteractionModelReports
                            const chip::Optional<std::vector<bool>> & isUrgents   = chip::NullOptional);
 
     CHIP_ERROR ReadAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
-                       const chip::Optional<bool> & fabricFiltered = chip::Optional<bool>(true));
+                       std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
+                       std::vector<chip::EventId> eventIds,
+                       const chip::Optional<bool> & fabricFiltered                         = chip::Optional<bool>(true),
+                       const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional,
+                       const chip::Optional<chip::EventNumber> & eventNumber               = chip::NullOptional)
+    {
+        return ReportAll(device, endpointIds, clusterIds, attributeIds, eventIds, chip::app::ReadClient::InteractionType::Read, 0,
+                         0, fabricFiltered, dataVersions, eventNumber);
+    }
+
+    CHIP_ERROR SubscribeAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
+                            std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
+                            std::vector<chip::EventId> eventIds, uint16_t minInterval = 0, uint16_t maxInterval = 0,
+                            const chip::Optional<bool> & fabricFiltered           = chip::Optional<bool>(true),
+                            const chip::Optional<chip::EventNumber> & eventNumber = chip::NullOptional,
+                            const chip::Optional<bool> & keepSubscriptions        = chip::NullOptional)
+    {
+        return ReportAll(device, endpointIds, clusterIds, attributeIds, eventIds, chip::app::ReadClient::InteractionType::Subscribe,
+                         minInterval, maxInterval, fabricFiltered, chip::NullOptional, eventNumber, keepSubscriptions);
+    }
+
+    CHIP_ERROR ReportAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
+                         std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
+                         std::vector<chip::EventId> eventIds, chip::app::ReadClient::InteractionType interactionType,
+                         uint16_t minInterval = 0, uint16_t maxInterval = 0,
+                         const chip::Optional<bool> & fabricFiltered                         = chip::Optional<bool>(true),
+                         const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional,
+                         const chip::Optional<chip::EventNumber> & eventNumber               = chip::NullOptional,
+                         const chip::Optional<bool> & keepSubscriptions                      = chip::NullOptional);
 
     void Shutdown() { mReadClients.clear(); }