Dictation on the Wrist: nil, Not an Empty List, and a Swipe Up

"It was a swipe up to switch between Korean and English."

SwiftUI Cannot Open the Microphone Here

A watch capture view with a SwiftUI text field labelled "Speak" opened the keyboard on a real watch. It was not a setting and not the watch remembering the last mode. SwiftUI's dictation controls are declared unavailable on watchOS, so a text field gets whatever input screen the system prefers and the app has no say. There is no Speech framework on the watch either, so an app cannot run its own recognizer in a language it chooses. The route that works is WatchKit's presentTextInputController(withSuggestions:allowedInputMode:completion:), reached through WKApplication.shared().visibleInterfaceController. Checked against the installed SDK for this lesson: the SwiftUI type carries @available(watchOS, unavailable), and the watchOS SDK has no Speech framework.

nil and [] Are Different Calls

The suggestions argument decides the screen. Passing nil means there is no list, so watchOS skips the input screen and opens the microphone immediately. Passing [] means a list that happens to be empty, so watchOS shows the input screen with its keyboard, scribble and microphone choices. The difference is invisible at the call site, and it is the difference between a five-second capture and a detour. The Simulator cannot arbitrate it: the watch Simulator falls back to the keyboard either way, so a screenshot of a keyboard there proves nothing.

The Second Door Three Apps Shipped and Removed

A bilingual wearer spoke Korean into dictation that opened in English and got nonsense. Looking for the language switch, a session read the SDK header, found the variant that lets the user switch input language, concluded the only in-app way to switch was the empty-list screen with its globe, and shipped two buttons: a fast one, and an "Other language" one. Two more apps copied the pair. On the owner's wrist the second button did nothing useful, and he found the real answer himself: a swipe up on the ordinary dictation screen shows language selection. The button was removed from all three apps, and the shared dictation module now has one entry point.

Two rules came out of it. A claim that something is the only way to reach a feature is a claim about the whole platform, and getting one way to work cannot establish it: somebody has to try the ordinary way. And a Simulator screenshot of your own button proves your view rendered; it proves nothing about the system sheet the button opens. One correction from re-checking for this lesson: the language-choosing variant was once recorded as unavailable in Swift, but with the current SDK it imports and compiles. It still never goes straight to dictation, so the family's answer stays one door and the swipe.

Two Details That Bite

visibleInterfaceController is nil until a view is on screen, which is exactly where a cold launch from the Action Button can land, so "dictation unavailable" is a moment, not a state: test it on every attempt instead of latching it for the session. And the completion is built in a nonisolated factory, for the same reason as the audio tap: a closure written inside a main-actor method inherits that isolation, and the framework may call it elsewhere.

Code

One dictation door: nil suggestions, a nonisolated completion, and no latched unavailability·swift

import WatchKit

/// Dictation on watchOS goes through WatchKit. SwiftUI's dictation controls are unavailable here,
/// and there is no Speech framework on the watch.
enum WristDictation {
    /// nil suggestions opens the microphone at once. An EMPTY array would show the input list instead.
    /// The language switch is a swipe up on the dictation screen itself; the app adds no second door.
    @MainActor
    static func speak(_ deliver: @escaping @MainActor @Sendable (String?) -> Void) -> Bool {
        // nil until a view is on screen: a cold launch from the Action Button can land here too early.
        guard let controller = WKApplication.shared().visibleInterfaceController else { return false }
        controller.presentTextInputController(withSuggestions: nil, allowedInputMode: .plain,
                                              completion: completion(deliver))
        return true
    }

    /// Built off any actor. An inline closure written in a @MainActor method would inherit that
    /// isolation, and WatchKit may call it elsewhere.
    nonisolated static func completion(_ deliver: @escaping @MainActor @Sendable (String?) -> Void)
        -> @Sendable ([Any]?) -> Void {
        { results in
            let text = (results?.first as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
            Task { @MainActor in deliver(text?.isEmpty == false ? text : nil) }
        }
    }
}

Read the SDK instead of remembering it·bash

# What the watchOS SDK actually offers, checked against the installed SDK rather than memory.
WSDK=$(xcrun --sdk watchsimulator --show-sdk-path)

# SwiftUI's dictation controls: declared unavailable on watchOS.
grep -h -B3 'struct TextInputDictationBehavior' \
  "$WSDK"/System/Library/Frameworks/SwiftUI.framework/Modules/SwiftUI.swiftmodule/*.swiftinterface | head -4
#   @available(watchOS, unavailable)

# No Speech framework on the watch, so no recognizer with an app-chosen locale.
ls "$WSDK/System/Library/Frameworks" | grep -c '^Speech.framework'          # 0

# The language-choosing variant exists and imports into Swift, but its header says it
# "will never go straight to dictation".
grep -o 'will never go straight to dictation[^;]*' \
  "$WSDK/System/Library/Frameworks/WatchKit.framework/Headers/WKInterfaceController.h"

Exercise

Run the SDK checks above and record each answer. Then add WristDictation.speak to Spark's watch app behind its one button, and on a real watch compare nil with [] as the suggestions argument, writing down which screen each opens. With nil, swipe up on the dictation screen and switch the language. Finally, launch the app from its complication while it is not running and confirm that a first call returning false is retried once the view appears.

Hint

If you only have the Simulator, record that both variants show the keyboard there and mark the comparison as still open. Retrying is as simple as calling speak again from the view's onAppear when a pending request is set.