OneClip 架构设计与核心模块解析¶

class ClipboardManager: NSObject, ObservableObject {
    // 剪贴板监控
    private var changeCount: Int = 0
    private var monitoringTimer: Timer?

    // 发布者
    @Published var clipboardItems: [ClipboardItem] = []
    @Published var currentClip: ClipboardItem?

    // 核心方法
    func startMonitoring()           // 启动监控
    func stopMonitoring()            // 停止监控
    func getClipboardContent()       // 获取剪贴板内容
    func setClipboardContent()       // 设置剪贴板内容
    func processNewClip()            // 处理新剪贴板项
}

@Entity
final class ClipboardItemEntity {
    @Attribute(.unique) var id: UUID
    var content: String?              // 文本内容
    var contentType: String           // 类型：text/image/file/link
    var timestamp: Date               // 创建时间
    var sourceApp: String?            // 来源应用
    var category: String?             // 分类标签
    var isFavorite: Bool              // 是否收藏
    var metadata: Data?               // 元数据（JSON）
    var fileURL: URL?                 // 文件路径
    var imageData: Data?              // 图片二进制数据
}

// 使用谓词和排序优化查询性能
func fetchClipboardItems(
    limit: Int = 100,
    offset: Int = 0,
    predicate: NSPredicate? = nil,
    sortBy: NSSortDescriptor? = nil
) -> [ClipboardItem] {
    let request = ClipboardItemEntity.fetchRequest()
    request.fetchLimit = limit
    request.fetchOffset = offset

    if let predicate = predicate {
        request.predicate = predicate
    }

    if let sortBy = sortBy {
        request.sortDescriptors = [sortBy]
    }

    return try? container.viewContext.fetch(request)
}

class ContentProcessor {
    func processContent(_ content: NSPasteboard.PasteboardType) -> ClipboardItem {
        switch content {
        case .string:
            return processText(pasteboard.string(forType: .string))
        case .tiff, .png:
            return processImage(pasteboard.data(forType: content))
        case .fileURL:
            return processFile(pasteboard.propertyList(forType: .fileURL))
        default:
            return processGeneric(content)
        }
    }

    private func processText(_ text: String?) -> ClipboardItem {
        guard let text = text else { return .empty }

        // 清理 YAML 前置
        let cleaned = text.replacingOccurrences(of: "^---.*?---", with: "", options: .regularExpression)

        // 检测内容类型
        let type = detectContentType(cleaned)

        // 生成摘要
        let summary = generateSummary(cleaned, maxLength: 100)

        return ClipboardItem(
            content: cleaned,
            type: type,
            summary: summary,
            timestamp: Date()
        )
    }
}

class HotkeyManager {
    // 快捷键映射
    private var hotkeyHandlers: [HotkeyAction: EventHotKeyRef] = [:]

    // 支持的快捷键
    enum HotkeyAction {
        case showMainWindow      // Cmd+Option+V
        case showQuickReply      // Cmd+Option+R
        case showStackPanel      // Control+Shift+C
        case pasteFromStack      // Control+Shift+V
        case showDragDrop        // Control+Shift+D
    }

    // 注册快捷键
    func registerHotkey(_ action: HotkeyAction, with keyCode: UInt32, modifiers: UInt32) {
        let eventSpec = EventHotKeyID(signature: OSType(action.rawValue), id: UInt32(action.hashValue))

        var hotKeyRef: EventHotKeyRef?
        RegisterEventHotKey(keyCode, modifiers, eventSpec, GetApplicationEventTarget(), 0, &hotKeyRef)

        hotkeyHandlers[action] = hotKeyRef
    }
}

class WindowManager: NSObject {
    // 主窗口
    var mainWindow: NSWindow?

    // 快捷回复窗口
    var quickReplyWindow: NSWindow?

    // 栈粘贴板窗口
    var stackPanelWindow: NSWindow?

    // 拖拽容器窗口
    var dragDropWindow: NSWindow?

    // 菜单栏弹窗
    var menuPopover: NSPopover?

