diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index a1a1d4914c0111..82132cdedaccdb 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -2179,6 +2179,64 @@ server cluster OperationalCredentials = 62 { } server cluster PowerSource = 47 { + enum BatChargeFaultType : ENUM8 { + kUnspecfied = 0; + kAmbientTooHot = 1; + kAmbientTooCold = 2; + kBatteryTooHot = 3; + kBatteryTooCold = 4; + kBatteryAbsent = 5; + kBatteryOverVoltage = 6; + kBatteryUnderVoltage = 7; + kChargerOverVoltage = 8; + kChargerUnderVoltage = 9; + kSafetyTimeout = 10; + } + + enum BatChargeLevel : ENUM8 { + kOk = 0; + kWarning = 1; + kCritical = 2; + } + + enum BatChargeState : ENUM8 { + kUnknown = 0; + kIsCharging = 1; + kIsAtFullCharge = 2; + kIsNotCharging = 3; + } + + enum BatFaultType : ENUM8 { + kUnspecfied = 0; + kOverTemp = 1; + kUnderTemp = 2; + } + + enum BatReplaceability : ENUM8 { + kUnspecified = 0; + kNotReplaceable = 1; + kUserReplaceable = 2; + kFactoryReplaceable = 3; + } + + enum PowerSourceStatus : ENUM8 { + kUnspecfied = 0; + kActive = 1; + kStandby = 2; + kUnavailable = 3; + } + + enum WiredCurrentType : ENUM8 { + kAc = 0; + kDc = 1; + } + + enum WiredFaultType : ENUM8 { + kUnspecfied = 0; + kOverVoltage = 1; + kUnderVoltage = 2; + } + readonly attribute enum8 status = 0; readonly attribute int8u order = 1; readonly attribute char_string<60> description = 2; diff --git a/examples/door-lock-app/door-lock-common/door-lock-app.matter b/examples/door-lock-app/door-lock-common/door-lock-app.matter index ef93f7d527baaa..07cf64dea9adea 100644 --- a/examples/door-lock-app/door-lock-common/door-lock-app.matter +++ b/examples/door-lock-app/door-lock-common/door-lock-app.matter @@ -869,6 +869,64 @@ server cluster OperationalCredentials = 62 { } server cluster PowerSource = 47 { + enum BatChargeFaultType : ENUM8 { + kUnspecfied = 0; + kAmbientTooHot = 1; + kAmbientTooCold = 2; + kBatteryTooHot = 3; + kBatteryTooCold = 4; + kBatteryAbsent = 5; + kBatteryOverVoltage = 6; + kBatteryUnderVoltage = 7; + kChargerOverVoltage = 8; + kChargerUnderVoltage = 9; + kSafetyTimeout = 10; + } + + enum BatChargeLevel : ENUM8 { + kOk = 0; + kWarning = 1; + kCritical = 2; + } + + enum BatChargeState : ENUM8 { + kUnknown = 0; + kIsCharging = 1; + kIsAtFullCharge = 2; + kIsNotCharging = 3; + } + + enum BatFaultType : ENUM8 { + kUnspecfied = 0; + kOverTemp = 1; + kUnderTemp = 2; + } + + enum BatReplaceability : ENUM8 { + kUnspecified = 0; + kNotReplaceable = 1; + kUserReplaceable = 2; + kFactoryReplaceable = 3; + } + + enum PowerSourceStatus : ENUM8 { + kUnspecfied = 0; + kActive = 1; + kStandby = 2; + kUnavailable = 3; + } + + enum WiredCurrentType : ENUM8 { + kAc = 0; + kDc = 1; + } + + enum WiredFaultType : ENUM8 { + kUnspecfied = 0; + kOverVoltage = 1; + kUnderVoltage = 2; + } + readonly attribute enum8 status = 0; readonly attribute int8u order = 1; readonly attribute char_string<60> description = 2; diff --git a/examples/lock-app/lock-common/lock-app.matter b/examples/lock-app/lock-common/lock-app.matter index d8432bb6335368..d885506c81fec8 100644 --- a/examples/lock-app/lock-common/lock-app.matter +++ b/examples/lock-app/lock-common/lock-app.matter @@ -565,6 +565,64 @@ server cluster OperationalCredentials = 62 { } server cluster PowerSource = 47 { + enum BatChargeFaultType : ENUM8 { + kUnspecfied = 0; + kAmbientTooHot = 1; + kAmbientTooCold = 2; + kBatteryTooHot = 3; + kBatteryTooCold = 4; + kBatteryAbsent = 5; + kBatteryOverVoltage = 6; + kBatteryUnderVoltage = 7; + kChargerOverVoltage = 8; + kChargerUnderVoltage = 9; + kSafetyTimeout = 10; + } + + enum BatChargeLevel : ENUM8 { + kOk = 0; + kWarning = 1; + kCritical = 2; + } + + enum BatChargeState : ENUM8 { + kUnknown = 0; + kIsCharging = 1; + kIsAtFullCharge = 2; + kIsNotCharging = 3; + } + + enum BatFaultType : ENUM8 { + kUnspecfied = 0; + kOverTemp = 1; + kUnderTemp = 2; + } + + enum BatReplaceability : ENUM8 { + kUnspecified = 0; + kNotReplaceable = 1; + kUserReplaceable = 2; + kFactoryReplaceable = 3; + } + + enum PowerSourceStatus : ENUM8 { + kUnspecfied = 0; + kActive = 1; + kStandby = 2; + kUnavailable = 3; + } + + enum WiredCurrentType : ENUM8 { + kAc = 0; + kDc = 1; + } + + enum WiredFaultType : ENUM8 { + kUnspecfied = 0; + kOverVoltage = 1; + kUnderVoltage = 2; + } + readonly attribute enum8 status = 0; readonly attribute int8u order = 1; readonly attribute char_string<60> description = 2; diff --git a/examples/window-app/common/window-app.matter b/examples/window-app/common/window-app.matter index 49e636136033c2..1eb01c312a264d 100644 --- a/examples/window-app/common/window-app.matter +++ b/examples/window-app/common/window-app.matter @@ -551,6 +551,64 @@ server cluster OperationalCredentials = 62 { } server cluster PowerSource = 47 { + enum BatChargeFaultType : ENUM8 { + kUnspecfied = 0; + kAmbientTooHot = 1; + kAmbientTooCold = 2; + kBatteryTooHot = 3; + kBatteryTooCold = 4; + kBatteryAbsent = 5; + kBatteryOverVoltage = 6; + kBatteryUnderVoltage = 7; + kChargerOverVoltage = 8; + kChargerUnderVoltage = 9; + kSafetyTimeout = 10; + } + + enum BatChargeLevel : ENUM8 { + kOk = 0; + kWarning = 1; + kCritical = 2; + } + + enum BatChargeState : ENUM8 { + kUnknown = 0; + kIsCharging = 1; + kIsAtFullCharge = 2; + kIsNotCharging = 3; + } + + enum BatFaultType : ENUM8 { + kUnspecfied = 0; + kOverTemp = 1; + kUnderTemp = 2; + } + + enum BatReplaceability : ENUM8 { + kUnspecified = 0; + kNotReplaceable = 1; + kUserReplaceable = 2; + kFactoryReplaceable = 3; + } + + enum PowerSourceStatus : ENUM8 { + kUnspecfied = 0; + kActive = 1; + kStandby = 2; + kUnavailable = 3; + } + + enum WiredCurrentType : ENUM8 { + kAc = 0; + kDc = 1; + } + + enum WiredFaultType : ENUM8 { + kUnspecfied = 0; + kOverVoltage = 1; + kUnderVoltage = 2; + } + readonly attribute enum8 status = 0; readonly attribute int8u order = 1; readonly attribute char_string<60> description = 2; diff --git a/src/app/zap-templates/zcl/data-model/chip/power-source-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/power-source-cluster.xml index cc31b480ad0ee8..c3540b2bbb8d6c 100644 --- a/src/app/zap-templates/zcl/data-model/chip/power-source-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/power-source-cluster.xml @@ -83,7 +83,7 @@ limitations under the License. - + @@ -91,18 +91,21 @@ limitations under the License. + + + @@ -117,6 +120,7 @@ limitations under the License. + @@ -124,17 +128,20 @@ limitations under the License. + + + @@ -142,6 +149,7 @@ limitations under the License. + @@ -149,16 +157,19 @@ limitations under the License. + + + diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index 04ca0d00c4f6f8..2dadba8401a2e1 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -2402,6 +2402,64 @@ client cluster OperationalCredentials = 62 { } client cluster PowerSource = 47 { + enum BatChargeFaultType : ENUM8 { + kUnspecfied = 0; + kAmbientTooHot = 1; + kAmbientTooCold = 2; + kBatteryTooHot = 3; + kBatteryTooCold = 4; + kBatteryAbsent = 5; + kBatteryOverVoltage = 6; + kBatteryUnderVoltage = 7; + kChargerOverVoltage = 8; + kChargerUnderVoltage = 9; + kSafetyTimeout = 10; + } + + enum BatChargeLevel : ENUM8 { + kOk = 0; + kWarning = 1; + kCritical = 2; + } + + enum BatChargeState : ENUM8 { + kUnknown = 0; + kIsCharging = 1; + kIsAtFullCharge = 2; + kIsNotCharging = 3; + } + + enum BatFaultType : ENUM8 { + kUnspecfied = 0; + kOverTemp = 1; + kUnderTemp = 2; + } + + enum BatReplaceability : ENUM8 { + kUnspecified = 0; + kNotReplaceable = 1; + kUserReplaceable = 2; + kFactoryReplaceable = 3; + } + + enum PowerSourceStatus : ENUM8 { + kUnspecfied = 0; + kActive = 1; + kStandby = 2; + kUnavailable = 3; + } + + enum WiredCurrentType : ENUM8 { + kAc = 0; + kDc = 1; + } + + enum WiredFaultType : ENUM8 { + kUnspecfied = 0; + kOverVoltage = 1; + kUnderVoltage = 2; + } + readonly attribute enum8 status = 0; readonly attribute int8u order = 1; readonly attribute char_string<60> description = 2; diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 396e8e05d63f61..d0070debbd91c8 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -1201,6 +1201,81 @@ public String toString() { } } + public static class PowerSourceClusterBatChargeFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatChargeFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterWiredFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterWiredFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterWiredFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + public static class ScenesClusterSceneExtensionFieldSet { public Long clusterId; public Integer length; diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 6c0fff9c47a3ac..22d68dfa971c0e 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -7460,6 +7460,98 @@ def descriptor(cls) -> ClusterObjectDescriptor: featureMap: 'typing.Optional[uint]' = None clusterRevision: 'uint' = None + class Enums: + class BatChargeFaultType(IntEnum): + kUnspecfied = 0x00 + kAmbientTooHot = 0x01 + kAmbientTooCold = 0x02 + kBatteryTooHot = 0x03 + kBatteryTooCold = 0x04 + kBatteryAbsent = 0x05 + kBatteryOverVoltage = 0x06 + kBatteryUnderVoltage = 0x07 + kChargerOverVoltage = 0x08 + kChargerUnderVoltage = 0x09 + kSafetyTimeout = 0x0A + + class BatChargeLevel(IntEnum): + kOk = 0x00 + kWarning = 0x01 + kCritical = 0x02 + + class BatChargeState(IntEnum): + kUnknown = 0x00 + kIsCharging = 0x01 + kIsAtFullCharge = 0x02 + kIsNotCharging = 0x03 + + class BatFaultType(IntEnum): + kUnspecfied = 0x00 + kOverTemp = 0x01 + kUnderTemp = 0x02 + + class BatReplaceability(IntEnum): + kUnspecified = 0x00 + kNotReplaceable = 0x01 + kUserReplaceable = 0x02 + kFactoryReplaceable = 0x03 + + class PowerSourceStatus(IntEnum): + kUnspecfied = 0x00 + kActive = 0x01 + kStandby = 0x02 + kUnavailable = 0x03 + + class WiredCurrentType(IntEnum): + kAc = 0x00 + kDc = 0x01 + + class WiredFaultType(IntEnum): + kUnspecfied = 0x00 + kOverVoltage = 0x01 + kUnderVoltage = 0x02 + + + class Structs: + @dataclass + class BatChargeFaultChangeType(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields = [ + ClusterObjectFieldDescriptor(Label="current", Tag=0, Type=typing.List[PowerSource.Enums.BatChargeFaultType]), + ClusterObjectFieldDescriptor(Label="previous", Tag=1, Type=typing.List[PowerSource.Enums.BatChargeFaultType]), + ]) + + current: 'typing.List[PowerSource.Enums.BatChargeFaultType]' = field(default_factory=lambda: []) + previous: 'typing.List[PowerSource.Enums.BatChargeFaultType]' = field(default_factory=lambda: []) + + @dataclass + class BatFaultChangeType(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields = [ + ClusterObjectFieldDescriptor(Label="current", Tag=0, Type=typing.List[PowerSource.Enums.BatFaultType]), + ClusterObjectFieldDescriptor(Label="previous", Tag=1, Type=typing.List[PowerSource.Enums.BatFaultType]), + ]) + + current: 'typing.List[PowerSource.Enums.BatFaultType]' = field(default_factory=lambda: []) + previous: 'typing.List[PowerSource.Enums.BatFaultType]' = field(default_factory=lambda: []) + + @dataclass + class WiredFaultChangeType(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields = [ + ClusterObjectFieldDescriptor(Label="current", Tag=0, Type=typing.List[PowerSource.Enums.WiredFaultType]), + ClusterObjectFieldDescriptor(Label="previous", Tag=1, Type=typing.List[PowerSource.Enums.WiredFaultType]), + ]) + + current: 'typing.List[PowerSource.Enums.WiredFaultType]' = field(default_factory=lambda: []) + previous: 'typing.List[PowerSource.Enums.WiredFaultType]' = field(default_factory=lambda: []) + diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm index ccdd11d4dd2bd7..39a9ecf6dd9ad0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm @@ -7564,6 +7564,422 @@ } } +void CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::BatChargeFaultType value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterBatChargeLevelAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::BatChargeLevel value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterBatChargeStateAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::BatChargeState value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterBatFaultTypeAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::BatFaultType value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterBatFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::BatReplaceability value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::PowerSourceStatus value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::WiredCurrentType value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackBridge::OnSuccessFn( + void * context, chip::app::Clusters::PowerSource::WiredFaultType value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value)]; + DispatchSuccess(context, objCValue); +}; + +void CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralCommissioning::GeneralCommissioningError value) { diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h index 4d76ebf66a53a3..795c8ce06e5a74 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h @@ -215,6 +215,30 @@ typedef void (*TimeFormatLocalizationClusterHourFormatAttributeCallback)(void *, chip::app::Clusters::TimeFormatLocalization::HourFormat); typedef void (*NullableTimeFormatLocalizationClusterHourFormatAttributeCallback)( void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterBatChargeFaultTypeAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatChargeFaultType); +typedef void (*NullablePowerSourceClusterBatChargeFaultTypeAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterBatChargeLevelAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatChargeLevel); +typedef void (*NullablePowerSourceClusterBatChargeLevelAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterBatChargeStateAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatChargeState); +typedef void (*NullablePowerSourceClusterBatChargeStateAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterBatFaultTypeAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatFaultType); +typedef void (*NullablePowerSourceClusterBatFaultTypeAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterBatReplaceabilityAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatReplaceability); +typedef void (*NullablePowerSourceClusterBatReplaceabilityAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterPowerSourceStatusAttributeCallback)(void *, chip::app::Clusters::PowerSource::PowerSourceStatus); +typedef void (*NullablePowerSourceClusterPowerSourceStatusAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterWiredCurrentTypeAttributeCallback)(void *, chip::app::Clusters::PowerSource::WiredCurrentType); +typedef void (*NullablePowerSourceClusterWiredCurrentTypeAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); +typedef void (*PowerSourceClusterWiredFaultTypeAttributeCallback)(void *, chip::app::Clusters::PowerSource::WiredFaultType); +typedef void (*NullablePowerSourceClusterWiredFaultTypeAttributeCallback)( + void *, const chip::app::DataModel::Nullable &); typedef void (*GeneralCommissioningClusterGeneralCommissioningErrorAttributeCallback)( void *, chip::app::Clusters::GeneralCommissioning::GeneralCommissioningError); typedef void (*NullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallback)( @@ -6312,6 +6336,470 @@ class CHIPNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscr SubscriptionEstablishedHandler mEstablishedHandler; }; +class CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeFaultType value); +}; + +class CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterBatChargeFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterBatChargeLevelAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeLevel value); +}; + +class CHIPPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterBatChargeLevelAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterBatChargeStateAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeState value); +}; + +class CHIPPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterBatChargeStateAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterBatFaultTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterBatFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatFaultType value); +}; + +class CHIPPowerSourceClusterBatFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterBatFaultTypeAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterBatFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterBatFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterBatFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatReplaceability value); +}; + +class CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::PowerSourceStatus value); +}; + +class CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::WiredCurrentType value); +}; + +class CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::WiredFaultType value); +}; + +class CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackBridge +{ +public: + CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceClusterWiredFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + +class CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackBridge +{ +public: + CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePowerSourceClusterWiredFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge : public CHIPCallbackBridge { diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h index 91023e1cb7bf5a..a46455eaac30ed 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h @@ -108,6 +108,24 @@ NS_ASSUME_NONNULL_BEGIN - (instancetype)init; @end +@interface CHIPPowerSourceClusterBatChargeFaultChangeType : NSObject +@property (strong, nonatomic) NSArray * _Nonnull current; +@property (strong, nonatomic) NSArray * _Nonnull previous; +- (instancetype)init; +@end + +@interface CHIPPowerSourceClusterBatFaultChangeType : NSObject +@property (strong, nonatomic) NSArray * _Nonnull current; +@property (strong, nonatomic) NSArray * _Nonnull previous; +- (instancetype)init; +@end + +@interface CHIPPowerSourceClusterWiredFaultChangeType : NSObject +@property (strong, nonatomic) NSArray * _Nonnull current; +@property (strong, nonatomic) NSArray * _Nonnull previous; +- (instancetype)init; +@end + @interface CHIPGeneralCommissioningClusterBasicCommissioningInfoType : NSObject @property (strong, nonatomic) NSNumber * _Nonnull failSafeExpiryLengthMs; - (instancetype)init; diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm index 8da9ea4990687b..767f0085dffde8 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm @@ -200,6 +200,45 @@ - (instancetype)init } @end +@implementation CHIPPowerSourceClusterBatChargeFaultChangeType +- (instancetype)init +{ + if (self = [super init]) { + + _current = [NSArray array]; + + _previous = [NSArray array]; + } + return self; +} +@end + +@implementation CHIPPowerSourceClusterBatFaultChangeType +- (instancetype)init +{ + if (self = [super init]) { + + _current = [NSArray array]; + + _previous = [NSArray array]; + } + return self; +} +@end + +@implementation CHIPPowerSourceClusterWiredFaultChangeType +- (instancetype)init +{ + if (self = [super init]) { + + _current = [NSArray array]; + + _previous = [NSArray array]; + } + return self; +} +@end + @implementation CHIPGeneralCommissioningClusterBasicCommissioningInfoType - (instancetype)init { 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 22d2bbb5dd0fff..73d94ad3c47021 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 @@ -6571,6 +6571,128 @@ namespace Events { } // namespace PowerSourceConfiguration namespace PowerSource { +namespace Structs { +namespace BatChargeFaultChangeType { +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(to_underlying(Fields::kCurrent)), current)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPrevious)), previous)); + 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); + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG); + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kCurrent): + ReturnErrorOnFailure(DataModel::Decode(reader, current)); + break; + case to_underlying(Fields::kPrevious): + ReturnErrorOnFailure(DataModel::Decode(reader, previous)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace BatChargeFaultChangeType +namespace BatFaultChangeType { +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(to_underlying(Fields::kCurrent)), current)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPrevious)), previous)); + 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); + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG); + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kCurrent): + ReturnErrorOnFailure(DataModel::Decode(reader, current)); + break; + case to_underlying(Fields::kPrevious): + ReturnErrorOnFailure(DataModel::Decode(reader, previous)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace BatFaultChangeType +namespace WiredFaultChangeType { +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(to_underlying(Fields::kCurrent)), current)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kPrevious)), previous)); + 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); + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG); + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kCurrent): + ReturnErrorOnFailure(DataModel::Decode(reader, current)); + break; + case to_underlying(Fields::kPrevious): + ReturnErrorOnFailure(DataModel::Decode(reader, previous)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace WiredFaultChangeType +} // namespace Structs namespace Commands { } // namespace Commands 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 7e1870e4c09cab..e17c22abebc4d6 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 @@ -9224,6 +9224,72 @@ struct TypeInfo } // namespace Attributes } // namespace PowerSourceConfiguration namespace PowerSource { +// Enum for BatChargeFaultType +enum class BatChargeFaultType : uint8_t +{ + kUnspecfied = 0x00, + kAmbientTooHot = 0x01, + kAmbientTooCold = 0x02, + kBatteryTooHot = 0x03, + kBatteryTooCold = 0x04, + kBatteryAbsent = 0x05, + kBatteryOverVoltage = 0x06, + kBatteryUnderVoltage = 0x07, + kChargerOverVoltage = 0x08, + kChargerUnderVoltage = 0x09, + kSafetyTimeout = 0x0A, +}; +// Enum for BatChargeLevel +enum class BatChargeLevel : uint8_t +{ + kOk = 0x00, + kWarning = 0x01, + kCritical = 0x02, +}; +// Enum for BatChargeState +enum class BatChargeState : uint8_t +{ + kUnknown = 0x00, + kIsCharging = 0x01, + kIsAtFullCharge = 0x02, + kIsNotCharging = 0x03, +}; +// Enum for BatFaultType +enum class BatFaultType : uint8_t +{ + kUnspecfied = 0x00, + kOverTemp = 0x01, + kUnderTemp = 0x02, +}; +// Enum for BatReplaceability +enum class BatReplaceability : uint8_t +{ + kUnspecified = 0x00, + kNotReplaceable = 0x01, + kUserReplaceable = 0x02, + kFactoryReplaceable = 0x03, +}; +// Enum for PowerSourceStatus +enum class PowerSourceStatus : uint8_t +{ + kUnspecfied = 0x00, + kActive = 0x01, + kStandby = 0x02, + kUnavailable = 0x03, +}; +// Enum for WiredCurrentType +enum class WiredCurrentType : uint8_t +{ + kAc = 0x00, + kDc = 0x01, +}; +// Enum for WiredFaultType +enum class WiredFaultType : uint8_t +{ + kUnspecfied = 0x00, + kOverVoltage = 0x01, + kUnderVoltage = 0x02, +}; // Bitmap for PowerSourceFeature enum class PowerSourceFeature : uint32_t @@ -9234,6 +9300,84 @@ enum class PowerSourceFeature : uint32_t kReplaceable = 0x8, }; +namespace Structs { +namespace BatChargeFaultChangeType { +enum class Fields +{ + kCurrent = 0, + kPrevious = 1, +}; + +struct Type +{ +public: + DataModel::List current; + DataModel::List previous; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; +}; + +struct DecodableType +{ +public: + DataModel::DecodableList current; + DataModel::DecodableList previous; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace BatChargeFaultChangeType +namespace BatFaultChangeType { +enum class Fields +{ + kCurrent = 0, + kPrevious = 1, +}; + +struct Type +{ +public: + DataModel::List current; + DataModel::List previous; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; +}; + +struct DecodableType +{ +public: + DataModel::DecodableList current; + DataModel::DecodableList previous; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace BatFaultChangeType +namespace WiredFaultChangeType { +enum class Fields +{ + kCurrent = 0, + kPrevious = 1, +}; + +struct Type +{ +public: + DataModel::List current; + DataModel::List previous; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; +}; + +struct DecodableType +{ +public: + DataModel::DecodableList current; + DataModel::DecodableList previous; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace WiredFaultChangeType +} // namespace Structs + namespace Attributes { namespace Status { 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 6e8754bb9fa069..08f99c4cd3a510 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -239,6 +239,55 @@ CHIP_ERROR DataModelLogger::LogValue( return CHIP_NO_ERROR; } CHIP_ERROR +DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::PowerSource::Structs::BatChargeFaultChangeType::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("Current", indent + 1, value.current); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Current'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Previous", indent + 1, value.previous); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Previous'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::PowerSource::Structs::BatFaultChangeType::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("Current", indent + 1, value.current); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Current'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Previous", indent + 1, value.previous); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Previous'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::DecodableType & value) { @@ -2242,6 +2291,30 @@ DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::PowerSource::Structs::WiredFaultChangeType::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("Current", indent + 1, value.current); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Current'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Previous", indent + 1, value.previous); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Previous'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, 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 4682c2ccb52f9c..4a089241056f9c 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -34,6 +34,10 @@ LogValue(const char * label, size_t indent, static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfoType::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::PowerSource::Structs::BatChargeFaultChangeType::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::PowerSource::Structs::BatFaultChangeType::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, @@ -131,6 +135,8 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::NetworkCommissioning::Structs::WiFiInterfaceScanResult::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::PowerSource::Structs::WiredFaultChangeType::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::AccessControl::Events::AccessControlEntryChanged::DecodableType & value);