b980d7df7a
- 워치 첫 화면 최상단에 '즐겨찾기' 항목 추가 — 앱에서 즐겨찾기한 행동을 태그를 거치지 않고 한 탭 만에 연다. WatchActionInfo.isFavorite는 optional로 실어 구버전 캐시 스냅숏도 그대로 디코딩된다. - 워치 스냅숏 전송 디바운스(350ms): 모든 커밋마다 목표×다짐×3기간 진행률을 전부 재집계하던 것을, 연타 중에는 마지막 상태 한 번만 계산해 보내도록 변경 (명령 응답 경로의 즉시 스냅숏은 그대로). iOS·watchOS 스킴 빌드 확인. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013yKDMhuF39GVYy3FMcGHh7
247 lines
11 KiB
Swift
247 lines
11 KiB
Swift
//
|
||
// WatchSyncManager.swift
|
||
// Haru_Danim
|
||
//
|
||
// Apple Watch 실시간 연동 (CLAUDE.md §9.1)
|
||
// - 워치의 실행 명령을 받아 DB에 반영하고 최신 스냅숏을 돌려준다
|
||
// - 데이터가 바뀔 때마다 updateApplicationContext로 최신 상태를 밀어 넣는다
|
||
//
|
||
|
||
import Foundation
|
||
import OSLog
|
||
import SwiftData
|
||
import WatchConnectivity
|
||
import WidgetKit
|
||
|
||
private let watchSyncLog = Logger(subsystem: "com.yechan.HaruDanim", category: "WatchSync")
|
||
|
||
@MainActor
|
||
final class WatchSyncManager: NSObject {
|
||
static let shared = WatchSyncManager()
|
||
|
||
func activate() {
|
||
guard WCSession.isSupported() else { return }
|
||
let session = WCSession.default
|
||
session.delegate = self
|
||
session.activate()
|
||
#if DEBUG
|
||
watchSyncLog.notice("responds userInfo=\(self.responds(to: NSSelectorFromString("session:didReceiveUserInfo:"))) message=\(self.responds(to: NSSelectorFromString("session:didReceiveMessage:replyHandler:")))")
|
||
#endif
|
||
}
|
||
|
||
// MARK: 스냅숏 생성
|
||
|
||
/// 현재 DB 상태로 워치용 스냅숏 생성
|
||
func makeSnapshot() -> WatchSnapshot {
|
||
let context = DataStore.shared.mainContext
|
||
let now = Date.now
|
||
let math = DayMath()
|
||
let agg = Aggregator(math: math)
|
||
|
||
var snapshot = WatchSnapshot()
|
||
snapshot.isPremium = PremiumGate.isUnlocked(.watchApp)
|
||
|
||
let tags = (try? context.fetch(FetchDescriptor<Tag>(
|
||
sortBy: [SortDescriptor(\.sortOrder), SortDescriptor(\.createdAt)]
|
||
))) ?? []
|
||
snapshot.tags = tags.map { WatchTagInfo(id: $0.uuid, name: $0.name, colorHex: $0.colorHex) }
|
||
|
||
// 워치의 행동 나열 순서도 이 기기(페어링된 폰)의 모음 탭 배치(로컬 설정)를 따른다
|
||
let actions = LocalPrefs.orderedActions(
|
||
(try? context.fetch(FetchDescriptor<Action>(sortBy: [SortDescriptor(\.createdAt)]))) ?? []
|
||
)
|
||
snapshot.actions = actions.map { action in
|
||
let todayValue = agg.todayValue(for: action, now: now)
|
||
let isCount = action.trackingType == .count
|
||
return WatchActionInfo(
|
||
id: action.uuid,
|
||
name: action.name,
|
||
symbolName: action.symbolName,
|
||
colorHex: action.sortedTags.first?.colorHex ?? "#2F6B4F",
|
||
isCount: isCount,
|
||
todayValue: todayValue,
|
||
isRunning: action.isRunning,
|
||
tickingBase: action.isRunning && !isCount ? now.addingTimeInterval(-todayValue) : nil,
|
||
tagIDs: action.sortedTags.map(\.uuid),
|
||
isFavorite: action.isFavorite
|
||
)
|
||
}
|
||
|
||
let goals = (try? context.fetch(FetchDescriptor<Goal>(
|
||
predicate: #Predicate { $0.statusRaw == "inProgress" },
|
||
sortBy: [SortDescriptor(\.sortOrder), SortDescriptor(\.createdAt)]
|
||
))) ?? []
|
||
snapshot.goals = goals.map { goal in
|
||
WatchGoalInfo(
|
||
id: goal.uuid,
|
||
title: goal.title,
|
||
symbolName: goal.symbolName,
|
||
colorHex: goal.colorHex,
|
||
dayRatio: goal.combinedSpanRatio(.day, math: math, now: now),
|
||
weekRatio: goal.combinedSpanRatio(.week, math: math, now: now),
|
||
monthRatio: goal.combinedSpanRatio(.month, math: math, now: now),
|
||
quests: goal.sortedQuests.map { quest in
|
||
let progress = QuestProgress(quest: quest, math: math)
|
||
let day = progress.spanProgress(.day, now: now)
|
||
let week = progress.spanProgress(.week, now: now)
|
||
let month = progress.spanProgress(.month, now: now)
|
||
return WatchQuestInfo(
|
||
id: quest.uuid,
|
||
name: quest.targetName,
|
||
symbolName: quest.targetSymbol,
|
||
colorHex: quest.targetAction?.sortedTags.first?.colorHex
|
||
?? quest.targetTag?.colorHex ?? "#2F6B4F",
|
||
dayRatio: day.ratio,
|
||
weekRatio: week.ratio,
|
||
monthRatio: month.ratio,
|
||
isAtMost: quest.direction == .atMost,
|
||
dayAchieved: day.isAchieved,
|
||
weekAchieved: week.isAchieved,
|
||
monthAchieved: month.isAchieved
|
||
)
|
||
}
|
||
)
|
||
}
|
||
|
||
// 현재 측정 중 대표 행동 (다이나믹 아일랜드와 동일 기준)
|
||
let running = (try? context.fetch(FetchDescriptor<TimeSession>(
|
||
predicate: #Predicate { $0.endAt == nil },
|
||
sortBy: [SortDescriptor(\.startAt, order: .forward)]
|
||
))) ?? []
|
||
let mode = LiveActivityMode(
|
||
rawValue: AppGroup.defaults.string(forKey: SettingsKeys.liveActivityMode)
|
||
?? UserDefaults.standard.string(forKey: SettingsKeys.liveActivityMode) ?? ""
|
||
) ?? .latest
|
||
if let representative = mode == .earliest ? running.first : running.last,
|
||
let action = representative.action {
|
||
snapshot.runningName = action.name
|
||
snapshot.runningSymbol = action.symbolName
|
||
snapshot.runningStartAt = representative.startAt
|
||
snapshot.extraRunningCount = max(0, running.count - 1)
|
||
}
|
||
|
||
return snapshot
|
||
}
|
||
|
||
/// 컴플리케이션 전용 전송의 최근 상태 (하루 전송 예산이 있어 절약해서 보냄)
|
||
private var lastComplicationStateKey = ""
|
||
private var lastComplicationPushAt = Date.distantPast
|
||
|
||
/// 디바운스 중인 전송 작업 (연타 대비)
|
||
private var pushTask: Task<Void, Never>?
|
||
|
||
/// 최신 스냅숏을 워치로 전송 (데이터 변경 시마다 호출).
|
||
/// 스냅숏 생성은 모든 목표×다짐×3기간 진행률을 집계하는 비싼 작업이라,
|
||
/// 짧은 디바운스로 연타(횟수 버튼 연속 탭 등) 중의 중간 계산을 건너뛰고
|
||
/// 마지막 상태 한 번만 만들어 보낸다.
|
||
func pushSnapshot() {
|
||
pushTask?.cancel()
|
||
pushTask = Task { @MainActor in
|
||
try? await Task.sleep(for: .milliseconds(350))
|
||
guard !Task.isCancelled else { return }
|
||
self.pushSnapshotNow()
|
||
}
|
||
}
|
||
|
||
private func pushSnapshotNow() {
|
||
guard WCSession.isSupported() else { return }
|
||
let session = WCSession.default
|
||
guard session.activationState == .activated, session.isPaired, session.isWatchAppInstalled else { return }
|
||
let snapshot = makeSnapshot()
|
||
guard let data = snapshot.encoded() else { return }
|
||
// applicationContext: 워치 앱이 다음에 열릴 때 확실히 전달되는 기본 채널
|
||
try? session.updateApplicationContext([WatchSync.snapshotKey: data])
|
||
pushForComplicationIfNeeded(session: session, snapshot: snapshot, data: data)
|
||
}
|
||
|
||
/// 워치 앱이 꺼져 있어도 컴플리케이션이 갱신되도록 전용 채널로 전송.
|
||
/// 시스템이 하루 전송 횟수를 제한하므로 측정 상태가 바뀌었거나 30분이 지났을 때만 보낸다
|
||
private func pushForComplicationIfNeeded(session: WCSession, snapshot: WatchSnapshot, data: Data) {
|
||
guard session.isComplicationEnabled else { return }
|
||
let stateKey = "\(snapshot.runningName ?? "")|\(snapshot.extraRunningCount)|\(snapshot.isPremium)"
|
||
let now = Date.now
|
||
guard stateKey != lastComplicationStateKey
|
||
|| now.timeIntervalSince(lastComplicationPushAt) > 30 * 60 else { return }
|
||
lastComplicationStateKey = stateKey
|
||
lastComplicationPushAt = now
|
||
session.transferCurrentComplicationUserInfo([WatchSync.snapshotKey: data])
|
||
}
|
||
|
||
// MARK: 명령 처리
|
||
|
||
/// 워치의 명령을 처리하고 최신 스냅숏 응답을 만든다
|
||
fileprivate func handle(command: String?, actionID: String?) -> [String: Any] {
|
||
let context = DataStore.shared.mainContext
|
||
if command == WatchSync.runCommand,
|
||
let idString = actionID,
|
||
let id = UUID(uuidString: idString) {
|
||
if PremiumGate.isUnlocked(.watchApp) {
|
||
let actions = (try? context.fetch(FetchDescriptor<Action>())) ?? []
|
||
if let action = actions.first(where: { $0.uuid == id }) {
|
||
watchSyncLog.notice("run command: \(action.name, privacy: .public)")
|
||
ActionRunner.run(action, context: context)
|
||
try? context.save()
|
||
LiveActivityManager.sync(context: context)
|
||
WidgetCenter.shared.reloadAllTimelines()
|
||
} else {
|
||
watchSyncLog.error("run command: action not found \(idString, privacy: .public)")
|
||
}
|
||
} else {
|
||
watchSyncLog.error("run command ignored: watchApp premium locked")
|
||
}
|
||
}
|
||
guard let data = makeSnapshot().encoded() else { return [:] }
|
||
return [WatchSync.snapshotKey: data]
|
||
}
|
||
}
|
||
|
||
extension WatchSyncManager: WCSessionDelegate {
|
||
nonisolated func session(
|
||
_ session: WCSession,
|
||
activationDidCompleteWith activationState: WCSessionActivationState,
|
||
error: (any Error)?
|
||
) {
|
||
Task { @MainActor in
|
||
WatchSyncManager.shared.pushSnapshot()
|
||
}
|
||
}
|
||
|
||
nonisolated func sessionDidBecomeInactive(_ session: WCSession) {}
|
||
|
||
nonisolated func sessionDidDeactivate(_ session: WCSession) {
|
||
session.activate()
|
||
}
|
||
|
||
/// 워치의 실행/새로 고침 요청 (응답으로 최신 스냅숏 반환)
|
||
nonisolated func session(
|
||
_ session: WCSession,
|
||
didReceiveMessage message: [String: Any],
|
||
replyHandler: @escaping ([String: Any]) -> Void
|
||
) {
|
||
let command = message[WatchSync.commandKey] as? String
|
||
let actionID = message[WatchSync.actionIDKey] as? String
|
||
Task { @MainActor in
|
||
let reply = WatchSyncManager.shared.handle(command: command, actionID: actionID)
|
||
replyHandler(reply)
|
||
WatchSyncManager.shared.pushSnapshot()
|
||
}
|
||
}
|
||
|
||
/// sendMessage 실패 시 워치가 큐 채널로 재전송한 실행 명령 (백그라운드 전달 보장)
|
||
nonisolated func session(_ session: WCSession, didReceiveUserInfo userInfo: [String: Any] = [:]) {
|
||
let command = userInfo[WatchSync.commandKey] as? String
|
||
let actionID = userInfo[WatchSync.actionIDKey] as? String
|
||
watchSyncLog.notice("didReceiveUserInfo command=\(command ?? "nil", privacy: .public)")
|
||
guard command == WatchSync.runCommand else { return }
|
||
// 큐에 오래 머문 명령이 뒤늦게 실행돼 엉뚱한 토글을 일으키지 않도록 유효 시간 확인
|
||
if let sentAt = userInfo[WatchSync.sentAtKey] as? TimeInterval,
|
||
Date.now.timeIntervalSince1970 - sentAt > WatchSync.queuedRunMaxAge {
|
||
return
|
||
}
|
||
Task { @MainActor in
|
||
_ = WatchSyncManager.shared.handle(command: command, actionID: actionID)
|
||
WatchSyncManager.shared.pushSnapshot()
|
||
}
|
||
}
|
||
}
|