    // 窗口显示逻辑
    func showMainWindow() {
        if mainWindow == nil {
            createMainWindow()
        }

        mainWindow?.makeKeyAndOrderFront(nil)
        NSApp.activate(ignoringOtherApps: true)
    }

    func hideAllWindows() {
        mainWindow?.orderOut(nil)
        quickReplyWindow?.orderOut(nil)
        stackPanelWindow?.orderOut(nil)
    }
}

protocol AIServiceProvider {
    func generateSummary(_ content: String) -> String
    func extractKeywords(_ content: String) -> [String]
    func classifyContent(_ content: String) -> String
}

class AIService {
    // 支持的服务
    enum Provider {
        case ollama(url: String)        // 本地 Ollama
        case openai(apiKey: String)     // OpenAI
        case deepseek(apiKey: String)   // DeepSeek
        case claude(apiKey: String)     // Claude
    }

    private var provider: AIServiceProvider?

    func setProvider(_ provider: Provider) {
        switch provider {
        case .ollama(let url):
            self.provider = OllamaProvider(baseURL: url)
        case .openai(let key):
            self.provider = OpenAIProvider(apiKey: key)
        case .deepseek(let key):
            self.provider = DeepSeekProvider(apiKey: key)
        case .claude(let key):
            self.provider = ClaudeProvider(apiKey: key)
        }
    }
}

class MemoryOptimizer {
    // 限制内存中的项数
    private let maxItemsInMemory = 500

    // 定期清理过期数据
    func cleanupOldItems() {
        let calendar = Calendar.current
        let sevenDaysAgo = calendar.date(byAdding: .day, value: -7, to: Date())!

        let predicate = NSPredicate(format: "timestamp < %@", sevenDaysAgo as NSDate)
        store.deleteItems(matching: predicate)
    }

    // 图片压缩存储
    func compressImage(_ image: NSImage) -> Data? {
        guard let tiffData = image.tiffRepresentation,
              let bitmapImage = NSBitmapImageRep(data: tiffData) else {
            return nil
        }

        // 压缩到 70% 质量
        return bitmapImage.representation(using: .jpeg, properties: [.compressionFactor: 0.7])
    }
}

class SearchOptimizer {
    // 使用 Core Data 谓词优化查询
    func searchClipboard(_ query: String) -> [ClipboardItem] {
        let predicate = NSPredicate(format: "content CONTAINS[cd] %@", query)

        let request = ClipboardItemEntity.fetchRequest()
        request.predicate = predicate
        request.fetchLimit = 50  // 限制结果数

        // 按时间倒序排列
        request.sortDescriptors = [NSSortDescriptor(keyPath: \ClipboardItemEntity.timestamp, ascending: false)]

        return try? container.viewContext.fetch(request)
    }

    // 搜索防抖
    func debouncedSearch(_ query: String, delay: TimeInterval = 0.3) {
        NSObject.cancelPreviousPerformRequests(withTarget: self)
        perform(#selector(executeSearch(_:)), with: query, afterDelay: delay)
    }
}

class AdaptiveMonitoring {
    private var monitoringInterval: TimeInterval = 0.1  // 100ms

    func adjustMonitoringFrequency() {
        let workspace = NSWorkspace.shared
        let frontmostApp = workspace.frontmostApplication

        // 检查应用是否活跃
        if isAppActive(frontmostApp) {
            monitoringInterval = 0.1   // 活跃：100ms
        } else {
            monitoringInterval = 0.5   // 空闲：500ms
        }

        // 重新设置定时器
        restartMonitoringTimer()
    }

    private func isAppActive(_ app: NSRunningApplication?) -> Bool {
        guard let app = app else { return false }
        return !app.isHidden && app.isActive
    }
}

enum ClipboardError: LocalizedError {
    case accessDenied
    case invalidContent
    case storageError(String)
    case networkError(String)

    var errorDescription: String? {
        switch self {
        case .accessDenied:
            return "无法访问剪贴板，请检查权限"
        case .invalidContent:
            return "无效的剪贴板内容"
        case .storageError(let msg):
            return "存储错误：\(msg)"
        case .networkError(let msg):
            return "网络错误：\(msg)"
        }
    }
}