Add keyboard backlight adjustment

DynamicIsland/managers/KeyboardBrightnessSensor.swift

@@ -0,0 +1,190 @@
+//
+//  KeyboardBrightnessSensor.swift
+//  DynamicIsland
+//
+//  Copied from TheBoringWorker-HUD `KeyboardManager.swift` and adapted for Atoll.
+//
+
+import Foundation
+import IOKit
+import IOKit.hid
+import ObjectiveC.runtime
+
+final class KeyboardBrightnessSensor {
+    private init() {}
+
+    private static let maxKeyboardBrightness: Float = 342
+    private static let coreBrightnessClient = CoreBrightnessClient()
+    private static var method = SensorMethod.standard
+
+    static func currentLevel() throws -> Float {
+        if let client = coreBrightnessClient, let value = client.currentBrightness() {
+            return clamp(value)
+        }
+        switch method {
+        case .standard:
+            do {
+                return normalizedValue(fromRaw: try readStandardRawLevel())
+            } catch {
+                method = .m1
+            }
+        case .m1:
+            do {
+                return normalizedValue(fromRaw: try readM1RawLevel())
+            } catch {
+                method = .allFailed
+            }
+        case .allFailed:
+            throw SensorError.Keyboard.notFound
+        }
+        return try currentLevel()
+    }
+
+    static func setLevel(_ level: Float) throws {
+        let clamped = max(0, min(1, level))
+        if let client = coreBrightnessClient, client.setBrightness(clamped) {
+            return
+        }
+        let raw = rawValue(fromNormalized: clamped)
+        do {
+            try writeStandard(rawLevel: raw)
+        } catch {
+            method = .m1
+            throw error
+        }
+    }
+
+    private static func clamp(_ value: Float) -> Float {
+        max(0, min(1, value))
+    }
+
+    private static func normalizedValue(fromRaw rawLevel: Float) -> Float {
+        let clamped = max(0, min(1, rawLevel))
+        if clamped <= 0.07 {
+            return 0
+        }
+        let value = log10(clamped + 0.03) + 1
+        return max(0, min(1, value))
+    }
+
+    private static func rawValue(fromNormalized normalized: Float) -> Float {
+        guard normalized > 0 else { return 0 }
+        let powValue = powf(10, normalized - 1) - 0.03
+        return max(0, min(1, powValue))
+    }
+
+    private static func readStandardRawLevel() throws -> Float {
+        let service = IOServiceGetMatchingService(kIOMasterPortDefault, IOServiceMatching("AppleHIDKeyboardEventDriverV2"))
+        guard service != 0 else {
+            throw SensorError.Keyboard.notStandard
+        }
+        defer { IOObjectRelease(service) }
+
+        guard let property: CFTypeRef = IORegistryEntryCreateCFProperty(
+            service,
+            "KeyboardBacklightBrightness" as CFString,
+            kCFAllocatorDefault,
+            0
+        )?.takeUnretainedValue() else {
+            throw SensorError.Keyboard.notStandard
+        }
+        if CFGetTypeID(property) == CFNumberGetTypeID() {
+            var rawValue: Float = 0
+            if CFNumberGetValue(property as! CFNumber, .floatType, &rawValue) {
+                return rawValue / maxKeyboardBrightness
+            }
+        }
+        throw SensorError.Keyboard.notStandard
+    }
+
+    private static func readM1RawLevel() throws -> Float {
+        let task = Process()
+        task.launchPath = "/usr/libexec/corebrightnessdiag"
+        task.arguments = ["status-info"]
+        let pipe = Pipe()
+        task.standardOutput = pipe
+        try task.run()
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        task.waitUntilExit()
+
+        if let plist = try? PropertyListSerialization.propertyList(from: data, options: [], format: nil) as? NSDictionary,
+           let keyboards = plist["CBKeyboards"] as? [String: [String: Any]] {
+            for keyboard in keyboards.values {
+                if let backlightInfo = keyboard["CBKeyboardBacklightContainer"] as? [String: Any],
+                   backlightInfo["KeyboardBacklightBuiltIn"] as? Bool == true,
+                   let brightness = backlightInfo["KeyboardBacklightBrightness"] as? Float {
+                    return brightness
+                }
+            }
+        }
+
+        throw SensorError.Keyboard.notSilicon
+    }
+
+    private static func writeStandard(rawLevel: Float) throws {
+        let service = IOServiceGetMatchingService(kIOMasterPortDefault, IOServiceMatching("AppleHIDKeyboardEventDriverV2"))
+        guard service != 0 else {
+            throw SensorError.Keyboard.notStandard
+        }
+        defer { IOObjectRelease(service) }
+
+        var scaled = rawLevel * maxKeyboardBrightness
+        guard let number = CFNumberCreate(kCFAllocatorDefault, .floatType, &scaled) else {
+            throw SensorError.Keyboard.notStandard
+        }
+        let status = IORegistryEntrySetCFProperty(service, "KeyboardBacklightBrightness" as CFString, number)
+        if status != KERN_SUCCESS {
+            throw SensorError.Keyboard.notStandard
+        }
+    }
+}
+
+// MARK: - CoreBrightness bridge
+private final class CoreBrightnessClient {
+    private static let keyboardID: UInt64 = 1
+    private var clientInstance: NSObject?
+    private let getSelector = NSSelectorFromString("brightnessForKeyboard:")
+    private let setSelector = NSSelectorFromString("setBrightness:forKeyboard:")
+
+    init?() {
+        var loaded = false
+        let bundlePaths = [
+            "/System/Library/PrivateFrameworks/CoreBrightness.framework",
+            "/System/Library/PrivateFrameworks/CoreBrightness.framework/CoreBrightness"
+        ]
+        for path in bundlePaths where !loaded {
+            if let bundle = Bundle(path: path) {
+                loaded = bundle.load()
+            }
+        }
+        guard loaded, let cls = NSClassFromString("KeyboardBrightnessClient") as? NSObject.Type else {
+            return nil
+        }
+        clientInstance = cls.init()
+    }
+
+    func currentBrightness() -> Float? {
+        guard let clientInstance,
+              let getter: BrightnessGetter = methodIMP(on: clientInstance, selector: getSelector, as: BrightnessGetter.self)
+        else { return nil }
+        return getter(clientInstance, getSelector, Self.keyboardID)
+    }
+
+    func setBrightness(_ value: Float) -> Bool {
+        guard let clientInstance,
+              let setter: BrightnessSetter = methodIMP(on: clientInstance, selector: setSelector, as: BrightnessSetter.self)
+        else { return false }
+        return setter(clientInstance, setSelector, value, Self.keyboardID).boolValue
+    }
+
+    private typealias BrightnessGetter = @convention(c) (NSObject, Selector, UInt64) -> Float
+    private typealias BrightnessSetter = @convention(c) (NSObject, Selector, Float, UInt64) -> ObjCBool
+
+    private func methodIMP<T>(on object: NSObject, selector: Selector, as type: T.Type) -> T? {
+        guard let cls = object_getClass(object),
+              let method = class_getInstanceMethod(cls, selector)
+        else { return nil }
+        let imp = method_getImplementation(method)
+        return unsafeBitCast(imp, to: T.self)
+    }
+}