@hasna/recordings 0.1.4 → 0.1.6

package/src/native/Recordings/Recordings/RecordingEngine.swift

@@ -0,0 +1,355 @@
+import SwiftUI
+import KeyboardShortcuts
+
+// MARK: - Custom shortcut (not fn — fn is handled by FnKeyMonitor)
+
+extension KeyboardShortcuts.Name {
+    static let toggleRecording = Self("toggleRecording")
+}
+
+// MARK: - Recording Mode
+
+enum RecordingMode: String, CaseIterable, Identifiable, Sendable {
+    case pushToTalk = "Push to Talk"
+    case dictation = "Dictation"
+    case command = "Command"
+
+    var id: String { rawValue }
+    var icon: String {
+        switch self {
+        case .pushToTalk: return "hand.tap.fill"
+        case .dictation: return "text.bubble.fill"
+        case .command: return "wand.and.stars"
+        }
+    }
+    var hint: String {
+        switch self {
+        case .pushToTalk: return "Hold fn to record, release to stop & paste"
+        case .dictation: return "Hold fn to dictate, release to stop & paste"
+        case .command: return "Select text, hold fn, speak to rewrite"
+        }
+    }
+}
+
+// MARK: - Transcription Result
+
+struct TranscriptionResult: Sendable {
+    let rawText: String
+    let processedText: String?
+    let timestamp: Date
+    var displayText: String { processedText ?? rawText }
+}
+
+// MARK: - Recording Engine
+
+@MainActor
+final class RecordingEngine: ObservableObject {
+    @Published var isRecording = false
+    @Published var mode: RecordingMode = .pushToTalk
+    @Published var useFnKey: Bool = true {
+        didSet {
+            UserDefaults.standard.set(useFnKey, forKey: "useFnKey")
+            updateFnMonitor()
+            updateStatus()
+        }
+    }
+    @Published var isWhisperMode = false
+    @Published var recentTranscriptions: [TranscriptionResult] = []
+    @Published var statusMessage = "Starting..."
+    @Published var isTranscribing = false
+    @Published var recordingDuration: TimeInterval = 0
+
+    private var recordProcess: Process?
+    private var stdinPipe: Pipe?
+    private var currentAudioPath: String?
+    private var recordingTimer: Timer?
+    private let maxDuration = 300
+
+    // fn key monitor (CGEventTap-based, swallows fn to prevent emoji picker)
+    private let fnMonitor = FnKeyMonitor()
+
+    let home = FileManager.default.homeDirectoryForCurrentUser.path
+    private var audioDir: String { "\(home)/.recordings/audio" }
+
+    init() {
+        try? FileManager.default.createDirectory(atPath: audioDir, withIntermediateDirectories: true)
+
+        // Load preferences
+        useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? true
+
+        // Set up fn key monitor — hold fn to record, release to stop (like WisprFlow)
+        fnMonitor.onFnKeyDown = { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self, self.useFnKey, !self.isRecording else { return }
+                self.startRecording()
+            }
+        }
+        fnMonitor.onFnKeyUp = { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self, self.useFnKey, self.isRecording else { return }
+                self.stopAndTranscribe()
+            }
+        }
+        updateFnMonitor()
+
+        // Set up custom shortcut (toggle mode — press to start, press to stop)
+        KeyboardShortcuts.onKeyUp(for: .toggleRecording) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.toggleRecording()
+            }
+        }
+
+        updateStatus()
+    }
+
+    private func updateFnMonitor() {
+        if useFnKey {
+            let ok = fnMonitor.start()
+            if !ok {
+                statusMessage = "fn needs Accessibility permission (System Settings > Privacy & Security > Accessibility)"
+            }
+        } else {
+            fnMonitor.stop()
+        }
+    }
+
+    func updateStatus() {
+        if isRecording || isTranscribing { return }
+
+        var parts: [String] = []
+        if useFnKey {
+            parts.append("fn (hold)")
+        }
+        if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+            parts.append(shortcut.description)
+        }
+
+        if parts.isEmpty {
+            statusMessage = "No shortcut set — enable fn or set a custom shortcut"
+        } else {
+            statusMessage = "Ready — press \(parts.joined(separator: " or ")) to record"
+        }
+    }
+
+    // MARK: - Toggle
+
+    func toggleRecording() {
+        if isRecording { stopAndTranscribe() } else { startRecording() }
+    }
+
+    // MARK: - Start Recording
+
+    func startRecording() {
+        guard !isRecording else { return }
+
+        let ts = DateFormatter()
+        ts.dateFormat = "yyyyMMdd'T'HHmmss"
+        let path = "\(audioDir)/rec-\(ts.string(from: Date())).wav"
+        currentAudioPath = path
+
+        let proc = Process()
+        let stdin = Pipe()
+        proc.executableURL = URL(fileURLWithPath: "/bin/bash")
+        proc.arguments = ["-c", """
+            export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
+            if command -v ffmpeg &>/dev/null; then
+                ffmpeg -f avfoundation -i ":0" -ar 16000 -ac 1 -t \(maxDuration) "\(path)" -y 2>/dev/null
+            elif command -v rec &>/dev/null; then
+                rec -r 16000 -c 1 -b 16 "\(path)" trim 0 \(maxDuration)
+            else
+                exit 1
+            fi
+        """]
+        proc.standardInput = stdin
+        proc.standardOutput = FileHandle.nullDevice
+        proc.standardError = FileHandle.nullDevice
+
+        do {
+            try proc.run()
+            recordProcess = proc
+            stdinPipe = stdin
+            isRecording = true
+            recordingDuration = 0
+            statusMessage = mode == .command ? "Speak your instruction..." : "Recording — press fn to stop"
+
+            recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+                Task { @MainActor [weak self] in
+                    self?.recordingDuration += 0.1
+                }
+            }
+        } catch {
+            statusMessage = "Failed: \(error.localizedDescription)"
+        }
+    }
+
+    // MARK: - Stop & Transcribe
+
+    func stopAndTranscribe() {
+        guard let proc = recordProcess else { return }
+
+        recordingTimer?.invalidate()
+        recordingTimer = nil
+
+        if let pipe = stdinPipe {
+            try? pipe.fileHandleForWriting.write(contentsOf: Data("q".utf8))
+            try? pipe.fileHandleForWriting.close()
+        }
+
+        isRecording = false
+        isTranscribing = true
+        statusMessage = "Transcribing..."
+
+        let audioPath = currentAudioPath
+        let curMode = mode
+        currentAudioPath = nil
+        recordProcess = nil
+        stdinPipe = nil
+        let homePath = home
+
+        Task.detached {
+            try? await Task.sleep(for: .seconds(1))
+            if proc.isRunning { proc.terminate() }
+            try? await Task.sleep(for: .milliseconds(300))
+            if proc.isRunning { proc.interrupt() }
+
+            guard let audioPath else {
+                await MainActor.run { self.finish("No audio file") }
+                return
+            }
+
+            let attrs = try? FileManager.default.attributesOfItem(atPath: audioPath)
+            let size = (attrs?[.size] as? Int) ?? 0
+            guard size >= 1000 else {
+                await MainActor.run { self.finish("Audio too short — speak longer") }
+                return
+            }
+
+            let output = CLIRunner.run(["transcribe", audioPath, "--json"], home: homePath)
+            let text = CLIRunner.parseJSON(output)
+
+            guard let text, !text.isEmpty else {
+                await MainActor.run { self.finish("Empty transcription") }
+                return
+            }
+
+            await MainActor.run {
+                self.isTranscribing = false
+                if curMode == .command {
+                    self.runCommandMode(instruction: text)
+                } else {
+                    self.pasteIntoFrontApp(text)
+                    self.recentTranscriptions.insert(
+                        TranscriptionResult(rawText: text, processedText: nil, timestamp: Date()), at: 0
+                    )
+                    if self.recentTranscriptions.count > 20 { self.recentTranscriptions.removeLast() }
+                    self.statusMessage = "Pasted: \(String(text.prefix(50)))"
+                }
+            }
+        }
+    }
+
+    private func finish(_ msg: String) {
+        isTranscribing = false
+        statusMessage = msg
+    }
+
+    // MARK: - Command Mode
+
+    private func runCommandMode(instruction: String) {
+        postKey(0x08, flags: .maskCommand) // Cmd+C
+        let homePath = home
+
+        Task {
+            try? await Task.sleep(for: .milliseconds(250))
+            let selected = NSPasteboard.general.string(forType: .string) ?? ""
+            guard !selected.isEmpty else {
+                statusMessage = "No text selected"
+                return
+            }
+            statusMessage = "Rewriting..."
+            isTranscribing = true
+            let prompt = "Rewrite: \"\(instruction)\"\n\nText:\n\(selected)"
+
+            Task.detached {
+                let result = CLIRunner.run(["transcribe", "--text", prompt, "--enhance"], home: homePath)
+                await MainActor.run {
+                    self.isTranscribing = false
+                    if !result.isEmpty {
+                        self.pasteIntoFrontApp(result)
+                        self.statusMessage = "Rewritten"
+                    } else {
+                        self.statusMessage = "Rewrite failed"
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Paste
+
+    func pasteIntoFrontApp(_ text: String) {
+        let pb = NSPasteboard.general
+        pb.clearContents()
+        pb.setString(text, forType: .string)
+
+        // Activate the last user app (not us)
+        let myPID = ProcessInfo.processInfo.processIdentifier
+        if let target = NSWorkspace.shared.runningApplications.first(where: {
+            $0.activationPolicy == .regular && $0.processIdentifier != myPID
+        }) {
+            target.activate()
+        }
+
+        // Wait for activation, then Cmd+V
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            self.postKey(0x09, flags: .maskCommand)
+        }
+    }
+
+    private func postKey(_ key: CGKeyCode, flags: CGEventFlags) {
+        let src = CGEventSource(stateID: .hidSystemState)
+        let down = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: true)
+        down?.flags = flags
+        down?.post(tap: .cghidEventTap)
+        let up = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: false)
+        up?.flags = flags
+        up?.post(tap: .cghidEventTap)
+    }
+}
+
+// MARK: - CLI Runner
+
+enum CLIRunner: Sendable {
+    static func run(_ args: [String], home: String) -> String {
+        let bin = "\(home)/.bun/bin/recordings"
+        let escaped = args.map { "\"\($0)\"" }.joined(separator: " ")
+        let proc = Process()
+        let pipe = Pipe()
+        proc.executableURL = URL(fileURLWithPath: "/bin/bash")
+        proc.arguments = ["-c", """
+            export PATH="\(home)/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
+            "\(bin)" \(escaped)
+        """]
+        proc.standardOutput = pipe
+        proc.standardError = FileHandle.nullDevice
+        do {
+            try proc.run()
+            proc.waitUntilExit()
+            return String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+        } catch { return "" }
+    }
+
+    static func parseJSON(_ output: String) -> String? {
+        if let s = output.range(of: "{"), let e = output.range(of: "}", options: .backwards) {
+            let json = String(output[s.lowerBound...e.upperBound])
+            if let data = json.data(using: .utf8),
+               let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                if let t = obj["processed_text"] as? String, !t.isEmpty { return t }
+                if let t = obj["raw_text"] as? String, !t.isEmpty { return t }
+            }
+        }
+        return output.components(separatedBy: "\n")
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .first { !$0.isEmpty && !$0.hasPrefix("{") && !$0.contains("Transcribing") && !$0.hasPrefix("Saved") }
+    }
+}

