Merge pull request #20 : Build with SwiftPM and avoid code signing

This PR makes the build reproducible which in turns enable integration in the homebrew repository.

Merge pull request #20 from ratkins/master

Author: jeantil

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj

Package.resolved

@@ -0,0 +1,16 @@
+{
+  "object": {
+    "pins": [
+      {
+        "package": "SwiftPM",
+        "repositoryURL": "https://github.com/apple/swift-package-manager",
+        "state": {
+          "branch": null,
+          "revision": "235aacc514cb81a6881364b0fedcb3dd083228f3",
+          "version": "0.3.0"
+        }
+      }
+    ]
+  },
+  "version": 1
+}

Package.swift

@@ -0,0 +1,25 @@
+// swift-tools-version:4.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "autokbisw",
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-package-manager", from: "0.3.0"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages which this package depends on.
+        .target(
+            name: "autokbisw",
+            dependencies: ["Utility"]
+        ),
+        .testTarget(
+            name: "autokbiswTests",
+            dependencies: ["autokbisw"]
+        ),
+    ]
+)

Sources/autokbisw/IOKeyEventMonitor.swift

@@ -0,0 +1,180 @@
+// Copyright [2016] Jean Helou
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Carbon
+import Foundation
+import IOKit
+import IOKit.hid
+import IOKit.usb
+
+internal final class IOKeyEventMonitor {
+    private let hidManager: IOHIDManager
+    fileprivate let MAPPINGS_DEFAULTS_KEY = "keyboardISMapping"
+    fileprivate let notificationCenter: CFNotificationCenter
+    fileprivate var lastActiveKeyboard: String = ""
+    fileprivate var kb2is: [String: TISInputSource] = [String: TISInputSource]()
+    fileprivate var defaults: UserDefaults = UserDefaults.standard
+    fileprivate var useLocation: Bool
+    fileprivate var verbosity: Int
+
+    init? (usagePage: Int, usage: Int, useLocation: Bool, verbosity: Int) {
+        self.useLocation = useLocation
+        self.verbosity = verbosity
+        hidManager = IOHIDManagerCreate(kCFAllocatorDefault, IOOptionBits(kIOHIDOptionsTypeNone))
+        notificationCenter = CFNotificationCenterGetDistributedCenter()
+        let deviceMatch: CFMutableDictionary = [kIOHIDDeviceUsageKey: usage, kIOHIDDeviceUsagePageKey: usagePage] as NSMutableDictionary
+        IOHIDManagerSetDeviceMatching(hidManager, deviceMatch)
+        loadMappings()
+    }
+
+    deinit {
+        self.saveMappings()
+        let context = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
+        IOHIDManagerRegisterInputValueCallback(hidManager, Optional.none, context)
+        CFNotificationCenterRemoveObserver(notificationCenter, context, CFNotificationName(kTISNotifySelectedKeyboardInputSourceChanged), nil)
+    }
+
+    func start() {
+        let context = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
+
+        observeIputSourceChangedNotification(context: context)
+        registerHIDKeyboardCallback(context: context)
+
+        IOHIDManagerScheduleWithRunLoop(hidManager, CFRunLoopGetMain(), CFRunLoopMode.defaultMode!.rawValue)
+        IOHIDManagerOpen(hidManager, IOOptionBits(kIOHIDOptionsTypeNone))
+    }
+
+    private func observeIputSourceChangedNotification(context: UnsafeMutableRawPointer) {
+        let inputSourceChanged: CFNotificationCallback = {
+            _, observer, _, _, _ in
+            let selfPtr = Unmanaged<IOKeyEventMonitor>.fromOpaque(observer!).takeUnretainedValue()
+            selfPtr.onInputSourceChanged()
+        }
+
+        CFNotificationCenterAddObserver(notificationCenter,
+                                        context, inputSourceChanged,
+                                        kTISNotifySelectedKeyboardInputSourceChanged, nil,
+                                        CFNotificationSuspensionBehavior.deliverImmediately)
+    }
+
+    private func registerHIDKeyboardCallback(context: UnsafeMutableRawPointer) {
+        let myHIDKeyboardCallback: IOHIDValueCallback = {
+            context, _, sender, _ in
+            let selfPtr = Unmanaged<IOKeyEventMonitor>.fromOpaque(context!).takeUnretainedValue()
+            let senderDevice = Unmanaged<IOHIDDevice>.fromOpaque(sender!).takeUnretainedValue()
+
+            let vendorId = IOHIDDeviceGetProperty(senderDevice, kIOHIDVendorIDKey as CFString) ??? "unknown"
+            let productId = IOHIDDeviceGetProperty(senderDevice, kIOHIDProductIDKey as CFString) ??? "unknown"
+            let product = IOHIDDeviceGetProperty(senderDevice, kIOHIDProductKey as CFString) ??? "unknown"
+            let manufacturer = IOHIDDeviceGetProperty(senderDevice, kIOHIDManufacturerKey as CFString) ??? "unknown"
+            let serialNumber = IOHIDDeviceGetProperty(senderDevice, kIOHIDSerialNumberKey as CFString) ??? "unknown"
+            let locationId = IOHIDDeviceGetProperty(senderDevice, kIOHIDLocationIDKey as CFString) ??? "unknown"
+            let uniqueId = IOHIDDeviceGetProperty(senderDevice, kIOHIDUniqueIDKey as CFString) ??? "unknown"
+
+            let keyboard = selfPtr.useLocation
+                ? "\(product)-[\(vendorId)-\(productId)-\(manufacturer)-\(serialNumber)-\(locationId)]"
+                : "\(product)-[\(vendorId)-\(productId)-\(manufacturer)-\(serialNumber)]"
+
+            if selfPtr.verbosity >= TRACE {
+                print("received event from keyboard \(keyboard) - \(locationId) - \(uniqueId)")
+            }
+            selfPtr.onKeyboardEvent(keyboard: keyboard)
+        }
+
+        IOHIDManagerRegisterInputValueCallback(hidManager, myHIDKeyboardCallback, context)
+    }
+}
+
+extension IOKeyEventMonitor {
+    func restoreInputSource(keyboard: String) {
+        if let targetIs = kb2is[keyboard] {
+            if verbosity >= DEBUG {
+                print("set input source to \(targetIs) for keyboard \(keyboard)")
+            }
+            TISSelectInputSource(targetIs)
+        } else {
+            storeInputSource(keyboard: keyboard)
+        }
+    }
+
+    func storeInputSource(keyboard: String) {
+        let currentSource: TISInputSource = TISCopyCurrentKeyboardInputSource().takeUnretainedValue()
+        kb2is[keyboard] = currentSource
+        saveMappings()
+    }
+
+    func onInputSourceChanged() {
+        storeInputSource(keyboard: lastActiveKeyboard)
+    }
+
+    func onKeyboardEvent(keyboard: String) {
+        guard lastActiveKeyboard != keyboard else { return }
+
+        restoreInputSource(keyboard: keyboard)
+        lastActiveKeyboard = keyboard
+    }
+
+    func loadMappings() {
+        let selectableIsProperties = [
+            kTISPropertyInputSourceIsEnableCapable: true,
+            kTISPropertyInputSourceCategory: kTISCategoryKeyboardInputSource,
+        ] as CFDictionary
+        let inputSources = TISCreateInputSourceList(selectableIsProperties, false).takeUnretainedValue() as! Array<TISInputSource>
+
+        let inputSourcesById = inputSources.reduce([String: TISInputSource]()) {
+            (dict, inputSource) -> [String: TISInputSource] in
+            var dict = dict
+            if let id = unmanagedStringToString(TISGetInputSourceProperty(inputSource, kTISPropertyInputSourceID)) {
+                dict[id] = inputSource
+            }
+            return dict
+        }
+
+        if let mappings = self.defaults.dictionary(forKey: MAPPINGS_DEFAULTS_KEY) {
+            for (keyboardId, inputSourceId) in mappings {
+                kb2is[keyboardId] = inputSourcesById[String(describing: inputSourceId)]
+            }
+        }
+    }
+
+    func saveMappings() {
+        let mappings = kb2is.mapValues(is2Id)
+        defaults.set(mappings, forKey: MAPPINGS_DEFAULTS_KEY)
+    }
+
+    private func is2Id(_ inputSource: TISInputSource) -> String? {
+        return unmanagedStringToString(TISGetInputSourceProperty(inputSource, kTISPropertyInputSourceID))!
+    }
+
+    func unmanagedStringToString(_ p: UnsafeMutableRawPointer?) -> String? {
+        if let cfValue = p {
+            let value = Unmanaged.fromOpaque(cfValue).takeUnretainedValue() as CFString
+            if CFGetTypeID(value) == CFStringGetTypeID() {
+                return value as String
+            } else {
+                return nil
+            }
+        } else {
+            return nil
+        }
+    }
+}
+
+// Nicer string interpolation of optional strings, see: https://oleb.net/blog/2016/12/optionals-string-interpolation/
+
+infix operator ???: NilCoalescingPrecedence
+
+public func ???<T>(optional: T?, defaultValue: @autoclosure () -> String) -> String {
+    return optional.map { String(describing: $0) } ?? defaultValue()
+}

