esp_matter: fix event_list issue

components/esp_matter/esp_matter_cluster.cpp

@@ -134,6 +134,9 @@ cluster_t *create(endpoint_t *endpoint, uint8_t flags)
         attribute::create_endpoint_lists(cluster, NULL, 0, 0);
     }
 
+    event::create_action_failed(cluster);
+    event::create_state_changed(cluster);
+
     return cluster;
 }
 } /* actions */
@@ -169,6 +172,9 @@ cluster_t *create(endpoint_t *endpoint, uint8_t flags)
         global::attribute::create_feature_map(cluster, 0);
     }
 
+    event::create_access_control_entry_changed(cluster);
+    event::create_access_control_extension_changed(cluster);
+
     return cluster;
 }
 } /* access_control */
@@ -219,6 +225,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    event::create_start_up(cluster);
+
     return cluster;
 }
 } /* basic_information */
@@ -342,6 +350,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    event::create_download_error(cluster);
+    event::create_state_transition(cluster);
+    event::create_version_applied(cluster);
+
     /* Commands */
     command::create_announce_ota_provider(cluster);
 
@@ -488,6 +500,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    event::create_boot_reason(cluster);
+
     command::create_test_event_trigger(cluster);
 
     return cluster;
@@ -765,6 +779,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    event::create_time_failure(cluster);
+
     return cluster;
 }
 } /* time_synchronization */
@@ -799,6 +815,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    event::create_reachable_changed(cluster);
+
     return cluster;
 }
 } /* bridged_device_basic_information */
@@ -1350,6 +1368,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         }
     }
 
+    event::create_door_lock_alarm(cluster);
+    event::create_lock_operation(cluster);
+    event::create_lock_operation_error(cluster);
+
     /* Commands */
     command::create_lock_door(cluster);
     command::create_unlock_door(cluster);

components/esp_matter/esp_matter_core.cpp

@@ -45,6 +45,7 @@
 
 using chip::CommandId;
 using chip::DataVersion;
+using chip::EventId;
 using chip::kInvalidAttributeId;
 using chip::kInvalidCommandId;
 using chip::kInvalidClusterId;
@@ -157,6 +158,11 @@ typedef struct _command {
     struct _command *next;
 } _command_t;
 
+typedef struct _event {
+    uint32_t event_id;
+    struct _event *next;
+} _event_t;
+
 typedef struct _cluster {
     uint32_t cluster_id;
     uint16_t endpoint_id;
@@ -166,6 +172,7 @@ typedef struct _cluster {
     cluster::plugin_client_init_callback_t plugin_client_init_callback;
     _attribute_t *attribute_list;
     _command_t *command_list;
+    _event_t *event_list;
     struct _cluster *next;
 } _cluster_t;
 
@@ -260,6 +267,18 @@ static int get_count(_command_t *current, int command_flag)
 }
 } /* command */
 
+namespace event {
+static int get_count(_event_t *current)
+{
+    int count = 0;
+    while (current) {
+        count++;
+        current = current->next;
+    }
+    return count;
+}
+}
+
 namespace attribute {
 
 extern esp_err_t get_data_from_attr_val(esp_matter_attr_val_t *val, EmberAfAttributeType *attribute_type,
@@ -454,6 +473,10 @@ static esp_err_t disable(endpoint_t *endpoint)
         if (endpoint_type->cluster[cluster_index].generatedCommandList) {
             esp_matter_mem_free((void *)endpoint_type->cluster[cluster_index].generatedCommandList);
         }
+        /* Free events */
+        if (endpoint_type->cluster[cluster_index].eventList) {
+            esp_matter_mem_free((void *)endpoint_type->cluster[cluster_index].eventList);
+        }
     }
     esp_matter_mem_free((void *)endpoint_type->cluster);
 
@@ -544,6 +567,10 @@ esp_err_t enable(endpoint_t *endpoint)
     int command_count = 0;
     int command_index = 0;
     int command_flag = COMMAND_FLAG_NONE;
+    EventId *event_ids = NULL;
+    _event_t *event = NULL;
+    int event_count = 0;
+    int event_index = 0;
     int endpoint_index = 0;
 
     matter_clusters = (EmberAfCluster *)esp_matter_mem_calloc(1, cluster_count * sizeof(EmberAfCluster));
@@ -631,6 +658,25 @@ esp_err_t enable(endpoint_t *endpoint)
             generated_command_ids[command_index] = kInvalidCommandId;
         }
 
