diff --git a/src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml index 3ee77549dae7dd..d93f1f47dadc0e 100644 --- a/src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml @@ -17,39 +17,74 @@ limitations under the License. + + + + + + + + + + + + + + - - - - - + + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -58,7 +93,7 @@ limitations under the License. - + @@ -68,42 +103,81 @@ limitations under the License. TIME_SYNCHRONIZATION_CLUSTER true true - Accurate time is required for a number of reasons, including scheduling, display and validating -security materials. + Accurate time is required for a number of reasons, including scheduling, display and validating security materials. UTCTime Granularity TimeSource - - TrustedTimeNodeId - - - - - DefaultNtp - - - - - TimeZone - - - - - DSTOffset - - - - LocalTime - TimeZoneDatabase - NtpServerPort - - - - Upon receipt of this command, the server MAY update its UTCTime Attribute to match the time specified in the command - - - - + TrustedTimeSource + DefaultNTP + TimeZone + DSTOffset + LocalTime + TimeZoneDatabase + NTPServerAvailable + TimeZoneListMaxSize + DSTOffsetListMaxSize + SupportsDNSResolve + + + This command MAY be issued by Administrator to set the time. + + + + + + + + This command SHALL set TrustedTimeSource. + + + + + + This command SHALL set TimeZone. + + + + + + Response to SetTimeZone. + + + + + This command SHALL set DSTOffset. + + + + + + This command is used to set DefaultNTP. + + + + + + This event SHALL be generated when the server stops applying the current DSTOffset and there are no entries in the list with a larger ValidStarting time. + + + + This event SHALL be generated when the server starts or stops applying a DST offset. + + + + + This event SHALL be generated when the server changes its time zone offset or name. + + + + + + This event SHALL be generated if the node has attempted to update its time, but was unable to find a good time from any source. + + + + This event SHALL be generated if the node attempts to update its time and finds that the TrustedTimeSource is null, or the specified peer cannot be reached. + + 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 8399e4a3dfe139..04d2ded871b659 100644 --- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json +++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json @@ -275,7 +275,15 @@ "Channel": ["Lineup", "CurrentChannel"], "Media Playback": ["SampledPosition"], "Application Launcher": ["CurrentApp"], - "Application Basic": ["Application"] + "Application Basic": ["Application"], + "Time Synchronization": [ + "TrustedTimeSource", + "DefaultNTP", + "TimeZone", + "DSTOffset", + "UTCTime", + "LocalTime" + ] }, "defaultReportingPolicy": "mandatory", "ZCLDataTypes": ["ARRAY", "BITMAP", "ENUM", "NUMBER", "STRING", "STRUCT"], diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json index f63ef856fce8ac..e59bac13b6f81a 100644 --- a/src/app/zap-templates/zcl/zcl.json +++ b/src/app/zap-templates/zcl/zcl.json @@ -273,7 +273,15 @@ "Channel": ["Lineup", "CurrentChannel"], "Media Playback": ["SampledPosition"], "Application Launcher": ["CurrentApp"], - "Application Basic": ["Application"] + "Application Basic": ["Application"], + "Time Synchronization": [ + "TrustedTimeSource", + "DefaultNTP", + "TimeZone", + "DSTOffset", + "UTCTime", + "LocalTime" + ] }, "defaultReportingPolicy": "mandatory", "ZCLDataTypes": ["ARRAY", "BITMAP", "ENUM", "NUMBER", "STRING", "STRUCT"], diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index fba181de8c0289..d85ce20a52b52c 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -11035,13 +11035,16 @@ def descriptor(cls) -> ClusterObjectDescriptor: ClusterObjectFieldDescriptor(Label="UTCTime", Tag=0x00000000, Type=typing.Union[Nullable, uint]), ClusterObjectFieldDescriptor(Label="granularity", Tag=0x00000001, Type=TimeSynchronization.Enums.GranularityEnum), ClusterObjectFieldDescriptor(Label="timeSource", Tag=0x00000002, Type=typing.Optional[TimeSynchronization.Enums.TimeSourceEnum]), - ClusterObjectFieldDescriptor(Label="trustedTimeNodeId", Tag=0x00000003, Type=typing.Union[Nullable, uint]), - ClusterObjectFieldDescriptor(Label="defaultNtp", Tag=0x00000004, Type=typing.Union[None, Nullable, str]), + ClusterObjectFieldDescriptor(Label="trustedTimeSource", Tag=0x00000003, Type=typing.Union[None, Nullable, TimeSynchronization.Structs.TrustedTimeSourceStruct]), + ClusterObjectFieldDescriptor(Label="defaultNTP", Tag=0x00000004, Type=typing.Union[None, Nullable, str]), ClusterObjectFieldDescriptor(Label="timeZone", Tag=0x00000005, Type=typing.Optional[typing.List[TimeSynchronization.Structs.TimeZoneStruct]]), ClusterObjectFieldDescriptor(Label="DSTOffset", Tag=0x00000006, Type=typing.Optional[typing.List[TimeSynchronization.Structs.DSTOffsetStruct]]), ClusterObjectFieldDescriptor(Label="localTime", Tag=0x00000007, Type=typing.Union[None, Nullable, uint]), - ClusterObjectFieldDescriptor(Label="timeZoneDatabase", Tag=0x00000008, Type=typing.Optional[bool]), - ClusterObjectFieldDescriptor(Label="ntpServerPort", Tag=0x00000009, Type=typing.Union[None, Nullable, uint]), + ClusterObjectFieldDescriptor(Label="timeZoneDatabase", Tag=0x00000008, Type=typing.Optional[TimeSynchronization.Enums.TimeZoneDatabaseEnum]), + ClusterObjectFieldDescriptor(Label="NTPServerAvailable", Tag=0x00000009, Type=typing.Optional[bool]), + ClusterObjectFieldDescriptor(Label="timeZoneListMaxSize", Tag=0x0000000A, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="DSTOffsetListMaxSize", Tag=0x0000000B, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="supportsDNSResolve", Tag=0x0000000C, Type=typing.Optional[bool]), 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]), @@ -11053,13 +11056,16 @@ def descriptor(cls) -> ClusterObjectDescriptor: UTCTime: 'typing.Union[Nullable, uint]' = None granularity: 'TimeSynchronization.Enums.GranularityEnum' = None timeSource: 'typing.Optional[TimeSynchronization.Enums.TimeSourceEnum]' = None - trustedTimeNodeId: 'typing.Union[Nullable, uint]' = None - defaultNtp: 'typing.Union[None, Nullable, str]' = None + trustedTimeSource: 'typing.Union[None, Nullable, TimeSynchronization.Structs.TrustedTimeSourceStruct]' = None + defaultNTP: 'typing.Union[None, Nullable, str]' = None timeZone: 'typing.Optional[typing.List[TimeSynchronization.Structs.TimeZoneStruct]]' = None DSTOffset: 'typing.Optional[typing.List[TimeSynchronization.Structs.DSTOffsetStruct]]' = None localTime: 'typing.Union[None, Nullable, uint]' = None - timeZoneDatabase: 'typing.Optional[bool]' = None - ntpServerPort: 'typing.Union[None, Nullable, uint]' = None + timeZoneDatabase: 'typing.Optional[TimeSynchronization.Enums.TimeZoneDatabaseEnum]' = None + NTPServerAvailable: 'typing.Optional[bool]' = None + timeZoneListMaxSize: 'typing.Optional[uint]' = None + DSTOffsetListMaxSize: 'typing.Optional[uint]' = None + supportsDNSResolve: 'typing.Optional[bool]' = None generatedCommandList: 'typing.List[uint]' = None acceptedCommandList: 'typing.List[uint]' = None eventList: 'typing.List[uint]' = None @@ -11080,21 +11086,29 @@ class GranularityEnum(MatterIntEnum): # enum value. This specific should never be transmitted. kUnknownEnumValue = 5, + class StatusCode(MatterIntEnum): + kTimeNotAccepted = 0x02 + # All received enum values that are not listed above will be mapped + # to kUnknownEnumValue. This is a helper enum value that should only + # be used by code to process how it handles receiving and unknown + # enum value. This specific should never be transmitted. + kUnknownEnumValue = 0, + class TimeSourceEnum(MatterIntEnum): kNone = 0x00 kUnknown = 0x01 kAdmin = 0x02 kNodeTimeCluster = 0x03 - kNonFabricSntp = 0x04 - kNonFabricNtp = 0x05 - kFabricSntp = 0x06 - kFabricNtp = 0x07 - kMixedNtp = 0x08 - kNonFabricSntpNts = 0x09 - kNonFabricNtpNts = 0x0A - kFabricSntpNts = 0x0B - kFabricNtpNts = 0x0C - kMixedNtpNts = 0x0D + kNonMatterSNTP = 0x04 + kNonMatterNTP = 0x05 + kMatterSNTP = 0x06 + kMatterNTP = 0x07 + kMixedNTP = 0x08 + kNonMatterSNTPNTS = 0x09 + kNonMatterNTPNTS = 0x0A + kMatterSNTPNTS = 0x0B + kMatterNTPNTS = 0x0C + kMixedNTPNTS = 0x0D kCloudSource = 0x0E kPtp = 0x0F kGnss = 0x10 @@ -11104,6 +11118,23 @@ class TimeSourceEnum(MatterIntEnum): # enum value. This specific should never be transmitted. kUnknownEnumValue = 17, + class TimeZoneDatabaseEnum(MatterIntEnum): + kFull = 0x00 + kPartial = 0x01 + kNone = 0x02 + # All received enum values that are not listed above will be mapped + # to kUnknownEnumValue. This is a helper enum value that should only + # be used by code to process how it handles receiving and unknown + # enum value. This specific should never be transmitted. + kUnknownEnumValue = 3, + + class Bitmaps: + class TimeSynchronizationFeature(IntFlag): + kTimeZone = 0x1 + kNTPClient = 0x2 + kNTPServer = 0x4 + kTimeSyncClient = 0x8 + class Structs: @dataclass class DSTOffsetStruct(ClusterObject): @@ -11113,12 +11144,25 @@ def descriptor(cls) -> ClusterObjectDescriptor: Fields=[ ClusterObjectFieldDescriptor(Label="offset", Tag=0, Type=int), ClusterObjectFieldDescriptor(Label="validStarting", Tag=1, Type=uint), - ClusterObjectFieldDescriptor(Label="validUntil", Tag=2, Type=uint), + ClusterObjectFieldDescriptor(Label="validUntil", Tag=2, Type=typing.Union[Nullable, uint]), ]) offset: 'int' = 0 validStarting: 'uint' = 0 - validUntil: 'uint' = 0 + validUntil: 'typing.Union[Nullable, uint]' = NullValue + + @dataclass + class FabricScopedTrustedTimeSourceStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="nodeID", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="endpoint", Tag=1, Type=uint), + ]) + + nodeID: 'uint' = 0 + endpoint: 'uint' = 0 @dataclass class TimeZoneStruct(ClusterObject): @@ -11135,9 +11179,24 @@ def descriptor(cls) -> ClusterObjectDescriptor: validAt: 'uint' = 0 name: 'typing.Optional[str]' = None + @dataclass + class TrustedTimeSourceStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="fabricIndex", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="nodeID", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="endpoint", Tag=2, Type=uint), + ]) + + fabricIndex: 'uint' = 0 + nodeID: 'uint' = 0 + endpoint: 'uint' = 0 + class Commands: @dataclass - class SetUtcTime(ClusterCommand): + class SetUTCTime(ClusterCommand): cluster_id: typing.ClassVar[int] = 0x0038 command_id: typing.ClassVar[int] = 0x00000000 is_client: typing.ClassVar[bool] = True @@ -11147,15 +11206,95 @@ class SetUtcTime(ClusterCommand): def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="utcTime", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="UTCTime", Tag=0, Type=uint), ClusterObjectFieldDescriptor(Label="granularity", Tag=1, Type=TimeSynchronization.Enums.GranularityEnum), ClusterObjectFieldDescriptor(Label="timeSource", Tag=2, Type=typing.Optional[TimeSynchronization.Enums.TimeSourceEnum]), ]) - utcTime: 'uint' = 0 + UTCTime: 'uint' = 0 granularity: 'TimeSynchronization.Enums.GranularityEnum' = 0 timeSource: 'typing.Optional[TimeSynchronization.Enums.TimeSourceEnum]' = None + @dataclass + class SetTrustedTimeSource(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x0038 + command_id: typing.ClassVar[int] = 0x00000001 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="trustedTimeSource", Tag=0, Type=typing.Union[Nullable, TimeSynchronization.Structs.FabricScopedTrustedTimeSourceStruct]), + ]) + + trustedTimeSource: 'typing.Union[Nullable, TimeSynchronization.Structs.FabricScopedTrustedTimeSourceStruct]' = NullValue + + @dataclass + class SetTimeZone(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x0038 + command_id: typing.ClassVar[int] = 0x00000002 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = 'SetTimeZoneResponse' + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="timeZone", Tag=0, Type=typing.List[TimeSynchronization.Structs.TimeZoneStruct]), + ]) + + timeZone: 'typing.List[TimeSynchronization.Structs.TimeZoneStruct]' = field(default_factory=lambda: []) + + @dataclass + class SetTimeZoneResponse(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x0038 + command_id: typing.ClassVar[int] = 0x00000003 + is_client: typing.ClassVar[bool] = False + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="DSTOffsetRequired", Tag=0, Type=bool), + ]) + + DSTOffsetRequired: 'bool' = False + + @dataclass + class SetDSTOffset(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x0038 + command_id: typing.ClassVar[int] = 0x00000004 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="DSTOffset", Tag=0, Type=typing.List[TimeSynchronization.Structs.DSTOffsetStruct]), + ]) + + DSTOffset: 'typing.List[TimeSynchronization.Structs.DSTOffsetStruct]' = field(default_factory=lambda: []) + + @dataclass + class SetDefaultNTP(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x0038 + command_id: typing.ClassVar[int] = 0x00000005 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="defaultNTP", Tag=0, Type=typing.Union[Nullable, str]), + ]) + + defaultNTP: 'typing.Union[Nullable, str]' = NullValue + class Attributes: @dataclass class UTCTime(ClusterAttributeDescriptor): @@ -11206,7 +11345,7 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Optional[TimeSynchronization.Enums.TimeSourceEnum]' = None @dataclass - class TrustedTimeNodeId(ClusterAttributeDescriptor): + class TrustedTimeSource(ClusterAttributeDescriptor): @ChipUtility.classproperty def cluster_id(cls) -> int: return 0x0038 @@ -11217,12 +11356,12 @@ def attribute_id(cls) -> int: @ChipUtility.classproperty def attribute_type(cls) -> ClusterObjectFieldDescriptor: - return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, TimeSynchronization.Structs.TrustedTimeSourceStruct]) - value: 'typing.Union[Nullable, uint]' = NullValue + value: 'typing.Union[None, Nullable, TimeSynchronization.Structs.TrustedTimeSourceStruct]' = None @dataclass - class DefaultNtp(ClusterAttributeDescriptor): + class DefaultNTP(ClusterAttributeDescriptor): @ChipUtility.classproperty def cluster_id(cls) -> int: return 0x0038 @@ -11295,6 +11434,22 @@ def cluster_id(cls) -> int: def attribute_id(cls) -> int: return 0x00000008 + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[TimeSynchronization.Enums.TimeZoneDatabaseEnum]) + + value: 'typing.Optional[TimeSynchronization.Enums.TimeZoneDatabaseEnum]' = None + + @dataclass + class NTPServerAvailable(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000009 + @ChipUtility.classproperty def attribute_type(cls) -> ClusterObjectFieldDescriptor: return ClusterObjectFieldDescriptor(Type=typing.Optional[bool]) @@ -11302,20 +11457,52 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Optional[bool]' = None @dataclass - class NtpServerPort(ClusterAttributeDescriptor): + class TimeZoneListMaxSize(ClusterAttributeDescriptor): @ChipUtility.classproperty def cluster_id(cls) -> int: return 0x0038 @ChipUtility.classproperty def attribute_id(cls) -> int: - return 0x00000009 + return 0x0000000A @ChipUtility.classproperty def attribute_type(cls) -> ClusterObjectFieldDescriptor: - return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, uint]) + return ClusterObjectFieldDescriptor(Type=typing.Optional[uint]) - value: 'typing.Union[None, Nullable, uint]' = None + value: 'typing.Optional[uint]' = None + + @dataclass + class DSTOffsetListMaxSize(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000000B + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[uint]) + + value: 'typing.Optional[uint]' = None + + @dataclass + class SupportsDNSResolve(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000000C + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[bool]) + + value: 'typing.Optional[bool]' = None @dataclass class GeneratedCommandList(ClusterAttributeDescriptor): @@ -11413,6 +11600,95 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = 0 + class Events: + @dataclass + class DSTTableEmpty(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + + @dataclass + class DSTStatus(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="DSTOffsetActive", Tag=0, Type=bool), + ]) + + DSTOffsetActive: 'bool' = False + + @dataclass + class TimeZoneStatus(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="offset", Tag=0, Type=int), + ClusterObjectFieldDescriptor(Label="name", Tag=1, Type=typing.Optional[str]), + ]) + + offset: 'int' = 0 + name: 'typing.Optional[str]' = None + + @dataclass + class TimeFailure(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + + @dataclass + class MissingTrustedTimeSource(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0038 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000004 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + @dataclass class BridgedDeviceBasicInformation(Cluster): diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index f55d7231050d42..c7b3edf744c299 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -19975,19 +19975,19 @@ typedef NS_ENUM(uint8_t, MTRTimeSynchronizationTimeSource) { MTRTimeSynchronizationTimeSourceUnknown API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x01, MTRTimeSynchronizationTimeSourceAdmin API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x02, MTRTimeSynchronizationTimeSourceNodeTimeCluster API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x03, - MTRTimeSynchronizationTimeSourceNonFabricSntp API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x04, - MTRTimeSynchronizationTimeSourceNonFabricNtp API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x05, - MTRTimeSynchronizationTimeSourceFabricSntp API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x06, - MTRTimeSynchronizationTimeSourceFabricNtp API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x07, - MTRTimeSynchronizationTimeSourceMixedNtp API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x08, - MTRTimeSynchronizationTimeSourceNonFabricSntpNts API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x09, - MTRTimeSynchronizationTimeSourceNonFabricNtpNts API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x0A, - MTRTimeSynchronizationTimeSourceFabricSntpNts API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x0B, - MTRTimeSynchronizationTimeSourceFabricNtpNts API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x0C, - MTRTimeSynchronizationTimeSourceMixedNtpNts API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x0D, + MTRTimeSynchronizationTimeSourceNonMatterSNTP MTR_NEWLY_AVAILABLE = 0x04, + MTRTimeSynchronizationTimeSourceNonMatterNTP MTR_NEWLY_AVAILABLE = 0x05, + MTRTimeSynchronizationTimeSourceMatterSNTP MTR_NEWLY_AVAILABLE = 0x06, + MTRTimeSynchronizationTimeSourceMatterNTP MTR_NEWLY_AVAILABLE = 0x07, + MTRTimeSynchronizationTimeSourceMixedNTP MTR_NEWLY_AVAILABLE = 0x08, + MTRTimeSynchronizationTimeSourceNonMatterSNTPNTS MTR_NEWLY_AVAILABLE = 0x09, + MTRTimeSynchronizationTimeSourceNonMatterNTPNTS MTR_NEWLY_AVAILABLE = 0x0A, + MTRTimeSynchronizationTimeSourceMatterSNTPNTS MTR_NEWLY_AVAILABLE = 0x0B, + MTRTimeSynchronizationTimeSourceMatterNTPNTS MTR_NEWLY_AVAILABLE = 0x0C, + MTRTimeSynchronizationTimeSourceMixedNTPNTS MTR_NEWLY_AVAILABLE = 0x0D, MTRTimeSynchronizationTimeSourceCloudSource API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x0E, - MTRTimeSynchronizationTimeSourcePtp API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x0F, - MTRTimeSynchronizationTimeSourceGnss API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) = 0x10, + MTRTimeSynchronizationTimeSourcePTP MTR_NEWLY_AVAILABLE = 0x0F, + MTRTimeSynchronizationTimeSourceGNSS MTR_NEWLY_AVAILABLE = 0x10, } API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)); typedef NS_ENUM(uint8_t, MTRBridgedDeviceBasicInformationColor) { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 5d5fbcead09a84..c035318ae60a5d 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -2849,14 +2849,6 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeSourceID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) = 0x00000002, - MTRClusterTimeSynchronizationAttributeTrustedTimeNodeIdID MTR_DEPRECATED( - "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeTrustedTimeNodeIdID", ios(16.1, 16.4), macos(13.0, 13.3), - watchos(9.1, 9.4), tvos(16.1, 16.4)) - = 0x00000003, - MTRClusterTimeSynchronizationAttributeDefaultNtpID MTR_DEPRECATED( - "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeDefaultNtpID", ios(16.1, 16.4), macos(13.0, 13.3), - watchos(9.1, 9.4), tvos(16.1, 16.4)) - = 0x00000004, MTRClusterTimeSynchronizationAttributeTimeZoneID MTR_DEPRECATED( "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeZoneID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) @@ -2873,10 +2865,6 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeZoneDatabaseID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) = 0x00000008, - MTRClusterTimeSynchronizationAttributeNtpServerPortID MTR_DEPRECATED( - "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeNtpServerPortID", ios(16.1, 16.4), macos(13.0, 13.3), - watchos(9.1, 9.4), tvos(16.1, 16.4)) - = 0x00000009, MTRClusterTimeSynchronizationAttributeGeneratedCommandListID MTR_DEPRECATED( "Please use MTRAttributeIDTypeClusterTimeSynchronizationAttributeGeneratedCommandListID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) @@ -2907,12 +2895,8 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeSourceID API_AVAILABLE( ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000002, - MTRAttributeIDTypeClusterTimeSynchronizationAttributeTrustedTimeNodeIdID API_AVAILABLE( - ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) - = 0x00000003, - MTRAttributeIDTypeClusterTimeSynchronizationAttributeDefaultNtpID API_AVAILABLE( - ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) - = 0x00000004, + MTRAttributeIDTypeClusterTimeSynchronizationAttributeTrustedTimeSourceID MTR_NEWLY_AVAILABLE = 0x00000003, + MTRAttributeIDTypeClusterTimeSynchronizationAttributeDefaultNTPID MTR_NEWLY_AVAILABLE = 0x00000004, MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeZoneID API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000005, MTRAttributeIDTypeClusterTimeSynchronizationAttributeDSTOffsetID API_AVAILABLE(ios(16.5), macos(13.4), watchos(9.5), tvos(16.5)) @@ -2926,9 +2910,10 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeZoneDatabaseID API_AVAILABLE( ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000008, - MTRAttributeIDTypeClusterTimeSynchronizationAttributeNtpServerPortID API_AVAILABLE( - ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) - = 0x00000009, + MTRAttributeIDTypeClusterTimeSynchronizationAttributeNTPServerAvailableID MTR_NEWLY_AVAILABLE = 0x00000009, + MTRAttributeIDTypeClusterTimeSynchronizationAttributeTimeZoneListMaxSizeID MTR_NEWLY_AVAILABLE = 0x0000000A, + MTRAttributeIDTypeClusterTimeSynchronizationAttributeDSTOffsetListMaxSizeID MTR_NEWLY_AVAILABLE = 0x0000000B, + MTRAttributeIDTypeClusterTimeSynchronizationAttributeSupportsDNSResolveID MTR_NEWLY_AVAILABLE = 0x0000000C, MTRAttributeIDTypeClusterTimeSynchronizationAttributeGeneratedCommandListID API_AVAILABLE( ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, @@ -8560,14 +8545,14 @@ typedef NS_ENUM(uint32_t, MTRCommandIDType) { = 0x00000000, // Cluster TimeSynchronization deprecated command id names - MTRClusterTimeSynchronizationCommandSetUtcTimeID MTR_DEPRECATED( - "Please use MTRCommandIDTypeClusterTimeSynchronizationCommandSetUtcTimeID", ios(16.1, 16.4), macos(13.0, 13.3), - watchos(9.1, 9.4), tvos(16.1, 16.4)) - = 0x00000000, // Cluster TimeSynchronization commands - MTRCommandIDTypeClusterTimeSynchronizationCommandSetUtcTimeID API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) - = 0x00000000, + MTRCommandIDTypeClusterTimeSynchronizationCommandSetUTCTimeID MTR_NEWLY_AVAILABLE = 0x00000000, + MTRCommandIDTypeClusterTimeSynchronizationCommandSetTrustedTimeSourceID MTR_NEWLY_AVAILABLE = 0x00000001, + MTRCommandIDTypeClusterTimeSynchronizationCommandSetTimeZoneID MTR_NEWLY_AVAILABLE = 0x00000002, + MTRCommandIDTypeClusterTimeSynchronizationCommandSetTimeZoneResponseID MTR_NEWLY_AVAILABLE = 0x00000003, + MTRCommandIDTypeClusterTimeSynchronizationCommandSetDSTOffsetID MTR_NEWLY_AVAILABLE = 0x00000004, + MTRCommandIDTypeClusterTimeSynchronizationCommandSetDefaultNTPID MTR_NEWLY_AVAILABLE = 0x00000005, // Cluster AdministratorCommissioning deprecated command id names MTRClusterAdministratorCommissioningCommandOpenCommissioningWindowID MTR_DEPRECATED( @@ -9775,6 +9760,12 @@ typedef NS_ENUM(uint32_t, MTREventIDType) { ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000002, + MTREventIDTypeClusterTimeSynchronizationEventDSTTableEmptyID MTR_NEWLY_AVAILABLE = 0x00000000, + MTREventIDTypeClusterTimeSynchronizationEventDSTStatusID MTR_NEWLY_AVAILABLE = 0x00000001, + MTREventIDTypeClusterTimeSynchronizationEventTimeZoneStatusID MTR_NEWLY_AVAILABLE = 0x00000002, + MTREventIDTypeClusterTimeSynchronizationEventTimeFailureID MTR_NEWLY_AVAILABLE = 0x00000003, + MTREventIDTypeClusterTimeSynchronizationEventMissingTrustedTimeSourceID MTR_NEWLY_AVAILABLE = 0x00000004, + // Cluster BridgedDeviceBasic deprecated event names MTRClusterBridgedDeviceBasicEventStartUpID MTR_DEPRECATED( "Please use MTREventIDTypeClusterBridgedDeviceBasicInformationEventStartUpID", ios(16.1, 16.4), macos(13.0, 13.3), diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h index 2e257f43660372..a96f234508cf3c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h @@ -3012,40 +3012,6 @@ API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) @property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; @end -API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) -@interface MTRTimeSynchronizationClusterSetUtcTimeParams : NSObject - -@property (nonatomic, copy) NSNumber * _Nonnull utcTime API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)); - -@property (nonatomic, copy) NSNumber * _Nonnull granularity API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)); - -@property (nonatomic, copy) NSNumber * _Nullable timeSource API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)); -/** - * 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 - API_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) @interface MTRAdministratorCommissioningClusterOpenCommissioningWindowParams : NSObject diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm index b0a66d4e6484ee..c12cfb5bc60d2d 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm @@ -3678,43 +3678,6 @@ - (NSString *)description return descriptionString; } -@end -@implementation MTRTimeSynchronizationClusterSetUtcTimeParams -- (instancetype)init -{ - if (self = [super init]) { - - _utcTime = @(0); - - _granularity = @(0); - - _timeSource = nil; - _timedInvokeTimeoutMs = nil; - _serverSideProcessingTimeout = nil; - } - return self; -} - -- (id)copyWithZone:(NSZone * _Nullable)zone; -{ - auto other = [[MTRTimeSynchronizationClusterSetUtcTimeParams alloc] init]; - - other.utcTime = self.utcTime; - other.granularity = self.granularity; - other.timeSource = self.timeSource; - other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; - other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; - - return other; -} - -- (NSString *)description -{ - NSString * descriptionString = [NSString stringWithFormat:@"<%@: utcTime:%@; granularity:%@; timeSource:%@; >", - NSStringFromClass([self class]), _utcTime, _granularity, _timeSource]; - return descriptionString; -} - @end @implementation MTRAdministratorCommissioningClusterOpenCommissioningWindowParams - (instancetype)init diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index f0711c27592b29..77be660c039fb5 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -482,7 +482,7 @@ API_AVAILABLE(ios(16.5), macos(13.4), watchos(9.5), tvos(16.5)) @interface MTRTimeSynchronizationClusterDSTOffsetStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull offset API_AVAILABLE(ios(16.5), macos(13.4), watchos(9.5), tvos(16.5)); @property (nonatomic, copy) NSNumber * _Nonnull validStarting API_AVAILABLE(ios(16.5), macos(13.4), watchos(9.5), tvos(16.5)); -@property (nonatomic, copy) NSNumber * _Nonnull validUntil API_AVAILABLE(ios(16.5), macos(13.4), watchos(9.5), tvos(16.5)); +@property (nonatomic, copy) NSNumber * _Nullable validUntil API_AVAILABLE(ios(16.5), macos(13.4), watchos(9.5), tvos(16.5)); @end MTR_DEPRECATED("Please use MTRTimeSynchronizationClusterDSTOffsetStruct", ios(16.1, 16.5), macos(13.0, 13.4), watchos(9.1, 9.5), diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index d079a7173770b8..bc26064a203a12 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -1851,7 +1851,7 @@ - (instancetype)init _validStarting = @(0); - _validUntil = @(0); + _validUntil = nil; } return self; } 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 603fa9be0d4fab..c620b5f2108b1e 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 @@ -5069,59 +5069,6 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) namespace TimeSynchronization { namespace Attributes { -namespace UTCTime { - -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType temp; - uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); - EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp)); - VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (Traits::IsNullValue(temp)) - { - value.SetNull(); - } - else - { - value.SetNonNull() = Traits::StorageToWorking(temp); - } - return status; -} -EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) -{ - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) - { - return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; - } - Traits::StorageType storageValue; - Traits::WorkingToStorage(value, storageValue); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE); -} - -EmberAfStatus SetNull(chip::EndpointId endpoint) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType value; - Traits::SetNull(value); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE); -} - -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) -{ - if (value.IsNull()) - { - return SetNull(endpoint); - } - - return Set(endpoint, value.Value()); -} - -} // namespace UTCTime - namespace Granularity { EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::GranularityEnum * value) @@ -5184,165 +5131,104 @@ EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchroniz } // namespace TimeSource -namespace TrustedTimeNodeId { +namespace TimeZoneDatabase { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum * value) { - using Traits = NumericAttributeTraits; + using Traits = NumericAttributeTraits; Traits::StorageType temp; uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (Traits::IsNullValue(temp)) - { - value.SetNull(); - } - else + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) { - value.SetNonNull() = Traits::StorageToWorking(temp); + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } + *value = Traits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, chip::NodeId value) +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum value) { - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + using Traits = NumericAttributeTraits; + 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::TimeSynchronization::Id, Id, writable, ZCL_NODE_ID_ATTRIBUTE_TYPE); -} - -EmberAfStatus SetNull(chip::EndpointId endpoint) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType value; - Traits::SetNull(value); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_NODE_ID_ATTRIBUTE_TYPE); -} - -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) -{ - if (value.IsNull()) - { - return SetNull(endpoint); - } - - return Set(endpoint, value.Value()); + return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); } -} // namespace TrustedTimeNodeId +} // namespace TimeZoneDatabase -namespace DefaultNtp { +namespace NTPServerAvailable { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, bool * value) { - uint8_t zclString[128 + 1]; - EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, zclString, sizeof(zclString)); + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - size_t length = emberAfStringLength(zclString); - if (length == NumericAttributeTraits::kNullValue) + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) { - value.SetNull(); - return EMBER_ZCL_STATUS_SUCCESS; + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - auto & span = value.SetNonNull(); - - VerifyOrReturnError(span.size() == 128, EMBER_ZCL_STATUS_INVALID_DATA_TYPE); - memcpy(span.data(), &zclString[1], 128); - span.reduce_size(length); + *value = Traits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value) -{ - static_assert(128 < NumericAttributeTraits::kNullValue, "value.size() might be too big"); - VerifyOrReturnError(value.size() <= 128, EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - uint8_t zclString[128 + 1]; - emberAfCopyInt8u(zclString, 0, static_cast(value.size())); - memcpy(&zclString[1], value.data(), value.size()); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE); -} - -EmberAfStatus SetNull(chip::EndpointId endpoint) -{ - uint8_t zclString[1] = { 0xFF }; - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE); -} - -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, bool value) { - if (value.IsNull()) + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) { - return SetNull(endpoint); + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - - return Set(endpoint, value.Value()); + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); } -} // namespace DefaultNtp +} // namespace NTPServerAvailable -namespace LocalTime { +namespace TimeZoneListMaxSize { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) { - using Traits = NumericAttributeTraits; + using Traits = NumericAttributeTraits; Traits::StorageType temp; uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (Traits::IsNullValue(temp)) - { - value.SetNull(); - } - else + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) { - value.SetNonNull() = Traits::StorageToWorking(temp); + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } + *value = Traits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) { - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + using Traits = NumericAttributeTraits; + 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::TimeSynchronization::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE); -} - -EmberAfStatus SetNull(chip::EndpointId endpoint) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType value; - Traits::SetNull(value); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE); -} - -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) -{ - if (value.IsNull()) - { - return SetNull(endpoint); - } - - return Set(endpoint, value.Value()); + return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); } -} // namespace LocalTime +} // namespace TimeZoneListMaxSize -namespace TimeZoneDatabase { +namespace DSTOffsetListMaxSize { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value) +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) { - using Traits = NumericAttributeTraits; + using Traits = NumericAttributeTraits; Traits::StorageType temp; uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp)); @@ -5354,9 +5240,9 @@ EmberAfStatus Get(chip::EndpointId endpoint, bool * value) *value = Traits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, bool value) +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) { - using Traits = NumericAttributeTraits; + using Traits = NumericAttributeTraits; if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; @@ -5364,63 +5250,41 @@ EmberAfStatus Set(chip::EndpointId endpoint, bool value) Traits::StorageType storageValue; Traits::WorkingToStorage(value, storageValue); uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); + return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); } -} // namespace TimeZoneDatabase +} // namespace DSTOffsetListMaxSize -namespace NtpServerPort { +namespace SupportsDNSResolve { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, bool * value) { - using Traits = NumericAttributeTraits; + using Traits = NumericAttributeTraits; Traits::StorageType temp; uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (Traits::IsNullValue(temp)) - { - value.SetNull(); - } - else + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) { - value.SetNonNull() = Traits::StorageToWorking(temp); + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } + *value = Traits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +EmberAfStatus Set(chip::EndpointId endpoint, bool value) { - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + using Traits = NumericAttributeTraits; + 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::TimeSynchronization::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); -} - -EmberAfStatus SetNull(chip::EndpointId endpoint) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType value; - Traits::SetNull(value); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); - return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); -} - -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) -{ - if (value.IsNull()) - { - return SetNull(endpoint); - } - - return Set(endpoint, value.Value()); + return emberAfWriteAttribute(endpoint, Clusters::TimeSynchronization::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); } -} // namespace NtpServerPort +} // namespace SupportsDNSResolve namespace FeatureMap { 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 d897fd29993f61..c2b6ca482ae634 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 @@ -973,13 +973,6 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); namespace TimeSynchronization { namespace Attributes { -namespace UTCTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us -EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); -EmberAfStatus SetNull(chip::EndpointId endpoint); -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); -} // namespace UTCTime - namespace Granularity { EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::GranularityEnum * value); // GranularityEnum EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::GranularityEnum value); @@ -990,38 +983,31 @@ EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchroniz EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value); } // namespace TimeSource -namespace TrustedTimeNodeId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // node_id -EmberAfStatus Set(chip::EndpointId endpoint, chip::NodeId value); -EmberAfStatus SetNull(chip::EndpointId endpoint); -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); -} // namespace TrustedTimeNodeId +namespace TimeZoneDatabase { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum * value); // TimeZoneDatabaseEnum +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum value); +} // namespace TimeZoneDatabase -namespace DefaultNtp { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string -EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); -EmberAfStatus SetNull(chip::EndpointId endpoint); -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); -} // namespace DefaultNtp +namespace NTPServerAvailable { +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Set(chip::EndpointId endpoint, bool value); +} // namespace NTPServerAvailable -namespace LocalTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us -EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); -EmberAfStatus SetNull(chip::EndpointId endpoint); -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); -} // namespace LocalTime +namespace TimeZoneListMaxSize { +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); +} // namespace TimeZoneListMaxSize -namespace TimeZoneDatabase { +namespace DSTOffsetListMaxSize { +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); +} // namespace DSTOffsetListMaxSize + +namespace SupportsDNSResolve { EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean EmberAfStatus Set(chip::EndpointId endpoint, bool value); -} // namespace TimeZoneDatabase - -namespace NtpServerPort { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u -EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); -EmberAfStatus SetNull(chip::EndpointId endpoint); -EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); -} // namespace NtpServerPort +} // namespace SupportsDNSResolve namespace FeatureMap { EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 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 f28ebdafecf988..ac7379e8c8f052 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -6525,11 +6525,35 @@ bool emberAfEthernetNetworkDiagnosticsClusterResetCountsCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::DecodableType & commandData); /** - * @brief Time Synchronization Cluster SetUtcTime Command callback (from client) + * @brief Time Synchronization Cluster SetUTCTime Command callback (from client) */ -bool emberAfTimeSynchronizationClusterSetUtcTimeCallback( +bool emberAfTimeSynchronizationClusterSetUTCTimeCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, - const chip::app::Clusters::TimeSynchronization::Commands::SetUtcTime::DecodableType & commandData); + const chip::app::Clusters::TimeSynchronization::Commands::SetUTCTime::DecodableType & commandData); +/** + * @brief Time Synchronization Cluster SetTrustedTimeSource Command callback (from client) + */ +bool emberAfTimeSynchronizationClusterSetTrustedTimeSourceCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::DecodableType & commandData); +/** + * @brief Time Synchronization Cluster SetTimeZone Command callback (from client) + */ +bool emberAfTimeSynchronizationClusterSetTimeZoneCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::TimeSynchronization::Commands::SetTimeZone::DecodableType & commandData); +/** + * @brief Time Synchronization Cluster SetDSTOffset Command callback (from client) + */ +bool emberAfTimeSynchronizationClusterSetDSTOffsetCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::TimeSynchronization::Commands::SetDSTOffset::DecodableType & commandData); +/** + * @brief Time Synchronization Cluster SetDefaultNTP Command callback (from client) + */ +bool emberAfTimeSynchronizationClusterSetDefaultNTPCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::TimeSynchronization::Commands::SetDefaultNTP::DecodableType & commandData); /** * @brief Administrator Commissioning Cluster OpenCommissioningWindow Command callback (from client) */ diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h index dd8a0282fdab6d..d5cd9844b83932 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h @@ -1111,6 +1111,17 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::Gr return static_cast(5); } } +static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::StatusCode val) +{ + using EnumType = TimeSynchronization::StatusCode; + switch (val) + { + case EnumType::kTimeNotAccepted: + return val; + default: + return static_cast(0); + } +} static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::TimeSourceEnum val) { using EnumType = TimeSynchronization::TimeSourceEnum; @@ -1120,16 +1131,16 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::Ti case EnumType::kUnknown: case EnumType::kAdmin: case EnumType::kNodeTimeCluster: - case EnumType::kNonFabricSntp: - case EnumType::kNonFabricNtp: - case EnumType::kFabricSntp: - case EnumType::kFabricNtp: - case EnumType::kMixedNtp: - case EnumType::kNonFabricSntpNts: - case EnumType::kNonFabricNtpNts: - case EnumType::kFabricSntpNts: - case EnumType::kFabricNtpNts: - case EnumType::kMixedNtpNts: + case EnumType::kNonMatterSNTP: + case EnumType::kNonMatterNTP: + case EnumType::kMatterSNTP: + case EnumType::kMatterNTP: + case EnumType::kMixedNTP: + case EnumType::kNonMatterSNTPNTS: + case EnumType::kNonMatterNTPNTS: + case EnumType::kMatterSNTPNTS: + case EnumType::kMatterNTPNTS: + case EnumType::kMixedNTPNTS: case EnumType::kCloudSource: case EnumType::kPtp: case EnumType::kGnss: @@ -1138,6 +1149,19 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::Ti return static_cast(17); } } +static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::TimeZoneDatabaseEnum val) +{ + using EnumType = TimeSynchronization::TimeZoneDatabaseEnum; + switch (val) + { + case EnumType::kFull: + case EnumType::kPartial: + case EnumType::kNone: + return val; + default: + return static_cast(3); + } +} static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedDeviceBasicInformation::ColorEnum val) { 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 9b423e822a7e64..481e9b1b438fb2 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 @@ -1271,6 +1271,17 @@ enum class GranularityEnum : uint8_t kUnknownEnumValue = 5, }; +// Enum for StatusCode +enum class StatusCode : uint8_t +{ + kTimeNotAccepted = 0x02, + // All received enum values that are not listed above will be mapped + // to kUnknownEnumValue. This is a helper enum value that should only + // be used by code to process how it handles receiving and unknown + // enum value. This specific should never be transmitted. + kUnknownEnumValue = 0, +}; + // Enum for TimeSourceEnum enum class TimeSourceEnum : uint8_t { @@ -1278,16 +1289,16 @@ enum class TimeSourceEnum : uint8_t kUnknown = 0x01, kAdmin = 0x02, kNodeTimeCluster = 0x03, - kNonFabricSntp = 0x04, - kNonFabricNtp = 0x05, - kFabricSntp = 0x06, - kFabricNtp = 0x07, - kMixedNtp = 0x08, - kNonFabricSntpNts = 0x09, - kNonFabricNtpNts = 0x0A, - kFabricSntpNts = 0x0B, - kFabricNtpNts = 0x0C, - kMixedNtpNts = 0x0D, + kNonMatterSNTP = 0x04, + kNonMatterNTP = 0x05, + kMatterSNTP = 0x06, + kMatterNTP = 0x07, + kMixedNTP = 0x08, + kNonMatterSNTPNTS = 0x09, + kNonMatterNTPNTS = 0x0A, + kMatterSNTPNTS = 0x0B, + kMatterNTPNTS = 0x0C, + kMixedNTPNTS = 0x0D, kCloudSource = 0x0E, kPtp = 0x0F, kGnss = 0x10, @@ -1297,6 +1308,28 @@ enum class TimeSourceEnum : uint8_t // enum value. This specific should never be transmitted. kUnknownEnumValue = 17, }; + +// Enum for TimeZoneDatabaseEnum +enum class TimeZoneDatabaseEnum : uint8_t +{ + kFull = 0x00, + kPartial = 0x01, + kNone = 0x02, + // All received enum values that are not listed above will be mapped + // to kUnknownEnumValue. This is a helper enum value that should only + // be used by code to process how it handles receiving and unknown + // enum value. This specific should never be transmitted. + kUnknownEnumValue = 3, +}; + +// Bitmap for TimeSynchronizationFeature +enum class TimeSynchronizationFeature : uint32_t +{ + kTimeZone = 0x1, + kNTPClient = 0x2, + kNTPServer = 0x4, + kTimeSyncClient = 0x8, +}; } // namespace TimeSynchronization namespace BridgedDeviceBasicInformation { 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 1e9a9aa8a52728..d412b0a9b64cc0 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 @@ -8125,6 +8125,50 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } } // namespace DSTOffsetStruct +namespace FabricScopedTrustedTimeSourceStruct { +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::kNodeID), nodeID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kEndpoint), endpoint)); + 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) + { + if (!TLV::IsContextTag(reader.GetTag())) + { + continue; + } + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kNodeID): + ReturnErrorOnFailure(DataModel::Decode(reader, nodeID)); + break; + case to_underlying(Fields::kEndpoint): + ReturnErrorOnFailure(DataModel::Decode(reader, endpoint)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + + return CHIP_NO_ERROR; +} + +} // namespace FabricScopedTrustedTimeSourceStruct namespace TimeZoneStruct { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const { @@ -8173,15 +8217,63 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } } // namespace TimeZoneStruct +namespace TrustedTimeSourceStruct { +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::kFabricIndex), fabricIndex)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kNodeID), nodeID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kEndpoint), endpoint)); + 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) + { + if (!TLV::IsContextTag(reader.GetTag())) + { + continue; + } + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kFabricIndex): + ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex)); + break; + case to_underlying(Fields::kNodeID): + ReturnErrorOnFailure(DataModel::Decode(reader, nodeID)); + break; + case to_underlying(Fields::kEndpoint): + ReturnErrorOnFailure(DataModel::Decode(reader, endpoint)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + + return CHIP_NO_ERROR; +} + +} // namespace TrustedTimeSourceStruct } // namespace Structs namespace Commands { -namespace SetUtcTime { +namespace SetUTCTime { 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::kUtcTime), utcTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kUTCTime), UTCTime)); ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kGranularity), granularity)); ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kTimeSource), timeSource)); ReturnErrorOnFailure(writer.EndContainer(outer)); @@ -8202,8 +8294,8 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } switch (TLV::TagNumFromTag(reader.GetTag())) { - case to_underlying(Fields::kUtcTime): - ReturnErrorOnFailure(DataModel::Decode(reader, utcTime)); + case to_underlying(Fields::kUTCTime): + ReturnErrorOnFailure(DataModel::Decode(reader, UTCTime)); break; case to_underlying(Fields::kGranularity): ReturnErrorOnFailure(DataModel::Decode(reader, granularity)); @@ -8220,7 +8312,192 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) ReturnErrorOnFailure(reader.ExitContainer(outer)); return CHIP_NO_ERROR; } -} // namespace SetUtcTime. +} // namespace SetUTCTime. +namespace SetTrustedTimeSource { +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::kTrustedTimeSource), trustedTimeSource)); + 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::kTrustedTimeSource): + ReturnErrorOnFailure(DataModel::Decode(reader, trustedTimeSource)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SetTrustedTimeSource. +namespace SetTimeZone { +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::kTimeZone), timeZone)); + 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::kTimeZone): + ReturnErrorOnFailure(DataModel::Decode(reader, timeZone)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SetTimeZone. +namespace SetTimeZoneResponse { +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::kDSTOffsetRequired), DSTOffsetRequired)); + 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::kDSTOffsetRequired): + ReturnErrorOnFailure(DataModel::Decode(reader, DSTOffsetRequired)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SetTimeZoneResponse. +namespace SetDSTOffset { +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::kDSTOffset), DSTOffset)); + 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::kDSTOffset): + ReturnErrorOnFailure(DataModel::Decode(reader, DSTOffset)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SetDSTOffset. +namespace SetDefaultNTP { +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::kDefaultNTP), defaultNTP)); + 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::kDefaultNTP): + ReturnErrorOnFailure(DataModel::Decode(reader, defaultNTP)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SetDefaultNTP. } // namespace Commands namespace Attributes { @@ -8237,11 +8514,11 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre case Attributes::TimeSource::TypeInfo::GetAttributeId(): ReturnErrorOnFailure(DataModel::Decode(reader, timeSource)); break; - case Attributes::TrustedTimeNodeId::TypeInfo::GetAttributeId(): - ReturnErrorOnFailure(DataModel::Decode(reader, trustedTimeNodeId)); + case Attributes::TrustedTimeSource::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, trustedTimeSource)); break; - case Attributes::DefaultNtp::TypeInfo::GetAttributeId(): - ReturnErrorOnFailure(DataModel::Decode(reader, defaultNtp)); + case Attributes::DefaultNTP::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, defaultNTP)); break; case Attributes::TimeZone::TypeInfo::GetAttributeId(): ReturnErrorOnFailure(DataModel::Decode(reader, timeZone)); @@ -8255,8 +8532,17 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre case Attributes::TimeZoneDatabase::TypeInfo::GetAttributeId(): ReturnErrorOnFailure(DataModel::Decode(reader, timeZoneDatabase)); break; - case Attributes::NtpServerPort::TypeInfo::GetAttributeId(): - ReturnErrorOnFailure(DataModel::Decode(reader, ntpServerPort)); + case Attributes::NTPServerAvailable::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, NTPServerAvailable)); + break; + case Attributes::TimeZoneListMaxSize::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, timeZoneListMaxSize)); + break; + case Attributes::DSTOffsetListMaxSize::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, DSTOffsetListMaxSize)); + break; + case Attributes::SupportsDNSResolve::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, supportsDNSResolve)); break; case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): ReturnErrorOnFailure(DataModel::Decode(reader, generatedCommandList)); @@ -8284,7 +8570,185 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre } } // namespace Attributes -namespace Events {} // namespace Events +namespace Events { +namespace DSTTableEmpty { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + 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())) + { + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace DSTTableEmpty. +namespace DSTStatus { +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::kDSTOffsetActive), DSTOffsetActive)); + 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::kDSTOffsetActive): + ReturnErrorOnFailure(DataModel::Decode(reader, DSTOffsetActive)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace DSTStatus. +namespace TimeZoneStatus { +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::kOffset), offset)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kName), name)); + 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::kOffset): + ReturnErrorOnFailure(DataModel::Decode(reader, offset)); + break; + case to_underlying(Fields::kName): + ReturnErrorOnFailure(DataModel::Decode(reader, name)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace TimeZoneStatus. +namespace TimeFailure { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + 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())) + { + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace TimeFailure. +namespace MissingTrustedTimeSource { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + 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())) + { + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace MissingTrustedTimeSource. +} // namespace Events } // namespace TimeSynchronization namespace BridgedDeviceBasicInformation { @@ -21743,6 +22207,8 @@ bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand) case Clusters::TimeSynchronization::Id: { switch (aCommand) { + case Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Id: + return true; default: return false; } 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 c8b474f334ba13..71cce002a8b974 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 @@ -10307,7 +10307,7 @@ struct Type public: int32_t offset = static_cast(0); uint64_t validStarting = static_cast(0); - uint64_t validUntil = static_cast(0); + DataModel::Nullable validUntil; CHIP_ERROR Decode(TLV::TLVReader & reader); @@ -10319,6 +10319,29 @@ struct Type using DecodableType = Type; } // namespace DSTOffsetStruct +namespace FabricScopedTrustedTimeSourceStruct { +enum class Fields : uint8_t +{ + kNodeID = 0, + kEndpoint = 1, +}; + +struct Type +{ +public: + chip::NodeId nodeID = static_cast(0); + chip::EndpointId endpoint = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; +}; + +using DecodableType = Type; + +} // namespace FabricScopedTrustedTimeSourceStruct namespace TimeZoneStruct { enum class Fields : uint8_t { @@ -10344,23 +10367,73 @@ struct Type using DecodableType = Type; } // namespace TimeZoneStruct +namespace TrustedTimeSourceStruct { +enum class Fields : uint8_t +{ + kFabricIndex = 0, + kNodeID = 1, + kEndpoint = 2, +}; + +struct Type +{ +public: + chip::FabricIndex fabricIndex = static_cast(0); + chip::NodeId nodeID = static_cast(0); + chip::EndpointId endpoint = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; +}; + +using DecodableType = Type; + +} // namespace TrustedTimeSourceStruct } // namespace Structs namespace Commands { // Forward-declarations so we can reference these later. -namespace SetUtcTime { +namespace SetUTCTime { +struct Type; +struct DecodableType; +} // namespace SetUTCTime + +namespace SetTrustedTimeSource { +struct Type; +struct DecodableType; +} // namespace SetTrustedTimeSource + +namespace SetTimeZone { +struct Type; +struct DecodableType; +} // namespace SetTimeZone + +namespace SetTimeZoneResponse { struct Type; struct DecodableType; -} // namespace SetUtcTime +} // namespace SetTimeZoneResponse + +namespace SetDSTOffset { +struct Type; +struct DecodableType; +} // namespace SetDSTOffset + +namespace SetDefaultNTP { +struct Type; +struct DecodableType; +} // namespace SetDefaultNTP } // namespace Commands namespace Commands { -namespace SetUtcTime { +namespace SetUTCTime { enum class Fields : uint8_t { - kUtcTime = 0, + kUTCTime = 0, kGranularity = 1, kTimeSource = 2, }; @@ -10369,10 +10442,10 @@ struct Type { public: // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand - static constexpr CommandId GetCommandId() { return Commands::SetUtcTime::Id; } + static constexpr CommandId GetCommandId() { return Commands::SetUTCTime::Id; } static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } - uint64_t utcTime = static_cast(0); + uint64_t UTCTime = static_cast(0); GranularityEnum granularity = static_cast(0); Optional timeSource; @@ -10386,15 +10459,175 @@ struct Type struct DecodableType { public: - static constexpr CommandId GetCommandId() { return Commands::SetUtcTime::Id; } + static constexpr CommandId GetCommandId() { return Commands::SetUTCTime::Id; } static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } - uint64_t utcTime = static_cast(0); + uint64_t UTCTime = static_cast(0); GranularityEnum granularity = static_cast(0); Optional timeSource; CHIP_ERROR Decode(TLV::TLVReader & reader); }; -}; // namespace SetUtcTime +}; // namespace SetUTCTime +namespace SetTrustedTimeSource { +enum class Fields : uint8_t +{ + kTrustedTimeSource = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetTrustedTimeSource::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::Nullable trustedTimeSource; + + 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::SetTrustedTimeSource::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::Nullable trustedTimeSource; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetTrustedTimeSource +namespace SetTimeZone { +enum class Fields : uint8_t +{ + kTimeZone = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetTimeZone::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::List timeZone; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; + + using ResponseType = Clusters::TimeSynchronization::Commands::SetTimeZoneResponse::DecodableType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SetTimeZone::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::DecodableList timeZone; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetTimeZone +namespace SetTimeZoneResponse { +enum class Fields : uint8_t +{ + kDSTOffsetRequired = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetTimeZoneResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + bool DSTOffsetRequired = static_cast(0); + + 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::SetTimeZoneResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + bool DSTOffsetRequired = static_cast(0); + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetTimeZoneResponse +namespace SetDSTOffset { +enum class Fields : uint8_t +{ + kDSTOffset = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetDSTOffset::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::List DSTOffset; + + 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::SetDSTOffset::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::DecodableList DSTOffset; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetDSTOffset +namespace SetDefaultNTP { +enum class Fields : uint8_t +{ + kDefaultNTP = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetDefaultNTP::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::Nullable defaultNTP; + + 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::SetDefaultNTP::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + DataModel::Nullable defaultNTP; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetDefaultNTP } // namespace Commands namespace Attributes { @@ -10435,19 +10668,21 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace TimeSource -namespace TrustedTimeNodeId { +namespace TrustedTimeSource { struct TypeInfo { - using Type = chip::app::DataModel::Nullable; - using DecodableType = chip::app::DataModel::Nullable; - using DecodableArgType = const chip::app::DataModel::Nullable &; + using Type = chip::app::DataModel::Nullable; + using DecodableType = + chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable< + chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::DecodableType> &; static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::TrustedTimeNodeId::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::TrustedTimeSource::Id; } static constexpr bool MustUseTimedWrite() { return false; } }; -} // namespace TrustedTimeNodeId -namespace DefaultNtp { +} // namespace TrustedTimeSource +namespace DefaultNTP { struct TypeInfo { using Type = chip::app::DataModel::Nullable; @@ -10455,11 +10690,11 @@ struct TypeInfo using DecodableArgType = const chip::app::DataModel::Nullable &; static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::DefaultNtp::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::DefaultNTP::Id; } static constexpr bool MustUseTimedWrite() { return false; } static constexpr size_t MaxLength() { return 128; } }; -} // namespace DefaultNtp +} // namespace DefaultNTP namespace TimeZone { struct TypeInfo { @@ -10502,28 +10737,64 @@ struct TypeInfo } // namespace LocalTime namespace TimeZoneDatabase { struct TypeInfo +{ + using Type = chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum; + using DecodableType = chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum; + using DecodableArgType = chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum; + + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::TimeZoneDatabase::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace TimeZoneDatabase +namespace NTPServerAvailable { +struct TypeInfo { using Type = bool; using DecodableType = bool; using DecodableArgType = bool; static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::TimeZoneDatabase::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NTPServerAvailable::Id; } static constexpr bool MustUseTimedWrite() { return false; } }; -} // namespace TimeZoneDatabase -namespace NtpServerPort { +} // namespace NTPServerAvailable +namespace TimeZoneListMaxSize { struct TypeInfo { - using Type = chip::app::DataModel::Nullable; - using DecodableType = chip::app::DataModel::Nullable; - using DecodableArgType = const chip::app::DataModel::Nullable &; + using Type = uint8_t; + using DecodableType = uint8_t; + using DecodableArgType = uint8_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::TimeZoneListMaxSize::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace TimeZoneListMaxSize +namespace DSTOffsetListMaxSize { +struct TypeInfo +{ + using Type = uint8_t; + using DecodableType = uint8_t; + using DecodableArgType = uint8_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::DSTOffsetListMaxSize::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace DSTOffsetListMaxSize +namespace SupportsDNSResolve { +struct TypeInfo +{ + using Type = bool; + using DecodableType = bool; + using DecodableArgType = bool; static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::NtpServerPort::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::SupportsDNSResolve::Id; } static constexpr bool MustUseTimedWrite() { return false; } }; -} // namespace NtpServerPort +} // namespace SupportsDNSResolve namespace GeneratedCommandList { struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo { @@ -10574,13 +10845,17 @@ struct TypeInfo static_cast(0); Attributes::TimeSource::TypeInfo::DecodableType timeSource = static_cast(0); - Attributes::TrustedTimeNodeId::TypeInfo::DecodableType trustedTimeNodeId; - Attributes::DefaultNtp::TypeInfo::DecodableType defaultNtp; + Attributes::TrustedTimeSource::TypeInfo::DecodableType trustedTimeSource; + Attributes::DefaultNTP::TypeInfo::DecodableType defaultNTP; Attributes::TimeZone::TypeInfo::DecodableType timeZone; Attributes::DSTOffset::TypeInfo::DecodableType DSTOffset; Attributes::LocalTime::TypeInfo::DecodableType localTime; - Attributes::TimeZoneDatabase::TypeInfo::DecodableType timeZoneDatabase = static_cast(0); - Attributes::NtpServerPort::TypeInfo::DecodableType ntpServerPort; + Attributes::TimeZoneDatabase::TypeInfo::DecodableType timeZoneDatabase = + static_cast(0); + Attributes::NTPServerAvailable::TypeInfo::DecodableType NTPServerAvailable = static_cast(0); + Attributes::TimeZoneListMaxSize::TypeInfo::DecodableType timeZoneListMaxSize = static_cast(0); + Attributes::DSTOffsetListMaxSize::TypeInfo::DecodableType DSTOffsetListMaxSize = static_cast(0); + Attributes::SupportsDNSResolve::TypeInfo::DecodableType supportsDNSResolve = static_cast(0); Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; Attributes::EventList::TypeInfo::DecodableType eventList; @@ -10590,6 +10865,161 @@ struct TypeInfo }; }; } // namespace Attributes +namespace Events { +namespace DSTTableEmpty { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::DSTTableEmpty::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr bool kIsFabricScoped = false; + + 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::DSTTableEmpty::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace DSTTableEmpty +namespace DSTStatus { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kDSTOffsetActive = 0, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::DSTStatus::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr bool kIsFabricScoped = false; + + bool DSTOffsetActive = static_cast(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::DSTStatus::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + bool DSTOffsetActive = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace DSTStatus +namespace TimeZoneStatus { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kOffset = 0, + kName = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::TimeZoneStatus::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr bool kIsFabricScoped = false; + + int32_t offset = static_cast(0); + Optional name; + + 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::TimeZoneStatus::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + int32_t offset = static_cast(0); + Optional name; + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace TimeZoneStatus +namespace TimeFailure { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::TimeFailure::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr bool kIsFabricScoped = false; + + 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::TimeFailure::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace TimeFailure +namespace MissingTrustedTimeSource { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::MissingTrustedTimeSource::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + static constexpr bool kIsFabricScoped = false; + + 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::MissingTrustedTimeSource::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace MissingTrustedTimeSource +} // namespace Events } // namespace TimeSynchronization namespace BridgedDeviceBasicInformation { namespace Structs { 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 e658adbe832a81..f3027919531c3b 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 @@ -1814,13 +1814,13 @@ namespace TimeSource { static constexpr AttributeId Id = 0x00000002; } // namespace TimeSource -namespace TrustedTimeNodeId { +namespace TrustedTimeSource { static constexpr AttributeId Id = 0x00000003; -} // namespace TrustedTimeNodeId +} // namespace TrustedTimeSource -namespace DefaultNtp { +namespace DefaultNTP { static constexpr AttributeId Id = 0x00000004; -} // namespace DefaultNtp +} // namespace DefaultNTP namespace TimeZone { static constexpr AttributeId Id = 0x00000005; @@ -1838,9 +1838,21 @@ namespace TimeZoneDatabase { static constexpr AttributeId Id = 0x00000008; } // namespace TimeZoneDatabase -namespace NtpServerPort { +namespace NTPServerAvailable { static constexpr AttributeId Id = 0x00000009; -} // namespace NtpServerPort +} // namespace NTPServerAvailable + +namespace TimeZoneListMaxSize { +static constexpr AttributeId Id = 0x0000000A; +} // namespace TimeZoneListMaxSize + +namespace DSTOffsetListMaxSize { +static constexpr AttributeId Id = 0x0000000B; +} // namespace DSTOffsetListMaxSize + +namespace SupportsDNSResolve { +static constexpr AttributeId Id = 0x0000000C; +} // namespace SupportsDNSResolve namespace GeneratedCommandList { static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id; 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 6699a225a48b1f..b8763a4db4024d 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 @@ -480,9 +480,29 @@ static constexpr CommandId Id = 0x00000000; namespace TimeSynchronization { namespace Commands { -namespace SetUtcTime { +namespace SetUTCTime { static constexpr CommandId Id = 0x00000000; -} // namespace SetUtcTime +} // namespace SetUTCTime + +namespace SetTrustedTimeSource { +static constexpr CommandId Id = 0x00000001; +} // namespace SetTrustedTimeSource + +namespace SetTimeZone { +static constexpr CommandId Id = 0x00000002; +} // namespace SetTimeZone + +namespace SetTimeZoneResponse { +static constexpr CommandId Id = 0x00000003; +} // namespace SetTimeZoneResponse + +namespace SetDSTOffset { +static constexpr CommandId Id = 0x00000004; +} // namespace SetDSTOffset + +namespace SetDefaultNTP { +static constexpr CommandId Id = 0x00000005; +} // namespace SetDefaultNTP } // namespace Commands } // namespace TimeSynchronization 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 743778bab8bd1f..598669e8ec2603 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 @@ -175,6 +175,32 @@ static constexpr EventId Id = 0x00000002; } // namespace Events } // namespace WiFiNetworkDiagnostics +namespace TimeSynchronization { +namespace Events { + +namespace DSTTableEmpty { +static constexpr EventId Id = 0x00000000; +} // namespace DSTTableEmpty + +namespace DSTStatus { +static constexpr EventId Id = 0x00000001; +} // namespace DSTStatus + +namespace TimeZoneStatus { +static constexpr EventId Id = 0x00000002; +} // namespace TimeZoneStatus + +namespace TimeFailure { +static constexpr EventId Id = 0x00000003; +} // namespace TimeFailure + +namespace MissingTrustedTimeSource { +static constexpr EventId Id = 0x00000004; +} // namespace MissingTrustedTimeSource + +} // namespace Events +} // namespace TimeSynchronization + namespace BridgedDeviceBasicInformation { namespace Events { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index f0cbc03189adf7..23ef97785a890b 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -2942,19 +2942,26 @@ class EthernetNetworkDiagnosticsResetCounts : public ClusterCommand | Cluster TimeSynchronization | 0x0038 | |------------------------------------------------------------------------------| | Commands: | | -| * SetUtcTime | 0x00 | +| * SetUTCTime | 0x00 | +| * SetTrustedTimeSource | 0x01 | +| * SetTimeZone | 0x02 | +| * SetDSTOffset | 0x04 | +| * SetDefaultNTP | 0x05 | |------------------------------------------------------------------------------| | Attributes: | | | * UTCTime | 0x0000 | | * Granularity | 0x0001 | | * TimeSource | 0x0002 | -| * TrustedTimeNodeId | 0x0003 | -| * DefaultNtp | 0x0004 | +| * TrustedTimeSource | 0x0003 | +| * DefaultNTP | 0x0004 | | * TimeZone | 0x0005 | | * DSTOffset | 0x0006 | | * LocalTime | 0x0007 | | * TimeZoneDatabase | 0x0008 | -| * NtpServerPort | 0x0009 | +| * NTPServerAvailable | 0x0009 | +| * TimeZoneListMaxSize | 0x000A | +| * DSTOffsetListMaxSize | 0x000B | +| * SupportsDNSResolve | 0x000C | | * GeneratedCommandList | 0xFFF8 | | * AcceptedCommandList | 0xFFF9 | | * EventList | 0xFFFA | @@ -2963,17 +2970,22 @@ class EthernetNetworkDiagnosticsResetCounts : public ClusterCommand | * ClusterRevision | 0xFFFD | |------------------------------------------------------------------------------| | Events: | | +| * DSTTableEmpty | 0x0000 | +| * DSTStatus | 0x0001 | +| * TimeZoneStatus | 0x0002 | +| * TimeFailure | 0x0003 | +| * MissingTrustedTimeSource | 0x0004 | \*----------------------------------------------------------------------------*/ /* - * Command SetUtcTime + * Command SetUTCTime */ -class TimeSynchronizationSetUtcTime : public ClusterCommand +class TimeSynchronizationSetUTCTime : public ClusterCommand { public: - TimeSynchronizationSetUtcTime(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-utc-time", credsIssuerConfig) + TimeSynchronizationSetUTCTime(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-utctime", credsIssuerConfig) { - AddArgument("UtcTime", 0, UINT64_MAX, &mRequest.utcTime); + AddArgument("UTCTime", 0, UINT64_MAX, &mRequest.UTCTime); AddArgument("Granularity", 0, UINT8_MAX, &mRequest.granularity); AddArgument("TimeSource", 0, UINT8_MAX, &mRequest.timeSource); ClusterCommand::AddArguments(); @@ -2994,7 +3006,138 @@ class TimeSynchronizationSetUtcTime : public ClusterCommand } private: - chip::app::Clusters::TimeSynchronization::Commands::SetUtcTime::Type mRequest; + chip::app::Clusters::TimeSynchronization::Commands::SetUTCTime::Type mRequest; +}; + +/* + * Command SetTrustedTimeSource + */ +class TimeSynchronizationSetTrustedTimeSource : public ClusterCommand +{ +public: + TimeSynchronizationSetTrustedTimeSource(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-trusted-time-source", credsIssuerConfig), mComplex_TrustedTimeSource(&mRequest.trustedTimeSource) + { + AddArgument("TrustedTimeSource", &mComplex_TrustedTimeSource); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000001) on endpoint %u", endpointIds.at(0)); + + return ClusterCommand::SendCommand(device, endpointIds.at(0), 0x00000038, 0x00000001, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000001) on Group %u", groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, 0x00000038, 0x00000001, mRequest); + } + +private: + chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Type mRequest; + TypedComplexArgument> + mComplex_TrustedTimeSource; +}; + +/* + * Command SetTimeZone + */ +class TimeSynchronizationSetTimeZone : public ClusterCommand +{ +public: + TimeSynchronizationSetTimeZone(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-time-zone", credsIssuerConfig), mComplex_TimeZone(&mRequest.timeZone) + { + AddArgument("TimeZone", &mComplex_TimeZone); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000002) on endpoint %u", endpointIds.at(0)); + + return ClusterCommand::SendCommand(device, endpointIds.at(0), 0x00000038, 0x00000002, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000002) on Group %u", groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, 0x00000038, 0x00000002, mRequest); + } + +private: + chip::app::Clusters::TimeSynchronization::Commands::SetTimeZone::Type mRequest; + TypedComplexArgument> + mComplex_TimeZone; +}; + +/* + * Command SetDSTOffset + */ +class TimeSynchronizationSetDSTOffset : public ClusterCommand +{ +public: + TimeSynchronizationSetDSTOffset(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-dstoffset", credsIssuerConfig), mComplex_DSTOffset(&mRequest.DSTOffset) + { + AddArgument("DSTOffset", &mComplex_DSTOffset); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000004) on endpoint %u", endpointIds.at(0)); + + return ClusterCommand::SendCommand(device, endpointIds.at(0), 0x00000038, 0x00000004, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000004) on Group %u", groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, 0x00000038, 0x00000004, mRequest); + } + +private: + chip::app::Clusters::TimeSynchronization::Commands::SetDSTOffset::Type mRequest; + TypedComplexArgument> + mComplex_DSTOffset; +}; + +/* + * Command SetDefaultNTP + */ +class TimeSynchronizationSetDefaultNTP : public ClusterCommand +{ +public: + TimeSynchronizationSetDefaultNTP(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-default-ntp", credsIssuerConfig) + { + AddArgument("DefaultNTP", &mRequest.defaultNTP); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000005) on endpoint %u", endpointIds.at(0)); + + return ClusterCommand::SendCommand(device, endpointIds.at(0), 0x00000038, 0x00000005, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + ChipLogProgress(chipTool, "Sending cluster (0x00000038) command (0x00000005) on Group %u", groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, 0x00000038, 0x00000005, mRequest); + } + +private: + chip::app::Clusters::TimeSynchronization::Commands::SetDefaultNTP::Type mRequest; }; /*----------------------------------------------------------------------------*\ @@ -11008,53 +11151,66 @@ void registerClusterTimeSynchronization(Commands & commands, CredentialIssuerCom // // Commands // - make_unique(Id, credsIssuerConfig), // - make_unique(credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // // // Attributes // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, "utctime", Attributes::UTCTime::Id, credsIssuerConfig), // - make_unique(Id, "granularity", Attributes::Granularity::Id, credsIssuerConfig), // - make_unique(Id, "time-source", Attributes::TimeSource::Id, credsIssuerConfig), // - make_unique(Id, "trusted-time-node-id", Attributes::TrustedTimeNodeId::Id, credsIssuerConfig), // - make_unique(Id, "default-ntp", Attributes::DefaultNtp::Id, credsIssuerConfig), // - make_unique(Id, "time-zone", Attributes::TimeZone::Id, credsIssuerConfig), // - make_unique(Id, "dstoffset", Attributes::DSTOffset::Id, credsIssuerConfig), // - make_unique(Id, "local-time", Attributes::LocalTime::Id, credsIssuerConfig), // - make_unique(Id, "time-zone-database", Attributes::TimeZoneDatabase::Id, credsIssuerConfig), // - make_unique(Id, "ntp-server-port", Attributes::NtpServerPort::Id, credsIssuerConfig), // - make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // - make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // - make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // - make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // - make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // - make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // - make_unique>(Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "utctime", Attributes::UTCTime::Id, credsIssuerConfig), // + make_unique(Id, "granularity", Attributes::Granularity::Id, credsIssuerConfig), // + make_unique(Id, "time-source", Attributes::TimeSource::Id, credsIssuerConfig), // + make_unique(Id, "trusted-time-source", Attributes::TrustedTimeSource::Id, credsIssuerConfig), // + make_unique(Id, "default-ntp", Attributes::DefaultNTP::Id, credsIssuerConfig), // + make_unique(Id, "time-zone", Attributes::TimeZone::Id, credsIssuerConfig), // + make_unique(Id, "dstoffset", Attributes::DSTOffset::Id, credsIssuerConfig), // + make_unique(Id, "local-time", Attributes::LocalTime::Id, credsIssuerConfig), // + make_unique(Id, "time-zone-database", Attributes::TimeZoneDatabase::Id, credsIssuerConfig), // + make_unique(Id, "ntpserver-available", Attributes::NTPServerAvailable::Id, credsIssuerConfig), // + make_unique(Id, "time-zone-list-max-size", Attributes::TimeZoneListMaxSize::Id, credsIssuerConfig), // + make_unique(Id, "dstoffset-list-max-size", Attributes::DSTOffsetListMaxSize::Id, credsIssuerConfig), // + make_unique(Id, "supports-dnsresolve", Attributes::SupportsDNSResolve::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + make_unique>(Id, credsIssuerConfig), // make_unique>>(Id, "utctime", 0, UINT64_MAX, Attributes::UTCTime::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>( Id, "granularity", 0, UINT8_MAX, Attributes::Granularity::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>( Id, "time-source", 0, UINT8_MAX, Attributes::TimeSource::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // - make_unique>>(Id, "trusted-time-node-id", 0, UINT64_MAX, - Attributes::TrustedTimeNodeId::Id, - WriteCommandType::kWrite, credsIssuerConfig), // - make_unique>>(Id, "default-ntp", Attributes::DefaultNtp::Id, - WriteCommandType::kWrite, credsIssuerConfig), // + make_unique>>( + Id, "trusted-time-source", Attributes::TrustedTimeSource::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "default-ntp", Attributes::DefaultNTP::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>>( - Id, "time-zone", Attributes::TimeZone::Id, WriteCommandType::kWrite, credsIssuerConfig), // + Id, "time-zone", Attributes::TimeZone::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>>( - Id, "dstoffset", Attributes::DSTOffset::Id, WriteCommandType::kWrite, credsIssuerConfig), // + Id, "dstoffset", Attributes::DSTOffset::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>>( Id, "local-time", 0, UINT64_MAX, Attributes::LocalTime::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // - make_unique>(Id, "time-zone-database", 0, 1, Attributes::TimeZoneDatabase::Id, + make_unique>( + Id, "time-zone-database", 0, UINT8_MAX, Attributes::TimeZoneDatabase::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>(Id, "ntpserver-available", 0, 1, Attributes::NTPServerAvailable::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "time-zone-list-max-size", 0, UINT8_MAX, Attributes::TimeZoneListMaxSize::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "dstoffset-list-max-size", 0, UINT8_MAX, Attributes::DSTOffsetListMaxSize::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "supports-dnsresolve", 0, 1, Attributes::SupportsDNSResolve::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // - make_unique>>(Id, "ntp-server-port", 0, UINT16_MAX, - Attributes::NtpServerPort::Id, - WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>>( Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // @@ -11067,29 +11223,42 @@ void registerClusterTimeSynchronization(Commands & commands, CredentialIssuerCom make_unique>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id, - WriteCommandType::kForceWrite, credsIssuerConfig), // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, "utctime", Attributes::UTCTime::Id, credsIssuerConfig), // - make_unique(Id, "granularity", Attributes::Granularity::Id, credsIssuerConfig), // - make_unique(Id, "time-source", Attributes::TimeSource::Id, credsIssuerConfig), // - make_unique(Id, "trusted-time-node-id", Attributes::TrustedTimeNodeId::Id, credsIssuerConfig), // - make_unique(Id, "default-ntp", Attributes::DefaultNtp::Id, credsIssuerConfig), // - make_unique(Id, "time-zone", Attributes::TimeZone::Id, credsIssuerConfig), // - make_unique(Id, "dstoffset", Attributes::DSTOffset::Id, credsIssuerConfig), // - make_unique(Id, "local-time", Attributes::LocalTime::Id, credsIssuerConfig), // - make_unique(Id, "time-zone-database", Attributes::TimeZoneDatabase::Id, credsIssuerConfig), // - make_unique(Id, "ntp-server-port", Attributes::NtpServerPort::Id, credsIssuerConfig), // - make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // - make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // - make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // - make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // - make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // - make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "utctime", Attributes::UTCTime::Id, credsIssuerConfig), // + make_unique(Id, "granularity", Attributes::Granularity::Id, credsIssuerConfig), // + make_unique(Id, "time-source", Attributes::TimeSource::Id, credsIssuerConfig), // + make_unique(Id, "trusted-time-source", Attributes::TrustedTimeSource::Id, credsIssuerConfig), // + make_unique(Id, "default-ntp", Attributes::DefaultNTP::Id, credsIssuerConfig), // + make_unique(Id, "time-zone", Attributes::TimeZone::Id, credsIssuerConfig), // + make_unique(Id, "dstoffset", Attributes::DSTOffset::Id, credsIssuerConfig), // + make_unique(Id, "local-time", Attributes::LocalTime::Id, credsIssuerConfig), // + make_unique(Id, "time-zone-database", Attributes::TimeZoneDatabase::Id, credsIssuerConfig), // + make_unique(Id, "ntpserver-available", Attributes::NTPServerAvailable::Id, credsIssuerConfig), // + make_unique(Id, "time-zone-list-max-size", Attributes::TimeZoneListMaxSize::Id, credsIssuerConfig), // + make_unique(Id, "dstoffset-list-max-size", Attributes::DSTOffsetListMaxSize::Id, credsIssuerConfig), // + make_unique(Id, "supports-dnsresolve", Attributes::SupportsDNSResolve::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // // // Events // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "dsttable-empty", Events::DSTTableEmpty::Id, credsIssuerConfig), // + make_unique(Id, "dststatus", Events::DSTStatus::Id, credsIssuerConfig), // + make_unique(Id, "time-zone-status", Events::TimeZoneStatus::Id, credsIssuerConfig), // + make_unique(Id, "time-failure", Events::TimeFailure::Id, credsIssuerConfig), // + make_unique(Id, "missing-trusted-time-source", Events::MissingTrustedTimeSource::Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "dsttable-empty", Events::DSTTableEmpty::Id, credsIssuerConfig), // + make_unique(Id, "dststatus", Events::DSTStatus::Id, credsIssuerConfig), // + make_unique(Id, "time-zone-status", Events::TimeZoneStatus::Id, credsIssuerConfig), // + make_unique(Id, "time-failure", Events::TimeFailure::Id, credsIssuerConfig), // + make_unique(Id, "missing-trusted-time-source", Events::MissingTrustedTimeSource::Id, credsIssuerConfig), // }; commands.Register(clusterName, clusterCommands); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp index e4aa5a34e4b89d..5ce59a33759a42 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp @@ -1358,6 +1358,40 @@ void ComplexArgumentParser::Finalize(chip::app::Clusters::TimeSynchronization::S ComplexArgumentParser::Finalize(request.validUntil); } +CHIP_ERROR +ComplexArgumentParser::Setup(const char * label, + chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::Type & request, + Json::Value & value) +{ + VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT); + + // Copy to track which members we already processed. + Json::Value valueCopy(value); + + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("FabricScopedTrustedTimeSourceStruct.nodeID", "nodeID", value.isMember("nodeID"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("FabricScopedTrustedTimeSourceStruct.endpoint", "endpoint", + value.isMember("endpoint"))); + + char labelWithMember[kMaxLabelLength]; + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nodeID"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nodeID, value["nodeID"])); + valueCopy.removeMember("nodeID"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoint"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoint, value["endpoint"])); + valueCopy.removeMember("endpoint"); + + return ComplexArgumentParser::EnsureNoMembersRemaining(label, valueCopy); +} + +void ComplexArgumentParser::Finalize( + chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::Type & request) +{ + ComplexArgumentParser::Finalize(request.nodeID); + ComplexArgumentParser::Finalize(request.endpoint); +} + CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::Type & request, Json::Value & value) @@ -1396,6 +1430,45 @@ void ComplexArgumentParser::Finalize(chip::app::Clusters::TimeSynchronization::S ComplexArgumentParser::Finalize(request.name); } +CHIP_ERROR ComplexArgumentParser::Setup(const char * label, + chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::Type & request, + Json::Value & value) +{ + VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT); + + // Copy to track which members we already processed. + Json::Value valueCopy(value); + + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TrustedTimeSourceStruct.fabricIndex", "fabricIndex", + value.isMember("fabricIndex"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("TrustedTimeSourceStruct.nodeID", "nodeID", value.isMember("nodeID"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("TrustedTimeSourceStruct.endpoint", "endpoint", value.isMember("endpoint"))); + + char labelWithMember[kMaxLabelLength]; + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"])); + valueCopy.removeMember("fabricIndex"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nodeID"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nodeID, value["nodeID"])); + valueCopy.removeMember("nodeID"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoint"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoint, value["endpoint"])); + valueCopy.removeMember("endpoint"); + + return ComplexArgumentParser::EnsureNoMembersRemaining(label, valueCopy); +} + +void ComplexArgumentParser::Finalize(chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::Type & request) +{ + ComplexArgumentParser::Finalize(request.fabricIndex); + ComplexArgumentParser::Finalize(request.nodeID); + ComplexArgumentParser::Finalize(request.endpoint); +} + CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::Type & request, diff --git a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h index fb84db01015080..38c67265a1bbc5 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h @@ -167,11 +167,23 @@ static CHIP_ERROR Setup(const char * label, chip::app::Clusters::TimeSynchroniza static void Finalize(chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::Type & request); +static CHIP_ERROR Setup(const char * label, + chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::Type & request, + Json::Value & value); + +static void Finalize(chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::Type & request); + static CHIP_ERROR Setup(const char * label, chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::Type & request, Json::Value & value); static void Finalize(chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::Type & request); +static CHIP_ERROR Setup(const char * label, + chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::Type & request, + Json::Value & value); + +static void Finalize(chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::Type & request); + static CHIP_ERROR Setup(const char * label, chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::Type & request, Json::Value & value); 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 46ccdd27881a2b..c46841fe3ea27f 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -1249,6 +1249,32 @@ 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::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("NodeID", indent + 1, value.nodeID); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'NodeID'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Endpoint", indent + 1, value.endpoint); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Endpoint'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::DecodableType & value) { @@ -1282,6 +1308,40 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR +DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("FabricIndex", indent + 1, value.fabricIndex); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'FabricIndex'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("NodeID", indent + 1, value.nodeID); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'NodeID'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Endpoint", indent + 1, value.endpoint); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Endpoint'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + CHIP_ERROR DataModelLogger::LogValue( const char * label, size_t indent, const chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::DecodableType & value) @@ -3150,6 +3210,70 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const TimeSynchronization::Events::DSTTableEmpty::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const TimeSynchronization::Events::DSTStatus::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("DSTOffsetActive", indent + 1, value.DSTOffsetActive); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'DSTOffsetActive'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const TimeSynchronization::Events::TimeZoneStatus::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("Offset", indent + 1, value.offset); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Offset'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("Name", indent + 1, value.name); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Name'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const TimeSynchronization::Events::TimeFailure::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const TimeSynchronization::Events::MissingTrustedTimeSource::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const BridgedDeviceBasicInformation::Events::StartUp::DecodableType & value) { 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 81d723c231777c..a1a038ba506b0b 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -107,9 +107,16 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::DecodableType & value); +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::DecodableType & value); + static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::DecodableType & value); + static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::DecodableType & value); @@ -254,6 +261,16 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::WiFiNetworkDiagnostics::Events::AssociationFailure::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::WiFiNetworkDiagnostics::Events::ConnectionStatus::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Events::DSTTableEmpty::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Events::DSTStatus::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Events::TimeZoneStatus::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Events::TimeFailure::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::TimeSynchronization::Events::MissingTrustedTimeSource::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::BridgedDeviceBasicInformation::Events::StartUp::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent,