동작 버튼: 단축어, 한 번 쓰는 요청, 그리고 다시 시도

// LaunchRequest.swift
import Foundation

/// A one-shot request that survives a cold launch. The process that reads it may not exist yet when
/// the button is pressed, so it lives in UserDefaults, and reading it clears it: a request left armed
/// would reopen the microphone every time the wearer comes back to the app.
enum LaunchRequest {
    private static let key = "spark.launch.speak"

    static func arm(_ defaults: UserDefaults = .standard) {
        defaults.set(true, forKey: key)
    }

    static func consume(_ defaults: UserDefaults = .standard) -> Bool {
        guard defaults.bool(forKey: key) else { return false }
        defaults.removeObject(forKey: key)
        return true
    }
}

// SpeakIntent.swift (watch target)
import AppIntents
import Foundation

/// The Action Button cannot point at an app, only at a shortcut. Publishing this intent through an
/// AppShortcutsProvider in the WATCH target is what makes Spark selectable there.
struct SpeakToSparkIntent: AppIntent {
    static let title: LocalizedStringResource = "Speak to Spark"
    static let description = IntentDescription("Opens Spark's dictation so you can capture a thought.")
    static let openAppWhenRun = true    // dictation needs the app on screen; never pretend to capture silently

    @MainActor
    func perform() async throws -> some IntentResult {
        LaunchRequest.arm()             // the first view consumes it
        return .result()
    }
}

struct SparkWatchShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(intent: SpeakToSparkIntent(),
                    phrases: ["Speak to \(.applicationName)"],
                    shortTitle: "Speak",
                    systemImageName: "mic.fill")
    }
}

import SwiftUI

struct SparkWatchRoot: View {
    /// The dictation door from the dictation lesson: false while no controller is visible yet.
    let openDictation: @MainActor () -> Bool
    @Environment(\.scenePhase) private var phase
    @State private var wantsDictation = false

    var body: some View {
        Button("Speak", systemImage: "mic.fill") { request() }
            .onOpenURL { url in                                        // the complication's tap, same door
                if url.scheme == "spark", url.host() == "speak" { request() }
            }
            .onAppear {
                if LaunchRequest.consume() { wantsDictation = true }   // a cold press of the Action Button
                attempt()
            }
            .onChange(of: phase) { _, now in
                guard now == .active else { return }
                if LaunchRequest.consume() { wantsDictation = true }   // a press while the app was alive
                attempt()
            }
    }

    private func request() {
        wantsDictation = true
        attempt()
    }

    /// Unavailable is a moment, not a state: keep the wish until the door actually opens.
    private func attempt() {
        guard wantsDictation else { return }
        if openDictation() { wantsDictation = false }
    }
}