+        /* Event */
+        event = cluster->event_list;
+        event_count = event::get_count(event);
+        if (event_count > 0) {
+            event_index = 0;
+            event_ids = (EventId *)esp_matter_mem_calloc(1, (event_count + 1) * sizeof(EventId));
+            if (!event_ids) {
+                ESP_LOGE(TAG, "Couldn't allocate event_ids");
+                err = ESP_ERR_NO_MEM;
+                break;
+            }
+            while (event) {
+                event_ids[event_index] = event->event_id;
+                event_index++;
+                event = event->next;
+            }
+            event_ids[event_index] = chip::kInvalidEventId;
+        }
+
         /* Fill up the cluster */
         matter_clusters[cluster_index].clusterId = cluster->cluster_id;
         matter_clusters[cluster_index].attributes = matter_attributes;
@@ -639,6 +685,8 @@ esp_err_t enable(endpoint_t *endpoint)
         matter_clusters[cluster_index].functions = (EmberAfGenericClusterFunction *)cluster->function_list;
         matter_clusters[cluster_index].acceptedCommandList = accepted_command_ids;
         matter_clusters[cluster_index].generatedCommandList = generated_command_ids;
+        matter_clusters[cluster_index].eventList = event_ids;
+        matter_clusters[cluster_index].eventCount = event_count;
 
         /* Get next cluster */
         endpoint_type->endpointSize += matter_clusters[cluster_index].clusterSize;
@@ -649,6 +697,7 @@ esp_err_t enable(endpoint_t *endpoint)
         matter_attributes = NULL;
         accepted_command_ids = NULL;
         generated_command_ids = NULL;
+        event_ids = NULL;
     }
     if (err != ESP_OK) {
         goto cleanup;
@@ -689,6 +738,9 @@ cleanup:
     if (accepted_command_ids) {
         esp_matter_mem_free(accepted_command_ids);
     }
+    if (event_ids) {
+        esp_matter_mem_free(event_ids);
+    }
     if (matter_attributes) {
         esp_matter_mem_free(matter_attributes);
     }
@@ -705,6 +757,10 @@ cleanup:
             if (matter_clusters[cluster_index].generatedCommandList) {
                 esp_matter_mem_free((void *)matter_clusters[cluster_index].generatedCommandList);
             }
+            /* Free events */
+            if (matter_clusters[cluster_index].eventList) {
+                esp_matter_mem_free((void *)matter_clusters[cluster_index].eventList);
+            }
         }
         esp_matter_mem_free(matter_clusters);
     }
@@ -1697,6 +1753,112 @@ uint16_t get_flags(command_t *command)
 
 } /* command */
 
