feat(weather): add native iOS widget weather refresh

.github/workflows/ci.yml

@@ -161,6 +161,9 @@ jobs:
       - name: Build info
         run: bash tool/check/build_info.sh
 
+      - name: Widget township resources
+        run: bash tool/check/widget_township_resources.sh
+
       - name: Codegen is up to date
         run: |
           bash tool/dev/codegen.sh

ios/DPIPWidgetIntentsExtension/IntentHandler.swift

@@ -7,6 +7,12 @@ final class IntentHandler: INExtension,
         return self
     }
 
+    func defaultLocation(
+        for intent: WeatherWidgetConfigurationIntent
+    ) -> WidgetLocation? {
+        makeCurrentWidgetLocation()
+    }
+
     func provideLocationOptionsCollection(
         for intent: WeatherWidgetConfigurationIntent,
         with completion: @escaping (
@@ -15,11 +21,6 @@ final class IntentHandler: INExtension,
         ) -> Void
     ) {
         let catalog = WidgetLocationCatalogStore().load()
-        let currentLocationDisplayString = String(
-            localized: "intent.current_location",
-            bundle: .main,
-            comment: "Current-location option in weather widget configuration."
-        )
 
         let locations = makeWidgetLocationOptions(
             from: catalog,
@@ -36,4 +37,22 @@ final class IntentHandler: INExtension,
             nil
         )
     }
+
+    private func makeCurrentWidgetLocation() -> WidgetLocation {
+        let option = makeCurrentWidgetLocationOption(
+            displayString: currentLocationDisplayString
+        )
+        return WidgetLocation(
+            identifier: option.identifier,
+            display: option.displayString
+        )
+    }
+
+    private var currentLocationDisplayString: String {
+        String(
+            localized: "intent.current_location",
+            bundle: .main,
+            comment: "Current-location option in weather widget configuration."
+        )
+    }
 }

ios/DPIPWidgetIntentsExtension/WidgetLocationOptions.swift

@@ -5,13 +5,21 @@ struct WidgetLocationOption: Equatable {
     let displayString: String
 }
 
