Refactor lifecycle and subscription handling in scenes

Moved subscription logic for candles and mids to async onAppear/onDisappear methods in both PerpetualScene and PerpetualsScene. Updated ViewModels to subscribe/unsubscribe to all periods or mids on appearance/disappearance, and removed redundant or now-unnecessary code. This improves resource management and ensures subscriptions are properly handled with SwiftUI view lifecycle.

Author: DRadmir

Features/Perpetuals/Sources/Scenes/PerpetualScene.swift

@@ -169,7 +169,12 @@ public struct PerpetualScene: View {
         .taskOnce {
             model.fetch()
         }
+        .onAppear {
+            Task { await model.onAppear() }
+        }
+        .onDisappear {
+            Task { await model.onDisappear() }
+        }
         .onChange(of: model.currentPeriod, initial: true, model.onPeriodChange)
-        .onDisappear(perform: model.onDisappear)
     }
 }

Features/Perpetuals/Sources/Scenes/PerpetualsScene.swift

@@ -44,7 +44,12 @@ public struct PerpetualsScene: View {
                 await model.fetch()
             }
         }
-        .onDisappear(perform: model.onDisappear)
+        .onAppear {
+            Task { await model.onAppear() }
+        }
+        .onDisappear {
+            Task { await model.onDisappear() }
+        }
         .refreshable {
             await model.fetch()
         }

Features/Perpetuals/Sources/Types/ChartBounds.swift

@@ -34,12 +34,11 @@ struct ChartBounds {
     }
 
     var axisFractionLength: Int {
-        switch axisStride {
-        case _ where axisStride >= 1: 0
-        case _ where axisStride >= 0.1: 1
-        case _ where axisStride >= 0.01: 2
-        case _ where axisStride >= 0.001: 3
-        case _ where axisStride >= 0.0001: 4
+        switch maxPrice {
+        case _ where maxPrice >= 1000: 0
+        case _ where maxPrice >= 0.01: 2
+        case _ where maxPrice >= 0.001: 3
+        case _ where maxPrice >= 0.0001: 4
         default: 5
         }
     }

Features/Perpetuals/Sources/ViewModels/PerpetualSceneViewModel.swift

@@ -41,8 +41,7 @@ public final class PerpetualSceneViewModel {
 
     public var state: StateViewType<[ChartCandleStick]> = .loading
     public var currentPeriod: ChartPeriod = .day
-
-    private var chartTask: Task<Void, Never>?
+    let periods: [ChartPeriod] = [.hour, .day, .week, .month, .year, .all]
 
     public var isPresentingInfoSheet: InfoSheetType?
     public var isPresentingModifyAlert: Bool?
@@ -127,33 +126,25 @@ public extension PerpetualSceneViewModel {
         }
     }
 
+    func onAppear() async {
+        await subscribeCandles()
+        await observeCandles()
+    }
+
+    func onDisappear() async {
+        await unsubscribeCandles()
+    }
+
     func onPeriodChange(_ oldPeriod: ChartPeriod, _ newPeriod: ChartPeriod) {
-        chartTask?.cancel()
-        chartTask = Task {
+        Task {
             do {
                 try await fetchCandlesticks()
-                guard !Task.isCancelled else { return }
-                await subscribeCandle()
-                if oldPeriod != newPeriod {
-                    await unsubscribeCandle(period: oldPeriod)
-                }
-                await observeCandles()
             } catch {
-                if !Task.isCancelled {
-                    state = .error(error)
-                }
+                state = .error(error)
             }
         }
     }
 
-    func onDisappear() {
-        chartTask?.cancel()
-        chartTask = nil
-        Task {
-            await unsubscribeCandle(period: currentPeriod)
-        }
-    }
-
     func onSelectFundingRateInfo() {
         isPresentingInfoSheet = .fundingRate
     }
@@ -272,15 +263,6 @@ public extension PerpetualSceneViewModel {
 // MARK: - Private
 
 private extension PerpetualSceneViewModel {
-    func unsubscribeCandle(period: ChartPeriod) async {
-        do {
-            let subscription = ChartSubscription(coin: perpetual.name, period: period)
-            try await observerService.unsubscribeCandle(subscription: subscription)
-        } catch {
-            debugLog("Chart unsubscribe failed: \(error)")
-        }
-    }
-
     func fetchCandlesticks() async throws {
         state = .loading
         let candlesticks = try await perpetualService.candlesticks(
@@ -290,16 +272,30 @@ private extension PerpetualSceneViewModel {
         state = .data(candlesticks)
     }
 
-    func subscribeCandle() async {
+    func subscribeCandles() async {
         do {
-            try await observerService.subscribeCandle(
-                subscription: .init(coin: perpetual.name, period: currentPeriod)
-            )
+            for period in periods {
+                try await observerService.subscribeCandle(
+                    subscription: ChartSubscription(coin: perpetual.name, period: period)
+                )
+            }
         } catch {
             debugLog("Chart subscription failed: \(error)")
         }
     }
 
+    func unsubscribeCandles() async {
+        do {
+            for period in periods {
+                try await observerService.unsubscribeCandle(
+                    subscription: ChartSubscription(coin: perpetual.name, period: period)
+                )
+            }
+        } catch {
+            debugLog("Chart unsubscribe failed: \(error)")
+        }
+    }
+
     func observeCandles() async {
         for await candle in await observerService.chartService.makeStream() {
             handleChartUpdate(candle)

Features/Perpetuals/Sources/ViewModels/PerpetualsSceneViewModel.swift

@@ -89,20 +89,39 @@ public final class PerpetualsSceneViewModel {
             balance: walletBalance
         )
     }
+    
+    // MARK: - Private
+
+    private func subscribeAllMids() async {
+        do {
+            try await observerService.subscribeAllMids()
+        } catch {
+            debugLog("AllMids subscribe failed: \(error)")
+        }
+    }
+
+    private func unsubscribeAllMids() async {
+        do {
+            try await observerService.unsubscribeAllMids()
+        } catch {
+            debugLog("AllMids unsubscribe failed: \(error)")
+        }
+    }
 }
 
 // MARK: - Businesss Logic
 
 extension PerpetualsSceneViewModel {
     func fetch() async {
         await updateMarkets()
+    }
+
+    func onAppear() async {
         await subscribeAllMids()
     }
 
-    func onDisappear() {
-        Task {
-            await unsubscribeAllMids()
-        }
+    func onDisappear() async {
+        await unsubscribeAllMids()
     }
 
     func updateMarkets() async {
@@ -175,22 +194,4 @@ extension PerpetualsSceneViewModel {
     func onSelectBalance() {
         isPresentingPortfolio = true
     }
-
-    // MARK: - AllMids
-
-    private func subscribeAllMids() async {
-        do {
-            try await observerService.subscribeAllMids()
-        } catch {
-            debugLog("AllMids subscribe failed: \(error)")
-        }
-    }
-
-    private func unsubscribeAllMids() async {
-        do {
-            try await observerService.unsubscribeAllMids()
-        } catch {
-            debugLog("AllMids unsubscribe failed: \(error)")
-        }
-    }
 }

Packages/FeatureServices/PerpetualService/TestKit/PerpetualService+TestKit.swift

@@ -2,6 +2,7 @@
 
 import PerpetualService
 import Preferences
+import PreferencesTestKit
 import Primitives
 import Store
 import StoreTestKit