+namespace event {
+
+event_t *create(cluster_t *cluster, uint32_t event_id)
+{
+    /* Find */
+    if (!cluster) {
+        ESP_LOGE(TAG, "Cluster cannot be NULL");
+        return NULL;
+    }
+    _cluster_t *current_cluster = (_cluster_t *)cluster;
+    event_t *existing_event = get(cluster, event_id);
+    if (existing_event) {
+        ESP_LOGW(TAG, "Event 0x%08" PRIX32 " on cluster 0x%08" PRIX32 " already exists. Not creating again.", event_id,
+                 current_cluster->cluster_id);
+        return existing_event;
+    }
+
+    /* Allocate */
+    _event_t *event = (_event_t *)esp_matter_mem_calloc(1, sizeof(_event_t));
+    if (!event) {
+        ESP_LOGE(TAG, "Couldn't allocate _event_t");
+        return NULL;
+    }
+
+    /* Set */
+    event->event_id = event_id;
+
+    /* Add */
+    _event_t *previous_event = NULL;
+    _event_t *current_event = current_cluster->event_list;
+    while (current_event) {
+        previous_event = current_event;
+        current_event = current_event->next;
+    }
+    if (previous_event == NULL) {
+        current_cluster->event_list = event;
+    } else {
+        previous_event->next = event;
+    }
+
+    return (event_t *)event;
+}
+
+static esp_err_t destroy(event_t *event)
+{
+    if (!event) {
+        ESP_LOGE(TAG, "Event cannot be NULL");
+        return ESP_ERR_INVALID_ARG;
+    }
+    _event_t *current_event = (_event_t *)event;
+
+    /* Free */
+    esp_matter_mem_free(current_event);
+    return ESP_OK;
+}
+
+event_t *get(cluster_t *cluster, uint32_t event_id)
+{
+    if (!cluster) {
+        ESP_LOGE(TAG, "Cluster cannot be NULL");
+        return NULL;
+    }
+    _cluster_t *current_cluster = (_cluster_t *)cluster;
+    _event_t *current_event = (_event_t *)current_cluster->event_list;
+    while (current_event) {
+        if (current_event->event_id == event_id) {
+            break;
+        }
+        current_event = current_event->next;
+    }
+    return (event_t *)current_event;
+}
+
+event_t *get_first(cluster_t *cluster)
+{
+    if (!cluster) {
+        ESP_LOGE(TAG, "Cluster cannot be NULL");
+        return NULL;
+    }
+    _cluster_t *current_cluster = (_cluster_t *)cluster;
+    return (event_t *)current_cluster->event_list;
+}
+
+event_t *get_next(event_t *event)
+{
+    if (!event) {
+        ESP_LOGE(TAG, "Event cannot be NULL");
+        return NULL;
+    }
+    _event_t *current_event = (_event_t *)event;
+    return (event_t *)current_event->next;
+}
+
+uint32_t get_id(event_t *event)
+{
+    if (!event) {
+        ESP_LOGE(TAG, "Event cannot be NULL");
+        return NULL;
+    }
+    _event_t *current_event = (_event_t *)event;
+    return current_event->event_id;
+}
+
+} /* event */
+
+
 namespace cluster {
 
 cluster_t *create(endpoint_t *endpoint, uint32_t cluster_id, uint8_t flags)
@@ -1787,6 +1949,14 @@ static esp_err_t destroy(cluster_t *cluster)
         attribute = next_attribute;
     }
 
+    /* Parse and delete all events */
+    _event_t *event = current_cluster->event_list;
+    while (event) {
+        _event_t *next_event = event->next;
+        event::destroy((event_t *)event);
+        event = next_event;
+    }
+
     /* Free */
     esp_matter_mem_free(current_cluster);
     return ESP_OK;

components/esp_matter/esp_matter_core.h

@@ -38,6 +38,8 @@ typedef handle_t cluster_t;
 typedef handle_t attribute_t;
 /** Command handle */
 typedef handle_t command_t;
+/** Event handle */
+typedef handle_t event_t;
 
 /** Event callback
  *
@@ -730,6 +732,67 @@ uint16_t get_flags(command_t *command);
 
 } /* command */
 
