From cc2aeedf97df602112b439ea952e186c687af3ef Mon Sep 17 00:00:00 2001 From: David Rempel Date: Thu, 19 Dec 2024 11:07:26 -0800 Subject: [PATCH 1/5] Added Thermostat events to thermostat xml. --- .../data-model/chip/thermostat-cluster.xml | 91 ++++++++++++++++++- 1 file changed, 87 insertions(+), 4 deletions(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml index e2109af8dda365..831d47c8dc906e 100644 --- a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml @@ -309,6 +309,9 @@ limitations under the License. + + + @@ -675,17 +678,97 @@ limitations under the License. Returns the status of an atomic write - - + + Begins, Commits or Cancels an atomic write - - + + + + + This event SHALL be generated when the SystemMode attribute changes. + + + + + + + + + This field SHALL indicate the current value of the LocalTemperature attribute. + + + + + + + + + + + + This event SHALL be generated when the Occupancy attribute changes. + + + + + + + + + + This event SHALL be generated when the value of any of the OccupiedHeatingSetpoint, UnoccupiedHeatingSetpoint>>, OccupiedCoolingSetpoint, or UnoccupiedCoolingSetpoint attributes is changed + + + + + + + + + + + This event SHALL be generated when the ThermostatRunningState attribute changes. + + + + + + + + + This event SHALL be generated when the ThermostatRunningMode attribute changes. + + + + + + + + + This event SHALL be generated when the ActiveScheduleHandle attribute changes. + + + + + + + + + + This event SHALL be generated when the ActivePresetHandle attribute changes. + + + + + + + From 880c50ddc79839effe6e6c5b5f0c460d38c20ce2 Mon Sep 17 00:00:00 2001 From: David Rempel Date: Thu, 19 Dec 2024 12:18:09 -0800 Subject: [PATCH 2/5] Added the codegen for the thermostat cluster events --- .../air-purifier-app.matter | 42 ++ .../all-clusters-app.matter | 42 ++ .../all-clusters-minimal-app.matter | 42 ++ ...umiditysensor_thermostat_56de3d5f45.matter | 42 ++ ...tnode_heatingcoolingunit_ncdGai1E5a.matter | 42 ++ .../rootnode_heatpump_87ivjRAECh.matter | 42 ++ ...tnode_roomairconditioner_9cf3607804.matter | 42 ++ .../rootnode_thermostat_bm3fb8dhYi.matter | 42 ++ .../placeholder/linux/apps/app1/config.matter | 84 +++ .../placeholder/linux/apps/app2/config.matter | 84 +++ .../nxp/zap/thermostat_matter_br.matter | 42 ++ .../nxp/zap/thermostat_matter_thread.matter | 42 ++ .../nxp/zap/thermostat_matter_wifi.matter | 42 ++ .../qpg/zap/thermostaticRadiatorValve.matter | 42 ++ .../thermostat-common/thermostat.matter | 42 ++ .../data_model/controller-clusters.matter | 42 ++ .../devicecontroller/ChipEventStructs.java | 503 ++++++++++++++++++ .../devicecontroller/ClusterIDMapping.java | 10 +- ...hermostatClusterActivePresetChangeEvent.kt | 61 +++ ...rmostatClusterActiveScheduleChangeEvent.kt | 64 +++ ...ostatClusterLocalTemperatureChangeEvent.kt | 53 ++ .../ThermostatClusterOccupancyChangeEvent.kt | 59 ++ ...ThermostatClusterRunningModeChangeEvent.kt | 59 ++ ...hermostatClusterRunningStateChangeEvent.kt | 59 ++ .../ThermostatClusterSetpointChangeEvent.kt | 74 +++ .../ThermostatClusterSystemModeChangeEvent.kt | 59 ++ .../chip/devicecontroller/cluster/files.gni | 8 + ...hermostatClusterActivePresetChangeEvent.kt | 61 +++ ...rmostatClusterActiveScheduleChangeEvent.kt | 64 +++ ...ostatClusterLocalTemperatureChangeEvent.kt | 53 ++ .../ThermostatClusterOccupancyChangeEvent.kt | 59 ++ ...ThermostatClusterRunningModeChangeEvent.kt | 59 ++ ...hermostatClusterRunningStateChangeEvent.kt | 59 ++ .../ThermostatClusterSetpointChangeEvent.kt | 74 +++ .../ThermostatClusterSystemModeChangeEvent.kt | 59 ++ .../java/matter/controller/cluster/files.gni | 8 + .../CHIPEventTLVValueDecoder.cpp | 382 +++++++++++++ .../python/chip/clusters/Objects.py | 172 ++++++ .../CHIP/zap-generated/MTRBaseClusters.h | 1 + .../CHIP/zap-generated/MTRClusterConstants.h | 12 + .../CHIP/zap-generated/MTRClusterNames.mm | 33 ++ .../zap-generated/MTREventTLVValueDecoder.mm | 181 +++++++ .../CHIP/zap-generated/MTRStructsObjc.h | 49 ++ .../CHIP/zap-generated/MTRStructsObjc.mm | 243 +++++++++ .../app-common/zap-generated/cluster-enums.h | 1 + .../zap-generated/cluster-objects.cpp | 328 +++++++++++- .../zap-generated/cluster-objects.h | 293 ++++++++++ .../app-common/zap-generated/ids/Events.h | 38 ++ .../zap-generated/cluster/Commands.h | 28 +- .../cluster/logging/DataModelLogger.cpp | 246 +++++++++ .../cluster/logging/DataModelLogger.h | 16 + .../zap-generated/cluster/Commands.h | 10 + 52 files changed, 4290 insertions(+), 4 deletions(-) create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt diff --git a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter index be9b08eecf6c5d..a50e5855ba1113 100644 --- a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter +++ b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter @@ -1656,6 +1656,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1764,6 +1765,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index be6f4c0622c94a..e0cfe5a7ad3f3a 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -5519,6 +5519,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5627,6 +5628,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter index e7c61c1c308a05..adaa874c48b2af 100644 --- a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter +++ b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter @@ -3931,6 +3931,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -4039,6 +4040,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter index dfa25e487b78e9..e62c3ddd5415d8 100644 --- a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter +++ b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter @@ -1579,6 +1579,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1687,6 +1688,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter index 76eac769b14b2b..36c24a441fe7b7 100644 --- a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter +++ b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter @@ -1875,6 +1875,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1983,6 +1984,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter index ecd48d74867218..d677e0c903adba 100644 --- a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter +++ b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter @@ -2138,6 +2138,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -2246,6 +2247,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter index bb4a46da845f29..318f52134f9096 100644 --- a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter +++ b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter @@ -1519,6 +1519,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1627,6 +1628,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter index 549c98f930b62b..c5d5379c2dec7a 100644 --- a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter +++ b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter @@ -1739,6 +1739,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1847,6 +1848,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/placeholder/linux/apps/app1/config.matter b/examples/placeholder/linux/apps/app1/config.matter index 6bc47afef7015b..e87e8146544d10 100644 --- a/examples/placeholder/linux/apps/app1/config.matter +++ b/examples/placeholder/linux/apps/app1/config.matter @@ -5218,6 +5218,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5326,6 +5327,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; @@ -5573,6 +5615,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5681,6 +5724,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/placeholder/linux/apps/app2/config.matter b/examples/placeholder/linux/apps/app2/config.matter index 9b116eb8ba7780..49c12cde2a8f08 100644 --- a/examples/placeholder/linux/apps/app2/config.matter +++ b/examples/placeholder/linux/apps/app2/config.matter @@ -5175,6 +5175,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5283,6 +5284,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; @@ -5530,6 +5572,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5638,6 +5681,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_br.matter b/examples/thermostat/nxp/zap/thermostat_matter_br.matter index 1ba87a1fbd58b5..ea9675edcc5e8a 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_br.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_br.matter @@ -1891,6 +1891,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1999,6 +2000,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter index af687b2ba11bcb..2a558d7ad9bd7f 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter @@ -1814,6 +1814,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1922,6 +1923,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter index 825a527c59b155..eab75a84860442 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter @@ -1725,6 +1725,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1833,6 +1834,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter index 96ed93bd8c07b9..5223ec2f76fd3a 100644 --- a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter +++ b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter @@ -1938,6 +1938,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -2046,6 +2047,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/thermostat-common/thermostat.matter b/examples/thermostat/thermostat-common/thermostat.matter index 03428f294324cf..84b581797c4280 100644 --- a/examples/thermostat/thermostat-common/thermostat.matter +++ b/examples/thermostat/thermostat-common/thermostat.matter @@ -2118,6 +2118,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -2226,6 +2227,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index aa2707931f36d6..223c784442bae6 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -6818,6 +6818,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -6926,6 +6927,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java index 59892d05188b8a..6c00351773f4fd 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java @@ -5825,6 +5825,509 @@ public String toString() { return output.toString(); } } +public static class ThermostatClusterSystemModeChangeEvent { + public Integer previousSystemMode; + public Integer currentSystemMode; + private static final long PREVIOUS_SYSTEM_MODE_ID = 0L; + private static final long CURRENT_SYSTEM_MODE_ID = 1L; + + public ThermostatClusterSystemModeChangeEvent( + Integer previousSystemMode, + Integer currentSystemMode + ) { + this.previousSystemMode = previousSystemMode; + this.currentSystemMode = currentSystemMode; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_SYSTEM_MODE_ID, new UIntType(previousSystemMode))); + values.add(new StructElement(CURRENT_SYSTEM_MODE_ID, new UIntType(currentSystemMode))); + + return new StructType(values); + } + + public static ThermostatClusterSystemModeChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousSystemMode = null; + Integer currentSystemMode = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_SYSTEM_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousSystemMode = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_SYSTEM_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentSystemMode = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterSystemModeChangeEvent( + previousSystemMode, + currentSystemMode + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterSystemModeChangeEvent {\n"); + output.append("\tpreviousSystemMode: "); + output.append(previousSystemMode); + output.append("\n"); + output.append("\tcurrentSystemMode: "); + output.append(currentSystemMode); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterLocalTemperatureChangeEvent { + public Integer currentLocalTemperature; + private static final long CURRENT_LOCAL_TEMPERATURE_ID = 0L; + + public ThermostatClusterLocalTemperatureChangeEvent( + Integer currentLocalTemperature + ) { + this.currentLocalTemperature = currentLocalTemperature; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(CURRENT_LOCAL_TEMPERATURE_ID, new IntType(currentLocalTemperature))); + + return new StructType(values); + } + + public static ThermostatClusterLocalTemperatureChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer currentLocalTemperature = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == CURRENT_LOCAL_TEMPERATURE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + currentLocalTemperature = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterLocalTemperatureChangeEvent( + currentLocalTemperature + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterLocalTemperatureChangeEvent {\n"); + output.append("\tcurrentLocalTemperature: "); + output.append(currentLocalTemperature); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterOccupancyChangeEvent { + public Integer previousOccupancy; + public Integer currentOccupancy; + private static final long PREVIOUS_OCCUPANCY_ID = 0L; + private static final long CURRENT_OCCUPANCY_ID = 1L; + + public ThermostatClusterOccupancyChangeEvent( + Integer previousOccupancy, + Integer currentOccupancy + ) { + this.previousOccupancy = previousOccupancy; + this.currentOccupancy = currentOccupancy; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_OCCUPANCY_ID, new UIntType(previousOccupancy))); + values.add(new StructElement(CURRENT_OCCUPANCY_ID, new UIntType(currentOccupancy))); + + return new StructType(values); + } + + public static ThermostatClusterOccupancyChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousOccupancy = null; + Integer currentOccupancy = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_OCCUPANCY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousOccupancy = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_OCCUPANCY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentOccupancy = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterOccupancyChangeEvent( + previousOccupancy, + currentOccupancy + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterOccupancyChangeEvent {\n"); + output.append("\tpreviousOccupancy: "); + output.append(previousOccupancy); + output.append("\n"); + output.append("\tcurrentOccupancy: "); + output.append(currentOccupancy); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterSetpointChangeEvent { + public Integer systemMode; + public Integer occupancy; + public Integer previousSetpoint; + public Integer currentSetpoint; + private static final long SYSTEM_MODE_ID = 0L; + private static final long OCCUPANCY_ID = 1L; + private static final long PREVIOUS_SETPOINT_ID = 2L; + private static final long CURRENT_SETPOINT_ID = 3L; + + public ThermostatClusterSetpointChangeEvent( + Integer systemMode, + Integer occupancy, + Integer previousSetpoint, + Integer currentSetpoint + ) { + this.systemMode = systemMode; + this.occupancy = occupancy; + this.previousSetpoint = previousSetpoint; + this.currentSetpoint = currentSetpoint; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(SYSTEM_MODE_ID, new UIntType(systemMode))); + values.add(new StructElement(OCCUPANCY_ID, new UIntType(occupancy))); + values.add(new StructElement(PREVIOUS_SETPOINT_ID, new IntType(previousSetpoint))); + values.add(new StructElement(CURRENT_SETPOINT_ID, new IntType(currentSetpoint))); + + return new StructType(values); + } + + public static ThermostatClusterSetpointChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer systemMode = null; + Integer occupancy = null; + Integer previousSetpoint = null; + Integer currentSetpoint = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == SYSTEM_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + systemMode = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == OCCUPANCY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + occupancy = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == PREVIOUS_SETPOINT_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + previousSetpoint = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_SETPOINT_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + currentSetpoint = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterSetpointChangeEvent( + systemMode, + occupancy, + previousSetpoint, + currentSetpoint + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterSetpointChangeEvent {\n"); + output.append("\tsystemMode: "); + output.append(systemMode); + output.append("\n"); + output.append("\toccupancy: "); + output.append(occupancy); + output.append("\n"); + output.append("\tpreviousSetpoint: "); + output.append(previousSetpoint); + output.append("\n"); + output.append("\tcurrentSetpoint: "); + output.append(currentSetpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterRunningStateChangeEvent { + public Integer previousRunningState; + public Integer currentRunningState; + private static final long PREVIOUS_RUNNING_STATE_ID = 0L; + private static final long CURRENT_RUNNING_STATE_ID = 1L; + + public ThermostatClusterRunningStateChangeEvent( + Integer previousRunningState, + Integer currentRunningState + ) { + this.previousRunningState = previousRunningState; + this.currentRunningState = currentRunningState; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_RUNNING_STATE_ID, new UIntType(previousRunningState))); + values.add(new StructElement(CURRENT_RUNNING_STATE_ID, new UIntType(currentRunningState))); + + return new StructType(values); + } + + public static ThermostatClusterRunningStateChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousRunningState = null; + Integer currentRunningState = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_RUNNING_STATE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousRunningState = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_RUNNING_STATE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentRunningState = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterRunningStateChangeEvent( + previousRunningState, + currentRunningState + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterRunningStateChangeEvent {\n"); + output.append("\tpreviousRunningState: "); + output.append(previousRunningState); + output.append("\n"); + output.append("\tcurrentRunningState: "); + output.append(currentRunningState); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterRunningModeChangeEvent { + public Integer previousRunningMode; + public Integer currentRunningMode; + private static final long PREVIOUS_RUNNING_MODE_ID = 0L; + private static final long CURRENT_RUNNING_MODE_ID = 1L; + + public ThermostatClusterRunningModeChangeEvent( + Integer previousRunningMode, + Integer currentRunningMode + ) { + this.previousRunningMode = previousRunningMode; + this.currentRunningMode = currentRunningMode; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_RUNNING_MODE_ID, new UIntType(previousRunningMode))); + values.add(new StructElement(CURRENT_RUNNING_MODE_ID, new UIntType(currentRunningMode))); + + return new StructType(values); + } + + public static ThermostatClusterRunningModeChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousRunningMode = null; + Integer currentRunningMode = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_RUNNING_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousRunningMode = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_RUNNING_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentRunningMode = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterRunningModeChangeEvent( + previousRunningMode, + currentRunningMode + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterRunningModeChangeEvent {\n"); + output.append("\tpreviousRunningMode: "); + output.append(previousRunningMode); + output.append("\n"); + output.append("\tcurrentRunningMode: "); + output.append(currentRunningMode); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterActiveScheduleChangeEvent { + public byte[] previousScheduleHandle; + public byte[] currentScheduleHandle; + private static final long PREVIOUS_SCHEDULE_HANDLE_ID = 0L; + private static final long CURRENT_SCHEDULE_HANDLE_ID = 1L; + + public ThermostatClusterActiveScheduleChangeEvent( + byte[] previousScheduleHandle, + byte[] currentScheduleHandle + ) { + this.previousScheduleHandle = previousScheduleHandle; + this.currentScheduleHandle = currentScheduleHandle; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_SCHEDULE_HANDLE_ID, new ByteArrayType(previousScheduleHandle))); + values.add(new StructElement(CURRENT_SCHEDULE_HANDLE_ID, new ByteArrayType(currentScheduleHandle))); + + return new StructType(values); + } + + public static ThermostatClusterActiveScheduleChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + byte[] previousScheduleHandle = null; + byte[] currentScheduleHandle = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_SCHEDULE_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + previousScheduleHandle = castingValue.value(byte[].class); + } + } else if (element.contextTagNum() == CURRENT_SCHEDULE_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + currentScheduleHandle = castingValue.value(byte[].class); + } + } + } + return new ThermostatClusterActiveScheduleChangeEvent( + previousScheduleHandle, + currentScheduleHandle + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterActiveScheduleChangeEvent {\n"); + output.append("\tpreviousScheduleHandle: "); + output.append(Arrays.toString(previousScheduleHandle)); + output.append("\n"); + output.append("\tcurrentScheduleHandle: "); + output.append(Arrays.toString(currentScheduleHandle)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterActivePresetChangeEvent { + public byte[] previousPresetHandle; + public byte[] currentPresetHandle; + private static final long PREVIOUS_PRESET_HANDLE_ID = 0L; + private static final long CURRENT_PRESET_HANDLE_ID = 1L; + + public ThermostatClusterActivePresetChangeEvent( + byte[] previousPresetHandle, + byte[] currentPresetHandle + ) { + this.previousPresetHandle = previousPresetHandle; + this.currentPresetHandle = currentPresetHandle; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_PRESET_HANDLE_ID, new ByteArrayType(previousPresetHandle))); + values.add(new StructElement(CURRENT_PRESET_HANDLE_ID, new ByteArrayType(currentPresetHandle))); + + return new StructType(values); + } + + public static ThermostatClusterActivePresetChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + byte[] previousPresetHandle = null; + byte[] currentPresetHandle = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_PRESET_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + previousPresetHandle = castingValue.value(byte[].class); + } + } else if (element.contextTagNum() == CURRENT_PRESET_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + currentPresetHandle = castingValue.value(byte[].class); + } + } + } + return new ThermostatClusterActivePresetChangeEvent( + previousPresetHandle, + currentPresetHandle + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterActivePresetChangeEvent {\n"); + output.append("\tpreviousPresetHandle: "); + output.append(Arrays.toString(previousPresetHandle)); + output.append("\n"); + output.append("\tcurrentPresetHandle: "); + output.append(Arrays.toString(currentPresetHandle)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} public static class OccupancySensingClusterOccupancyChangedEvent { public Integer occupancy; private static final long OCCUPANCY_ID = 0L; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 86a43781fec889..39d948d114b7c2 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -11660,7 +11660,15 @@ public static Attribute value(long id) throws NoSuchFieldError { } } - public enum Event {; + public enum Event { + SystemModeChange(0L), + LocalTemperatureChange(1L), + OccupancyChange(2L), + SetpointChange(3L), + RunningStateChange(4L), + RunningModeChange(5L), + ActiveScheduleChange(6L), + ActivePresetChange(7L),; private final long id; Event(long id) { this.id = id; diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt new file mode 100644 index 00000000000000..3dbc04fac9e76d --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt @@ -0,0 +1,61 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActivePresetChangeEvent( + val previousPresetHandle: ByteArray, + val currentPresetHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActivePresetChangeEvent {\n") + append("\tpreviousPresetHandle : $previousPresetHandle\n") + append("\tcurrentPresetHandle : $currentPresetHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), previousPresetHandle) + put(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE), currentPresetHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_PRESET_HANDLE = 0 + private const val TAG_CURRENT_PRESET_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActivePresetChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE)) + val currentPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActivePresetChangeEvent(previousPresetHandle, currentPresetHandle) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt new file mode 100644 index 00000000000000..e20c472b84ec7e --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt @@ -0,0 +1,64 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActiveScheduleChangeEvent( + val previousScheduleHandle: ByteArray, + val currentScheduleHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActiveScheduleChangeEvent {\n") + append("\tpreviousScheduleHandle : $previousScheduleHandle\n") + append("\tcurrentScheduleHandle : $currentScheduleHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), previousScheduleHandle) + put(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE), currentScheduleHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SCHEDULE_HANDLE = 0 + private const val TAG_CURRENT_SCHEDULE_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActiveScheduleChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE)) + val currentScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActiveScheduleChangeEvent( + previousScheduleHandle, + currentScheduleHandle, + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt new file mode 100644 index 00000000000000..63fc1ee7e67cd3 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt @@ -0,0 +1,53 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterLocalTemperatureChangeEvent(val currentLocalTemperature: Int) { + override fun toString(): String = buildString { + append("ThermostatClusterLocalTemperatureChangeEvent {\n") + append("\tcurrentLocalTemperature : $currentLocalTemperature\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE), currentLocalTemperature) + endStructure() + } + } + + companion object { + private const val TAG_CURRENT_LOCAL_TEMPERATURE = 0 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterLocalTemperatureChangeEvent { + tlvReader.enterStructure(tlvTag) + val currentLocalTemperature = + tlvReader.getInt(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE)) + + tlvReader.exitContainer() + + return ThermostatClusterLocalTemperatureChangeEvent(currentLocalTemperature) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt new file mode 100644 index 00000000000000..db1dd397cccda3 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterOccupancyChangeEvent( + val previousOccupancy: UInt, + val currentOccupancy: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterOccupancyChangeEvent {\n") + append("\tpreviousOccupancy : $previousOccupancy\n") + append("\tcurrentOccupancy : $currentOccupancy\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), previousOccupancy) + put(ContextSpecificTag(TAG_CURRENT_OCCUPANCY), currentOccupancy) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_OCCUPANCY = 0 + private const val TAG_CURRENT_OCCUPANCY = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterOccupancyChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousOccupancy = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY)) + val currentOccupancy = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_OCCUPANCY)) + + tlvReader.exitContainer() + + return ThermostatClusterOccupancyChangeEvent(previousOccupancy, currentOccupancy) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt new file mode 100644 index 00000000000000..1c0e3698dd2111 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningModeChangeEvent( + val previousRunningMode: UInt, + val currentRunningMode: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningModeChangeEvent {\n") + append("\tpreviousRunningMode : $previousRunningMode\n") + append("\tcurrentRunningMode : $currentRunningMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), previousRunningMode) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE), currentRunningMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_MODE = 0 + private const val TAG_CURRENT_RUNNING_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningMode = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE)) + val currentRunningMode = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningModeChangeEvent(previousRunningMode, currentRunningMode) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt new file mode 100644 index 00000000000000..eb3ce3277114ec --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningStateChangeEvent( + val previousRunningState: UInt, + val currentRunningState: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningStateChangeEvent {\n") + append("\tpreviousRunningState : $previousRunningState\n") + append("\tcurrentRunningState : $currentRunningState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), previousRunningState) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE), currentRunningState) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_STATE = 0 + private const val TAG_CURRENT_RUNNING_STATE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningStateChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningState = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE)) + val currentRunningState = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningStateChangeEvent(previousRunningState, currentRunningState) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt new file mode 100644 index 00000000000000..a6e62436e4b23c --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSetpointChangeEvent( + val systemMode: UInt, + val occupancy: UInt, + val previousSetpoint: Int, + val currentSetpoint: Int, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSetpointChangeEvent {\n") + append("\tsystemMode : $systemMode\n") + append("\toccupancy : $occupancy\n") + append("\tpreviousSetpoint : $previousSetpoint\n") + append("\tcurrentSetpoint : $currentSetpoint\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_SYSTEM_MODE), systemMode) + put(ContextSpecificTag(TAG_OCCUPANCY), occupancy) + put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), previousSetpoint) + put(ContextSpecificTag(TAG_CURRENT_SETPOINT), currentSetpoint) + endStructure() + } + } + + companion object { + private const val TAG_SYSTEM_MODE = 0 + private const val TAG_OCCUPANCY = 1 + private const val TAG_PREVIOUS_SETPOINT = 2 + private const val TAG_CURRENT_SETPOINT = 3 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSetpointChangeEvent { + tlvReader.enterStructure(tlvTag) + val systemMode = tlvReader.getUInt(ContextSpecificTag(TAG_SYSTEM_MODE)) + val occupancy = tlvReader.getUInt(ContextSpecificTag(TAG_OCCUPANCY)) + val previousSetpoint = tlvReader.getInt(ContextSpecificTag(TAG_PREVIOUS_SETPOINT)) + val currentSetpoint = tlvReader.getInt(ContextSpecificTag(TAG_CURRENT_SETPOINT)) + + tlvReader.exitContainer() + + return ThermostatClusterSetpointChangeEvent( + systemMode, + occupancy, + previousSetpoint, + currentSetpoint, + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt new file mode 100644 index 00000000000000..38f2c727bfc6e7 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSystemModeChangeEvent( + val previousSystemMode: UInt, + val currentSystemMode: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSystemModeChangeEvent {\n") + append("\tpreviousSystemMode : $previousSystemMode\n") + append("\tcurrentSystemMode : $currentSystemMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), previousSystemMode) + put(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE), currentSystemMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SYSTEM_MODE = 0 + private const val TAG_CURRENT_SYSTEM_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSystemModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousSystemMode = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE)) + val currentSystemMode = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterSystemModeChangeEvent(previousSystemMode, currentSystemMode) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni index a4fcda9f9bfcc0..7ad0bc8201d8c7 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni @@ -254,6 +254,14 @@ eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SwitchClusterShortReleaseEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SwitchClusterSwitchLatchedEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/TargetNavigatorClusterTargetUpdatedEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterConnectionStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/TimeSynchronizationClusterDSTStatusEvent.kt", diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt new file mode 100644 index 00000000000000..2040aa07f1c842 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt @@ -0,0 +1,61 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActivePresetChangeEvent( + val previousPresetHandle: ByteArray, + val currentPresetHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActivePresetChangeEvent {\n") + append("\tpreviousPresetHandle : $previousPresetHandle\n") + append("\tcurrentPresetHandle : $currentPresetHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), previousPresetHandle) + put(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE), currentPresetHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_PRESET_HANDLE = 0 + private const val TAG_CURRENT_PRESET_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActivePresetChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE)) + val currentPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActivePresetChangeEvent(previousPresetHandle, currentPresetHandle) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt new file mode 100644 index 00000000000000..9664d5670d976c --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt @@ -0,0 +1,64 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActiveScheduleChangeEvent( + val previousScheduleHandle: ByteArray, + val currentScheduleHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActiveScheduleChangeEvent {\n") + append("\tpreviousScheduleHandle : $previousScheduleHandle\n") + append("\tcurrentScheduleHandle : $currentScheduleHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), previousScheduleHandle) + put(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE), currentScheduleHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SCHEDULE_HANDLE = 0 + private const val TAG_CURRENT_SCHEDULE_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActiveScheduleChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE)) + val currentScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActiveScheduleChangeEvent( + previousScheduleHandle, + currentScheduleHandle, + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt new file mode 100644 index 00000000000000..4d4216c17bfffe --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt @@ -0,0 +1,53 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterLocalTemperatureChangeEvent(val currentLocalTemperature: Short) { + override fun toString(): String = buildString { + append("ThermostatClusterLocalTemperatureChangeEvent {\n") + append("\tcurrentLocalTemperature : $currentLocalTemperature\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE), currentLocalTemperature) + endStructure() + } + } + + companion object { + private const val TAG_CURRENT_LOCAL_TEMPERATURE = 0 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterLocalTemperatureChangeEvent { + tlvReader.enterStructure(tlvTag) + val currentLocalTemperature = + tlvReader.getShort(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE)) + + tlvReader.exitContainer() + + return ThermostatClusterLocalTemperatureChangeEvent(currentLocalTemperature) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt new file mode 100644 index 00000000000000..5a92acb59d7d5b --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterOccupancyChangeEvent( + val previousOccupancy: UByte, + val currentOccupancy: UByte, +) { + override fun toString(): String = buildString { + append("ThermostatClusterOccupancyChangeEvent {\n") + append("\tpreviousOccupancy : $previousOccupancy\n") + append("\tcurrentOccupancy : $currentOccupancy\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), previousOccupancy) + put(ContextSpecificTag(TAG_CURRENT_OCCUPANCY), currentOccupancy) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_OCCUPANCY = 0 + private const val TAG_CURRENT_OCCUPANCY = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterOccupancyChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousOccupancy = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY)) + val currentOccupancy = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_OCCUPANCY)) + + tlvReader.exitContainer() + + return ThermostatClusterOccupancyChangeEvent(previousOccupancy, currentOccupancy) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt new file mode 100644 index 00000000000000..df399793ee1cf2 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningModeChangeEvent( + val previousRunningMode: UByte, + val currentRunningMode: UByte, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningModeChangeEvent {\n") + append("\tpreviousRunningMode : $previousRunningMode\n") + append("\tcurrentRunningMode : $currentRunningMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), previousRunningMode) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE), currentRunningMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_MODE = 0 + private const val TAG_CURRENT_RUNNING_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningMode = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE)) + val currentRunningMode = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningModeChangeEvent(previousRunningMode, currentRunningMode) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt new file mode 100644 index 00000000000000..1db9ca7e54c08c --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningStateChangeEvent( + val previousRunningState: UShort, + val currentRunningState: UShort, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningStateChangeEvent {\n") + append("\tpreviousRunningState : $previousRunningState\n") + append("\tcurrentRunningState : $currentRunningState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), previousRunningState) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE), currentRunningState) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_STATE = 0 + private const val TAG_CURRENT_RUNNING_STATE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningStateChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningState = tlvReader.getUShort(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE)) + val currentRunningState = tlvReader.getUShort(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningStateChangeEvent(previousRunningState, currentRunningState) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt new file mode 100644 index 00000000000000..62b6588d51c47b --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSetpointChangeEvent( + val systemMode: UByte, + val occupancy: UByte, + val previousSetpoint: Short, + val currentSetpoint: Short, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSetpointChangeEvent {\n") + append("\tsystemMode : $systemMode\n") + append("\toccupancy : $occupancy\n") + append("\tpreviousSetpoint : $previousSetpoint\n") + append("\tcurrentSetpoint : $currentSetpoint\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_SYSTEM_MODE), systemMode) + put(ContextSpecificTag(TAG_OCCUPANCY), occupancy) + put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), previousSetpoint) + put(ContextSpecificTag(TAG_CURRENT_SETPOINT), currentSetpoint) + endStructure() + } + } + + companion object { + private const val TAG_SYSTEM_MODE = 0 + private const val TAG_OCCUPANCY = 1 + private const val TAG_PREVIOUS_SETPOINT = 2 + private const val TAG_CURRENT_SETPOINT = 3 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSetpointChangeEvent { + tlvReader.enterStructure(tlvTag) + val systemMode = tlvReader.getUByte(ContextSpecificTag(TAG_SYSTEM_MODE)) + val occupancy = tlvReader.getUByte(ContextSpecificTag(TAG_OCCUPANCY)) + val previousSetpoint = tlvReader.getShort(ContextSpecificTag(TAG_PREVIOUS_SETPOINT)) + val currentSetpoint = tlvReader.getShort(ContextSpecificTag(TAG_CURRENT_SETPOINT)) + + tlvReader.exitContainer() + + return ThermostatClusterSetpointChangeEvent( + systemMode, + occupancy, + previousSetpoint, + currentSetpoint, + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt new file mode 100644 index 00000000000000..16fa4aee72f482 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSystemModeChangeEvent( + val previousSystemMode: UByte, + val currentSystemMode: UByte, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSystemModeChangeEvent {\n") + append("\tpreviousSystemMode : $previousSystemMode\n") + append("\tcurrentSystemMode : $currentSystemMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), previousSystemMode) + put(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE), currentSystemMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SYSTEM_MODE = 0 + private const val TAG_CURRENT_SYSTEM_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSystemModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousSystemMode = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE)) + val currentSystemMode = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterSystemModeChangeEvent(previousSystemMode, currentSystemMode) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/files.gni b/src/controller/java/generated/java/matter/controller/cluster/files.gni index b09fc7b799e316..3a3dc217a602bf 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/files.gni +++ b/src/controller/java/generated/java/matter/controller/cluster/files.gni @@ -254,6 +254,14 @@ matter_eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SwitchClusterShortReleaseEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SwitchClusterSwitchLatchedEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/TargetNavigatorClusterTargetUpdatedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterConnectionStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/TimeSynchronizationClusterDSTStatusEvent.kt", diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index fdb5c9fb6589f7..e480eb4faad027 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -7578,6 +7578,388 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & using namespace app::Clusters::Thermostat; switch (aPath.mEventId) { + case Events::SystemModeChange::Id: { + Events::SystemModeChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousSystemMode; + std::string value_previousSystemModeClassName = "java/lang/Integer"; + std::string value_previousSystemModeCtorSignature = "(I)V"; + jint jnivalue_previousSystemMode = static_cast(cppValue.previousSystemMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousSystemModeClassName.c_str(), + value_previousSystemModeCtorSignature.c_str(), + jnivalue_previousSystemMode, value_previousSystemMode); + + jobject value_currentSystemMode; + std::string value_currentSystemModeClassName = "java/lang/Integer"; + std::string value_currentSystemModeCtorSignature = "(I)V"; + jint jnivalue_currentSystemMode = static_cast(cppValue.currentSystemMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentSystemModeClassName.c_str(), + value_currentSystemModeCtorSignature.c_str(), + jnivalue_currentSystemMode, value_currentSystemMode); + + jclass systemModeChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterSystemModeChangeEvent", systemModeChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterSystemModeChangeEvent"); + return nullptr; + } + + jmethodID systemModeChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, systemModeChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + &systemModeChangeStructCtor); + if (err != CHIP_NO_ERROR || systemModeChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterSystemModeChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(systemModeChangeStructClass, systemModeChangeStructCtor, value_previousSystemMode, + value_currentSystemMode); + + return value; + } + case Events::LocalTemperatureChange::Id: { + Events::LocalTemperatureChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_currentLocalTemperature; + std::string value_currentLocalTemperatureClassName = "java/lang/Integer"; + std::string value_currentLocalTemperatureCtorSignature = "(I)V"; + jint jnivalue_currentLocalTemperature = static_cast(cppValue.currentLocalTemperature); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_currentLocalTemperatureClassName.c_str(), value_currentLocalTemperatureCtorSignature.c_str(), + jnivalue_currentLocalTemperature, value_currentLocalTemperature); + + jclass localTemperatureChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterLocalTemperatureChangeEvent", + localTemperatureChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterLocalTemperatureChangeEvent"); + return nullptr; + } + + jmethodID localTemperatureChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, localTemperatureChangeStructClass, "", + "(Ljava/lang/Integer;)V", &localTemperatureChangeStructCtor); + if (err != CHIP_NO_ERROR || localTemperatureChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterLocalTemperatureChangeEvent constructor"); + return nullptr; + } + + jobject value = + env->NewObject(localTemperatureChangeStructClass, localTemperatureChangeStructCtor, value_currentLocalTemperature); + + return value; + } + case Events::OccupancyChange::Id: { + Events::OccupancyChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousOccupancy; + std::string value_previousOccupancyClassName = "java/lang/Integer"; + std::string value_previousOccupancyCtorSignature = "(I)V"; + jint jnivalue_previousOccupancy = static_cast(cppValue.previousOccupancy.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousOccupancyClassName.c_str(), + value_previousOccupancyCtorSignature.c_str(), + jnivalue_previousOccupancy, value_previousOccupancy); + + jobject value_currentOccupancy; + std::string value_currentOccupancyClassName = "java/lang/Integer"; + std::string value_currentOccupancyCtorSignature = "(I)V"; + jint jnivalue_currentOccupancy = static_cast(cppValue.currentOccupancy.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentOccupancyClassName.c_str(), + value_currentOccupancyCtorSignature.c_str(), + jnivalue_currentOccupancy, value_currentOccupancy); + + jclass occupancyChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterOccupancyChangeEvent", occupancyChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterOccupancyChangeEvent"); + return nullptr; + } + + jmethodID occupancyChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod( + env, occupancyChangeStructClass, "", "(Ljava/lang/Integer;Ljava/lang/Integer;)V", &occupancyChangeStructCtor); + if (err != CHIP_NO_ERROR || occupancyChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterOccupancyChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(occupancyChangeStructClass, occupancyChangeStructCtor, value_previousOccupancy, + value_currentOccupancy); + + return value; + } + case Events::SetpointChange::Id: { + Events::SetpointChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_systemMode; + std::string value_systemModeClassName = "java/lang/Integer"; + std::string value_systemModeCtorSignature = "(I)V"; + jint jnivalue_systemMode = static_cast(cppValue.systemMode); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_systemModeClassName.c_str(), value_systemModeCtorSignature.c_str(), jnivalue_systemMode, value_systemMode); + + jobject value_occupancy; + std::string value_occupancyClassName = "java/lang/Integer"; + std::string value_occupancyCtorSignature = "(I)V"; + jint jnivalue_occupancy = static_cast(cppValue.occupancy.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_occupancyClassName.c_str(), value_occupancyCtorSignature.c_str(), jnivalue_occupancy, value_occupancy); + + jobject value_previousSetpoint; + std::string value_previousSetpointClassName = "java/lang/Integer"; + std::string value_previousSetpointCtorSignature = "(I)V"; + jint jnivalue_previousSetpoint = static_cast(cppValue.previousSetpoint); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousSetpointClassName.c_str(), + value_previousSetpointCtorSignature.c_str(), + jnivalue_previousSetpoint, value_previousSetpoint); + + jobject value_currentSetpoint; + std::string value_currentSetpointClassName = "java/lang/Integer"; + std::string value_currentSetpointCtorSignature = "(I)V"; + jint jnivalue_currentSetpoint = static_cast(cppValue.currentSetpoint); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentSetpointClassName.c_str(), + value_currentSetpointCtorSignature.c_str(), + jnivalue_currentSetpoint, value_currentSetpoint); + + jclass setpointChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterSetpointChangeEvent", setpointChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterSetpointChangeEvent"); + return nullptr; + } + + jmethodID setpointChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod( + env, setpointChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &setpointChangeStructCtor); + if (err != CHIP_NO_ERROR || setpointChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterSetpointChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(setpointChangeStructClass, setpointChangeStructCtor, value_systemMode, value_occupancy, + value_previousSetpoint, value_currentSetpoint); + + return value; + } + case Events::RunningStateChange::Id: { + Events::RunningStateChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousRunningState; + std::string value_previousRunningStateClassName = "java/lang/Integer"; + std::string value_previousRunningStateCtorSignature = "(I)V"; + jint jnivalue_previousRunningState = static_cast(cppValue.previousRunningState.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousRunningStateClassName.c_str(), + value_previousRunningStateCtorSignature.c_str(), + jnivalue_previousRunningState, value_previousRunningState); + + jobject value_currentRunningState; + std::string value_currentRunningStateClassName = "java/lang/Integer"; + std::string value_currentRunningStateCtorSignature = "(I)V"; + jint jnivalue_currentRunningState = static_cast(cppValue.currentRunningState.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentRunningStateClassName.c_str(), + value_currentRunningStateCtorSignature.c_str(), + jnivalue_currentRunningState, value_currentRunningState); + + jclass runningStateChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterRunningStateChangeEvent", + runningStateChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterRunningStateChangeEvent"); + return nullptr; + } + + jmethodID runningStateChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, runningStateChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + &runningStateChangeStructCtor); + if (err != CHIP_NO_ERROR || runningStateChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterRunningStateChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(runningStateChangeStructClass, runningStateChangeStructCtor, value_previousRunningState, + value_currentRunningState); + + return value; + } + case Events::RunningModeChange::Id: { + Events::RunningModeChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousRunningMode; + std::string value_previousRunningModeClassName = "java/lang/Integer"; + std::string value_previousRunningModeCtorSignature = "(I)V"; + jint jnivalue_previousRunningMode = static_cast(cppValue.previousRunningMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousRunningModeClassName.c_str(), + value_previousRunningModeCtorSignature.c_str(), + jnivalue_previousRunningMode, value_previousRunningMode); + + jobject value_currentRunningMode; + std::string value_currentRunningModeClassName = "java/lang/Integer"; + std::string value_currentRunningModeCtorSignature = "(I)V"; + jint jnivalue_currentRunningMode = static_cast(cppValue.currentRunningMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentRunningModeClassName.c_str(), + value_currentRunningModeCtorSignature.c_str(), + jnivalue_currentRunningMode, value_currentRunningMode); + + jclass runningModeChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterRunningModeChangeEvent", + runningModeChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterRunningModeChangeEvent"); + return nullptr; + } + + jmethodID runningModeChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, runningModeChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + &runningModeChangeStructCtor); + if (err != CHIP_NO_ERROR || runningModeChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterRunningModeChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(runningModeChangeStructClass, runningModeChangeStructCtor, value_previousRunningMode, + value_currentRunningMode); + + return value; + } + case Events::ActiveScheduleChange::Id: { + Events::ActiveScheduleChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousScheduleHandle; + jbyteArray value_previousScheduleHandleByteArray = + env->NewByteArray(static_cast(cppValue.previousScheduleHandle.size())); + env->SetByteArrayRegion(value_previousScheduleHandleByteArray, 0, + static_cast(cppValue.previousScheduleHandle.size()), + reinterpret_cast(cppValue.previousScheduleHandle.data())); + value_previousScheduleHandle = value_previousScheduleHandleByteArray; + + jobject value_currentScheduleHandle; + jbyteArray value_currentScheduleHandleByteArray = + env->NewByteArray(static_cast(cppValue.currentScheduleHandle.size())); + env->SetByteArrayRegion(value_currentScheduleHandleByteArray, 0, + static_cast(cppValue.currentScheduleHandle.size()), + reinterpret_cast(cppValue.currentScheduleHandle.data())); + value_currentScheduleHandle = value_currentScheduleHandleByteArray; + + jclass activeScheduleChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent", + activeScheduleChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent"); + return nullptr; + } + + jmethodID activeScheduleChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, activeScheduleChangeStructClass, "", "([B[B)V", + &activeScheduleChangeStructCtor); + if (err != CHIP_NO_ERROR || activeScheduleChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(activeScheduleChangeStructClass, activeScheduleChangeStructCtor, + value_previousScheduleHandle, value_currentScheduleHandle); + + return value; + } + case Events::ActivePresetChange::Id: { + Events::ActivePresetChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousPresetHandle; + jbyteArray value_previousPresetHandleByteArray = + env->NewByteArray(static_cast(cppValue.previousPresetHandle.size())); + env->SetByteArrayRegion(value_previousPresetHandleByteArray, 0, + static_cast(cppValue.previousPresetHandle.size()), + reinterpret_cast(cppValue.previousPresetHandle.data())); + value_previousPresetHandle = value_previousPresetHandleByteArray; + + jobject value_currentPresetHandle; + jbyteArray value_currentPresetHandleByteArray = + env->NewByteArray(static_cast(cppValue.currentPresetHandle.size())); + env->SetByteArrayRegion(value_currentPresetHandleByteArray, 0, static_cast(cppValue.currentPresetHandle.size()), + reinterpret_cast(cppValue.currentPresetHandle.data())); + value_currentPresetHandle = value_currentPresetHandleByteArray; + + jclass activePresetChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterActivePresetChangeEvent", + activePresetChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterActivePresetChangeEvent"); + return nullptr; + } + + jmethodID activePresetChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, activePresetChangeStructClass, "", "([B[B)V", + &activePresetChangeStructCtor); + if (err != CHIP_NO_ERROR || activePresetChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterActivePresetChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(activePresetChangeStructClass, activePresetChangeStructCtor, value_previousPresetHandle, + value_currentPresetHandle); + + return value; + } default: *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; break; diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index b27196c7512fce..08d62d616fe07b 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -30696,6 +30696,7 @@ class Feature(IntFlag): kLocalTemperatureNotExposed = 0x40 kMatterScheduleConfiguration = 0x80 kPresets = 0x100 + kEvents = 0x200 class HVACSystemTypeBitmap(IntFlag): kCoolingStage = 0x3 @@ -32065,6 +32066,177 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: uint = 0 + class Events: + @dataclass + class SystemModeChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousSystemMode", Tag=0, Type=Thermostat.Enums.SystemModeEnum), + ClusterObjectFieldDescriptor(Label="currentSystemMode", Tag=1, Type=Thermostat.Enums.SystemModeEnum), + ]) + + previousSystemMode: Thermostat.Enums.SystemModeEnum = 0 + currentSystemMode: Thermostat.Enums.SystemModeEnum = 0 + + @dataclass + class LocalTemperatureChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="currentLocalTemperature", Tag=0, Type=int), + ]) + + currentLocalTemperature: int = 0 + + @dataclass + class OccupancyChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousOccupancy", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="currentOccupancy", Tag=1, Type=uint), + ]) + + previousOccupancy: uint = 0 + currentOccupancy: uint = 0 + + @dataclass + class SetpointChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="systemMode", Tag=0, Type=Thermostat.Enums.SystemModeEnum), + ClusterObjectFieldDescriptor(Label="occupancy", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="previousSetpoint", Tag=2, Type=int), + ClusterObjectFieldDescriptor(Label="currentSetpoint", Tag=3, Type=int), + ]) + + systemMode: Thermostat.Enums.SystemModeEnum = 0 + occupancy: uint = 0 + previousSetpoint: int = 0 + currentSetpoint: int = 0 + + @dataclass + class RunningStateChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000004 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousRunningState", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="currentRunningState", Tag=1, Type=uint), + ]) + + previousRunningState: uint = 0 + currentRunningState: uint = 0 + + @dataclass + class RunningModeChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000005 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousRunningMode", Tag=0, Type=Thermostat.Enums.ThermostatRunningModeEnum), + ClusterObjectFieldDescriptor(Label="currentRunningMode", Tag=1, Type=Thermostat.Enums.ThermostatRunningModeEnum), + ]) + + previousRunningMode: Thermostat.Enums.ThermostatRunningModeEnum = 0 + currentRunningMode: Thermostat.Enums.ThermostatRunningModeEnum = 0 + + @dataclass + class ActiveScheduleChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000006 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousScheduleHandle", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="currentScheduleHandle", Tag=1, Type=bytes), + ]) + + previousScheduleHandle: bytes = b"" + currentScheduleHandle: bytes = b"" + + @dataclass + class ActivePresetChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000007 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousPresetHandle", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="currentPresetHandle", Tag=1, Type=bytes), + ]) + + previousPresetHandle: bytes = b"" + currentPresetHandle: bytes = b"" + @dataclass class FanControl(Cluster): diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index 3b73ca8805a296..c76e57789bdf39 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -18837,6 +18837,7 @@ typedef NS_OPTIONS(uint32_t, MTRThermostatFeature) { MTRThermostatFeatureLocalTemperatureNotExposed MTR_AVAILABLE(ios(17.0), macos(14.0), watchos(10.0), tvos(17.0)) = 0x40, MTRThermostatFeatureMatterScheduleConfiguration MTR_PROVISIONALLY_AVAILABLE = 0x80, MTRThermostatFeaturePresets MTR_PROVISIONALLY_AVAILABLE = 0x100, + MTRThermostatFeatureEvents MTR_PROVISIONALLY_AVAILABLE = 0x200, } MTR_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)); typedef NS_OPTIONS(uint8_t, MTRThermostatHVACSystemTypeBitmap) { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 95c91d9ab34423..0c462679acfa10 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -7486,6 +7486,18 @@ typedef NS_ENUM(uint32_t, MTREventIDType) { MTREventIDTypeClusterPumpConfigurationAndControlEventAirDetectionID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x0000000F, MTREventIDTypeClusterPumpConfigurationAndControlEventTurbineOperationID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000010, + // Cluster Thermostat deprecated event names + + // Cluster Thermostat events + MTREventIDTypeClusterThermostatEventSystemModeChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTREventIDTypeClusterThermostatEventLocalTemperatureChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTREventIDTypeClusterThermostatEventOccupancyChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTREventIDTypeClusterThermostatEventSetpointChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTREventIDTypeClusterThermostatEventRunningStateChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, + MTREventIDTypeClusterThermostatEventRunningModeChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000005, + MTREventIDTypeClusterThermostatEventActiveScheduleChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000006, + MTREventIDTypeClusterThermostatEventActivePresetChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000007, + // Cluster OccupancySensing deprecated event names // Cluster OccupancySensing events diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm index 9f8206f2e04d8f..a5e18292a0c600 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm @@ -13874,6 +13874,39 @@ switch (eventID) { + // Cluster Thermostat events + case MTREventIDTypeClusterThermostatEventSystemModeChangeID: + result = @"SystemModeChange"; + break; + + case MTREventIDTypeClusterThermostatEventLocalTemperatureChangeID: + result = @"LocalTemperatureChange"; + break; + + case MTREventIDTypeClusterThermostatEventOccupancyChangeID: + result = @"OccupancyChange"; + break; + + case MTREventIDTypeClusterThermostatEventSetpointChangeID: + result = @"SetpointChange"; + break; + + case MTREventIDTypeClusterThermostatEventRunningStateChangeID: + result = @"RunningStateChange"; + break; + + case MTREventIDTypeClusterThermostatEventRunningModeChangeID: + result = @"RunningModeChange"; + break; + + case MTREventIDTypeClusterThermostatEventActiveScheduleChangeID: + result = @"ActiveScheduleChange"; + break; + + case MTREventIDTypeClusterThermostatEventActivePresetChangeID: + result = @"ActivePresetChange"; + break; + default: result = [NSString stringWithFormat:@"", eventID]; break; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index 0a04add54fd1d3..6d1c7af0397f1c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -3926,6 +3926,187 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV { using namespace Clusters::Thermostat; switch (aEventId) { + case Events::SystemModeChange::Id: { + Events::SystemModeChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterSystemModeChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousSystemMode)]; + value.previousSystemMode = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.currentSystemMode)]; + value.currentSystemMode = memberValue; + } while (0); + + return value; + } + case Events::LocalTemperatureChange::Id: { + Events::LocalTemperatureChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterLocalTemperatureChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithShort:cppValue.currentLocalTemperature]; + value.currentLocalTemperature = memberValue; + } while (0); + + return value; + } + case Events::OccupancyChange::Id: { + Events::OccupancyChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterOccupancyChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.previousOccupancy.Raw()]; + value.previousOccupancy = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.currentOccupancy.Raw()]; + value.currentOccupancy = memberValue; + } while (0); + + return value; + } + case Events::SetpointChange::Id: { + Events::SetpointChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterSetpointChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.systemMode)]; + value.systemMode = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.occupancy.Raw()]; + value.occupancy = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithShort:cppValue.previousSetpoint]; + value.previousSetpoint = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithShort:cppValue.currentSetpoint]; + value.currentSetpoint = memberValue; + } while (0); + + return value; + } + case Events::RunningStateChange::Id: { + Events::RunningStateChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterRunningStateChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedShort:cppValue.previousRunningState.Raw()]; + value.previousRunningState = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedShort:cppValue.currentRunningState.Raw()]; + value.currentRunningState = memberValue; + } while (0); + + return value; + } + case Events::RunningModeChange::Id: { + Events::RunningModeChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterRunningModeChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousRunningMode)]; + value.previousRunningMode = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.currentRunningMode)]; + value.currentRunningMode = memberValue; + } while (0); + + return value; + } + case Events::ActiveScheduleChange::Id: { + Events::ActiveScheduleChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterActiveScheduleChangeEvent new]; + + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.previousScheduleHandle); + value.previousScheduleHandle = memberValue; + } while (0); + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.currentScheduleHandle); + value.currentScheduleHandle = memberValue; + } while (0); + + return value; + } + case Events::ActivePresetChange::Id: { + Events::ActivePresetChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterActivePresetChangeEvent new]; + + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.previousPresetHandle); + value.previousPresetHandle = memberValue; + } while (0); + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.currentPresetHandle); + value.currentPresetHandle = memberValue; + } while (0); + + return value; + } default: { break; } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index f6e17d8bb4cfae..e06dd26652ecf6 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1766,6 +1766,55 @@ MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", @property (nonatomic, copy) NSNumber * _Nullable coolSetpoint MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", ios(16.1, 17.4), macos(13.0, 14.4), watchos(9.1, 10.4), tvos(16.1, 17.4)); @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterSystemModeChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousSystemMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentSystemMode MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterLocalTemperatureChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull currentLocalTemperature MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterOccupancyChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousOccupancy MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentOccupancy MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterSetpointChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull systemMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull occupancy MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull previousSetpoint MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentSetpoint MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterRunningStateChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousRunningState MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentRunningState MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterRunningModeChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousRunningMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentRunningMode MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterActiveScheduleChangeEvent : NSObject +@property (nonatomic, copy) NSData * _Nonnull previousScheduleHandle MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSData * _Nonnull currentScheduleHandle MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterActivePresetChangeEvent : NSObject +@property (nonatomic, copy) NSData * _Nonnull previousPresetHandle MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSData * _Nonnull currentPresetHandle MTR_PROVISIONALLY_AVAILABLE; +@end + MTR_PROVISIONALLY_AVAILABLE @interface MTROccupancySensingClusterHoldTimeLimitsStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull holdTimeMin MTR_PROVISIONALLY_AVAILABLE; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index ddc22861202fc1..f738d3296a87ac 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -7486,6 +7486,249 @@ @implementation MTRThermostatClusterThermostatScheduleTransition : MTRThermostat @dynamic coolSetpoint; @end +@implementation MTRThermostatClusterSystemModeChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousSystemMode = @(0); + + _currentSystemMode = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterSystemModeChangeEvent alloc] init]; + + other.previousSystemMode = self.previousSystemMode; + other.currentSystemMode = self.currentSystemMode; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousSystemMode:%@; currentSystemMode:%@; >", NSStringFromClass([self class]), _previousSystemMode, _currentSystemMode]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterLocalTemperatureChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _currentLocalTemperature = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterLocalTemperatureChangeEvent alloc] init]; + + other.currentLocalTemperature = self.currentLocalTemperature; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: currentLocalTemperature:%@; >", NSStringFromClass([self class]), _currentLocalTemperature]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterOccupancyChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousOccupancy = @(0); + + _currentOccupancy = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterOccupancyChangeEvent alloc] init]; + + other.previousOccupancy = self.previousOccupancy; + other.currentOccupancy = self.currentOccupancy; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousOccupancy:%@; currentOccupancy:%@; >", NSStringFromClass([self class]), _previousOccupancy, _currentOccupancy]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterSetpointChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _systemMode = @(0); + + _occupancy = @(0); + + _previousSetpoint = @(0); + + _currentSetpoint = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterSetpointChangeEvent alloc] init]; + + other.systemMode = self.systemMode; + other.occupancy = self.occupancy; + other.previousSetpoint = self.previousSetpoint; + other.currentSetpoint = self.currentSetpoint; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: systemMode:%@; occupancy:%@; previousSetpoint:%@; currentSetpoint:%@; >", NSStringFromClass([self class]), _systemMode, _occupancy, _previousSetpoint, _currentSetpoint]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterRunningStateChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousRunningState = @(0); + + _currentRunningState = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterRunningStateChangeEvent alloc] init]; + + other.previousRunningState = self.previousRunningState; + other.currentRunningState = self.currentRunningState; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousRunningState:%@; currentRunningState:%@; >", NSStringFromClass([self class]), _previousRunningState, _currentRunningState]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterRunningModeChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousRunningMode = @(0); + + _currentRunningMode = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterRunningModeChangeEvent alloc] init]; + + other.previousRunningMode = self.previousRunningMode; + other.currentRunningMode = self.currentRunningMode; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousRunningMode:%@; currentRunningMode:%@; >", NSStringFromClass([self class]), _previousRunningMode, _currentRunningMode]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterActiveScheduleChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousScheduleHandle = [NSData data]; + + _currentScheduleHandle = [NSData data]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterActiveScheduleChangeEvent alloc] init]; + + other.previousScheduleHandle = self.previousScheduleHandle; + other.currentScheduleHandle = self.currentScheduleHandle; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousScheduleHandle:%@; currentScheduleHandle:%@; >", NSStringFromClass([self class]), [_previousScheduleHandle base64EncodedStringWithOptions:0], [_currentScheduleHandle base64EncodedStringWithOptions:0]]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterActivePresetChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousPresetHandle = [NSData data]; + + _currentPresetHandle = [NSData data]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterActivePresetChangeEvent alloc] init]; + + other.previousPresetHandle = self.previousPresetHandle; + other.currentPresetHandle = self.currentPresetHandle; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousPresetHandle:%@; currentPresetHandle:%@; >", NSStringFromClass([self class]), [_previousPresetHandle base64EncodedStringWithOptions:0], [_currentPresetHandle base64EncodedStringWithOptions:0]]; + return descriptionString; +} + +@end + @implementation MTROccupancySensingClusterHoldTimeLimitsStruct - (instancetype)init { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index aae67302e404a0..1b4ee8270fcaf3 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -4292,6 +4292,7 @@ enum class Feature : uint32_t kLocalTemperatureNotExposed = 0x40, kMatterScheduleConfiguration = 0x80, kPresets = 0x100, + kEvents = 0x200, }; // Bitmap for HVACSystemTypeBitmap diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 4879ae5213c65d..29e590705efad0 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -21903,7 +21903,333 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre } } // namespace Attributes -namespace Events {} // namespace Events +namespace Events { +namespace SystemModeChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousSystemMode), previousSystemMode)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentSystemMode), currentSystemMode)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousSystemMode)) + { + err = DataModel::Decode(reader, previousSystemMode); + } + else if (__context_tag == to_underlying(Fields::kCurrentSystemMode)) + { + err = DataModel::Decode(reader, currentSystemMode); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SystemModeChange. +namespace LocalTemperatureChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentLocalTemperature), currentLocalTemperature)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kCurrentLocalTemperature)) + { + err = DataModel::Decode(reader, currentLocalTemperature); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace LocalTemperatureChange. +namespace OccupancyChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousOccupancy), previousOccupancy)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentOccupancy), currentOccupancy)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousOccupancy)) + { + err = DataModel::Decode(reader, previousOccupancy); + } + else if (__context_tag == to_underlying(Fields::kCurrentOccupancy)) + { + err = DataModel::Decode(reader, currentOccupancy); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace OccupancyChange. +namespace SetpointChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSystemMode), systemMode)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOccupancy), occupancy)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousSetpoint), previousSetpoint)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentSetpoint), currentSetpoint)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kSystemMode)) + { + err = DataModel::Decode(reader, systemMode); + } + else if (__context_tag == to_underlying(Fields::kOccupancy)) + { + err = DataModel::Decode(reader, occupancy); + } + else if (__context_tag == to_underlying(Fields::kPreviousSetpoint)) + { + err = DataModel::Decode(reader, previousSetpoint); + } + else if (__context_tag == to_underlying(Fields::kCurrentSetpoint)) + { + err = DataModel::Decode(reader, currentSetpoint); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SetpointChange. +namespace RunningStateChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousRunningState), previousRunningState)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentRunningState), currentRunningState)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousRunningState)) + { + err = DataModel::Decode(reader, previousRunningState); + } + else if (__context_tag == to_underlying(Fields::kCurrentRunningState)) + { + err = DataModel::Decode(reader, currentRunningState); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace RunningStateChange. +namespace RunningModeChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousRunningMode), previousRunningMode)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentRunningMode), currentRunningMode)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousRunningMode)) + { + err = DataModel::Decode(reader, previousRunningMode); + } + else if (__context_tag == to_underlying(Fields::kCurrentRunningMode)) + { + err = DataModel::Decode(reader, currentRunningMode); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace RunningModeChange. +namespace ActiveScheduleChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousScheduleHandle), previousScheduleHandle)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentScheduleHandle), currentScheduleHandle)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousScheduleHandle)) + { + err = DataModel::Decode(reader, previousScheduleHandle); + } + else if (__context_tag == to_underlying(Fields::kCurrentScheduleHandle)) + { + err = DataModel::Decode(reader, currentScheduleHandle); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace ActiveScheduleChange. +namespace ActivePresetChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPresetHandle), previousPresetHandle)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentPresetHandle), currentPresetHandle)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousPresetHandle)) + { + err = DataModel::Decode(reader, previousPresetHandle); + } + else if (__context_tag == to_underlying(Fields::kCurrentPresetHandle)) + { + err = DataModel::Decode(reader, currentPresetHandle); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace ActivePresetChange. +} // namespace Events } // namespace Thermostat namespace FanControl { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 2357a87dd9d9fa..543efdb2568a7b 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -30007,6 +30007,299 @@ struct TypeInfo }; }; } // namespace Attributes +namespace Events { +namespace SystemModeChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousSystemMode = 0, + kCurrentSystemMode = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SystemModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + SystemModeEnum previousSystemMode = static_cast(0); + SystemModeEnum currentSystemMode = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SystemModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + SystemModeEnum previousSystemMode = static_cast(0); + SystemModeEnum currentSystemMode = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace SystemModeChange +namespace LocalTemperatureChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kCurrentLocalTemperature = 0, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::LocalTemperatureChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + int16_t currentLocalTemperature = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::LocalTemperatureChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + int16_t currentLocalTemperature = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace LocalTemperatureChange +namespace OccupancyChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousOccupancy = 0, + kCurrentOccupancy = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::OccupancyChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask previousOccupancy = static_cast>(0); + chip::BitMask currentOccupancy = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::OccupancyChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::BitMask previousOccupancy = static_cast>(0); + chip::BitMask currentOccupancy = static_cast>(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace OccupancyChange +namespace SetpointChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kSystemMode = 0, + kOccupancy = 1, + kPreviousSetpoint = 2, + kCurrentSetpoint = 3, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SetpointChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + SystemModeEnum systemMode = static_cast(0); + chip::BitMask occupancy = static_cast>(0); + int16_t previousSetpoint = static_cast(0); + int16_t currentSetpoint = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SetpointChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + SystemModeEnum systemMode = static_cast(0); + chip::BitMask occupancy = static_cast>(0); + int16_t previousSetpoint = static_cast(0); + int16_t currentSetpoint = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace SetpointChange +namespace RunningStateChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousRunningState = 0, + kCurrentRunningState = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningStateChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask previousRunningState = static_cast>(0); + chip::BitMask currentRunningState = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningStateChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::BitMask previousRunningState = static_cast>(0); + chip::BitMask currentRunningState = static_cast>(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace RunningStateChange +namespace RunningModeChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousRunningMode = 0, + kCurrentRunningMode = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + ThermostatRunningModeEnum previousRunningMode = static_cast(0); + ThermostatRunningModeEnum currentRunningMode = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + ThermostatRunningModeEnum previousRunningMode = static_cast(0); + ThermostatRunningModeEnum currentRunningMode = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace RunningModeChange +namespace ActiveScheduleChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousScheduleHandle = 0, + kCurrentScheduleHandle = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActiveScheduleChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::ByteSpan previousScheduleHandle; + chip::ByteSpan currentScheduleHandle; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActiveScheduleChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::ByteSpan previousScheduleHandle; + chip::ByteSpan currentScheduleHandle; + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace ActiveScheduleChange +namespace ActivePresetChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousPresetHandle = 0, + kCurrentPresetHandle = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActivePresetChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::ByteSpan previousPresetHandle; + chip::ByteSpan currentPresetHandle; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActivePresetChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::ByteSpan previousPresetHandle; + chip::ByteSpan currentPresetHandle; + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace ActivePresetChange +} // namespace Events } // namespace Thermostat namespace FanControl { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h index 818b5504b29e30..840d21897e57d5 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h @@ -633,6 +633,44 @@ static constexpr EventId Id = 0x00000010; } // namespace Events } // namespace PumpConfigurationAndControl +namespace Thermostat { +namespace Events { + +namespace SystemModeChange { +static constexpr EventId Id = 0x00000000; +} // namespace SystemModeChange + +namespace LocalTemperatureChange { +static constexpr EventId Id = 0x00000001; +} // namespace LocalTemperatureChange + +namespace OccupancyChange { +static constexpr EventId Id = 0x00000002; +} // namespace OccupancyChange + +namespace SetpointChange { +static constexpr EventId Id = 0x00000003; +} // namespace SetpointChange + +namespace RunningStateChange { +static constexpr EventId Id = 0x00000004; +} // namespace RunningStateChange + +namespace RunningModeChange { +static constexpr EventId Id = 0x00000005; +} // namespace RunningModeChange + +namespace ActiveScheduleChange { +static constexpr EventId Id = 0x00000006; +} // namespace ActiveScheduleChange + +namespace ActivePresetChange { +static constexpr EventId Id = 0x00000007; +} // namespace ActivePresetChange + +} // namespace Events +} // namespace Thermostat + namespace OccupancySensing { namespace Events { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index b0c00980d3e42d..8039170e49bf02 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -9364,6 +9364,14 @@ class ServiceAreaSkipArea : public ClusterCommand | * ClusterRevision | 0xFFFD | |------------------------------------------------------------------------------| | Events: | | +| * SystemModeChange | 0x0000 | +| * LocalTemperatureChange | 0x0001 | +| * OccupancyChange | 0x0002 | +| * SetpointChange | 0x0003 | +| * RunningStateChange | 0x0004 | +| * RunningModeChange | 0x0005 | +| * ActiveScheduleChange | 0x0006 | +| * ActivePresetChange | 0x0007 | \*----------------------------------------------------------------------------*/ /* @@ -23420,8 +23428,24 @@ void registerClusterThermostat(Commands & commands, CredentialIssuerCommands * c // // Events // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "system-mode-change", Events::SystemModeChange::Id, credsIssuerConfig), // + make_unique(Id, "local-temperature-change", Events::LocalTemperatureChange::Id, credsIssuerConfig), // + make_unique(Id, "occupancy-change", Events::OccupancyChange::Id, credsIssuerConfig), // + make_unique(Id, "setpoint-change", Events::SetpointChange::Id, credsIssuerConfig), // + make_unique(Id, "running-state-change", Events::RunningStateChange::Id, credsIssuerConfig), // + make_unique(Id, "running-mode-change", Events::RunningModeChange::Id, credsIssuerConfig), // + make_unique(Id, "active-schedule-change", Events::ActiveScheduleChange::Id, credsIssuerConfig), // + make_unique(Id, "active-preset-change", Events::ActivePresetChange::Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "system-mode-change", Events::SystemModeChange::Id, credsIssuerConfig), // + make_unique(Id, "local-temperature-change", Events::LocalTemperatureChange::Id, credsIssuerConfig), // + make_unique(Id, "occupancy-change", Events::OccupancyChange::Id, credsIssuerConfig), // + make_unique(Id, "setpoint-change", Events::SetpointChange::Id, credsIssuerConfig), // + make_unique(Id, "running-state-change", Events::RunningStateChange::Id, credsIssuerConfig), // + make_unique(Id, "running-mode-change", Events::RunningModeChange::Id, credsIssuerConfig), // + make_unique(Id, "active-schedule-change", Events::ActiveScheduleChange::Id, credsIssuerConfig), // + make_unique(Id, "active-preset-change", Events::ActivePresetChange::Id, credsIssuerConfig), // }; commands.RegisterCluster(clusterName, clusterCommands); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp index 9e44b001a17247..c7d68827b08a3d 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -8524,6 +8524,206 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::SystemModeChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousSystemMode", indent + 1, value.previousSystemMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousSystemMode'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentSystemMode", indent + 1, value.currentSystemMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentSystemMode'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::LocalTemperatureChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentLocalTemperature", indent + 1, value.currentLocalTemperature); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentLocalTemperature'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::OccupancyChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousOccupancy", indent + 1, value.previousOccupancy); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousOccupancy'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentOccupancy", indent + 1, value.currentOccupancy); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentOccupancy'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::SetpointChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("SystemMode", indent + 1, value.systemMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'SystemMode'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("Occupancy", indent + 1, value.occupancy); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Occupancy'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousSetpoint", indent + 1, value.previousSetpoint); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousSetpoint'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentSetpoint", indent + 1, value.currentSetpoint); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentSetpoint'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::RunningStateChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousRunningState", indent + 1, value.previousRunningState); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousRunningState'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentRunningState", indent + 1, value.currentRunningState); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentRunningState'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::RunningModeChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousRunningMode", indent + 1, value.previousRunningMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousRunningMode'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentRunningMode", indent + 1, value.currentRunningMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentRunningMode'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::ActiveScheduleChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousScheduleHandle", indent + 1, value.previousScheduleHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousScheduleHandle'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentScheduleHandle", indent + 1, value.currentScheduleHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentScheduleHandle'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::ActivePresetChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousPresetHandle", indent + 1, value.previousPresetHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousPresetHandle'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentPresetHandle", indent + 1, value.currentPresetHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentPresetHandle'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const OccupancySensing::Events::OccupancyChanged::DecodableType & value) { @@ -21001,6 +21201,52 @@ CHIP_ERROR DataModelLogger::LogEvent(const chip::app::EventHeader & header, chip } break; } + case Thermostat::Id: { + switch (header.mPath.mEventId) + { + case Thermostat::Events::SystemModeChange::Id: { + chip::app::Clusters::Thermostat::Events::SystemModeChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("SystemModeChange", 1, value); + } + case Thermostat::Events::LocalTemperatureChange::Id: { + chip::app::Clusters::Thermostat::Events::LocalTemperatureChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("LocalTemperatureChange", 1, value); + } + case Thermostat::Events::OccupancyChange::Id: { + chip::app::Clusters::Thermostat::Events::OccupancyChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("OccupancyChange", 1, value); + } + case Thermostat::Events::SetpointChange::Id: { + chip::app::Clusters::Thermostat::Events::SetpointChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("SetpointChange", 1, value); + } + case Thermostat::Events::RunningStateChange::Id: { + chip::app::Clusters::Thermostat::Events::RunningStateChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("RunningStateChange", 1, value); + } + case Thermostat::Events::RunningModeChange::Id: { + chip::app::Clusters::Thermostat::Events::RunningModeChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("RunningModeChange", 1, value); + } + case Thermostat::Events::ActiveScheduleChange::Id: { + chip::app::Clusters::Thermostat::Events::ActiveScheduleChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ActiveScheduleChange", 1, value); + } + case Thermostat::Events::ActivePresetChange::Id: { + chip::app::Clusters::Thermostat::Events::ActivePresetChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ActivePresetChange", 1, value); + } + } + break; + } case OccupancySensing::Id: { switch (header.mPath.mEventId) { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h index dd53dfabc6a6eb..aabc56b1b8f175 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -716,6 +716,22 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::PumpConfigurationAndControl::Events::AirDetection::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::PumpConfigurationAndControl::Events::TurbineOperation::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::SystemModeChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::LocalTemperatureChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::OccupancyChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::SetpointChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::RunningStateChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::RunningModeChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::ActiveScheduleChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::ActivePresetChange::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::OccupancySensing::Events::OccupancyChanged::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h index 5f6e87c76b7b03..c02c345edc7a6c 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -94900,6 +94900,14 @@ class SubscribeAttributePumpConfigurationAndControlClusterRevision : public Subs | * ClusterRevision | 0xFFFD | |------------------------------------------------------------------------------| | Events: | | +| * SystemModeChange | 0x0000 | +| * LocalTemperatureChange | 0x0001 | +| * OccupancyChange | 0x0002 | +| * SetpointChange | 0x0003 | +| * RunningStateChange | 0x0004 | +| * RunningModeChange | 0x0005 | +| * ActiveScheduleChange | 0x0006 | +| * ActivePresetChange | 0x0007 | \*----------------------------------------------------------------------------*/ /* @@ -177168,6 +177176,8 @@ void registerClusterThermostat(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(Id), // + make_unique(Id), // }; commands.RegisterCluster(clusterName, clusterCommands); From 5c031b1e731fae8ee1f4c46b05da07b2df674088 Mon Sep 17 00:00:00 2001 From: David Rempel Date: Thu, 19 Dec 2024 12:23:45 -0800 Subject: [PATCH 3/5] Removed some white space --- .../zap-templates/zcl/data-model/chip/thermostat-cluster.xml | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml index 831d47c8dc906e..f5f2cd10cf981d 100644 --- a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml @@ -690,7 +690,6 @@ limitations under the License. - This event SHALL be generated when the SystemMode attribute changes. @@ -711,7 +710,6 @@ limitations under the License. - This event SHALL be generated when the Occupancy attribute changes. From 7fa387ab7ba6d4d67fa45a811aba13186c7a7cfb Mon Sep 17 00:00:00 2001 From: David Rempel Date: Thu, 19 Dec 2024 13:30:09 -0800 Subject: [PATCH 4/5] Marked some of the optional fields as actually optional. There may be more changes as the last bit of the spec PR gets finalized. --- .../air-purifier-app.matter | 14 +- .../all-clusters-app.matter | 14 +- .../all-clusters-minimal-app.matter | 14 +- ...umiditysensor_thermostat_56de3d5f45.matter | 14 +- ...tnode_heatingcoolingunit_ncdGai1E5a.matter | 14 +- .../rootnode_heatpump_87ivjRAECh.matter | 14 +- ...tnode_roomairconditioner_9cf3607804.matter | 14 +- .../rootnode_thermostat_bm3fb8dhYi.matter | 14 +- .../placeholder/linux/apps/app1/config.matter | 28 +-- .../placeholder/linux/apps/app2/config.matter | 28 +-- .../nxp/zap/thermostat_matter_br.matter | 14 +- .../nxp/zap/thermostat_matter_thread.matter | 14 +- .../nxp/zap/thermostat_matter_wifi.matter | 14 +- .../qpg/zap/thermostaticRadiatorValve.matter | 14 +- .../thermostat-common/thermostat.matter | 14 +- .../data-model/chip/thermostat-cluster.xml | 14 +- .../data_model/controller-clusters.matter | 14 +- .../devicecontroller/ChipEventStructs.java | 74 ++++---- ...hermostatClusterActivePresetChangeEvent.kt | 14 +- ...rmostatClusterActiveScheduleChangeEvent.kt | 14 +- .../ThermostatClusterOccupancyChangeEvent.kt | 15 +- ...ThermostatClusterRunningModeChangeEvent.kt | 15 +- ...hermostatClusterRunningStateChangeEvent.kt | 15 +- .../ThermostatClusterSetpointChangeEvent.kt | 15 +- .../ThermostatClusterSystemModeChangeEvent.kt | 15 +- ...hermostatClusterActivePresetChangeEvent.kt | 14 +- ...rmostatClusterActiveScheduleChangeEvent.kt | 14 +- .../ThermostatClusterOccupancyChangeEvent.kt | 15 +- ...ThermostatClusterRunningModeChangeEvent.kt | 15 +- ...hermostatClusterRunningStateChangeEvent.kt | 15 +- .../ThermostatClusterSetpointChangeEvent.kt | 15 +- .../ThermostatClusterSystemModeChangeEvent.kt | 15 +- .../CHIPEventTLVValueDecoder.cpp | 177 +++++++++++++----- .../python/chip/clusters/Objects.py | 28 +-- .../zap-generated/MTREventTLVValueDecoder.mm | 56 ++++-- .../CHIP/zap-generated/MTRStructsObjc.h | 14 +- .../CHIP/zap-generated/MTRStructsObjc.mm | 14 +- .../zap-generated/cluster-objects.h | 48 ++--- 38 files changed, 553 insertions(+), 330 deletions(-) diff --git a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter index a50e5855ba1113..6b537e8ad9273d 100644 --- a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter +++ b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter @@ -1766,7 +1766,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1775,34 +1775,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index e0cfe5a7ad3f3a..d1d15e5a41c09c 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -5629,7 +5629,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -5638,34 +5638,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter index adaa874c48b2af..1043c63a339e77 100644 --- a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter +++ b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter @@ -4041,7 +4041,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -4050,34 +4050,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter index e62c3ddd5415d8..4c24cb204e841b 100644 --- a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter +++ b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter @@ -1689,7 +1689,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1698,34 +1698,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter index 36c24a441fe7b7..90313bc1543552 100644 --- a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter +++ b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter @@ -1985,7 +1985,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1994,34 +1994,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter index d677e0c903adba..7b9788985342d6 100644 --- a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter +++ b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter @@ -2248,7 +2248,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -2257,34 +2257,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter index 318f52134f9096..2657cbcf56a523 100644 --- a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter +++ b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter @@ -1629,7 +1629,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1638,34 +1638,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter index c5d5379c2dec7a..c9adb139fc72e6 100644 --- a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter +++ b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter @@ -1849,7 +1849,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1858,34 +1858,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/placeholder/linux/apps/app1/config.matter b/examples/placeholder/linux/apps/app1/config.matter index e87e8146544d10..4791338380caf6 100644 --- a/examples/placeholder/linux/apps/app1/config.matter +++ b/examples/placeholder/linux/apps/app1/config.matter @@ -5328,7 +5328,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -5337,34 +5337,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } @@ -5725,7 +5725,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -5734,34 +5734,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/placeholder/linux/apps/app2/config.matter b/examples/placeholder/linux/apps/app2/config.matter index 49c12cde2a8f08..b4385162061404 100644 --- a/examples/placeholder/linux/apps/app2/config.matter +++ b/examples/placeholder/linux/apps/app2/config.matter @@ -5285,7 +5285,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -5294,34 +5294,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } @@ -5682,7 +5682,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -5691,34 +5691,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/thermostat/nxp/zap/thermostat_matter_br.matter b/examples/thermostat/nxp/zap/thermostat_matter_br.matter index ea9675edcc5e8a..7a50a840ee6408 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_br.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_br.matter @@ -2001,7 +2001,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -2010,34 +2010,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter index 2a558d7ad9bd7f..cc5aab49fb864a 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter @@ -1924,7 +1924,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1933,34 +1933,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter index eab75a84860442..862de3d99b733d 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter @@ -1835,7 +1835,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -1844,34 +1844,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter index 5223ec2f76fd3a..483e420c0e6d72 100644 --- a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter +++ b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter @@ -2048,7 +2048,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -2057,34 +2057,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/examples/thermostat/thermostat-common/thermostat.matter b/examples/thermostat/thermostat-common/thermostat.matter index 84b581797c4280..193c60fb8ca291 100644 --- a/examples/thermostat/thermostat-common/thermostat.matter +++ b/examples/thermostat/thermostat-common/thermostat.matter @@ -2228,7 +2228,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -2237,34 +2237,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml index f5f2cd10cf981d..e1b5ef82698276 100644 --- a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml @@ -692,7 +692,7 @@ limitations under the License. This event SHALL be generated when the SystemMode attribute changes. - + @@ -712,7 +712,7 @@ limitations under the License. This event SHALL be generated when the Occupancy attribute changes. - + @@ -724,7 +724,7 @@ limitations under the License. This event SHALL be generated when the value of any of the OccupiedHeatingSetpoint, UnoccupiedHeatingSetpoint>>, OccupiedCoolingSetpoint, or UnoccupiedCoolingSetpoint attributes is changed - + @@ -733,7 +733,7 @@ limitations under the License. This event SHALL be generated when the ThermostatRunningState attribute changes. - + @@ -742,7 +742,7 @@ limitations under the License. This event SHALL be generated when the ThermostatRunningMode attribute changes. - + @@ -751,7 +751,7 @@ limitations under the License. This event SHALL be generated when the ActiveScheduleHandle attribute changes. - + @@ -761,7 +761,7 @@ limitations under the License. This event SHALL be generated when the ActivePresetHandle attribute changes. - + diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index 223c784442bae6..3a944ffc5127c5 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -6928,7 +6928,7 @@ cluster Thermostat = 513 { } info event SystemModeChange = 0 { - SystemModeEnum previousSystemMode = 0; + optional SystemModeEnum previousSystemMode = 0; SystemModeEnum currentSystemMode = 1; } @@ -6937,34 +6937,34 @@ cluster Thermostat = 513 { } info event OccupancyChange = 2 { - OccupancyBitmap previousOccupancy = 0; + optional OccupancyBitmap previousOccupancy = 0; OccupancyBitmap currentOccupancy = 1; } info event SetpointChange = 3 { SystemModeEnum systemMode = 0; OccupancyBitmap occupancy = 1; - temperature previousSetpoint = 2; + optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } info event RunningStateChange = 4 { - RelayStateBitmap previousRunningState = 0; + optional RelayStateBitmap previousRunningState = 0; RelayStateBitmap currentRunningState = 1; } info event RunningModeChange = 5 { - ThermostatRunningModeEnum previousRunningMode = 0; + optional ThermostatRunningModeEnum previousRunningMode = 0; ThermostatRunningModeEnum currentRunningMode = 1; } info event ActiveScheduleChange = 6 { - octet_string previousScheduleHandle = 0; + optional octet_string previousScheduleHandle = 0; octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - octet_string previousPresetHandle = 0; + optional octet_string previousPresetHandle = 0; octet_string currentPresetHandle = 1; } diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java index 6c00351773f4fd..123c254a1bc262 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java @@ -5826,13 +5826,13 @@ public String toString() { } } public static class ThermostatClusterSystemModeChangeEvent { - public Integer previousSystemMode; + public Optional previousSystemMode; public Integer currentSystemMode; private static final long PREVIOUS_SYSTEM_MODE_ID = 0L; private static final long CURRENT_SYSTEM_MODE_ID = 1L; public ThermostatClusterSystemModeChangeEvent( - Integer previousSystemMode, + Optional previousSystemMode, Integer currentSystemMode ) { this.previousSystemMode = previousSystemMode; @@ -5841,7 +5841,7 @@ public ThermostatClusterSystemModeChangeEvent( public StructType encodeTlv() { ArrayList values = new ArrayList<>(); - values.add(new StructElement(PREVIOUS_SYSTEM_MODE_ID, new UIntType(previousSystemMode))); + values.add(new StructElement(PREVIOUS_SYSTEM_MODE_ID, previousSystemMode.map((nonOptionalpreviousSystemMode) -> new UIntType(nonOptionalpreviousSystemMode)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_SYSTEM_MODE_ID, new UIntType(currentSystemMode))); return new StructType(values); @@ -5851,13 +5851,13 @@ public static ThermostatClusterSystemModeChangeEvent decodeTlv(BaseTLVType tlvVa if (tlvValue == null || tlvValue.type() != TLVType.Struct) { return null; } - Integer previousSystemMode = null; + Optional previousSystemMode = Optional.empty(); Integer currentSystemMode = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == PREVIOUS_SYSTEM_MODE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { UIntType castingValue = element.value(UIntType.class); - previousSystemMode = castingValue.value(Integer.class); + previousSystemMode = Optional.of(castingValue.value(Integer.class)); } } else if (element.contextTagNum() == CURRENT_SYSTEM_MODE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { @@ -5933,13 +5933,13 @@ public String toString() { } } public static class ThermostatClusterOccupancyChangeEvent { - public Integer previousOccupancy; + public Optional previousOccupancy; public Integer currentOccupancy; private static final long PREVIOUS_OCCUPANCY_ID = 0L; private static final long CURRENT_OCCUPANCY_ID = 1L; public ThermostatClusterOccupancyChangeEvent( - Integer previousOccupancy, + Optional previousOccupancy, Integer currentOccupancy ) { this.previousOccupancy = previousOccupancy; @@ -5948,7 +5948,7 @@ public ThermostatClusterOccupancyChangeEvent( public StructType encodeTlv() { ArrayList values = new ArrayList<>(); - values.add(new StructElement(PREVIOUS_OCCUPANCY_ID, new UIntType(previousOccupancy))); + values.add(new StructElement(PREVIOUS_OCCUPANCY_ID, previousOccupancy.map((nonOptionalpreviousOccupancy) -> new UIntType(nonOptionalpreviousOccupancy)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_OCCUPANCY_ID, new UIntType(currentOccupancy))); return new StructType(values); @@ -5958,13 +5958,13 @@ public static ThermostatClusterOccupancyChangeEvent decodeTlv(BaseTLVType tlvVal if (tlvValue == null || tlvValue.type() != TLVType.Struct) { return null; } - Integer previousOccupancy = null; + Optional previousOccupancy = Optional.empty(); Integer currentOccupancy = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == PREVIOUS_OCCUPANCY_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { UIntType castingValue = element.value(UIntType.class); - previousOccupancy = castingValue.value(Integer.class); + previousOccupancy = Optional.of(castingValue.value(Integer.class)); } } else if (element.contextTagNum() == CURRENT_OCCUPANCY_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { @@ -5996,7 +5996,7 @@ public String toString() { public static class ThermostatClusterSetpointChangeEvent { public Integer systemMode; public Integer occupancy; - public Integer previousSetpoint; + public Optional previousSetpoint; public Integer currentSetpoint; private static final long SYSTEM_MODE_ID = 0L; private static final long OCCUPANCY_ID = 1L; @@ -6006,7 +6006,7 @@ public static class ThermostatClusterSetpointChangeEvent { public ThermostatClusterSetpointChangeEvent( Integer systemMode, Integer occupancy, - Integer previousSetpoint, + Optional previousSetpoint, Integer currentSetpoint ) { this.systemMode = systemMode; @@ -6019,7 +6019,7 @@ public StructType encodeTlv() { ArrayList values = new ArrayList<>(); values.add(new StructElement(SYSTEM_MODE_ID, new UIntType(systemMode))); values.add(new StructElement(OCCUPANCY_ID, new UIntType(occupancy))); - values.add(new StructElement(PREVIOUS_SETPOINT_ID, new IntType(previousSetpoint))); + values.add(new StructElement(PREVIOUS_SETPOINT_ID, previousSetpoint.map((nonOptionalpreviousSetpoint) -> new IntType(nonOptionalpreviousSetpoint)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_SETPOINT_ID, new IntType(currentSetpoint))); return new StructType(values); @@ -6031,7 +6031,7 @@ public static ThermostatClusterSetpointChangeEvent decodeTlv(BaseTLVType tlvValu } Integer systemMode = null; Integer occupancy = null; - Integer previousSetpoint = null; + Optional previousSetpoint = Optional.empty(); Integer currentSetpoint = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == SYSTEM_MODE_ID) { @@ -6047,7 +6047,7 @@ public static ThermostatClusterSetpointChangeEvent decodeTlv(BaseTLVType tlvValu } else if (element.contextTagNum() == PREVIOUS_SETPOINT_ID) { if (element.value(BaseTLVType.class).type() == TLVType.Int) { IntType castingValue = element.value(IntType.class); - previousSetpoint = castingValue.value(Integer.class); + previousSetpoint = Optional.of(castingValue.value(Integer.class)); } } else if (element.contextTagNum() == CURRENT_SETPOINT_ID) { if (element.value(BaseTLVType.class).type() == TLVType.Int) { @@ -6085,13 +6085,13 @@ public String toString() { } } public static class ThermostatClusterRunningStateChangeEvent { - public Integer previousRunningState; + public Optional previousRunningState; public Integer currentRunningState; private static final long PREVIOUS_RUNNING_STATE_ID = 0L; private static final long CURRENT_RUNNING_STATE_ID = 1L; public ThermostatClusterRunningStateChangeEvent( - Integer previousRunningState, + Optional previousRunningState, Integer currentRunningState ) { this.previousRunningState = previousRunningState; @@ -6100,7 +6100,7 @@ public ThermostatClusterRunningStateChangeEvent( public StructType encodeTlv() { ArrayList values = new ArrayList<>(); - values.add(new StructElement(PREVIOUS_RUNNING_STATE_ID, new UIntType(previousRunningState))); + values.add(new StructElement(PREVIOUS_RUNNING_STATE_ID, previousRunningState.map((nonOptionalpreviousRunningState) -> new UIntType(nonOptionalpreviousRunningState)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_RUNNING_STATE_ID, new UIntType(currentRunningState))); return new StructType(values); @@ -6110,13 +6110,13 @@ public static ThermostatClusterRunningStateChangeEvent decodeTlv(BaseTLVType tlv if (tlvValue == null || tlvValue.type() != TLVType.Struct) { return null; } - Integer previousRunningState = null; + Optional previousRunningState = Optional.empty(); Integer currentRunningState = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == PREVIOUS_RUNNING_STATE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { UIntType castingValue = element.value(UIntType.class); - previousRunningState = castingValue.value(Integer.class); + previousRunningState = Optional.of(castingValue.value(Integer.class)); } } else if (element.contextTagNum() == CURRENT_RUNNING_STATE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { @@ -6146,13 +6146,13 @@ public String toString() { } } public static class ThermostatClusterRunningModeChangeEvent { - public Integer previousRunningMode; + public Optional previousRunningMode; public Integer currentRunningMode; private static final long PREVIOUS_RUNNING_MODE_ID = 0L; private static final long CURRENT_RUNNING_MODE_ID = 1L; public ThermostatClusterRunningModeChangeEvent( - Integer previousRunningMode, + Optional previousRunningMode, Integer currentRunningMode ) { this.previousRunningMode = previousRunningMode; @@ -6161,7 +6161,7 @@ public ThermostatClusterRunningModeChangeEvent( public StructType encodeTlv() { ArrayList values = new ArrayList<>(); - values.add(new StructElement(PREVIOUS_RUNNING_MODE_ID, new UIntType(previousRunningMode))); + values.add(new StructElement(PREVIOUS_RUNNING_MODE_ID, previousRunningMode.map((nonOptionalpreviousRunningMode) -> new UIntType(nonOptionalpreviousRunningMode)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_RUNNING_MODE_ID, new UIntType(currentRunningMode))); return new StructType(values); @@ -6171,13 +6171,13 @@ public static ThermostatClusterRunningModeChangeEvent decodeTlv(BaseTLVType tlvV if (tlvValue == null || tlvValue.type() != TLVType.Struct) { return null; } - Integer previousRunningMode = null; + Optional previousRunningMode = Optional.empty(); Integer currentRunningMode = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == PREVIOUS_RUNNING_MODE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { UIntType castingValue = element.value(UIntType.class); - previousRunningMode = castingValue.value(Integer.class); + previousRunningMode = Optional.of(castingValue.value(Integer.class)); } } else if (element.contextTagNum() == CURRENT_RUNNING_MODE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.UInt) { @@ -6207,13 +6207,13 @@ public String toString() { } } public static class ThermostatClusterActiveScheduleChangeEvent { - public byte[] previousScheduleHandle; + public Optional previousScheduleHandle; public byte[] currentScheduleHandle; private static final long PREVIOUS_SCHEDULE_HANDLE_ID = 0L; private static final long CURRENT_SCHEDULE_HANDLE_ID = 1L; public ThermostatClusterActiveScheduleChangeEvent( - byte[] previousScheduleHandle, + Optional previousScheduleHandle, byte[] currentScheduleHandle ) { this.previousScheduleHandle = previousScheduleHandle; @@ -6222,7 +6222,7 @@ public ThermostatClusterActiveScheduleChangeEvent( public StructType encodeTlv() { ArrayList values = new ArrayList<>(); - values.add(new StructElement(PREVIOUS_SCHEDULE_HANDLE_ID, new ByteArrayType(previousScheduleHandle))); + values.add(new StructElement(PREVIOUS_SCHEDULE_HANDLE_ID, previousScheduleHandle.map((nonOptionalpreviousScheduleHandle) -> new ByteArrayType(nonOptionalpreviousScheduleHandle)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_SCHEDULE_HANDLE_ID, new ByteArrayType(currentScheduleHandle))); return new StructType(values); @@ -6232,13 +6232,13 @@ public static ThermostatClusterActiveScheduleChangeEvent decodeTlv(BaseTLVType t if (tlvValue == null || tlvValue.type() != TLVType.Struct) { return null; } - byte[] previousScheduleHandle = null; + Optional previousScheduleHandle = Optional.empty(); byte[] currentScheduleHandle = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == PREVIOUS_SCHEDULE_HANDLE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { ByteArrayType castingValue = element.value(ByteArrayType.class); - previousScheduleHandle = castingValue.value(byte[].class); + previousScheduleHandle = Optional.of(castingValue.value(byte[].class)); } } else if (element.contextTagNum() == CURRENT_SCHEDULE_HANDLE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { @@ -6258,7 +6258,7 @@ public String toString() { StringBuilder output = new StringBuilder(); output.append("ThermostatClusterActiveScheduleChangeEvent {\n"); output.append("\tpreviousScheduleHandle: "); - output.append(Arrays.toString(previousScheduleHandle)); + output.append(previousScheduleHandle.isPresent() ? Arrays.toString(previousScheduleHandle.get()) : ""); output.append("\n"); output.append("\tcurrentScheduleHandle: "); output.append(Arrays.toString(currentScheduleHandle)); @@ -6268,13 +6268,13 @@ public String toString() { } } public static class ThermostatClusterActivePresetChangeEvent { - public byte[] previousPresetHandle; + public Optional previousPresetHandle; public byte[] currentPresetHandle; private static final long PREVIOUS_PRESET_HANDLE_ID = 0L; private static final long CURRENT_PRESET_HANDLE_ID = 1L; public ThermostatClusterActivePresetChangeEvent( - byte[] previousPresetHandle, + Optional previousPresetHandle, byte[] currentPresetHandle ) { this.previousPresetHandle = previousPresetHandle; @@ -6283,7 +6283,7 @@ public ThermostatClusterActivePresetChangeEvent( public StructType encodeTlv() { ArrayList values = new ArrayList<>(); - values.add(new StructElement(PREVIOUS_PRESET_HANDLE_ID, new ByteArrayType(previousPresetHandle))); + values.add(new StructElement(PREVIOUS_PRESET_HANDLE_ID, previousPresetHandle.map((nonOptionalpreviousPresetHandle) -> new ByteArrayType(nonOptionalpreviousPresetHandle)).orElse(new EmptyType()))); values.add(new StructElement(CURRENT_PRESET_HANDLE_ID, new ByteArrayType(currentPresetHandle))); return new StructType(values); @@ -6293,13 +6293,13 @@ public static ThermostatClusterActivePresetChangeEvent decodeTlv(BaseTLVType tlv if (tlvValue == null || tlvValue.type() != TLVType.Struct) { return null; } - byte[] previousPresetHandle = null; + Optional previousPresetHandle = Optional.empty(); byte[] currentPresetHandle = null; for (StructElement element: ((StructType)tlvValue).value()) { if (element.contextTagNum() == PREVIOUS_PRESET_HANDLE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { ByteArrayType castingValue = element.value(ByteArrayType.class); - previousPresetHandle = castingValue.value(byte[].class); + previousPresetHandle = Optional.of(castingValue.value(byte[].class)); } } else if (element.contextTagNum() == CURRENT_PRESET_HANDLE_ID) { if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { @@ -6319,7 +6319,7 @@ public String toString() { StringBuilder output = new StringBuilder(); output.append("ThermostatClusterActivePresetChangeEvent {\n"); output.append("\tpreviousPresetHandle: "); - output.append(Arrays.toString(previousPresetHandle)); + output.append(previousPresetHandle.isPresent() ? Arrays.toString(previousPresetHandle.get()) : ""); output.append("\n"); output.append("\tcurrentPresetHandle: "); output.append(Arrays.toString(currentPresetHandle)); diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt index 3dbc04fac9e76d..ab741addc18666 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt @@ -17,13 +17,14 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterActivePresetChangeEvent( - val previousPresetHandle: ByteArray, + val previousPresetHandle: Optional, val currentPresetHandle: ByteArray, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterActivePresetChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), previousPresetHandle) + if (previousPresetHandle.isPresent) { + val optpreviousPresetHandle = previousPresetHandle.get() + put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), optpreviousPresetHandle) + } put(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE), currentPresetHandle) endStructure() } @@ -49,7 +53,11 @@ class ThermostatClusterActivePresetChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActivePresetChangeEvent { tlvReader.enterStructure(tlvTag) val previousPresetHandle = - tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE)) + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE))) { + Optional.of(tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE))) + } else { + Optional.empty() + } val currentPresetHandle = tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE)) diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt index e20c472b84ec7e..f0cc6d34967cdf 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt @@ -17,13 +17,14 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterActiveScheduleChangeEvent( - val previousScheduleHandle: ByteArray, + val previousScheduleHandle: Optional, val currentScheduleHandle: ByteArray, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterActiveScheduleChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), previousScheduleHandle) + if (previousScheduleHandle.isPresent) { + val optpreviousScheduleHandle = previousScheduleHandle.get() + put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), optpreviousScheduleHandle) + } put(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE), currentScheduleHandle) endStructure() } @@ -49,7 +53,11 @@ class ThermostatClusterActiveScheduleChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActiveScheduleChangeEvent { tlvReader.enterStructure(tlvTag) val previousScheduleHandle = - tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE)) + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE))) { + Optional.of(tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE))) + } else { + Optional.empty() + } val currentScheduleHandle = tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE)) diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt index db1dd397cccda3..8cf02d2d1e8552 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt @@ -17,13 +17,14 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterOccupancyChangeEvent( - val previousOccupancy: UInt, + val previousOccupancy: Optional, val currentOccupancy: UInt, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterOccupancyChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), previousOccupancy) + if (previousOccupancy.isPresent) { + val optpreviousOccupancy = previousOccupancy.get() + put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), optpreviousOccupancy) + } put(ContextSpecificTag(TAG_CURRENT_OCCUPANCY), currentOccupancy) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterOccupancyChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterOccupancyChangeEvent { tlvReader.enterStructure(tlvTag) - val previousOccupancy = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY)) + val previousOccupancy = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY))) + } else { + Optional.empty() + } val currentOccupancy = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_OCCUPANCY)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt index 1c0e3698dd2111..0ad3dffb3dbeb2 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt @@ -17,13 +17,14 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterRunningModeChangeEvent( - val previousRunningMode: UInt, + val previousRunningMode: Optional, val currentRunningMode: UInt, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterRunningModeChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), previousRunningMode) + if (previousRunningMode.isPresent) { + val optpreviousRunningMode = previousRunningMode.get() + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), optpreviousRunningMode) + } put(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE), currentRunningMode) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterRunningModeChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningModeChangeEvent { tlvReader.enterStructure(tlvTag) - val previousRunningMode = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE)) + val previousRunningMode = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE))) + } else { + Optional.empty() + } val currentRunningMode = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt index eb3ce3277114ec..510ccf9f878a9c 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt @@ -17,13 +17,14 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterRunningStateChangeEvent( - val previousRunningState: UInt, + val previousRunningState: Optional, val currentRunningState: UInt, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterRunningStateChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), previousRunningState) + if (previousRunningState.isPresent) { + val optpreviousRunningState = previousRunningState.get() + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), optpreviousRunningState) + } put(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE), currentRunningState) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterRunningStateChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningStateChangeEvent { tlvReader.enterStructure(tlvTag) - val previousRunningState = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE)) + val previousRunningState = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE))) + } else { + Optional.empty() + } val currentRunningState = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt index a6e62436e4b23c..4cc88aff35c0c4 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt @@ -17,6 +17,7 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader @@ -25,7 +26,7 @@ import matter.tlv.TlvWriter class ThermostatClusterSetpointChangeEvent( val systemMode: UInt, val occupancy: UInt, - val previousSetpoint: Int, + val previousSetpoint: Optional, val currentSetpoint: Int, ) { override fun toString(): String = buildString { @@ -42,7 +43,10 @@ class ThermostatClusterSetpointChangeEvent( startStructure(tlvTag) put(ContextSpecificTag(TAG_SYSTEM_MODE), systemMode) put(ContextSpecificTag(TAG_OCCUPANCY), occupancy) - put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), previousSetpoint) + if (previousSetpoint.isPresent) { + val optpreviousSetpoint = previousSetpoint.get() + put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), optpreviousSetpoint) + } put(ContextSpecificTag(TAG_CURRENT_SETPOINT), currentSetpoint) endStructure() } @@ -58,7 +62,12 @@ class ThermostatClusterSetpointChangeEvent( tlvReader.enterStructure(tlvTag) val systemMode = tlvReader.getUInt(ContextSpecificTag(TAG_SYSTEM_MODE)) val occupancy = tlvReader.getUInt(ContextSpecificTag(TAG_OCCUPANCY)) - val previousSetpoint = tlvReader.getInt(ContextSpecificTag(TAG_PREVIOUS_SETPOINT)) + val previousSetpoint = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_SETPOINT))) { + Optional.of(tlvReader.getInt(ContextSpecificTag(TAG_PREVIOUS_SETPOINT))) + } else { + Optional.empty() + } val currentSetpoint = tlvReader.getInt(ContextSpecificTag(TAG_CURRENT_SETPOINT)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt index 38f2c727bfc6e7..c32b2c1b7aea5d 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt @@ -17,13 +17,14 @@ package chip.devicecontroller.cluster.eventstructs import chip.devicecontroller.cluster.* +import java.util.Optional import matter.tlv.ContextSpecificTag import matter.tlv.Tag import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterSystemModeChangeEvent( - val previousSystemMode: UInt, + val previousSystemMode: Optional, val currentSystemMode: UInt, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterSystemModeChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), previousSystemMode) + if (previousSystemMode.isPresent) { + val optpreviousSystemMode = previousSystemMode.get() + put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), optpreviousSystemMode) + } put(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE), currentSystemMode) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterSystemModeChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSystemModeChangeEvent { tlvReader.enterStructure(tlvTag) - val previousSystemMode = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE)) + val previousSystemMode = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE))) + } else { + Optional.empty() + } val currentSystemMode = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt index 2040aa07f1c842..126fa331c7aa4a 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -23,7 +24,7 @@ import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterActivePresetChangeEvent( - val previousPresetHandle: ByteArray, + val previousPresetHandle: Optional, val currentPresetHandle: ByteArray, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterActivePresetChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), previousPresetHandle) + if (previousPresetHandle.isPresent) { + val optpreviousPresetHandle = previousPresetHandle.get() + put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), optpreviousPresetHandle) + } put(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE), currentPresetHandle) endStructure() } @@ -49,7 +53,11 @@ class ThermostatClusterActivePresetChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActivePresetChangeEvent { tlvReader.enterStructure(tlvTag) val previousPresetHandle = - tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE)) + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE))) { + Optional.of(tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE))) + } else { + Optional.empty() + } val currentPresetHandle = tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE)) diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt index 9664d5670d976c..c964fc034e2061 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -23,7 +24,7 @@ import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterActiveScheduleChangeEvent( - val previousScheduleHandle: ByteArray, + val previousScheduleHandle: Optional, val currentScheduleHandle: ByteArray, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterActiveScheduleChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), previousScheduleHandle) + if (previousScheduleHandle.isPresent) { + val optpreviousScheduleHandle = previousScheduleHandle.get() + put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), optpreviousScheduleHandle) + } put(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE), currentScheduleHandle) endStructure() } @@ -49,7 +53,11 @@ class ThermostatClusterActiveScheduleChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActiveScheduleChangeEvent { tlvReader.enterStructure(tlvTag) val previousScheduleHandle = - tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE)) + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE))) { + Optional.of(tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE))) + } else { + Optional.empty() + } val currentScheduleHandle = tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE)) diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt index 5a92acb59d7d5b..8988c66d6a493d 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -23,7 +24,7 @@ import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterOccupancyChangeEvent( - val previousOccupancy: UByte, + val previousOccupancy: Optional, val currentOccupancy: UByte, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterOccupancyChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), previousOccupancy) + if (previousOccupancy.isPresent) { + val optpreviousOccupancy = previousOccupancy.get() + put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), optpreviousOccupancy) + } put(ContextSpecificTag(TAG_CURRENT_OCCUPANCY), currentOccupancy) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterOccupancyChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterOccupancyChangeEvent { tlvReader.enterStructure(tlvTag) - val previousOccupancy = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY)) + val previousOccupancy = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY))) { + Optional.of(tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY))) + } else { + Optional.empty() + } val currentOccupancy = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_OCCUPANCY)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt index df399793ee1cf2..f6d1f7b97e668e 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -23,7 +24,7 @@ import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterRunningModeChangeEvent( - val previousRunningMode: UByte, + val previousRunningMode: Optional, val currentRunningMode: UByte, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterRunningModeChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), previousRunningMode) + if (previousRunningMode.isPresent) { + val optpreviousRunningMode = previousRunningMode.get() + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), optpreviousRunningMode) + } put(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE), currentRunningMode) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterRunningModeChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningModeChangeEvent { tlvReader.enterStructure(tlvTag) - val previousRunningMode = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE)) + val previousRunningMode = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE))) { + Optional.of(tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE))) + } else { + Optional.empty() + } val currentRunningMode = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt index 1db9ca7e54c08c..c0be2722721fa4 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -23,7 +24,7 @@ import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterRunningStateChangeEvent( - val previousRunningState: UShort, + val previousRunningState: Optional, val currentRunningState: UShort, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterRunningStateChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), previousRunningState) + if (previousRunningState.isPresent) { + val optpreviousRunningState = previousRunningState.get() + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), optpreviousRunningState) + } put(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE), currentRunningState) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterRunningStateChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningStateChangeEvent { tlvReader.enterStructure(tlvTag) - val previousRunningState = tlvReader.getUShort(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE)) + val previousRunningState = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE))) { + Optional.of(tlvReader.getUShort(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE))) + } else { + Optional.empty() + } val currentRunningState = tlvReader.getUShort(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt index 62b6588d51c47b..ba71b30663feef 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -25,7 +26,7 @@ import matter.tlv.TlvWriter class ThermostatClusterSetpointChangeEvent( val systemMode: UByte, val occupancy: UByte, - val previousSetpoint: Short, + val previousSetpoint: Optional, val currentSetpoint: Short, ) { override fun toString(): String = buildString { @@ -42,7 +43,10 @@ class ThermostatClusterSetpointChangeEvent( startStructure(tlvTag) put(ContextSpecificTag(TAG_SYSTEM_MODE), systemMode) put(ContextSpecificTag(TAG_OCCUPANCY), occupancy) - put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), previousSetpoint) + if (previousSetpoint.isPresent) { + val optpreviousSetpoint = previousSetpoint.get() + put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), optpreviousSetpoint) + } put(ContextSpecificTag(TAG_CURRENT_SETPOINT), currentSetpoint) endStructure() } @@ -58,7 +62,12 @@ class ThermostatClusterSetpointChangeEvent( tlvReader.enterStructure(tlvTag) val systemMode = tlvReader.getUByte(ContextSpecificTag(TAG_SYSTEM_MODE)) val occupancy = tlvReader.getUByte(ContextSpecificTag(TAG_OCCUPANCY)) - val previousSetpoint = tlvReader.getShort(ContextSpecificTag(TAG_PREVIOUS_SETPOINT)) + val previousSetpoint = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_SETPOINT))) { + Optional.of(tlvReader.getShort(ContextSpecificTag(TAG_PREVIOUS_SETPOINT))) + } else { + Optional.empty() + } val currentSetpoint = tlvReader.getShort(ContextSpecificTag(TAG_CURRENT_SETPOINT)) tlvReader.exitContainer() diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt index 16fa4aee72f482..ee65aff45f658e 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt @@ -16,6 +16,7 @@ */ package matter.controller.cluster.eventstructs +import java.util.Optional import matter.controller.cluster.* import matter.tlv.ContextSpecificTag import matter.tlv.Tag @@ -23,7 +24,7 @@ import matter.tlv.TlvReader import matter.tlv.TlvWriter class ThermostatClusterSystemModeChangeEvent( - val previousSystemMode: UByte, + val previousSystemMode: Optional, val currentSystemMode: UByte, ) { override fun toString(): String = buildString { @@ -36,7 +37,10 @@ class ThermostatClusterSystemModeChangeEvent( fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { tlvWriter.apply { startStructure(tlvTag) - put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), previousSystemMode) + if (previousSystemMode.isPresent) { + val optpreviousSystemMode = previousSystemMode.get() + put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), optpreviousSystemMode) + } put(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE), currentSystemMode) endStructure() } @@ -48,7 +52,12 @@ class ThermostatClusterSystemModeChangeEvent( fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSystemModeChangeEvent { tlvReader.enterStructure(tlvTag) - val previousSystemMode = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE)) + val previousSystemMode = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE))) { + Optional.of(tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE))) + } else { + Optional.empty() + } val currentSystemMode = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE)) tlvReader.exitContainer() diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index e480eb4faad027..576e7678b9a43f 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -7586,12 +7586,22 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & return nullptr; } jobject value_previousSystemMode; - std::string value_previousSystemModeClassName = "java/lang/Integer"; - std::string value_previousSystemModeCtorSignature = "(I)V"; - jint jnivalue_previousSystemMode = static_cast(cppValue.previousSystemMode); - chip::JniReferences::GetInstance().CreateBoxedObject(value_previousSystemModeClassName.c_str(), - value_previousSystemModeCtorSignature.c_str(), - jnivalue_previousSystemMode, value_previousSystemMode); + if (!cppValue.previousSystemMode.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousSystemMode); + } + else + { + jobject value_previousSystemModeInsideOptional; + std::string value_previousSystemModeInsideOptionalClassName = "java/lang/Integer"; + std::string value_previousSystemModeInsideOptionalCtorSignature = "(I)V"; + jint jnivalue_previousSystemModeInsideOptional = static_cast(cppValue.previousSystemMode.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_previousSystemModeInsideOptionalClassName.c_str(), + value_previousSystemModeInsideOptionalCtorSignature.c_str(), jnivalue_previousSystemModeInsideOptional, + value_previousSystemModeInsideOptional); + chip::JniReferences::GetInstance().CreateOptional(value_previousSystemModeInsideOptional, value_previousSystemMode); + } jobject value_currentSystemMode; std::string value_currentSystemModeClassName = "java/lang/Integer"; @@ -7612,7 +7622,7 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & jmethodID systemModeChangeStructCtor; err = chip::JniReferences::GetInstance().FindMethod(env, systemModeChangeStructClass, "", - "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + "(Ljava/util/Optional;Ljava/lang/Integer;)V", &systemModeChangeStructCtor); if (err != CHIP_NO_ERROR || systemModeChangeStructCtor == nullptr) { @@ -7672,12 +7682,22 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & return nullptr; } jobject value_previousOccupancy; - std::string value_previousOccupancyClassName = "java/lang/Integer"; - std::string value_previousOccupancyCtorSignature = "(I)V"; - jint jnivalue_previousOccupancy = static_cast(cppValue.previousOccupancy.Raw()); - chip::JniReferences::GetInstance().CreateBoxedObject(value_previousOccupancyClassName.c_str(), - value_previousOccupancyCtorSignature.c_str(), - jnivalue_previousOccupancy, value_previousOccupancy); + if (!cppValue.previousOccupancy.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousOccupancy); + } + else + { + jobject value_previousOccupancyInsideOptional; + std::string value_previousOccupancyInsideOptionalClassName = "java/lang/Integer"; + std::string value_previousOccupancyInsideOptionalCtorSignature = "(I)V"; + jint jnivalue_previousOccupancyInsideOptional = static_cast(cppValue.previousOccupancy.Value().Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_previousOccupancyInsideOptionalClassName.c_str(), + value_previousOccupancyInsideOptionalCtorSignature.c_str(), jnivalue_previousOccupancyInsideOptional, + value_previousOccupancyInsideOptional); + chip::JniReferences::GetInstance().CreateOptional(value_previousOccupancyInsideOptional, value_previousOccupancy); + } jobject value_currentOccupancy; std::string value_currentOccupancyClassName = "java/lang/Integer"; @@ -7697,8 +7717,9 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } jmethodID occupancyChangeStructCtor; - err = chip::JniReferences::GetInstance().FindMethod( - env, occupancyChangeStructClass, "", "(Ljava/lang/Integer;Ljava/lang/Integer;)V", &occupancyChangeStructCtor); + err = chip::JniReferences::GetInstance().FindMethod(env, occupancyChangeStructClass, "", + "(Ljava/util/Optional;Ljava/lang/Integer;)V", + &occupancyChangeStructCtor); if (err != CHIP_NO_ERROR || occupancyChangeStructCtor == nullptr) { ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterOccupancyChangeEvent constructor"); @@ -7732,12 +7753,22 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & value_occupancyClassName.c_str(), value_occupancyCtorSignature.c_str(), jnivalue_occupancy, value_occupancy); jobject value_previousSetpoint; - std::string value_previousSetpointClassName = "java/lang/Integer"; - std::string value_previousSetpointCtorSignature = "(I)V"; - jint jnivalue_previousSetpoint = static_cast(cppValue.previousSetpoint); - chip::JniReferences::GetInstance().CreateBoxedObject(value_previousSetpointClassName.c_str(), - value_previousSetpointCtorSignature.c_str(), - jnivalue_previousSetpoint, value_previousSetpoint); + if (!cppValue.previousSetpoint.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousSetpoint); + } + else + { + jobject value_previousSetpointInsideOptional; + std::string value_previousSetpointInsideOptionalClassName = "java/lang/Integer"; + std::string value_previousSetpointInsideOptionalCtorSignature = "(I)V"; + jint jnivalue_previousSetpointInsideOptional = static_cast(cppValue.previousSetpoint.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_previousSetpointInsideOptionalClassName.c_str(), + value_previousSetpointInsideOptionalCtorSignature.c_str(), jnivalue_previousSetpointInsideOptional, + value_previousSetpointInsideOptional); + chip::JniReferences::GetInstance().CreateOptional(value_previousSetpointInsideOptional, value_previousSetpoint); + } jobject value_currentSetpoint; std::string value_currentSetpointClassName = "java/lang/Integer"; @@ -7759,7 +7790,7 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & jmethodID setpointChangeStructCtor; err = chip::JniReferences::GetInstance().FindMethod( env, setpointChangeStructClass, "", - "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &setpointChangeStructCtor); + "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/util/Optional;Ljava/lang/Integer;)V", &setpointChangeStructCtor); if (err != CHIP_NO_ERROR || setpointChangeStructCtor == nullptr) { ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterSetpointChangeEvent constructor"); @@ -7779,12 +7810,23 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & return nullptr; } jobject value_previousRunningState; - std::string value_previousRunningStateClassName = "java/lang/Integer"; - std::string value_previousRunningStateCtorSignature = "(I)V"; - jint jnivalue_previousRunningState = static_cast(cppValue.previousRunningState.Raw()); - chip::JniReferences::GetInstance().CreateBoxedObject(value_previousRunningStateClassName.c_str(), - value_previousRunningStateCtorSignature.c_str(), - jnivalue_previousRunningState, value_previousRunningState); + if (!cppValue.previousRunningState.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousRunningState); + } + else + { + jobject value_previousRunningStateInsideOptional; + std::string value_previousRunningStateInsideOptionalClassName = "java/lang/Integer"; + std::string value_previousRunningStateInsideOptionalCtorSignature = "(I)V"; + jint jnivalue_previousRunningStateInsideOptional = static_cast(cppValue.previousRunningState.Value().Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_previousRunningStateInsideOptionalClassName.c_str(), + value_previousRunningStateInsideOptionalCtorSignature.c_str(), jnivalue_previousRunningStateInsideOptional, + value_previousRunningStateInsideOptional); + chip::JniReferences::GetInstance().CreateOptional(value_previousRunningStateInsideOptional, + value_previousRunningState); + } jobject value_currentRunningState; std::string value_currentRunningStateClassName = "java/lang/Integer"; @@ -7806,7 +7848,7 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & jmethodID runningStateChangeStructCtor; err = chip::JniReferences::GetInstance().FindMethod(env, runningStateChangeStructClass, "", - "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + "(Ljava/util/Optional;Ljava/lang/Integer;)V", &runningStateChangeStructCtor); if (err != CHIP_NO_ERROR || runningStateChangeStructCtor == nullptr) { @@ -7827,12 +7869,23 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & return nullptr; } jobject value_previousRunningMode; - std::string value_previousRunningModeClassName = "java/lang/Integer"; - std::string value_previousRunningModeCtorSignature = "(I)V"; - jint jnivalue_previousRunningMode = static_cast(cppValue.previousRunningMode); - chip::JniReferences::GetInstance().CreateBoxedObject(value_previousRunningModeClassName.c_str(), - value_previousRunningModeCtorSignature.c_str(), - jnivalue_previousRunningMode, value_previousRunningMode); + if (!cppValue.previousRunningMode.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousRunningMode); + } + else + { + jobject value_previousRunningModeInsideOptional; + std::string value_previousRunningModeInsideOptionalClassName = "java/lang/Integer"; + std::string value_previousRunningModeInsideOptionalCtorSignature = "(I)V"; + jint jnivalue_previousRunningModeInsideOptional = static_cast(cppValue.previousRunningMode.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_previousRunningModeInsideOptionalClassName.c_str(), + value_previousRunningModeInsideOptionalCtorSignature.c_str(), jnivalue_previousRunningModeInsideOptional, + value_previousRunningModeInsideOptional); + chip::JniReferences::GetInstance().CreateOptional(value_previousRunningModeInsideOptional, + value_previousRunningMode); + } jobject value_currentRunningMode; std::string value_currentRunningModeClassName = "java/lang/Integer"; @@ -7854,7 +7907,7 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & jmethodID runningModeChangeStructCtor; err = chip::JniReferences::GetInstance().FindMethod(env, runningModeChangeStructClass, "", - "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + "(Ljava/util/Optional;Ljava/lang/Integer;)V", &runningModeChangeStructCtor); if (err != CHIP_NO_ERROR || runningModeChangeStructCtor == nullptr) { @@ -7875,12 +7928,22 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & return nullptr; } jobject value_previousScheduleHandle; - jbyteArray value_previousScheduleHandleByteArray = - env->NewByteArray(static_cast(cppValue.previousScheduleHandle.size())); - env->SetByteArrayRegion(value_previousScheduleHandleByteArray, 0, - static_cast(cppValue.previousScheduleHandle.size()), - reinterpret_cast(cppValue.previousScheduleHandle.data())); - value_previousScheduleHandle = value_previousScheduleHandleByteArray; + if (!cppValue.previousScheduleHandle.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousScheduleHandle); + } + else + { + jobject value_previousScheduleHandleInsideOptional; + jbyteArray value_previousScheduleHandleInsideOptionalByteArray = + env->NewByteArray(static_cast(cppValue.previousScheduleHandle.Value().size())); + env->SetByteArrayRegion(value_previousScheduleHandleInsideOptionalByteArray, 0, + static_cast(cppValue.previousScheduleHandle.Value().size()), + reinterpret_cast(cppValue.previousScheduleHandle.Value().data())); + value_previousScheduleHandleInsideOptional = value_previousScheduleHandleInsideOptionalByteArray; + chip::JniReferences::GetInstance().CreateOptional(value_previousScheduleHandleInsideOptional, + value_previousScheduleHandle); + } jobject value_currentScheduleHandle; jbyteArray value_currentScheduleHandleByteArray = @@ -7901,8 +7964,8 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } jmethodID activeScheduleChangeStructCtor; - err = chip::JniReferences::GetInstance().FindMethod(env, activeScheduleChangeStructClass, "", "([B[B)V", - &activeScheduleChangeStructCtor); + err = chip::JniReferences::GetInstance().FindMethod(env, activeScheduleChangeStructClass, "", + "(Ljava/util/Optional;[B)V", &activeScheduleChangeStructCtor); if (err != CHIP_NO_ERROR || activeScheduleChangeStructCtor == nullptr) { ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent constructor"); @@ -7922,12 +7985,22 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & return nullptr; } jobject value_previousPresetHandle; - jbyteArray value_previousPresetHandleByteArray = - env->NewByteArray(static_cast(cppValue.previousPresetHandle.size())); - env->SetByteArrayRegion(value_previousPresetHandleByteArray, 0, - static_cast(cppValue.previousPresetHandle.size()), - reinterpret_cast(cppValue.previousPresetHandle.data())); - value_previousPresetHandle = value_previousPresetHandleByteArray; + if (!cppValue.previousPresetHandle.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_previousPresetHandle); + } + else + { + jobject value_previousPresetHandleInsideOptional; + jbyteArray value_previousPresetHandleInsideOptionalByteArray = + env->NewByteArray(static_cast(cppValue.previousPresetHandle.Value().size())); + env->SetByteArrayRegion(value_previousPresetHandleInsideOptionalByteArray, 0, + static_cast(cppValue.previousPresetHandle.Value().size()), + reinterpret_cast(cppValue.previousPresetHandle.Value().data())); + value_previousPresetHandleInsideOptional = value_previousPresetHandleInsideOptionalByteArray; + chip::JniReferences::GetInstance().CreateOptional(value_previousPresetHandleInsideOptional, + value_previousPresetHandle); + } jobject value_currentPresetHandle; jbyteArray value_currentPresetHandleByteArray = @@ -7947,8 +8020,8 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } jmethodID activePresetChangeStructCtor; - err = chip::JniReferences::GetInstance().FindMethod(env, activePresetChangeStructClass, "", "([B[B)V", - &activePresetChangeStructCtor); + err = chip::JniReferences::GetInstance().FindMethod(env, activePresetChangeStructClass, "", + "(Ljava/util/Optional;[B)V", &activePresetChangeStructCtor); if (err != CHIP_NO_ERROR || activePresetChangeStructCtor == nullptr) { ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterActivePresetChangeEvent constructor"); diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 08d62d616fe07b..a79036321a6d29 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -32081,11 +32081,11 @@ def event_id(cls) -> int: def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="previousSystemMode", Tag=0, Type=Thermostat.Enums.SystemModeEnum), + ClusterObjectFieldDescriptor(Label="previousSystemMode", Tag=0, Type=typing.Optional[Thermostat.Enums.SystemModeEnum]), ClusterObjectFieldDescriptor(Label="currentSystemMode", Tag=1, Type=Thermostat.Enums.SystemModeEnum), ]) - previousSystemMode: Thermostat.Enums.SystemModeEnum = 0 + previousSystemMode: typing.Optional[Thermostat.Enums.SystemModeEnum] = None currentSystemMode: Thermostat.Enums.SystemModeEnum = 0 @dataclass @@ -32121,11 +32121,11 @@ def event_id(cls) -> int: def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="previousOccupancy", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="previousOccupancy", Tag=0, Type=typing.Optional[uint]), ClusterObjectFieldDescriptor(Label="currentOccupancy", Tag=1, Type=uint), ]) - previousOccupancy: uint = 0 + previousOccupancy: typing.Optional[uint] = None currentOccupancy: uint = 0 @dataclass @@ -32144,13 +32144,13 @@ def descriptor(cls) -> ClusterObjectDescriptor: Fields=[ ClusterObjectFieldDescriptor(Label="systemMode", Tag=0, Type=Thermostat.Enums.SystemModeEnum), ClusterObjectFieldDescriptor(Label="occupancy", Tag=1, Type=uint), - ClusterObjectFieldDescriptor(Label="previousSetpoint", Tag=2, Type=int), + ClusterObjectFieldDescriptor(Label="previousSetpoint", Tag=2, Type=typing.Optional[int]), ClusterObjectFieldDescriptor(Label="currentSetpoint", Tag=3, Type=int), ]) systemMode: Thermostat.Enums.SystemModeEnum = 0 occupancy: uint = 0 - previousSetpoint: int = 0 + previousSetpoint: typing.Optional[int] = None currentSetpoint: int = 0 @dataclass @@ -32167,11 +32167,11 @@ def event_id(cls) -> int: def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="previousRunningState", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="previousRunningState", Tag=0, Type=typing.Optional[uint]), ClusterObjectFieldDescriptor(Label="currentRunningState", Tag=1, Type=uint), ]) - previousRunningState: uint = 0 + previousRunningState: typing.Optional[uint] = None currentRunningState: uint = 0 @dataclass @@ -32188,11 +32188,11 @@ def event_id(cls) -> int: def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="previousRunningMode", Tag=0, Type=Thermostat.Enums.ThermostatRunningModeEnum), + ClusterObjectFieldDescriptor(Label="previousRunningMode", Tag=0, Type=typing.Optional[Thermostat.Enums.ThermostatRunningModeEnum]), ClusterObjectFieldDescriptor(Label="currentRunningMode", Tag=1, Type=Thermostat.Enums.ThermostatRunningModeEnum), ]) - previousRunningMode: Thermostat.Enums.ThermostatRunningModeEnum = 0 + previousRunningMode: typing.Optional[Thermostat.Enums.ThermostatRunningModeEnum] = None currentRunningMode: Thermostat.Enums.ThermostatRunningModeEnum = 0 @dataclass @@ -32209,11 +32209,11 @@ def event_id(cls) -> int: def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="previousScheduleHandle", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="previousScheduleHandle", Tag=0, Type=typing.Optional[bytes]), ClusterObjectFieldDescriptor(Label="currentScheduleHandle", Tag=1, Type=bytes), ]) - previousScheduleHandle: bytes = b"" + previousScheduleHandle: typing.Optional[bytes] = None currentScheduleHandle: bytes = b"" @dataclass @@ -32230,11 +32230,11 @@ def event_id(cls) -> int: def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="previousPresetHandle", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="previousPresetHandle", Tag=0, Type=typing.Optional[bytes]), ClusterObjectFieldDescriptor(Label="currentPresetHandle", Tag=1, Type=bytes), ]) - previousPresetHandle: bytes = b"" + previousPresetHandle: typing.Optional[bytes] = None currentPresetHandle: bytes = b"" diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index 6d1c7af0397f1c..958456a329d18c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -3936,8 +3936,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV __auto_type * value = [MTRThermostatClusterSystemModeChangeEvent new]; do { - NSNumber * _Nonnull memberValue; - memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousSystemMode)]; + NSNumber * _Nullable memberValue; + if (cppValue.previousSystemMode.HasValue()) { + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousSystemMode.Value())]; + } else { + memberValue = nil; + } value.previousSystemMode = memberValue; } while (0); do { @@ -3975,8 +3979,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV __auto_type * value = [MTRThermostatClusterOccupancyChangeEvent new]; do { - NSNumber * _Nonnull memberValue; - memberValue = [NSNumber numberWithUnsignedChar:cppValue.previousOccupancy.Raw()]; + NSNumber * _Nullable memberValue; + if (cppValue.previousOccupancy.HasValue()) { + memberValue = [NSNumber numberWithUnsignedChar:cppValue.previousOccupancy.Value().Raw()]; + } else { + memberValue = nil; + } value.previousOccupancy = memberValue; } while (0); do { @@ -4007,8 +4015,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV value.occupancy = memberValue; } while (0); do { - NSNumber * _Nonnull memberValue; - memberValue = [NSNumber numberWithShort:cppValue.previousSetpoint]; + NSNumber * _Nullable memberValue; + if (cppValue.previousSetpoint.HasValue()) { + memberValue = [NSNumber numberWithShort:cppValue.previousSetpoint.Value()]; + } else { + memberValue = nil; + } value.previousSetpoint = memberValue; } while (0); do { @@ -4029,8 +4041,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV __auto_type * value = [MTRThermostatClusterRunningStateChangeEvent new]; do { - NSNumber * _Nonnull memberValue; - memberValue = [NSNumber numberWithUnsignedShort:cppValue.previousRunningState.Raw()]; + NSNumber * _Nullable memberValue; + if (cppValue.previousRunningState.HasValue()) { + memberValue = [NSNumber numberWithUnsignedShort:cppValue.previousRunningState.Value().Raw()]; + } else { + memberValue = nil; + } value.previousRunningState = memberValue; } while (0); do { @@ -4051,8 +4067,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV __auto_type * value = [MTRThermostatClusterRunningModeChangeEvent new]; do { - NSNumber * _Nonnull memberValue; - memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousRunningMode)]; + NSNumber * _Nullable memberValue; + if (cppValue.previousRunningMode.HasValue()) { + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousRunningMode.Value())]; + } else { + memberValue = nil; + } value.previousRunningMode = memberValue; } while (0); do { @@ -4073,8 +4093,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV __auto_type * value = [MTRThermostatClusterActiveScheduleChangeEvent new]; do { - NSData * _Nonnull memberValue; - memberValue = AsData(cppValue.previousScheduleHandle); + NSData * _Nullable memberValue; + if (cppValue.previousScheduleHandle.HasValue()) { + memberValue = AsData(cppValue.previousScheduleHandle.Value()); + } else { + memberValue = nil; + } value.previousScheduleHandle = memberValue; } while (0); do { @@ -4095,8 +4119,12 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV __auto_type * value = [MTRThermostatClusterActivePresetChangeEvent new]; do { - NSData * _Nonnull memberValue; - memberValue = AsData(cppValue.previousPresetHandle); + NSData * _Nullable memberValue; + if (cppValue.previousPresetHandle.HasValue()) { + memberValue = AsData(cppValue.previousPresetHandle.Value()); + } else { + memberValue = nil; + } value.previousPresetHandle = memberValue; } while (0); do { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index e06dd26652ecf6..c4d7d3bbd533ff 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1768,7 +1768,7 @@ MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterSystemModeChangeEvent : NSObject -@property (nonatomic, copy) NSNumber * _Nonnull previousSystemMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable previousSystemMode MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSNumber * _Nonnull currentSystemMode MTR_PROVISIONALLY_AVAILABLE; @end @@ -1779,7 +1779,7 @@ MTR_PROVISIONALLY_AVAILABLE MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterOccupancyChangeEvent : NSObject -@property (nonatomic, copy) NSNumber * _Nonnull previousOccupancy MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable previousOccupancy MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSNumber * _Nonnull currentOccupancy MTR_PROVISIONALLY_AVAILABLE; @end @@ -1787,31 +1787,31 @@ MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterSetpointChangeEvent : NSObject @property (nonatomic, copy) NSNumber * _Nonnull systemMode MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSNumber * _Nonnull occupancy MTR_PROVISIONALLY_AVAILABLE; -@property (nonatomic, copy) NSNumber * _Nonnull previousSetpoint MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable previousSetpoint MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSNumber * _Nonnull currentSetpoint MTR_PROVISIONALLY_AVAILABLE; @end MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterRunningStateChangeEvent : NSObject -@property (nonatomic, copy) NSNumber * _Nonnull previousRunningState MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable previousRunningState MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSNumber * _Nonnull currentRunningState MTR_PROVISIONALLY_AVAILABLE; @end MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterRunningModeChangeEvent : NSObject -@property (nonatomic, copy) NSNumber * _Nonnull previousRunningMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable previousRunningMode MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSNumber * _Nonnull currentRunningMode MTR_PROVISIONALLY_AVAILABLE; @end MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterActiveScheduleChangeEvent : NSObject -@property (nonatomic, copy) NSData * _Nonnull previousScheduleHandle MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSData * _Nullable previousScheduleHandle MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSData * _Nonnull currentScheduleHandle MTR_PROVISIONALLY_AVAILABLE; @end MTR_PROVISIONALLY_AVAILABLE @interface MTRThermostatClusterActivePresetChangeEvent : NSObject -@property (nonatomic, copy) NSData * _Nonnull previousPresetHandle MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSData * _Nullable previousPresetHandle MTR_PROVISIONALLY_AVAILABLE; @property (nonatomic, copy) NSData * _Nonnull currentPresetHandle MTR_PROVISIONALLY_AVAILABLE; @end diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index f738d3296a87ac..816d8985a00e6a 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -7491,7 +7491,7 @@ - (instancetype)init { if (self = [super init]) { - _previousSystemMode = @(0); + _previousSystemMode = nil; _currentSystemMode = @(0); } @@ -7548,7 +7548,7 @@ - (instancetype)init { if (self = [super init]) { - _previousOccupancy = @(0); + _previousOccupancy = nil; _currentOccupancy = @(0); } @@ -7582,7 +7582,7 @@ - (instancetype)init _occupancy = @(0); - _previousSetpoint = @(0); + _previousSetpoint = nil; _currentSetpoint = @(0); } @@ -7614,7 +7614,7 @@ - (instancetype)init { if (self = [super init]) { - _previousRunningState = @(0); + _previousRunningState = nil; _currentRunningState = @(0); } @@ -7644,7 +7644,7 @@ - (instancetype)init { if (self = [super init]) { - _previousRunningMode = @(0); + _previousRunningMode = nil; _currentRunningMode = @(0); } @@ -7674,7 +7674,7 @@ - (instancetype)init { if (self = [super init]) { - _previousScheduleHandle = [NSData data]; + _previousScheduleHandle = nil; _currentScheduleHandle = [NSData data]; } @@ -7704,7 +7704,7 @@ - (instancetype)init { if (self = [super init]) { - _previousPresetHandle = [NSData data]; + _previousPresetHandle = nil; _currentPresetHandle = [NSData data]; } diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 543efdb2568a7b..5719784f59d2c2 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -30025,8 +30025,8 @@ struct Type static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } static constexpr bool kIsFabricScoped = false; - SystemModeEnum previousSystemMode = static_cast(0); - SystemModeEnum currentSystemMode = static_cast(0); + Optional previousSystemMode; + SystemModeEnum currentSystemMode = static_cast(0); CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; }; @@ -30038,8 +30038,8 @@ struct DecodableType static constexpr EventId GetEventId() { return Events::SystemModeChange::Id; } static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } - SystemModeEnum previousSystemMode = static_cast(0); - SystemModeEnum currentSystemMode = static_cast(0); + Optional previousSystemMode; + SystemModeEnum currentSystemMode = static_cast(0); CHIP_ERROR Decode(TLV::TLVReader & reader); }; @@ -30094,8 +30094,8 @@ struct Type static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } static constexpr bool kIsFabricScoped = false; - chip::BitMask previousOccupancy = static_cast>(0); - chip::BitMask currentOccupancy = static_cast>(0); + Optional> previousOccupancy; + chip::BitMask currentOccupancy = static_cast>(0); CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; }; @@ -30107,8 +30107,8 @@ struct DecodableType static constexpr EventId GetEventId() { return Events::OccupancyChange::Id; } static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } - chip::BitMask previousOccupancy = static_cast>(0); - chip::BitMask currentOccupancy = static_cast>(0); + Optional> previousOccupancy; + chip::BitMask currentOccupancy = static_cast>(0); CHIP_ERROR Decode(TLV::TLVReader & reader); }; @@ -30134,8 +30134,8 @@ struct Type SystemModeEnum systemMode = static_cast(0); chip::BitMask occupancy = static_cast>(0); - int16_t previousSetpoint = static_cast(0); - int16_t currentSetpoint = static_cast(0); + Optional previousSetpoint; + int16_t currentSetpoint = static_cast(0); CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; }; @@ -30149,8 +30149,8 @@ struct DecodableType SystemModeEnum systemMode = static_cast(0); chip::BitMask occupancy = static_cast>(0); - int16_t previousSetpoint = static_cast(0); - int16_t currentSetpoint = static_cast(0); + Optional previousSetpoint; + int16_t currentSetpoint = static_cast(0); CHIP_ERROR Decode(TLV::TLVReader & reader); }; @@ -30172,8 +30172,8 @@ struct Type static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } static constexpr bool kIsFabricScoped = false; - chip::BitMask previousRunningState = static_cast>(0); - chip::BitMask currentRunningState = static_cast>(0); + Optional> previousRunningState; + chip::BitMask currentRunningState = static_cast>(0); CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; }; @@ -30185,8 +30185,8 @@ struct DecodableType static constexpr EventId GetEventId() { return Events::RunningStateChange::Id; } static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } - chip::BitMask previousRunningState = static_cast>(0); - chip::BitMask currentRunningState = static_cast>(0); + Optional> previousRunningState; + chip::BitMask currentRunningState = static_cast>(0); CHIP_ERROR Decode(TLV::TLVReader & reader); }; @@ -30208,8 +30208,8 @@ struct Type static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } static constexpr bool kIsFabricScoped = false; - ThermostatRunningModeEnum previousRunningMode = static_cast(0); - ThermostatRunningModeEnum currentRunningMode = static_cast(0); + Optional previousRunningMode; + ThermostatRunningModeEnum currentRunningMode = static_cast(0); CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; }; @@ -30221,8 +30221,8 @@ struct DecodableType static constexpr EventId GetEventId() { return Events::RunningModeChange::Id; } static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } - ThermostatRunningModeEnum previousRunningMode = static_cast(0); - ThermostatRunningModeEnum currentRunningMode = static_cast(0); + Optional previousRunningMode; + ThermostatRunningModeEnum currentRunningMode = static_cast(0); CHIP_ERROR Decode(TLV::TLVReader & reader); }; @@ -30244,7 +30244,7 @@ struct Type static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } static constexpr bool kIsFabricScoped = false; - chip::ByteSpan previousScheduleHandle; + Optional previousScheduleHandle; chip::ByteSpan currentScheduleHandle; CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; @@ -30257,7 +30257,7 @@ struct DecodableType static constexpr EventId GetEventId() { return Events::ActiveScheduleChange::Id; } static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } - chip::ByteSpan previousScheduleHandle; + Optional previousScheduleHandle; chip::ByteSpan currentScheduleHandle; CHIP_ERROR Decode(TLV::TLVReader & reader); @@ -30280,7 +30280,7 @@ struct Type static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } static constexpr bool kIsFabricScoped = false; - chip::ByteSpan previousPresetHandle; + Optional previousPresetHandle; chip::ByteSpan currentPresetHandle; CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; @@ -30293,7 +30293,7 @@ struct DecodableType static constexpr EventId GetEventId() { return Events::ActivePresetChange::Id; } static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } - chip::ByteSpan previousPresetHandle; + Optional previousPresetHandle; chip::ByteSpan currentPresetHandle; CHIP_ERROR Decode(TLV::TLVReader & reader); From fd859ae9e63558cc0e6821e65a8a4d46c14762e8 Mon Sep 17 00:00:00 2001 From: David Rempel Date: Wed, 19 Feb 2025 14:26:37 -0800 Subject: [PATCH 5/5] Used alchemy to generate the events xml. ran zap_regen_all script --- .../air-purifier-app.matter | 14 +-- .../all-clusters-app.matter | 14 +-- .../all-clusters-minimal-app.matter | 14 +-- ...umiditysensor_thermostat_56de3d5f45.matter | 14 +-- ...tnode_heatingcoolingunit_ncdGai1E5a.matter | 14 +-- .../rootnode_heatpump_87ivjRAECh.matter | 14 +-- ...tnode_roomairconditioner_9cf3607804.matter | 14 +-- .../rootnode_thermostat_bm3fb8dhYi.matter | 14 +-- .../placeholder/linux/apps/app1/config.matter | 28 ++--- .../placeholder/linux/apps/app2/config.matter | 28 ++--- .../nxp/zap/thermostat_matter_br.matter | 14 +-- .../nxp/zap/thermostat_matter_thread.matter | 14 +-- .../nxp/zap/thermostat_matter_wifi.matter | 14 +-- .../qpg/zap/thermostaticRadiatorValve.matter | 14 +-- .../thermostat-common/thermostat.matter | 14 +-- .../data-model/chip/thermostat-cluster.xml | 88 +++++++------ .../data_model/controller-clusters.matter | 14 +-- .../devicecontroller/ChipEventStructs.java | 50 ++++---- ...hermostatClusterActivePresetChangeEvent.kt | 38 ++++-- ...rmostatClusterActiveScheduleChangeEvent.kt | 38 ++++-- ...ostatClusterLocalTemperatureChangeEvent.kt | 15 ++- .../ThermostatClusterSetpointChangeEvent.kt | 14 ++- ...hermostatClusterActivePresetChangeEvent.kt | 38 ++++-- ...rmostatClusterActiveScheduleChangeEvent.kt | 38 ++++-- ...ostatClusterLocalTemperatureChangeEvent.kt | 15 ++- .../ThermostatClusterSetpointChangeEvent.kt | 14 ++- .../CHIPEventTLVValueDecoder.cpp | 117 ++++++++++++------ .../python/chip/clusters/Objects.py | 24 ++-- .../zap-generated/MTREventTLVValueDecoder.mm | 44 +++++-- .../CHIP/zap-generated/MTRStructsObjc.h | 8 +- .../CHIP/zap-generated/MTRStructsObjc.mm | 8 +- .../zap-generated/cluster-objects.h | 28 ++--- 32 files changed, 509 insertions(+), 320 deletions(-) diff --git a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter index 3d2dfa5316db74..6110bc89c97639 100644 --- a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter +++ b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter @@ -1538,7 +1538,7 @@ cluster ActivatedCarbonFilterMonitoring = 114 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1771,7 +1771,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1781,7 +1781,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1797,13 +1797,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index ab3a3e4805ea5b..95b5b779fe71f9 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -5401,7 +5401,7 @@ cluster PumpConfigurationAndControl = 512 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -5634,7 +5634,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -5644,7 +5644,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -5660,13 +5660,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter index 2b6d62f8e6b155..38c5ded7fcc7fe 100644 --- a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter +++ b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter @@ -3813,7 +3813,7 @@ cluster PumpConfigurationAndControl = 512 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -4046,7 +4046,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -4056,7 +4056,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -4072,13 +4072,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter index 3b3f98b22c9f0d..f9468c634848e1 100644 --- a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter +++ b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter @@ -1461,7 +1461,7 @@ cluster ActivatedCarbonFilterMonitoring = 114 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1694,7 +1694,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1704,7 +1704,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1720,13 +1720,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter index 44832aff097ebf..bb1a094cdbbc46 100644 --- a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter +++ b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter @@ -1757,7 +1757,7 @@ cluster FixedLabel = 64 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1990,7 +1990,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -2000,7 +2000,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -2016,13 +2016,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter index 20485ae4cd2350..caad1c5faece27 100644 --- a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter +++ b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter @@ -2020,7 +2020,7 @@ provisional cluster DeviceEnergyManagementMode = 159 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -2253,7 +2253,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -2263,7 +2263,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -2279,13 +2279,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter index a8ff3e555f97f0..e806b26bfec402 100644 --- a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter +++ b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter @@ -1401,7 +1401,7 @@ cluster GroupKeyManagement = 63 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1634,7 +1634,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1644,7 +1644,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1660,13 +1660,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter index 6f25cea7871d11..99c912dbaa963a 100644 --- a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter +++ b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter @@ -1621,7 +1621,7 @@ cluster FixedLabel = 64 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1854,7 +1854,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1864,7 +1864,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1880,13 +1880,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/placeholder/linux/apps/app1/config.matter b/examples/placeholder/linux/apps/app1/config.matter index bd249534671795..1fe6d3f59e8789 100644 --- a/examples/placeholder/linux/apps/app1/config.matter +++ b/examples/placeholder/linux/apps/app1/config.matter @@ -5100,7 +5100,7 @@ cluster PumpConfigurationAndControl = 512 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -5333,7 +5333,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -5343,7 +5343,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -5359,13 +5359,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; @@ -5497,7 +5497,7 @@ cluster Thermostat = 513 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -5730,7 +5730,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -5740,7 +5740,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -5756,13 +5756,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/placeholder/linux/apps/app2/config.matter b/examples/placeholder/linux/apps/app2/config.matter index a1155786720590..50052c4949a7b1 100644 --- a/examples/placeholder/linux/apps/app2/config.matter +++ b/examples/placeholder/linux/apps/app2/config.matter @@ -5057,7 +5057,7 @@ cluster PumpConfigurationAndControl = 512 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -5290,7 +5290,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -5300,7 +5300,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -5316,13 +5316,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; @@ -5454,7 +5454,7 @@ cluster Thermostat = 513 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -5687,7 +5687,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -5697,7 +5697,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -5713,13 +5713,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_br.matter b/examples/thermostat/nxp/zap/thermostat_matter_br.matter index c3889e403fdda7..7b6aa1cefbe58d 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_br.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_br.matter @@ -1723,7 +1723,7 @@ cluster UserLabel = 65 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1956,7 +1956,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1966,7 +1966,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1982,13 +1982,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter index dfe7bd956e8ec0..211849e11bfbe3 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter @@ -1646,7 +1646,7 @@ cluster UserLabel = 65 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1879,7 +1879,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1889,7 +1889,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1905,13 +1905,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter index 5c5210001d4dd0..abf508080a15dd 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter @@ -1557,7 +1557,7 @@ cluster UserLabel = 65 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -1790,7 +1790,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -1800,7 +1800,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -1816,13 +1816,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter index 0cf6224e37fa6a..25aa59ea227e57 100644 --- a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter +++ b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter @@ -1820,7 +1820,7 @@ cluster UserLabel = 65 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -2053,7 +2053,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -2063,7 +2063,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -2079,13 +2079,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/examples/thermostat/thermostat-common/thermostat.matter b/examples/thermostat/thermostat-common/thermostat.matter index f90bfe23cb314f..47772390c751e0 100644 --- a/examples/thermostat/thermostat-common/thermostat.matter +++ b/examples/thermostat/thermostat-common/thermostat.matter @@ -2000,7 +2000,7 @@ cluster UserLabel = 65 { /** An interface for configuring and controlling the functionality of a thermostat. */ cluster Thermostat = 513 { - revision 7; + revision 9; enum ACCapacityFormatEnum : enum8 { kBTUh = 0; @@ -2233,7 +2233,7 @@ cluster Thermostat = 513 { } info event LocalTemperatureChange = 1 { - temperature currentLocalTemperature = 0; + nullable temperature currentLocalTemperature = 0; } info event OccupancyChange = 2 { @@ -2243,7 +2243,7 @@ cluster Thermostat = 513 { info event SetpointChange = 3 { SystemModeEnum systemMode = 0; - OccupancyBitmap occupancy = 1; + optional OccupancyBitmap occupancy = 1; optional temperature previousSetpoint = 2; temperature currentSetpoint = 3; } @@ -2259,13 +2259,13 @@ cluster Thermostat = 513 { } info event ActiveScheduleChange = 6 { - optional octet_string previousScheduleHandle = 0; - octet_string currentScheduleHandle = 1; + optional nullable octet_string previousScheduleHandle = 0; + nullable octet_string currentScheduleHandle = 1; } info event ActivePresetChange = 7 { - optional octet_string previousPresetHandle = 0; - octet_string currentPresetHandle = 1; + optional nullable octet_string previousPresetHandle = 0; + nullable octet_string currentPresetHandle = 1; } readonly attribute nullable temperature localTemperature = 0; diff --git a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml index e1b5ef82698276..b81b8271bf8b20 100644 --- a/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml @@ -1,6 +1,6 @@