mirror of
https://github.com/anomalyco/hex.git
synced 2026-11-22 21:23:02 +01:00
* iOS: plainer interface wording (copy pass)
A TestFlight tester on build 121 said the interface reads as machine-written.
This rewrites 84 user-facing strings (80 catalog entries, the two permission
prompts, two keyboard-only errors) in flat, short, Apple-Settings style and
updates every changed zh-Hans value to match.
What changed:
- Notes that explained the mechanism, restated the row title, or reassured
are cut to the one fact people need (e.g. Hide word suggestions now says
"Autocorrect still works"; Learn how I type, Record typing logs, the
Experiments rows, the Languages hint, onboarding notes, intents).
- Removed notes that said nothing: Auto-capitalization, Key pop-ups, and
the iPad-only "The full keyboard works on iPad too" (its runsOnPad helper
went with it). Haptics and the dictation bar now say "Needs Full Access"
only while Full Access is off, instead of "Needs Full Access, which isn't
on yet" / a note that repeated the requirement while it was on.
- One name per thing: "speech model" and "multilingual model" instead of
Parakeet V2/Ultra in errors; "Apple's speech recognition" instead of
Apple Speech / Apple's on-device speech; "No speech heard." for every
empty recording; "Hex Keyboard" for iOS's name, "the Hex keyboard" in
prose; US spelling (off-center, key centers).
- Permission prompts drop the sentence that restated "on this iPhone"
(Info.plist, project.yml, zh-Hans InfoPlist.strings).
- Wording only: no settings keys, layout or behaviour changed. Catalog
edits are confined to the changed entries; stale entries and the
unlocalized UIKit strip strings are left as they were.
Verified: built before (8583160e) and after; screenshots of 21 scenes on
iPhone 17 Pro and iPhone SE (3rd gen) iOS 27.2 sims, EN before/after and
zh-Hans after, at default and AX5 text sizes, no truncation. xcodebuild test
on a fresh iPhone 17 Pro sim: TEST SUCCEEDED (DictationControllerTests
updated where they asserted the old wording; README quotes updated).
* iOS: Onboarding's doc comment quotes the new optimizing status
Matches the wording changed in the copy pass; comment only.
* iOS: keep the privacy facts in the copy pass; translate the keyboard strip
Review on #2345: for Hex, "on this iPhone", "never leaves" and "not sent"
are facts people need at that moment, not reassurance.
Restored:
- Microphone prompt: "...Audio never leaves it and is deleted once it's
transcribed." Speech Recognition prompt keeps "Nothing you say is sent to
a server." (Info.plist, project.yml, zh-Hans InfoPlist.strings)
- Learn how I type and Record typing logs say "on this iPhone" again.
- Clean up what I say is back to "Drops ums, repeats and corrected words".
- "Allow Speech Recognition. It stays on this iPhone." and "...in Settings.
It runs on this iPhone." back to the originals.
- On-device put back in the shortest form: Checking on-device speech
recognition; the Parakeet memory fallback names Apple's on-device speech
recognition; Adaptive touch learns "on this iPhone"; the Shortcut, Control
Center and Live Activity descriptions say "on device" / "on-device" (not
"iPhone": KeyboardBridgeTests forbids Apple platform names in intent
strings).
Keyboard strip: Undo dictation, Paste, Paste dictation, Code from Messages
(and its VoiceOver hint), Undoes the autocorrection, the Full Access hint
(title, Settings path, spoken path, Open Hex, its hint) and the dictation
bar's Full Access path were plain strings, so Chinese users saw English.
They now go through String(localized:); the keyboard extension already
bundles HEXMobile/Localizable.xcstrings, so no wiring was needed. 10 new
catalog entries with zh-Hans, using the app's terms (粘贴听写, 完全访问).
Verified: the built HEXKeyboard.appex zh-Hans Localizable.strings carries the
new keys; zh screenshots show 撤销听写 in the strip and the translated path
in the dictation bar; scripts/code-shape.py has no hard problems;
xcodebuild test on a fresh iPhone 17 Pro sim: TEST SUCCEEDED.
173 lines
No EOL
8.3 KiB
Swift
173 lines
No EOL
8.3 KiB
Swift
import SwiftUI
|
||
@preconcurrency import Translation
|
||
|
||
/// Settings › Dictation › Translate what I say: the switch (the keyboards' Translate to
|
||
/// <language> is the same one), the target language, the one-time download of Apple's
|
||
/// on-device language pack, and why the last dictation went in as spoken, with its fix. The
|
||
/// keyboard's note after such a dictation opens this page.
|
||
struct TranslateDictationRow: View {
|
||
@State private var enabled = DictationTranslationSettings().isEnabled
|
||
@State private var target = DictationTranslationSettings().targetLanguage
|
||
@State private var lastFailure = DictationTranslationSettings().lastFailure
|
||
@State private var languages: [Locale.Language] = []
|
||
@State private var status: LanguageAvailability.Status?
|
||
@State private var download: TranslationSession.Configuration?
|
||
|
||
/// What you dictate in: the language of the dictation that last went in as spoken, else
|
||
/// Settings › Dictation language, or the language it last resolved.
|
||
private var source: Locale.Language {
|
||
if let lastFailure, lastFailure.target == Locale.Language(identifier: target).minimalIdentifier {
|
||
return Locale.Language(identifier: lastFailure.source)
|
||
}
|
||
return LanguageSettings().effectiveDictationLanguage.map { Locale(identifier: $0).language }
|
||
?? Locale.current.language
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
Toggle(isOn: $enabled) {
|
||
VStack(alignment: .leading, spacing: 2) {
|
||
Text("Translate what I say")
|
||
.font(.system(size: 15, weight: .regular))
|
||
.foregroundStyle(HexTheme.textBase)
|
||
Text("Speak one language, insert another")
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
}
|
||
}
|
||
.tint(HexTheme.success)
|
||
.onChange(of: enabled) { _, value in
|
||
let settings = DictationTranslationSettings()
|
||
if settings.isEnabled != value { settings.isEnabled = value }
|
||
}
|
||
|
||
if enabled {
|
||
HStack {
|
||
Text("Insert in")
|
||
.font(.system(size: 13))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
Spacer()
|
||
Menu {
|
||
ForEach(languages, id: \.minimalIdentifier) { language in
|
||
Button {
|
||
target = language.minimalIdentifier
|
||
} label: {
|
||
if target == language.minimalIdentifier {
|
||
Label(name(of: language), systemImage: "checkmark")
|
||
} else {
|
||
Text(name(of: language))
|
||
}
|
||
}
|
||
}
|
||
} label: {
|
||
SettingsMenuValue(value: name(of: Locale.Language(identifier: target)))
|
||
}
|
||
.accessibilityLabel("Insert in")
|
||
}
|
||
.onChange(of: target) { _, value in
|
||
DictationTranslationSettings().targetLanguage = value
|
||
Task { await refreshStatus() }
|
||
}
|
||
|
||
if Locale.Language(identifier: target).languageCode == source.languageCode {
|
||
// You dictate in the target already: switch the dictation language from the
|
||
// keyboard's Hex key to speak another one and paste in this one.
|
||
Text("Change the spoken language from the Hex key.")
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
} else {
|
||
switch status {
|
||
case .installed where lastFailure?.reason == .needsHexOpen:
|
||
// Before iOS 26 the session lives in Hex's window (TranslationSessionHost).
|
||
Text("On iOS 18, dictations translate only with Hex open.")
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
case .installed where lastFailure?.reason == .failed:
|
||
// Apple's own pack is there but translating failed, as when its Translate
|
||
// app was removed.
|
||
Text("Couldn't translate the last dictation. If it keeps happening, reinstall Apple's Translate app.")
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
downloadButton(again: true)
|
||
case .installed:
|
||
Text("Ready. Works offline.")
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
case .supported:
|
||
if lastFailure != nil {
|
||
Text(TranslationFailure.note)
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
}
|
||
downloadButton(again: false)
|
||
case .unsupported:
|
||
Text("Apple can't translate between these languages.")
|
||
.font(.system(size: 12))
|
||
.foregroundStyle(HexTheme.textMuted)
|
||
default:
|
||
EmptyView()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
.translationTask(download) { session in
|
||
try? await session.prepareTranslation()
|
||
await refreshStatus()
|
||
}
|
||
.onAppear(perform: reload)
|
||
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { _ in
|
||
// The keyboard may have changed the switch or failed to translate, and the pack
|
||
// may have been removed in iOS Settings meanwhile.
|
||
reload()
|
||
Task { await refreshStatus() }
|
||
}
|
||
.task {
|
||
// Every language, including the one you dictate in now: you can switch the
|
||
// dictation language per dictation, so English must be pickable while you
|
||
// usually dictate in English. A dictation already in the target pastes as spoken.
|
||
let supported = await LanguageAvailability().supportedLanguages
|
||
var seen = Set<String>()
|
||
languages = supported
|
||
.filter { seen.insert($0.minimalIdentifier).inserted }
|
||
.sorted { name(of: $0) < name(of: $1) }
|
||
await refreshStatus()
|
||
}
|
||
}
|
||
|
||
/// The keyboard's Translate to <language> switch and its targets change these too.
|
||
private func reload() {
|
||
let settings = DictationTranslationSettings()
|
||
enabled = settings.isEnabled
|
||
target = settings.targetLanguage
|
||
lastFailure = settings.lastFailure
|
||
}
|
||
|
||
/// Asks Apple to download the pair. Asking again for the same pair invalidates the last
|
||
/// request, or `translationTask` would not run it again after a cancelled download.
|
||
private func downloadButton(again: Bool) -> some View {
|
||
let language = name(of: Locale.Language(identifier: lastFailure?.language ?? target))
|
||
return Button(again ? "Download \(language) again" : "Download \(language)") {
|
||
let configuration = TranslationSession.Configuration(source: source, target: Locale.Language(identifier: target))
|
||
if download == configuration {
|
||
download?.invalidate()
|
||
} else {
|
||
download = configuration
|
||
}
|
||
}
|
||
.font(.system(size: 13, weight: .medium))
|
||
}
|
||
|
||
private func refreshStatus() async {
|
||
let current = await LanguageAvailability().status(from: source, to: Locale.Language(identifier: target))
|
||
status = current
|
||
// Downloaded now: the note about a missing pack is out of date.
|
||
if current == .installed, lastFailure?.reason == .notDownloaded {
|
||
DictationTranslationSettings().lastFailure = nil
|
||
lastFailure = nil
|
||
}
|
||
}
|
||
|
||
private func name(of language: Locale.Language) -> String {
|
||
Locale.current.localizedString(forIdentifier: language.minimalIdentifier) ?? language.minimalIdentifier
|
||
}
|
||
} |