Sources/autokbisw/main.swift

@@ -0,0 +1,48 @@
+// Copyright [2016] Jean Helou
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Basic
+import Foundation
+import Utility
+
+let DEBUG = 1
+let TRACE = 2
+
+let arguments = Array(ProcessInfo.processInfo.arguments.dropFirst())
+let parser = ArgumentParser(usage: "<options>", overview: "Automatic keyboard/input source switching for macOS")
+
+let locationUsage = """
+Use locationId to identify keyboards (defaults to false.)
+Note that the locationId changes when you plug a keyboard in a different port. Therefore using the locationId in the keyboards identifiers means the configured language will be associated to a keyboard on a specific port.
+
+"""
+let locationOption = parser.add(option: "--location", shortName: "-l", kind: Bool.self, usage: locationUsage, completion: .none)
+let verboseOption = parser.add(option: "--verbose", shortName: "-v", kind: Int.self, usage: "Print verbose output (1 = DEBUG, 2 = TRACE)", completion: .none)
+
+do {
+    let parsedArguments = try parser.parse(arguments)
+    let useLocation = parsedArguments.get(locationOption) ?? false
+    let verbosity = parsedArguments.get(verboseOption) ?? 0
+
+    if verbosity > 0 {
+        print("Starting with useLocation: \(useLocation) - verbosity: \(verbosity)");
+    }
+    let monitor = IOKeyEventMonitor(usagePage: 0x01, usage: 6, useLocation: useLocation, verbosity: verbosity)
+    monitor?.start()
+    CFRunLoopRun()
+} catch let e as ArgumentParserError {
+    print(e.description)
+} catch let e {
+    print(e.localizedDescription)
+}

