Capture OSX media control buttons in Swift

Question

I would like my app to respond to the F7, F8 and F9 keyboard media control buttons. I am aware of this lovely library but it is not working in combination with Swift: https://github.com/nevyn/SPMediaKeyTap

Accepted Answer

I actually solved this problem myself just the other day. I wrote a blog post on it, as well as a Gist

I'll embed the blog post and final code just in case the blog or Gist ever go away. Note: This is a very long post that goes into detail about how the class in constructed and what you can do to call other methods in your App's delegate. If all you want is the finished product (the MediaApplication class), head towards the bottom. It's just above the XML and the Info.plist informaton.

For starters, to get the key events from the media keys you need to create a class that extends `NSApplication`. This is as simple as

```
import Cocoa

class MediaApplication: NSApplication {
}
```

Next, we need to override the `sendEvent()` function

```
override func sendEvent(event: NSEvent) {
    if (event.type == .SystemDefined && event.subtype.rawValue == 8) {
        let keyCode = ((event.data1 & 0xFFFF0000) >> 16)
        let keyFlags = (event.data1 & 0x0000FFFF)
        // Get the key state. 0xA is KeyDown, OxB is KeyUp
        let keyState = (((keyFlags & 0xFF00) >> 8)) == 0xA
        let keyRepeat = (keyFlags & 0x1)
        mediaKeyEvent(Int32(keyCode), state: keyState, keyRepeat: Bool(keyRepeat))
    }

super.sendEvent(event)
}
```

Now, I don't pretend to entirely understand what is going on here, but I think I have a decent idea. `NSEvent` objects contain several key properties: `type`, `subtype`, `data1`, and `data2`. `Type` and `subtype` are fairly self-explanatory, but `data1` and `data2` are extremely vague. Since the code only uses `data1`, that's what we'll be looking at. From what I can tell, `data1` contains all of the data surrounding a key event. That means it contains the key code and any key flags. It appears that key flags contain information about the key's state (Is the key pressed down? Has the key been released?) as well as whether or not the key is being held down and repeating the signal. I'm also guessing that the key code and key flags both take up half of the data contained in `data1` and the bitwise operations are separating that data out into appropriate variables. After we get the values we need, we call `mediaKeyEvent()` which I will get to in a moment. Regardless of what events get sent to our `MediaApplication`, we do want the default `NSApplication` to handle all events as well. To do this, we call `super.sendEvent(event)` at the end of the function. Now, let's take a look at `mediaKeyEvent()`.

```
func mediaKeyEvent(key: Int32, state: Bool, keyRepeat: Bool) {
    // Only send events on KeyDown. Without this check, these events will happen twice
    if (state) {
        switch(key) {
        case NX_KEYTYPE_PLAY:
            // Do work
            break
        case NX_KEYTYPE_FAST:
            // Do work
            break
        case NX_KEYTYPE_REWIND:
            // Do work
            break
        default:
            break
        }
    }
}
```

This is where things start to get fun. First things first, we only want to check what key is being pressed if `state` is true, which in this case is whenever the key is pressed down. Once we get into checking the keys, we look for `NX_KEYTYPE_PLAY`, `NX_KEYTYPE_FAST`, and `NX_KEYTYPE_REWIND`. If their functions aren't obvious, `NX_KEYTYPE_PLAY` is the play/pause key, `NX_KEYTYPE_FAST` is the next key, and `NX_KEYTYPE_REWIND` is the previous key. Right now, nothing happens when any of those keys is pressed down, so lets go over some possible logic. We'll start with a simple scenario.

```
case NX_KEYTYPE_PLAY:
    print("Play")
    break
```

With this code in place, when your application detects that the play/pause key has been pressed you will see "Play" printed out to the console. Simple, right? Let's up the ante by calling functions in your application's `NSApplicationDelegate`. First we will assume that your `NSApplicationDelegate` has a function called `printMessage`. We will be modifying it as we go, so pay close attention to the changes. They will be minor, but the changes will impact how you call them from `mediaEventKey`.

```
func printMessage() {
    print("Hello World")
}
```

This is the simplest case. When `printMessage()` is called, you will see "Hello World" in your console. You can call this by calling `performSelector` on your `NSApplicationDelegate` which is accessible through the `MediaApplication`. `performSelector` takes in a `Selector` which is just the name of the function in your `NSApplicationDelegate`.

```
case NX_KEYTYPE_PLAY:
    delegate!.performSelector("printMessage")
    break
```

Now, when your application detects that the play/pause key has been pressed, you will see "Hello World" printed to the console. Let's kick things up a notch with a new version of `printMessage` that takes in a parameter.

```
func printMessage(arg: String) {
    print(arg)
}
```

The idea is now that if `printMessage("Hello World")` is called, you will see "Hello World" in your console. We can now modify the `perfor…

Capture OSX media control buttons in Swift

Solution

Problem

Related problems