+namespace event {
+
+/** Create event
+ *
+ * This will create a new event and add it to the cluster.
+ *
+ * @param[in] cluster Cluster handle.
+ * @param[in] event_id Event ID for the event.
+ *
+ * @return Event handle on success.
+ * @return NULL in case of failure.
+ */
+event_t *create(cluster_t *cluster, uint32_t event_id);
+
+/** Get event
+ *
+ * Get the event present on the cluster.
+ *
+ * @param[in] cluster Cluster handle.
+ * @param[in] event_id Event ID for the command.
+ *
+ * @return Event handle on success.
+ * @return NULL in case of failure.
+ */
+event_t *get(cluster_t *cluster, uint32_t event_id);
+
+/** Get first event
+ *
+ * Get the first event present on the cluster.
+ *
+ * @param[in] cluster Cluster handle.
+ *
+ * @return Event handle on success.
+ * @return NULL in case of failure.
+ */
+event_t *get_first(cluster_t *cluster);
+
+/** Get next event
+ *
+ * Get the next event present on the cluster.
+ *
+ * @param[in] event Event handle.
+ *
+ * @return Event handle on success.
+ * @return NULL in case of failure.
+ */
+event_t *get_next(event_t *event);
+
+/** Get event ID
+ *
+ * Get the event ID for the event.
+ *
+ * @param[in] event Event handle.
+ *
+ * @return Event ID on success.
+ * @return Invalid Event ID (0xFFFF'FFFF) in case of failure.
+ */
+uint32_t get_id(event_t *event);
+
+} /* event */
+
 /* Client APIs */
 namespace client {
 

components/esp_matter/esp_matter_event.cpp

@@ -18,17 +18,278 @@
 #include <app/clusters/switch-server/switch-server.h>
 #include <platform/DeviceControlServer.h>
 
-
-using chip::DeviceLayer::DeviceControlServer;
 using chip::EndpointId;
+using chip::DeviceLayer::DeviceControlServer;
 using namespace chip::app::Clusters;
 
 namespace esp_matter {
 namespace cluster {
+namespace access_control {
+namespace event {
+esp_err_t create_access_control_entry_changed(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, AccessControl::Events::AccessControlEntryChanged::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_access_control_extension_changed(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, AccessControl::Events::AccessControlExtensionChanged::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t send_state_changed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state)
+{
+    /* Not implemented */
+    return ESP_OK;
+}
+
+esp_err_t send_action_failed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state,
+                             uint8_t error)
+{
+    /* Not implemented */
+    return ESP_OK;
+}
+
+} // namespace event
+} // namespace access_control
+
+namespace actions {
+namespace event {
+esp_err_t create_state_changed(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Actions::Events::StateChanged::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_action_failed(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Actions::Events::ActionFailed::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace actions
+
+namespace basic_information {
+namespace event {
+esp_err_t create_start_up(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BasicInformation::Events::StartUp::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_shut_down(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BasicInformation::Events::ShutDown::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_leave(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BasicInformation::Events::Leave::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_reachable_changed(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BasicInformation::Events::ReachableChanged::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace basic_information
+
+namespace ota_requestor {
+namespace event {
+esp_err_t create_state_transition(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, OtaSoftwareUpdateRequestor::Events::StateTransition::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_version_applied(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, OtaSoftwareUpdateRequestor::Events::VersionApplied::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_download_error(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, OtaSoftwareUpdateRequestor::Events::DownloadError::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace ota_requestor
+
+namespace general_diagnostics {
+namespace event {
+esp_err_t create_hardware_fault_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, GeneralDiagnostics::Events::HardwareFaultChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_radio_fault_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, GeneralDiagnostics::Events::RadioFaultChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_network_fault_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, GeneralDiagnostics::Events::NetworkFaultChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_boot_reason(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, GeneralDiagnostics::Events::BootReason::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace general_diagnostics
+
+namespace diagnostics_network_wifi {
+namespace event {
+esp_err_t create_disconnection(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, WiFiNetworkDiagnostics::Events::Disconnection::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_association_failure(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, WiFiNetworkDiagnostics::Events::AssociationFailure::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_connection_status(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, WiFiNetworkDiagnostics::Events::ConnectionStatus::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace diagnostics_network_wifi
+
+namespace diagnostics_network_thread {
+namespace event {
+esp_err_t create_connection_status(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, ThreadNetworkDiagnostics::Events::ConnectionStatus::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_network_fault_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, ThreadNetworkDiagnostics::Events::NetworkFaultChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace diagnostics_network_thread
+
+namespace time_synchronization {
+namespace event {
+esp_err_t create_dst_table_empty(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, TimeSynchronization::Events::DSTTableEmpty::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_dst_status(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, TimeSynchronization::Events::DSTStatus::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_time_zone_status(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, TimeSynchronization::Events::TimeZoneStatus::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_time_failure(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, TimeSynchronization::Events::TimeFailure::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_missing_trusted_time_source(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, TimeSynchronization::Events::MissingTrustedTimeSource::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace time_synchronization
+
+namespace bridged_device_basic_information {
+namespace event {
+
+esp_err_t create_start_up(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::StartUp::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_shut_down(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::ShutDown::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_leave(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::Leave::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_reachable_changed(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::ReachableChanged::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace bridged_device_basic_information
 
 namespace door_lock {
 namespace event {
 
+esp_err_t create_door_lock_alarm(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, DoorLock::Events::DoorLockAlarm::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_door_state_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, DoorLock::Events::DoorStateChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_lock_operation(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, DoorLock::Events::LockOperation::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_lock_operation_error(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, DoorLock::Events::LockOperationError::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_lock_user_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, DoorLock::Events::LockUserChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
 esp_err_t send_door_lock_alarm()
 {
     /* Not implemented */
@@ -59,12 +320,219 @@ esp_err_t send_lock_user_change()
     return ESP_OK;
 }
 
-} /* event */
+} // namespace event
-} /* door_lock */
+} // namespace door_lock
+
+namespace switch_cluster {
+namespace event {
+
+esp_err_t create_switch_latched(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::SwitchLatched::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_initial_press(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::InitialPress::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_long_press(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::LongPress::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_short_release(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::ShortRelease::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_long_release(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::LongRelease::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_multi_press_ongoing(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::MultiPressOngoing::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_multi_press_complete(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, Switch::Events::MultiPressComplete::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t send_switch_latched(EndpointId endpoint, uint8_t new_position)
+{
+    SwitchServer::Instance().OnSwitchLatch(endpoint, new_position);
+    return ESP_OK;
+}
+
+esp_err_t send_initial_press(EndpointId endpoint, uint8_t new_position)
+{
+    SwitchServer::Instance().OnInitialPress(endpoint, new_position);
+    return ESP_OK;
+}
+
+esp_err_t send_long_press(EndpointId endpoint, uint8_t new_position)
+{
+    SwitchServer::Instance().OnLongPress(endpoint, new_position);
+    return ESP_OK;
+}
+
+esp_err_t send_short_release(EndpointId endpoint, uint8_t previous_position)
+{
+    SwitchServer::Instance().OnShortRelease(endpoint, previous_position);
+    return ESP_OK;
+}
+
+esp_err_t send_long_release(EndpointId endpoint, uint8_t previous_position)
+{
+    SwitchServer::Instance().OnLongRelease(endpoint, previous_position);
+    return ESP_OK;
+}
+
+esp_err_t send_multi_press_ongoing(EndpointId endpoint, uint8_t new_position, uint8_t count)
+{
+    SwitchServer::Instance().OnMultiPressOngoing(endpoint, new_position, count);
+    return ESP_OK;
+}
+
+esp_err_t send_multi_press_complete(EndpointId endpoint, uint8_t new_position, uint8_t count)
+{
+    SwitchServer::Instance().OnMultiPressComplete(endpoint, new_position, count);
+    return ESP_OK;
+}
+
+} // namespace event
+} // namespace switch_cluster
+
+namespace boolean_state {
+namespace event {
+
+esp_err_t create_state_change(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, BooleanState::Events::StateChange::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+} // namespace event
+} // namespace boolean_state
 
 namespace pump_configuration_and_control {
 namespace event {
 
+esp_err_t create_supply_voltage_low(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SupplyVoltageLow::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_supply_voltage_high(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SupplyVoltageHigh::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_power_missing_phase(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::PowerMissingPhase::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_system_pressure_low(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SystemPressureLow::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_system_pressure_high(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SystemPressureHigh::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_dry_running(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::DryRunning::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_motor_temperature_high(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::MotorTemperatureHigh::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_pump_motor_fatal_failure(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::PumpMotorFatalFailure::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_electronic_temperature_high(cluster_t *cluster)
+{
+    event_t *event =
+        esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::ElectronicTemperatureHigh::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_pump_blocked(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::PumpBlocked::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_sensor_failure(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SensorFailure::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_electronic_non_fatal_failure(cluster_t *cluster)
+{
+    event_t *event =
+        esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::ElectronicNonFatalFailure::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_electronic_fatal_failure(cluster_t *cluster)
+{
+    event_t *event =
+        esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::ElectronicFatalFailure::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_general_fault(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::GeneralFault::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_leakage(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::Leakage::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_air_detection(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::AirDetection::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
+esp_err_t create_turbine_operation(cluster_t *cluster)
+{
+    event_t *event = esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::TurbineOperation::Id);
+    return event ? ESP_OK : ESP_FAIL;
+}
+
 esp_err_t send_supply_voltage_low()
 {
     /* Not implemented */
@@ -167,73 +635,8 @@ esp_err_t send_turbine_operation()
     return ESP_OK;
 }
 
-} /* event */
+} // namespace event
-} /* pump_configuration_and_control */
+} // namespace pump_configuration_and_control
 
-namespace actions {
+} // namespace cluster
-namespace event {
+} // namespace esp_matter
-esp_err_t send_state_changed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state)
-{
-    /* Not implemented */
-    return ESP_OK;
-}
-
-esp_err_t send_action_failed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state,
-                             uint8_t error)
-{
-    /* Not implemented */
-    return ESP_OK;
-}
-} /* event */
-} /* actions */
-
-namespace switch_cluster {
-namespace event {
-
-esp_err_t send_switch_latched(EndpointId endpoint, uint8_t new_position)
-{
-    SwitchServer::Instance().OnSwitchLatch(endpoint, new_position);
-    return ESP_OK;
-}
-
-esp_err_t send_initial_press(EndpointId endpoint, uint8_t new_position)
-{
-    SwitchServer::Instance().OnInitialPress(endpoint, new_position);
-    return ESP_OK;
-}
-
-esp_err_t send_long_press(EndpointId endpoint, uint8_t new_position)
-{
-    SwitchServer::Instance().OnLongPress(endpoint, new_position);
-    return ESP_OK;
-}
-
-esp_err_t send_short_release(EndpointId endpoint, uint8_t previous_position)
-{
-    SwitchServer::Instance().OnShortRelease(endpoint, previous_position);
-    return ESP_OK;
-}
-
-esp_err_t send_long_release(EndpointId endpoint, uint8_t previous_position)
-{
-    SwitchServer::Instance().OnLongRelease(endpoint, previous_position);
-    return ESP_OK;
-}
-
-esp_err_t send_multi_press_ongoing(EndpointId endpoint, uint8_t new_position, uint8_t count)
-{
-    SwitchServer::Instance().OnMultiPressOngoing(endpoint, new_position, count);
-    return ESP_OK;
-}
-
-esp_err_t send_multi_press_complete(EndpointId endpoint, uint8_t new_position, uint8_t count)
-{
-    SwitchServer::Instance().OnMultiPressComplete(endpoint, new_position, count);
-    return ESP_OK;
-}
-
-} /* event */
-} /* switch_cluster */
-
-} /* cluster */
-} /* esp_matter */

components/esp_matter/esp_matter_event.h

@@ -15,6 +15,7 @@
 #pragma once
 
 #include <esp_err.h>
+#include <esp_matter.h>
 #include <platform/DeviceControlServer.h>
 
 namespace esp_matter {
@@ -25,8 +26,100 @@ namespace cluster {
  * If some standard event is not present here, it can be added.
  */
 
+namespace access_control {
+namespace event {
+esp_err_t create_access_control_entry_changed(cluster_t *cluster);
+esp_err_t create_access_control_extension_changed(cluster_t *cluster);
+} // namespace event
+} // namespace access_control
+
+namespace actions {
+namespace event {
+esp_err_t create_state_changed(cluster_t *cluster);
+esp_err_t create_action_failed(cluster_t *cluster);
+} // namespace event
+} // namespace actions
+
+namespace basic_information {
+namespace event {
+esp_err_t create_start_up(cluster_t *cluster);
+esp_err_t create_shut_down(cluster_t *cluster);
+esp_err_t create_leave(cluster_t *cluster);
+esp_err_t create_reachable_changed(cluster_t *cluster);
+} // namespace event
+} // namespace basic_information
+
+namespace ota_requestor {
+namespace event {
+esp_err_t create_state_transition(cluster_t *cluster);
+esp_err_t create_version_applied(cluster_t *cluster);
+esp_err_t create_download_error(cluster_t *cluster);
+} // namespace event
+} // namespace ota_requestor
+
+namespace general_diagnostics {
+namespace event {
+esp_err_t create_hardware_fault_change(cluster_t *cluster);
+esp_err_t create_radio_fault_change(cluster_t *cluster);
+esp_err_t create_network_fault_change(cluster_t *cluster);
+esp_err_t create_boot_reason(cluster_t *cluster);
+} // namespace event
+} // namespace general_diagnostics
+
+namespace diagnostics_network_wifi {
+namespace event {
+esp_err_t create_disconnection(cluster_t *cluster);
+esp_err_t create_association_failure(cluster_t *cluster);
+esp_err_t create_connection_status(cluster_t *cluster);
+} // namespace event
+} // namespace diagnostics_network_wifi
+
+namespace diagnostics_network_thread {
+namespace event {
+esp_err_t create_connection_status(cluster_t *cluster);
+esp_err_t create_network_fault_change(cluster_t *cluster);
+} // namespace event
+} // namespace diagnostics_network_thread
+
+namespace time_synchronization {
+namespace event {
+esp_err_t create_dst_table_empty(cluster_t *cluster);
+esp_err_t create_dst_status(cluster_t *cluster);
+esp_err_t create_time_zone_status(cluster_t *cluster);
+esp_err_t create_time_failure(cluster_t *cluster);
+esp_err_t create_missing_trusted_time_source(cluster_t *cluster);
+} // namespace event
+} // namespace time_synchronization
+
+namespace bridged_device_basic_information {
+namespace event {
+esp_err_t create_start_up(cluster_t *cluster);
+esp_err_t create_shut_down(cluster_t *cluster);
+esp_err_t create_leave(cluster_t *cluster);
+esp_err_t create_reachable_changed(cluster_t *cluster);
+} // namespace event
+} // namespace bridged_device_basic_information
+
+namespace door_lock {
+namespace event {
+esp_err_t create_door_lock_alarm(cluster_t *cluster);
+esp_err_t create_door_state_change(cluster_t *cluster);
+esp_err_t create_lock_operation(cluster_t *cluster);
+esp_err_t create_lock_operation_error(cluster_t *cluster);
+esp_err_t create_lock_user_change(cluster_t *cluster);
+} // namespace event
+} // namespace door_lock
+
 namespace switch_cluster {
 namespace event {
+esp_err_t create_switch_latched(cluster_t *cluster);
+esp_err_t create_initial_press(cluster_t *cluster);
+esp_err_t create_long_press(cluster_t *cluster);
+esp_err_t create_short_release(cluster_t *cluster);
+esp_err_t create_long_release(cluster_t *cluster);
+esp_err_t create_multi_press_ongoing(cluster_t *cluster);
+esp_err_t create_multi_press_complete(cluster_t *cluster);
+
 esp_err_t send_switch_latched(chip::EndpointId endpoint, uint8_t new_position);
 esp_err_t send_initial_press(chip::EndpointId endpoint, uint8_t new_position);
 esp_err_t send_long_press(chip::EndpointId endpoint, uint8_t new_position);
@@ -34,8 +127,36 @@ esp_err_t send_short_release(chip::EndpointId endpoint, uint8_t previous_positio
 esp_err_t send_long_release(chip::EndpointId endpoint, uint8_t previous_position);
 esp_err_t send_multi_press_ongoing(chip::EndpointId endpoint, uint8_t new_position, uint8_t count);
 esp_err_t send_multi_press_complete(chip::EndpointId endpoint, uint8_t new_position, uint8_t count);
-} /* event */
+} // namespace event
-} /* switch_cluster */
+} // namespace switch_cluster
 
-} /* cluster */
+namespace boolean_state {
-} /* esp_matter */
+namespace event {
+esp_err_t create_state_change(cluster_t *cluster);
+}
+} // namespace boolean_state
+
+namespace pump_configuration_and_control {
+namespace event {
+esp_err_t create_supply_voltage_low(cluster_t *cluster);
+esp_err_t create_supply_voltage_high(cluster_t *cluster);
+esp_err_t create_power_missing_phase(cluster_t *cluster);
+esp_err_t create_system_pressure_low(cluster_t *cluster);
+esp_err_t create_system_pressure_high(cluster_t *cluster);
+esp_err_t create_dry_running(cluster_t *cluster);
+esp_err_t create_motor_temperature_high(cluster_t *cluster);
+esp_err_t create_pump_motor_fatal_failure(cluster_t *cluster);
+esp_err_t create_electronic_temperature_high(cluster_t *cluster);
+esp_err_t create_pump_blocked(cluster_t *cluster);
+esp_err_t create_sensor_failure(cluster_t *cluster);
+esp_err_t create_electronic_non_fatal_failure(cluster_t *cluster);
+esp_err_t create_electronic_fatal_failure(cluster_t *cluster);
+esp_err_t create_general_fault(cluster_t *cluster);
+esp_err_t create_leakage(cluster_t *cluster);
+esp_err_t create_air_detection(cluster_t *cluster);
+esp_err_t create_turbine_operation(cluster_t *cluster);
+} // namespace event
+} // namespace pump_configuration_and_control
+
+} // namespace cluster
+} // namespace esp_matter