+func makeCurrentWidgetLocationOption(
+    displayString: String
+) -> WidgetLocationOption {
+    WidgetLocationOption(
+        identifier: "current-location",
+        displayString: displayString
+    )
+}
+
 func makeWidgetLocationOptions(
     from catalog: WidgetLocationCatalog?,
     currentLocationDisplayString: String
 ) -> [WidgetLocationOption] {
     var options = [
-        WidgetLocationOption(
-            identifier: "current-location",
+        makeCurrentWidgetLocationOption(
             displayString: currentLocationDisplayString
         )
     ]

ios/DPIPWidgets/CurrentLocationCurrentWeatherWidgetRefreshService.swift

@@ -0,0 +1,100 @@
+struct CurrentLocationCurrentWeatherWidgetRefreshService: Sendable {
+    typealias AcquireLocation = @MainActor @Sendable () async
+        -> WidgetCurrentLocationResult
+    typealias ResolveTownship = @Sendable (
+        WidgetCurrentLocation
+    ) -> WidgetResolvedWeatherLocation?
+    typealias BeginWrite = @Sendable (
+        CurrentWeatherSnapshotAddress
+    ) throws -> CurrentWeatherSnapshotWriteToken
+
+    private let acquireLocation: AcquireLocation
+    private let resolveTownship: ResolveTownship
+    private let beginWrite: BeginWrite
+    private let pipeline: CurrentWeatherWidgetRefreshPipeline
+
+    init(
+        acquireLocation: @escaping AcquireLocation,
+        resolver: WidgetTownshipResolver,
+        weatherClient: CurrentWeatherClient,
+        clock: WidgetServerClock,
+        writer: CurrentWeatherWidgetSnapshotWriter
+    ) {
+        self.init(
+            acquireLocation: acquireLocation,
+            resolveTownship: { currentLocation in
+                resolver.resolve(currentLocation)
+            },
+            beginWrite: { address in
+                try writer.beginWrite(for: address)
+            },
+            pipeline: CurrentWeatherWidgetRefreshPipeline(
+                weatherClient: weatherClient,
+                clock: clock,
+                writer: writer
+            )
+        )
+    }
+
+    init(
+        acquireLocation: @escaping AcquireLocation,
+        resolveTownship: @escaping ResolveTownship,
+        beginWrite: @escaping BeginWrite,
+        pipeline: CurrentWeatherWidgetRefreshPipeline
+    ) {
+        self.acquireLocation = acquireLocation
+        self.resolveTownship = resolveTownship
+        self.beginWrite = beginWrite
+        self.pipeline = pipeline
+    }
+
+    func refresh() async -> CurrentWeatherWidgetRefreshResult {
+        let writeToken: CurrentWeatherSnapshotWriteToken
+        do {
+            writeToken = try beginWrite(.currentLocation)
+        } catch {
+            return .failed
+        }
+
+        #if DEBUG
+        WidgetWeatherRefreshDiagnostics.log(
+            "current location acquisition started"
+        )
+        #endif
+
+        let currentLocationResult = await acquireLocation()
+        let currentLocation: WidgetCurrentLocation
+        switch currentLocationResult {
+        case .acquired(let acquiredLocation):
+            currentLocation = acquiredLocation
+        case .unavailable, .timedOut:
+            return .unavailable
+        case .failed:
+            return .failed
+        }
+
+        #if DEBUG
+        WidgetWeatherRefreshDiagnostics.log("township resolution started")
+        #endif
+        guard let location = resolveTownship(currentLocation),
+              location.address == .currentLocation
+        else {
+            #if DEBUG
+            WidgetWeatherRefreshDiagnostics.log(
+                "township resolution unavailable"
+            )
+            #endif
+            return .unavailable
+        }
+        #if DEBUG
+        WidgetWeatherRefreshDiagnostics.log(
+            "township resolved regionCode=\(location.regionCode)"
+        )
+        #endif
+
+        return await pipeline.refresh(
+            location: location,
+            writeToken: writeToken
+        )
+    }
+}

ios/DPIPWidgets/CurrentWeatherClient.swift

@@ -0,0 +1,87 @@
+import Foundation
+
+enum CurrentWeatherClientError: Error, Equatable {
+    case invalidCoordinate
+    case invalidURL
+    case invalidResponse
+    case httpStatus(Int)
+    case responseTooLarge
+}
+
+struct CurrentWeatherClient: Sendable {
+    private static let scheme = "https"
+    private static let host = "api.core-tnn1.exptech.dev"
+    private static let realtimePath = "/api/v5/meteor/weather/realtime"
+
+    private static let requestTimeout: TimeInterval = 6
+    private static let maximumResponseSize = 128 * 1024
+
+    private let session: URLSession
+
+    init(session: URLSession = .shared) {
+        self.session = session
+    }
+
+    func makeURL(latitude: Double, longitude: Double) throws -> URL {
+        guard latitude.isFinite,
+              longitude.isFinite,
+              (-90.0...90.0).contains(latitude),
+              (-180.0...180.0).contains(longitude)
+        else {
+            throw CurrentWeatherClientError.invalidCoordinate
+        }
+
+        var components = URLComponents()
+        components.scheme = Self.scheme
+        components.host = Self.host
+        components.path = "\(Self.realtimePath)/\(latitude),\(longitude)"
+
+        guard let url = components.url else {
+            throw CurrentWeatherClientError.invalidURL
+        }
+
+        return url
+    }
+
+    func fetch(
+        latitude: Double,
+        longitude: Double
+    ) async throws -> CurrentWeatherRemoteDTO? {
+        let url = try makeURL(
+            latitude: latitude,
+            longitude: longitude
+        )
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.requestTimeout
+
+        let (data, response) = try await session.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw CurrentWeatherClientError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            throw CurrentWeatherClientError.httpStatus(
+                httpResponse.statusCode
+            )
+        }
+
+        guard data.count <= Self.maximumResponseSize else {
+            throw CurrentWeatherClientError.responseTooLarge
+        }
+
+        let jsonObject = try JSONSerialization.jsonObject(with: data)
+
+        if let object = jsonObject as? [String: Any],
+           object.isEmpty {
+            return nil
+        }
+
+        return try JSONDecoder().decode(
+            CurrentWeatherRemoteDTO.self,
+            from: data
+        )
+    }
+}