Added macosmediakeys plugin that allows playback control via keyboard media keys.

CHANGELOG.txt

@@ -3,6 +3,8 @@
 musikcube:
 * added chiptunes support via Game_Music_Emu! supported formats include: vgm,
   gym, spc, sap, nsfe, nsf, ay, gbs, hes, and kss
+* added `macmediakeys` plugin; macOS users can play/pause/resume/skip tracks
+  using the media keys on the keyboard.
 * substantially improved metadata indexing performance for large collections
 * ensure all utf8 strings are sanitized immediately before inserting them into
   the database. this wasn't being done properly before, and could lead to weird

CMakeLists.txt

@@ -172,6 +172,8 @@ elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(src/plugins/coreaudioout)
   add_dependencies(musikcube coreaudioout)
+  add_subdirectory(src/plugins/macosmediakeys)
+  add_dependencies(musikcube macosmediakeys)
 endif()
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")

src/plugins/macosmediakeys/CMakeLists.txt

@@ -0,0 +1,12 @@
+set (macosmediakeys_SOURCES
+  plugin.mm
+  NSObject+SPInvocationGrabbing.m
+  SPMediaKeyTap.m
+)
+
+FIND_LIBRARY(APP_KIT_LIBRARY AppKit)
+FIND_LIBRARY(CARBON_LIBRARY Carbon)
+MARK_AS_ADVANCED (APP_KIT_LIBRARY CARBON_LIBRARY)
+
+add_library(macosmediakeys SHARED ${macosmediakeys_SOURCES})
+target_link_libraries(macosmediakeys ${musikcube_LINK_LIBS} ${APP_KIT_LIBRARY} ${CARBON_LIBRARY})

src/plugins/macosmediakeys/NSObject+SPInvocationGrabbing.h

@@ -0,0 +1,30 @@
+#import <Foundation/Foundation.h>
+
+@interface SPInvocationGrabber : NSObject {
+    id _object;
+    NSInvocation *_invocation;
+    int frameCount;
+    char **frameStrings;
+    BOOL backgroundAfterForward;
+    BOOL onMainAfterForward;
+    BOOL waitUntilDone;
+}
+-(id)initWithObject:(id)obj;
+-(id)initWithObject:(id)obj stacktraceSaving:(BOOL)saveStack;
+@property (readonly, retain, nonatomic) id object;
+@property (readonly, retain, nonatomic) NSInvocation *invocation;
+@property BOOL backgroundAfterForward;
+@property BOOL onMainAfterForward;
+@property BOOL waitUntilDone;
+-(void)invoke; // will release object and invocation
+-(void)printBacktrace;
+-(void)saveBacktrace;
+@end
+
+@interface NSObject (SPInvocationGrabbing)
+-(id)grab;
+-(id)invokeAfter:(NSTimeInterval)delta;
+-(id)nextRunloop;
+-(id)inBackground;
+-(id)onMainAsync:(BOOL)async;
+@end

src/plugins/macosmediakeys/NSObject+SPInvocationGrabbing.m