package/src/native/Recordings/Recordings/Recordings.entitlements

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.app-sandbox</key>
+    <false/>
+    <key>com.apple.security.device.audio-input</key>
+    <true/>
+    <key>com.apple.security.automation.apple-events</key>
+    <true/>
+</dict>
+</plist>

package/src/native/Recordings/Recordings/RecordingsApp.swift

@@ -0,0 +1,30 @@
+import SwiftUI
+import KeyboardShortcuts
+
+@main
+struct RecordingsApp: App {
+    @StateObject private var engine = RecordingEngine()
+    @StateObject private var shortcuts = VoiceShortcuts()
+
+    var body: some Scene {
+        MenuBarExtra {
+            MenuBarPopover(engine: engine, shortcuts: shortcuts)
+                .frame(width: 320, height: 440)
+        } label: {
+            if engine.isRecording {
+                Image(systemName: "record.circle.fill")
+                    .symbolRenderingMode(.multicolor)
+            } else if engine.isTranscribing {
+                Image(systemName: "ellipsis.circle")
+            } else {
+                Image(systemName: "mic.fill")
+            }
+        }
+        .menuBarExtraStyle(.window)
+
+        // Settings window — opened via SettingsLink
+        Settings {
+            SettingsView(engine: engine, shortcuts: shortcuts)
+        }
+    }
+}

