hex/ios/HEXMobile/FullKeyboardSnapshotStage.swift

673 lines
No EOL
32 KiB
Swift
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import SwiftUI
import UIKit
/// Renders the experimental `FullKeyboardView` under a composer when
/// `--snap-state full-keyboard-<state>[-dark|-dark-field]` is passed on Simulator.
/// `-dark` is a dark app; `-dark-field` is a light app whose field asks for a dark keyboard.
/// The layout follows `--dictation-language` (Automatic, English, without it), or
/// `--keyboard-layout nb|es|de|it|fr|fr-CA|fr-CH|pt|pl|cs|hu|ro|ru|uk|el|sr-Latn|ko|en` pins it; drafts are in the layout's language.
/// `--keyboard-letters qwerty|qwertz|azerty|dvorak|own` arranges its letters (its own without it).
/// `--accent-key ø` (or Cyrillic `е`, `ь`, `ʼ`, Greek `α`, `σ`, `t` on Romanian, or `o` on Hungarian) picks the key the `accents` state holds; `--emoji-query kiss` what `emoji-search` types.
/// Emoji states (`emoji`, `emoji-search`, `emoji-tones`, `emoji-food`, `emoji-strip`) turn
/// Settings › Keyboard › Emoji on with a seeded history; `emoji-probe` prints the panel's
/// footprint and latency (`EMOJI_PROBE` lines) for `simctl launch --console`.
struct FullKeyboardSnapshotStage: View {
let scene: String
static var layout: KeyboardLanguage {
argument(after: "--keyboard-layout").flatMap(KeyboardLanguage.init(rawValue:))
?? KeyboardLanguage.automatic(
dictationLanguage: DictationLanguageFixture.explicit ?? "en-US",
inputModes: [],
preferredLanguages: []
)
}
static var accentKey: String {
argument(after: "--accent-key") ?? "e"
}
/// What the `emoji-search` state types (`--emoji-query kiss`).
static var emojiQuery: String {
argument(after: "--emoji-query") ?? "heart"
}
static func argument(after flag: String) -> String? {
let args = ProcessInfo.processInfo.arguments
guard let idx = args.firstIndex(of: flag), idx + 1 < args.count else { return nil }
return args[idx + 1]
}
static var requestedScene: String? {
let args = ProcessInfo.processInfo.arguments
guard let idx = args.firstIndex(of: "--snap-state"), idx + 1 < args.count else {
return nil
}
let value = args[idx + 1]
guard value.hasPrefix("full-keyboard-") else { return nil }
if let p = args.firstIndex(of: "--hex-placement"), p + 1 < args.count,
let placement = HexKeyPlacement(rawValue: args[p + 1]) {
HexKeyPlacement.current = placement
}
return value
}
private var darkField: Bool { scene.hasSuffix("-dark-field") }
private var darkApp: Bool { scene.hasSuffix("-dark") }
private var state: String {
var name = String(scene.dropFirst("full-keyboard-".count))
for suffix in ["-dark-field", "-dark"] where name.hasSuffix(suffix) {
name = String(name.dropLast(suffix.count))
}
return name
}
private var draft: String {
switch Self.layout {
case .norwegian:
return switch state {
case "inserted": "Kommer ti min for sent, er hjemme 19.30. Begynn uten meg."
case "numbers": "Kommer ti min for sent, hjemme 19.3"
case "shift": "Kommer ti min for sent. "
case "typing": "Kommer ti min for sen"
case "accents": Self.accentKey == "e" ? "Kaf" : "Bl"
default: "Kommer ti min for sent, "
}
case .spanish:
return switch state {
case "inserted": "Llego diez minutos tarde, estaré en casa a las 7:30."
case "numbers": "Llego diez minutos tarde, en casa a las 7:3"
case "shift": "Llego diez minutos tarde. "
case "typing": "Llego diez minutos tard"
case "accents": "Caf"
default: "Llego diez minutos tarde, "
}
case .german:
return switch state {
case "inserted": "Bin zehn Minuten zu spät, um 7:30 zu Hause. Fangt ohne mich an."
case "numbers": "Bin zehn Minuten zu spät, um 7:3"
case "shift": "Bin zehn Minuten zu spät. "
case "typing": "Bin zehn Minuten zu spä"
case "accents": Self.accentKey == "s" ? "Stra" : "Caf"
default: "Bin zehn Minuten zu spät, "
}
case .italian:
return switch state {
case "inserted": "Arrivo con dieci minuti di ritardo, a casa per le 19:30. Iniziate senza di me."
case "numbers": "Arrivo con dieci minuti di ritardo, a casa per le 19:3"
case "shift": "Arrivo con dieci minuti di ritardo. "
case "typing": "Arrivo con dieci minuti di ritsrdo"
case "accents": Self.accentKey == "e" ? "Perch" : "Cos"
default: "Arrivo con dieci minuti di ritardo, "
}
case .french, .frenchCanadian, .frenchSwiss:
return switch state {
case "inserted": "J'arrive avec dix minutes de retard, à la maison vers 19h30. Commencez sans moi."
case "numbers": "J'arrive avec dix minutes de retard, à la maison vers 19h3"
case "shift": "J'arrive avec dix minutes de retard. "
case "typing": "J'arrive avec dix minutes de reta"
case "accents": "Caf"
default: "J'arrive avec dix minutes de retard, "
}
case .portuguese:
return switch state {
case "inserted": "Vou chegar dez minutos atrasado, em casa às 19:30. Comecem sem mim."
case "numbers": "Vou chegar dez minutos atrasado, em casa às 19:3"
case "shift": "Vou chegar dez minutos atrasado. "
case "typing": "Vou chegar dez minutos atras"
case "accents": "Caf"
default: "Vou chegar dez minutos atrasado, "
}
case .polish:
return switch state {
case "inserted": "Spóźnię się dziesięć minut, będę w domu o 19:30. Zacznijcie beze mnie."
case "numbers": "Spóźnię się dziesięć minut, będę w domu o 19:3"
case "shift": "Spóźnię się dziesięć minut. "
case "typing": "Spóźnię się dziesięć min"
case "accents": Self.accentKey == "e" ? "Prosz" : "Za"
default: "Spóźnię się dziesięć minut, "
}
case .czech:
return switch state {
case "inserted": "Přijdu o deset minut později, doma budu v 19:30. Začněte beze mě."
case "numbers": "Přijdu o deset minut později, doma budu v 19:3"
case "shift": "Přijdu o deset minut později. "
case "typing": "Přijdu o deset minut pozd"
case "accents": Self.accentKey == "r" ? "P" : "Ka"
default: "Přijdu o deset minut později, "
}
case .hungarian:
return switch state {
case "inserted": "Köszönöm szépen, találkozunk holnap!"
case "numbers": "Találkozunk 19:3"
case "shift": "Köszönöm szépen, találkozunk holnap. "
case "typing": "Köszönöm szépen, találkozunk holn"
case "accents": Self.accentKey == "e" ? "Káv" : "Köszön"
default: "Köszönöm szépen, találkozunk "
}
case .romanian:
return switch state {
case "inserted": "Întârzii zece minute, ajung acasă la 19:30. Începeți fără mine."
case "numbers": "Întârzii zece minute, ajung acasă la 19:3"
case "shift": "Întârzii zece minute. "
case "typing": "Întârzii zece min"
case "accents": Self.accentKey == "t" ? "Mul" : "Cas"
default: "Întârzii zece minute, "
}
case .russian:
return switch state {
case "inserted": "Опаздываю на десять минут, буду дома в 19:30. Начинайте без меня."
case "numbers": "Опаздываю на десять минут, буду дома в 19:3"
case "shift": "Опаздываю на десять минут. "
case "typing": "Опаздываю на десять мину"
case "accents": Self.accentKey == "ь" ? "Об" : "Ещ"
default: "Опаздываю на десять минут, "
}
case .ukrainian:
return switch state {
case "inserted": "Запізнююсь на десять хвилин, буду вдома о 19:30. Починайте без мене."
case "numbers": "Запізнююсь на десять хвилин, буду вдома о 19:3"
case "shift": "Запізнююсь на десять хвилин. "
case "typing": "Запізнююсь на десять хвил"
case "accents": "Сім"
default: "Запізнююсь на десять хвилин, "
}
case .greek:
return switch state {
case "inserted": "Θα αργήσω δέκα λεπτά, θα είμαι σπίτι στις 19:30. Ξεκινήστε χωρίς εμένα."
case "numbers": "Θα αργήσω δέκα λεπτά, θα είμαι σπίτι στις 19:3"
case "shift": "Θα αργήσω δέκα λεπτά. "
case "typing": "Θα αργήσω δέκα λεπ"
case "accents": Self.accentKey == "σ" ? "Θα αργήσω δέκα λεπτά, θα είμαι σπίτι στι" : "Καλημ"
default: "Θα αργήσω δέκα λεπτά, "
}
case .serbianLatin:
return switch state {
case "inserted": "Kasnim deset minuta, biću kod kuće u 19:30. Počnite bez mene."
case "numbers": "Kasnim deset minuta, biću kod kuće u 19:3"
case "shift": "Kasnim deset minuta. "
case "typing": "Kasnim deset minuta, biću kod kuć"
case "accents": Self.accentKey == "s" ? "Po" : "Laku no"
default: "Kasnim deset minuta, "
}
case .korean:
return switch state {
case "inserted": "10분 늦어요. 7시 30분까지 집에 갈게요. 먼저 시작하세요."
case "numbers": "10분 늦어요. 7시 3"
case "shift": "10분 늦어요. "
case "typing": "10분 늦어"
case "accents": "한"
default: "10분 늦어요. "
}
case .english:
break
}
if state.hasPrefix("emoji") {
return state == "emoji-strip" ? "Happy birthday " : "Congrats on the launch, pizza tonight? "
}
return switch state {
case "inserted": "Running 10 min late, should be home by 7:30. Start without me."
case "numbers": "Running 10 min late, home by 7:3"
case "shift": "Running 10 min late. "
case "typing": "Running 10 min teh"
case "accents": "Caf"
default: "Running 10 min late, "
}
}
var body: some View {
let ink = darkApp ? HexTheme.textBase : Color(red: 0x14 / 255, green: 0x16 / 255, blue: 0x1B / 255)
let canvas = darkApp
? Color(red: 0x09 / 255, green: 0x0A / 255, blue: 0x0C / 255)
: Color(red: 0xF5 / 255, green: 0xF6 / 255, blue: 0xF8 / 255)
let backdrop = FullKeyboardPalette(isDark: darkApp || darkField).backdrop
VStack(spacing: 0) {
Spacer()
Text(draft)
.font(.system(size: 15))
.foregroundStyle(ink)
.frame(maxWidth: .infinity, alignment: .leading)
.padding(.horizontal, 14)
.padding(.vertical, 10)
.background(
darkApp ? Color(red: 0x13 / 255, green: 0x15 / 255, blue: 0x19 / 255) : .white,
in: Capsule()
)
.padding(.horizontal, 14)
.padding(.bottom, 10)
FullKeyboardFixture(state: state, draft: draft, darkKeyboard: darkApp || darkField)
.frame(height: KeyboardLayout.height(for: .portrait, numberRow: FullKeyboardSettings().numberRow)
+ (state == "emoji-search" ? KeyboardMetrics.for(.portrait).stripHeight : 0)
// `--short-by 20`: a view shorter than the keyboard asks for, as iOS gives in Spotlight.
- (Self.argument(after: "--short-by").flatMap(Double.init).map { CGFloat($0) } ?? 0))
.background(Color(uiColor: backdrop).ignoresSafeArea(edges: .bottom))
}
.background(canvas.ignoresSafeArea())
.preferredColorScheme(darkApp ? .dark : .light)
}
}
private struct FullKeyboardFixture: UIViewRepresentable {
let state: String
let draft: String
let darkKeyboard: Bool
@MainActor
final class Coordinator {
let model = KeyboardViewModel()
let target: FixtureTextTarget
init(draft: String, darkKeyboard: Bool) {
target = FixtureTextTarget(text: draft, appearance: darkKeyboard ? .dark : .light)
}
}
func makeCoordinator() -> Coordinator {
Coordinator(draft: draft, darkKeyboard: darkKeyboard)
}
func makeUIView(context: Context) -> FullKeyboardView {
let model = context.coordinator.model
model.needsGlobeKey = false
let now: TimeInterval = 10_000
let warm = KeyboardSnapshot(state: .ready, heartbeat: now - 0.1, expiresAt: now + 14 * 60)
switch state {
case "recording":
model.configureFixture(
snapshot: KeyboardSnapshot(
state: .recording,
heartbeat: now - 0.05,
expiresAt: now + 15 * 60,
recordingStartedAt: now - 5,
audioLevel: 0.78,
loudnessDB: -31,
jobID: "snap-job"
),
now: now
)
case "transcribing":
model.configureFixture(
snapshot: KeyboardSnapshot(state: .transcribing, heartbeat: now - 0.05, expiresAt: now + 15 * 60, jobID: "snap-job"),
now: now
)
case "cold":
model.configureFixture(snapshot: .offline, now: now)
case "language-unavailable":
// In-keyboard dictation on an iPhone whose Apple Speech can't install Russian.
let unavailable = SpeechModelUnavailable(language: "ru-RU", reason: .notOnThisIPhone, fallback: "en-US")
model.configureFixture(
snapshot: KeyboardSnapshot(
state: .failed,
heartbeat: now,
expiresAt: now + 6,
message: UserFacingError.message(for: unavailable, context: .transcription)
),
now: now
)
case "no-access", "no-access-hint":
model.configureFixture(snapshot: .offline, now: now, hasFullAccess: false)
default:
model.configureFixture(snapshot: warm, now: now)
}
DictationLanguageFixture.apply(to: model)
let view = FullKeyboardView(model: model, target: context.coordinator.target)
if state.hasPrefix("emoji") {
view.emojiOverride = true
let usage = EmojiFixture.usage()
view.makeEmojiUsage = { usage }
}
let args = ProcessInfo.processInfo.arguments
if let p = args.firstIndex(of: "--hex-placement"), p + 1 < args.count {
view.hexPlacementOverride = HexKeyPlacement(rawValue: args[p + 1])
}
view.languageOverride = FullKeyboardSnapshotStage.layout
view.letterLayoutOverride = FullKeyboardSnapshotStage.argument(after: "--keyboard-letters")
.flatMap(KeyboardLetterLayout.init(rawValue:)) ?? FullKeyboardSnapshotStage.layout.defaultLetterLayout
view.appearanceOverride = darkKeyboard
view.orientationOverride = .portrait
view.drawsBackdrop = true
view.prepareForField()
view.warmUpTextCheckerAsync()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
switch state {
case "paste-notice":
view.showAllowPasteHint()
case "pressed":
view.debugPress("g")
case "accents":
let key = FullKeyboardSnapshotStage.accentKey
let serbian = FullKeyboardSnapshotStage.layout == .serbianLatin
let ownLetters: [String: String] = switch FullKeyboardSnapshotStage.layout {
case .polish: ["e": "ę", "a": "ą", "c": "ć", "l": "ł", "n": "ń", "o": "ó", "s": "ś", "z": "ż"]
case .romanian: ["a": "ă", "i": "î", "s": "ș", "t": "ț"]
case .czech: ["e": "ě", "r": "ř", "u": "ů", "a": "á", "c": "č", "s": "š", "z": "ž", "y": "ý", "n": "ň"]
case .hungarian: ["a": "á", "e": "é", "i": "í", "o": "ő", "u": "ű"]
case .greek: ["ε": "έ", "α": "ά", "ο": "ό", "η": "ή", "ι": "ί", "υ": "ύ", "ω": "ώ", "σ": "ς", "κ": "ϗ"]
default: [:]
}
let pick = ownLetters[key] ?? [
"e": "é", "s": serbian ? "š" : "ß", "ø": "ö", "æ": "ä", "a": "á", "o": "ó", "n": "ñ", "u": "ú",
"i": "ì", "е": "ё", "ь": "ъ", "c": "ć", "ʼ": "’",
][key]
view.debugHoldAccent(key, selecting: pick ?? key)
case "numbers":
view.engine.touchBegan(id: 900, at: center(of: .layerSwitch(.numbers), in: view))
view.engine.touchEnded(id: 900, at: center(of: .layerSwitch(.numbers), in: view))
view.debugPress("3")
case "symbols":
for kind in [KeyKind.layerSwitch(.numbers), .layerSwitch(.symbols)] {
view.engine.touchBegan(id: 901, at: center(of: kind, in: view))
view.engine.touchEnded(id: 901, at: center(of: kind, in: view))
}
case "capslock":
view.engine.touchBegan(id: 902, at: center(of: .shift, in: view))
view.engine.touchEnded(id: 902, at: center(of: .shift, in: view))
view.engine.touchBegan(id: 903, at: center(of: .shift, in: view))
view.engine.touchEnded(id: 903, at: center(of: .shift, in: view))
case "inserted":
view.didInsertDictation("should be home by 7:30. Start without me.")
// The bar's other states, set on the strip directly: a revert, Paste, Paste dictation,
// Code from Messages (with and without a copied code) and the two-thumb selection.
case "strip-revert":
view.stripView.update(suggestions: [
KeyboardSuggestion(displayText: "teh", replacement: "teh", kind: .revert),
KeyboardSuggestion(displayText: "then", replacement: "then", kind: .secondary),
KeyboardSuggestion(displayText: "tech", replacement: "tech", kind: .secondary),
], showsUndo: false, statusText: nil)
case "strip-two":
view.stripView.update(suggestions: [
KeyboardSuggestion(displayText: "\u{201C}lol\u{201D}", replacement: "lol", kind: .keepLiteral),
KeyboardSuggestion(displayText: "lot", replacement: "lot", kind: .secondary),
], showsUndo: false, statusText: nil)
case "strip-paste":
view.stripView.update(suggestions: [], showsUndo: false, statusText: nil, clipboard: .paste)
case "strip-paste-dictation":
view.stripView.update(suggestions: [], showsUndo: false, statusText: nil, clipboard: .dictation)
case "strip-code":
view.stripView.update(suggestions: [], showsUndo: false, statusText: nil, clipboard: .code(canPaste: true))
case "strip-selection":
view.stripView.isHidden = true
view.selectionStrip.update(TrackpadSelectionSession.Presentation(phase: .actions, before: "Running 10 ", selected: "min late", after: ", home by"), canUseClipboard: true)
case "emoji":
view.debugOpenEmoji()
case "emoji-search":
view.debugOpenEmoji(search: FullKeyboardSnapshotStage.emojiQuery)
case "emoji-tones":
view.debugOpenEmoji()
view.emojiPanel?.debugShowTones(for: "👍", selecting: 3)
case "emoji-food":
view.debugOpenEmoji()
view.emojiPanel?.debugJump(toSection: 3)
case "emoji-probe":
EmojiFixture.probe(view)
case "no-access-hint":
// The Hex key tapped without Full Access.
view.showFullAccessHint()
case "style":
view.debugShowStyleMenu()
case "languages":
view.debugShowStyleMenu(page: .languages)
case "languages-remove":
view.debugOfferRemove(model.languageChoices[1])
case "more-languages":
view.debugShowStyleMenu(page: .moreLanguages)
case "translation":
view.debugShowStyleMenu(page: .translation)
case "morph":
// Loops idle → recording → idle so the strip morph can be screen-recorded.
func cycle(_ start: TimeInterval) {
DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {
model.configureFixture(
snapshot: KeyboardSnapshot(
state: .recording,
heartbeat: start,
expiresAt: start + 15 * 60,
recordingStartedAt: start - 1,
audioLevel: 0.7,
loudnessDB: -30,
jobID: "snap-job"
),
now: start
)
DispatchQueue.main.asyncAfter(deadline: .now() + 2.4) {
model.configureFixture(snapshot: warm, now: start)
cycle(start)
}
}
}
cycle(now)
default:
break
}
}
return view
}
func updateUIView(_ uiView: FullKeyboardView, context: Context) {}
}
/// A seeded emoji history for the scenes, and the probe that measures the panel.
@MainActor
enum EmojiFixture {
static func usage() -> EmojiUsageStore {
let defaults = UserDefaults(suiteName: "anomaly.hex.fixture.emoji")
defaults?.removePersistentDomain(forName: "anomaly.hex.fixture.emoji")
let store = EmojiUsageStore(defaults: defaults)
for (emoji, times) in [("😂", 6), ("❤️", 5), ("👍", 4), ("🙏", 3), ("🔥", 3), ("😭", 2), ("🥹", 2), ("☕", 1)] {
for _ in 0..<times { store.record(emoji) }
}
store.setTone(3, for: "👍")
store.setTone(3, for: "🙏")
return store
}
private static func footprint() -> Double {
var info = task_vm_info_data_t()
var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size)
let result = withUnsafeMutablePointer(to: &info) {
$0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
}
}
return result == KERN_SUCCESS ? Double(info.phys_footprint) / 1_048_576 : -1
}
private static func log(_ message: String) {
print("EMOJI_PROBE \(message) footprint=\(String(format: "%.2f", footprint()))MB")
}
/// Opens the panel, pages through every section, searches, closes, and repeats the open
/// ten times, printing footprints and the open latencies.
static func probe(_ view: FullKeyboardView) {
log("keyboard")
var steps: [(TimeInterval, () -> Void)] = []
var latencies: [Double] = []
steps.append((1.0, { view.debugOpenEmoji(); latencies.append(view.lastEmojiPanelLatency ?? -1) }))
steps.append((1.0, { log("panel open, first time, latency=\(String(format: "%.1f", latencies[0] * 1000))ms") }))
// A category tapped every 8 frames, each for the first time, then each again: the
// longest frame after each tap (60 fps is 16.7 ms).
steps.append((0.3, {
let order = [3, 7, 1, 5, 8, 2, 6, 4, 3, 7, 1, 5, 8, 2, 6, 4, 0]
var frame = 0
var lastTick: CFTimeInterval = 0
var worst: [Double] = Array(repeating: 0, count: order.count)
FrameProbe.run(step: {
let now = CACurrentMediaTime()
let tap = frame / 8
if lastTick > 0, tap > 0, frame % 8 != 0 || tap <= order.count {
let owner = frame % 8 == 0 ? tap - 1 : tap
if owner < order.count { worst[owner] = max(worst[owner], now - lastTick) }
}
lastTick = now
if frame % 8 == 0, tap < order.count { view.emojiPanel?.debugJump(toSection: order[tap]) }
frame += 1
return tap < order.count
}) { _, _ in
func ms(_ values: ArraySlice<Double>) -> String { values.map { String(format: "%.0f", $0 * 1000) }.joined(separator: " ") }
log("category taps, longest frame after each (ms): first visits \(ms(worst[0..<8])) | again \(ms(worst[8..<16]))")
}
}))
steps.append((3.0, {}))
for section in 1...8 {
steps.append((0.3, { view.emojiPanel?.debugJump(toSection: section) }))
}
steps.append((0.5, { log("panel open, every section drawn") }))
// Every emoji: the grid scrolled from the first column to the last, a screen at a time.
steps.append((0.3, { view.emojiPanel?.debugJump(toSection: 0) }))
for page in 0..<60 {
steps.append((0.05, { view.emojiPanel?.debugScroll(toPage: page) }))
}
steps.append((0.5, {
guard let glyphs = view.emojiPanel?.glyphs else { return }
let average = glyphs.renders > 0 ? glyphs.renderTime / Double(glyphs.renders) * 1000 : 0
log("panel open, every emoji drawn, renders=\(glyphs.renders) fonts=\(glyphs.fontsMade) slowest font=\(String(format: "%.2f", glyphs.slowestFont * 1000))ms private=\(glyphs.hasPrivateFont) render avg=\(String(format: "%.2f", average))ms max=\(String(format: "%.2f", glyphs.slowestRender * 1000))ms cached=\(glyphs.cachedCount) \(glyphs.cachedBytes / 1024)KB")
}))
// A fast fling's pace, 40 pt a frame from the start to the end: each frame's work.
steps.append((0.3, { view.emojiPanel?.debugJump(toSection: 1) }))
steps.append((0.5, {
FrameProbe.run(step: { view.emojiPanel?.debugScroll(by: 40) ?? false }) { work, gaps in
let sorted = work.sorted()
func ms(_ value: Double) -> String { String(format: "%.2f", value * 1000) }
log("scrolled every emoji at 40 pt a frame, frames=\(sorted.count) work p50=\(ms(sorted[sorted.count / 2]))ms p95=\(ms(sorted[sorted.count * 95 / 100]))ms max=\(ms(sorted.last ?? 0))ms frames over 16.7ms=\(sorted.filter { $0 > 1.0 / 60 }.count) late frames=\(gaps)")
}
}))
steps.append((6.0, {}))
steps.append((0.2, {
view.beginEmojiSearch()
for character in "pizza" { view.routedTarget.insertText(String(character)) }
view.refreshEmojiSearch()
}))
steps.append((0.5, { log("searching") }))
steps.append((0.2, { view.closeEmojiPanel() }))
steps.append((1.0, { log("panel closed") }))
for _ in 0..<10 {
steps.append((0.3, { view.openEmojiPanel(); latencies.append(view.lastEmojiPanelLatency ?? -1) }))
steps.append((0.3, { view.closeEmojiPanel() }))
}
steps.append((1.0, {
let warm = latencies.dropFirst().map { $0 * 1000 }.sorted()
log("panel closed after 11 opens, warm open latency median=\(String(format: "%.1f", warm[warm.count / 2]))ms max=\(String(format: "%.1f", warm.last ?? 0))ms")
let before = footprint()
let start = CACurrentMediaTime()
let library = EmojiLibrary.load(language: "en", bundle: Bundle(for: FullKeyboardView.self))
let semantic = library.flatMap { EmojiSemanticIndex(language: "en", vocabulary: $0.vocabulary) }
let built = CACurrentMediaTime() - start
log("semantic index built=\(semantic != nil) in \(String(format: "%.0f", built * 1000))ms, +\(String(format: "%.2f", footprint() - before))MB")
_ = semantic?.neighbors(of: "congrats")
}))
func run(_ index: Int) {
guard index < steps.count else {
log("done")
return
}
DispatchQueue.main.asyncAfter(deadline: .now() + steps[index].0) {
steps[index].1()
run(index + 1)
}
}
run(0)
}
}
/// Probes: calls `step` once a frame until it returns false, timing each call, then
/// reports the times and how many frames came late (over 1.5 frames after the last).
@MainActor
final class FrameProbe: NSObject {
private let step: () -> Bool
private let done: ([Double], Int) -> Void
private var link: CADisplayLink?
private var work: [Double] = []
private var last: CFTimeInterval = 0
private var late = 0
private static var running: [FrameProbe] = []
private init(step: @escaping () -> Bool, done: @escaping ([Double], Int) -> Void) {
self.step = step
self.done = done
}
static func run(step: @escaping () -> Bool, done: @escaping ([Double], Int) -> Void) {
let probe = FrameProbe(step: step, done: done)
running.append(probe)
let link = CADisplayLink(target: probe, selector: #selector(tick(_:)))
link.preferredFrameRateRange = CAFrameRateRange(minimum: 60, maximum: 60, preferred: 60)
link.add(to: .main, forMode: .common)
probe.link = link
}
@objc private func tick(_ link: CADisplayLink) {
if last > 0, link.timestamp - last > 1.5 / 60 { late += 1 }
last = link.timestamp
let started = CACurrentMediaTime()
let more = step()
work.append(CACurrentMediaTime() - started)
guard !more else { return }
link.invalidate()
done(work, late)
Self.running.removeAll { $0 === self }
}
}
@MainActor
private func center(of kind: KeyKind, in view: FullKeyboardView) -> CGPoint {
guard let key = view.engine.layout.key(kind) else { return .zero }
return CGPoint(x: key.frame.midX, y: key.frame.midY)
}
@MainActor
class FixtureTextTarget: KeyboardTextTarget {
private(set) var text: String
private(set) var cursorIndex: Int
let keyboardAppearance: UIKeyboardAppearance?
var autocapitalizationType: UITextAutocapitalizationType? = .sentences
var autocorrectionType: UITextAutocorrectionType? = .default
var keyboardType: UIKeyboardType? = .default
var returnKeyType: UIReturnKeyType? = .default
var enablesReturnKeyAutomatically: Bool? = false
var smartQuotesType: UITextSmartQuotesType?
var smartDashesType: UITextSmartDashesType?
var selectedText: String?
var documentIdentifier: UUID?
/// Simulates a host whose window reports no text after the cursor.
var hidesAfterText = false
init(text: String = "", appearance: UIKeyboardAppearance? = nil) {
self.text = text
self.cursorIndex = text.count
keyboardAppearance = appearance
}
var documentContextBeforeInput: String? {
let clamped = max(0, min(text.count, cursorIndex))
let idx = text.index(text.startIndex, offsetBy: clamped)
return String(text[..<idx])
}
var documentContextAfterInput: String? {
hidesAfterText ? nil : String(text.dropFirst(max(0, min(text.count, cursorIndex))))
}
var hasText: Bool { !text.isEmpty }
func insertText(_ inserted: String) {
let clamped = max(0, min(text.count, cursorIndex))
let idx = text.index(text.startIndex, offsetBy: clamped)
text.insert(contentsOf: inserted, at: idx)
cursorIndex = clamped + inserted.count
}
func deleteBackward() {
let clamped = max(0, min(text.count, cursorIndex))
guard clamped > 0 else { return }
let removeIdx = text.index(text.startIndex, offsetBy: clamped - 1)
text.remove(at: removeIdx)
cursorIndex = clamped - 1
}
func adjustTextPosition(byCharacterOffset offset: Int) {
cursorIndex = max(0, min(text.count, cursorIndex + offset))
}
}