@@ -0,0 +1,127 @@
+#import "NSObject+SPInvocationGrabbing.h"
+#import <execinfo.h>
+
+#pragma mark Invocation grabbing
+@interface SPInvocationGrabber ()
+@property (readwrite, retain, nonatomic) id object;
+@property (readwrite, retain, nonatomic) NSInvocation *invocation;
+
+@end
+
+@implementation SPInvocationGrabber
+- (id)initWithObject:(id)obj;
+{
+	return [self initWithObject:obj stacktraceSaving:YES];
+}
+
+-(id)initWithObject:(id)obj stacktraceSaving:(BOOL)saveStack;
+{
+	self.object = obj;
+
+	if(saveStack)
+		[self saveBacktrace];
+
+	return self;
+}
+-(void)dealloc;
+{
+	free(frameStrings);
+	self.object = nil;
+	self.invocation = nil;
+	[super dealloc];
+}
+@synthesize invocation = _invocation, object = _object;
+
+@synthesize backgroundAfterForward, onMainAfterForward, waitUntilDone;
+- (void)runInBackground;
+{
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	@try {
+		[self invoke];
+	}
+	@finally {
+		[pool drain];
+	}
+}
+
+
+- (void)forwardInvocation:(NSInvocation *)anInvocation {
+	[anInvocation retainArguments];
+	anInvocation.target = _object;
+	self.invocation = anInvocation;
+
+	if(backgroundAfterForward)
+		[NSThread detachNewThreadSelector:@selector(runInBackground) toTarget:self withObject:nil];
+	else if(onMainAfterForward)
+        [self performSelectorOnMainThread:@selector(invoke) withObject:nil waitUntilDone:waitUntilDone];
+}
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)inSelector {
+	NSMethodSignature *signature = [super methodSignatureForSelector:inSelector];
+	if (signature == NULL)
+		signature = [_object methodSignatureForSelector:inSelector];
+
+	return signature;
+}
+
+- (void)invoke;
+{
+
+	@try {
+		[_invocation invoke];
+	}
+	@catch (NSException * e) {
+		NSLog(@"SPInvocationGrabber's target raised %@:\n\t%@\nInvocation was originally scheduled at:", e.name, e);
+		[self printBacktrace];
+		printf("\n");
+		[e raise];
+	}
+
+	self.invocation = nil;
+	self.object = nil;
+}
+
+-(void)saveBacktrace;
+{
+  void *backtraceFrames[128];
+  frameCount = backtrace(&backtraceFrames[0], 128);
+  frameStrings = backtrace_symbols(&backtraceFrames[0], frameCount);
+}
+-(void)printBacktrace;
+{
+	for(int x = 3; x < frameCount; x++) {
+		if(frameStrings[x] == NULL) { break; }
+		printf("%s\n", frameStrings[x]);
+	}
+}
+@end
+
+@implementation NSObject (SPInvocationGrabbing)
+-(id)grab;
+{
+	return [[[SPInvocationGrabber alloc] initWithObject:self] autorelease];
+}
+-(id)invokeAfter:(NSTimeInterval)delta;
+{
+	id grabber = [self grab];
+	[NSTimer scheduledTimerWithTimeInterval:delta target:grabber selector:@selector(invoke) userInfo:nil repeats:NO];
+	return grabber;
+}
+- (id)nextRunloop;
+{
+	return [self invokeAfter:0];
+}
+-(id)inBackground;
+{
+    SPInvocationGrabber *grabber = [self grab];
+	grabber.backgroundAfterForward = YES;
+	return grabber;
+}
+-(id)onMainAsync:(BOOL)async;
+{
+    SPInvocationGrabber *grabber = [self grab];
+	grabber.onMainAfterForward = YES;
+    grabber.waitUntilDone = !async;
+	return grabber;
+}
+
+@end

src/plugins/macosmediakeys/SPMediaKeyTap.h

@@ -0,0 +1,43 @@
+#include <Cocoa/Cocoa.h>
+#import <IOKit/hidsystem/ev_keymap.h>
+#import <Carbon/Carbon.h>
+
+// http://overooped.com/post/2593597587/mediakeys
+
+#define SPSystemDefinedEventMediaKeys 8
+
+@interface SPMediaKeyTap : NSObject {
+	EventHandlerRef _app_switching_ref;
+	EventHandlerRef _app_terminating_ref;
+	CFMachPortRef _eventPort;
+	CFRunLoopSourceRef _eventPortSource;
+	CFRunLoopRef _tapThreadRL;
+	BOOL _shouldInterceptMediaKeyEvents;
+	id _delegate;
+	// The app that is frontmost in this list owns media keys
+	NSMutableArray *_mediaKeyAppList;
+}
++ (NSArray*)defaultMediaKeyUserBundleIdentifiers;
+
+-(id)initWithDelegate:(id)delegate;
+
++(BOOL)usesGlobalMediaKeyTap;
+-(void)startWatchingMediaKeys;
+-(void)stopWatchingMediaKeys;
+-(void)handleAndReleaseMediaKeyEvent:(NSEvent *)event;
+@end
+
+@interface NSObject (SPMediaKeyTapDelegate)
+-(void)mediaKeyTap:(SPMediaKeyTap*)keyTap receivedMediaKeyEvent:(NSEvent*)event;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern NSString *kMediaKeyUsingBundleIdentifiersDefaultsKey;
+extern NSString *kIgnoreMediaKeysDefaultsKey;
+
+#ifdef __cplusplus
+}
+#endif

