Set more than one DST offset in MTRDevice if the server supports that.

bzbarsky-apple · bzbarsky-apple · commit 262d1f71ce8d · 2024-03-14T15:12:26.000-04:00
This way when the next DST transition happens, the device won't be confused
about the local time.
diff --git a/src/darwin/Framework/CHIP/MTRDefines_Internal.h b/src/darwin/Framework/CHIP/MTRDefines_Internal.h
@@ -34,6 +34,12 @@
 #define MTR_TESTABLE
 #endif
 
+#ifdef DEBUG
+#define MTR_TESTABLE_FUNC MTR_EXTERN
+#else
+#define MTR_TESTABLE_FUNC
+#endif
+
 // clang-format off
 /// Creates a weak shadow copy of the variable `local`
 #define mtr_weakify(local)                                      \
diff --git a/src/darwin/Framework/CHIP/MTRDevice.mm b/src/darwin/Framework/CHIP/MTRDevice.mm
@@ -33,6 +33,7 @@
 #import "MTRError_Internal.h"
 #import "MTREventTLVValueDecoder_Internal.h"
 #import "MTRLogging_Internal.h"
+#import "MTRTimeUtils.h"
 #import "MTRUnfairLock.h"
 #import "zap-generated/MTRCommandPayloads_Internal.h"
 
@@ -270,41 +271,50 @@ - (void)_setTimeOnDevice
         return;
     }
 
-    NSTimeZone * localTimeZone = [NSTimeZone localTimeZone];
-    BOOL setDST = TRUE;
-    if (!localTimeZone) {
-        MTR_LOG_ERROR("%@ Could not retrieve local time zone. Unable to setDSTOffset on endpoints.", self);
-        setDST = FALSE;
-    }
-
     uint64_t matterEpochTimeMicroseconds = 0;
-    uint64_t nextDSTInMatterEpochTimeMicroseconds = 0;
     if (!DateToMatterEpochMicroseconds(now, matterEpochTimeMicroseconds)) {
         MTR_LOG_ERROR("%@ Could not convert NSDate (%@) to Matter Epoch Time. Unable to setUTCTime on endpoints.", self, now);
         return;
     }
 
-    int32_t dstOffset = 0;
-    if (setDST) {
-        NSTimeInterval dstOffsetAsInterval = [localTimeZone daylightSavingTimeOffsetForDate:now];
-        dstOffset = int32_t(dstOffsetAsInterval);
-
-        // Calculate time to next DST. This is needed when we set the current DST.
-        NSDate * nextDSTTransitionDate = [localTimeZone nextDaylightSavingTimeTransition];
-        if (!DateToMatterEpochMicroseconds(nextDSTTransitionDate, nextDSTInMatterEpochTimeMicroseconds)) {
-            MTR_LOG_ERROR("%@ Could not convert NSDate (%@) to Matter Epoch Time. Unable to setDSTOffset on endpoints.", self, nextDSTTransitionDate);
-            setDST = FALSE;
-        }
-    }
-
     // Set Time on each Endpoint with a Time Synchronization Cluster Server
     NSArray<NSNumber *> * endpointsToSync = [self _endpointsWithTimeSyncClusterServer];
     for (NSNumber * endpoint in endpointsToSync) {
         MTR_LOG_DEBUG("%@ Setting Time on Endpoint %@", self, endpoint);
         [self _setUTCTime:matterEpochTimeMicroseconds withGranularity:MTRTimeSynchronizationGranularityMicrosecondsGranularity forEndpoint:endpoint];
-        if (setDST) {
-            [self _setDSTOffset:dstOffset validStarting:0 validUntil:nextDSTInMatterEpochTimeMicroseconds forEndpoint:endpoint];
+
+        // Check how many DST offsets this endpoint supports.
+        auto dstOffsetsMaxSizePath = [MTRAttributePath attributePathWithEndpointID:endpoint clusterID:@(MTRClusterIDTypeTimeSynchronizationID) attributeID:@(MTRAttributeIDTypeClusterTimeSynchronizationAttributeDSTOffsetListMaxSizeID)];
+        auto dstOffsetsMaxSize = [self readAttributeWithEndpointID:dstOffsetsMaxSizePath.endpoint clusterID:dstOffsetsMaxSizePath.cluster attributeID:dstOffsetsMaxSizePath.attribute params:nil];
+        if (dstOffsetsMaxSize == nil) {
+            // This endpoint does not support TZ, so won't support SetDSTOffset.
+            MTR_LOG_DEFAULT("%@ Unable to SetDSTOffset on endpoint %@, since it does not support the TZ feature", self, endpoint);
+            continue;
         }
+        auto attrReport = [[MTRAttributeReport alloc] initWithResponseValue:@{
+            MTRAttributePathKey : dstOffsetsMaxSizePath,
+            MTRDataKey : dstOffsetsMaxSize,
+        }
+                                                                      error:nil];
+        uint8_t maxOffsetCount;
+        if (attrReport == nil) {
+            MTR_LOG_ERROR("%@ DSTOffsetListMaxSize value on endpoint %@ is invalid. Defaulting to 1.", self, endpoint);
+            maxOffsetCount = 1;
+        } else {
+            NSNumber * maxOffsetCountAsNumber = attrReport.value;
+            maxOffsetCount = maxOffsetCountAsNumber.unsignedCharValue;
+            if (maxOffsetCount == 0) {
+                MTR_LOG_ERROR("%@ DSTOffsetListMaxSize value on endpoint %@ is 0, which is not allowed. Defaulting to 1.", self, endpoint);
+                maxOffsetCount = 1;
+            }
+        }
+        auto * dstOffsets = MTRComputeDSTOffsets(maxOffsetCount);
+        if (dstOffsets == nil) {
+            MTR_LOG_ERROR("%@ Could not retrieve DST offset information. Unable to setDSTOffset on endpoint %@.", self, endpoint);
+            continue;
+        }
+
+        [self _setDSTOffsets:dstOffsets forEndpoint:endpoint];
     }
 }
 