package/src/native/Recordings/Recordings/SettingsView.swift

@@ -0,0 +1,93 @@
+import SwiftUI
+import KeyboardShortcuts
+
+struct SettingsView: View {
+    @ObservedObject var engine: RecordingEngine
+    @ObservedObject var shortcuts: VoiceShortcuts
+    @State private var newTrigger = ""
+    @State private var newContent = ""
+
+    var body: some View {
+        TabView {
+            generalTab.tabItem { Label("General", systemImage: "gear") }
+            shortcutsTab.tabItem { Label("Voice Shortcuts", systemImage: "text.badge.star") }
+        }
+        .frame(width: 480, height: 400)
+    }
+
+    private var generalTab: some View {
+        Form {
+            Section("Shortcut — fn Key") {
+                Toggle("Use fn (Globe) key", isOn: $engine.useFnKey)
+
+                if engine.useFnKey {
+                    Text("Hold fn to record, release to stop and paste.")
+                        .font(.caption).foregroundStyle(.secondary)
+                    HStack(spacing: 4) {
+                        Image(systemName: "exclamationmark.triangle.fill")
+                            .foregroundStyle(.orange)
+                        Text("Required: System Settings → Keyboard → set \"Press 🌐 key to: Do Nothing\"")
+                            .font(.caption)
+                    }
+                    Button("Open Keyboard Settings") {
+                        NSWorkspace.shared.open(URL(string: "x-apple.systempreferences:com.apple.Keyboard-Settings.extension")!)
+                    }.controlSize(.small)
+                }
+            }
+
+            Section("Shortcut — Custom Key") {
+                HStack {
+                    Text("Toggle Recording")
+                    Spacer()
+                    KeyboardShortcuts.Recorder(for: .toggleRecording) { _ in
+                        engine.updateStatus()
+                    }
+                }
+                Text("Click the field and press any key combo (e.g. ⌥D, ⌃R, F5).")
+                    .font(.caption).foregroundStyle(.secondary)
+            }
+
+            Section("Recording") {
+                Picker("Mode", selection: $engine.mode) {
+                    ForEach(RecordingMode.allCases) { m in
+                        Label(m.rawValue, systemImage: m.icon).tag(m)
+                    }
+                }
+                Toggle("Whisper Mode", isOn: $engine.isWhisperMode)
+            }
+        }
+        .formStyle(.grouped).padding()
+    }
+
+    private var shortcutsTab: some View {
+        VStack(spacing: 0) {
+            HStack(spacing: 8) {
+                TextField("Trigger phrase", text: $newTrigger).textFieldStyle(.roundedBorder)
+                TextField("Text to insert", text: $newContent).textFieldStyle(.roundedBorder)
+                Button("Add") {
+                    guard !newTrigger.isEmpty, !newContent.isEmpty else { return }
+                    shortcuts.add(trigger: newTrigger, content: newContent)
+                    newTrigger = ""; newContent = ""
+                }.buttonStyle(.borderedProminent).disabled(newTrigger.isEmpty || newContent.isEmpty)
+            }.padding()
+            Divider()
+            if shortcuts.shortcuts.isEmpty {
+                Spacer()
+                VStack(spacing: 8) {
+                    Image(systemName: "text.badge.star").font(.largeTitle).foregroundStyle(.quaternary)
+                    Text("No voice shortcuts yet").foregroundStyle(.secondary)
+                }
+                Spacer()
+            } else {
+                List {
+                    ForEach(shortcuts.shortcuts) { s in
+                        VStack(alignment: .leading) {
+                            Text(s.trigger).font(.body.bold())
+                            Text(s.content).font(.caption).foregroundStyle(.secondary).lineLimit(2)
+                        }
+                    }.onDelete(perform: shortcuts.remove)
+                }
+            }
+        }
+    }
+}

