WatchConnectivity: 기록, 초인종, 그리고 델리게이트 하나

import Foundation

enum SealError: Error, Equatable {
    case notPropertyList(key: String)
}

/// What rides between watch and phone. Plain property-list values only: an absent optional
/// written as `Optional<String>.none as Any` is accepted by transferUserInfo and then never delivered.
enum WristEnvelope {
    static let idKey = "id"

    static func seal(id: String, fields: [String: Any]) throws(SealError) -> [String: Any] {
        var info = fields
        info[idKey] = id
        for (key, value) in info {
            guard PropertyListSerialization.propertyList([key: value], isValidFor: .binary) else {
                throw .notPropertyList(key: key)
            }
        }
        return info
    }

    static func identifier(in info: [String: Any]) -> String? { info[idKey] as? String }
}

// let place: String? = nil
// seal(id: "c1", fields: ["text": "hi", "place": place as Any])  -> throws notPropertyList(key: "place")
// if let place { fields["place"] = place }                        -> sealed, "place" simply absent

import Foundation
import WatchConnectivity

/// The ONE delegate the session has. WCSession.delegate is weak and single: whoever assigns it
/// last owns every callback, and an unretained relay leaves the session with no delegate at all.
final class WristSessionProxy: NSObject, WCSessionDelegate, @unchecked Sendable {
    static let shared = WristSessionProxy()          // retained for the life of the process
    var onFinished: @Sendable (String) -> Void = { _ in }
    var onHandedOver: @Sendable (String) -> Void = { _ in }
    /// Phone side: the one door. True once the capture is stored, now or by an earlier arrival.
    var onReceive: @Sendable ([String: Any]) -> Bool = { _ in false }

    func activate() {
        guard WCSession.isSupported() else { return }
        WCSession.default.delegate = self
        WCSession.default.activate()                  // from App.init: a background launch has no view
    }

    /// The record: queued, ordered, survives both apps exiting, delivered on the phone app's next launch.
    /// The ring: sendMessage launches the iOS app if it is not running. Same envelope, one door.
    func offer(_ info: [String: Any]) {
        let session = WCSession.default
        session.transferUserInfo(info)
        guard session.isReachable, let id = WristEnvelope.identifier(in: info) else { return }
        let handedOver = onHandedOver
        session.sendMessage(info, replyHandler: { reply in
            // "The phone has it" is the phone's own word. The queue entry still waits for didFinish.
            if reply["stored"] as? String == id { handedOver(id) }
        }, errorHandler: nil)
    }

    func session(_ session: WCSession, activationDidCompleteWith state: WCSessionActivationState, error: Error?) {}

    // The watch lets go of an entry ONLY here, never at send time and never on the ring's reply.
    func session(_ session: WCSession, didFinish transfer: WCSessionUserInfoTransfer, error: Error?) {
        guard error == nil, let id = WristEnvelope.identifier(in: transfer.userInfo) else { return }
        onFinished(id)
    }

    func session(_ session: WCSession, didReceiveUserInfo userInfo: [String: Any]) { _ = onReceive(userInfo) }

    // The ring carries a reply handler, so it arrives here. Answer only after the door has stored it.
    func session(_ session: WCSession, didReceiveMessage message: [String: Any],
                 replyHandler: @escaping ([String: Any]) -> Void) {
        if onReceive(message), let id = WristEnvelope.identifier(in: message) {
            replyHandler(["stored": id])
        } else {
            replyHandler([:])
        }
    }

    #if os(iOS)
    func sessionDidBecomeInactive(_ session: WCSession) {}
    func sessionDidDeactivate(_ session: WCSession) { session.activate() }   // it may be a different watch now
    #endif
}