src/plugins/macosmediakeys/SPMediaKeyTap.m

@@ -0,0 +1,344 @@
+// Copyright (c) 2010 Spotify AB
+#import "SPMediaKeyTap.h"
+#import "NSObject+SPInvocationGrabbing.h"
+
+@interface SPMediaKeyTap ()
+-(BOOL)shouldInterceptMediaKeyEvents;
+-(void)setShouldInterceptMediaKeyEvents:(BOOL)newSetting;
+-(void)startWatchingAppSwitching;
+-(void)stopWatchingAppSwitching;
+-(void)eventTapThread;
+@end
+static SPMediaKeyTap *singleton = nil;
+
+static pascal OSStatus appSwitched (EventHandlerCallRef nextHandler, EventRef evt, void* userData);
+static pascal OSStatus appTerminated (EventHandlerCallRef nextHandler, EventRef evt, void* userData);
+static CGEventRef tapEventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon);
+
+
+// Inspired by http://gist.github.com/546311
+
+@implementation SPMediaKeyTap
+
+#pragma mark -
+#pragma mark Setup and teardown
+-(id)initWithDelegate:(id)delegate;
+{
+	_delegate = delegate;
+	[self startWatchingAppSwitching];
+	singleton = self;
+	_mediaKeyAppList = [NSMutableArray new];
+    _tapThreadRL=nil;
+    _eventPort=nil;
+    _eventPortSource=nil;
+	return self;
+}
+-(void)dealloc;
+{
+	[self stopWatchingMediaKeys];
+	[self stopWatchingAppSwitching];
+	[_mediaKeyAppList release];
+	[super dealloc];
+}
+
+-(void)startWatchingAppSwitching;
+{
+	// Listen to "app switched" event, so that we don't intercept media keys if we
+	// weren't the last "media key listening" app to be active
+	EventTypeSpec eventType = { kEventClassApplication, kEventAppFrontSwitched };
+    OSStatus err = InstallApplicationEventHandler(NewEventHandlerUPP(appSwitched), 1, &eventType, self, &_app_switching_ref);
+	assert(err == noErr);
+
+	eventType.eventKind = kEventAppTerminated;
+    err = InstallApplicationEventHandler(NewEventHandlerUPP(appTerminated), 1, &eventType, self, &_app_terminating_ref);
+	assert(err == noErr);
+}
+-(void)stopWatchingAppSwitching;
+{
+	if(!_app_switching_ref) return;
+	RemoveEventHandler(_app_switching_ref);
+	_app_switching_ref = NULL;
+}
+
+-(void)startWatchingMediaKeys;{
+    // Prevent having multiple mediaKeys threads
+    [self stopWatchingMediaKeys];
+
+	[self setShouldInterceptMediaKeyEvents:YES];
+
+	// Add an event tap to intercept the system defined media key events
+	_eventPort = CGEventTapCreate(kCGSessionEventTap,
+								  kCGHeadInsertEventTap,
+								  kCGEventTapOptionDefault,
+								  CGEventMaskBit(NX_SYSDEFINED),
+								  tapEventCallback,
+								  self);
+	assert(_eventPort != NULL);
+
+    _eventPortSource = CFMachPortCreateRunLoopSource(kCFAllocatorSystemDefault, _eventPort, 0);
+	assert(_eventPortSource != NULL);
+
+	// Let's do this in a separate thread so that a slow app doesn't lag the event tap
+	[NSThread detachNewThreadSelector:@selector(eventTapThread) toTarget:self withObject:nil];
+}
+-(void)stopWatchingMediaKeys;
+{
+	// TODO<nevyn>: Shut down thread, remove event tap port and source
+
+    if(_tapThreadRL){
+        CFRunLoopStop(_tapThreadRL);
+        _tapThreadRL=nil;
+    }
+
+    if(_eventPort){
+        CFMachPortInvalidate(_eventPort);
+        CFRelease(_eventPort);
+        _eventPort=nil;
+    }
+
+    if(_eventPortSource){
+        CFRelease(_eventPortSource);
+        _eventPortSource=nil;
+    }
+}
+
+#pragma mark -
+#pragma mark Accessors
+
++(BOOL)usesGlobalMediaKeyTap
+{
+#ifdef _DEBUG
+	// breaking in gdb with a key tap inserted sometimes locks up all mouse and keyboard input forever, forcing reboot
+	return NO;
+#else
+	// XXX(nevyn): MediaKey event tap doesn't work on 10.4, feel free to figure out why if you have the energy.
+	return
+		![[NSUserDefaults standardUserDefaults] boolForKey:kIgnoreMediaKeysDefaultsKey]
+		&& floor(NSAppKitVersionNumber) >= 949/*NSAppKitVersionNumber10_5*/;
+#endif
+}
+
++ (NSArray*)defaultMediaKeyUserBundleIdentifiers;
+{
+	return [NSArray arrayWithObjects:
+		[[NSBundle mainBundle] bundleIdentifier], // your app
+		@"com.spotify.client",
+		@"com.apple.iTunes",
+		@"com.apple.QuickTimePlayerX",
+		@"com.apple.quicktimeplayer",
+		@"com.apple.iWork.Keynote",
+		@"com.apple.iPhoto",
+		@"org.videolan.vlc",
+		@"com.apple.Aperture",
+		@"com.plexsquared.Plex",
+		@"com.soundcloud.desktop",
+		@"org.niltsh.MPlayerX",
+		@"com.ilabs.PandorasHelper",
+		@"com.mahasoftware.pandabar",
+		@"com.bitcartel.pandorajam",
+		@"org.clementine-player.clementine",
+		@"fm.last.Last.fm",
+		@"fm.last.Scrobbler",
+		@"com.beatport.BeatportPro",
+		@"com.Timenut.SongKey",
+		@"com.macromedia.fireworks", // the tap messes up their mouse input
+		@"at.justp.Theremin",
+		@"ru.ya.themblsha.YandexMusic",
+		@"com.jriver.MediaCenter18",
+		@"com.jriver.MediaCenter19",
+		@"com.jriver.MediaCenter20",
+		@"co.rackit.mate",
+		@"com.ttitt.b-music",
+		@"com.beardedspice.BeardedSpice",
+		@"com.plug.Plug",
+		@"com.plug.Plug2",
+    	@"com.netease.163music",
+		@"org.quodlibet.quodlibet",
+		nil
+	];
+}
+
+
+-(BOOL)shouldInterceptMediaKeyEvents;
+{
+	BOOL shouldIntercept = NO;
+	@synchronized(self) {
+		shouldIntercept = _shouldInterceptMediaKeyEvents;
+	}
+	return shouldIntercept;
+}
+
+-(void)pauseTapOnTapThread:(BOOL)yeahno;
+{
+	CGEventTapEnable(self->_eventPort, yeahno);
+}
+-(void)setShouldInterceptMediaKeyEvents:(BOOL)newSetting;
+{
+	BOOL oldSetting;
+	@synchronized(self) {
+		oldSetting = _shouldInterceptMediaKeyEvents;
+		_shouldInterceptMediaKeyEvents = newSetting;
+	}
+	if(_tapThreadRL && oldSetting != newSetting) {
+		id grab = [self grab];
+		[grab pauseTapOnTapThread:newSetting];
+		NSTimer *timer = [NSTimer timerWithTimeInterval:0 invocation:[grab invocation] repeats:NO];
+		CFRunLoopAddTimer(_tapThreadRL, (CFRunLoopTimerRef)timer, kCFRunLoopCommonModes);
+	}
+}
+
+#pragma mark
+#pragma mark -
+#pragma mark Event tap callbacks
+
+// Note: method called on background thread
+
+static CGEventRef tapEventCallback2(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)
+{
+	SPMediaKeyTap *self = refcon;
+
+    if(type == kCGEventTapDisabledByTimeout) {
+		NSLog(@"Media key event tap was disabled by timeout");
+		CGEventTapEnable(self->_eventPort, TRUE);
+		return event;
+	} else if(type == kCGEventTapDisabledByUserInput) {
+		// Was disabled manually by -[pauseTapOnTapThread]
+		return event;
+	}
+	NSEvent *nsEvent = nil;
+	@try {
+		nsEvent = [NSEvent eventWithCGEvent:event];
+	}
+	@catch (NSException * e) {
+		NSLog(@"Strange CGEventType: %d: %@", type, e);
+		assert(0);
+		return event;
+	}
+
+	if (type != NX_SYSDEFINED || [nsEvent subtype] != SPSystemDefinedEventMediaKeys)
+		return event;
+
+	int keyCode = (([nsEvent data1] & 0xFFFF0000) >> 16);
+    if (keyCode != NX_KEYTYPE_PLAY && keyCode != NX_KEYTYPE_FAST && keyCode != NX_KEYTYPE_REWIND && keyCode != NX_KEYTYPE_PREVIOUS && keyCode != NX_KEYTYPE_NEXT)
+		return event;
+
+	if (![self shouldInterceptMediaKeyEvents])
+		return event;
+
+	[nsEvent retain]; // matched in handleAndReleaseMediaKeyEvent:
+	[self handleAndReleaseMediaKeyEvent: nsEvent];
+	return NULL;
+}
+
+static CGEventRef tapEventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)
+{
+	NSAutoreleasePool *pool = [NSAutoreleasePool new];
+	CGEventRef ret = tapEventCallback2(proxy, type, event, refcon);
+	[pool drain];
+	return ret;
+}
+
+// event will have been retained in the other thread
+-(void)handleAndReleaseMediaKeyEvent:(NSEvent *)event
+{
+	[event autorelease];
+	[_delegate mediaKeyTap:self receivedMediaKeyEvent:event];
+}
+
+-(void)eventTapThread;
+{
+	_tapThreadRL = CFRunLoopGetCurrent();
+	CFRunLoopAddSource(_tapThreadRL, _eventPortSource, kCFRunLoopCommonModes);
+	CFRunLoopRun();
+}
+
+#pragma mark Task switching callbacks
+
+NSString *kMediaKeyUsingBundleIdentifiersDefaultsKey = @"SPApplicationsNeedingMediaKeys";
+NSString *kIgnoreMediaKeysDefaultsKey = @"SPIgnoreMediaKeys";
+
+
+
+-(void)mediaKeyAppListChanged;
+{
+	if([_mediaKeyAppList count] == 0) return;
+
+	/*NSLog(@"--");
+	int i = 0;
+	for (NSValue *psnv in _mediaKeyAppList) {
+		ProcessSerialNumber psn; [psnv getValue:&psn];
+		NSDictionary *processInfo = [(id)ProcessInformationCopyDictionary(
+			&psn,
+			kProcessDictionaryIncludeAllInformationMask
+		) autorelease];
+		NSString *bundleIdentifier = [processInfo objectForKey:(id)kCFBundleIdentifierKey];
+		NSLog(@"%d: %@", i++, bundleIdentifier);
+	}*/
+
+    ProcessSerialNumber mySerial, topSerial;
+	GetCurrentProcess(&mySerial);
+	[[_mediaKeyAppList objectAtIndex:0] getValue:&topSerial];
+
+	Boolean same;
+	OSErr err = SameProcess(&mySerial, &topSerial, &same);
+	[self setShouldInterceptMediaKeyEvents:(err == noErr && same)];
+
+}
+-(void)appIsNowFrontmost:(ProcessSerialNumber)psn;
+{
+	NSValue *psnv = [NSValue valueWithBytes:&psn objCType:@encode(ProcessSerialNumber)];
+
+	NSDictionary *processInfo = [(id)ProcessInformationCopyDictionary(
+		&psn,
+		kProcessDictionaryIncludeAllInformationMask
+	) autorelease];
+	NSString *bundleIdentifier = [processInfo objectForKey:(id)kCFBundleIdentifierKey];
+
+	NSArray *whitelistIdentifiers = [[NSUserDefaults standardUserDefaults] arrayForKey:kMediaKeyUsingBundleIdentifiersDefaultsKey];
+	if(![whitelistIdentifiers containsObject:bundleIdentifier]) return;
+
+	[_mediaKeyAppList removeObject:psnv];
+	[_mediaKeyAppList insertObject:psnv atIndex:0];
+	[self mediaKeyAppListChanged];
+}
+-(void)appTerminated:(ProcessSerialNumber)psn;
+{
+	NSValue *psnv = [NSValue valueWithBytes:&psn objCType:@encode(ProcessSerialNumber)];
+	[_mediaKeyAppList removeObject:psnv];
+	[self mediaKeyAppListChanged];
+}
+
+static pascal OSStatus appSwitched (EventHandlerCallRef nextHandler, EventRef evt, void* userData)
+{
+	SPMediaKeyTap *self = (id)userData;
+
+    ProcessSerialNumber newSerial;
+    GetFrontProcess(&newSerial);
+
+	[self appIsNowFrontmost:newSerial];
+
+    return CallNextEventHandler(nextHandler, evt);
+}
+
+static pascal OSStatus appTerminated (EventHandlerCallRef nextHandler, EventRef evt, void* userData)
+{
+	SPMediaKeyTap *self = (id)userData;
+
+	ProcessSerialNumber deadPSN;
+
+	GetEventParameter(
+		evt,
+		kEventParamProcessID,
+		typeProcessSerialNumber,
+		NULL,
+		sizeof(deadPSN),
+		NULL,
+		&deadPSN
+	);
+
+
+	[self appTerminated:deadPSN];
+    return CallNextEventHandler(nextHandler, evt);
+}
+
+@end

