Add read/subscribe event function for darwin

examples/darwin-framework-tool/commands/clusters/ReportCommandBridge.h

@@ -184,6 +184,24 @@ class SubscribeEvent : public ModelCommand {
 public:
     SubscribeEvent()
         : ModelCommand("subscribe-all-events")
+    {
+        AddCommonArguments();
+    }
+
+    SubscribeEvent(chip::ClusterId clusterId, bool isClusterAny = false)
+        : ModelCommand("subscribe-event-by-id")
+        , mClusterId(clusterId)
+    {
+        if (isClusterAny == true) {
+            AddArgument("cluster-id", 0, UINT32_MAX, &mClusterId);
+        }
+        AddArgument("event-id", 0, UINT32_MAX, &mEventId);
+        AddArgument("event-min", 0, UINT64_MAX, &mEventNumber);
+        AddArgument("is-urgent", 0, 1, &mIsUrgent);
+        AddCommonArguments();
+    }
+
+    void AddCommonArguments()
     {
         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
@@ -199,34 +217,61 @@ class SubscribeEvent : public ModelCommand {
         dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
 
         MTRSubscribeParams * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+        if (mEventNumber.HasValue()) {
+            params.minimumEventNumber = [NSNumber numberWithUnsignedLongLong:mEventNumber.Value()];
+        }
         if (mKeepSubscriptions.HasValue()) {
             params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
         }
+        if (mIsUrgent.HasValue()) {
+            params.reportEventsUrgently = mIsUrgent.Value();
+        }
         if (mAutoResubscribe.HasValue()) {
             params.resubscribeIfLost = mAutoResubscribe.Value();
         }
 
-        [device subscribeWithQueue:callbackQueue
-            params:params
-            clusterStateCacheContainer:nil
-            attributeReportHandler:^(NSArray * value) {
-                SetCommandExitStatus(CHIP_NO_ERROR);
-            }
-            eventReportHandler:^(NSArray * value) {
-                for (id item in value) {
-                    NSLog(@"Response Item: %@", [item description]);
+        if (strcmp(GetName(), "subscribe-event-by-id") == 0) {
+            [device subscribeToEventsWithEndpointID:(endpointId == chip::kInvalidEndpointId)
+                        ? nil
+                        : [NSNumber numberWithUnsignedShort:endpointId]
+                clusterID:(mClusterId == chip::kInvalidClusterId) ? nil : [NSNumber numberWithUnsignedInteger:mClusterId]
+                eventID:(mEventId == chip::kInvalidEventId) ? nil : [NSNumber numberWithUnsignedInteger:mEventId]
+                params:params
+                queue:callbackQueue
+                reportHandler:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
+                    if (values) {
+                        for (id item in values) {
+                            NSLog(@"Response Item: %@", [item description]);
+                        }
+                    }
+                    SetCommandExitStatus(error);
                 }
-                SetCommandExitStatus(CHIP_NO_ERROR);
-            }
-            errorHandler:^(NSError * error) {
-                SetCommandExitStatus(error);
-            }
-            subscriptionEstablished:^() {
-                mSubscriptionEstablished = YES;
-            }
-            resubscriptionScheduled:^(NSError * error, NSNumber * resubscriptionDelay) {
-                NSLog(@"Subscription dropped with error %@.  Resubscription in %@ms", error, resubscriptionDelay);
-            }];
+                subscriptionEstablished:^() {
+                    mSubscriptionEstablished = YES;
+                }];
+        } else {
+            [device subscribeWithQueue:callbackQueue
+                params:params
+                clusterStateCacheContainer:nil
+                attributeReportHandler:^(NSArray * value) {
+                    SetCommandExitStatus(CHIP_NO_ERROR);
+                }
+                eventReportHandler:^(NSArray * value) {
+                    for (id item in value) {
+                        NSLog(@"Response Item: %@", [item description]);
+                    }
+                    SetCommandExitStatus(CHIP_NO_ERROR);
+                }
+                errorHandler:^(NSError * error) {
+                    SetCommandExitStatus(error);
+                }
+                subscriptionEstablished:^() {
+                    mSubscriptionEstablished = YES;
+                }
+                resubscriptionScheduled:^(NSError * error, NSNumber * resubscriptionDelay) {
+                    NSLog(@"Subscription dropped with error %@.  Resubscription in %@ms", error, resubscriptionDelay);
+                }];
+        }
 
         return CHIP_NO_ERROR;
     }
@@ -237,7 +282,82 @@ class SubscribeEvent : public ModelCommand {
     chip::Optional<bool> mKeepSubscriptions;
     chip::Optional<bool> mAutoResubscribe;
     chip::Optional<chip::EventNumber> mEventNumber;
+    chip::Optional<bool> mIsUrgent;
     bool mSubscriptionEstablished = NO;
     uint16_t mMinInterval;
     uint16_t mMaxInterval;
+
+    void Shutdown() override
+    {
+        mSubscriptionEstablished = NO;
+        ModelCommand::Shutdown();
+    }
+
+    bool DeferInteractiveCleanup() override { return mSubscriptionEstablished; }
+
+private:
+    chip::ClusterId mClusterId;
+    chip::EventId mEventId;
+};
+
+class ReadEvent : public ModelCommand {
+public:
+    ReadEvent()
+        : ModelCommand("read-event-by-id")
+    {
+        AddArgument("cluster-id", 0, UINT32_MAX, &mClusterId);
+        AddArgument("event-id", 0, UINT32_MAX, &mEventId);
+        AddArgument("event-min", 0, UINT64_MAX, &mEventNumber);
+        ModelCommand::AddArguments();
+    }
+
+    ReadEvent(chip::ClusterId clusterId)
+        : ModelCommand("read-event-by-id")
+        , mClusterId(clusterId)
+    {
+        AddArgument("event-id", 0, UINT32_MAX, &mEventId);
+        AddArgument("event-min", 0, UINT64_MAX, &mEventNumber);
+        ModelCommand::AddArguments();
+    }
+
+    ~ReadEvent() {}
+
+    CHIP_ERROR SendCommand(MTRBaseDevice * _Nonnull device, chip::EndpointId endpointId) override
+    {
+        dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+        MTRReadParams * params = [[MTRReadParams alloc] init];
+        if (mFabricFiltered.HasValue()) {
+            params.filterByFabric = mFabricFiltered.Value();
+        }
+        if (mEventNumber.HasValue()) {
+            params.minimumEventNumber = [NSNumber numberWithUnsignedLongLong:mEventNumber.Value()];
+        }
+
+        [device
+            readEventsWithEndpointID:(endpointId == chip::kInvalidEndpointId) ? nil : [NSNumber numberWithUnsignedShort:endpointId]
+                           clusterID:(mClusterId == chip::kInvalidClusterId) ? nil : [NSNumber numberWithUnsignedInteger:mClusterId]
+                             eventID:(mEventId == chip::kInvalidEventId) ? nil : [NSNumber numberWithUnsignedInteger:mEventId]
+                              params:params
+                               queue:callbackQueue
+                          completion:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
+                              if (error != nil) {
+                                  LogNSError("Error reading event", error);
+                              }
+                              if (values) {
+                                  for (id item in values) {
+                                      NSLog(@"Response Item: %@", [item description]);
+                                  }
+                              }
+                              SetCommandExitStatus(error);
+                          }];
+        return CHIP_NO_ERROR;
+    }
+
+protected:
+    chip::Optional<bool> mFabricFiltered;
+    chip::Optional<chip::EventNumber> mEventNumber;
+
+private:
+    chip::ClusterId mClusterId;
+    chip::AttributeId mEventId;
 };

examples/darwin-framework-tool/templates/commands.zapt

@@ -292,6 +292,12 @@ void registerCluster{{asUpperCamelCase name}}(Commands & commands)
         {{/if}}
         {{/unless}}
         {{/chip_server_cluster_attributes}}
+        {{#zcl_events}}
+        {{#first}}
+        make_unique<ReadEvent>(Id), //
+        make_unique<SubscribeEvent>(Id), //
+        {{/first}}
+        {{/zcl_events}}
     };
 
     commands.Register(clusterName, clusterCommands);
@@ -308,6 +314,8 @@ void registerClusterAny(Commands & commands)
         make_unique<ReadAttribute>(),   //
         make_unique<WriteAttribute>(),  //
         make_unique<SubscribeAttribute>(), //
+        make_unique<ReadEvent>(),     //
+        make_unique<SubscribeEvent>(chip::kInvalidClusterId, true), //
         make_unique<SubscribeEvent>(),     //
     };
 

src/darwin/Framework/CHIP/MTRBaseDevice.h

@@ -315,6 +315,47 @@ typedef NS_ENUM(uint8_t, MTRTransportType) {
                                       completion:(MTRDeviceOpenCommissioningWindowHandler)completion
     API_AVAILABLE(ios(16.2), macos(13.1), watchos(9.2), tvos(16.2));
 
+/**
+ * Reads events from the device.
+ *
+ * Nil values for endpointID, clusterID, eventID indicate wildcards
+ * (e.g. nil eventID means "read all the events from the endpoint(s) and
+ * cluster(s) that match endpointID/clusterID").
+ *
+ * If all of endpointID, clusterID, eventID are non-nil, all the matching instances of a single
+ * event will be read.
+ *
+ * If all of endpointID, clusterID, eventID are nil, all events on the
+ * device will be read.
+ */
+
+- (void)readEventsWithEndpointID:(NSNumber * _Nullable)endpointID
+                       clusterID:(NSNumber * _Nullable)clusterID
+                         eventID:(NSNumber * _Nullable)eventID
+                          params:(MTRReadParams * _Nullable)params
+                           queue:(dispatch_queue_t)queue
+                      completion:(MTRDeviceResponseHandler)completion MTR_NEWLY_AVAILABLE;
+
+/**
+ * Subscribes to the specified events on the device.
+ *
+ * Nil values for endpointID, clusterID, eventID indicate wildcards
+ * (e.g. nil eventID means "subscribe to all the events from the
+ * endpoint(s) and cluster(s) that match endpointID/clusterID").
+ *
+ * If all of endpointID, clusterID, eventID are non-nil, a single event
+ * will be subscribed to.
+ *
+ * If all of endpointID, clusterID, eventID are nil, all events on the
+ * device will be subscribed to.
+ */
+- (void)subscribeToEventsWithEndpointID:(NSNumber * _Nullable)endpointID
+                              clusterID:(NSNumber * _Nullable)clusterID
+                                eventID:(NSNumber * _Nullable)eventID
+                                 params:(MTRSubscribeParams * _Nullable)params
+                                  queue:(dispatch_queue_t)queue
+                          reportHandler:(MTRDeviceResponseHandler)reportHandler
+                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished MTR_NEWLY_AVAILABLE;
 @end
 
 /**