hex/ios/HEXShared/FullKeyboard/KeyboardStripView.swift
Ryan Vogel 87b5214f46
iOS keyboard: Code from Messages opens the keyboard list where the switch could land on Emoji, and needs no Full Access (#2384)
* iOS keyboard: Code from Messages only where its tap reaches Apple's keyboard, and without Full Access

TestFlight build 126 (iPhone 15 Pro, iOS 27.3): "That autofill for texted codes fails".

Cause, shown on an iPhone 15 Pro simulator (iOS 27.2) with real touches: the chip switches
with advanceToNextInputMode. On a number pad that always lands on Apple's number pad (Emoji and
other third-party keyboards are passed over). On any other code field (Safari's
autocomplete=one-time-code input, a .oneTimeCode field with autocorrection off) it lands on
Emoji in 10 of 21 taps with English + Emoji + Hex (iPhone's default list plus Hex, in any
order), and on another third-party keyboard in 4 of 8 taps with one in the list. Those get no
code, so the chip does nothing. Separately, the chip needed Full Access, though switching
keyboards doesn't.

Change (KeyboardClipboardTracker.offer, KeyboardInputModes.switchReachesAppleKeyboard):
- Outside number pads, Code from Messages shows only when every other keyboard is one of
  Apple's language keyboards (no Emoji, no other third-party keyboard). Removed: the chip in
  Safari's text-style code fields for anyone with Emoji on; a copied code still gets Paste.
  Number pads (including Safari's inputmode=numeric) keep it in every list with Apple's keyboard.
- The chip no longer needs Full Access; Paste still does and still reads nothing without it.
- The comment that said the switch skips Emoji in either order is corrected.

Verified on that simulator, the fixed build:
- English + Emoji + Hex: Safari one-time-code and a .oneTimeCode autocorrection-off field show no
  chip (Paste only with a copy); a number-pad field and inputmode=numeric show it and the tap
  lands on Apple's number pad.
- English + Hex: chip in both kinds, tap lands on Apple's keyboard. Hex + another third-party
  keyboard + English: text field no chip, number pad chip -> Apple's number pad.
- Full Access off (English + Hex): chip shows in both kinds and lands on Apple's keyboard;
  with Emoji, on the number pad only. No Paste chip without Full Access.
- Before the change on origin/dev (fd4e98bb, the 44 pt bar): the chip draws and takes its tap
  upright and turned, at its edges, and beside Paste.
- xcodebuild test on the rebased head: 857 tests, 3 skipped, 0 failures, including the new
  KeyboardClipboardTests.testCodeFromMessagesOnlyWhereTheSwitchReachesApplesKeyboard.
- code-shape.py passes. Not verified: whether Apple's keyboard then shows the code (a simulator
  gets no texts), or a real phone.

* iOS keyboard: Code from Messages opens the keyboard list where the next keyboard could be Emoji

Follow-up to the previous commit, at the coordinator's request: hiding the chip in text-style
code fields whenever Emoji or another third-party keyboard is on took it away from almost
everyone (Emoji is on by default) with no pointer to where codes come from.

