1
struct StatusScheduleCard: View {
2
    @ObservedObject var vm: StatusScheduleCardViewModel
3

4
    @ViewBuilder
5
    var body: some View {
6
        if vm.inited {
7
            StatusScheduleCardInner(vm: vm)
8
        }
9
    }
10
}

1
@MainActor
2
class StatusScheduleCardViewModel: ObservableObject, StatusCardViewModel {
3
   @Published var inited = false
4
  ...
5
  func onInit() {
6
        inited = true
7
        initUpdateTask()
8
    }
9

10
  private func initUpdateTask() {
11
        Task {
12
            while !Task.isCancelled {
13
                updateData()
14
                do {
15
                    try await Task.sleep(nanoseconds: 10_000_000_000)
16
                } catch {
17
                    break
18
                }
19
            }
20
        }
21
    }
22

23
    private func updateData() {
24
        currentTime = Date()
25
        let currentWeekInfo = getCurrentWeekInfo(date: currentTime)
26
        Task.detached(priority: .background) { [currentWeekInfo, currentTime] in
27
            let realm = try! Realm(queue: nil)
28
            let results = realm.objects(ScheduleItemModel.self)
29
                .where {
30
                    ($0.end == nil && $0.begin >= currentTime) ||
31
                    ($0.end != nil && $0.end >= currentTime)
32
                }
33
                .freeze()
34
                .sorted(byKeyPath: "begin", ascending: true)
35
            let weekScheduleListResult = results
36
                .where {
37
                    return ($0.end == nil && $0.begin <= currentWeekInfo.end) || ($0.end != nil && $0.end <= currentWeekInfo.end)
38
                }
39
                .freeze()
40
            await MainActor.run {
41
                let snapshot = Array(results)
42
                let weekScheduleList = Array(weekScheduleListResult)
43
                withAnimation {
44
                    self.scheduleList = snapshot
45
                    self.weekScheduleList = weekScheduleList
46
                }
47
            }
48
        }
49
    }
50
  ...

1
struct CommonStatusCard<Content: View>: View {
2
    let icon: String
3
    let title: String
4
    let color: Color
5
    let padding: CGFloat
6
    var navDest: AnyView? = nil
7
    let content: () -> Content
8

9
    init<NavView: View>(icon: String,
10
                        title: String,
11
                        color: Color,
12
                        padding: Int = 12,
13
                        navDest: () -> NavView,
14
                        content: @escaping () -> Content) {
15
        self.icon = icon
16
        self.title = title
17
        self.color = color
18
        self.navDest = AnyView(navDest())
19
        self.content = content
20
        self.padding = CGFloat(padding)
21
    }

1
struct StatusCourseCard: View {
2

3
    @ObservedObject let vm: StatusCourseCardViewModel
4
  ...

1
struct StatusBusCard: View {
2

3
    @ObservedObject var vm: StatusBusCardViewModel
4
  ...

1
@MainActor
2
class StatusContentViewModel: ObservableObject, @MainActor StatusCardController {
3
    let weatherCardVM = StatusWeatherCardViewModel()
4
    let libraryCardVM = StatusLibraryCardViewModel()
5
    let courseCardVM = StatusCourseCardViewModel()
6
    let busCardVM = StatusBusCardViewModel()
7
    let sportCardVM = StatusSportCardVM()
8
    let scheduleCardVM = StatusScheduleCardViewModel()
9
    let casAlertCardVM = StatusCasAlertCardViewModel()
10

11
    ...
12

13
    init() {
14
        onInit()
15
    }
16

17
    ...
18

19
    func onInit() {
20
        getAllVM().forEach { $0.onInit() }
21
    }
22

23
    ...

1
class StatusBusCardViewModel: ObservableObject, StatusCardViewModel, LocationListener {
2
  ...
3
  func onInit() {
4
        LocationManager.shared.registerListener(self)
5
        update()
6
        casContext.isLoginFlow.sink { [weak self] _ in
7
            self?.update()
8
        }
9
        .store(in: &cancellables)
10
        initTimer()
11
    }
12
  ...

1
struct StatusView: View {
2
  var body: some View {
3
    ...
4
    .onReceive(NotificationCenter.default.publisher(
5
            for: UIApplication.didBecomeActiveNotification
6
        )) { _ in
7
            vm.contentVM.doInit()
8
        }
9
  }
10
  ...

1
struct StatusWeatherForecastInfo: SmartCodable {
2
    var day: String = ""
3
    var weather: String = ""
4
    var dayTemp: String = ""
5
    var nightTemp: String = ""
6
}
7

8
struct StatusWeatherDisplayInfo: SmartCodable {
9
    var temp: String = ""
10
    var weather: String = ""
11
    var description: String = ""
12
    var forecastInfo: [StatusWeatherForecastInfo] = []
13
}
14

15
@MainActor
16
class StatusWeatherCardViewModel: ObservableObject, LocationListener, StatusCardViewModel {
17

18
   private let TAG = "StatusWeatherCardViewModel"
19

20
    @Published var loadState = LoadStatus.unload
21
    @Published var weatherInfo: StatusWeatherDisplayInfo?
22
    @Published var errorMessage: String = ""
23
    weak var controller: StatusCardController?
24

25
    private var lastUpdateWeatherTimestamp: Int64 = 0
26
    private var placemark: CLPlacemark? = nil
27
    private var weatherObj: Weather? = nil
28
    @Published var inited = false
29

30
    // MARK: - Init
31

32
    init() {
33
      // 初始化时读取数据
34
        let displayInfo = StatusWeatherDisplayInfo.deserialize(from: LocalStorageHelper.shared.getStringValue(.weatherCache))
35
        _weatherInfo = .init(initialValue: displayInfo)
36
    }
37

38
    ...
39
    private func updateWeather(location: CLLocation) {
40
      ...
41
      // 天气获取成功时
42
      storeWeatherInfo(weatherInfo: weatherInfo)
43
    }
44

45
    private func storeWeatherInfo(weatherInfo: StatusWeatherDisplayInfo) {
46
      // 存数据
47
        LocalStorageHelper.shared.set(.weatherCache, value: weatherInfo.toJSONString())
48
    }
49
  ...

1
struct MainView: View {
2
    ...
3

4
    var body: some View {
5
        ...
6
        .onReceive(NotificationCenter.default.publisher(
7
            for: UIApplication.didBecomeActiveNotification
8
        )) { _ in
9
            ColdStartManager.shared.onIdle()
10
        }
11
    }
12
}

1
class ColdStartManager {
2
    static let shared = ColdStartManager()
3

4
    var privacyAgree: Bool {
5
        set {
6
            LocalStorageHelper.shared.set(.app_isReadPrivacy, value: newValue)
7
        }
8
        get {
9
            LocalStorageHelper.shared.getBool(.app_isReadPrivacy) ?? false
10
        }
11
    }
12

13
    private init() {}
14

15
    private weak var appDelegate: AppDelegate? = nil
16

17
    private let prepareLaunchCodeStartTask = PrepareLaunchCodeStartTask()
18
    private let primaryMainColdStartTask = PrimaryMainColdStartTask()
19
    private let primaryAsyncColdStartTask = PrimaryAsyncColdStartTask()
20
    private let secondaryAsyncColdStartTask = SecondaryAsyncColdStartTask()
21
    private let idleMainColdStartTask = IdleMainColdStartTask()
22
    private let idleAsyncColdStartTask = IdleAsyncColdStartTask()
23

24
    private var idleInited = false
25

26
    func onPrepareLaunch(delegate: AppDelegate) {
27
        logTime("prepareLaunch") { prepareLaunchCodeStartTask.action(delegate: delegate, privacyAgreed: privacyAgree) }
28
    }
29

30
    func onDidFinishLaunching(delegate: AppDelegate) {
31
        appDelegate = delegate
32
        logTime("primaryMainColdStartTask.action") {
33
            primaryMainColdStartTask.action(
34
                delegate: delegate,
35
                privacyAgreed: privacyAgree
36
            )
37
        }
38
        Task
39
            .detached(name: "ColdStartTask", priority: .background) { [
40
                primaryAsyncColdStartTask,
41
                secondaryAsyncColdStartTask,
42
                privacyAgree
43
            ] in
44
            logTime("primaryColdStartTask.action") {
45
                primaryAsyncColdStartTask.action(
46
                    delegate: delegate,
47
                    privacyAgreed: privacyAgree
48
                )
49
            }
50

51
            logTime("secondaryAsyncColdStartTask.action") {
52
                secondaryAsyncColdStartTask.action(
53
                    delegate: delegate,
54
                    privacyAgreed: privacyAgree
55
                )
56
            }
57
        }
58
    }
59

60
    func onPrivacyAgreed() {
61
        guard let appDelegate = appDelegate else {
62
            return
63
        }
64
        LocalStorageHelper.shared.set(.app_isReadPrivacy, value: true)
65
        NotificationCenter.default.post(name: .byKey(.ham_privacyRead), object: nil)
66
        logTime("primaryMainColdStartTask.onPrivacyAgree") {
67
            primaryMainColdStartTask.onPrivacyAgree(delegate: appDelegate)
68
        }
69
        Task.detached(name: "ColdStartTask - After privacy read", priority: .background) { [primaryAsyncColdStartTask, secondaryAsyncColdStartTask, appDelegate] in
70
            logTime("primaryColdStartTask.onPrivacyAgree") {
71
                primaryAsyncColdStartTask.onPrivacyAgree(delegate: appDelegate)
72
            }
73

74
            logTime("secondaryAsyncColdStartTask.onPrivacyAgree") {
75
                secondaryAsyncColdStartTask.onPrivacyAgree(delegate: appDelegate)
76
            }
77
        }
78
    }
79

80
    func onIdle() {
81
        guard let appDelegate = appDelegate, !idleInited else {
82
            return
83
        }
84
        idleInited = true
85
        Task { @MainActor in
86
            logTime("idleMainColdStartTask.action") {
87
                idleMainColdStartTask.action(
88
                    delegate: appDelegate,
89
                    privacyAgreed: privacyAgree
90
                )
91
            }
92
        }
93
        Task.detached(name: "ColdStartTask - onIdle", priority: .background) { [idleAsyncColdStartTask, appDelegate, privacyAgree] in
94
            logTime("idleAsyncColdStartTask.action") {
95
                idleAsyncColdStartTask.action(delegate: appDelegate, privacyAgreed: privacyAgree)
96
            }
97
        }
98
    }
99
}