package/src/native/Recordings/Recordings/VoiceShortcuts.swift

@@ -0,0 +1,82 @@
+import SwiftUI
+
+// MARK: - Voice Shortcut
+
+struct VoiceShortcut: Identifiable, Codable {
+    let id: UUID
+    var trigger: String   // e.g. "add disclaimer"
+    var content: String   // text to insert when trigger is spoken
+
+    init(trigger: String, content: String) {
+        self.id = UUID()
+        self.trigger = trigger
+        self.content = content
+    }
+}
+
+// MARK: - Voice Shortcuts Manager
+
+@MainActor
+final class VoiceShortcuts: ObservableObject {
+    @Published var shortcuts: [VoiceShortcut] = []
+
+    private let storageURL: URL = {
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        return home.appendingPathComponent(".recordings/voice-shortcuts.json")
+    }()
+
+    init() {
+        load()
+    }
+
+    func add(trigger: String, content: String) {
+        let shortcut = VoiceShortcut(trigger: trigger, content: content)
+        shortcuts.append(shortcut)
+        save()
+    }
+
+    func remove(at offsets: IndexSet) {
+        shortcuts.remove(atOffsets: offsets)
+        save()
+    }
+
+    func update(_ shortcut: VoiceShortcut) {
+        if let index = shortcuts.firstIndex(where: { $0.id == shortcut.id }) {
+            shortcuts[index] = shortcut
+            save()
+        }
+    }
+
+    /// Check if transcribed text matches a voice shortcut trigger.
+    /// Returns the content to paste if matched, nil otherwise.
+    func match(_ text: String) -> String? {
+        let lower = text.lowercased().trimmingCharacters(in: .whitespacesAndNewlines)
+        for shortcut in shortcuts {
+            if lower.contains(shortcut.trigger.lowercased()) {
+                return shortcut.content
+            }
+        }
+        return nil
+    }
+
+    // MARK: - Persistence
+
+    private func save() {
+        do {
+            let data = try JSONEncoder().encode(shortcuts)
+            try data.write(to: storageURL, options: .atomic)
+        } catch {
+            print("Failed to save voice shortcuts: \(error)")
+        }
+    }
+
+    private func load() {
+        guard FileManager.default.fileExists(atPath: storageURL.path) else { return }
+        do {
+            let data = try Data(contentsOf: storageURL)
+            shortcuts = try JSONDecoder().decode([VoiceShortcut].self, from: data)
+        } catch {
+            print("Failed to load voice shortcuts: \(error)")
+        }
+    }
+}