src/plugins/macosmediakeys/plugin.mm

@@ -0,0 +1,175 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004-2019 musikcube team
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//    * Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//    * Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//    * Neither the name of the author nor the names of other contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <core/sdk/constants.h>
+#include <core/sdk/IPlugin.h>
+#include <core/sdk/IPlaybackRemote.h>
+#include <mutex>
+#include <iostream>
+#include "SPMediaKeyTap.h"
+
+using namespace musik::core::sdk;
+
+struct IKeyProcessor {
+    virtual void ProcessKeyCode(int keyCode) = 0;
+};
+
+@interface MediaKeys: NSObject {
+    SPMediaKeyTap* keyTap;
+    IKeyProcessor* processor;
+}
+- (void) unregister;
+- (void) setKeyProcessor: (IKeyProcessor*) processor;
+@end
+
+static class Plugin: public IPlugin {
+    public:
+        virtual void Release() override { }
+        virtual const char* Name() override { return "MediaKeys IPlaybackRemote"; }
+        virtual const char* Version() override { return "0.1.0"; }
+        virtual const char* Author() override { return "clangen"; }
+        virtual const char* Guid() override { return "e850a2eb-5aaa-4322-b63e-bf1c1593805b"; }
+        virtual bool Configurable() override { return false; }
+        virtual void Configure() override { }
+        virtual void Reload() override { }
+        virtual int SdkVersion() override { return musik::core::sdk::SdkVersion; }
+} plugin;
+
+class PlaybackRemote: public IPlaybackRemote, IKeyProcessor {
+    public:
+        PlaybackRemote() {
+            this->mediaKeys = [[MediaKeys alloc] init];
+            [this->mediaKeys setKeyProcessor: this];
+        }
+
+        virtual void Release() override {
+            [this->mediaKeys unregister];
+            [this->mediaKeys release];
+            this->mediaKeys = nullptr;
+            delete this;
+        }
+
+        virtual void SetPlaybackService(IPlaybackService* playback) override {
+            std::unique_lock<decltype(mutex)> lock(mutex);
+            this->playback = playback;
+        }
+
+        virtual void ProcessKeyCode(int keyCode) override {
+            std::unique_lock<decltype(mutex)> lock(mutex);
+            if (this->playback) {
+                switch (keyCode) {
+                    case NX_KEYTYPE_PLAY: {
+                        auto state = this->playback->GetPlaybackState();
+                        if (state == PlaybackStopped) {
+                            if (this->playback->Count()) {
+                                this->playback->Play(0);
+                            }
+                        }
+                        else {
+                            this->playback->PauseOrResume();
+                        }
+                    } return;
+                    case NX_KEYTYPE_FAST:
+                    case NX_KEYTYPE_NEXT:
+                        this->playback->Next();
+                        return;
+                    case NX_KEYTYPE_REWIND:
+                    case NX_KEYTYPE_PREVIOUS:
+                        this->playback->Previous();
+                        return;
+                }
+            }
+        }
+
+        virtual void OnTrackChanged(ITrack* track) override { }
+        virtual void OnPlaybackStateChanged(PlaybackState state) override { }
+        virtual void OnPlaybackTimeChanged(double time) override { }
+        virtual void OnVolumeChanged(double volume) override { }
+        virtual void OnModeChanged(RepeatMode repeatMode, bool shuffled) override { }
+        virtual void OnPlayQueueChanged() override { }
+
+    private:
+        std::mutex mutex;
+        IPlaybackService* playback { nullptr };
+        MediaKeys* mediaKeys { nullptr };
+};
+
+@implementation MediaKeys
+- (id) init {
+    keyTap = [[SPMediaKeyTap alloc] initWithDelegate:self];
+    processor = nil;
+
+    // Register defaults for the whitelist of apps that want to use media keys
+    [[NSUserDefaults standardUserDefaults] registerDefaults:[NSDictionary dictionaryWithObjectsAndKeys:
+        [SPMediaKeyTap defaultMediaKeyUserBundleIdentifiers], kMediaKeyUsingBundleIdentifiersDefaultsKey,
+    nil]];
+
+    if ([SPMediaKeyTap usesGlobalMediaKeyTap]) {
+        [keyTap startWatchingMediaKeys];
+    }
+
+    return self;
+}
+
+- (void) setKeyProcessor: (IKeyProcessor*) keyProcessor {
+    processor = keyProcessor;
+}
+
+- (void) mediaKeyTap:(SPMediaKeyTap*) keyTap receivedMediaKeyEvent: (NSEvent*) event {
+    assert([event type] == NSSystemDefined && [event subtype] == SPSystemDefinedEventMediaKeys);
+
+    int keyCode = (([event data1] & 0xFFFF0000) >> 16);
+    int keyFlags = ([event data1] & 0x0000FFFF);
+    int keyState = (((keyFlags & 0xFF00) >> 8)) == 0xA;
+
+    if (keyState == 1) {
+        processor->ProcessKeyCode(keyCode);
+    }
+}
+
+- (void) unregister; {
+    if (keyTap) {
+        [keyTap stopWatchingMediaKeys];
+        [keyTap release];
+    }
+}
+@end
+
+extern "C" IPlugin* GetPlugin() {
+    return &plugin;
+}
+
+extern "C" IPlaybackRemote* GetPlaybackRemote() {
+    return new PlaybackRemote();
+}