Change:
- Where advanceToNextInputMode could land elsewhere (Emoji or another third-party keyboard on,
  field not a number pad), the chip stays and a tap opens iOS's own keyboard list, where the
  person picks Apple's keyboard. Replaced: the previous commit's hiding of the chip there.
  KeyboardInputModes.route gives .next or .list (nil without Apple's keyboard);
  KeyboardClipboardOffer.code gains opensList (default false).
- The chip's touches go to handleInputModeList(from:with:) as the globe's do, through the
  globe's own path (FullKeyboardView.inputModeListTouch, split out of globeTouch unchanged): the
  lift of a touch that stayed on the chip is held back, so UIKit's 0.2 s hold opens the list
  (as the globe does on the Duo's split posture, #2340). A hold shows it under the finger, and
  a slide onto a keyboard picks it on lift. The chip's .touchUpInside does nothing in that mode.
- Number pads and lists with only Apple's keyboards besides Hex keep the direct switch.
- Accessibility hint in list mode: "Shows your keyboards: pick Apple's, where iOS offers codes
  from Messages and Mail" (zh-Hans added). The direct mode keeps its hint.
- showsPasteChip matches .code(canPaste: false, _) so the list mode doesn't show Paste.

Verified (iPhone 15 Pro simulator, iOS 27.2, real touches; Apple's keyboard told apart through
its keys in the accessibility tree):
- List mode, a pick of English (US) from the list: 55 of 56 picks landed on Apple's keyboard
  across English + Emoji + Hex, Hex + Emoji + English, Hex + another third-party + English and
  English + Hex + another third-party; Safari one-time-code and a .oneTimeCode field with
  autocorrection off; upright and turned; beside Paste; Full Access on and off; tap, hold and
  slide-and-lift. The one miss ended on Hex with the list gone; once, the direct switch did
  the same (shown on Apple's keyboard, then Hex again half a second later), so it isn't
  specific to the list.
- Direct mode unchanged: number pads in every list and English + Hex reach Apple's keyboard
  with no list.
- On the head rebased onto #2386 (Paste alone takes the whole bar): 5 more list picks and 2
  number-pad switches reach Apple's keyboard, and Paste beside the chip still pastes.
- xcodebuild test on that head: 858 tests, 3 skipped, 0 failures, including
  testCodeFromMessagesOpensTheListWhereTheSwitchCouldMissApplesKeyboard. code-shape.py passes.
- Not verified: VoiceOver with the list mode, a real phone, and whether Apple's keyboard then
  shows the code (a simulator gets no texts).
2026-11-22 12:02:17 -05:00

943 lines
46 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 UIKit
/// The 3-slot top bar above the keys, drawn as Apple's iOS 26 predictive bar is (measured in
/// the iOS 27.2 simulator): SF 17 pt regular in muted ink, slots a third of the keyboard wide,
/// 1 × 24 pt dividers ending on the thirds, and a pending autocorrection as a full-slot
/// capsule with the dividers beside it hidden. On an iPhone the strip is Apple's whole 44 pt
/// bar (`KeyboardMetrics.appleBar`): words, dividers and the cell-wide 38 pt bubble on Apple's
/// line, 25 pt below the keyboard's top edge (`KeyboardMetrics.stripTextCenter`). Before it was
/// measured (iOS 18) it is the bar from its pill's top down (38 pt), with a small chip around a
/// word instead of the capsule. The centred
/// `Undo dictation` chip or a status message replaces the slots when needed.
@MainActor
final class KeyboardStripView: UIView {
var palette = FullKeyboardPalette(isDark: false) { didSet { if palette != oldValue { applyPalette() } } }
/// Hosted in iOS's platter (not a snapshot scene's own backdrop).
var inSystemPlatter = true {
didSet {
guard inSystemPlatter != oldValue else { return }
for button in slotButtons { button.inSystemPlatter = inSystemPlatter }
setNeedsLayout()
setNeedsDisplay()
}
}
/// Each slot's frame in this view, from `KeyboardLayout.stripSlotFrames`; thirds of the
/// view until the keyboard lays it out.
var slotFrames: [CGRect]? { didSet { if slotFrames != oldValue { setNeedsLayout(); setNeedsDisplay() } } }
/// Where the words and dividers centre, from the strip's top (`KeyboardMetrics.stripTextCenter`).
var textCenterY: CGFloat? {
didSet {
guard textCenterY != oldValue else { return }
for button in slotButtons { button.textCenterY = textCenterY }
setNeedsLayout()
setNeedsDisplay()
}
}
/// A suggestion's chip and the dividers' height (`KeyboardMetrics.stripChipHeight`).
var chipHeight: CGFloat? {
didSet {
guard chipHeight != oldValue else { return }
for button in slotButtons { button.chipHeight = chipHeight }
setNeedsLayout()
setNeedsDisplay()
}
}
/// The strip is Apple's bar (`KeyboardMetrics.appleBar`): a pending word gets Apple's bubble,
/// its cell's width, and the dividers beside it hide, as Apple's do.
var appleBar = false {
didSet {
guard appleBar != oldValue else { return }
for button in slotButtons { button.fillsCell = appleBar }
setNeedsDisplay()
}
}
/// The Hex key has a cell of its own at the strip's end (Apple's bar): a divider stands
/// between it and the slot beside it, as between Apple's icon and its first cell.
var dividerBesideHex = false { didSet { if dividerBesideHex != oldValue { setNeedsDisplay() } } }
/// How far the pills sit in from the strip's top and bottom (`KeyboardMetrics.stripInset`).
var pillInset: CGFloat = 0.5 {
didSet {
guard pillInset != oldValue else { return }
for button in slotButtons { button.pillInset = pillInset }
setNeedsLayout()
}
}
var onSelectSuggestion: ((KeyboardSuggestion) -> Void)?
/// A slot was held (half a second): the word you typed offers Add to vocabulary.
var onHoldSuggestion: ((KeyboardSuggestion) -> Void)?
var onUndoDictation: (() -> Void)?
var onPaste: (() -> Void)?
var onNextKeyboard: (() -> Void)?
/// Code from Messages' touches where it opens iOS's keyboard list (`.code(opensList: true)`).
var onKeyboardListTouch: ((UIButton, UIEvent) -> Void)?
/// The Full Access hint's Open Hex was tapped (it opens Hex's setup).
var onOpenHexFromHint: (() -> Void)?
/// The notice's chip was tapped (`KeyboardStripNotice`).
var onOpenNotice: (() -> Void)?
private let statusLabel = UILabel()
private let undoChip = UIButton(type: .custom)
private let slotButtons: [SlotButton] = [SlotButton(), SlotButton(), SlotButton()]
private var currentSuggestions: [KeyboardSuggestion] = []
private var showsUndo = false
private var statusText: String?
private var clipboard: KeyboardClipboardOffer?
private var showsFullAccessHint = false
/// Built the first time the Hex key is tapped without Full Access.
private var fullAccessHintView: FullAccessHintView?
private var notice: KeyboardStripNotice?
/// Built for the first notice, in the Full Access hint's shape.
private var noticeView: FullAccessHintView?
/// The Hex key sits left of the strip (Settings › Keyboard › Hex key): the Full Access
/// hint's Open Hex leads, beside the key.
var hexOnLeading = false {
didSet {
guard hexOnLeading != oldValue else { return }
fullAccessHintView?.chipLeads = hexOnLeading
noticeView?.chipLeads = hexOnLeading
setNeedsLayout()
}
}
/// Where the bar's middle slot centres, from this view's leading edge: the keyboard's middle,
/// not this view's, which leaves out the Hex key. Paste and Next keyboard centre on it.
var barMidX: CGFloat? { didSet { if barMidX != oldValue { setNeedsLayout() } } }
/// The bar around this view, in its coordinates: from the keyboard's top to the bar's bottom
/// and across it up to the Hex key's cell. While Paste (or Paste dictation) is the only chip,
/// a tap anywhere on it pastes; beside Code from Messages each chip keeps its own frame. The
/// Hex key and row 1's reach, laid over it, keep theirs.
var barTouchFrame: CGRect? { didSet { if barTouchFrame != oldValue { setNeedsLayout() } } }
/// Plain text on the words' line, as a suggestion is: `UIPasteControl` renders as an empty
/// blue box inside a keyboard extension (TestFlight build 4), so this reads the clipboard on
/// tap instead, once, which iOS asks about until Paste from Other Apps is Allow
/// (`KeyboardClipboardTracker`).
private let pasteControl = StripChip()
private let nextKeyboardChip = UIButton(type: .custom)
override init(frame: CGRect) {
super.init(frame: frame)
isOpaque = false
backgroundColor = .clear
contentMode = .redraw
statusLabel.font = .systemFont(ofSize: 13.5)
statusLabel.textAlignment = .center
statusLabel.adjustsFontSizeToFitWidth = true
statusLabel.minimumScaleFactor = 0.8
statusLabel.isHidden = true
addSubview(statusLabel)
var chip = UIButton.Configuration.plain()
chip.image = UIImage(
systemName: "arrow.uturn.backward",
withConfiguration: UIImage.SymbolConfiguration(pointSize: 12.5, weight: .medium)
)
chip.imagePadding = 6
chip.title = String(localized: "Undo dictation")
chip.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 13, bottom: 0, trailing: 13)
chip.background.cornerRadius = 15
undoChip.configuration = chip
undoChip.isHidden = true
undoChip.addTarget(self, action: #selector(handleUndo), for: .touchUpInside)
// Apple's bar words: SF 17 pt regular in the bar's ink, no chip.
var paste = UIButton.Configuration.plain()
paste.image = UIImage(
systemName: "doc.on.clipboard",
withConfiguration: UIImage.SymbolConfiguration(font: Self.pasteFont, scale: .small)
)
paste.imagePadding = 5
paste.title = String(localized: "Paste")
paste.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { attributes in
var attributes = attributes
attributes.font = Self.pasteFont
return attributes
}
paste.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 8, bottom: 0, trailing: 8)
paste.background.backgroundColor = .clear
pasteControl.configuration = paste
pasteControl.isHidden = true
pasteControl.addTarget(self, action: #selector(handlePaste), for: .touchUpInside)
addSubview(pasteControl)
addSubview(undoChip)
var next = UIButton.Configuration.plain()
next.image = UIImage(
systemName: "keyboard",
withConfiguration: UIImage.SymbolConfiguration(pointSize: 12.5, weight: .medium)
)
next.imagePadding = 6
next.title = String(localized: "Code from Messages")
next.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 13, bottom: 0, trailing: 13)
next.background.cornerRadius = 15
nextKeyboardChip.configuration = next
nextKeyboardChip.isHidden = true
nextKeyboardChip.addTarget(self, action: #selector(handleNextKeyboard), for: .touchUpInside)
nextKeyboardChip.addTarget(self, action: #selector(keyboardListTouch(_:with:)), for: .allTouchEvents)
addSubview(nextKeyboardChip)
for (index, button) in slotButtons.enumerated() {
button.tag = index
button.addTarget(self, action: #selector(handleSlotTap(_:)), for: .touchUpInside)
button.addGestureRecognizer(UILongPressGestureRecognizer(target: self, action: #selector(handleSlotHold(_:))))
addSubview(button)
}
applyPalette()
}
@available(*, unavailable)
required init?(coder: NSCoder) { fatalError() }
private static let pasteFont = UIFont.systemFont(ofSize: 17, weight: .regular)
/// `fullAccessHint`, while true, replaces everything else in the strip with what
/// dictation needs (`FullAccessHintView`); `notice` does the same after it.
func update(
suggestions: [KeyboardSuggestion],
showsUndo: Bool,
statusText: String?,
clipboard: KeyboardClipboardOffer? = nil,
fullAccessHint: Bool = false,
notice: KeyboardStripNotice? = nil
) {
let changed = suggestions != currentSuggestions || showsUndo != self.showsUndo
|| statusText != self.statusText || clipboard != self.clipboard
|| fullAccessHint != showsFullAccessHint || notice != self.notice
guard changed else { return }
currentSuggestions = suggestions
self.showsUndo = showsUndo
self.statusText = statusText
self.clipboard = clipboard
showsFullAccessHint = fullAccessHint
self.notice = notice
if fullAccessHint, fullAccessHintView == nil { _ = makeFullAccessHintView() }
if let hint = fullAccessHintView { show(hint, fullAccessHint) }
if let notice, noticeView == nil { _ = makeNoticeView() }
if let notice { noticeView?.show(notice) }
if let noticeView { show(noticeView, notice != nil && !fullAccessHint) }
let showsHint = fullAccessHint || notice != nil
show(undoChip, showsUndo && !showsHint)
let showsClipboard = showsClipboard
var paste = pasteControl.configuration
let pasteTitle = clipboard == .dictation ? String(localized: "Paste dictation") : String(localized: "Paste")
if paste?.title != pasteTitle {
paste?.title = pasteTitle
pasteControl.configuration = paste
}
show(pasteControl, showsPasteChip)
show(nextKeyboardChip, showsNextKeyboardChip)
nextKeyboardChip.accessibilityHint = chipOpensList
? String(localized: "Shows your keyboards: pick Apple's, where iOS offers codes from Messages and Mail")
: String(localized: "Switches to the next keyboard, where iOS offers codes from Messages and Mail")
// Words swap letter by letter (and leave the same way when a chip or status takes the
// strip); the strip being shown for the first time just draws them.
let animated = window != nil
if showsHint || showsUndo || showsClipboard {
statusLabel.isHidden = true
slotButtons.forEach { $0.configure(with: nil, palette: palette, animated: animated) }
} else if let statusText, suggestions.isEmpty {
statusLabel.text = statusText
statusLabel.isHidden = false
slotButtons.forEach { $0.configure(with: nil, palette: palette, animated: false) }
} else {
statusLabel.isHidden = true
let slots = Self.slots(for: suggestions)
for (idx, button) in slotButtons.enumerated() {
let item = slots.firstIndex(of: idx).map { suggestions[$0] }
button.configure(with: item, palette: palette, animated: animated)
}
}
setNeedsLayout()
setNeedsDisplay()
}
/// Shows or hides a chip, fading it over Apple's 0.2 s word swap (at once with Reduce Motion).
private func show(_ view: UIView, _ shown: Bool) {
let visible = !view.isHidden && view.alpha > 0
guard shown != visible || (shown && view.alpha < 1) else { return }
guard window != nil, !UIAccessibility.isReduceMotionEnabled else {
view.layer.removeAllAnimations()
view.alpha = 1
view.isHidden = !shown
return
}
if shown {
if view.isHidden { view.alpha = 0 }
view.isHidden = false
}
UIView.animate(withDuration: 0.2, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction, .curveEaseOut]) {
view.alpha = shown ? 1 : 0
} completion: { _ in
guard view.alpha == 0 else { return }
view.isHidden = true
view.alpha = 1
}
}
/// Which slot shows each suggestion: in order, except a lone emoji, swiped word or reading
/// of one, which takes the centre. A revert keeps the left slot.
static func slots(for suggestions: [KeyboardSuggestion]) -> [Int] {
if suggestions.count == 1, ![.keepLiteral, .secondary, .revert].contains(suggestions[0].kind) { return [1] }
return Array(suggestions.indices.prefix(3))
}
/// Clipboard chips replace the empty strip; suggestions and status win.
private var showsClipboard: Bool {
guard let clipboard, !showsUndo, statusText == nil, !showsFullAccessHint, notice == nil else { return false }
if case .code = clipboard { return true }
return currentSuggestions.isEmpty
}
private var showsPasteChip: Bool {
if case .code(canPaste: false, _)? = clipboard { return false }
return showsClipboard
}
private var chipOpensList: Bool {
if case .code(_, opensList: true)? = clipboard { return true }
return false
}
private var showsNextKeyboardChip: Bool {
guard showsClipboard, case .code = clipboard else { return false }
return true
}
@objc private func handlePaste() {
onPaste?()
}
@objc private func handleNextKeyboard() {
guard !chipOpensList else { return }
onNextKeyboard?()
}
@objc private func keyboardListTouch(_ sender: UIButton, with event: UIEvent) {
guard chipOpensList else { return }
onKeyboardListTouch?(sender, event)
}
private func makeFullAccessHintView() -> FullAccessHintView {
let hint = FullAccessHintView()
hint.chipLeads = hexOnLeading
hint.onOpenHex = { [weak self] in self?.onOpenHexFromHint?() }
hint.isHidden = true
addSubview(hint)
fullAccessHintView = hint
applyPalette()
setNeedsLayout()
return hint
}
private func makeNoticeView() -> FullAccessHintView {
let view = FullAccessHintView()
view.chipLeads = hexOnLeading
view.onOpenHex = { [weak self] in self?.onOpenNotice?() }
view.isHidden = true
addSubview(view)
noticeView = view
applyPalette()
setNeedsLayout()
return view
}
private func applyPalette() {
statusLabel.textColor = palette.textMuted
var paste = pasteControl.configuration
paste?.baseForegroundColor = palette.stripText
pasteControl.configuration = paste
var next = nextKeyboardChip.configuration
next?.baseForegroundColor = palette.textMuted
next?.background.backgroundColor = palette.chipFill
nextKeyboardChip.configuration = next
var chip = undoChip.configuration
chip?.baseForegroundColor = palette.textMuted
chip?.background.backgroundColor = palette.chipFill
undoChip.configuration = chip
fullAccessHintView?.palette = palette
noticeView?.palette = palette
for (item, slot) in Self.slots(for: currentSuggestions).enumerated() {
slotButtons[slot].configure(with: currentSuggestions[item], palette: palette, animated: false)
}
setNeedsDisplay()
}
private var contentCenterY: CGFloat {
textCenterY ?? bounds.height * 0.5
}
override func layoutSubviews() {
super.layoutSubviews()
let midY = contentCenterY
statusLabel.frame = CGRect(x: 16, y: max(0, midY - 12), width: max(0, bounds.width - 32), height: 24)
let chipH = min(34, max(18, min(bounds.height - 2 * pillInset, chipHeight ?? .infinity)))
let chipSize = undoChip.sizeThatFits(CGSize(width: bounds.width, height: chipH))
undoChip.frame = CGRect(
x: (bounds.width - chipSize.width) / 2,
y: max(0, midY - chipH / 2),
width: chipSize.width,
height: chipH
)
let pasteW = pasteControl.sizeThatFits(CGSize(width: bounds.width, height: chipH)).width
let nextSize = nextKeyboardChip.sizeThatFits(CGSize(width: bounds.width, height: chipH))
// Laid out for what is shown, not what is still fading out.
let pasteShown = showsPasteChip
let nextShown = showsNextKeyboardChip
let pair = pasteShown && nextShown
let gap: CGFloat = 8
let total = pair ? pasteW + gap + nextSize.width : (pasteShown ? pasteW : nextSize.width)
// On the keyboard's middle, as the middle slot's word, kept inside the strip.
let midX = barMidX ?? bounds.width / 2
let startX = max(0, min(bounds.width - total, midX - total / 2))
let chipY = max(0, midY - chipH / 2)
pasteControl.frame = CGRect(x: startX, y: chipY, width: pasteW, height: chipH)
nextKeyboardChip.frame = CGRect(
x: pair ? startX + pasteW + gap : startX,
y: chipY,
width: nextSize.width,
height: chipH
)
pasteControl.touchArea = pasteShown && !nextShown ? barTouchFrame ?? bounds : nil
// The hint's two lines and chip centre on the words' line, as everything in the strip.
let hintHalf = min(midY, bounds.height - midY)
let hintY = midY - hintHalf
let hintFrame = CGRect(x: 12, y: hintY, width: max(0, bounds.width - 24), height: 2 * hintHalf)
fullAccessHintView?.frame = hintFrame
fullAccessHintView?.chipHeight = chipH
noticeView?.frame = hintFrame
noticeView?.chipHeight = chipH
let slots = currentSlotFrames
for (idx, button) in slotButtons.enumerated() {
button.inSystemPlatter = inSystemPlatter
button.frame = slots[idx]
}
}
override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
if pasteControl.touchArea != nil, let barTouchFrame, barTouchFrame.contains(point) { return true }
return super.point(inside: point, with: event)
}
private var currentSlotFrames: [CGRect] {
if let slotFrames, slotFrames.count == 3 { return slotFrames }
let slotW = bounds.width / 3
return (0..<3).map { CGRect(x: CGFloat($0) * slotW, y: 0, width: slotW, height: bounds.height) }
}
override func draw(_ rect: CGRect) {
guard !showsUndo, !showsClipboard, !showsFullAccessHint, notice == nil, statusLabel.isHidden, bounds.width > 60 else { return }
// A chip sits inside its slot, so the dividers stay beside it, but for the one beside a
// revert, which Apple's bar hides.
let reverting = currentSuggestions.first?.kind == .revert
// Apple's dividers: 1 pt wide, ending on the slot boundary, centred on the words' line, and
// no taller than a chip (24 pt where there's room).
let lineH: CGFloat = min(24, bounds.height - 2, chipHeight ?? .infinity, 2 * contentCenterY)
let y = contentCenterY - lineH / 2
palette.stripDivider.setFill()
// Only between two filled slots: nothing to show, no dividers (as Apple's bar in a
// field it offers nothing for).
let slots = Self.slots(for: currentSuggestions)
let filled = Set(slots)
// Apple's bar hides both dividers beside its bubble (a pending autocorrection or a revert).
let bubbled: Set<Int> = appleBar ? Set(zip(currentSuggestions, slots).filter { $0.0.willAutoReplace || $0.0.kind == .revert }.map(\.1)) : []
for (index, slot) in currentSlotFrames.prefix(2).enumerated()
where slot.maxX < bounds.width - 1 && filled.contains(index) && filled.contains(index + 1) && !(reverting && index == 0)
&& !bubbled.contains(index) && !bubbled.contains(index + 1) {
UIRectFill(CGRect(x: slot.maxX - 1, y: y, width: 1, height: lineH))
}
let besideHex = hexOnLeading ? 0 : 2
if dividerBesideHex, filled.contains(besideHex), !bubbled.contains(besideHex) {
UIRectFill(CGRect(x: hexOnLeading ? 0 : bounds.width - 1, y: y, width: 1, height: lineH))
}
}
@objc private func handleUndo() {
onUndoDictation?()
}
@objc private func handleSlotTap(_ sender: SlotButton) {
guard let item = Self.slots(for: currentSuggestions).firstIndex(of: sender.tag) else { return }
onSelectSuggestion?(currentSuggestions[item])
}
@objc private func handleSlotHold(_ recognizer: UILongPressGestureRecognizer) {
guard recognizer.state == .began, let slot = recognizer.view?.tag,
let item = Self.slots(for: currentSuggestions).firstIndex(of: slot) else { return }
onHoldSuggestion?(currentSuggestions[item])
}
/// A chip whose touch can reach past its frame (`touchArea`, in the strip's coordinates): it
/// lights wherever there the finger lands, follows it in and out, and acts only if it lifts
/// inside, so a finger slid off the bar cancels. Without one, a plain button.
private final class StripChip: UIButton {
var touchArea: CGRect?
private var trackedTouch: UITouch?
private func inArea(_ touch: UITouch) -> Bool {
guard let touchArea, let superview else { return false }
return touchArea.contains(touch.location(in: superview))
}
override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
guard let touchArea, let superview else { return super.point(inside: point, with: event) }
return touchArea.contains(convert(point, to: superview))
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
guard touchArea != nil, trackedTouch == nil, let touch = touches.first else {
super.touchesBegan(touches, with: event)
return
}
trackedTouch = touch
isHighlighted = true
sendActions(for: .touchDown)
}
override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
guard let touch = trackedTouch, touches.contains(touch) else {
super.touchesMoved(touches, with: event)
return
}
let inside = inArea(touch)
guard inside != isHighlighted else { return }
isHighlighted = inside
sendActions(for: inside ? .touchDragEnter : .touchDragExit)
}
override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
guard let touch = trackedTouch, touches.contains(touch) else {
super.touchesEnded(touches, with: event)
return
}
trackedTouch = nil
let inside = inArea(touch)
isHighlighted = false
sendActions(for: inside ? .touchUpInside : .touchUpOutside)
}
override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
guard let touch = trackedTouch, touches.contains(touch) else {
super.touchesCancelled(touches, with: event)
return
}
trackedTouch = nil
isHighlighted = false
sendActions(for: .touchCancel)
}
}
/// One suggestion slot. A word that changes swaps letter by letter, as Apple's bar does
/// (iOS 27.2, recorded at 60 fps): the letters both words share stay, the old word's other
/// letters fade from its end and the new word's from its start, each in 0.1 s, staggered
/// over 0.2 s. The capsule and dividers change at once. Reduce Motion swaps at once.
private final class SlotButton: UIControl {
var inSystemPlatter = true { didSet { if inSystemPlatter != oldValue { setNeedsDisplay() } } }
var pillInset: CGFloat = 0.5 { didSet { if pillInset != oldValue { setNeedsDisplay() } } }
var textCenterY: CGFloat? { didSet { if textCenterY != oldValue { setNeedsDisplay() } } }
var chipHeight: CGFloat? { didSet { if chipHeight != oldValue { setNeedsDisplay() } } }
/// Apple's bar: the bubble fills the slot across, from `pillInset` down `chipHeight`.
var fillsCell = false { didSet { if fillsCell != oldValue { setNeedsDisplay() } } }
private var suggestion: KeyboardSuggestion?
private var palette = FullKeyboardPalette(isDark: false)
/// The word leaving while its letters fade, and when the swap began.
private var outgoing: KeyboardSuggestion?
private var swapStart: CFTimeInterval = 0
private var displayLink: CADisplayLink?
static let letterFade: CFTimeInterval = 0.1
static let swapLength: CFTimeInterval = 0.2
static let maxStagger: CFTimeInterval = 0.025
override init(frame: CGRect) {
super.init(frame: frame)
isOpaque = false
backgroundColor = .clear
contentMode = .redraw
isAccessibilityElement = false
isUserInteractionEnabled = false
accessibilityTraits = .button
addTarget(self, action: #selector(redraw), for: [.touchDown, .touchDragEnter, .touchDragExit, .touchCancel, .touchUpInside, .touchUpOutside])
}
@available(*, unavailable)
required init?(coder: NSCoder) { fatalError() }
override var isHighlighted: Bool { didSet { if isHighlighted != oldValue { setNeedsDisplay() } } }
/// nil empties the slot (its word fades out when animated).
func configure(with suggestion: KeyboardSuggestion?, palette: FullKeyboardPalette, animated: Bool) {
let old = self.suggestion
self.suggestion = suggestion
self.palette = palette
isAccessibilityElement = suggestion != nil
isUserInteractionEnabled = suggestion != nil
accessibilityLabel = suggestion?.displayText
accessibilityHint = suggestion?.kind == .revert ? String(localized: "Undoes the autocorrection") : nil
if old?.displayText != suggestion?.displayText {
if animated, window != nil, !UIAccessibility.isReduceMotionEnabled {
outgoing = old
swapStart = CACurrentMediaTime()
startTicking()
} else {
endSwap()
}
}
setNeedsDisplay()
}
override func didMoveToWindow() {
super.didMoveToWindow()
if window == nil { endSwap() }
}
private func startTicking() {
guard displayLink == nil else { return }
let link = CADisplayLink(target: self, selector: #selector(tick))
link.add(to: .main, forMode: .common)
displayLink = link
}
private func endSwap() {
outgoing = nil
displayLink?.invalidate()
displayLink = nil
}
@objc private func tick() {
if CACurrentMediaTime() - swapStart >= Self.swapLength { endSwap() }
setNeedsDisplay()
}
@objc private func redraw() { setNeedsDisplay() }
private struct Word {
let text: String
let attributes: [NSAttributedString.Key: Any]
let origin: CGPoint
/// Drawn in a box with a truncating tail (too long for the slot): never swapped by letter.
let truncatedRect: CGRect?
}
private func layout(_ suggestion: KeyboardSuggestion, ink: UIColor) -> Word {
let midY = textCenterY ?? bounds.height * 0.5
// Apple's words are all SF 17 pt regular, the one in the capsule included.
let font = UIFont.systemFont(ofSize: suggestion.kind == .emoji ? 22 : 17, weight: .regular)
let attributes: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: ink]
// The word centres in the slot; a revert's with its arrow after it.
let arrowRoom = suggestion.kind == .revert ? Self.revertArrowSize + Self.revertArrowGap : 0
let textMidX = (bounds.width - arrowRoom) / 2
let maxTextW = max(20, bounds.width - 12 - arrowRoom)
let text = suggestion.displayText
let size = (text as NSString).size(withAttributes: attributes)
guard size.width > maxTextW else {
let origin = CGPoint(x: textMidX - size.width / 2, y: midY - size.height / 2)
return Word(text: text, attributes: attributes, origin: origin, truncatedRect: nil)
}
let style = NSMutableParagraphStyle()
style.lineBreakMode = .byTruncatingTail
style.alignment = .center
let small: [NSAttributedString.Key: Any] = [
.font: UIFont.systemFont(ofSize: 15, weight: .regular), .foregroundColor: ink, .paragraphStyle: style,
]
let smallSize = (text as NSString).size(withAttributes: small)
let width = min(maxTextW, smallSize.width)
let box = CGRect(x: textMidX - width / 2, y: midY - smallSize.height / 2, width: width, height: smallSize.height)
return Word(text: text, attributes: small, origin: box.origin, truncatedRect: box)
}
/// Draws the word with each letter's opacity from alpha (1 is the ink's own).
private func draw(_ word: Word, alpha: (Int) -> CGFloat) {
let ink = word.attributes[.foregroundColor] as? UIColor ?? .label
if let box = word.truncatedRect {
var attributes = word.attributes
attributes[.foregroundColor] = ink.withAlphaComponent(ink.cgColor.alpha * max(0, alpha(0)))
(word.text as NSString).draw(in: box, withAttributes: attributes)
return
}
let string = NSMutableAttributedString(string: word.text, attributes: word.attributes)
var offset = 0
for (index, character) in word.text.enumerated() {
let length = String(character).utf16.count
let a = alpha(index)
if a < 1 {
let faded = ink.withAlphaComponent(ink.cgColor.alpha * max(0, a))
string.addAttribute(.foregroundColor, value: faded, range: NSRange(location: offset, length: length))
}
offset += length
}
string.draw(at: word.origin)
}
private static func progress(_ t: CFTimeInterval, start: CFTimeInterval) -> CGFloat {
let x = min(1, max(0, (t - start) / letterFade))
return CGFloat(x * x * (3 - 2 * x))
}
static let chipPadding: CGFloat = 12
static let revertArrowSize: CGFloat = 13
static let revertArrowGap: CGFloat = 5
/// Apple's revert bubble's undo arrow, after the word.
private func drawRevertArrow(after word: Word, ink: UIColor) {
let config = UIImage.SymbolConfiguration(pointSize: Self.revertArrowSize, weight: .medium)
guard let arrow = UIImage(systemName: "arrow.uturn.backward", withConfiguration: config)?
.withTintColor(ink, renderingMode: .alwaysOriginal) else { return }
let textWidth = word.truncatedRect?.width ?? (word.text as NSString).size(withAttributes: word.attributes).width
let x = word.origin.x + textWidth + Self.revertArrowGap
arrow.draw(at: CGPoint(x: x, y: (textCenterY ?? bounds.height * 0.5) - arrow.size.height / 2))
}
override func draw(_ rect: CGRect) {
let pilled = suggestion != nil && (isHighlighted || suggestion?.willAutoReplace == true || suggestion?.kind == .revert)
let ink = pilled ? palette.stripPillText : palette.stripText
let incoming = suggestion.map { layout($0, ink: ink) }
if pilled, let incoming {
// A chip around the word (and a revert's arrow), even above and below the words'
// line: Apple's slot-wide 38 pt pill reaches into the band iOS draws over a
// third-party keyboard, and cut short there it read as squashed.
let textW = incoming.truncatedRect?.width ?? (incoming.text as NSString).size(withAttributes: incoming.attributes).width
let arrowRoom = suggestion?.kind == .revert ? Self.revertArrowSize + Self.revertArrowGap : 0
let chipH = chipHeight ?? max(22, bounds.height - 2 * pillInset)
let chipW = min(bounds.width, textW + arrowRoom + 2 * Self.chipPadding)
let midY = textCenterY ?? bounds.height * 0.5
// Apple's bubble (iOS 26.5 and 27.2): the whole cell across, a capsule on the line.
let chip = fillsCell ? CGRect(x: 0, y: midY - chipH / 2, width: bounds.width, height: chipH) : CGRect(
x: max(0, min(bounds.width - chipW, incoming.origin.x - (chipW - textW - arrowRoom) / 2)),
y: midY - chipH / 2,
width: chipW,
height: chipH
)
(isHighlighted ? palette.stripPillPressedFill : palette.stripPillFill).setFill()
UIBezierPath(roundedRect: chip, cornerRadius: chipH / 2).fill()
}
if let incoming, suggestion?.kind == .revert { drawRevertArrow(after: incoming, ink: ink) }
guard var leaving = outgoing.map({ layout($0, ink: ink) }) else {
if let incoming { draw(incoming) { _ in 1 } }
return
}
let t = CACurrentMediaTime() - swapStart
let oldLetters = Array(leaving.text)
let newLetters = Array(incoming?.text ?? "")
let byLetter = leaving.truncatedRect == nil && incoming?.truncatedRect == nil
// Letters both words start with stay put (drawn once, in the new word).
var shared = 0
if byLetter, incoming != nil {
while shared < min(oldLetters.count, newLetters.count), oldLetters[shared] == newLetters[shared] {
shared += 1
}
}
if shared > 0, let incoming {
// The old ending continues from the shared letters, so it never jumps aside.
leaving = Word(text: leaving.text, attributes: leaving.attributes, origin: incoming.origin, truncatedRect: nil)
}
let changing = max(oldLetters.count, newLetters.count) - shared
let stagger = changing > 1 ? min(Self.maxStagger, (Self.swapLength - Self.letterFade) / Double(changing - 1)) : 0
draw(leaving) { index in
guard index >= shared else { return 0 }
guard byLetter else { return 1 - Self.progress(t, start: 0) }
return 1 - Self.progress(t, start: Double(oldLetters.count - 1 - index) * stagger)
}
if let incoming {
draw(incoming) { index in
guard index >= shared else { return 1 }
guard byLetter else { return Self.progress(t, start: 0) }
return Self.progress(t, start: Double(index - shared) * stagger)
}
}
}
}
}
/// A two-line message with a chip that replaces the strip for a few seconds, in the Full Access
/// hint's shape: "Couldn't translate, pasted as spoken" over its fix, and Open Hex.
struct KeyboardStripNotice: Equatable {
let title: String
let detail: String
let button: String
}
/// What the Hex key shows without Full Access: dictation needs Allow Full Access, where to
/// turn it on, and an Open Hex chip, the only part that opens Hex, on the Hex key's side.
@MainActor
final class FullAccessHintView: UIView {
static let title = String(localized: "Allow Full Access to dictate")
static let path = String(localized: "Settings › Apps › Hex › Keyboards")
static let spokenPath = String(localized: "Settings, Apps, Hex, Keyboards")
var palette = FullKeyboardPalette(isDark: false) { didSet { applyPalette() } }
var chipHeight: CGFloat = 30 { didSet { setNeedsLayout() } }
/// The Hex key is on the left: Open Hex sits at the leading end, the text after it.
var chipLeads = false { didSet { if chipLeads != oldValue { setNeedsLayout() } } }
var onOpenHex: (() -> Void)?
private let titleLabel = UILabel()
private let pathLabel = UILabel()
private let openButton = UIButton(type: .custom)
override init(frame: CGRect) {
super.init(frame: frame)
backgroundColor = .clear
titleLabel.text = Self.title
titleLabel.font = .systemFont(ofSize: 13, weight: .medium)
pathLabel.text = Self.path
pathLabel.font = .systemFont(ofSize: 11.5)
pathLabel.accessibilityLabel = Self.spokenPath
for label in [titleLabel, pathLabel] {
label.adjustsFontSizeToFitWidth = true
label.minimumScaleFactor = 0.8
label.lineBreakMode = .byTruncatingTail
addSubview(label)
}
var open = UIButton.Configuration.plain()
open.title = String(localized: "Open Hex")
open.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 13, bottom: 0, trailing: 13)
open.background.cornerRadius = 15
openButton.configuration = open
openButton.accessibilityHint = String(localized: "Opens Hex's setup")
openButton.addTarget(self, action: #selector(handleOpen), for: .touchUpInside)
addSubview(openButton)
applyPalette()
}
@available(*, unavailable)
required init?(coder: NSCoder) { fatalError() }
@objc private func handleOpen() {
onOpenHex?()
}
/// Shows `notice` in place of the Full Access words.
func show(_ notice: KeyboardStripNotice) {
titleLabel.text = notice.title
pathLabel.text = notice.detail
pathLabel.accessibilityLabel = nil
var open = openButton.configuration
open?.title = notice.button
openButton.configuration = open
openButton.accessibilityHint = nil
setNeedsLayout()
}
private func applyPalette() {
titleLabel.textColor = palette.textBase
pathLabel.textColor = palette.textMuted
var open = openButton.configuration
open?.baseForegroundColor = palette.textBase
open?.background.backgroundColor = palette.chipFill
openButton.configuration = open
}
override func layoutSubviews() {
super.layoutSubviews()
let buttonWidth = openButton.sizeThatFits(CGSize(width: bounds.width, height: chipHeight)).width
openButton.frame = CGRect(
x: chipLeads ? 0 : bounds.width - buttonWidth,
y: (bounds.height - chipHeight) / 2,
width: buttonWidth,
height: chipHeight
)
let textX = chipLeads ? openButton.frame.maxX + 10 : 0
let textWidth = chipLeads ? max(0, bounds.width - textX) : max(0, openButton.frame.minX - 10)
// Two lines, even above and below the strip's words' line.
let lineHeight: CGFloat = min(16, (bounds.height + 1) / 2)
let top = (bounds.height - 2 * lineHeight) / 2
titleLabel.frame = CGRect(x: textX, y: top, width: textWidth, height: lineHeight)
pathLabel.frame = CGRect(x: textX, y: top + lineHeight, width: textWidth, height: lineHeight)
}
}
/// The strip's geometry: Apple's prediction bar on an iPhone (`appleBar`), the 38 pt strip before
/// it was measured, and the Duo's and iPad's bars.
nonisolated extension KeyboardMetrics {
/// The suggestion strip is Apple's predictive bar from the top of its suggestion pill down.
/// Apple's bar is 44 pt from its panel's edge, the pill around a suggested word starts 6 pt
/// down, and row 1's keycaps start about 8 pt under the bar (51.7 pt down, iPhone 17 Pro,
/// iOS 27.2). So the strip is 38 pt, then the same 8 pt gap, and row 1 starts 46 pt down.
/// iOS 26 and later draw about 17 pt of their own panel above a third-party keyboard in some
/// presentations and nothing in others (Hex, Gboard and SwiftKey alike on an iPhone 17 Pro,
/// iOS 27.2: Notes has it, a Safari form's first focus doesn't), and a keyboard can't tell
/// which, so the strip carries its own room above the words. It was 27 pt, the part of
/// Apple's bar below that band: without the band the words sat 9 pt under the keyboard's top
/// edge and a chip touched it. Everything the strip shows (suggestions, Undo dictation, the
/// Full Access hint, the recording bar, the emoji panel's top row) lives in those 38 pt,
/// centred on the words' line (`stripTextCenter`).
static let stripBarHeight: CGFloat = 38
static let stripGap: CGFloat = 8
/// On the iPhone Duo iOS sets the keyboard in a platter with its own band above, and the
/// strip is Apple's whole 44 pt bar, right on the keys.
static let insetStripHeight: CGFloat = 44
/// The Duo folded and upright: iOS's band there is 8.7 pt and Apple's keycaps start 48.7 pt
/// below the panel's edge (iOS 27.2), so the strip is 32 pt with the iPhone's 8 pt gap.
static let coverStripHeight: CGFloat = 32
/// How far below the strip's top its pills (the Hex key, the recording bar) start: they
/// centre on the words' line, 6 pt down in the phone's portrait strip, in the Duo's 44 pt
/// bar 4 pt.
var stripInset: CGFloat { stripTextCenter - stripPillHeight / 2 }
/// Apple's pill starts 6 pt below its panel's edge (iOS 27.2, iPhone 17 Pro); Hex's pills
/// start as far below the keyboard's own top edge, which is the panel's edge whenever iOS
/// draws nothing above the keyboard.
static let barPillTop: CGFloat = 6
/// The pills' height. In the phone's portrait strip, even above and below the words' line
/// from `barPillTop` down (28 pt), inside the strip. Elsewhere it's the strip less half a
/// point above and below, at most 36 pt.
var stripPillHeight: CGFloat {
if appleBar { return min(Self.appleBubbleHeight, 2 * min(stripTextCenter, stripHeight - stripTextCenter)) }
guard stripHeight == Self.stripBarHeight else { return min(stripHeight - 1, 36) }
return 2 * min(stripTextCenter - Self.barPillTop, stripHeight - stripTextCenter)
}
/// Where the strip's words, dividers, chips and Hex mark centre. Apple's words sit midway
/// between the panel's edge and row 1's keycaps (25.3 pt down, keycaps at 52 pt, iPhone 17
/// Pro, iOS 27.2), so in the phone's portrait strip they're 26 pt above row 1, 20 pt below
/// the keyboard's top edge. Elsewhere the strip is Apple's bar and they centre in it.
static let barTextAboveKeys: CGFloat = 26
var stripTextCenter: CGFloat {
if appleBar { return stripHeight - Self.appleBarTextAboveBottom }
return stripHeight == Self.stripBarHeight ? stripHeight + stripBottom - Self.barTextAboveKeys : stripHeight / 2
}
/// A suggestion's chip (an autocorrection, a pressed word, a revert) and the dividers: in
/// the phone's portrait strip a small chip around the word, 18 pt, even above and below the
/// words' line (not Apple's slot-wide 38 pt pill). Elsewhere the pill height.
static let barChipHeight: CGFloat = 18
var stripChipHeight: CGFloat {
!appleBar && stripHeight == Self.stripBarHeight ? Self.barChipHeight : stripPillHeight
}
/// Apple's prediction bar, measured beside Hex on iOS 26.5 and 27.2 (iPhone 17 Pro, Air, 17 Pro
/// Max and SE, upright and turned, light and dark, black box): 44 pt from the keyboard's top
/// edge on every iPhone, row 1's keycaps 8 pt under it upright and 6 pt turned. Its words, its
/// dividers and the bubble behind a pending autocorrection all centre 25 pt down (19 pt above
/// the bar's bottom); the bubble fills its cell from 6 pt down to the bar's bottom, a 38 pt
/// capsule, and the dividers are 1 × 24 pt, hidden beside the bubble.
static let appleBarHeight: CGFloat = 44
static let appleBarTurnedGap: CGFloat = 6
static let appleBarTextAboveBottom: CGFloat = 19
static let appleBubbleHeight: CGFloat = 38
/// Apple's bar leads with a 59 pt cell for its writing tools icon, then a divider, then three
/// equal cells (iPhone 17 Pro Max, iOS 27.2.1, a TestFlight tester's screenshot; the simulator
/// shows no icon). Hex's key takes that cell at its own end of the bar.
static let appleIconCellWidth: CGFloat = 59
/// Hex's key in Apple's bar keeps the 44 × 28 pt mark it had in the 38 pt strip.
static let barHexKeyHeight: CGFloat = 28
/// Apple's bar was measured on iOS 26 and 27 (`KeyboardLanguage.systemMajorVersion`); iOS 18
/// is unmeasured (no simulator runtime) and keeps the 38 pt strip it always had.
static var appleBarIsMeasured: Bool { KeyboardLanguage.systemMajorVersion >= 26 }
/// These metrics with Apple's prediction bar for a strip: 44 pt, then 8 pt to row 1 upright or
/// 6 pt turned. Upright the keyboard grows 6 pt upward (rows stay put) and its top edge is
/// Apple's; turned it was already Apple's height (42 + 8 pt), and only the strip changes.
func withAppleBar(turned: Bool) -> KeyboardMetrics {
var m = rebuilt(stripHeight: Self.appleBarHeight, stripBottom: turned ? Self.appleBarTurnedGap : Self.stripGap)
m.appleBar = true
return m
}
/// The tallest band of the strip that is even above and below the words' line, from the
/// strip's top: what fills the strip (the Full Access hint, the emoji panel's top row, the
/// emoji search field) centres in it, so it sits on the line too. The whole strip where the
/// words centre in it.
var stripLineBand: (top: CGFloat, height: CGFloat) {
let half = min(stripTextCenter, stripHeight - stripTextCenter)
return (stripTextCenter - half, 2 * half)
}
}