Streamline timers

alicerunsonfedora · alicerunsonfedora · commit bb91c637ab0a · 2025-07-29T19:09:06.000-04:00
diff --git a/Alidade.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Alidade.xcworkspace/xcshareddata/swiftpm/Package.resolved
diff --git a/MCMaps/Legacy/Views/CartographyOrnamentMap.swift b/MCMaps/Legacy/Views/CartographyOrnamentMap.swift
@@ -6,7 +6,6 @@
 //
 
 import AsyncAlgorithms
-import Combine
 import CubiomesKit
 import MCMap
 import SwiftUI
@@ -51,7 +50,7 @@ struct CartographyOrnamentMap: View {
     @State private var integrationData = [IntegrationServiceType: any CartographyIntegrationServiceData]()
     @State private var integrationFetchState = IntegrationFetchState.initial
 
-    private let bmapTimer: Publishers.Autoconnect<Timer.TimerPublisher>
+    private let clock: CartographyClock
 
     private var integrationAnnotations: [any MinecraftMapBuilderContent] {
         var annotations = [any MinecraftMapBuilderContent]()
@@ -70,9 +69,11 @@ struct CartographyOrnamentMap: View {
         self._file = file
         self._viewModel = viewModel
 
-        self.bmapTimer = Timer
-            .publish(every: file.wrappedValue.integrations.bluemap.refreshRate, on: .main, in: .common)
-            .autoconnect()
+        self.clock = CartographyClock()
+        if file.wrappedValue.integrations.bluemap.enabled {
+            clock.setupTimer(for: .bluemap, with: file.wrappedValue.integrations.bluemap.refreshRate)
+        }
+        clock.restartTimers()
     }
 
     var body: some View {
@@ -123,18 +124,18 @@ struct CartographyOrnamentMap: View {
                     }
                 }
             }
-            .onReceive(bmapTimer) { _ in
+            .onReceive(clock.bluemap) { _ in
                 Task { await updateIntegrationData() }
             }
             .onDisappear {
-                bmapTimer.upstream.connect().cancel()
+                clock.cancelTimers()
             }
         } ornaments: {
             Ornament(alignment: Constants.locationBadgePlacement) {
                 VStack(alignment: .trailing) {
                     #if os(iOS)
-                    LocationBadge(location: centerCoordinate)
-                        .environment(\.contentTransitionAddsDrawingGroup, true)
+                        LocationBadge(location: centerCoordinate)
+                            .environment(\.contentTransitionAddsDrawingGroup, true)
                         HStack {
                             Menu {
                                 Toggle(isOn: $viewModel.renderNaturalColors) {
@@ -154,12 +155,12 @@ struct CartographyOrnamentMap: View {
                             LocalTips.dimensionPicker.invalidate(reason: .actionPerformed)
                         }
                     #else
-                    HStack(spacing: 0) {
-                        IntegrationFetchStateView(state: integrationFetchState)
-                            .padding(8)
-                        LocationBadge(location: centerCoordinate)
-                            .environment(\.contentTransitionAddsDrawingGroup, true)
-                    }
+                        HStack(spacing: 0) {
+                            IntegrationFetchStateView(state: integrationFetchState)
+                                .padding(8)
+                            LocationBadge(location: centerCoordinate)
+                                .environment(\.contentTransitionAddsDrawingGroup, true)
+                        }
                     #endif
                 }
             }
diff --git a/MCMaps/Red Window/Views/Map/RedWindowMapView.swift b/MCMaps/Red Window/Views/Map/RedWindowMapView.swift
@@ -6,7 +6,6 @@
 //
 
 import AlidadeUI
-import Combine
 import CubiomesKit
 import MCMap
 import SwiftUI
@@ -52,12 +51,15 @@ struct RedWindowMapView: View {
         return annotations
     }
 
-    private let bmapTimer: Publishers.Autoconnect<Timer.TimerPublisher>
+    private let clock = CartographyClock()
 
     init(file: Binding<CartographyMapFile>) {
         self._file = file
         let bmap = file.wrappedValue.integrations.bluemap
-        self.bmapTimer = Timer.publish(every: bmap.refreshRate, tolerance: 0.5, on: .main, in: .common).autoconnect()
+        if bmap.enabled {
+            clock.setupTimer(for: .bluemap, with: bmap.refreshRate)
+        }
+        clock.restartTimers()
     }
 
     var body: some View {
@@ -91,10 +93,9 @@ struct RedWindowMapView: View {
                 await updateIntegrationData()
             }
             .onDisappear {
-                bmapTimer.upstream.connect().cancel()
-                logger.debug("⏰ Timer has been stopped.")
+                clock.cancelTimers()
             }
-            .onReceive(bmapTimer) { _ in
+            .onReceive(clock.bluemap) { _ in
                 Task { await updateIntegrationData() }
             }
             .onChange(of: env.currentDimension, initial: false) { _, _ in
diff --git a/MCMaps/Shared/Models/Bluemap/BluemapResults.swift b/MCMaps/Shared/Models/Bluemap/BluemapResults.swift
@@ -61,7 +61,7 @@ extension BluemapResults: CartographyIntegrationServiceData {
         if let markers {
             for (markerGroup, group) in markers {
                 if markerGroup == "death-markers", configuration.displayOptions.contains(.deathMarkers) {
-                    let deathMarkers = group.markers.values.map { annotation in
+                    let deathMarkers = group.markers.map { (id, annotation) in
                         Marker(
                             location: CGPoint(x: annotation.position.x, y: annotation.position.z),
                             title: annotation.label,
@@ -74,7 +74,7 @@ extension BluemapResults: CartographyIntegrationServiceData {
                     continue
                 }
 
-                let mapMarkers = group.markers.values.map { annotation in
+                let mapMarkers = group.markers.map { (id, annotation) in
                     Marker(
                         location: CGPoint(x: annotation.position.x, y: annotation.position.z),
                         title: annotation.label,
diff --git a/MCMaps/Shared/Services/CartographyClock.swift b/MCMaps/Shared/Services/CartographyClock.swift
@@ -0,0 +1,63 @@
+//
+//  CartographyClock.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 29-07-2025.
+//
+
+import Combine
+import Foundation
+import os
+
+/// A clock used to house several timers.
+///
+/// Maps and other parts of the interface might require a constant stream of updates based on a timer. Rather than
+/// creating several timers to manage, views can create a clock and subscribe to the timers they need.
+class CartographyClock {
+    /// A timer used to publish realtime data.
+    var realtime: Publishers.Autoconnect<Timer.TimerPublisher>
+
+    /// A timer used to publish data when connecting to the Bluemap service.
+    ///
+    /// If the service is disabled or hasn't been set up with ``setupTimer(for:with:)``, this will almost never fire.
+    var bluemap: Publishers.Autoconnect<Timer.TimerPublisher>
+
+    private let realtimeTimer = Timer.publish(every: 0.250, on: .main, in: .common)
+    private var bluemapTimer: Timer.TimerPublisher?
+    private let stillFrame = Timer.publish(every: .greatestFiniteMagnitude, on: .main, in: .default)
+
+    private let logger: Logger
+
+    /// Create a clock service.
+    init() {
+        logger = Logger(subsystem: "net.marquiskurt.mcmaps", category: "\(CartographyClock.self)")
+        realtime = realtimeTimer.autoconnect()
+        bluemap = stillFrame.autoconnect()
+    }
+
+    /// Set up a timer for a corresponding service integration.
+    /// - Parameter integration: The integration to set up a timer for.
+    /// - Parameter timeInterval: The duration of the timer before a new event is published.
+    func setupTimer(for integration: CartographyIntegrationService.ServiceType, with timeInterval: TimeInterval) {
+        switch integration {
+        case .bluemap:
+            bluemapTimer = Timer.publish(every: timeInterval, on: .main, in: .common)
+        }
+    }
+
+    /// Restart all the current timers.
+    func restartTimers() {
+        let still = stillFrame.autoconnect()
+        realtime = realtimeTimer.autoconnect()
+        bluemap = bluemapTimer?.autoconnect() ?? still
+        logger.debug("⏰ Timers have been restarted.")
+    }
+
+    /// Cancel all currently running timers.
+    func cancelTimers() {
+        realtimeTimer.connect().cancel()
+        bluemapTimer?.connect().cancel()
+        stillFrame.connect().cancel()
+        logger.debug("⏰ Timers have been cancelled.")
+    }
+}
diff --git a/MCMaps/Shared/Services/CartographyIntegrationService.swift b/MCMaps/Shared/Services/CartographyIntegrationService.swift
@@ -73,6 +73,22 @@ actor CartographyIntegrationService {
         case bluemap
     }
 
+    /// An enumeration of the types of sync requests.
+    enum SyncType {
+        /// Fetch data used for a regular context.
+        case regular
+
+        /// Fetch data used for realtime updates.
+        case realtime
+
+        fileprivate var logValue: String {
+            switch self {
+            case .regular: "Regular"
+            case .realtime: "Realtime"
+            }
+        }
+    }
+
     /// An enumeration of the errors that the service can throw when attempting to make requests.
     enum ServiceError: Error {
         /// The integration is disabled.
@@ -112,7 +128,8 @@ actor CartographyIntegrationService {
     /// Synchronize the current dataset from the integrations that the service supports, decoding the response.
     /// - Parameter dimension: The Minecraft world dimension to perform the synchronization operation under.
     func sync<Response: CartographyIntegrationServiceData>(
-        dimension: MinecraftWorld.Dimension
+        dimension: MinecraftWorld.Dimension,
+        syncType: SyncType = .regular
     ) async throws(ServiceError) -> Response? {
         guard integrationSettings.enabled else {
             logger.debug("☁️ Integrations are not enabled. Skipping fetch.")
@@ -121,27 +138,30 @@ actor CartographyIntegrationService {
 
         switch serviceType {
         case .bluemap:
-            self.logger.debug("☁️ Fetching data from Bluemap.")
-            let response = try await fetchBluemapData(dimension: dimension)
+            self.logger.debug("☁️ (\(syncType.logValue)) Fetching data from Bluemap.")
+            let response = try await fetchBluemapData(dimension: dimension, syncType: syncType)
             return response as? Response
         }
     }
 
-    private func fetchBluemapData(dimension: MinecraftWorld.Dimension) async throws(ServiceError) -> BluemapResults {
+    private func fetchBluemapData(
+        dimension: MinecraftWorld.Dimension,
+        syncType: SyncType = .regular
+    ) async throws(ServiceError) -> BluemapResults {
         let bluemapSettings = integrationSettings.bluemap
         guard bluemapSettings.enabled else {
-            logger.debug("☁️ Bluemap integration is not enabled. Skipping fetch.")
+            logger.debug("☁️ (\(syncType.logValue)) Bluemap integration is not enabled. Skipping fetch.")
             throw .integrationDisabled
         }
 
-        let itemsToFetch = bluemapSettings.displayOptions
+        let itemsToFetch = syncType == .realtime ? [.players] : bluemapSettings.displayOptions
         do {
             let response = await makeBluemapRequests(itemsToFetch: itemsToFetch, dimension: dimension)
             switch response {
             case .success(let results):
-                self.logger.debug("☁️ Results were fetched. Returning to sender.")
+                self.logger.debug("☁️ (\(syncType.logValue)) Results were fetched. Returning to sender.")
                 if results.isEmpty {
-                    self.logger.warning("☁️ Bluemap results don't contain anything.")
+                    self.logger.warning("☁️ (\(syncType.logValue)) Bluemap results don't contain anything.")
                 }
                 return results
             case .failure(let error):