package/src/native/Recordings/build.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Build Recordings.app for macOS 26
+# Usage: ./build.sh [debug|release]
+
+set -euo pipefail
+
+MODE="${1:-release}"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "Building Recordings.app ($MODE)..."
+swift build -c "$MODE"
+
+# Create .app bundle
+BUILD_DIR=".build/$MODE"
+APP_DIR="$BUILD_DIR/Recordings.app"
+CONTENTS="$APP_DIR/Contents"
+MACOS="$CONTENTS/MacOS"
+
+rm -rf "$APP_DIR"
+mkdir -p "$MACOS"
+
+# Copy binary
+cp "$BUILD_DIR/Recordings" "$MACOS/Recordings"
+
+# Copy Info.plist
+cp Recordings/Info.plist "$CONTENTS/Info.plist"
+
+# Copy entitlements (for codesigning)
+if [ -f Recordings/Recordings.entitlements ]; then
+    codesign --force --sign - --entitlements Recordings/Recordings.entitlements "$APP_DIR" 2>/dev/null || true
+fi
+
+echo "✓ Built $APP_DIR"
+echo ""
+echo "To install to ~/.recordings/:"
+echo "  cp -r $APP_DIR ~/.recordings/Recordings.app"
+echo ""
+echo "To run:"
+echo "  open $APP_DIR"