@@ -410,23 +420,18 @@ - (void)_setUTCTime:(UInt64)matterEpochTime withGranularity:(uint8_t)granularity
                                  completion:setUTCTimeResponseHandler];
 }
 
-- (void)_setDSTOffset:(int32_t)dstOffset validStarting:(uint64_t)validStarting validUntil:(uint64_t)validUntil forEndpoint:(NSNumber *)endpoint
+- (void)_setDSTOffsets:(NSArray<MTRTimeSynchronizationClusterDSTOffsetStruct *> *)dstOffsets forEndpoint:(NSNumber *)endpoint
 {
-    MTR_LOG_DEBUG("%@ _setDSTOffset with offset: %d, validStarting: %llu, validUntil: %llu, endpoint %@",
-        self,
-        dstOffset, validStarting, validUntil, endpoint);
+    MTR_LOG_DEBUG("%@ _setDSTOffsets with offsets: %@, endpoint %@",
+        self, dstOffsets, endpoint);
 
     MTRTimeSynchronizationClusterSetDSTOffsetParams * params = [[MTRTimeSynchronizationClusterSetDSTOffsetParams
         alloc] init];
-    MTRTimeSynchronizationClusterDSTOffsetStruct * dstOffsetStruct = [[MTRTimeSynchronizationClusterDSTOffsetStruct alloc] init];
-    dstOffsetStruct.offset = @(dstOffset);
-    dstOffsetStruct.validStarting = @(validStarting);
-    dstOffsetStruct.validUntil = @(validUntil);
-    params.dstOffset = @[ dstOffsetStruct ];
+    params.dstOffset = dstOffsets;
 
     auto setDSTOffsetResponseHandler = ^(id _Nullable response, NSError * _Nullable error) {
         if (error) {
-            MTR_LOG_ERROR("%@ _setDSTOffset failed on endpoint %@, with parameters %@, error: %@", self, endpoint, params, error);
+            MTR_LOG_ERROR("%@ _setDSTOffsets failed on endpoint %@, with parameters %@, error: %@", self, endpoint, params, error);
         }
     };
 
diff --git a/src/darwin/Framework/CHIP/MTRDeviceController.mm b/src/darwin/Framework/CHIP/MTRDeviceController.mm
@@ -44,6 +44,7 @@
 #import "MTRPersistentStorageDelegateBridge.h"
 #import "MTRServerEndpoint_Internal.h"
 #import "MTRSetupPayload.h"
+#import "MTRTimeUtils.h"
 #import "NSDataSpanConversion.h"
 #import "NSStringSpanConversion.h"
 #import <setup_payload/ManualSetupPayloadGenerator.h>
@@ -737,40 +738,34 @@ - (BOOL)commissionNodeWithID:(NSNumber *)nodeID
         // to add, but in practice devices likely support only 2 and
         // AutoCommissioner caps the list at 10.  Let's do up to 4 transitions
         // for now.
+        constexpr size_t dstOffsetMaxCount = 4;
         using DSTOffsetType = chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::Type;
-
-        DSTOffsetType dstOffsets[4];
-        size_t dstOffsetCount = 0;
-        auto nextOffset = tz.daylightSavingTimeOffset;
-        uint64_t nextValidStarting = 0;
-        auto * nextTransition = tz.nextDaylightSavingTimeTransition;
-        for (auto & dstOffset : dstOffsets) {
-            ++dstOffsetCount;
-            dstOffset.offset = static_cast<int32_t>(nextOffset);
-            dstOffset.validStarting = nextValidStarting;
-            if (nextTransition != nil) {
-                uint32_t transitionEpochS;
-                if (DateToMatterEpochSeconds(nextTransition, transitionEpochS)) {
-                    using Microseconds64 = chip::System::Clock::Microseconds64;
-                    using Seconds32 = chip::System::Clock::Seconds32;
-                    dstOffset.validUntil.SetNonNull(Microseconds64(Seconds32(transitionEpochS)).count());
+        // dstOffsets needs to live long enough, so its existence is not
+        // conditional on having offsets.
+        DSTOffsetType dstOffsets[dstOffsetMaxCount];
+
+        auto * offsets = MTRComputeDSTOffsets(dstOffsetMaxCount);
+        if (offsets != nil) {
+            size_t dstOffsetCount = 0;
+            for (MTRTimeSynchronizationClusterDSTOffsetStruct * offset in offsets) {
+                if (dstOffsetCount >= dstOffsetMaxCount) {
+                    // Really shouldn't happen, but let's be extra careful about
+                    // buffer overruns.
+                    break;
+                }
+                auto & targetOffset = dstOffsets[dstOffsetCount];
+                targetOffset.offset = offset.offset.intValue;
+                targetOffset.validStarting = offset.validStarting.unsignedLongLongValue;
+                if (offset.validUntil == nil) {
+                    targetOffset.validUntil.SetNull();
                 } else {
-                    // Out of range; treat as "forever".
-                    dstOffset.validUntil.SetNull();
+                    targetOffset.validUntil.SetNonNull(offset.validUntil.unsignedLongLongValue);
                 }
-            } else {
-                dstOffset.validUntil.SetNull();
-            }
-
-            if (dstOffset.validUntil.IsNull()) {
-                break;
+                ++dstOffsetCount;
             }
 
-            nextOffset = [tz daylightSavingTimeOffsetForDate:nextTransition];
-            nextValidStarting = dstOffset.validUntil.Value();
-            nextTransition = [tz nextDaylightSavingTimeTransitionAfterDate:nextTransition];
+            params.SetDSTOffsets(chip::app::DataModel::List<DSTOffsetType>(dstOffsets, dstOffsetCount));
         }
-        params.SetDSTOffsets(chip::app::DataModel::List<DSTOffsetType>(dstOffsets, dstOffsetCount));
 
         chip::NodeId deviceId = [nodeID unsignedLongLongValue];
         self->_operationalCredentialsDelegate->SetDeviceID(deviceId);
diff --git a/src/darwin/Framework/CHIP/MTRTimeUtils.h b/src/darwin/Framework/CHIP/MTRTimeUtils.h
@@ -0,0 +1,34 @@
+/**
+ *    Copyright (c) 2024 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import <Matter/MTRDefines.h>
+#import <Matter/MTRStructsObjc.h>
+
+#import "MTRDefines_Internal.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Utility method to compute up to the given count of instances of
+ * MTRTimeSynchronizationClusterDSTOffsetStruct and return them.
+ *
+ * Returns nil on errors.
+ */
+MTR_TESTABLE_FUNC
+NSArray<MTRTimeSynchronizationClusterDSTOffsetStruct *> * _Nullable MTRComputeDSTOffsets(size_t maxCount);
+
+NS_ASSUME_NONNULL_END
diff --git a/src/darwin/Framework/CHIP/MTRTimeUtils.mm b/src/darwin/Framework/CHIP/MTRTimeUtils.mm
@@ -0,0 +1,67 @@
+/**
+ *    Copyright (c) 2024 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#import "MTRTimeUtils.h"
+#import "MTRConversion.h"
+#import "MTRLogging_Internal.h"
+
+NSArray<MTRTimeSynchronizationClusterDSTOffsetStruct *> * _Nullable MTRComputeDSTOffsets(size_t maxCount)
+{
+    auto * tz = [NSTimeZone localTimeZone];
+    if (!tz) {
+        MTR_LOG_ERROR("Could not retrieve local time zone. Unable to determine DST offsets.");
+        return nil;
+    }
+
+    NSMutableArray<MTRTimeSynchronizationClusterDSTOffsetStruct *> * retval = [NSMutableArray arrayWithCapacity:maxCount];
+
+    auto nextOffset = tz.daylightSavingTimeOffset;
+    NSNumber * nextValidStarting = @(0);
+    auto * nextTransition = tz.nextDaylightSavingTimeTransition;
+    for (size_t offsetsAdded = 0; offsetsAdded < maxCount; ++offsetsAdded) {
+        auto offset = [[MTRTimeSynchronizationClusterDSTOffsetStruct alloc] init];
+        offset.offset = @(nextOffset);
+        offset.validStarting = nextValidStarting;
+        if (nextTransition == nil) {
+            // This one is valid forever.
+            offset.validUntil = nil;
+        } else {
+            uint64_t nextTransitionEpochUs;
+            if (!DateToMatterEpochMicroseconds(nextTransition, nextTransitionEpochUs)) {
+                // Transition is somehow before Matter epoch start.  This really
+                // should not happen, but if it does just don't pretend like we
+                // know what's going on with timezones here.
+                MTR_LOG_ERROR("Future daylight savings transition is before Matter epoch start?");
+                return nil;
+            }
+
+            offset.validUntil = @(nextTransitionEpochUs);
+        }
+
+        [retval addObject:offset];
+
+        if (offset.validUntil == nil) {
+            // Valid forever, so no need for more offsets.
+            break;
+        }
+
+        nextOffset = [tz daylightSavingTimeOffsetForDate:nextTransition];
+        nextValidStarting = offset.validUntil;
+        nextTransition = [tz nextDaylightSavingTimeTransitionAfterDate:nextTransition];
+    }
+
+    return [retval copy];
+}
diff --git a/src/darwin/Framework/CHIPTests/MTRDSTOffsetTests.m b/src/darwin/Framework/CHIPTests/MTRDSTOffsetTests.m
@@ -0,0 +1,57 @@
+/*
+ *    Copyright (c) 2024 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+// module headers
+#import "MTRTimeUtils.h"
+#import <Matter/Matter.h>
+
+// system dependencies
+#import <XCTest/XCTest.h>
+
+@interface MTRDSTOffsetTests : XCTestCase
+@end
+
+@implementation MTRDSTOffsetTests
+
+- (void)test001_SingleOffset
+{
+    __auto_type * offsets = MTRComputeDSTOffsets(1);
+    // We should be able to get offsets.
+    XCTAssertNotNil(offsets);
+
+    // And there is always at least one, even if all it says is "no offset, forever".
+    XCTAssertEqual(offsets.count, 1);
+    XCTAssertEqualObjects(offsets[0].validStarting, @(0));
+}
+
+- (void)test002_TryGetting2Offsets
+{
+    __auto_type * offsets = MTRComputeDSTOffsets(2);
+    // We should be able to get offsets.
+    XCTAssertNotNil(offsets);
+
+    // And there is always at least one, even if all it says is "no offset,
+    // forever".  And we should not get too many offsets.
+    XCTAssertTrue(offsets.count >= 1);
+    XCTAssertTrue(offsets.count <= 2);
+    NSNumber * previousValidUntil = @(0);
+    for (MTRTimeSynchronizationClusterDSTOffsetStruct * offset in offsets) {
+        XCTAssertEqualObjects(previousValidUntil, offset.validStarting);
+        previousValidUntil = offset.validUntil;
+    }
+}
+
+@end
diff --git a/src/darwin/Framework/Matter.xcodeproj/project.pbxproj b/src/darwin/Framework/Matter.xcodeproj/project.pbxproj