Tests/LinuxMain.swift

@@ -0,0 +1,7 @@
+import XCTest
+
+import autokbiswTests
+
+var tests = [XCTestCaseEntry]()
+tests += autokbiswTests.allTests()
+XCTMain(tests)

Tests/autokbiswTests/XCTestManifests.swift

@@ -0,0 +1,9 @@
+import XCTest
+
+#if !os(macOS)
+    public func allTests() -> [XCTestCaseEntry] {
+        return [
+            testCase(autokbiswTests.allTests),
+        ]
+    }
+#endif

Tests/autokbiswTests/autokbiswTests.swift

@@ -0,0 +1,47 @@
+import class Foundation.Bundle
+import XCTest
+
+final class autokbiswTests: XCTestCase {
+    func testExample() throws {
+        // This is an example of a functional test case.
+        // Use XCTAssert and related functions to verify your tests produce the correct
+        // results.
+
+        // Some of the APIs that we use below are available in macOS 10.13 and above.
+        guard #available(macOS 10.13, *) else {
+            return
+        }
+
+        let fooBinary = productsDirectory.appendingPathComponent("autokbisw")
+
+        let process = Process()
+        process.executableURL = fooBinary
+
+        let pipe = Pipe()
+        process.standardOutput = pipe
+
+        try process.run()
+        process.waitUntilExit()
+
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        let output = String(data: data, encoding: .utf8)
+
+        XCTAssertEqual(output, "Hello, world!\n")
+    }
+
+    /// Returns path to the built products directory.
+    var productsDirectory: URL {
+        #if os(macOS)
+            for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") {
+                return bundle.bundleURL.deletingLastPathComponent()
+            }
+            fatalError("couldn't find the products directory")
+        #else
+            return Bundle.main.bundleURL
+        #endif
+    }
+
+    static var allTests = [
+        ("testExample", testExample),
+    ]
+}