package/src/native/Recordings/test_fn.swift

@@ -0,0 +1,79 @@
+#!/usr/bin/env swift
+// Quick test: can we see fn key events via CGEventTap?
+import Cocoa
+
+print("Listening for ALL key events for 15 seconds...")
+print("Press fn, F5, Option, or any key. Ctrl+C to quit.\n")
+
+let mask: CGEventMask =
+    (1 << CGEventType.flagsChanged.rawValue) |
+    (1 << CGEventType.keyDown.rawValue) |
+    (1 << CGEventType.keyUp.rawValue)
+
+let callback: CGEventTapCallBack = { proxy, type, event, refcon in
+    let keyCode = event.getIntegerValueField(.keyboardEventKeycode)
+    let flags = event.flags
+
+    if type == .flagsChanged {
+        let fn = flags.contains(.maskSecondaryFn) ? " [fn]" : ""
+        let cmd = flags.contains(.maskCommand) ? " [cmd]" : ""
+        let opt = flags.contains(.maskAlternate) ? " [opt]" : ""
+        let ctrl = flags.contains(.maskControl) ? " [ctrl]" : ""
+        let shift = flags.contains(.maskShift) ? " [shift]" : ""
+        print("flagsChanged  keyCode=\(keyCode)\(fn)\(cmd)\(opt)\(ctrl)\(shift)")
+    } else if type == .keyDown {
+        print("keyDown       keyCode=\(keyCode)")
+    } else if type == .keyUp {
+        print("keyUp         keyCode=\(keyCode)")
+    } else if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
+        print("TAP DISABLED — re-enabling")
+        if let refcon {
+            let tap = Unmanaged<AnyObject>.fromOpaque(refcon).takeUnretainedValue() as! CFMachPort
+            CGEvent.tapEnable(tap: tap, enable: true)
+        }
+    }
+
+    return Unmanaged.passRetained(event)
+}
+
+// Try HID-level tap first
+var tap = CGEvent.tapCreate(
+    tap: .cghidEventTap,
+    place: .headInsertEventTap,
+    options: .defaultTap,
+    eventsOfInterest: mask,
+    callback: callback,
+    userInfo: nil
+)
+
+if tap == nil {
+    print("⚠ cghidEventTap failed, trying cgSessionEventTap...")
+    tap = CGEvent.tapCreate(
+        tap: .cgSessionEventTap,
+        place: .headInsertEventTap,
+        options: .defaultTap,
+        eventsOfInterest: mask,
+        callback: callback,
+        userInfo: nil
+    )
+}
+
+guard let tap else {
+    print("❌ FAILED to create event tap. Grant Accessibility permission:")
+    print("   System Settings > Privacy & Security > Accessibility")
+    exit(1)
+}
+
+print("✅ Event tap created successfully\n")
+
+let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
+CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .commonModes)
+CGEvent.tapEnable(tap: tap, enable: true)
+
+// Run for 15 seconds
+DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
+    print("\nDone.")
+    exit(0)
+}
+
+CFRunLoopRun()