wehub-resource-sync
691 lines
29 KiB
Swift
691 lines
29 KiB
Swift
import AppKit
|
||
import ApplicationServices
|
||
import Carbon
|
||
import Foundation
|
||
import SwiftUI
|
||
import MacToolsPluginKit
|
||
|
||
public final class TranslatorPluginFactory: NSObject, MacToolsPluginBundleFactory {
|
||
public static func makeProvider(context: PluginRuntimeContext) throws -> any PluginProvider {
|
||
TranslatorPluginProvider(context: context)
|
||
}
|
||
}
|
||
|
||
@MainActor
|
||
private struct TranslatorPluginProvider: PluginProvider {
|
||
let context: PluginRuntimeContext
|
||
|
||
func makePlugins() -> [any MacToolsPlugin] {
|
||
[TranslatorPlugin(context: context)]
|
||
}
|
||
}
|
||
|
||
typealias ScreenshotRegionCapturerFactory = @MainActor (@escaping () -> Bool) -> any ScreenshotRegionCapturing
|
||
|
||
@MainActor
|
||
final class TranslatorPlugin: MacToolsPlugin, PluginPrimaryPanel, PluginConfigurationPresenting {
|
||
private enum APIKeyState: Equatable {
|
||
case unknown
|
||
case present
|
||
case missing
|
||
case error(String)
|
||
}
|
||
|
||
let metadata: PluginMetadata
|
||
|
||
let primaryPanelDescriptor = PluginPrimaryPanelDescriptor(
|
||
controlStyle: .switch,
|
||
menuActionBehavior: .keepPresented
|
||
)
|
||
|
||
var onStateChange: (() -> Void)?
|
||
var requestPermissionGuidance: ((String) -> Void)?
|
||
var shortcutBindingResolver: ((String) -> ShortcutBinding?)?
|
||
var requestConfigurationPresentation: (() -> Void)?
|
||
|
||
private let storage: PluginStorage
|
||
private let accessibilityTrustProvider: () -> Bool
|
||
private let accessibilityTrustRequester: (Bool) -> Bool
|
||
private let screenRecordingPermissionProvider: () -> Bool
|
||
private let selectTranslationStarter: (() -> Void)?
|
||
private let screenshotTranslationStarter: (() -> Void)?
|
||
private let secretStore: any TranslatorSecretStoring
|
||
private let languagePreferenceStore: LanguagePreferenceStore
|
||
private let panelController: any TranslatorPanelControlling
|
||
private let selectedTextCapturePipeline: SelectedTextCapturePipeline
|
||
private let screenshotRegionCapturer: (any ScreenshotRegionCapturing)?
|
||
private let screenshotRegionCapturerFactory: ScreenshotRegionCapturerFactory
|
||
private let ocrTextRecognizer: (any OCRTextRecognizing)?
|
||
private let translationProviderFactoryOverride: TranslatorProviderFactory?
|
||
private let providerProfileStore: TranslatorProviderProfileStore
|
||
private let localization: PluginLocalization
|
||
private var providerConfiguration: OpenAICompatibleConfiguration
|
||
private var providerProfiles: [TranslatorProviderProfile]
|
||
private var languagePair: TranslatorLanguagePair
|
||
private var cachedAPIKey: String?
|
||
private var cachedAPIKeys: [String: String]
|
||
private var didLoadProfileAPIKeys: Set<String>
|
||
private var didLoadAPIKey = false
|
||
private var apiKeyState: APIKeyState
|
||
private var coordinator: TranslatorCoordinator?
|
||
|
||
init(
|
||
context: PluginRuntimeContext = PluginRuntimeContext(pluginID: TranslatorConstants.pluginID),
|
||
accessibilityTrustProvider: @escaping () -> Bool = AccessibilityCheck.isTrusted,
|
||
accessibilityTrustRequester: @escaping (Bool) -> Bool = AccessibilityCheck.requestTrust,
|
||
screenRecordingPermissionProvider: @escaping () -> Bool = { CGPreflightScreenCaptureAccess() },
|
||
selectTranslationStarter: (() -> Void)? = nil,
|
||
screenshotTranslationStarter: (() -> Void)? = nil,
|
||
secretStore: any TranslatorSecretStoring = OpenAICompatibleSecretStore(),
|
||
panelController: (any TranslatorPanelControlling)? = nil,
|
||
selectedTextCapturePipeline: SelectedTextCapturePipeline? = nil,
|
||
screenshotRegionCapturer: (any ScreenshotRegionCapturing)? = nil,
|
||
screenshotRegionCapturerFactory: ScreenshotRegionCapturerFactory? = nil,
|
||
ocrTextRecognizer: (any OCRTextRecognizing)? = nil,
|
||
translationProviderFactoryOverride: TranslatorProviderFactory? = nil,
|
||
localization: PluginLocalization? = nil
|
||
) {
|
||
let localization = localization ?? PluginLocalization(bundle: context.resourceBundle)
|
||
self.localization = localization
|
||
self.metadata = PluginMetadata(
|
||
id: TranslatorConstants.pluginID,
|
||
title: localization.string("metadata.title", defaultValue: "翻译"),
|
||
iconName: "text.bubble",
|
||
iconTint: Color(nsColor: .systemBlue),
|
||
order: 57,
|
||
defaultDescription: localization.string("metadata.description", defaultValue: "划词与截图快捷键翻译")
|
||
)
|
||
self.storage = context.storage
|
||
self.accessibilityTrustProvider = accessibilityTrustProvider
|
||
self.accessibilityTrustRequester = accessibilityTrustRequester
|
||
self.screenRecordingPermissionProvider = screenRecordingPermissionProvider
|
||
self.selectTranslationStarter = selectTranslationStarter
|
||
self.screenshotTranslationStarter = screenshotTranslationStarter
|
||
self.secretStore = secretStore
|
||
self.panelController = panelController ?? TranslatorPanelController(localization: localization)
|
||
self.selectedTextCapturePipeline = selectedTextCapturePipeline ?? .live(localization: localization)
|
||
self.screenshotRegionCapturer = screenshotRegionCapturer
|
||
self.screenshotRegionCapturerFactory = screenshotRegionCapturerFactory ?? { permissionProvider in
|
||
ScreenshotRegionCapturer(screenRecordingPermissionProvider: permissionProvider)
|
||
}
|
||
self.ocrTextRecognizer = ocrTextRecognizer
|
||
self.translationProviderFactoryOverride = translationProviderFactoryOverride
|
||
let providerProfileStore = TranslatorProviderProfileStore(storage: context.storage, localization: localization)
|
||
let providerProfiles = providerProfileStore.loadProfiles()
|
||
self.providerProfileStore = providerProfileStore
|
||
self.providerProfiles = providerProfiles
|
||
let languagePreferenceStore = LanguagePreferenceStore(storage: context.storage)
|
||
self.languagePreferenceStore = languagePreferenceStore
|
||
self.providerConfiguration = providerProfiles.first?.configuration
|
||
?? OpenAICompatibleConfiguration(storage: context.storage, localization: localization)
|
||
self.languagePair = languagePreferenceStore.loadPair()
|
||
self.cachedAPIKey = nil
|
||
self.cachedAPIKeys = [:]
|
||
self.didLoadProfileAPIKeys = []
|
||
self.apiKeyState = .unknown
|
||
self.panelController.onAction = { [weak self] action in
|
||
self?.handlePanelAction(action)
|
||
}
|
||
}
|
||
|
||
var primaryPanelState: PluginPanelState {
|
||
PluginPanelState(
|
||
subtitle: panelSubtitle,
|
||
isOn: isShortcutEnabled,
|
||
isExpanded: false,
|
||
isEnabled: true,
|
||
isVisible: true,
|
||
detail: nil,
|
||
errorMessage: nil
|
||
)
|
||
}
|
||
|
||
var permissionRequirements: [PluginPermissionRequirement] {
|
||
[
|
||
PluginPermissionRequirement(
|
||
id: TranslatorConstants.PermissionID.accessibility,
|
||
kind: .accessibility,
|
||
title: localization.string("permission.accessibility.title", defaultValue: "辅助功能授权"),
|
||
description: localization.string("permission.accessibility.description", defaultValue: "划词翻译需要读取当前选中文本。")
|
||
),
|
||
PluginPermissionRequirement(
|
||
id: TranslatorConstants.PermissionID.automation,
|
||
kind: .automation,
|
||
title: localization.string("permission.automation.title", defaultValue: "自动化授权"),
|
||
description: localization.string("permission.automation.description", defaultValue: "浏览器划词可能需要允许 MacTools 控制当前浏览器。")
|
||
),
|
||
PluginPermissionRequirement(
|
||
id: TranslatorConstants.PermissionID.screenRecording,
|
||
kind: .screenRecording,
|
||
title: localization.string("permission.screenRecording.title", defaultValue: "屏幕录制授权"),
|
||
description: localization.string("permission.screenRecording.description", defaultValue: "截图翻译需要读取框选区域的屏幕内容。")
|
||
),
|
||
]
|
||
}
|
||
|
||
var settingsSections: [PluginSettingsSection] { [] }
|
||
|
||
var shortcutDefinitions: [PluginShortcutDefinition] {
|
||
[
|
||
PluginShortcutDefinition(
|
||
id: TranslatorConstants.ShortcutID.selectTranslation,
|
||
title: localization.string("shortcut.selectTranslation.title", defaultValue: "划词翻译"),
|
||
description: localization.string("shortcut.selectTranslation.description", defaultValue: "翻译当前选中的文本。"),
|
||
actionID: TranslatorConstants.ActionID.selectTranslation,
|
||
scope: .global,
|
||
defaultBinding: TranslatorConstants.Defaults.selectTranslationShortcut,
|
||
isRequired: false
|
||
),
|
||
PluginShortcutDefinition(
|
||
id: TranslatorConstants.ShortcutID.screenshotTranslation,
|
||
title: localization.string("shortcut.screenshotTranslation.title", defaultValue: "截图翻译"),
|
||
description: localization.string("shortcut.screenshotTranslation.description", defaultValue: "框选截图区域并翻译识别出的文字。"),
|
||
actionID: TranslatorConstants.ActionID.screenshotTranslation,
|
||
scope: .global,
|
||
defaultBinding: TranslatorConstants.Defaults.screenshotTranslationShortcut,
|
||
isRequired: false
|
||
),
|
||
]
|
||
}
|
||
|
||
var configuration: PluginConfiguration? {
|
||
PluginConfiguration(description: metadata.defaultDescription, prefersFullHeight: false) { [weak self] _ in
|
||
if let self {
|
||
TranslatorSettingsView(
|
||
profiles: self.providerProfiles,
|
||
apiKeys: self.cachedAPIKeys,
|
||
languagePair: self.languagePair,
|
||
localization: self.localization,
|
||
onSave: { [weak self] profiles, apiKeys, languagePair in
|
||
self?.saveConfiguration(
|
||
profiles: profiles,
|
||
apiKeys: apiKeys,
|
||
languagePair: languagePair
|
||
)
|
||
},
|
||
onMakeNewProfile: { [weak self] profiles in
|
||
self?.providerProfileStore.makeNewProfile(existingProfiles: profiles)
|
||
?? TranslatorProviderProfile(
|
||
name: self?.localization.string("openAIClient.providerTitle", defaultValue: "OpenAI 翻译")
|
||
?? "OpenAI",
|
||
isEnabled: false
|
||
)
|
||
}
|
||
)
|
||
} else {
|
||
EmptyView()
|
||
}
|
||
}
|
||
}
|
||
|
||
func handleAction(_ action: PluginPanelAction) {
|
||
guard case let .setSwitch(isEnabled) = action else {
|
||
return
|
||
}
|
||
|
||
storage.set(isEnabled, forKey: TranslatorConstants.StorageKey.shortcutEnabled)
|
||
onStateChange?()
|
||
}
|
||
|
||
func permissionState(for permissionID: String) -> PluginPermissionState {
|
||
switch permissionID {
|
||
case TranslatorConstants.PermissionID.accessibility:
|
||
let isGranted = accessibilityTrustProvider()
|
||
return PluginPermissionState(
|
||
isGranted: isGranted,
|
||
footnote: isGranted
|
||
? nil
|
||
: localization.string(
|
||
"permission.accessibility.footnote",
|
||
defaultValue: "前往系统设置 → 隐私与安全性 → 辅助功能，授权 MacTools。"
|
||
)
|
||
)
|
||
case TranslatorConstants.PermissionID.automation:
|
||
return PluginPermissionState(
|
||
isGranted: true,
|
||
footnote: localization.string(
|
||
"permission.automation.footnote",
|
||
defaultValue: "macOS 会在首次控制浏览器时请求自动化授权。"
|
||
),
|
||
statusText: localization.string("permission.automation.status", defaultValue: "按需确认"),
|
||
statusSystemImage: "sparkles",
|
||
statusTone: .neutral
|
||
)
|
||
case TranslatorConstants.PermissionID.screenRecording:
|
||
let isGranted = screenRecordingPermissionProvider()
|
||
return PluginPermissionState(
|
||
isGranted: isGranted,
|
||
footnote: isGranted
|
||
? nil
|
||
: localization.string(
|
||
"permission.screenRecording.footnote",
|
||
defaultValue: "前往系统设置 → 隐私与安全性 → 屏幕录制，授权 MacTools。"
|
||
)
|
||
)
|
||
default:
|
||
return PluginPermissionState(isGranted: true, footnote: nil)
|
||
}
|
||
}
|
||
|
||
func handlePermissionAction(id: String) {
|
||
switch id {
|
||
case TranslatorConstants.PermissionID.accessibility:
|
||
_ = accessibilityTrustRequester(true)
|
||
onStateChange?()
|
||
case TranslatorConstants.PermissionID.automation:
|
||
requestPermissionGuidance?(TranslatorConstants.PermissionID.automation)
|
||
onStateChange?()
|
||
case TranslatorConstants.PermissionID.screenRecording:
|
||
NSWorkspace.shared.open(
|
||
URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture")!
|
||
)
|
||
onStateChange?()
|
||
default:
|
||
return
|
||
}
|
||
}
|
||
|
||
func handleSettingsAction(id: String) {}
|
||
|
||
func deactivate(reason: PluginDeactivationReason) {
|
||
guard reason.requiresStateCleanup else {
|
||
return
|
||
}
|
||
|
||
if let coordinator {
|
||
coordinator.close()
|
||
} else {
|
||
panelController.close()
|
||
}
|
||
coordinator = nil
|
||
}
|
||
|
||
func handleShortcutAction(id: String) {
|
||
guard isShortcutEnabled else {
|
||
return
|
||
}
|
||
|
||
switch id {
|
||
case TranslatorConstants.ActionID.selectTranslation:
|
||
if let selectTranslationStarter {
|
||
selectTranslationStarter()
|
||
return
|
||
}
|
||
|
||
let coordinator = coordinator ?? makeCoordinator()
|
||
self.coordinator = coordinator
|
||
coordinator.startSelectTranslation()
|
||
case TranslatorConstants.ActionID.screenshotTranslation:
|
||
if let screenshotTranslationStarter {
|
||
screenshotTranslationStarter()
|
||
return
|
||
}
|
||
|
||
let coordinator = coordinator ?? makeCoordinator()
|
||
self.coordinator = coordinator
|
||
coordinator.startScreenshotTranslation()
|
||
default:
|
||
return
|
||
}
|
||
}
|
||
|
||
private var isShortcutEnabled: Bool {
|
||
guard storage.object(forKey: TranslatorConstants.StorageKey.shortcutEnabled) != nil else {
|
||
return TranslatorConstants.Defaults.shortcutEnabled
|
||
}
|
||
|
||
return storage.bool(forKey: TranslatorConstants.StorageKey.shortcutEnabled)
|
||
}
|
||
|
||
private var panelSubtitle: String {
|
||
if !isShortcutEnabled {
|
||
return localization.string("panel.subtitle.shortcutPaused", defaultValue: "快捷键已暂停")
|
||
}
|
||
if !accessibilityTrustProvider() {
|
||
return localization.string("panel.subtitle.permissionRequired", defaultValue: "启用前需要辅助功能授权")
|
||
}
|
||
if enabledValidProfiles.isEmpty {
|
||
return localization.string("panel.subtitle.needsProvider", defaultValue: "需要配置翻译服务")
|
||
}
|
||
|
||
switch apiKeyState {
|
||
case .missing, .error:
|
||
return localization.string("panel.subtitle.needsProvider", defaultValue: "需要配置翻译服务")
|
||
case .unknown, .present:
|
||
return localization.string("panel.subtitle.ready", defaultValue: "按 ⌥D 划词，⌥S 截图")
|
||
}
|
||
}
|
||
|
||
private var enabledValidProfiles: [TranslatorProviderProfile] {
|
||
providerProfiles.filter { $0.isEnabled && $0.validationError == nil }
|
||
}
|
||
|
||
private var hasKnownAPIKey: Bool {
|
||
switch apiKeyState {
|
||
case .present:
|
||
return true
|
||
case .unknown:
|
||
return (try? secretStore.containsAPIKey()) == true
|
||
case .missing, .error:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func saveConfiguration(
|
||
_ configuration: OpenAICompatibleConfiguration,
|
||
apiKey: String,
|
||
languagePair: TranslatorLanguagePair
|
||
) -> String? {
|
||
let profile = TranslatorProviderProfile(
|
||
id: TranslatorProviderProfile.defaultID,
|
||
name: TranslatorProviderProfile.defaultName,
|
||
isEnabled: true,
|
||
baseURL: configuration.baseURL,
|
||
model: configuration.model,
|
||
promptTemplate: configuration.promptTemplate
|
||
)
|
||
return saveConfiguration(
|
||
profiles: [profile],
|
||
apiKeys: [profile.id: apiKey],
|
||
languagePair: languagePair
|
||
)
|
||
}
|
||
|
||
func saveConfiguration(
|
||
profiles: [TranslatorProviderProfile],
|
||
apiKeys: [String: String],
|
||
languagePair: TranslatorLanguagePair
|
||
) -> String? {
|
||
guard languagePair.first != languagePair.second else {
|
||
return localization.string("settings.error.sameLanguages", defaultValue: "两种偏好语言不能相同。")
|
||
}
|
||
|
||
guard profiles.contains(where: \.isEnabled) else {
|
||
return localization.string("settings.error.noEnabledProvider", defaultValue: "至少启用一个翻译服务。")
|
||
}
|
||
|
||
for profile in profiles where profile.isEnabled {
|
||
if let validationError = profile.validationError {
|
||
let title = profile.normalizedName.isEmpty
|
||
? localization.string("settings.provider.fallbackName", defaultValue: "翻译服务")
|
||
: profile.normalizedName
|
||
return localization.format(
|
||
"settings.error.providerValidationFormat",
|
||
defaultValue: "%@：%@",
|
||
title,
|
||
validationError.errorDescription(localization: localization)
|
||
)
|
||
}
|
||
}
|
||
|
||
do {
|
||
// Compute removed profiles before saving because `providerProfiles` still reflects
|
||
// the persisted state at this point.
|
||
let retainedProfileIDs = Set(profiles.map(\.id))
|
||
let removedProfileIDs = providerProfiles
|
||
.map(\.id)
|
||
.filter { !retainedProfileIDs.contains($0) }
|
||
|
||
for profile in profiles where profile.isEnabled {
|
||
let apiKey = apiKeys[profile.id]
|
||
if let normalizedAPIKey = Self.normalizedAPIKey(apiKey) {
|
||
try secretStore.saveAPIKey(normalizedAPIKey, forProfileID: profile.id)
|
||
cachedAPIKeys[profile.id] = normalizedAPIKey
|
||
didLoadProfileAPIKeys.insert(profile.id)
|
||
} else if try secretStore.containsAPIKey(forProfileID: profile.id) {
|
||
cachedAPIKeys.removeValue(forKey: profile.id)
|
||
didLoadProfileAPIKeys.remove(profile.id)
|
||
} else if profile.id == TranslatorProviderProfile.defaultID, hasKnownAPIKey {
|
||
cachedAPIKeys.removeValue(forKey: profile.id)
|
||
didLoadProfileAPIKeys.remove(profile.id)
|
||
} else {
|
||
apiKeyState = .missing
|
||
onStateChange?()
|
||
if profiles.count == 1, profile.id == TranslatorProviderProfile.defaultID {
|
||
return localization.string("settings.error.blankAPIKey", defaultValue: "API Key 不能为空。")
|
||
}
|
||
return localization.format(
|
||
"settings.error.providerBlankAPIKeyFormat",
|
||
defaultValue: "%@：API Key 不能为空。",
|
||
profile.normalizedName.isEmpty
|
||
? localization.string("settings.provider.fallbackName", defaultValue: "翻译服务")
|
||
: profile.normalizedName
|
||
)
|
||
}
|
||
}
|
||
|
||
// Remove stale Keychain credentials and caches for deleted profiles.
|
||
for removedID in removedProfileIDs {
|
||
try secretStore.deleteAPIKey(forProfileID: removedID)
|
||
cachedAPIKeys.removeValue(forKey: removedID)
|
||
didLoadProfileAPIKeys.remove(removedID)
|
||
}
|
||
|
||
try providerProfileStore.saveProfiles(profiles)
|
||
languagePreferenceStore.savePair(languagePair)
|
||
providerProfiles = providerProfileStore.loadProfiles()
|
||
providerConfiguration = providerProfiles.first?.configuration
|
||
?? OpenAICompatibleConfiguration(
|
||
promptTemplate: OpenAICompatibleConfiguration.defaultPromptTemplate(localization: localization)
|
||
)
|
||
self.languagePair = languagePair
|
||
cachedAPIKey = cachedAPIKeys[TranslatorProviderProfile.defaultID]
|
||
didLoadAPIKey = didLoadProfileAPIKeys.contains(TranslatorProviderProfile.defaultID)
|
||
apiKeyState = .present
|
||
if let coordinator {
|
||
coordinator.close()
|
||
} else {
|
||
panelController.close()
|
||
}
|
||
coordinator = nil
|
||
onStateChange?()
|
||
return nil
|
||
} catch {
|
||
return error.localizedDescription
|
||
}
|
||
}
|
||
|
||
private func handlePanelAction(_ action: TranslatorPanelAction) {
|
||
if action == .openSettings {
|
||
requestConfigurationPresentation?()
|
||
return
|
||
}
|
||
|
||
if action == .close {
|
||
if let coordinator {
|
||
coordinator.close()
|
||
} else {
|
||
panelController.close()
|
||
}
|
||
return
|
||
}
|
||
|
||
guard let coordinator else { return }
|
||
|
||
Task { await coordinator.handle(action) }
|
||
}
|
||
|
||
private func makeCoordinator() -> TranslatorCoordinator {
|
||
TranslatorCoordinator(
|
||
selectedTextCapturePipeline: selectedTextCapturePipeline,
|
||
screenshotRegionCapturer: screenshotRegionCapturer
|
||
?? screenshotRegionCapturerFactory(screenRecordingPermissionProvider),
|
||
ocrTextRecognizer: ocrTextRecognizer ?? VisionOCRTextRecognizer(),
|
||
languagePreferenceStore: LanguagePreferenceStore(storage: storage),
|
||
providerFactory: translationProviderFactoryOverride ?? { [weak self] in
|
||
guard let self else {
|
||
return .missing(
|
||
message: PluginLocalization(bundle: .main).string(
|
||
"panelError.missingProvider",
|
||
defaultValue: "请先启用翻译服务"
|
||
)
|
||
)
|
||
}
|
||
|
||
let resolvedProviders = self.resolvedTranslationProviders()
|
||
guard !resolvedProviders.isEmpty else {
|
||
return .missing(message: self.localization.string("panelError.missingProvider", defaultValue: "请先启用翻译服务"))
|
||
}
|
||
|
||
return .providers(resolvedProviders)
|
||
},
|
||
panelController: panelController,
|
||
localization: localization
|
||
)
|
||
}
|
||
|
||
private func resolvedTranslationProviders() -> [ResolvedTranslationProvider] {
|
||
// Capture state before resolution: `loadAPIKey` may update `apiKeyState` early through
|
||
// `updateLegacyAPIKeyCacheIfNeeded`. Compare against the pre-resolution value so state
|
||
// change notifications are not missed.
|
||
let previousState = apiKeyState
|
||
let resolved = providerProfiles.filter(\.isEnabled).map { profile -> ResolvedTranslationProvider in
|
||
if let validationError = profile.validationError {
|
||
return ResolvedTranslationProvider(
|
||
id: profile.id,
|
||
title: profile.normalizedName.isEmpty
|
||
? localization.string("settings.provider.fallbackName", defaultValue: "翻译服务")
|
||
: profile.normalizedName,
|
||
errorMessage: validationError.errorDescription(localization: localization)
|
||
)
|
||
}
|
||
|
||
do {
|
||
let apiKey = try loadAPIKey(for: profile.id)
|
||
guard let trimmedKey = Self.normalizedAPIKey(apiKey) else {
|
||
return ResolvedTranslationProvider(
|
||
id: profile.id,
|
||
title: profile.normalizedName,
|
||
errorMessage: localization.string("panelError.missingAPIKey", defaultValue: "请配置 API Key")
|
||
)
|
||
}
|
||
|
||
return ResolvedTranslationProvider(
|
||
id: profile.id,
|
||
title: profile.normalizedName,
|
||
provider: OpenAITranslationProviderAdapter(
|
||
client: OpenAICompatibleClient(localization: localization),
|
||
configuration: profile.configuration,
|
||
apiKey: trimmedKey,
|
||
providerTitle: profile.normalizedName
|
||
)
|
||
)
|
||
} catch {
|
||
return ResolvedTranslationProvider(
|
||
id: profile.id,
|
||
title: profile.normalizedName,
|
||
errorMessage: userFacingMessage(for: error)
|
||
)
|
||
}
|
||
}
|
||
|
||
updateAPIKeyState(forResolvedProviders: resolved, previousState: previousState)
|
||
return resolved
|
||
}
|
||
|
||
/// Aggregates the overall API-key state after resolving all enabled profiles.
|
||
/// A single usable provider counts as present so one profile with a missing key does not make
|
||
/// the whole plugin look missing.
|
||
private func updateAPIKeyState(
|
||
forResolvedProviders resolved: [ResolvedTranslationProvider],
|
||
previousState: APIKeyState
|
||
) {
|
||
guard !resolved.isEmpty else { return }
|
||
apiKeyState = resolved.contains { $0.provider != nil } ? .present : .missing
|
||
if apiKeyState != previousState {
|
||
onStateChange?()
|
||
}
|
||
}
|
||
|
||
private func userFacingMessage(for error: Error) -> String {
|
||
if let error = error as? OpenAICompatibleClientError {
|
||
return error.errorDescription(localization: localization)
|
||
}
|
||
if let error = error as? OpenAICompatibleConfigurationError {
|
||
return error.errorDescription(localization: localization)
|
||
}
|
||
if let error = error as? TranslationPromptRendererError {
|
||
return error.errorDescription(localization: localization)
|
||
}
|
||
if let error = error as? OpenAICompatibleSecretStoreError {
|
||
return error.errorDescription(localization: localization)
|
||
}
|
||
if let error = error as? TranslatorProviderProfileValidationError {
|
||
return error.errorDescription(localization: localization)
|
||
}
|
||
return error.localizedDescription
|
||
}
|
||
|
||
private static func hasNonEmptyAPIKey(_ apiKey: String?) -> Bool {
|
||
apiKey?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
|
||
}
|
||
|
||
private static func normalizedAPIKey(_ apiKey: String?) -> String? {
|
||
let trimmedKey = apiKey?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
||
return trimmedKey.isEmpty ? nil : trimmedKey
|
||
}
|
||
|
||
private func loadCachedAPIKeyIfNeeded() {
|
||
guard !didLoadAPIKey else {
|
||
return
|
||
}
|
||
let previousState = apiKeyState
|
||
|
||
do {
|
||
cachedAPIKey = try secretStore.loadAPIKey()
|
||
} catch {
|
||
cachedAPIKey = nil
|
||
apiKeyState = .error(error.localizedDescription)
|
||
didLoadAPIKey = true
|
||
if apiKeyState != previousState {
|
||
onStateChange?()
|
||
}
|
||
return
|
||
}
|
||
didLoadAPIKey = true
|
||
apiKeyState = Self.hasNonEmptyAPIKey(cachedAPIKey) ? .present : .missing
|
||
if apiKeyState != previousState {
|
||
onStateChange?()
|
||
}
|
||
}
|
||
|
||
private func loadAPIKey(for profileID: String) throws -> String? {
|
||
if didLoadProfileAPIKeys.contains(profileID) {
|
||
return cachedAPIKeys[profileID]
|
||
}
|
||
|
||
let profileKey = try secretStore.loadAPIKey(forProfileID: profileID)
|
||
if Self.hasNonEmptyAPIKey(profileKey) {
|
||
cachedAPIKeys[profileID] = profileKey
|
||
didLoadProfileAPIKeys.insert(profileID)
|
||
updateLegacyAPIKeyCacheIfNeeded(profileID: profileID, apiKey: profileKey)
|
||
return profileKey
|
||
}
|
||
|
||
if profileID == TranslatorProviderProfile.defaultID {
|
||
let legacyKey = try secretStore.loadAPIKey()
|
||
if Self.hasNonEmptyAPIKey(legacyKey) {
|
||
cachedAPIKeys[profileID] = legacyKey
|
||
didLoadProfileAPIKeys.insert(profileID)
|
||
updateLegacyAPIKeyCacheIfNeeded(profileID: profileID, apiKey: legacyKey)
|
||
return legacyKey
|
||
}
|
||
}
|
||
|
||
cachedAPIKeys.removeValue(forKey: profileID)
|
||
didLoadProfileAPIKeys.insert(profileID)
|
||
updateLegacyAPIKeyCacheIfNeeded(profileID: profileID, apiKey: nil)
|
||
return nil
|
||
}
|
||
|
||
private func updateLegacyAPIKeyCacheIfNeeded(profileID: String, apiKey: String?) {
|
||
guard profileID == TranslatorProviderProfile.defaultID else {
|
||
return
|
||
}
|
||
|
||
cachedAPIKey = apiKey
|
||
didLoadAPIKey = true
|
||
apiKeyState = Self.hasNonEmptyAPIKey(apiKey) ? .present : .missing
|
||
}
|
||
}
|