Add xml of refrigerator alarm cluster and zap generated (#26572)
* Add refrigerator alarm cluster xml to data-model
* Zap generated for refrigerator alarm cluster
* Changed domain name to Appliences
* Fix Android build.
* Fix Android and Java codegen for bitmaps.
We were casting to the BitMask type, which did implicit conversions to its IntegerType.
And those could fail if the java primitive type ended up wider than IntegerType.
* Try to fix java build by enabling RefrigeratorAlarm in controller-clusters.zap.
* Fix is_bitmap test in java codegen to actually work.
* Fix up jinja codegen for untyped bitmaps. ZAP file codegen still broken
* Fixup encode_value to use strong bitmap checks only for java
---------
Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>
Co-authored-by: Andrei Litvin <andy314@gmail.com>
diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml
index 02ee720..dcf34d4 100644
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@@ -171,6 +171,7 @@
src/app/zap-templates/zcl/data-model/chip/proxy-valid-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/pump-configuration-and-control-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/pwm-cluster.xml \
+ src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml \
src/app/zap-templates/zcl/data-model/chip/relative-humidity-measurement-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/scene.xml \
src/app/zap-templates/zcl/data-model/chip/software-diagnostics-cluster.xml \
diff --git a/scripts/py_matter_idl/matter_idl/generators/java/ChipClustersCpp.jinja b/scripts/py_matter_idl/matter_idl/generators/java/ChipClustersCpp.jinja
index 596cc5d..85428e4 100644
--- a/scripts/py_matter_idl/matter_idl/generators/java/ChipClustersCpp.jinja
+++ b/scripts/py_matter_idl/matter_idl/generators/java/ChipClustersCpp.jinja
@@ -77,8 +77,10 @@
{%- endfor -%}
{%- elif encodable.is_enum -%}
{{target}} = static_cast<std::remove_reference_t<decltype({{target}})>>(chip::JniReferences::GetInstance().IntegerToPrimitive({{source}}));
- {%- elif encodable.is_bitmap -%}
+ {%- elif encodable.is_untyped_bitmap -%}
{{target}} = static_cast<std::remove_reference_t<decltype({{target}})>>(chip::JniReferences::GetInstance().{{encodable.boxed_java_type}}ToPrimitive({{source}}));
+ {%- elif encodable.is_bitmap -%}
+ {{target}}.SetRaw(static_cast<std::remove_reference_t<decltype({{target}})>::IntegerType>(chip::JniReferences::GetInstance().{{encodable.boxed_java_type}}ToPrimitive({{source}})));
{% else -%}
{{target}} = static_cast<std::remove_reference_t<decltype({{target}})>>(chip::JniReferences::GetInstance().{{encodable.boxed_java_type}}ToPrimitive({{source}}));
{% endif -%}
diff --git a/scripts/py_matter_idl/matter_idl/generators/java/__init__.py b/scripts/py_matter_idl/matter_idl/generators/java/__init__.py
index e52913b..b513493 100644
--- a/scripts/py_matter_idl/matter_idl/generators/java/__init__.py
+++ b/scripts/py_matter_idl/matter_idl/generators/java/__init__.py
@@ -381,7 +381,11 @@
@property
def is_bitmap(self):
- self.context.is_bitmap_type(self.data_type.name)
+ return self.context.is_bitmap_type(self.data_type.name)
+
+ @property
+ def is_untyped_bitmap(self):
+ return self.context.is_untyped_bitmap_type(self.data_type.name)
def clone(self):
return EncodableValue(self.context, self.data_type, self.attrs)
diff --git a/scripts/py_matter_idl/matter_idl/generators/types.py b/scripts/py_matter_idl/matter_idl/generators/types.py
index 960d73f..393c444 100644
--- a/scripts/py_matter_idl/matter_idl/generators/types.py
+++ b/scripts/py_matter_idl/matter_idl/generators/types.py
@@ -344,6 +344,10 @@
"""
return any(map(lambda s: s.name == name, self.all_structs))
+ def is_untyped_bitmap_type(self, name: str):
+ """Determine if the given type is a untyped bitmap (just an interger size)."""
+ return name.lower() in {"bitmap8", "bitmap16", "bitmap24", "bitmap32", "bitmap64"}
+
def is_bitmap_type(self, name: str):
"""
Determine if the given type name is type that is known to be a bitmap.
@@ -351,7 +355,7 @@
Handles both standard/zcl names (like bitmap32) and types defined within
the current lookup context.
"""
- if name.lower() in ["bitmap8", "bitmap16", "bitmap24", "bitmap32", "bitmap64"]:
+ if self.is_untyped_bitmap_type(name):
return True
return any(map(lambda s: s.name == name, self.all_bitmaps))
diff --git a/scripts/rules.matterlint b/scripts/rules.matterlint
index 8ef273a..98b9f08 100644
--- a/scripts/rules.matterlint
+++ b/scripts/rules.matterlint
@@ -72,6 +72,7 @@
load "../src/app/zap-templates/zcl/data-model/chip/wifi-network-diagnostics-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/window-covering.xml";
load "../src/app/zap-templates/zcl/data-model/chip/temperature-control-cluster.xml";
+load "../src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml";
load "../src/app/zap-templates/zcl/data-model/draft/barrier-control-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/draft/electrical-measurement-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/draft/input-output-value-clusters.xml";
diff --git a/src/app/zap-templates/zcl/data-model/all.xml b/src/app/zap-templates/zcl/data-model/all.xml
index 62571d7..56d251c 100644
--- a/src/app/zap-templates/zcl/data-model/all.xml
+++ b/src/app/zap-templates/zcl/data-model/all.xml
@@ -74,6 +74,7 @@
<xi:include href="chip/wifi-network-diagnostics-cluster.xml" />
<xi:include href="chip/window-covering.xml" />
<xi:include href="chip/temperature-control-cluster.xml" />
+ <xi:include href="chip/refrigerator-alarm.xml" />
<xi:include href="chip/matter-devices.xml" />
<xi:include href="draft/barrier-control.xml" />
<xi:include href="draft/electrical-measurement-cluster.xml" />
diff --git a/src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml b/src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml
new file mode 100644
index 0000000..3a3215a
--- /dev/null
+++ b/src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0"?>
+<!--
+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.
+-->
+<configurator>
+ <domain name="CHIP"/>
+ <bitmap name="AlarmMap" type="BITMAP32">
+ <cluster code="0x0057" />
+ <field name="DoorOpen" mask="0x01"/>
+ </bitmap>
+ <cluster>
+ <name>Refrigerator Alarm</name>
+ <domain>Appliances</domain>
+ <description>Attributes and commands for configuring the Refrigerator alarm.</description>
+ <code>0x0057</code>
+ <define>REFRIGERATOR_ALARM</define>
+ <client tick="false" init="false">true</client>
+ <server tick="false" init="false">true</server>
+ <attribute side="server" code="0x0000" define="MASK" type="AlarmMap" default="0" writable="true" optional="false">Mask</attribute>
+ <attribute side="server" code="0x0001" define="LATCH" type="AlarmMap" default="0" writable="false" optional="false">Latch</attribute>
+ <attribute side="server" code="0x0002" define="STATE" type="AlarmMap" default="0" writable="false" optional="false">State</attribute>
+
+ <command source="client" code="0x00" name="Reset" optional="false">
+ <description>Reset alarm</description>
+ <arg name="Alarms" type="AlarmMap" optional="false"/>
+ <arg name="Mask" type="AlarmMap" optional="true"/>
+ </command>
+
+ <event side="server" code="0x00" priority="info" name="Notify" optional="false">
+ <description>Notify</description>
+ <field id="0" name="Active" type="AlarmMap" />
+ <field id="1" name="Inactive" type="AlarmMap" />
+ <field id="2" name="State" type="AlarmMap" />
+ <field id="3" name="Mask" type="AlarmMap" />
+ </event>
+ </cluster>
+</configurator>
diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json
index 397e35d..bf09285 100644
--- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json
+++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json
@@ -71,6 +71,7 @@
"proxy-valid-cluster.xml",
"pump-configuration-and-control-cluster.xml",
"pwm-cluster.xml",
+ "refrigerator-alarm.xml",
"relative-humidity-measurement-cluster.xml",
"replacable-monitoring-cluster.xml",
"scene.xml",
diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json
index c91a3bd..3d56644 100644
--- a/src/app/zap-templates/zcl/zcl.json
+++ b/src/app/zap-templates/zcl/zcl.json
@@ -69,6 +69,7 @@
"proxy-valid-cluster.xml",
"pump-configuration-and-control-cluster.xml",
"pwm-cluster.xml",
+ "refrigerator-alarm.xml",
"relative-humidity-measurement-cluster.xml",
"replacable-monitoring-cluster.xml",
"scene.xml",
diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json
index a96d532..eb9c236 100644
--- a/src/app/zap_cluster_list.json
+++ b/src/app/zap_cluster_list.json
@@ -74,6 +74,7 @@
"pump-configuration-and-control-client"
],
"PWM_CLUSTER": [],
+ "REFRIGERATOR_ALARM": [],
"RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER": [],
"SCENES_CLUSTER": [],
"SMOKE_CO_ALARM_CLUSTER": [],
@@ -177,6 +178,7 @@
"pump-configuration-and-control-server"
],
"PWM_CLUSTER": [],
+ "REFRIGERATOR_ALARM_CLUSTER": ["refrigerator-alarm-server"],
"RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER": [],
"SCENES_CLUSTER": ["scenes"],
"SMOKE_CO_ALARM_CLUSTER": [],
diff --git a/src/controller/data_model/BUILD.gn b/src/controller/data_model/BUILD.gn
index 549fd96..1a89e51 100644
--- a/src/controller/data_model/BUILD.gn
+++ b/src/controller/data_model/BUILD.gn
@@ -172,6 +172,8 @@
"jni/PulseWidthModulationClient-ReadImpl.cpp",
"jni/PumpConfigurationAndControlClient-InvokeSubscribeImpl.cpp",
"jni/PumpConfigurationAndControlClient-ReadImpl.cpp",
+ "jni/RefrigeratorAlarmClient-InvokeSubscribeImpl.cpp",
+ "jni/RefrigeratorAlarmClient-ReadImpl.cpp",
"jni/RelativeHumidityMeasurementClient-InvokeSubscribeImpl.cpp",
"jni/RelativeHumidityMeasurementClient-ReadImpl.cpp",
"jni/ScenesClient-InvokeSubscribeImpl.cpp",
diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter
index 41d26fe..8c5cc23 100644
--- a/src/controller/data_model/controller-clusters.matter
+++ b/src/controller/data_model/controller-clusters.matter
@@ -2806,6 +2806,38 @@
command SetTemperature(SetTemperatureRequest): DefaultSuccess = 0;
}
+/** Attributes and commands for configuring the Refrigerator alarm. */
+client cluster RefrigeratorAlarm = 87 {
+ bitmap AlarmMap : BITMAP32 {
+ kDoorOpen = 0x1;
+ }
+
+ info event Notify = 0 {
+ AlarmMap active = 0;
+ AlarmMap inactive = 1;
+ AlarmMap state = 2;
+ AlarmMap mask = 3;
+ }
+
+ attribute AlarmMap mask = 0;
+ readonly attribute AlarmMap latch = 1;
+ readonly attribute AlarmMap state = 2;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ request struct ResetRequest {
+ AlarmMap alarms = 0;
+ optional AlarmMap mask = 1;
+ }
+
+ /** Reset alarm */
+ command Reset(ResetRequest): DefaultSuccess = 0;
+}
+
/** Attributes for reporting air quality classification */
client cluster AirQuality = 91 {
enum AirQualityEnum : ENUM8 {
diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap
index d52d30e..ae71d90 100644
--- a/src/controller/data_model/controller-clusters.zap
+++ b/src/controller/data_model/controller-clusters.zap
@@ -18,17 +18,17 @@
"package": [
{
"pathRelativity": "relativeToZap",
+ "path": "../../app/zap-templates/app-templates.json",
+ "type": "gen-templates-json",
+ "version": "chip-v1"
+ },
+ {
+ "pathRelativity": "relativeToZap",
"path": "../../app/zap-templates/zcl/zcl.json",
"type": "zcl-properties",
"category": "matter",
"version": 1,
"description": "Matter SDK ZCL data"
- },
- {
- "pathRelativity": "relativeToZap",
- "path": "../../app/zap-templates/app-templates.json",
- "type": "gen-templates-json",
- "version": "chip-v1"
}
],
"endpointTypes": [
@@ -10277,6 +10277,212 @@
]
},
{
+ "name": "Refrigerator Alarm",
+ "code": 87,
+ "mfgCode": null,
+ "define": "REFRIGERATOR_ALARM",
+ "side": "client",
+ "enabled": 1,
+ "commands": [
+ {
+ "name": "Reset",
+ "code": 0,
+ "mfgCode": null,
+ "source": "client",
+ "incoming": 0,
+ "outgoing": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "client",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "client",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
+ "name": "Refrigerator Alarm",
+ "code": 87,
+ "mfgCode": null,
+ "define": "REFRIGERATOR_ALARM",
+ "side": "server",
+ "enabled": 0,
+ "attributes": [
+ {
+ "name": "Mask",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "type": "AlarmMap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "Latch",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "type": "AlarmMap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "State",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "type": "AlarmMap",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "GeneratedCommandList",
+ "code": 65528,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AcceptedCommandList",
+ "code": 65529,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "EventList",
+ "code": 65530,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "AttributeList",
+ "code": 65531,
+ "mfgCode": null,
+ "side": "server",
+ "type": "array",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "server",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "server",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
+ {
"name": "Air Quality",
"code": 91,
"mfgCode": null,
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
index 306e57c..4699afd 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
@@ -7958,6 +7958,133 @@
return result;
}
+ private static Map<String, InteractionInfo> readRefrigeratorAlarmInteractionInfo() {
+ Map<String, InteractionInfo> result = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmMaskCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmMaskAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readMaskAttribute((ChipClusters.LongAttributeCallback) callback);
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readRefrigeratorAlarmMaskCommandParams);
+ result.put("readMaskAttribute", readRefrigeratorAlarmMaskAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmLatchCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmLatchAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readLatchAttribute((ChipClusters.LongAttributeCallback) callback);
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readRefrigeratorAlarmLatchCommandParams);
+ result.put("readLatchAttribute", readRefrigeratorAlarmLatchAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmStateCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmStateAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readStateAttribute((ChipClusters.LongAttributeCallback) callback);
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readRefrigeratorAlarmStateCommandParams);
+ result.put("readStateAttribute", readRefrigeratorAlarmStateAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmGeneratedCommandListCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readGeneratedCommandListAttribute(
+ (ChipClusters.RefrigeratorAlarmCluster.GeneratedCommandListAttributeCallback)
+ callback);
+ },
+ () ->
+ new ClusterInfoMapping
+ .DelegatedRefrigeratorAlarmClusterGeneratedCommandListAttributeCallback(),
+ readRefrigeratorAlarmGeneratedCommandListCommandParams);
+ result.put(
+ "readGeneratedCommandListAttribute",
+ readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmAcceptedCommandListCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readAcceptedCommandListAttribute(
+ (ChipClusters.RefrigeratorAlarmCluster.AcceptedCommandListAttributeCallback)
+ callback);
+ },
+ () ->
+ new ClusterInfoMapping
+ .DelegatedRefrigeratorAlarmClusterAcceptedCommandListAttributeCallback(),
+ readRefrigeratorAlarmAcceptedCommandListCommandParams);
+ result.put(
+ "readAcceptedCommandListAttribute",
+ readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmEventListCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmEventListAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readEventListAttribute(
+ (ChipClusters.RefrigeratorAlarmCluster.EventListAttributeCallback) callback);
+ },
+ () ->
+ new ClusterInfoMapping
+ .DelegatedRefrigeratorAlarmClusterEventListAttributeCallback(),
+ readRefrigeratorAlarmEventListCommandParams);
+ result.put("readEventListAttribute", readRefrigeratorAlarmEventListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmAttributeListCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmAttributeListAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readAttributeListAttribute(
+ (ChipClusters.RefrigeratorAlarmCluster.AttributeListAttributeCallback)
+ callback);
+ },
+ () ->
+ new ClusterInfoMapping
+ .DelegatedRefrigeratorAlarmClusterAttributeListAttributeCallback(),
+ readRefrigeratorAlarmAttributeListCommandParams);
+ result.put(
+ "readAttributeListAttribute", readRefrigeratorAlarmAttributeListAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmFeatureMapCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmFeatureMapAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback);
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readRefrigeratorAlarmFeatureMapCommandParams);
+ result.put("readFeatureMapAttribute", readRefrigeratorAlarmFeatureMapAttributeInteractionInfo);
+ Map<String, CommandParameterInfo> readRefrigeratorAlarmClusterRevisionCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ InteractionInfo readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback);
+ },
+ () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
+ readRefrigeratorAlarmClusterRevisionCommandParams);
+ result.put(
+ "readClusterRevisionAttribute",
+ readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo);
+
+ return result;
+ }
+
private static Map<String, InteractionInfo> readAirQualityInteractionInfo() {
Map<String, InteractionInfo> result = new LinkedHashMap<>();
Map<String, CommandParameterInfo> readAirQualityAirQualityCommandParams =
@@ -19704,6 +19831,7 @@
put("icdManagement", readIcdManagementInteractionInfo());
put("modeSelect", readModeSelectInteractionInfo());
put("temperatureControl", readTemperatureControlInteractionInfo());
+ put("refrigeratorAlarm", readRefrigeratorAlarmInteractionInfo());
put("airQuality", readAirQualityInteractionInfo());
put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo());
put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo());
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
index 5dec09e..649598f 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
@@ -639,6 +639,24 @@
writeAttributeMap.put("modeSelect", writeModeSelectInteractionInfo);
Map<String, InteractionInfo> writeTemperatureControlInteractionInfo = new LinkedHashMap<>();
writeAttributeMap.put("temperatureControl", writeTemperatureControlInteractionInfo);
+ Map<String, InteractionInfo> writeRefrigeratorAlarmInteractionInfo = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> writeRefrigeratorAlarmMaskCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ CommandParameterInfo refrigeratorAlarmmaskCommandParameterInfo =
+ new CommandParameterInfo("value", Long.class, Long.class);
+ writeRefrigeratorAlarmMaskCommandParams.put("value", refrigeratorAlarmmaskCommandParameterInfo);
+ InteractionInfo writeRefrigeratorAlarmMaskAttributeInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .writeMaskAttribute(
+ (DefaultClusterCallback) callback, (Long) commandArguments.get("value"));
+ },
+ () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(),
+ writeRefrigeratorAlarmMaskCommandParams);
+ writeRefrigeratorAlarmInteractionInfo.put(
+ "writeMaskAttribute", writeRefrigeratorAlarmMaskAttributeInteractionInfo);
+ writeAttributeMap.put("refrigeratorAlarm", writeRefrigeratorAlarmInteractionInfo);
Map<String, InteractionInfo> writeAirQualityInteractionInfo = new LinkedHashMap<>();
writeAttributeMap.put("airQuality", writeAirQualityInteractionInfo);
Map<String, InteractionInfo> writeSmokeCoAlarmInteractionInfo = new LinkedHashMap<>();
diff --git a/src/controller/java/templates/partials/encode_value.zapt b/src/controller/java/templates/partials/encode_value.zapt
index 8540e48..3f6d573 100644
--- a/src/controller/java/templates/partials/encode_value.zapt
+++ b/src/controller/java/templates/partials/encode_value.zapt
@@ -51,11 +51,11 @@
{{#if_chip_enum type}}
{{target}} = static_cast<std::remove_reference_t<decltype({{target}})>>(chip::JniReferences::GetInstance().{{asJavaType type null parent.parent.name forceNotList=true}}ToPrimitive({{source}}));
{{else}}
- {{#if_is_bitmap type}}
- {{target}} = static_cast<std::remove_reference_t<decltype({{target}})>>(chip::JniReferences::GetInstance().{{asJavaType type null parent.parent.name forceNotList=true}}ToPrimitive({{source}}));
+ {{#if_is_strongly_typed_bitmap type}}
+ {{target}}.SetRaw(static_cast<std::remove_reference_t<decltype({{target}})>::IntegerType>(chip::JniReferences::GetInstance().{{asJavaType type null parent.parent.name forceNotList=true}}ToPrimitive({{source}})));
{{else}}
{{target}} = static_cast<std::remove_reference_t<decltype({{target}})>>(chip::JniReferences::GetInstance().{{asJavaType type null parent.parent.name forceNotList=true}}ToPrimitive({{source}}));
- {{/if_is_bitmap}}
+ {{/if_is_strongly_typed_bitmap}}
{{/if_chip_enum}}
{{/if_is_struct}}
{{/if}}
diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
index 7be3283..83f0c0b 100644
--- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
+++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
@@ -12433,6 +12433,187 @@
}
break;
}
+ case app::Clusters::RefrigeratorAlarm::Id: {
+ using namespace app::Clusters::RefrigeratorAlarm;
+ switch (aPath.mAttributeId)
+ {
+ case Attributes::Mask::Id: {
+ using TypeInfo = Attributes::Mask::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
+ cppValue.Raw(), value);
+ return value;
+ }
+ case Attributes::Latch::Id: {
+ using TypeInfo = Attributes::Latch::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
+ cppValue.Raw(), value);
+ return value;
+ }
+ case Attributes::State::Id: {
+ using TypeInfo = Attributes::State::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
+ cppValue.Raw(), value);
+ return value;
+ }
+ case Attributes::GeneratedCommandList::Id: {
+ using TypeInfo = Attributes::GeneratedCommandList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::AcceptedCommandList::Id: {
+ using TypeInfo = Attributes::AcceptedCommandList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::EventList::Id: {
+ using TypeInfo = Attributes::EventList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::AttributeList::Id: {
+ using TypeInfo = Attributes::AttributeList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::FeatureMap::Id: {
+ using TypeInfo = Attributes::FeatureMap::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
+ cppValue, value);
+ return value;
+ }
+ case Attributes::ClusterRevision::Id: {
+ using TypeInfo = Attributes::ClusterRevision::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint16_t>(valueClassName.c_str(), valueCtorSignature.c_str(),
+ cppValue, value);
+ return value;
+ }
+ default:
+ *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB;
+ break;
+ }
+ break;
+ }
case app::Clusters::AirQuality::Id: {
using namespace app::Clusters::AirQuality;
switch (aPath.mAttributeId)
diff --git a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp
index b55e2d6..3b922d4 100644
--- a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp
+++ b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp
@@ -324,8 +324,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue =
- static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -2342,6 +2342,58 @@
onFailure.release();
}
+JNI_METHOD(void, RefrigeratorAlarmCluster, writeMaskAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs)
+{
+ chip::DeviceLayer::StackLock lock;
+ ListFreer listFreer;
+ using TypeInfo = chip::app::Clusters::RefrigeratorAlarm::Attributes::Mask::TypeInfo;
+ TypeInfo::Type cppValue;
+
+ std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
+ std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
+
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().LongToPrimitive(value)));
+
+ std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
+ Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
+ VerifyOrReturn(onSuccess.get() != nullptr,
+ chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(
+ env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY));
+
+ std::unique_ptr<CHIPDefaultFailureCallback, void (*)(CHIPDefaultFailureCallback *)> onFailure(
+ Platform::New<CHIPDefaultFailureCallback>(callback), Platform::Delete<CHIPDefaultFailureCallback>);
+ VerifyOrReturn(onFailure.get() != nullptr,
+ chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(
+ env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY));
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ RefrigeratorAlarmCluster * cppCluster = reinterpret_cast<RefrigeratorAlarmCluster *>(clusterPtr);
+ VerifyOrReturn(cppCluster != nullptr,
+ chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(
+ env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE));
+
+ auto successFn = chip::Callback::Callback<CHIPDefaultWriteSuccessCallbackType>::FromCancelable(onSuccess->Cancel());
+ auto failureFn = chip::Callback::Callback<CHIPDefaultFailureCallbackType>::FromCancelable(onFailure->Cancel());
+
+ if (timedWriteTimeoutMs == nullptr)
+ {
+ err = cppCluster->WriteAttribute<TypeInfo>(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall);
+ }
+ else
+ {
+ err = cppCluster->WriteAttribute<TypeInfo>(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall,
+ chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs));
+ }
+ VerifyOrReturn(
+ err == CHIP_NO_ERROR,
+ chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err));
+
+ onSuccess.release();
+ onFailure.release();
+}
+
JNI_METHOD(void, SmokeCoAlarmCluster, writeSensitivityLevelAttribute)
(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs)
{
@@ -3026,8 +3078,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue =
- static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -3338,8 +3390,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue =
- static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -8095,8 +8147,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue =
- static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -8147,8 +8199,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue =
- static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -8199,7 +8251,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().LongToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().LongToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -8250,7 +8303,8 @@
std::vector<Platform::UniquePtr<JniByteArray>> cleanupByteArrays;
std::vector<Platform::UniquePtr<JniUtfString>> cleanupStrings;
- cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(chip::JniReferences::GetInstance().LongToPrimitive(value));
+ cppValue.SetRaw(static_cast<std::remove_reference_t<decltype(cppValue)>::IntegerType>(
+ chip::JniReferences::GetInstance().LongToPrimitive(value)));
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
Platform::New<CHIPDefaultSuccessCallback>(callback), Platform::Delete<CHIPDefaultSuccessCallback>);
@@ -10077,8 +10131,8 @@
jobject element_0_nullableStructItem_1_fItem_3;
chip::JniReferences::GetInstance().GetObjectField(element_0_nullableStructItem_1, "f", "Ljava/lang/Integer;",
element_0_nullableStructItem_1_fItem_3);
- nonNullValue_2.f = static_cast<std::remove_reference_t<decltype(nonNullValue_2.f)>>(
- chip::JniReferences::GetInstance().IntegerToPrimitive(element_0_nullableStructItem_1_fItem_3));
+ nonNullValue_2.f.SetRaw(static_cast<std::remove_reference_t<decltype(nonNullValue_2.f)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(element_0_nullableStructItem_1_fItem_3)));
jobject element_0_nullableStructItem_1_gItem_3;
chip::JniReferences::GetInstance().GetObjectField(element_0_nullableStructItem_1, "g", "Ljava/lang/Float;",
element_0_nullableStructItem_1_gItem_3);
@@ -10129,8 +10183,8 @@
jobject optionalValue_2_fItem_3;
chip::JniReferences::GetInstance().GetObjectField(optionalValue_2, "f", "Ljava/lang/Integer;",
optionalValue_2_fItem_3);
- definedValue_2.f = static_cast<std::remove_reference_t<decltype(definedValue_2.f)>>(
- chip::JniReferences::GetInstance().IntegerToPrimitive(optionalValue_2_fItem_3));
+ definedValue_2.f.SetRaw(static_cast<std::remove_reference_t<decltype(definedValue_2.f)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(optionalValue_2_fItem_3)));
jobject optionalValue_2_gItem_3;
chip::JniReferences::GetInstance().GetObjectField(optionalValue_2, "g", "Ljava/lang/Float;",
optionalValue_2_gItem_3);
@@ -10189,8 +10243,8 @@
jobject optionalValue_2_fItem_4;
chip::JniReferences::GetInstance().GetObjectField(optionalValue_2, "f", "Ljava/lang/Integer;",
optionalValue_2_fItem_4);
- nonNullValue_3.f = static_cast<std::remove_reference_t<decltype(nonNullValue_3.f)>>(
- chip::JniReferences::GetInstance().IntegerToPrimitive(optionalValue_2_fItem_4));
+ nonNullValue_3.f.SetRaw(static_cast<std::remove_reference_t<decltype(nonNullValue_3.f)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(optionalValue_2_fItem_4)));
jobject optionalValue_2_gItem_4;
chip::JniReferences::GetInstance().GetObjectField(optionalValue_2, "g", "Ljava/lang/Float;",
optionalValue_2_gItem_4);
@@ -10830,9 +10884,9 @@
jobject element_0_fabricSensitiveStructItem_1_fItem_2;
chip::JniReferences::GetInstance().GetObjectField(element_0_fabricSensitiveStructItem_1, "f", "Ljava/lang/Integer;",
element_0_fabricSensitiveStructItem_1_fItem_2);
- listHolder_0->mList[i_0].fabricSensitiveStruct.f =
- static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.f)>>(
- chip::JniReferences::GetInstance().IntegerToPrimitive(element_0_fabricSensitiveStructItem_1_fItem_2));
+ listHolder_0->mList[i_0].fabricSensitiveStruct.f.SetRaw(
+ static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.f)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(element_0_fabricSensitiveStructItem_1_fItem_2)));
jobject element_0_fabricSensitiveStructItem_1_gItem_2;
chip::JniReferences::GetInstance().GetObjectField(element_0_fabricSensitiveStructItem_1, "g", "Ljava/lang/Float;",
element_0_fabricSensitiveStructItem_1_gItem_2);
@@ -11207,8 +11261,8 @@
else
{
auto & nonNullValue_0 = cppValue.SetNonNull();
- nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(
- chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ nonNullValue_0.SetRaw(static_cast<std::remove_reference_t<decltype(nonNullValue_0)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
}
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
@@ -11267,8 +11321,8 @@
else
{
auto & nonNullValue_0 = cppValue.SetNonNull();
- nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(
- chip::JniReferences::GetInstance().IntegerToPrimitive(value));
+ nonNullValue_0.SetRaw(static_cast<std::remove_reference_t<decltype(nonNullValue_0)>::IntegerType>(
+ chip::JniReferences::GetInstance().IntegerToPrimitive(value)));
}
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
@@ -11327,8 +11381,8 @@
else
{
auto & nonNullValue_0 = cppValue.SetNonNull();
- nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(
- chip::JniReferences::GetInstance().LongToPrimitive(value));
+ nonNullValue_0.SetRaw(static_cast<std::remove_reference_t<decltype(nonNullValue_0)>::IntegerType>(
+ chip::JniReferences::GetInstance().LongToPrimitive(value)));
}
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
@@ -11387,8 +11441,8 @@
else
{
auto & nonNullValue_0 = cppValue.SetNonNull();
- nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(
- chip::JniReferences::GetInstance().LongToPrimitive(value));
+ nonNullValue_0.SetRaw(static_cast<std::remove_reference_t<decltype(nonNullValue_0)>::IntegerType>(
+ chip::JniReferences::GetInstance().LongToPrimitive(value)));
}
std::unique_ptr<CHIPDefaultSuccessCallback, void (*)(CHIPDefaultSuccessCallback *)> onSuccess(
diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
index 965fc7e..698b243 100644
--- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
+++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp
@@ -2432,6 +2432,68 @@
}
break;
}
+ case app::Clusters::RefrigeratorAlarm::Id: {
+ using namespace app::Clusters::RefrigeratorAlarm;
+ switch (aPath.mEventId)
+ {
+ case Events::Notify::Id: {
+ Events::Notify::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value_active;
+ std::string value_activeClassName = "java/lang/Long";
+ std::string value_activeCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ value_activeClassName.c_str(), value_activeCtorSignature.c_str(), cppValue.active.Raw(), value_active);
+
+ jobject value_inactive;
+ std::string value_inactiveClassName = "java/lang/Long";
+ std::string value_inactiveCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ value_inactiveClassName.c_str(), value_inactiveCtorSignature.c_str(), cppValue.inactive.Raw(), value_inactive);
+
+ jobject value_state;
+ std::string value_stateClassName = "java/lang/Long";
+ std::string value_stateCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ value_stateClassName.c_str(), value_stateCtorSignature.c_str(), cppValue.state.Raw(), value_state);
+
+ jobject value_mask;
+ std::string value_maskClassName = "java/lang/Long";
+ std::string value_maskCtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(
+ value_maskClassName.c_str(), value_maskCtorSignature.c_str(), cppValue.mask.Raw(), value_mask);
+
+ jclass notifyStructClass;
+ err = chip::JniReferences::GetInstance().GetClassRef(
+ env, "chip/devicecontroller/ChipEventStructs$RefrigeratorAlarmClusterNotifyEvent", notifyStructClass);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogError(Zcl, "Could not find class ChipEventStructs$RefrigeratorAlarmClusterNotifyEvent");
+ return nullptr;
+ }
+ jmethodID notifyStructCtor = env->GetMethodID(notifyStructClass, "<init>",
+ "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;)V");
+ if (notifyStructCtor == nullptr)
+ {
+ ChipLogError(Zcl, "Could not find ChipEventStructs$RefrigeratorAlarmClusterNotifyEvent constructor");
+ return nullptr;
+ }
+
+ jobject value =
+ env->NewObject(notifyStructClass, notifyStructCtor, value_active, value_inactive, value_state, value_mask);
+
+ return value;
+ }
+ default:
+ *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+ break;
+ }
+ break;
+ }
case app::Clusters::AirQuality::Id: {
using namespace app::Clusters::AirQuality;
switch (aPath.mEventId)
diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
index 6148aaf..67b729f 100644
--- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
+++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
@@ -20614,6 +20614,290 @@
env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
}
+CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback::CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback(
+ jobject javaCallback, bool keepAlive) :
+ chip::Callback::Callback<CHIPRefrigeratorAlarmClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
+ keepAlive(keepAlive)
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ return;
+ }
+
+ javaCallbackRef = env->NewGlobalRef(javaCallback);
+ if (javaCallbackRef == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ }
+}
+
+CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback::~CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback()
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not delete global reference for Java callback");
+ return;
+ }
+ env->DeleteGlobalRef(javaCallbackRef);
+}
+
+void CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback::CallbackFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & list)
+{
+ chip::DeviceLayer::StackUnlock unlock;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ jobject javaCallbackRef;
+
+ VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));
+
+ std::unique_ptr<CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback, decltype(&maybeDestroy)> cppCallback(
+ reinterpret_cast<CHIPRefrigeratorAlarmGeneratedCommandListAttributeCallback *>(context), maybeDestroy);
+
+ // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
+ javaCallbackRef = cppCallback.get()->javaCallbackRef;
+ VerifyOrReturn(javaCallbackRef != nullptr,
+ ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
+
+ jmethodID javaMethod;
+ err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod);
+ VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
+
+ jobject arrayListObj;
+ chip::JniReferences::GetInstance().CreateArrayList(arrayListObj);
+
+ auto iter_arrayListObj_0 = list.begin();
+ while (iter_arrayListObj_0.Next())
+ {
+ auto & entry_0 = iter_arrayListObj_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(newElement_0ClassName.c_str(),
+ newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
+ }
+
+ env->ExceptionClear();
+ env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
+}
+
+CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback::CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback(
+ jobject javaCallback, bool keepAlive) :
+ chip::Callback::Callback<CHIPRefrigeratorAlarmClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
+ keepAlive(keepAlive)
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ return;
+ }
+
+ javaCallbackRef = env->NewGlobalRef(javaCallback);
+ if (javaCallbackRef == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ }
+}
+
+CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback::~CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback()
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not delete global reference for Java callback");
+ return;
+ }
+ env->DeleteGlobalRef(javaCallbackRef);
+}
+
+void CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback::CallbackFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & list)
+{
+ chip::DeviceLayer::StackUnlock unlock;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ jobject javaCallbackRef;
+
+ VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));
+
+ std::unique_ptr<CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback, decltype(&maybeDestroy)> cppCallback(
+ reinterpret_cast<CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback *>(context), maybeDestroy);
+
+ // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
+ javaCallbackRef = cppCallback.get()->javaCallbackRef;
+ VerifyOrReturn(javaCallbackRef != nullptr,
+ ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
+
+ jmethodID javaMethod;
+ err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod);
+ VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
+
+ jobject arrayListObj;
+ chip::JniReferences::GetInstance().CreateArrayList(arrayListObj);
+
+ auto iter_arrayListObj_0 = list.begin();
+ while (iter_arrayListObj_0.Next())
+ {
+ auto & entry_0 = iter_arrayListObj_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(newElement_0ClassName.c_str(),
+ newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
+ }
+
+ env->ExceptionClear();
+ env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
+}
+
+CHIPRefrigeratorAlarmEventListAttributeCallback::CHIPRefrigeratorAlarmEventListAttributeCallback(jobject javaCallback,
+ bool keepAlive) :
+ chip::Callback::Callback<CHIPRefrigeratorAlarmClusterEventListAttributeCallbackType>(CallbackFn, this),
+ keepAlive(keepAlive)
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ return;
+ }
+
+ javaCallbackRef = env->NewGlobalRef(javaCallback);
+ if (javaCallbackRef == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ }
+}
+
+CHIPRefrigeratorAlarmEventListAttributeCallback::~CHIPRefrigeratorAlarmEventListAttributeCallback()
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not delete global reference for Java callback");
+ return;
+ }
+ env->DeleteGlobalRef(javaCallbackRef);
+}
+
+void CHIPRefrigeratorAlarmEventListAttributeCallback::CallbackFn(void * context,
+ const chip::app::DataModel::DecodableList<chip::EventId> & list)
+{
+ chip::DeviceLayer::StackUnlock unlock;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ jobject javaCallbackRef;
+
+ VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));
+
+ std::unique_ptr<CHIPRefrigeratorAlarmEventListAttributeCallback, decltype(&maybeDestroy)> cppCallback(
+ reinterpret_cast<CHIPRefrigeratorAlarmEventListAttributeCallback *>(context), maybeDestroy);
+
+ // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
+ javaCallbackRef = cppCallback.get()->javaCallbackRef;
+ VerifyOrReturn(javaCallbackRef != nullptr,
+ ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
+
+ jmethodID javaMethod;
+ err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod);
+ VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
+
+ jobject arrayListObj;
+ chip::JniReferences::GetInstance().CreateArrayList(arrayListObj);
+
+ auto iter_arrayListObj_0 = list.begin();
+ while (iter_arrayListObj_0.Next())
+ {
+ auto & entry_0 = iter_arrayListObj_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(newElement_0ClassName.c_str(),
+ newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
+ }
+
+ env->ExceptionClear();
+ env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
+}
+
+CHIPRefrigeratorAlarmAttributeListAttributeCallback::CHIPRefrigeratorAlarmAttributeListAttributeCallback(jobject javaCallback,
+ bool keepAlive) :
+ chip::Callback::Callback<CHIPRefrigeratorAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this),
+ keepAlive(keepAlive)
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ return;
+ }
+
+ javaCallbackRef = env->NewGlobalRef(javaCallback);
+ if (javaCallbackRef == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ }
+}
+
+CHIPRefrigeratorAlarmAttributeListAttributeCallback::~CHIPRefrigeratorAlarmAttributeListAttributeCallback()
+{
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not delete global reference for Java callback");
+ return;
+ }
+ env->DeleteGlobalRef(javaCallbackRef);
+}
+
+void CHIPRefrigeratorAlarmAttributeListAttributeCallback::CallbackFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & list)
+{
+ chip::DeviceLayer::StackUnlock unlock;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
+ jobject javaCallbackRef;
+
+ VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));
+
+ std::unique_ptr<CHIPRefrigeratorAlarmAttributeListAttributeCallback, decltype(&maybeDestroy)> cppCallback(
+ reinterpret_cast<CHIPRefrigeratorAlarmAttributeListAttributeCallback *>(context), maybeDestroy);
+
+ // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
+ javaCallbackRef = cppCallback.get()->javaCallbackRef;
+ VerifyOrReturn(javaCallbackRef != nullptr,
+ ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
+
+ jmethodID javaMethod;
+ err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod);
+ VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
+
+ jobject arrayListObj;
+ chip::JniReferences::GetInstance().CreateArrayList(arrayListObj);
+
+ auto iter_arrayListObj_0 = list.begin();
+ while (iter_arrayListObj_0.Next())
+ {
+ auto & entry_0 = iter_arrayListObj_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ chip::JniReferences::GetInstance().CreateBoxedObject<uint32_t>(newElement_0ClassName.c_str(),
+ newElement_0CtorSignature.c_str(), entry_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0);
+ }
+
+ env->ExceptionClear();
+ env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
+}
+
CHIPAirQualityGeneratedCommandListAttributeCallback::CHIPAirQualityGeneratedCommandListAttributeCallback(jobject javaCallback,
bool keepAlive) :
chip::Callback::Callback<CHIPAirQualityClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
index 1f28de5..9509b55 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
@@ -14128,6 +14128,224 @@
long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
}
+ public static class RefrigeratorAlarmCluster extends BaseChipCluster {
+ public static final long CLUSTER_ID = 87L;
+
+ public RefrigeratorAlarmCluster(long devicePtr, int endpointId) {
+ super(devicePtr, endpointId);
+ }
+
+ @Override
+ public native long initWithDevice(long devicePtr, int endpointId);
+
+ public void reset(DefaultClusterCallback callback, Long alarms, Optional<Long> mask) {
+ reset(chipClusterPtr, callback, alarms, mask, null);
+ }
+
+ public void reset(
+ DefaultClusterCallback callback,
+ Long alarms,
+ Optional<Long> mask,
+ int timedInvokeTimeoutMs) {
+ reset(chipClusterPtr, callback, alarms, mask, timedInvokeTimeoutMs);
+ }
+
+ private native void reset(
+ long chipClusterPtr,
+ DefaultClusterCallback Callback,
+ Long alarms,
+ Optional<Long> mask,
+ @Nullable Integer timedInvokeTimeoutMs);
+
+ public interface GeneratedCommandListAttributeCallback {
+ void onSuccess(List<Long> valueList);
+
+ void onError(Exception ex);
+
+ default void onSubscriptionEstablished(long subscriptionId) {}
+ }
+
+ public interface AcceptedCommandListAttributeCallback {
+ void onSuccess(List<Long> valueList);
+
+ void onError(Exception ex);
+
+ default void onSubscriptionEstablished(long subscriptionId) {}
+ }
+
+ public interface EventListAttributeCallback {
+ void onSuccess(List<Long> valueList);
+
+ void onError(Exception ex);
+
+ default void onSubscriptionEstablished(long subscriptionId) {}
+ }
+
+ public interface AttributeListAttributeCallback {
+ void onSuccess(List<Long> valueList);
+
+ void onError(Exception ex);
+
+ default void onSubscriptionEstablished(long subscriptionId) {}
+ }
+
+ public void readMaskAttribute(LongAttributeCallback callback) {
+ readMaskAttribute(chipClusterPtr, callback);
+ }
+
+ public void writeMaskAttribute(DefaultClusterCallback callback, Long value) {
+ writeMaskAttribute(chipClusterPtr, callback, value, null);
+ }
+
+ public void writeMaskAttribute(
+ DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+ writeMaskAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+ }
+
+ public void subscribeMaskAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readLatchAttribute(LongAttributeCallback callback) {
+ readLatchAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeLatchAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeLatchAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readStateAttribute(LongAttributeCallback callback) {
+ readStateAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeStateAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readGeneratedCommandListAttribute(GeneratedCommandListAttributeCallback callback) {
+ readGeneratedCommandListAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeGeneratedCommandListAttribute(
+ GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readAcceptedCommandListAttribute(AcceptedCommandListAttributeCallback callback) {
+ readAcceptedCommandListAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeAcceptedCommandListAttribute(
+ AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readEventListAttribute(EventListAttributeCallback callback) {
+ readEventListAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeEventListAttribute(
+ EventListAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readAttributeListAttribute(AttributeListAttributeCallback callback) {
+ readAttributeListAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeAttributeListAttribute(
+ AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readFeatureMapAttribute(LongAttributeCallback callback) {
+ readFeatureMapAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeFeatureMapAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ public void readClusterRevisionAttribute(IntegerAttributeCallback callback) {
+ readClusterRevisionAttribute(chipClusterPtr, callback);
+ }
+
+ public void subscribeClusterRevisionAttribute(
+ IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+ subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+ }
+
+ private native void readMaskAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void writeMaskAttribute(
+ long chipClusterPtr,
+ DefaultClusterCallback callback,
+ Long value,
+ @Nullable Integer timedWriteTimeoutMs);
+
+ private native void subscribeMaskAttribute(
+ long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+
+ private native void readLatchAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void subscribeLatchAttribute(
+ long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+
+ private native void readStateAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void subscribeStateAttribute(
+ long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+
+ private native void readGeneratedCommandListAttribute(
+ long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+
+ private native void subscribeGeneratedCommandListAttribute(
+ long chipClusterPtr,
+ GeneratedCommandListAttributeCallback callback,
+ int minInterval,
+ int maxInterval);
+
+ private native void readAcceptedCommandListAttribute(
+ long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+
+ private native void subscribeAcceptedCommandListAttribute(
+ long chipClusterPtr,
+ AcceptedCommandListAttributeCallback callback,
+ int minInterval,
+ int maxInterval);
+
+ private native void readEventListAttribute(
+ long chipClusterPtr, EventListAttributeCallback callback);
+
+ private native void subscribeEventListAttribute(
+ long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+
+ private native void readAttributeListAttribute(
+ long chipClusterPtr, AttributeListAttributeCallback callback);
+
+ private native void subscribeAttributeListAttribute(
+ long chipClusterPtr,
+ AttributeListAttributeCallback callback,
+ int minInterval,
+ int maxInterval);
+
+ private native void readFeatureMapAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void subscribeFeatureMapAttribute(
+ long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+
+ private native void readClusterRevisionAttribute(
+ long chipClusterPtr, IntegerAttributeCallback callback);
+
+ private native void subscribeClusterRevisionAttribute(
+ long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+ }
+
public static class AirQualityCluster extends BaseChipCluster {
public static final long CLUSTER_ID = 91L;
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java
index 2e78872..6a0bfaa 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java
@@ -963,6 +963,40 @@
}
}
+ public static class RefrigeratorAlarmClusterNotifyEvent {
+ public Long active;
+ public Long inactive;
+ public Long state;
+ public Long mask;
+
+ public RefrigeratorAlarmClusterNotifyEvent(Long active, Long inactive, Long state, Long mask) {
+ this.active = active;
+ this.inactive = inactive;
+ this.state = state;
+ this.mask = mask;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("RefrigeratorAlarmClusterNotifyEvent {\n");
+ output.append("\tactive: ");
+ output.append(active);
+ output.append("\n");
+ output.append("\tinactive: ");
+ output.append(inactive);
+ output.append("\n");
+ output.append("\tstate: ");
+ output.append(state);
+ output.append("\n");
+ output.append("\tmask: ");
+ output.append(mask);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+ }
+
public static class SmokeCoAlarmClusterSmokeAlarmEvent {
public SmokeCoAlarmClusterSmokeAlarmEvent() {}
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java
index 37fd144..f1f239b 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java
@@ -154,6 +154,9 @@
if (clusterId == 86L) {
return "TemperatureControl";
}
+ if (clusterId == 87L) {
+ return "RefrigeratorAlarm";
+ }
if (clusterId == 91L) {
return "AirQuality";
}
@@ -2073,6 +2076,36 @@
}
return "";
}
+ if (clusterId == 87L) {
+ if (attributeId == 0L) {
+ return "Mask";
+ }
+ if (attributeId == 1L) {
+ return "Latch";
+ }
+ if (attributeId == 2L) {
+ return "State";
+ }
+ if (attributeId == 65528L) {
+ return "GeneratedCommandList";
+ }
+ if (attributeId == 65529L) {
+ return "AcceptedCommandList";
+ }
+ if (attributeId == 65530L) {
+ return "EventList";
+ }
+ if (attributeId == 65531L) {
+ return "AttributeList";
+ }
+ if (attributeId == 65532L) {
+ return "FeatureMap";
+ }
+ if (attributeId == 65533L) {
+ return "ClusterRevision";
+ }
+ return "";
+ }
if (clusterId == 91L) {
if (attributeId == 0L) {
return "AirQuality";
@@ -4931,6 +4964,12 @@
if (clusterId == 86L) {
return "";
}
+ if (clusterId == 87L) {
+ if (eventId == 0L) {
+ return "Notify";
+ }
+ return "";
+ }
if (clusterId == 91L) {
return "";
}
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java
index 6b5e710..71e6724 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java
@@ -7489,6 +7489,102 @@
}
}
+ public static class DelegatedRefrigeratorAlarmClusterGeneratedCommandListAttributeCallback
+ implements ChipClusters.RefrigeratorAlarmCluster.GeneratedCommandListAttributeCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List<Long> valueList) {
+ Map<CommandResponseInfo, Object> responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List<Long>");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedRefrigeratorAlarmClusterAcceptedCommandListAttributeCallback
+ implements ChipClusters.RefrigeratorAlarmCluster.AcceptedCommandListAttributeCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List<Long> valueList) {
+ Map<CommandResponseInfo, Object> responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List<Long>");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedRefrigeratorAlarmClusterEventListAttributeCallback
+ implements ChipClusters.RefrigeratorAlarmCluster.EventListAttributeCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List<Long> valueList) {
+ Map<CommandResponseInfo, Object> responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List<Long>");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedRefrigeratorAlarmClusterAttributeListAttributeCallback
+ implements ChipClusters.RefrigeratorAlarmCluster.AttributeListAttributeCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List<Long> valueList) {
+ Map<CommandResponseInfo, Object> responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List<Long>");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
public static class DelegatedAirQualityClusterGeneratedCommandListAttributeCallback
implements ChipClusters.AirQualityCluster.GeneratedCommandListAttributeCallback,
DelegatedClusterCallback {
@@ -15674,6 +15770,11 @@
(ptr, endpointId) -> new ChipClusters.TemperatureControlCluster(ptr, endpointId),
new HashMap<>());
clusterMap.put("temperatureControl", temperatureControlClusterInfo);
+ ClusterInfo refrigeratorAlarmClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.RefrigeratorAlarmCluster(ptr, endpointId),
+ new HashMap<>());
+ clusterMap.put("refrigeratorAlarm", refrigeratorAlarmClusterInfo);
ClusterInfo airQualityClusterInfo =
new ClusterInfo(
(ptr, endpointId) -> new ChipClusters.AirQualityCluster(ptr, endpointId),
@@ -15965,6 +16066,7 @@
destination.get("icdManagement").combineCommands(source.get("icdManagement"));
destination.get("modeSelect").combineCommands(source.get("modeSelect"));
destination.get("temperatureControl").combineCommands(source.get("temperatureControl"));
+ destination.get("refrigeratorAlarm").combineCommands(source.get("refrigeratorAlarm"));
destination.get("airQuality").combineCommands(source.get("airQuality"));
destination.get("smokeCoAlarm").combineCommands(source.get("smokeCoAlarm"));
destination.get("hepaFilterMonitoring").combineCommands(source.get("hepaFilterMonitoring"));
@@ -18127,6 +18229,31 @@
Map<String, InteractionInfo> temperatureControlClusterInteractionInfoMap =
new LinkedHashMap<>();
commandMap.put("temperatureControl", temperatureControlClusterInteractionInfoMap);
+ Map<String, InteractionInfo> refrigeratorAlarmClusterInteractionInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> refrigeratorAlarmresetCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ CommandParameterInfo refrigeratorAlarmresetalarmsCommandParameterInfo =
+ new CommandParameterInfo("alarms", Long.class, Long.class);
+ refrigeratorAlarmresetCommandParams.put(
+ "alarms", refrigeratorAlarmresetalarmsCommandParameterInfo);
+
+ CommandParameterInfo refrigeratorAlarmresetmaskCommandParameterInfo =
+ new CommandParameterInfo("mask", Optional.class, Long.class);
+ refrigeratorAlarmresetCommandParams.put("mask", refrigeratorAlarmresetmaskCommandParameterInfo);
+
+ InteractionInfo refrigeratorAlarmresetInteractionInfo =
+ new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.RefrigeratorAlarmCluster) cluster)
+ .reset(
+ (DefaultClusterCallback) callback,
+ (Long) commandArguments.get("alarms"),
+ (Optional<Long>) commandArguments.get("mask"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ refrigeratorAlarmresetCommandParams);
+ refrigeratorAlarmClusterInteractionInfoMap.put("reset", refrigeratorAlarmresetInteractionInfo);
+ commandMap.put("refrigeratorAlarm", refrigeratorAlarmClusterInteractionInfoMap);
Map<String, InteractionInfo> airQualityClusterInteractionInfoMap = new LinkedHashMap<>();
commandMap.put("airQuality", airQualityClusterInteractionInfoMap);
Map<String, InteractionInfo> smokeCoAlarmClusterInteractionInfoMap = new LinkedHashMap<>();
diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py
index 66dacda..9530429 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.py
+++ b/src/controller/python/chip/clusters/CHIPClusters.py
@@ -4434,6 +4434,77 @@
},
},
}
+ _REFRIGERATOR_ALARM_CLUSTER_INFO = {
+ "clusterName": "RefrigeratorAlarm",
+ "clusterId": 0x00000057,
+ "commands": {
+ 0x00000000: {
+ "commandId": 0x00000000,
+ "commandName": "Reset",
+ "args": {
+ "alarms": "int",
+ "mask": "int",
+ },
+ },
+ },
+ "attributes": {
+ 0x00000000: {
+ "attributeName": "Mask",
+ "attributeId": 0x00000000,
+ "type": "int",
+ "reportable": True,
+ "writable": True,
+ },
+ 0x00000001: {
+ "attributeName": "Latch",
+ "attributeId": 0x00000001,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x00000002: {
+ "attributeName": "State",
+ "attributeId": 0x00000002,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x0000FFF8: {
+ "attributeName": "GeneratedCommandList",
+ "attributeId": 0x0000FFF8,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x0000FFF9: {
+ "attributeName": "AcceptedCommandList",
+ "attributeId": 0x0000FFF9,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x0000FFFA: {
+ "attributeName": "EventList",
+ "attributeId": 0x0000FFFA,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x0000FFFB: {
+ "attributeName": "AttributeList",
+ "attributeId": 0x0000FFFB,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x0000FFFC: {
+ "attributeName": "FeatureMap",
+ "attributeId": 0x0000FFFC,
+ "type": "int",
+ "reportable": True,
+ },
+ 0x0000FFFD: {
+ "attributeName": "ClusterRevision",
+ "attributeId": 0x0000FFFD,
+ "type": "int",
+ "reportable": True,
+ },
+ },
+ }
_AIR_QUALITY_CLUSTER_INFO = {
"clusterName": "AirQuality",
"clusterId": 0x0000005B,
@@ -10907,6 +10978,7 @@
0x00000046: _ICD_MANAGEMENT_CLUSTER_INFO,
0x00000050: _MODE_SELECT_CLUSTER_INFO,
0x00000056: _TEMPERATURE_CONTROL_CLUSTER_INFO,
+ 0x00000057: _REFRIGERATOR_ALARM_CLUSTER_INFO,
0x0000005B: _AIR_QUALITY_CLUSTER_INFO,
0x0000005C: _SMOKE_CO_ALARM_CLUSTER_INFO,
0x00000071: _HEPA_FILTER_MONITORING_CLUSTER_INFO,
@@ -10997,6 +11069,7 @@
"IcdManagement": _ICD_MANAGEMENT_CLUSTER_INFO,
"ModeSelect": _MODE_SELECT_CLUSTER_INFO,
"TemperatureControl": _TEMPERATURE_CONTROL_CLUSTER_INFO,
+ "RefrigeratorAlarm": _REFRIGERATOR_ALARM_CLUSTER_INFO,
"AirQuality": _AIR_QUALITY_CLUSTER_INFO,
"SmokeCoAlarm": _SMOKE_CO_ALARM_CLUSTER_INFO,
"HepaFilterMonitoring": _HEPA_FILTER_MONITORING_CLUSTER_INFO,
diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py
index 6ecaedb..81f22de 100644
--- a/src/controller/python/chip/clusters/Objects.py
+++ b/src/controller/python/chip/clusters/Objects.py
@@ -15369,6 +15369,230 @@
@dataclass
+class RefrigeratorAlarm(Cluster):
+ id: typing.ClassVar[int] = 0x0057
+
+ @ChipUtility.classproperty
+ def descriptor(cls) -> ClusterObjectDescriptor:
+ return ClusterObjectDescriptor(
+ Fields=[
+ ClusterObjectFieldDescriptor(Label="mask", Tag=0x00000000, Type=uint),
+ ClusterObjectFieldDescriptor(Label="latch", Tag=0x00000001, Type=uint),
+ ClusterObjectFieldDescriptor(Label="state", Tag=0x00000002, Type=uint),
+ ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]),
+ ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]),
+ ClusterObjectFieldDescriptor(Label="eventList", Tag=0x0000FFFA, Type=typing.List[uint]),
+ ClusterObjectFieldDescriptor(Label="attributeList", Tag=0x0000FFFB, Type=typing.List[uint]),
+ ClusterObjectFieldDescriptor(Label="featureMap", Tag=0x0000FFFC, Type=uint),
+ ClusterObjectFieldDescriptor(Label="clusterRevision", Tag=0x0000FFFD, Type=uint),
+ ])
+
+ mask: 'uint' = None
+ latch: 'uint' = None
+ state: 'uint' = None
+ generatedCommandList: 'typing.List[uint]' = None
+ acceptedCommandList: 'typing.List[uint]' = None
+ eventList: 'typing.List[uint]' = None
+ attributeList: 'typing.List[uint]' = None
+ featureMap: 'uint' = None
+ clusterRevision: 'uint' = None
+
+ class Bitmaps:
+ class AlarmMap(IntFlag):
+ kDoorOpen = 0x1
+
+ class Commands:
+ @dataclass
+ class Reset(ClusterCommand):
+ cluster_id: typing.ClassVar[int] = 0x0057
+ command_id: typing.ClassVar[int] = 0x00000000
+ is_client: typing.ClassVar[bool] = True
+ response_type: typing.ClassVar[str] = None
+
+ @ChipUtility.classproperty
+ def descriptor(cls) -> ClusterObjectDescriptor:
+ return ClusterObjectDescriptor(
+ Fields=[
+ ClusterObjectFieldDescriptor(Label="alarms", Tag=0, Type=uint),
+ ClusterObjectFieldDescriptor(Label="mask", Tag=1, Type=typing.Optional[uint]),
+ ])
+
+ alarms: 'uint' = 0
+ mask: 'typing.Optional[uint]' = None
+
+ class Attributes:
+ @dataclass
+ class Mask(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x00000000
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=uint)
+
+ value: 'uint' = 0
+
+ @dataclass
+ class Latch(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x00000001
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=uint)
+
+ value: 'uint' = 0
+
+ @dataclass
+ class State(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x00000002
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=uint)
+
+ value: 'uint' = 0
+
+ @dataclass
+ class GeneratedCommandList(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x0000FFF8
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+ value: 'typing.List[uint]' = field(default_factory=lambda: [])
+
+ @dataclass
+ class AcceptedCommandList(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x0000FFF9
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+ value: 'typing.List[uint]' = field(default_factory=lambda: [])
+
+ @dataclass
+ class EventList(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x0000FFFA
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+ value: 'typing.List[uint]' = field(default_factory=lambda: [])
+
+ @dataclass
+ class AttributeList(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x0000FFFB
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+ value: 'typing.List[uint]' = field(default_factory=lambda: [])
+
+ @dataclass
+ class FeatureMap(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x0000FFFC
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=uint)
+
+ value: 'uint' = 0
+
+ @dataclass
+ class ClusterRevision(ClusterAttributeDescriptor):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def attribute_id(cls) -> int:
+ return 0x0000FFFD
+
+ @ChipUtility.classproperty
+ def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+ return ClusterObjectFieldDescriptor(Type=uint)
+
+ value: 'uint' = 0
+
+ class Events:
+ @dataclass
+ class Notify(ClusterEvent):
+ @ChipUtility.classproperty
+ def cluster_id(cls) -> int:
+ return 0x0057
+
+ @ChipUtility.classproperty
+ def event_id(cls) -> int:
+ return 0x00000000
+
+ @ChipUtility.classproperty
+ def descriptor(cls) -> ClusterObjectDescriptor:
+ return ClusterObjectDescriptor(
+ Fields=[
+ ClusterObjectFieldDescriptor(Label="active", Tag=0, Type=uint),
+ ClusterObjectFieldDescriptor(Label="inactive", Tag=1, Type=uint),
+ ClusterObjectFieldDescriptor(Label="state", Tag=2, Type=uint),
+ ClusterObjectFieldDescriptor(Label="mask", Tag=3, Type=uint),
+ ])
+
+ active: 'uint' = 0
+ inactive: 'uint' = 0
+ state: 'uint' = 0
+ mask: 'uint' = 0
+
+
+@dataclass
class AirQuality(Cluster):
id: typing.ClassVar[int] = 0x005B
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm
index 61e6ec6..a502712 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm
@@ -9246,6 +9246,178 @@
*aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB;
return nil;
}
+static id _Nullable DecodeAttributeValueForRefrigeratorAlarmCluster(
+ AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
+{
+ using namespace Clusters::RefrigeratorAlarm;
+ switch (aAttributeId) {
+ case Attributes::Mask::Id: {
+ using TypeInfo = Attributes::Mask::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSNumber * _Nonnull value;
+ value = [NSNumber numberWithUnsignedInt:cppValue.Raw()];
+ return value;
+ }
+ case Attributes::Latch::Id: {
+ using TypeInfo = Attributes::Latch::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSNumber * _Nonnull value;
+ value = [NSNumber numberWithUnsignedInt:cppValue.Raw()];
+ return value;
+ }
+ case Attributes::State::Id: {
+ using TypeInfo = Attributes::State::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSNumber * _Nonnull value;
+ value = [NSNumber numberWithUnsignedInt:cppValue.Raw()];
+ return value;
+ }
+ case Attributes::GeneratedCommandList::Id: {
+ using TypeInfo = Attributes::GeneratedCommandList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSArray * _Nonnull value;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = cppValue.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ *aError = err;
+ return nil;
+ }
+ value = array_0;
+ }
+ return value;
+ }
+ case Attributes::AcceptedCommandList::Id: {
+ using TypeInfo = Attributes::AcceptedCommandList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSArray * _Nonnull value;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = cppValue.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ *aError = err;
+ return nil;
+ }
+ value = array_0;
+ }
+ return value;
+ }
+ case Attributes::EventList::Id: {
+ using TypeInfo = Attributes::EventList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSArray * _Nonnull value;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = cppValue.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ *aError = err;
+ return nil;
+ }
+ value = array_0;
+ }
+ return value;
+ }
+ case Attributes::AttributeList::Id: {
+ using TypeInfo = Attributes::AttributeList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSArray * _Nonnull value;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = cppValue.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ *aError = err;
+ return nil;
+ }
+ value = array_0;
+ }
+ return value;
+ }
+ case Attributes::FeatureMap::Id: {
+ using TypeInfo = Attributes::FeatureMap::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSNumber * _Nonnull value;
+ value = [NSNumber numberWithUnsignedInt:cppValue];
+ return value;
+ }
+ case Attributes::ClusterRevision::Id: {
+ using TypeInfo = Attributes::ClusterRevision::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+ NSNumber * _Nonnull value;
+ value = [NSNumber numberWithUnsignedShort:cppValue];
+ return value;
+ }
+ default: {
+ break;
+ }
+ }
+
+ *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB;
+ return nil;
+}
static id _Nullable DecodeAttributeValueForAirQualityCluster(
AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
{
@@ -22486,6 +22658,9 @@
case Clusters::TemperatureControl::Id: {
return DecodeAttributeValueForTemperatureControlCluster(aPath.mAttributeId, aReader, aError);
}
+ case Clusters::RefrigeratorAlarm::Id: {
+ return DecodeAttributeValueForRefrigeratorAlarmCluster(aPath.mAttributeId, aReader, aError);
+ }
case Clusters::AirQuality::Id: {
return DecodeAttributeValueForAirQualityCluster(aPath.mAttributeId, aReader, aError);
}
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h
index 5c48e40..057bcd7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h
@@ -8042,6 +8042,143 @@
@end
/**
+ * Cluster Refrigerator Alarm
+ *
+ * Attributes and commands for configuring the Refrigerator alarm.
+ */
+MTR_NEWLY_AVAILABLE
+@interface MTRBaseClusterRefrigeratorAlarm : MTRCluster
+
+- (instancetype _Nullable)initWithDevice:(MTRBaseDevice *)device
+ endpointID:(NSNumber *)endpointID
+ queue:(dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER MTR_NEWLY_AVAILABLE;
+
+/**
+ * Command Reset
+ *
+ * Reset alarm
+ */
+- (void)resetWithParams:(MTRRefrigeratorAlarmClusterResetParams *)params
+ completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE;
+- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value
+ params:(MTRWriteParams * _Nullable)params
+ completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeMaskWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeLatchWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeLatchWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeLatchWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSArray * _Nullable value,
+ NSError * _Nullable error))reportHandler MTR_NEWLY_AVAILABLE;
++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSArray * _Nullable value,
+ NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSArray * _Nullable value,
+ NSError * _Nullable error))reportHandler MTR_NEWLY_AVAILABLE;
++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSArray * _Nullable value,
+ NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+
+- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+ MTR_NEWLY_AVAILABLE;
+- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams *)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+ MTR_NEWLY_AVAILABLE;
++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value,
+ NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+/**
* Cluster Air Quality
*
* Attributes for reporting air quality classification
@@ -23200,6 +23337,10 @@
MTRTemperatureControlFeatureTemperatureLevel MTR_NEWLY_AVAILABLE = 0x2,
} MTR_NEWLY_AVAILABLE;
+typedef NS_OPTIONS(uint32_t, MTRRefrigeratorAlarmAlarmMap) {
+ MTRRefrigeratorAlarmAlarmMapDoorOpen MTR_NEWLY_AVAILABLE = 0x1,
+} MTR_NEWLY_AVAILABLE;
+
typedef NS_ENUM(uint8_t, MTRAirQuality) {
MTRAirQualityUnknown MTR_NEWLY_AVAILABLE = 0x00,
MTRAirQualityGood MTR_NEWLY_AVAILABLE = 0x01,
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
index 2d4cd5b..10844c3 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
@@ -48400,6 +48400,492 @@
@end
+@implementation MTRBaseClusterRefrigeratorAlarm
+
+- (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue
+{
+ if (self = [super initWithQueue:queue]) {
+ if (device == nil) {
+ return nil;
+ }
+
+ _device = device;
+ _endpoint = [endpointID unsignedShortValue];
+ }
+ return self;
+}
+
+- (void)resetWithParams:(MTRRefrigeratorAlarmClusterResetParams *)params completion:(MTRStatusCompletion)completion
+{
+ // Make a copy of params before we go async.
+ params = [params copy];
+ auto * bridge = new MTRCommandSuccessCallbackBridge(
+ self.callbackQueue,
+ ^(id _Nullable value, NSError * _Nullable error) {
+ completion(error);
+ },
+ ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+ MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+ auto * typedBridge = static_cast<MTRCommandSuccessCallbackBridge *>(bridge);
+ Optional<uint16_t> timedInvokeTimeoutMs;
+ Optional<Timeout> invokeTimeout;
+ ListFreer listFreer;
+ RefrigeratorAlarm::Commands::Reset::Type request;
+ if (params != nil) {
+ if (params.timedInvokeTimeoutMs != nil) {
+ params.timedInvokeTimeoutMs = MTRClampedNumber(params.timedInvokeTimeoutMs, @(1), @(UINT16_MAX));
+ timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+ }
+ if (params.serverSideProcessingTimeout != nil) {
+ // Clamp to a number of seconds that will not overflow 32-bit
+ // int when converted to ms.
+ auto * serverSideProcessingTimeout = MTRClampedNumber(params.serverSideProcessingTimeout, @(0), @(UINT16_MAX));
+ invokeTimeout.SetValue(Seconds16(serverSideProcessingTimeout.unsignedShortValue));
+ }
+ }
+ request.alarms = static_cast<std::remove_reference_t<decltype(request.alarms)>>(params.alarms.unsignedIntValue);
+ if (params.mask != nil) {
+ auto & definedValue_0 = request.mask.Emplace();
+ definedValue_0 = static_cast<std::remove_reference_t<decltype(definedValue_0)>>(params.mask.unsignedIntValue);
+ }
+
+ return MTRStartInvokeInteraction(typedBridge, request, exchangeManager, session, successCb, failureCb, self->_endpoint,
+ timedInvokeTimeoutMs, invokeTimeout);
+ });
+ std::move(*bridge).DispatchAction(self.device);
+}
+
+- (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmMaskAttributeCallbackBridge, NSNumber, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
+{
+ [self writeAttributeMaskWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
+}
+- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value
+ params:(MTRWriteParams * _Nullable)params
+ completion:(MTRStatusCompletion)completion
+{
+ // Make a copy of params before we go async.
+ params = [params copy];
+ value = [value copy];
+
+ auto * bridge = new MTRDefaultSuccessCallbackBridge(
+ self.callbackQueue,
+ ^(id _Nullable ignored, NSError * _Nullable error) {
+ completion(error);
+ },
+ ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+ MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+ chip::Optional<uint16_t> timedWriteTimeout;
+ if (params != nil) {
+ if (params.timedWriteTimeout != nil) {
+ timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+ }
+ }
+
+ ListFreer listFreer;
+ using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
+ TypeInfo::Type cppValue;
+ cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);
+
+ chip::Controller::ClusterBase cppCluster(exchangeManager, session, self->_endpoint);
+ return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
+ });
+ std::move(*bridge).DispatchAction(self.device);
+}
+
+- (void)subscribeAttributeMaskWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmMaskAttributeCallbackSubscriptionBridge, NSNumber, TypeInfo::DecodableType>(params,
+ subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(),
+ TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmMaskAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(
+ clusterStateCacheContainer.baseDevice, ^(RefrigeratorAlarmMaskAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeLatchWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::Latch::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmLatchAttributeCallbackBridge, NSNumber, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeLatchWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::Latch::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmLatchAttributeCallbackSubscriptionBridge, NSNumber, TypeInfo::DecodableType>(params,
+ subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(),
+ TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeLatchWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmLatchAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(
+ clusterStateCacheContainer.baseDevice, ^(RefrigeratorAlarmLatchAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::Latch::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::State::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmStateAttributeCallbackBridge, NSNumber, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::State::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmStateAttributeCallbackSubscriptionBridge, NSNumber, TypeInfo::DecodableType>(params,
+ subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(),
+ TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmStateAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(
+ clusterStateCacheContainer.baseDevice, ^(RefrigeratorAlarmStateAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::State::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::GeneratedCommandList::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge, NSArray, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:
+ (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::GeneratedCommandList::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge, NSArray,
+ TypeInfo::DecodableType>(params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint,
+ TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:
+ (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice,
+ ^(RefrigeratorAlarmGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::GeneratedCommandList::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::AcceptedCommandList::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge, NSArray, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:
+ (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::AcceptedCommandList::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge, NSArray,
+ TypeInfo::DecodableType>(params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint,
+ TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:
+ (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice,
+ ^(RefrigeratorAlarmAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::AcceptedCommandList::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::EventList::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmEventListListAttributeCallbackBridge, NSArray, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::EventList::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmEventListListAttributeCallbackSubscriptionBridge, NSArray, TypeInfo::DecodableType>(
+ params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(),
+ TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmEventListListAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice,
+ ^(RefrigeratorAlarmEventListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::EventList::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::AttributeList::TypeInfo;
+ return MTRReadAttribute<MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge, NSArray, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::AttributeList::TypeInfo;
+ MTRSubscribeAttribute<MTRRefrigeratorAlarmAttributeListListAttributeCallbackSubscriptionBridge, NSArray,
+ TypeInfo::DecodableType>(params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint,
+ TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice,
+ ^(RefrigeratorAlarmAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::AttributeList::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::FeatureMap::TypeInfo;
+ return MTRReadAttribute<MTRInt32uAttributeCallbackBridge, NSNumber, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::FeatureMap::TypeInfo;
+ MTRSubscribeAttribute<MTRInt32uAttributeCallbackSubscriptionBridge, NSNumber, TypeInfo::DecodableType>(params,
+ subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(),
+ TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(
+ clusterStateCacheContainer.baseDevice, ^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::FeatureMap::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ MTRReadParams * params = [[MTRReadParams alloc] init];
+ using TypeInfo = RefrigeratorAlarm::Attributes::ClusterRevision::TypeInfo;
+ return MTRReadAttribute<MTRInt16uAttributeCallbackBridge, NSNumber, TypeInfo::DecodableType>(
+ params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId());
+}
+
+- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
+ subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
+ reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
+{
+ using TypeInfo = RefrigeratorAlarm::Attributes::ClusterRevision::TypeInfo;
+ MTRSubscribeAttribute<MTRInt16uAttributeCallbackSubscriptionBridge, NSNumber, TypeInfo::DecodableType>(params,
+ subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(),
+ TypeInfo::GetAttributeId());
+}
+
++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
+ endpoint:(NSNumber *)endpoint
+ queue:(dispatch_queue_t)queue
+ completion:
+ (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
+{
+ auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+ std::move(*bridge).DispatchLocalAction(
+ clusterStateCacheContainer.baseDevice, ^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
+ if (clusterStateCacheContainer.cppClusterStateCache) {
+ chip::app::ConcreteAttributePath path;
+ using TypeInfo = RefrigeratorAlarm::Attributes::ClusterRevision::TypeInfo;
+ path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+ path.mClusterId = TypeInfo::GetClusterId();
+ path.mAttributeId = TypeInfo::GetAttributeId();
+ TypeInfo::DecodableType value;
+ CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
+ if (err == CHIP_NO_ERROR) {
+ successCb(bridge, value);
+ }
+ return err;
+ }
+ return CHIP_ERROR_NOT_FOUND;
+ });
+}
+
+@end
+
@implementation MTRBaseClusterAirQuality
- (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h
index 647703d..5aadb7f 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h
@@ -205,6 +205,11 @@
@property (nonatomic, assign, readonly) chip::EndpointId endpoint;
@end
+@interface MTRBaseClusterRefrigeratorAlarm ()
+@property (nonatomic, strong, readonly) MTRBaseDevice * device;
+@property (nonatomic, assign, readonly) chip::EndpointId endpoint;
+@end
+
@interface MTRBaseClusterAirQuality ()
@property (nonatomic, strong, readonly) MTRBaseDevice * device;
@property (nonatomic, assign, readonly) chip::EndpointId endpoint;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h
index 8500788..c2c0430 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h
@@ -1107,6 +1107,17 @@
const chip::app::DataModel::DecodableList<chip::EventId> & data);
typedef void (*TemperatureControlAttributeListListAttributeCallback)(
void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
+typedef void (*RefrigeratorAlarmMaskAttributeCallback)(void *, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>);
+typedef void (*RefrigeratorAlarmLatchAttributeCallback)(void *, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>);
+typedef void (*RefrigeratorAlarmStateAttributeCallback)(void *, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>);
+typedef void (*RefrigeratorAlarmGeneratedCommandListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
+typedef void (*RefrigeratorAlarmAcceptedCommandListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
+typedef void (*RefrigeratorAlarmEventListListAttributeCallback)(void * context,
+ const chip::app::DataModel::DecodableList<chip::EventId> & data);
+typedef void (*RefrigeratorAlarmAttributeListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*AirQualityGeneratedCommandListListAttributeCallback)(
void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AirQualityAcceptedCommandListListAttributeCallback)(
@@ -8749,6 +8760,228 @@
MTRSubscriptionEstablishedHandler mEstablishedHandler;
};
+class MTRRefrigeratorAlarmMaskAttributeCallbackBridge : public MTRCallbackBridge<RefrigeratorAlarmMaskAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmMaskAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmMaskAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmMaskAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmMaskAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value);
+};
+
+class MTRRefrigeratorAlarmMaskAttributeCallbackSubscriptionBridge : public MTRRefrigeratorAlarmMaskAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmMaskAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmMaskAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmMaskAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmMaskAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
+class MTRRefrigeratorAlarmLatchAttributeCallbackBridge : public MTRCallbackBridge<RefrigeratorAlarmLatchAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmLatchAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmLatchAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmLatchAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmLatchAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value);
+};
+
+class MTRRefrigeratorAlarmLatchAttributeCallbackSubscriptionBridge : public MTRRefrigeratorAlarmLatchAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmLatchAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmLatchAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmLatchAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmLatchAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
+class MTRRefrigeratorAlarmStateAttributeCallbackBridge : public MTRCallbackBridge<RefrigeratorAlarmStateAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmStateAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmStateAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value);
+};
+
+class MTRRefrigeratorAlarmStateAttributeCallbackSubscriptionBridge : public MTRRefrigeratorAlarmStateAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmStateAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmStateAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmStateAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
+class MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge
+ : public MTRCallbackBridge<RefrigeratorAlarmGeneratedCommandListListAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
+};
+
+class MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge
+ : public MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+ dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
+class MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge
+ : public MTRCallbackBridge<RefrigeratorAlarmAcceptedCommandListListAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
+};
+
+class MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge
+ : public MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+ dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
+class MTRRefrigeratorAlarmEventListListAttributeCallbackBridge
+ : public MTRCallbackBridge<RefrigeratorAlarmEventListListAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmEventListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmEventListListAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmEventListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmEventListListAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::EventId> & value);
+};
+
+class MTRRefrigeratorAlarmEventListListAttributeCallbackSubscriptionBridge
+ : public MTRRefrigeratorAlarmEventListListAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmEventListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmEventListListAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmEventListListAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmEventListListAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
+class MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge
+ : public MTRCallbackBridge<RefrigeratorAlarmAttributeListListAttributeCallback>
+{
+public:
+ MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) :
+ MTRCallbackBridge<RefrigeratorAlarmAttributeListListAttributeCallback>(queue, handler, OnSuccessFn){};
+
+ MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action) :
+ MTRCallbackBridge<RefrigeratorAlarmAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn){};
+
+ static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
+};
+
+class MTRRefrigeratorAlarmAttributeListListAttributeCallbackSubscriptionBridge
+ : public MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge
+{
+public:
+ MTRRefrigeratorAlarmAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+ MTRActionBlock action,
+ MTRSubscriptionEstablishedHandler establishedHandler) :
+ MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge(queue, handler, action),
+ mEstablishedHandler(establishedHandler)
+ {}
+
+ void OnSubscriptionEstablished();
+ using MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge::KeepAliveOnCallback;
+ using MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge::OnDone;
+
+private:
+ MTRSubscriptionEstablishedHandler mEstablishedHandler;
+};
+
class MTRAirQualityGeneratedCommandListListAttributeCallbackBridge
: public MTRCallbackBridge<AirQualityGeneratedCommandListListAttributeCallback>
{
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm
index 5f403d4..d750d5a 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm
@@ -8328,6 +8328,227 @@
}
}
+void MTRRefrigeratorAlarmMaskAttributeCallbackBridge::OnSuccessFn(
+ void * context, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value)
+{
+ NSNumber * _Nonnull objCValue;
+ objCValue = [NSNumber numberWithUnsignedInt:value.Raw()];
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmMaskAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
+void MTRRefrigeratorAlarmLatchAttributeCallbackBridge::OnSuccessFn(
+ void * context, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value)
+{
+ NSNumber * _Nonnull objCValue;
+ objCValue = [NSNumber numberWithUnsignedInt:value.Raw()];
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmLatchAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
+void MTRRefrigeratorAlarmStateAttributeCallbackBridge::OnSuccessFn(
+ void * context, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value)
+{
+ NSNumber * _Nonnull objCValue;
+ objCValue = [NSNumber numberWithUnsignedInt:value.Raw()];
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
+void MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackBridge::OnSuccessFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value)
+{
+ NSArray * _Nonnull objCValue;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = value.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ OnFailureFn(context, err);
+ return;
+ }
+ objCValue = array_0;
+ }
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
+void MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackBridge::OnSuccessFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value)
+{
+ NSArray * _Nonnull objCValue;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = value.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ OnFailureFn(context, err);
+ return;
+ }
+ objCValue = array_0;
+ }
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
+void MTRRefrigeratorAlarmEventListListAttributeCallbackBridge::OnSuccessFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::EventId> & value)
+{
+ NSArray * _Nonnull objCValue;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = value.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ OnFailureFn(context, err);
+ return;
+ }
+ objCValue = array_0;
+ }
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmEventListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
+void MTRRefrigeratorAlarmAttributeListListAttributeCallbackBridge::OnSuccessFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value)
+{
+ NSArray * _Nonnull objCValue;
+ { // Scope for our temporary variables
+ auto * array_0 = [NSMutableArray new];
+ auto iter_0 = value.begin();
+ while (iter_0.Next()) {
+ auto & entry_0 = iter_0.GetValue();
+ NSNumber * newElement_0;
+ newElement_0 = [NSNumber numberWithUnsignedInt:entry_0];
+ [array_0 addObject:newElement_0];
+ }
+ CHIP_ERROR err = iter_0.GetStatus();
+ if (err != CHIP_NO_ERROR) {
+ OnFailureFn(context, err);
+ return;
+ }
+ objCValue = array_0;
+ }
+ DispatchSuccess(context, objCValue);
+};
+
+void MTRRefrigeratorAlarmAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished()
+{
+ if (!mQueue) {
+ return;
+ }
+
+ if (mEstablishedHandler != nil) {
+ dispatch_async(mQueue, mEstablishedHandler);
+ // On failure, mEstablishedHandler will be cleaned up by our destructor,
+ // but we can clean it up earlier on successful subscription
+ // establishment.
+ mEstablishedHandler = nil;
+ }
+}
+
void MTRAirQualityGeneratedCommandListListAttributeCallbackBridge::OnSuccessFn(
void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value)
{
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h
index e1d33a8..be9c55e 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h
@@ -277,6 +277,7 @@
MTRClusterIDTypeBooleanStateID API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000045,
MTRClusterIDTypeModeSelectID API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000050,
MTRClusterIDTypeTemperatureControlID MTR_NEWLY_AVAILABLE = 0x00000056,
+ MTRClusterIDTypeRefrigeratorAlarmID MTR_NEWLY_AVAILABLE = 0x00000057,
MTRClusterIDTypeAirQualityID MTR_NEWLY_AVAILABLE = 0x0000005B,
MTRClusterIDTypeSmokeCOAlarmID MTR_NEWLY_AVAILABLE = 0x0000005C,
MTRClusterIDTypeHEPAFilterMonitoringID MTR_NEWLY_AVAILABLE = 0x00000071,
@@ -3748,6 +3749,23 @@
MTRAttributeIDTypeClusterTemperatureControlAttributeClusterRevisionID MTR_NEWLY_AVAILABLE
= MTRAttributeIDTypeGlobalAttributeClusterRevisionID,
+ // Cluster RefrigeratorAlarm attributes
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeMaskID MTR_NEWLY_AVAILABLE = 0x00000000,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeLatchID MTR_NEWLY_AVAILABLE = 0x00000001,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeStateID MTR_NEWLY_AVAILABLE = 0x00000002,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeGeneratedCommandListID MTR_NEWLY_AVAILABLE
+ = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeAcceptedCommandListID MTR_NEWLY_AVAILABLE
+ = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeEventListID MTR_NEWLY_AVAILABLE
+ = MTRAttributeIDTypeGlobalAttributeEventListID,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeAttributeListID MTR_NEWLY_AVAILABLE
+ = MTRAttributeIDTypeGlobalAttributeAttributeListID,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeFeatureMapID MTR_NEWLY_AVAILABLE
+ = MTRAttributeIDTypeGlobalAttributeFeatureMapID,
+ MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeClusterRevisionID MTR_NEWLY_AVAILABLE
+ = MTRAttributeIDTypeGlobalAttributeClusterRevisionID,
+
// Cluster AirQuality attributes
MTRAttributeIDTypeClusterAirQualityAttributeAirQualityID MTR_NEWLY_AVAILABLE = 0x00000000,
MTRAttributeIDTypeClusterAirQualityAttributeGeneratedCommandListID MTR_NEWLY_AVAILABLE
@@ -9131,6 +9149,9 @@
// Cluster TemperatureControl commands
MTRCommandIDTypeClusterTemperatureControlCommandSetTemperatureID MTR_NEWLY_AVAILABLE = 0x00000000,
+ // Cluster RefrigeratorAlarm commands
+ MTRCommandIDTypeClusterRefrigeratorAlarmCommandResetID MTR_NEWLY_AVAILABLE = 0x00000000,
+
// Cluster SmokeCOAlarm commands
MTRCommandIDTypeClusterSmokeCOAlarmCommandSelfTestRequestID MTR_NEWLY_AVAILABLE = 0x00000000,
@@ -10288,6 +10309,9 @@
MTREventIDTypeClusterBooleanStateEventStateChangeID API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4))
= 0x00000000,
+ // Cluster RefrigeratorAlarm events
+ MTREventIDTypeClusterRefrigeratorAlarmEventNotifyID MTR_NEWLY_AVAILABLE = 0x00000000,
+
// Cluster SmokeCOAlarm events
MTREventIDTypeClusterSmokeCOAlarmEventSmokeAlarmID MTR_NEWLY_AVAILABLE = 0x00000000,
MTREventIDTypeClusterSmokeCOAlarmEventCOAlarmID MTR_NEWLY_AVAILABLE = 0x00000001,
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h
index e6bc0cf..bd0145b 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h
@@ -2842,6 +2842,50 @@
@end
/**
+ * Cluster Refrigerator Alarm
+ * Attributes and commands for configuring the Refrigerator alarm.
+ */
+MTR_NEWLY_AVAILABLE
+@interface MTRClusterRefrigeratorAlarm : MTRCluster
+
+- (instancetype _Nullable)initWithDevice:(MTRDevice *)device
+ endpointID:(NSNumber *)endpointID
+ queue:(dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER MTR_NEWLY_AVAILABLE;
+
+- (void)resetWithParams:(MTRRefrigeratorAlarmClusterResetParams *)params
+ expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedDataValueDictionaries
+ expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs
+ completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeMaskWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+- (void)writeAttributeMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
+ expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_NEWLY_AVAILABLE;
+- (void)writeAttributeMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
+ expectedValueInterval:(NSNumber *)expectedValueIntervalMs
+ params:(MTRWriteParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeLatchWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeStateWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+/**
* Cluster Air Quality
* Attributes for reporting air quality classification
*/
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
index 518e195..940b702 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
@@ -13129,6 +13129,186 @@
@end
+@implementation MTRClusterRefrigeratorAlarm
+
+- (instancetype)initWithDevice:(MTRDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue
+{
+ if (self = [super initWithQueue:queue]) {
+ if (device == nil) {
+ return nil;
+ }
+
+ _endpoint = [endpointID unsignedShortValue];
+ _device = device;
+ }
+ return self;
+}
+
+- (void)resetWithParams:(MTRRefrigeratorAlarmClusterResetParams *)params
+ expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
+ expectedValueInterval:(NSNumber *)expectedValueIntervalMs
+ completion:(MTRStatusCompletion)completion
+{
+ NSString * logPrefix = [NSString stringWithFormat:@"MTRDevice command %u %u %u %u", self.device.deviceController.fabricIndex,
+ _endpoint, (unsigned int) MTRClusterIDTypeRefrigeratorAlarmID,
+ (unsigned int) MTRCommandIDTypeClusterRefrigeratorAlarmCommandResetID];
+ // Make a copy of params before we go async.
+ params = [params copy];
+ NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+ if (timedInvokeTimeoutMsParam) {
+ timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+ }
+ MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.device.queue];
+ MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+ MTRClustersLogDequeue(logPrefix, self.device.asyncCallbackWorkQueue);
+ MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+ controller:self.device.deviceController];
+ auto * bridge = new MTRCommandSuccessCallbackBridge(
+ self.device.queue,
+ ^(id _Nullable value, NSError * _Nullable error) {
+ MTRClustersLogCompletion(logPrefix, value, error);
+ dispatch_async(self.callbackQueue, ^{
+ completion(error);
+ });
+ [workItem endWork];
+ },
+ ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+ MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+ auto * typedBridge = static_cast<MTRCommandSuccessCallbackBridge *>(bridge);
+ Optional<uint16_t> timedInvokeTimeoutMs;
+ Optional<Timeout> invokeTimeout;
+ ListFreer listFreer;
+ RefrigeratorAlarm::Commands::Reset::Type request;
+ if (timedInvokeTimeoutMsParam != nil) {
+ timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+ }
+ if (params != nil) {
+ if (params.serverSideProcessingTimeout != nil) {
+ // Clamp to a number of seconds that will not overflow 32-bit
+ // int when converted to ms.
+ auto * serverSideProcessingTimeout
+ = MTRClampedNumber(params.serverSideProcessingTimeout, @(0), @(UINT16_MAX));
+ invokeTimeout.SetValue(Seconds16(serverSideProcessingTimeout.unsignedShortValue));
+ }
+ }
+ request.alarms = static_cast<std::remove_reference_t<decltype(request.alarms)>>(params.alarms.unsignedIntValue);
+ if (params.mask != nil) {
+ auto & definedValue_0 = request.mask.Emplace();
+ definedValue_0 = static_cast<std::remove_reference_t<decltype(definedValue_0)>>(params.mask.unsignedIntValue);
+ }
+
+ return MTRStartInvokeInteraction(typedBridge, request, exchangeManager, session, successCb, failureCb,
+ self->_endpoint, timedInvokeTimeoutMs, invokeTimeout);
+ });
+ std::move(*bridge).DispatchAction(baseDevice);
+ };
+ workItem.readyHandler = readyHandler;
+ MTRClustersLogEnqueue(logPrefix, self.device.asyncCallbackWorkQueue);
+ [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+ if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+ expectedValues = nil;
+ } else {
+ expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+ }
+ if (expectedValues) {
+ [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+ }
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeMaskWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeMaskID)
+ params:params];
+}
+
+- (void)writeAttributeMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
+ expectedValueInterval:(NSNumber *)expectedValueIntervalMs
+{
+ [self writeAttributeMaskWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
+}
+- (void)writeAttributeMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
+ expectedValueInterval:(NSNumber *)expectedValueIntervalMs
+ params:(MTRWriteParams * _Nullable)params
+{
+ NSNumber * timedWriteTimeout = params.timedWriteTimeout;
+
+ [self.device writeAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeMaskID)
+ value:dataValueDictionary
+ expectedValueInterval:expectedValueIntervalMs
+ timedWriteTimeout:timedWriteTimeout];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeLatchWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeLatchID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeStateWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeStateID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeGeneratedCommandListID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeAcceptedCommandListID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeEventListID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeAttributeListID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeFeatureMapID)
+ params:params];
+}
+
+- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
+{
+ return [self.device readAttributeWithEndpointID:@(_endpoint)
+ clusterID:@(MTRClusterIDTypeRefrigeratorAlarmID)
+ attributeID:@(MTRAttributeIDTypeClusterRefrigeratorAlarmAttributeClusterRevisionID)
+ params:params];
+}
+
+@end
+
@implementation MTRClusterAirQuality
- (instancetype)initWithDevice:(MTRDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h
index f67f51f..e483aa7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h
@@ -206,6 +206,11 @@
@property (nonatomic, readonly) MTRDevice * device;
@end
+@interface MTRClusterRefrigeratorAlarm ()
+@property (nonatomic, readonly) uint16_t endpoint;
+@property (nonatomic, readonly) MTRDevice * device;
+@end
+
@interface MTRClusterAirQuality ()
@property (nonatomic, readonly) uint16_t endpoint;
@property (nonatomic, readonly) MTRDevice * device;
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h
index 342464b..b0f5287 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h
@@ -4110,6 +4110,38 @@
@end
MTR_NEWLY_AVAILABLE
+@interface MTRRefrigeratorAlarmClusterResetParams : NSObject <NSCopying>
+
+@property (nonatomic, copy) NSNumber * _Nonnull alarms MTR_NEWLY_AVAILABLE;
+
+@property (nonatomic, copy) NSNumber * _Nullable mask MTR_NEWLY_AVAILABLE;
+/**
+ * Controls whether the command is a timed command (using Timed Invoke).
+ *
+ * If nil (the default value), a regular invoke is done for commands that do
+ * not require a timed invoke and a timed invoke with some default timed request
+ * timeout is done for commands that require a timed invoke.
+ *
+ * If not nil, a timed invoke is done, with the provided value used as the timed
+ * request timeout. The value should be chosen small enough to provide the
+ * desired security properties but large enough that it will allow a round-trip
+ * from the sever to the client (for the status response and actual invoke
+ * request) within the timeout window.
+ *
+ */
+@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs;
+
+/**
+ * Controls how much time, in seconds, we will allow for the server to process the command.
+ *
+ * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes.
+ *
+ * If nil, the framework will try to select an appropriate timeout value itself.
+ */
+@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout;
+@end
+
+MTR_NEWLY_AVAILABLE
@interface MTRSmokeCOAlarmClusterSelfTestRequestParams : NSObject <NSCopying>
/**
* Controls whether the command is a timed command (using Timed Invoke).
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm
index bd6f116..5e9e298 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm
@@ -6493,6 +6493,40 @@
}
@end
+@implementation MTRRefrigeratorAlarmClusterResetParams
+- (instancetype)init
+{
+ if (self = [super init]) {
+
+ _alarms = @(0);
+
+ _mask = nil;
+ _timedInvokeTimeoutMs = nil;
+ _serverSideProcessingTimeout = nil;
+ }
+ return self;
+}
+
+- (id)copyWithZone:(NSZone * _Nullable)zone;
+{
+ auto other = [[MTRRefrigeratorAlarmClusterResetParams alloc] init];
+
+ other.alarms = self.alarms;
+ other.mask = self.mask;
+ other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs;
+ other.serverSideProcessingTimeout = self.serverSideProcessingTimeout;
+
+ return other;
+}
+
+- (NSString *)description
+{
+ NSString * descriptionString =
+ [NSString stringWithFormat:@"<%@: alarms:%@; mask:%@; >", NSStringFromClass([self class]), _alarms, _mask];
+ return descriptionString;
+}
+
+@end
@implementation MTRSmokeCOAlarmClusterSelfTestRequestParams
- (instancetype)init
{
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm
index f33a6a1..3e1a0cb 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm
@@ -1563,6 +1563,50 @@
*aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
return nil;
}
+static id _Nullable DecodeEventPayloadForRefrigeratorAlarmCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
+{
+ using namespace Clusters::RefrigeratorAlarm;
+ switch (aEventId) {
+ case Events::Notify::Id: {
+ Events::Notify::DecodableType cppValue;
+ *aError = DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR) {
+ return nil;
+ }
+
+ __auto_type * value = [MTRRefrigeratorAlarmClusterNotifyEvent new];
+
+ do {
+ NSNumber * _Nonnull memberValue;
+ memberValue = [NSNumber numberWithUnsignedInt:cppValue.active.Raw()];
+ value.active = memberValue;
+ } while (0);
+ do {
+ NSNumber * _Nonnull memberValue;
+ memberValue = [NSNumber numberWithUnsignedInt:cppValue.inactive.Raw()];
+ value.inactive = memberValue;
+ } while (0);
+ do {
+ NSNumber * _Nonnull memberValue;
+ memberValue = [NSNumber numberWithUnsignedInt:cppValue.state.Raw()];
+ value.state = memberValue;
+ } while (0);
+ do {
+ NSNumber * _Nonnull memberValue;
+ memberValue = [NSNumber numberWithUnsignedInt:cppValue.mask.Raw()];
+ value.mask = memberValue;
+ } while (0);
+
+ return value;
+ }
+ default: {
+ break;
+ }
+ }
+
+ *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB;
+ return nil;
+}
static id _Nullable DecodeEventPayloadForAirQualityCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError)
{
using namespace Clusters::AirQuality;
@@ -2889,6 +2933,9 @@
case Clusters::TemperatureControl::Id: {
return DecodeEventPayloadForTemperatureControlCluster(aPath.mEventId, aReader, aError);
}
+ case Clusters::RefrigeratorAlarm::Id: {
+ return DecodeEventPayloadForRefrigeratorAlarmCluster(aPath.mEventId, aReader, aError);
+ }
case Clusters::AirQuality::Id: {
return DecodeEventPayloadForAirQualityCluster(aPath.mEventId, aReader, aError);
}
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h
index 5f7f262..fa0842d 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h
@@ -686,6 +686,14 @@
@end
MTR_NEWLY_AVAILABLE
+@interface MTRRefrigeratorAlarmClusterNotifyEvent : NSObject <NSCopying>
+@property (nonatomic, copy) NSNumber * _Nonnull active MTR_NEWLY_AVAILABLE;
+@property (nonatomic, copy) NSNumber * _Nonnull inactive MTR_NEWLY_AVAILABLE;
+@property (nonatomic, copy) NSNumber * _Nonnull state MTR_NEWLY_AVAILABLE;
+@property (nonatomic, copy) NSNumber * _Nonnull mask MTR_NEWLY_AVAILABLE;
+@end
+
+MTR_NEWLY_AVAILABLE
@interface MTRSmokeCOAlarmClusterSmokeAlarmEvent : NSObject <NSCopying>
@end
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm
index 8d5e8f7..f34a16a 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm
@@ -2698,6 +2698,43 @@
@end
+@implementation MTRRefrigeratorAlarmClusterNotifyEvent
+- (instancetype)init
+{
+ if (self = [super init]) {
+
+ _active = @(0);
+
+ _inactive = @(0);
+
+ _state = @(0);
+
+ _mask = @(0);
+ }
+ return self;
+}
+
+- (id)copyWithZone:(NSZone * _Nullable)zone
+{
+ auto other = [[MTRRefrigeratorAlarmClusterNotifyEvent alloc] init];
+
+ other.active = self.active;
+ other.inactive = self.inactive;
+ other.state = self.state;
+ other.mask = self.mask;
+
+ return other;
+}
+
+- (NSString *)description
+{
+ NSString * descriptionString = [NSString stringWithFormat:@"<%@: active:%@; inactive:%@; state:%@; mask:%@; >",
+ NSStringFromClass([self class]), _active, _inactive, _state, _mask];
+ return descriptionString;
+}
+
+@end
+
@implementation MTRSmokeCOAlarmClusterSmokeAlarmEvent
- (instancetype)init
{
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
index 79e9553..a84a46b 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
@@ -7433,6 +7433,167 @@
} // namespace Attributes
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+namespace Attributes {
+
+namespace Mask {
+
+EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Mask
+
+namespace Latch {
+
+EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace Latch
+
+namespace State {
+
+EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> * value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value)
+{
+ using Traits = NumericAttributeTraits<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace State
+
+namespace FeatureMap {
+
+EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value)
+{
+ using Traits = NumericAttributeTraits<uint32_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE);
+}
+
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+
+EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ Traits::StorageType temp;
+ uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
+ EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, readable, sizeof(temp));
+ VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status);
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, temp))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ *value = Traits::StorageToWorking(temp);
+ return status;
+}
+EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value)
+{
+ using Traits = NumericAttributeTraits<uint16_t>;
+ if (!Traits::CanRepresentValue(/* isNullable = */ false, value))
+ {
+ return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
+ }
+ Traits::StorageType storageValue;
+ Traits::WorkingToStorage(value, storageValue);
+ uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
+ return emberAfWriteAttribute(endpoint, Clusters::RefrigeratorAlarm::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE);
+}
+
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAlarm
+
namespace AirQuality {
namespace Attributes {
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
index 869e7be..b7d0c6f 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
@@ -1422,6 +1422,37 @@
} // namespace Attributes
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+namespace Attributes {
+
+namespace Mask {
+EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> * value); // AlarmMap
+EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value);
+} // namespace Mask
+
+namespace Latch {
+EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> * value); // AlarmMap
+EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value);
+} // namespace Latch
+
+namespace State {
+EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> * value); // AlarmMap
+EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value);
+} // namespace State
+
+namespace FeatureMap {
+EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32
+EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value);
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u
+EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value);
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAlarm
+
namespace AirQuality {
namespace Attributes {
diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h
index 692af22..0b6e677 100644
--- a/zzz_generated/app-common/app-common/zap-generated/callback.h
+++ b/zzz_generated/app-common/app-common/zap-generated/callback.h
@@ -377,6 +377,14 @@
*/
void emberAfTemperatureControlClusterInitCallback(chip::EndpointId endpoint);
+/** @brief Refrigerator Alarm Cluster Init
+ *
+ * Cluster Init
+ *
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAlarmClusterInitCallback(chip::EndpointId endpoint);
+
/** @brief Air Quality Cluster Init
*
* Cluster Init
@@ -4045,6 +4053,84 @@
void emberAfTemperatureControlClusterClientTickCallback(chip::EndpointId endpoint);
//
+// Refrigerator Alarm Cluster
+//
+
+/** @brief Refrigerator Alarm Cluster Server Init
+ *
+ * Server Init
+ *
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAlarmClusterServerInitCallback(chip::EndpointId endpoint);
+
+/** @brief Refrigerator Alarm Cluster Server Shutdown
+ *
+ * Server Shutdown
+ *
+ * @param endpoint Endpoint that is being shutdown
+ */
+void MatterRefrigeratorAlarmClusterServerShutdownCallback(chip::EndpointId endpoint);
+
+/** @brief Refrigerator Alarm Cluster Client Init
+ *
+ * Client Init
+ *
+ * @param endpoint Endpoint that is being initialized
+ */
+void emberAfRefrigeratorAlarmClusterClientInitCallback(chip::EndpointId endpoint);
+
+/** @brief Refrigerator Alarm Cluster Server Attribute Changed
+ *
+ * Server Attribute Changed
+ *
+ * @param attributePath Concrete attribute path that changed
+ */
+void MatterRefrigeratorAlarmClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath);
+
+/** @brief Refrigerator Alarm Cluster Server Pre Attribute Changed
+ *
+ * Server Pre Attribute Changed
+ *
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterRefrigeratorAlarmClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/** @brief Refrigerator Alarm Cluster Client Pre Attribute Changed
+ *
+ * Client Pre Attribute Changed
+ *
+ * @param attributePath Concrete attribute path to be changed
+ * @param attributeType Attribute type
+ * @param size Attribute size
+ * @param value Attribute value
+ */
+chip::Protocols::InteractionModel::Status
+MatterRefrigeratorAlarmClusterClientPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath,
+ EmberAfAttributeType attributeType, uint16_t size, uint8_t * value);
+
+/** @brief Refrigerator Alarm Cluster Server Tick
+ *
+ * Server Tick
+ *
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRefrigeratorAlarmClusterServerTickCallback(chip::EndpointId endpoint);
+
+/** @brief Refrigerator Alarm Cluster Client Tick
+ *
+ * Client Tick
+ *
+ * @param endpoint Endpoint that is being served
+ */
+void emberAfRefrigeratorAlarmClusterClientTickCallback(chip::EndpointId endpoint);
+
+//
// Air Quality Cluster
//
@@ -7941,6 +8027,12 @@
chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
const chip::app::Clusters::TemperatureControl::Commands::SetTemperature::DecodableType & commandData);
/**
+ * @brief Refrigerator Alarm Cluster Reset Command callback (from client)
+ */
+bool emberAfRefrigeratorAlarmClusterResetCallback(
+ chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
+ const chip::app::Clusters::RefrigeratorAlarm::Commands::Reset::DecodableType & commandData);
+/**
* @brief Smoke CO Alarm Cluster SelfTestRequest Command callback (from client)
*/
bool emberAfSmokeCoAlarmClusterSelfTestRequestCallback(
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 671ba9a..d35c549 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
@@ -1514,6 +1514,15 @@
};
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+
+// Bitmap for AlarmMap
+enum class AlarmMap : uint32_t
+{
+ kDoorOpen = 0x1,
+};
+} // namespace RefrigeratorAlarm
+
namespace AirQuality {
// Enum for AirQualityEnum
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 a027ea9..dcb8139 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
@@ -11568,6 +11568,145 @@
namespace Events {} // namespace Events
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+
+namespace Commands {
+namespace Reset {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kAlarms), alarms));
+ ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kMask), mask));
+ ReturnErrorOnFailure(writer.EndContainer(outer));
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ TLV::TLVType outer;
+ VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+ ReturnErrorOnFailure(reader.EnterContainer(outer));
+ while ((err = reader.Next()) == CHIP_NO_ERROR)
+ {
+ if (!TLV::IsContextTag(reader.GetTag()))
+ {
+ continue;
+ }
+ switch (TLV::TagNumFromTag(reader.GetTag()))
+ {
+ case to_underlying(Fields::kAlarms):
+ ReturnErrorOnFailure(DataModel::Decode(reader, alarms));
+ break;
+ case to_underlying(Fields::kMask):
+ ReturnErrorOnFailure(DataModel::Decode(reader, mask));
+ break;
+ default:
+ break;
+ }
+ }
+
+ VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+ ReturnErrorOnFailure(reader.ExitContainer(outer));
+ return CHIP_NO_ERROR;
+}
+} // namespace Reset.
+} // namespace Commands
+
+namespace Attributes {
+CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
+{
+ switch (path.mAttributeId)
+ {
+ case Attributes::Mask::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, mask));
+ break;
+ case Attributes::Latch::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, latch));
+ break;
+ case Attributes::State::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, state));
+ break;
+ case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, generatedCommandList));
+ break;
+ case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, acceptedCommandList));
+ break;
+ case Attributes::EventList::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, eventList));
+ break;
+ case Attributes::AttributeList::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, attributeList));
+ break;
+ case Attributes::FeatureMap::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, featureMap));
+ break;
+ case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
+ ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision));
+ break;
+ default:
+ break;
+ }
+
+ return CHIP_NO_ERROR;
+}
+} // namespace Attributes
+
+namespace Events {
+namespace Notify {
+CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const
+{
+ TLV::TLVType outer;
+ ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer));
+ ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kActive), active));
+ ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kInactive), inactive));
+ ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kState), state));
+ ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kMask), mask));
+ ReturnErrorOnFailure(writer.EndContainer(outer));
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
+{
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ TLV::TLVType outer;
+ VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
+ ReturnErrorOnFailure(reader.EnterContainer(outer));
+ while ((err = reader.Next()) == CHIP_NO_ERROR)
+ {
+ if (!TLV::IsContextTag(reader.GetTag()))
+ {
+ continue;
+ }
+ switch (TLV::TagNumFromTag(reader.GetTag()))
+ {
+ case to_underlying(Fields::kActive):
+ ReturnErrorOnFailure(DataModel::Decode(reader, active));
+ break;
+ case to_underlying(Fields::kInactive):
+ ReturnErrorOnFailure(DataModel::Decode(reader, inactive));
+ break;
+ case to_underlying(Fields::kState):
+ ReturnErrorOnFailure(DataModel::Decode(reader, state));
+ break;
+ case to_underlying(Fields::kMask):
+ ReturnErrorOnFailure(DataModel::Decode(reader, mask));
+ break;
+ default:
+ break;
+ }
+ }
+
+ VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+ ReturnErrorOnFailure(reader.ExitContainer(outer));
+ return CHIP_NO_ERROR;
+}
+} // namespace Notify.
+} // namespace Events
+
+} // namespace RefrigeratorAlarm
namespace AirQuality {
namespace Commands {} // namespace Commands
@@ -23992,6 +24131,13 @@
return false;
}
}
+ case Clusters::RefrigeratorAlarm::Id: {
+ switch (aCommand)
+ {
+ default:
+ return false;
+ }
+ }
case Clusters::SmokeCoAlarm::Id: {
switch (aCommand)
{
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 f63f82c..30d3eb2 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
@@ -14426,6 +14426,199 @@
};
} // namespace Attributes
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+
+namespace Commands {
+// Forward-declarations so we can reference these later.
+
+namespace Reset {
+struct Type;
+struct DecodableType;
+} // namespace Reset
+
+} // namespace Commands
+
+namespace Commands {
+namespace Reset {
+enum class Fields : uint8_t
+{
+ kAlarms = 0,
+ kMask = 1,
+};
+
+struct Type
+{
+public:
+ // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
+ static constexpr CommandId GetCommandId() { return Commands::Reset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+
+ chip::BitMask<AlarmMap> alarms = static_cast<chip::BitMask<AlarmMap>>(0);
+ Optional<chip::BitMask<AlarmMap>> mask;
+
+ CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+
+ using ResponseType = DataModel::NullObjectType;
+
+ static constexpr bool MustUseTimedInvoke() { return false; }
+};
+
+struct DecodableType
+{
+public:
+ static constexpr CommandId GetCommandId() { return Commands::Reset::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+
+ chip::BitMask<AlarmMap> alarms = static_cast<chip::BitMask<AlarmMap>>(0);
+ Optional<chip::BitMask<AlarmMap>> mask;
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+}; // namespace Reset
+} // namespace Commands
+
+namespace Attributes {
+
+namespace Mask {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Mask::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Mask
+namespace Latch {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::Latch::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace Latch
+namespace State {
+struct TypeInfo
+{
+ using Type = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+ using DecodableType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+ using DecodableArgType = chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>;
+
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; }
+ static constexpr bool MustUseTimedWrite() { return false; }
+};
+} // namespace State
+namespace GeneratedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace GeneratedCommandList
+namespace AcceptedCommandList {
+struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace AcceptedCommandList
+namespace EventList {
+struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace EventList
+namespace AttributeList {
+struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace AttributeList
+namespace FeatureMap {
+struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace FeatureMap
+namespace ClusterRevision {
+struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
+{
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+};
+} // namespace ClusterRevision
+
+struct TypeInfo
+{
+ struct DecodableType
+ {
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
+
+ Attributes::Mask::TypeInfo::DecodableType mask =
+ static_cast<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>(0);
+ Attributes::Latch::TypeInfo::DecodableType latch =
+ static_cast<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>(0);
+ Attributes::State::TypeInfo::DecodableType state =
+ static_cast<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>(0);
+ Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
+ Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
+ Attributes::EventList::TypeInfo::DecodableType eventList;
+ Attributes::AttributeList::TypeInfo::DecodableType attributeList;
+ Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
+ Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
+ };
+};
+} // namespace Attributes
+namespace Events {
+namespace Notify {
+static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info;
+
+enum class Fields : uint8_t
+{
+ kActive = 0,
+ kInactive = 1,
+ kState = 2,
+ kMask = 3,
+};
+
+struct Type
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Notify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+ static constexpr bool kIsFabricScoped = false;
+
+ chip::BitMask<AlarmMap> active = static_cast<chip::BitMask<AlarmMap>>(0);
+ chip::BitMask<AlarmMap> inactive = static_cast<chip::BitMask<AlarmMap>>(0);
+ chip::BitMask<AlarmMap> state = static_cast<chip::BitMask<AlarmMap>>(0);
+ chip::BitMask<AlarmMap> mask = static_cast<chip::BitMask<AlarmMap>>(0);
+
+ CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const;
+};
+
+struct DecodableType
+{
+public:
+ static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; }
+ static constexpr EventId GetEventId() { return Events::Notify::Id; }
+ static constexpr ClusterId GetClusterId() { return Clusters::RefrigeratorAlarm::Id; }
+
+ chip::BitMask<AlarmMap> active = static_cast<chip::BitMask<AlarmMap>>(0);
+ chip::BitMask<AlarmMap> inactive = static_cast<chip::BitMask<AlarmMap>>(0);
+ chip::BitMask<AlarmMap> state = static_cast<chip::BitMask<AlarmMap>>(0);
+ chip::BitMask<AlarmMap> mask = static_cast<chip::BitMask<AlarmMap>>(0);
+
+ CHIP_ERROR Decode(TLV::TLVReader & reader);
+};
+} // namespace Notify
+} // namespace Events
+} // namespace RefrigeratorAlarm
namespace AirQuality {
namespace Attributes {
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
index 8435a59..d4e77a9 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
@@ -2513,6 +2513,48 @@
} // namespace Attributes
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+namespace Attributes {
+
+namespace Mask {
+static constexpr AttributeId Id = 0x00000000;
+} // namespace Mask
+
+namespace Latch {
+static constexpr AttributeId Id = 0x00000001;
+} // namespace Latch
+
+namespace State {
+static constexpr AttributeId Id = 0x00000002;
+} // namespace State
+
+namespace GeneratedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id;
+} // namespace GeneratedCommandList
+
+namespace AcceptedCommandList {
+static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id;
+} // namespace AcceptedCommandList
+
+namespace EventList {
+static constexpr AttributeId Id = Globals::Attributes::EventList::Id;
+} // namespace EventList
+
+namespace AttributeList {
+static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id;
+} // namespace AttributeList
+
+namespace FeatureMap {
+static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id;
+} // namespace FeatureMap
+
+namespace ClusterRevision {
+static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id;
+} // namespace ClusterRevision
+
+} // namespace Attributes
+} // namespace RefrigeratorAlarm
+
namespace AirQuality {
namespace Attributes {
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
index 7f82d99..ba75dc4 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h
@@ -154,6 +154,9 @@
namespace TemperatureControl {
static constexpr ClusterId Id = 0x00000056;
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+static constexpr ClusterId Id = 0x00000057;
+} // namespace RefrigeratorAlarm
namespace AirQuality {
static constexpr ClusterId Id = 0x0000005B;
} // namespace AirQuality
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
index 3b616e0..9470493 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h
@@ -651,6 +651,16 @@
} // namespace Commands
} // namespace TemperatureControl
+namespace RefrigeratorAlarm {
+namespace Commands {
+
+namespace Reset {
+static constexpr CommandId Id = 0x00000000;
+} // namespace Reset
+
+} // namespace Commands
+} // namespace RefrigeratorAlarm
+
namespace SmokeCoAlarm {
namespace Commands {
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 523d92c..91ec9c2 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
@@ -267,6 +267,16 @@
} // namespace Events
} // namespace BooleanState
+namespace RefrigeratorAlarm {
+namespace Events {
+
+namespace Notify {
+static constexpr EventId Id = 0x00000000;
+} // namespace Notify
+
+} // namespace Events
+} // namespace RefrigeratorAlarm
+
namespace SmokeCoAlarm {
namespace Events {
diff --git a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h
index f043609..6807688 100644
--- a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h
+++ b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h
@@ -298,6 +298,12 @@
#define CHIP_PRINTCLUSTER_TEMPERATURE_CONTROL_CLUSTER
#endif
+#if defined(ZCL_USING_REFRIGERATOR_ALARM_SERVER) || defined(ZCL_USING_REFRIGERATOR_ALARM_CLIENT)
+#define CHIP_PRINTCLUSTER_REFRIGERATOR_ALARM { chip::app::Clusters::RefrigeratorAlarm::Id, "Refrigerator Alarm" },
+#else
+#define CHIP_PRINTCLUSTER_REFRIGERATOR_ALARM
+#endif
+
#if defined(ZCL_USING_AIR_QUALITY_CLUSTER_SERVER) || defined(ZCL_USING_AIR_QUALITY_CLUSTER_CLIENT)
#define CHIP_PRINTCLUSTER_AIR_QUALITY_CLUSTER { chip::app::Clusters::AirQuality::Id, "Air Quality" },
#else
@@ -626,6 +632,7 @@
CHIP_PRINTCLUSTER_ICD_MANAGEMENT_CLUSTER \
CHIP_PRINTCLUSTER_MODE_SELECT_CLUSTER \
CHIP_PRINTCLUSTER_TEMPERATURE_CONTROL_CLUSTER \
+ CHIP_PRINTCLUSTER_REFRIGERATOR_ALARM \
CHIP_PRINTCLUSTER_AIR_QUALITY_CLUSTER \
CHIP_PRINTCLUSTER_SMOKE_CO_ALARM_CLUSTER \
CHIP_PRINTCLUSTER_HEPA_FILTER_MONITORING_CLUSTER \
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
index d9f38d3..fe957b6 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
@@ -75,6 +75,7 @@
| IcdManagement | 0x0046 |
| ModeSelect | 0x0050 |
| TemperatureControl | 0x0056 |
+| RefrigeratorAlarm | 0x0057 |
| AirQuality | 0x005B |
| SmokeCoAlarm | 0x005C |
| HepaFilterMonitoring | 0x0071 |
@@ -4094,6 +4095,58 @@
};
/*----------------------------------------------------------------------------*\
+| Cluster RefrigeratorAlarm | 0x0057 |
+|------------------------------------------------------------------------------|
+| Commands: | |
+| * Reset | 0x00 |
+|------------------------------------------------------------------------------|
+| Attributes: | |
+| * Mask | 0x0000 |
+| * Latch | 0x0001 |
+| * State | 0x0002 |
+| * GeneratedCommandList | 0xFFF8 |
+| * AcceptedCommandList | 0xFFF9 |
+| * EventList | 0xFFFA |
+| * AttributeList | 0xFFFB |
+| * FeatureMap | 0xFFFC |
+| * ClusterRevision | 0xFFFD |
+|------------------------------------------------------------------------------|
+| Events: | |
+| * Notify | 0x0000 |
+\*----------------------------------------------------------------------------*/
+
+/*
+ * Command Reset
+ */
+class RefrigeratorAlarmReset : public ClusterCommand
+{
+public:
+ RefrigeratorAlarmReset(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("reset", credsIssuerConfig)
+ {
+ AddArgument("Alarms", 0, UINT32_MAX, &mRequest.alarms);
+ AddArgument("Mask", 0, UINT32_MAX, &mRequest.mask);
+ ClusterCommand::AddArguments();
+ }
+
+ CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) command (0x00000000) on endpoint %u", endpointIds.at(0));
+
+ return ClusterCommand::SendCommand(device, endpointIds.at(0), 0x00000057, 0x00000000, mRequest);
+ }
+
+ CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) command (0x00000000) on Group %u", groupId);
+
+ return ClusterCommand::SendGroupCommand(groupId, fabricIndex, 0x00000057, 0x00000000, mRequest);
+ }
+
+private:
+ chip::app::Clusters::RefrigeratorAlarm::Commands::Reset::Type mRequest;
+};
+
+/*----------------------------------------------------------------------------*\
| Cluster AirQuality | 0x005B |
|------------------------------------------------------------------------------|
| Commands: | |
@@ -13061,6 +13114,72 @@
commands.Register(clusterName, clusterCommands);
}
+void registerClusterRefrigeratorAlarm(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
+{
+ using namespace chip::app::Clusters::RefrigeratorAlarm;
+
+ const char * clusterName = "RefrigeratorAlarm";
+
+ commands_list clusterCommands = {
+ //
+ // Commands
+ //
+ make_unique<ClusterCommand>(Id, credsIssuerConfig), //
+ make_unique<RefrigeratorAlarmReset>(credsIssuerConfig), //
+ //
+ // Attributes
+ //
+ make_unique<ReadAttribute>(Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "mask", Attributes::Mask::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "latch", Attributes::Latch::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
+ make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
+ make_unique<WriteAttribute<>>(Id, credsIssuerConfig), //
+ make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>>(
+ Id, "mask", 0, UINT32_MAX, Attributes::Mask::Id, WriteCommandType::kWrite, credsIssuerConfig), //
+ make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>>(
+ Id, "latch", 0, UINT32_MAX, Attributes::Latch::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap>>>(
+ Id, "state", 0, UINT32_MAX, Attributes::State::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
+ Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
+ credsIssuerConfig), //
+ make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
+ Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
+ Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
+ Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
+ WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
+ WriteCommandType::kForceWrite, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "mask", Attributes::Mask::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "latch", Attributes::Latch::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
+ make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
+ //
+ // Events
+ //
+ make_unique<ReadEvent>(Id, credsIssuerConfig), //
+ make_unique<ReadEvent>(Id, "notify", Events::Notify::Id, credsIssuerConfig), //
+ make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
+ make_unique<SubscribeEvent>(Id, "notify", Events::Notify::Id, credsIssuerConfig), //
+ };
+
+ commands.Register(clusterName, clusterCommands);
+}
void registerClusterAirQuality(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::AirQuality;
@@ -18256,6 +18375,7 @@
registerClusterIcdManagement(commands, credsIssuerConfig);
registerClusterModeSelect(commands, credsIssuerConfig);
registerClusterTemperatureControl(commands, credsIssuerConfig);
+ registerClusterRefrigeratorAlarm(commands, credsIssuerConfig);
registerClusterAirQuality(commands, credsIssuerConfig);
registerClusterSmokeCoAlarm(commands, credsIssuerConfig);
registerClusterHepaFilterMonitoring(commands, credsIssuerConfig);
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 cc89135..bce6c44 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp
+++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp
@@ -3548,6 +3548,46 @@
return CHIP_NO_ERROR;
}
CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent,
+ const RefrigeratorAlarm::Events::Notify::DecodableType & value)
+{
+ DataModelLogger::LogString(label, indent, "{");
+ {
+ CHIP_ERROR err = DataModelLogger::LogValue("Active", indent + 1, value.active);
+ if (err != CHIP_NO_ERROR)
+ {
+ DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Active'");
+ return err;
+ }
+ }
+ {
+ CHIP_ERROR err = DataModelLogger::LogValue("Inactive", indent + 1, value.inactive);
+ if (err != CHIP_NO_ERROR)
+ {
+ DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Inactive'");
+ return err;
+ }
+ }
+ {
+ CHIP_ERROR err = DataModelLogger::LogValue("State", indent + 1, value.state);
+ if (err != CHIP_NO_ERROR)
+ {
+ DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'State'");
+ return err;
+ }
+ }
+ {
+ CHIP_ERROR err = DataModelLogger::LogValue("Mask", indent + 1, value.mask);
+ if (err != CHIP_NO_ERROR)
+ {
+ DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Mask'");
+ return err;
+ }
+ }
+ DataModelLogger::LogString(indent, "}");
+
+ return CHIP_NO_ERROR;
+}
+CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent,
const SmokeCoAlarm::Events::SmokeAlarm::DecodableType & value)
{
DataModelLogger::LogString(label, indent, "{");
@@ -7711,6 +7751,57 @@
}
break;
}
+ case RefrigeratorAlarm::Id: {
+ switch (path.mAttributeId)
+ {
+ case RefrigeratorAlarm::Attributes::Mask::Id: {
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("Mask", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::Latch::Id: {
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("Latch", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::State::Id: {
+ chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmMap> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("State", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::GeneratedCommandList::Id: {
+ chip::app::DataModel::DecodableList<chip::CommandId> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("GeneratedCommandList", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::AcceptedCommandList::Id: {
+ chip::app::DataModel::DecodableList<chip::CommandId> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("AcceptedCommandList", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::EventList::Id: {
+ chip::app::DataModel::DecodableList<chip::EventId> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("EventList", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::AttributeList::Id: {
+ chip::app::DataModel::DecodableList<chip::AttributeId> value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("AttributeList", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::FeatureMap::Id: {
+ uint32_t value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("FeatureMap", 1, value);
+ }
+ case RefrigeratorAlarm::Attributes::ClusterRevision::Id: {
+ uint16_t value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("ClusterRevision", 1, value);
+ }
+ }
+ break;
+ }
case AirQuality::Id: {
switch (path.mAttributeId)
{
@@ -12839,6 +12930,17 @@
}
break;
}
+ case RefrigeratorAlarm::Id: {
+ switch (header.mPath.mEventId)
+ {
+ case RefrigeratorAlarm::Events::Notify::Id: {
+ chip::app::Clusters::RefrigeratorAlarm::Events::Notify::DecodableType value;
+ ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+ return DataModelLogger::LogValue("Notify", 1, value);
+ }
+ }
+ break;
+ }
case SmokeCoAlarm::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 64346cd..753b6f8 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h
@@ -305,6 +305,8 @@
static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::BooleanState::Events::StateChange::DecodableType & value);
static CHIP_ERROR LogValue(const char * label, size_t indent,
+ const chip::app::Clusters::RefrigeratorAlarm::Events::Notify::DecodableType & value);
+static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::SmokeCoAlarm::Events::SmokeAlarm::DecodableType & value);
static CHIP_ERROR LogValue(const char * label, size_t indent,
const chip::app::Clusters::SmokeCoAlarm::Events::COAlarm::DecodableType & value);
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 520ff16..a7411f0 100644
--- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h
@@ -78,6 +78,7 @@
| IcdManagement | 0x0046 |
| ModeSelect | 0x0050 |
| TemperatureControl | 0x0056 |
+| RefrigeratorAlarm | 0x0057 |
| AirQuality | 0x005B |
| SmokeCoAlarm | 0x005C |
| HepaFilterMonitoring | 0x0071 |
@@ -41364,6 +41365,749 @@
};
/*----------------------------------------------------------------------------*\
+| Cluster RefrigeratorAlarm | 0x0057 |
+|------------------------------------------------------------------------------|
+| Commands: | |
+| * Reset | 0x00 |
+|------------------------------------------------------------------------------|
+| Attributes: | |
+| * Mask | 0x0000 |
+| * Latch | 0x0001 |
+| * State | 0x0002 |
+| * GeneratedCommandList | 0xFFF8 |
+| * AcceptedCommandList | 0xFFF9 |
+| * EventList | 0xFFFA |
+| * AttributeList | 0xFFFB |
+| * FeatureMap | 0xFFFC |
+| * ClusterRevision | 0xFFFD |
+|------------------------------------------------------------------------------|
+| Events: | |
+| * Notify | 0x0000 |
+\*----------------------------------------------------------------------------*/
+
+/*
+ * Command Reset
+ */
+class RefrigeratorAlarmReset : public ClusterCommand {
+public:
+ RefrigeratorAlarmReset()
+ : ClusterCommand("reset")
+ {
+ AddArgument("Alarms", 0, UINT32_MAX, &mRequest.alarms);
+ AddArgument("Mask", 0, UINT32_MAX, &mRequest.mask);
+ ClusterCommand::AddArguments();
+ }
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) command (0x00000000) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRRefrigeratorAlarmClusterResetParams alloc] init];
+ params.timedInvokeTimeoutMs
+ = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil;
+ params.alarms = [NSNumber numberWithUnsignedInt:mRequest.alarms.Raw()];
+ if (mRequest.mask.HasValue()) {
+ params.mask = [NSNumber numberWithUnsignedInt:mRequest.mask.Value().Raw()];
+ } else {
+ params.mask = nil;
+ }
+ uint16_t repeatCount = mRepeatCount.ValueOr(1);
+ uint16_t __block responsesNeeded = repeatCount;
+ while (repeatCount--) {
+ [cluster resetWithParams:params
+ completion:^(NSError * _Nullable error) {
+ responsesNeeded--;
+ if (error != nil) {
+ mError = error;
+ LogNSError("Error", error);
+ }
+ if (responsesNeeded == 0) {
+ SetCommandExitStatus(mError);
+ }
+ }];
+ }
+ return CHIP_NO_ERROR;
+ }
+
+private:
+ chip::app::Clusters::RefrigeratorAlarm::Commands::Reset::Type mRequest;
+};
+
+/*
+ * Attribute Mask
+ */
+class ReadRefrigeratorAlarmMask : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmMask()
+ : ReadAttribute("mask")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmMask() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x00000000) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeMaskWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.Mask response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm Mask read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class WriteRefrigeratorAlarmMask : public WriteAttribute {
+public:
+ WriteRefrigeratorAlarmMask()
+ : WriteAttribute("mask")
+ {
+ AddArgument("attr-name", "mask");
+ AddArgument("attr-value", 0, UINT32_MAX, &mValue);
+ WriteAttribute::AddArguments();
+ }
+
+ ~WriteRefrigeratorAlarmMask() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) WriteAttribute (0x00000000) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRWriteParams alloc] init];
+ params.timedWriteTimeout
+ = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil;
+ params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil;
+ NSNumber * _Nonnull value = [NSNumber numberWithUnsignedInt:mValue];
+
+ [cluster writeAttributeMaskWithValue:value
+ params:params
+ completion:^(NSError * _Nullable error) {
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm Mask write Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+
+private:
+ uint32_t mValue;
+};
+
+class SubscribeAttributeRefrigeratorAlarmMask : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmMask()
+ : SubscribeAttribute("mask")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmMask() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x00000000) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeMaskWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.Mask response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute Latch
+ */
+class ReadRefrigeratorAlarmLatch : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmLatch()
+ : ReadAttribute("latch")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmLatch() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x00000001) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeLatchWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.Latch response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm Latch read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmLatch : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmLatch()
+ : SubscribeAttribute("latch")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmLatch() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x00000001) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeLatchWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.Latch response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute State
+ */
+class ReadRefrigeratorAlarmState : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmState()
+ : ReadAttribute("state")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmState() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x00000002) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeStateWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.State response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm State read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmState : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmState()
+ : SubscribeAttribute("state")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmState() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x00000002) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeStateWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.State response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute GeneratedCommandList
+ */
+class ReadRefrigeratorAlarmGeneratedCommandList : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmGeneratedCommandList()
+ : ReadAttribute("generated-command-list")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmGeneratedCommandList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x0000FFF8) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.GeneratedCommandList response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm GeneratedCommandList read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmGeneratedCommandList : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmGeneratedCommandList()
+ : SubscribeAttribute("generated-command-list")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmGeneratedCommandList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x0000FFF8) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeGeneratedCommandListWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.GeneratedCommandList response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute AcceptedCommandList
+ */
+class ReadRefrigeratorAlarmAcceptedCommandList : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmAcceptedCommandList()
+ : ReadAttribute("accepted-command-list")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmAcceptedCommandList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x0000FFF9) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.AcceptedCommandList response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm AcceptedCommandList read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmAcceptedCommandList : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmAcceptedCommandList()
+ : SubscribeAttribute("accepted-command-list")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmAcceptedCommandList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x0000FFF9) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeAcceptedCommandListWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.AcceptedCommandList response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute EventList
+ */
+class ReadRefrigeratorAlarmEventList : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmEventList()
+ : ReadAttribute("event-list")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmEventList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x0000FFFA) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.EventList response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm EventList read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmEventList : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmEventList()
+ : SubscribeAttribute("event-list")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmEventList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x0000FFFA) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeEventListWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.EventList response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute AttributeList
+ */
+class ReadRefrigeratorAlarmAttributeList : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmAttributeList()
+ : ReadAttribute("attribute-list")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmAttributeList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x0000FFFB) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.AttributeList response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm AttributeList read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmAttributeList : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmAttributeList()
+ : SubscribeAttribute("attribute-list")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmAttributeList() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x0000FFFB) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeAttributeListWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.AttributeList response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute FeatureMap
+ */
+class ReadRefrigeratorAlarmFeatureMap : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmFeatureMap()
+ : ReadAttribute("feature-map")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmFeatureMap() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x0000FFFC) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.FeatureMap response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm FeatureMap read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmFeatureMap : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmFeatureMap()
+ : SubscribeAttribute("feature-map")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmFeatureMap() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x0000FFFC) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeFeatureMapWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.FeatureMap response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*
+ * Attribute ClusterRevision
+ */
+class ReadRefrigeratorAlarmClusterRevision : public ReadAttribute {
+public:
+ ReadRefrigeratorAlarmClusterRevision()
+ : ReadAttribute("cluster-revision")
+ {
+ }
+
+ ~ReadRefrigeratorAlarmClusterRevision() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReadAttribute (0x0000FFFD) on endpoint %u", endpointId);
+
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.ClusterRevision response %@", [value description]);
+ if (error != nil) {
+ LogNSError("RefrigeratorAlarm ClusterRevision read Error", error);
+ }
+ SetCommandExitStatus(error);
+ }];
+ return CHIP_NO_ERROR;
+ }
+};
+
+class SubscribeAttributeRefrigeratorAlarmClusterRevision : public SubscribeAttribute {
+public:
+ SubscribeAttributeRefrigeratorAlarmClusterRevision()
+ : SubscribeAttribute("cluster-revision")
+ {
+ }
+
+ ~SubscribeAttributeRefrigeratorAlarmClusterRevision() {}
+
+ CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x00000057) ReportAttribute (0x0000FFFD) on endpoint %u", endpointId);
+ dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL);
+ __auto_type * cluster = [[MTRBaseClusterRefrigeratorAlarm alloc] initWithDevice:device
+ endpointID:@(endpointId)
+ queue:callbackQueue];
+ __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)];
+ if (mKeepSubscriptions.HasValue()) {
+ params.replaceExistingSubscriptions = !mKeepSubscriptions.Value();
+ }
+ if (mFabricFiltered.HasValue()) {
+ params.filterByFabric = mFabricFiltered.Value();
+ }
+ if (mAutoResubscribe.HasValue()) {
+ params.resubscribeAutomatically = mAutoResubscribe.Value();
+ }
+ [cluster subscribeAttributeClusterRevisionWithParams:params
+ subscriptionEstablished:^() {
+ mSubscriptionEstablished = YES;
+ }
+ reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) {
+ NSLog(@"RefrigeratorAlarm.ClusterRevision response %@", [value description]);
+ SetCommandExitStatus(error);
+ }];
+
+ return CHIP_NO_ERROR;
+ }
+};
+
+/*----------------------------------------------------------------------------*\
| Cluster AirQuality | 0x005B |
|------------------------------------------------------------------------------|
| Commands: | |
@@ -115908,6 +116652,43 @@
commands.Register(clusterName, clusterCommands);
}
+void registerClusterRefrigeratorAlarm(Commands & commands)
+{
+ using namespace chip::app::Clusters::RefrigeratorAlarm;
+
+ const char * clusterName = "RefrigeratorAlarm";
+
+ commands_list clusterCommands = {
+ make_unique<ClusterCommand>(Id), //
+ make_unique<RefrigeratorAlarmReset>(), //
+ make_unique<ReadAttribute>(Id), //
+ make_unique<ReadRefrigeratorAlarmMask>(), //
+ make_unique<WriteAttribute>(Id), //
+ make_unique<WriteRefrigeratorAlarmMask>(), //
+ make_unique<SubscribeAttribute>(Id), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmMask>(), //
+ make_unique<ReadRefrigeratorAlarmLatch>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmLatch>(), //
+ make_unique<ReadRefrigeratorAlarmState>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmState>(), //
+ make_unique<ReadRefrigeratorAlarmGeneratedCommandList>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmGeneratedCommandList>(), //
+ make_unique<ReadRefrigeratorAlarmAcceptedCommandList>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmAcceptedCommandList>(), //
+ make_unique<ReadRefrigeratorAlarmEventList>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmEventList>(), //
+ make_unique<ReadRefrigeratorAlarmAttributeList>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmAttributeList>(), //
+ make_unique<ReadRefrigeratorAlarmFeatureMap>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmFeatureMap>(), //
+ make_unique<ReadRefrigeratorAlarmClusterRevision>(), //
+ make_unique<SubscribeAttributeRefrigeratorAlarmClusterRevision>(), //
+ make_unique<ReadEvent>(Id), //
+ make_unique<SubscribeEvent>(Id), //
+ };
+
+ commands.Register(clusterName, clusterCommands);
+}
void registerClusterAirQuality(Commands & commands)
{
using namespace chip::app::Clusters::AirQuality;
@@ -118560,6 +119341,7 @@
registerClusterBooleanState(commands);
registerClusterModeSelect(commands);
registerClusterTemperatureControl(commands);
+ registerClusterRefrigeratorAlarm(commands);
registerClusterAirQuality(commands);
registerClusterSmokeCoAlarm(commands);
registerClusterHepaFilterMonitoring(commands);
diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h
index 01c4640..3da35cb 100644
--- a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h
+++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h
@@ -427,6 +427,14 @@
const chip::app::DataModel::DecodableList<chip::EventId> & data);
typedef void (*ModeSelectAttributeListListAttributeCallback)(void * context,
const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
+typedef void (*RefrigeratorAlarmGeneratedCommandListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
+typedef void (*RefrigeratorAlarmAcceptedCommandListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
+typedef void (*RefrigeratorAlarmEventListListAttributeCallback)(void * context,
+ const chip::app::DataModel::DecodableList<chip::EventId> & data);
+typedef void (*RefrigeratorAlarmAttributeListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*AirQualityGeneratedCommandListListAttributeCallback)(
void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AirQualityAcceptedCommandListListAttributeCallback)(
diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h
index db17098..3397e83 100644
--- a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h
+++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h
@@ -375,6 +375,15 @@
~ModeSelectCluster() {}
};
+class DLL_EXPORT RefrigeratorAlarmCluster : public ClusterBase
+{
+public:
+ RefrigeratorAlarmCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) :
+ ClusterBase(exchangeManager, session, endpoint)
+ {}
+ ~RefrigeratorAlarmCluster() {}
+};
+
class DLL_EXPORT AirQualityCluster : public ClusterBase
{
public:
diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h
index 345ab29..c71929f 100644
--- a/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h
+++ b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h
@@ -59,7 +59,7 @@
#define GENERATED_FUNCTION_ARRAYS
// This is an array of EmberAfCluster structures.
-#define GENERATED_CLUSTER_COUNT 80
+#define GENERATED_CLUSTER_COUNT 81
// clang-format off
#define GENERATED_CLUSTERS { \
{ \
@@ -544,6 +544,19 @@
.eventCount = 0, \
},\
{ \
+ /* Endpoint: 1, Cluster: Refrigerator Alarm (client) */ \
+ .clusterId = 0x00000057, \
+ .attributes = ZAP_ATTRIBUTE_INDEX(0), \
+ .attributeCount = 0, \
+ .clusterSize = 0, \
+ .mask = ZAP_CLUSTER_MASK(CLIENT), \
+ .functions = NULL, \
+ .acceptedCommandList = nullptr, \
+ .generatedCommandList = nullptr, \
+ .eventList = nullptr, \
+ .eventCount = 0, \
+ },\
+ { \
/* Endpoint: 1, Cluster: Air Quality (client) */ \
.clusterId = 0x0000005B, \
.attributes = ZAP_ATTRIBUTE_INDEX(0), \
@@ -1111,7 +1124,7 @@
// This is an array of EmberAfEndpointType structures.
#define GENERATED_ENDPOINT_TYPES \
{ \
- { ZAP_CLUSTER_INDEX(0), 80, 0 }, \
+ { ZAP_CLUSTER_INDEX(0), 81, 0 }, \
}
// Largest attribute size is needed for various buffers
diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h
index a7f94ba..7a1fca8 100644
--- a/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h
+++ b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h
@@ -58,6 +58,7 @@
#define EMBER_AF_BOOLEAN_STATE_CLUSTER_CLIENT_ENDPOINT_COUNT (1)
#define EMBER_AF_ICD_MANAGEMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1)
#define EMBER_AF_MODE_SELECT_CLUSTER_CLIENT_ENDPOINT_COUNT (1)
+#define EMBER_AF_REFRIGERATOR_ALARM_CLIENT_ENDPOINT_COUNT (1)
#define EMBER_AF_AIR_QUALITY_CLUSTER_CLIENT_ENDPOINT_COUNT (1)
#define EMBER_AF_SMOKE_CO_ALARM_CLUSTER_CLIENT_ENDPOINT_COUNT (1)
#define EMBER_AF_HEPA_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1)
@@ -252,6 +253,10 @@
#define ZCL_USING_MODE_SELECT_CLUSTER_CLIENT
#define EMBER_AF_PLUGIN_MODE_SELECT_CLIENT
+// Use this macro to check if the client side of the Refrigerator Alarm cluster is included
+#define ZCL_USING_REFRIGERATOR_ALARM_CLIENT
+#define EMBER_AF_PLUGIN_REFRIGERATOR_ALARM_CLIENT
+
// Use this macro to check if the client side of the Air Quality cluster is included
#define ZCL_USING_AIR_QUALITY_CLUSTER_CLIENT
#define EMBER_AF_PLUGIN_AIR_QUALITY_CLIENT
