summaryrefslogtreecommitdiffstats
path: root/osdep/ar
diff options
context:
space:
mode:
authorStefano Pigozzi <stefano.pigozzi@gmail.com>2013-06-03 00:52:40 +0200
committerStefano Pigozzi <stefano.pigozzi@gmail.com>2013-06-03 22:35:47 +0200
commit72f2942dfa575a57d61fe023c845ba711ab78f55 (patch)
treed62395e98d5ee0ae58a5779bd8b472ee90aa9a80 /osdep/ar
parentc39efb96d1109b7a5960cd17cc4c392c2b93b61b (diff)
downloadmpv-72f2942dfa575a57d61fe023c845ba711ab78f55.tar.bz2
mpv-72f2942dfa575a57d61fe023c845ba711ab78f55.tar.xz
osx: add Apple Remote support
After killing the non functional AR support in c8fd9e5 I got much complaints so this adds AR support back in (and it works). I am using the HIDRemote class by Felix Schwarz and that part of the code is under the BSD license. I slightly modified it replacing [NSApplication sharedApplication] with NSApp. The code of the class is quite complex (probably because it had to deal with all the edge cases with IOKit) but it works nicely as a black box. In a later commit I'll remove the deprecation warnings caused by HIDRemote's usage of Gestalt. Check out `etc/input.conf` for the default bindings. Apple Remote functionality is automatically compiled in when cocoa is enabled. It can be disabled at runtime with the `--no-ar` option.
Diffstat (limited to 'osdep/ar')
-rw-r--r--osdep/ar/HIDRemote.h378
-rw-r--r--osdep/ar/HIDRemote.m2068
2 files changed, 2446 insertions, 0 deletions
diff --git a/osdep/ar/HIDRemote.h b/osdep/ar/HIDRemote.h
new file mode 100644
index 0000000000..9dd16faa5a
--- /dev/null
+++ b/osdep/ar/HIDRemote.h
@@ -0,0 +1,378 @@
+//
+// HIDRemote.h
+// HIDRemote V1.2
+//
+// Created by Felix Schwarz on 06.04.07.
+// Copyright 2007-2011 IOSPIRIT GmbH. All rights reserved.
+//
+// The latest version of this class is available at
+// http://www.iospirit.com/developers/hidremote/
+//
+// ** LICENSE *************************************************************************
+//
+// Copyright (c) 2007-2011 IOSPIRIT GmbH (http://www.iospirit.com/)
+// 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 IOSPIRIT GmbH nor the names of its 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 HOLDER 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.
+//
+// ************************************************************************************
+
+
+// ************************************************************************************
+// ********************************** DOCUMENTATION ***********************************
+// ************************************************************************************
+//
+// - a reference is available at http://www.iospirit.com/developers/hidremote/reference/
+// - for a guide, please see http://www.iospirit.com/developers/hidremote/guide/
+//
+// ************************************************************************************
+
+
+#import <Cocoa/Cocoa.h>
+
+#include <Carbon/Carbon.h>
+
+#include <unistd.h>
+#include <mach/mach.h>
+#include <sys/types.h>
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#include <IOKit/IOMessage.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDUsageTables.h>
+#include <IOKit/hidsystem/IOHIDLib.h>
+#include <IOKit/hidsystem/IOHIDParameter.h>
+#include <IOKit/hidsystem/IOHIDShared.h>
+
+#pragma mark -- Enums / Codes --
+
+typedef enum
+{
+ kHIDRemoteModeNone = 0L,
+ kHIDRemoteModeShared, // Share the remote with others - let's you listen to the remote control events as long as noone has an exclusive lock on it
+ // (RECOMMENDED ONLY FOR SPECIAL PURPOSES)
+
+ kHIDRemoteModeExclusive, // Try to acquire an exclusive lock on the remote (NOT RECOMMENDED)
+
+ kHIDRemoteModeExclusiveAuto // Try to acquire an exclusive lock on the remote whenever the application has focus. Temporarily release control over the
+ // remote when another application has focus (RECOMMENDED)
+} HIDRemoteMode;
+
+typedef enum
+{
+ /* A code reserved for "no button" (needed for tracking) */
+ kHIDRemoteButtonCodeNone = 0L,
+
+ /* Standard codes - available for white plastic and aluminum remote */
+ kHIDRemoteButtonCodeUp,
+ kHIDRemoteButtonCodeDown,
+ kHIDRemoteButtonCodeLeft,
+ kHIDRemoteButtonCodeRight,
+ kHIDRemoteButtonCodeCenter,
+ kHIDRemoteButtonCodeMenu,
+
+ /* Extra codes - Only available for the new aluminum version of the remote */
+ kHIDRemoteButtonCodePlay,
+
+ /* Masks */
+ kHIDRemoteButtonCodeCodeMask = 0xFFL,
+ kHIDRemoteButtonCodeHoldMask = (1L << 16L),
+ kHIDRemoteButtonCodeSpecialMask = (1L << 17L),
+ kHIDRemoteButtonCodeAluminumMask = (1L << 21L), // PRIVATE - only used internally
+
+ /* Hold button standard codes - available for white plastic and aluminum remote */
+ kHIDRemoteButtonCodeUpHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodeUp),
+ kHIDRemoteButtonCodeDownHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodeDown),
+ kHIDRemoteButtonCodeLeftHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodeLeft),
+ kHIDRemoteButtonCodeRightHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodeRight),
+ kHIDRemoteButtonCodeCenterHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodeCenter),
+ kHIDRemoteButtonCodeMenuHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodeMenu),
+
+ /* Hold button extra codes - Only available for aluminum version of the remote */
+ kHIDRemoteButtonCodePlayHold = (kHIDRemoteButtonCodeHoldMask|kHIDRemoteButtonCodePlay),
+
+ /* DEPRECATED codes - compatibility with HIDRemote 1.0 */
+ kHIDRemoteButtonCodePlus = kHIDRemoteButtonCodeUp,
+ kHIDRemoteButtonCodePlusHold = kHIDRemoteButtonCodeUpHold,
+ kHIDRemoteButtonCodeMinus = kHIDRemoteButtonCodeDown,
+ kHIDRemoteButtonCodeMinusHold = kHIDRemoteButtonCodeDownHold,
+ kHIDRemoteButtonCodePlayPause = kHIDRemoteButtonCodeCenter,
+ kHIDRemoteButtonCodePlayPauseHold = kHIDRemoteButtonCodeCenterHold,
+
+ /* Special purpose codes */
+ kHIDRemoteButtonCodeIDChanged = (kHIDRemoteButtonCodeSpecialMask|(1L << 18L)), // (the ID of the connected remote has changed, you can safely ignore this)
+ #ifdef _HIDREMOTE_EXTENSIONS
+ #define _HIDREMOTE_EXTENSIONS_SECTION 1
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+} HIDRemoteButtonCode;
+
+typedef enum
+{
+ kHIDRemoteModelUndetermined = 0L, // Assume a white plastic remote
+ kHIDRemoteModelWhitePlastic, // Signal *likely* to be coming from a white plastic remote
+ kHIDRemoteModelAluminum // Signal *definitely* coming from an aluminum remote
+} HIDRemoteModel;
+
+typedef enum
+{
+ kHIDRemoteAluminumRemoteSupportLevelNone = 0L, // This system has no support for the Aluminum Remote at all
+ kHIDRemoteAluminumRemoteSupportLevelEmulation, // This system possibly has support for the Aluminum Remote (via emulation)
+ kHIDRemoteAluminumRemoteSupportLevelNative // This system has native support for the Aluminum Remote
+} HIDRemoteAluminumRemoteSupportLevel;
+
+@class HIDRemote;
+
+#pragma mark -- Delegate protocol (mandatory) --
+@protocol HIDRemoteDelegate
+
+// Notification of button events
+- (void)hidRemote:(HIDRemote *)hidRemote // The instance of HIDRemote sending this
+ eventWithButton:(HIDRemoteButtonCode)buttonCode // Event for the button specified by code
+ isPressed:(BOOL)isPressed // The button was pressed (YES) / released (NO)
+ fromHardwareWithAttributes:(NSMutableDictionary *)attributes; // Information on the device this event comes from
+
+@optional
+
+// Notification of ID changes
+- (void)hidRemote:(HIDRemote *)hidRemote // Invoked when the user switched to a remote control with a different ID
+ remoteIDChangedOldID:(SInt32)old
+ newID:(SInt32)newID
+ forHardwareWithAttributes:(NSMutableDictionary *)attributes;
+
+// Notification about hardware additions/removals
+- (void)hidRemote:(HIDRemote *)hidRemote // Invoked when new hardware was found / added to HIDRemote's pool
+ foundNewHardwareWithAttributes:(NSMutableDictionary *)attributes;
+
+- (void)hidRemote:(HIDRemote *)hidRemote // Invoked when initialization of new hardware as requested failed
+ failedNewHardwareWithError:(NSError *)error;
+
+- (void)hidRemote:(HIDRemote *)hidRemote // Invoked when hardware was removed from HIDRemote's pool
+ releasedHardwareWithAttributes:(NSMutableDictionary *)attributes;
+
+// ### WARNING: Unless you know VERY PRECISELY what you are doing, do not implement any of the delegate methods below. ###
+
+// Matching of newly found receiver hardware
+- (BOOL)hidRemote:(HIDRemote *)hidRemote // Invoked when new hardware is inspected
+ inspectNewHardwareWithService:(io_service_t)service //
+ prematchResult:(BOOL)prematchResult; // Return YES if HIDRemote should go on with this hardware and try
+ // to use it, or NO if it should not be persued further.
+
+// Exlusive lock lending
+- (BOOL)hidRemote:(HIDRemote *)hidRemote
+ lendExclusiveLockToApplicationWithInfo:(NSDictionary *)applicationInfo;
+
+- (void)hidRemote:(HIDRemote *)hidRemote
+ exclusiveLockReleasedByApplicationWithInfo:(NSDictionary *)applicationInfo;
+
+- (BOOL)hidRemote:(HIDRemote *)hidRemote
+ shouldRetryExclusiveLockWithInfo:(NSDictionary *)applicationInfo;
+
+@end
+
+
+#pragma mark -- Actual header file for class --
+
+@interface HIDRemote : NSObject
+{
+ // IOMasterPort
+ mach_port_t _masterPort;
+
+ // Notification ports
+ IONotificationPortRef _notifyPort;
+ CFRunLoopSourceRef _notifyRLSource;
+
+ // Matching iterator
+ io_iterator_t _matchingServicesIterator;
+
+ // SecureInput notification
+ io_object_t _secureInputNotification;
+
+ // Service attributes
+ NSMutableDictionary *_serviceAttribMap;
+
+ // Mode
+ HIDRemoteMode _mode;
+ BOOL _autoRecover;
+ NSTimer *_autoRecoveryTimer;
+
+ // Delegate
+ NSObject <HIDRemoteDelegate> *_delegate;
+
+ // Last seen ID and remote model
+ SInt32 _lastSeenRemoteID;
+ HIDRemoteModel _lastSeenModel;
+ SInt32 _lastSeenModelRemoteID;
+
+ // Unused button codes
+ NSArray *_unusedButtonCodes;
+
+ // Simulate Plus/Minus Hold
+ BOOL _simulateHoldEvents;
+
+ // SecureEventInput workaround
+ BOOL _secureEventInputWorkAround;
+ UInt64 _lastSecureEventInputPIDSum;
+ uid_t _lastFrontUserSession;
+
+ // Exclusive lock lending
+ BOOL _exclusiveLockLending;
+ BOOL _sendExclusiveResourceReuseNotification;
+ NSNumber *_waitForReturnByPID;
+ NSNumber *_returnToPID;
+ BOOL _isRestarting;
+
+ // Status notifications
+ BOOL _sendStatusNotifications;
+ NSString *_pidString;
+
+ // Status
+ BOOL _applicationIsTerminating;
+ BOOL _isStopping;
+
+ // Thread safety
+ #ifdef HIDREMOTE_THREADSAFETY_HARDENED_NOTIFICATION_HANDLING /* #define HIDREMOTE_THREADSAFETY_HARDENED_NOTIFICATION_HANDLING if you're running your HIDRemote instance on a background thread (requires OS X 10.5 or later) */
+ NSThread *_runOnThread;
+ #endif
+}
+
+#pragma mark -- PUBLIC: Shared HID Remote --
++ (HIDRemote *)sharedHIDRemote;
+
+#pragma mark -- PUBLIC: System Information --
++ (BOOL)isCandelairInstalled;
++ (BOOL)isCandelairInstallationRequiredForRemoteMode:(HIDRemoteMode)remoteMode;
+- (HIDRemoteAluminumRemoteSupportLevel)aluminiumRemoteSystemSupportLevel;
+
+#pragma mark -- PUBLIC: Interface / API --
+- (BOOL)startRemoteControl:(HIDRemoteMode)hidRemoteMode;
+- (void)stopRemoteControl;
+
+- (BOOL)isStarted;
+- (HIDRemoteMode)startedInMode;
+
+- (unsigned)activeRemoteControlCount;
+
+- (SInt32)lastSeenRemoteControlID;
+
+- (void)setLastSeenModel:(HIDRemoteModel)aModel;
+- (HIDRemoteModel)lastSeenModel;
+
+- (void)setDelegate:(NSObject <HIDRemoteDelegate> *)newDelegate;
+- (NSObject <HIDRemoteDelegate> *)delegate;
+
+- (void)setSimulateHoldEvents:(BOOL)newSimulateHoldEvents;
+- (BOOL)simulateHoldEvents;
+
+- (void)setUnusedButtonCodes:(NSArray *)newArrayWithUnusedButtonCodesAsNSNumbers;
+- (NSArray *)unusedButtonCodes;
+
+#pragma mark -- PUBLIC: Expert APIs --
+- (void)setEnableSecureEventInputWorkaround:(BOOL)newEnableSecureEventInputWorkaround;
+- (BOOL)enableSecureEventInputWorkaround;
+
+- (void)setExclusiveLockLendingEnabled:(BOOL)newExclusiveLockLendingEnabled;
+- (BOOL)exclusiveLockLendingEnabled;
+
+- (BOOL)isApplicationTerminating;
+- (BOOL)isStopping;
+
+#pragma mark -- PRIVATE: HID Event handling --
+- (void)_handleButtonCode:(HIDRemoteButtonCode)buttonCode isPressed:(BOOL)isPressed hidAttribsDict:(NSMutableDictionary *)hidAttribsDict;
+- (void)_sendButtonCode:(HIDRemoteButtonCode)buttonCode isPressed:(BOOL)isPressed hidAttribsDict:(NSMutableDictionary *)hidAttribsDict;
+- (void)_hidEventFor:(io_service_t)hidDevice from:(IOHIDQueueInterface **)interface withResult:(IOReturn)result;
+
+#pragma mark -- PRIVATE: Service setup and destruction --
+- (BOOL)_prematchService:(io_object_t)service;
+- (HIDRemoteButtonCode)buttonCodeForUsage:(unsigned int)usage usagePage:(unsigned int)usagePage;
+- (BOOL)_setupService:(io_object_t)service;
+- (void)_destructService:(io_object_t)service;
+
+#pragma mark -- PRIVATE: Distributed notifiations handling --
+- (void)_postStatusWithAction:(NSString *)action;
+- (void)_handleNotifications:(NSNotification *)notification;
+- (void)_setSendStatusNotifications:(BOOL)doSend;
+- (BOOL)_sendStatusNotifications;
+
+#pragma mark -- PRIVATE: Application becomes active / inactive handling for kHIDRemoteModeExclusiveAuto --
+- (void)_appStatusChanged:(NSNotification *)notification;
+- (void)_delayedAutoRecovery:(NSTimer *)aTimer;
+
+#pragma mark -- PRIVATE: Notification handling --
+- (void)_serviceMatching:(io_iterator_t)iterator;
+- (void)_serviceNotificationFor:(io_service_t)service messageType:(natural_t)messageType messageArgument:(void *)messageArgument;
+- (void)_updateSessionInformation;
+- (void)_secureInputNotificationFor:(io_service_t)service messageType:(natural_t)messageType messageArgument:(void *)messageArgument;
+
+@end
+
+#pragma mark -- Information attribute keys --
+extern NSString *kHIDRemoteManufacturer;
+extern NSString *kHIDRemoteProduct;
+extern NSString *kHIDRemoteTransport;
+
+#pragma mark -- Internal/Expert attribute keys (AKA: don't touch these unless you really, really, REALLY know what you do) --
+extern NSString *kHIDRemoteCFPluginInterface;
+extern NSString *kHIDRemoteHIDDeviceInterface;
+extern NSString *kHIDRemoteCookieButtonCodeLUT;
+extern NSString *kHIDRemoteHIDQueueInterface;
+extern NSString *kHIDRemoteServiceNotification;
+extern NSString *kHIDRemoteCFRunLoopSource;
+extern NSString *kHIDRemoteLastButtonPressed;
+extern NSString *kHIDRemoteService;
+extern NSString *kHIDRemoteSimulateHoldEventsTimer;
+extern NSString *kHIDRemoteSimulateHoldEventsOriginButtonCode;
+extern NSString *kHIDRemoteAluminumRemoteSupportLevel;
+extern NSString *kHIDRemoteAluminumRemoteSupportOnDemand;
+
+#pragma mark -- Distributed notifications --
+extern NSString *kHIDRemoteDNHIDRemotePing;
+extern NSString *kHIDRemoteDNHIDRemoteRetry;
+extern NSString *kHIDRemoteDNHIDRemoteStatus;
+
+extern NSString *kHIDRemoteDNHIDRemoteRetryGlobalObject;
+
+#pragma mark -- Distributed notifications userInfo keys and values --
+extern NSString *kHIDRemoteDNStatusHIDRemoteVersionKey;
+extern NSString *kHIDRemoteDNStatusPIDKey;
+extern NSString *kHIDRemoteDNStatusModeKey;
+extern NSString *kHIDRemoteDNStatusUnusedButtonCodesKey;
+extern NSString *kHIDRemoteDNStatusRemoteControlCountKey;
+extern NSString *kHIDRemoteDNStatusReturnToPIDKey;
+extern NSString *kHIDRemoteDNStatusActionKey;
+extern NSString *kHIDRemoteDNStatusActionStart;
+extern NSString *kHIDRemoteDNStatusActionStop;
+extern NSString *kHIDRemoteDNStatusActionUpdate;
+extern NSString *kHIDRemoteDNStatusActionNoNeed;
+
+#pragma mark -- Driver compatibility flags --
+typedef enum
+{
+ kHIDRemoteCompatibilityFlagsStandardHIDRemoteDevice = 1L,
+} HIDRemoteCompatibilityFlags;
diff --git a/osdep/ar/HIDRemote.m b/osdep/ar/HIDRemote.m
new file mode 100644
index 0000000000..f05628c040
--- /dev/null
+++ b/osdep/ar/HIDRemote.m
@@ -0,0 +1,2068 @@
+//
+// HIDRemote.m
+// HIDRemote V1.2 (27th May 2011)
+//
+// Created by Felix Schwarz on 06.04.07.
+// Copyright 2007-2011 IOSPIRIT GmbH. All rights reserved.
+//
+// The latest version of this class is available at
+// http://www.iospirit.com/developers/hidremote/
+//
+// ** LICENSE *************************************************************************
+//
+// Copyright (c) 2007-2011 IOSPIRIT GmbH (http://www.iospirit.com/)
+// 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 IOSPIRIT GmbH nor the names of its 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 HOLDER 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.
+//
+// ************************************************************************************
+
+// ************************************************************************************
+// ********************************** DOCUMENTATION ***********************************
+// ************************************************************************************
+//
+// - a reference is available at http://www.iospirit.com/developers/hidremote/reference/
+// - for a guide, please see http://www.iospirit.com/developers/hidremote/guide/
+//
+// ************************************************************************************
+
+#import "HIDRemote.h"
+
+// Callback Prototypes
+static void HIDEventCallback( void * target,
+ IOReturn result,
+ void * refcon,
+ void * sender);
+
+static void ServiceMatchingCallback( void *refCon,
+ io_iterator_t iterator);
+
+static void ServiceNotificationCallback(void * refCon,
+ io_service_t service,
+ natural_t messageType,
+ void * messageArgument);
+
+static void SecureInputNotificationCallback( void * refCon,
+ io_service_t service,
+ natural_t messageType,
+ void * messageArgument);
+
+// Shared HIDRemote instance
+static HIDRemote *sHIDRemote = nil;
+
+@implementation HIDRemote
+
+#pragma mark -- Init, dealloc & shared instance --
+
++ (HIDRemote *)sharedHIDRemote
+{
+ if (sHIDRemote==nil)
+ {
+ sHIDRemote = [[HIDRemote alloc] init];
+ }
+
+ return (sHIDRemote);
+}
+
+- (id)init
+{
+ if ((self = [super init]) != nil)
+ {
+ #ifdef HIDREMOTE_THREADSAFETY_HARDENED_NOTIFICATION_HANDLING
+ _runOnThread = [[NSThread currentThread] retain];
+ #endif
+
+ // Detect application becoming active/inactive
+ [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_appStatusChanged:) name:NSApplicationDidBecomeActiveNotification object:NSApp];
+ [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_appStatusChanged:) name:NSApplicationWillResignActiveNotification object:NSApp];
+ [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_appStatusChanged:) name:NSApplicationWillTerminateNotification object:NSApp];
+
+ // Handle distributed notifications
+ _pidString = [[NSString alloc] initWithFormat:@"%d", getpid()];
+
+ [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(_handleNotifications:) name:kHIDRemoteDNHIDRemotePing object:nil];
+ [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(_handleNotifications:) name:kHIDRemoteDNHIDRemoteRetry object:kHIDRemoteDNHIDRemoteRetryGlobalObject];
+ [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(_handleNotifications:) name:kHIDRemoteDNHIDRemoteRetry object:_pidString];
+
+ // Enabled by default: simulate hold events for plus/minus
+ _simulateHoldEvents = YES;
+
+ // Enabled by default: work around for a locking issue introduced with Security Update 2008-004 / 10.4.9 and beyond (credit for finding this workaround goes to Martin Kahr)
+ _secureEventInputWorkAround = YES;
+ _secureInputNotification = 0;
+
+ // Initialize instance variables
+ _lastSeenRemoteID = -1;
+ _lastSeenModel = kHIDRemoteModelUndetermined;
+ _unusedButtonCodes = [[NSMutableArray alloc] init];
+ _exclusiveLockLending = NO;
+ _sendExclusiveResourceReuseNotification = YES;
+ _applicationIsTerminating = NO;
+
+ // Send status notifications
+ _sendStatusNotifications = YES;
+ }
+
+ return (self);
+}
+
+- (void)dealloc
+{
+ [[NSNotificationCenter defaultCenter] removeObserver:self name:NSApplicationWillTerminateNotification object:NSApp];
+ [[NSNotificationCenter defaultCenter] removeObserver:self name:NSApplicationWillResignActiveNotification object:NSApp];
+ [[NSNotificationCenter defaultCenter] removeObserver:self name:NSApplicationDidBecomeActiveNotification object:NSApp];
+
+ [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:kHIDRemoteDNHIDRemotePing object:nil];
+ [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:kHIDRemoteDNHIDRemoteRetry object:kHIDRemoteDNHIDRemoteRetryGlobalObject];
+ [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:kHIDRemoteDNHIDRemoteRetry object:_pidString];
+ [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:nil object:nil]; /* As demanded by the documentation for -[NSDistributedNotificationCenter removeObserver:name:object:] */
+
+ [self stopRemoteControl];
+
+ [self setExclusiveLockLendingEnabled:NO];
+
+ [self setDelegate:nil];
+
+ if (_unusedButtonCodes != nil)
+ {
+ [_unusedButtonCodes release];
+ _unusedButtonCodes = nil;
+ }
+
+ #ifdef HIDREMOTE_THREADSAFETY_HARDENED_NOTIFICATION_HANDLING
+ [_runOnThread release];
+ _runOnThread = nil;
+ #endif
+
+ [_pidString release];
+ _pidString = nil;
+
+ [super dealloc];
+}
+
+#pragma mark -- PUBLIC: System Information --
++ (BOOL)isCandelairInstalled
+{
+ mach_port_t masterPort = 0;
+ kern_return_t kernResult;
+ io_service_t matchingService = 0;
+ BOOL isInstalled = NO;
+
+ kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort);
+ if ((kernResult!=kIOReturnSuccess) || (masterPort==0)) { return(NO); }
+
+ if ((matchingService = IOServiceGetMatchingService(masterPort, IOServiceMatching("IOSPIRITIRController"))) != 0)
+ {
+ isInstalled = YES;
+ IOObjectRelease((io_object_t) matchingService);
+ }
+
+ mach_port_deallocate(mach_task_self(), masterPort);
+
+ return (isInstalled);
+}
+
++ (BOOL)isCandelairInstallationRequiredForRemoteMode:(HIDRemoteMode)remoteMode
+{
+ SInt32 systemVersion = 0;
+
+ // Determine OS version
+ if (Gestalt(gestaltSystemVersion, &systemVersion) == noErr)
+ {
+ switch (systemVersion)
+ {
+ case 0x1060: // OS 10.6
+ case 0x1061: // OS 10.6.1
+ // OS X 10.6(.0) and OS X 10.6.1 require the Candelair driver for to be installed,
+ // so that third party apps can acquire an exclusive lock on the receiver HID Device
+ // via IOKit.
+
+ switch (remoteMode)
+ {
+ case kHIDRemoteModeExclusive:
+ case kHIDRemoteModeExclusiveAuto:
+ if (![self isCandelairInstalled])
+ {
+ return (YES);
+ }
+ break;
+ }
+ break;
+ }
+ }
+
+ return (NO);
+}
+
+- (HIDRemoteAluminumRemoteSupportLevel)aluminiumRemoteSystemSupportLevel
+{
+ HIDRemoteAluminumRemoteSupportLevel supportLevel = kHIDRemoteAluminumRemoteSupportLevelNone;
+ NSEnumerator *attribDictsEnum;
+ NSDictionary *hidAttribsDict;
+
+ attribDictsEnum = [_serviceAttribMap objectEnumerator];
+
+ while ((hidAttribsDict = [attribDictsEnum nextObject]) != nil)
+ {
+ NSNumber *deviceSupportLevel;
+
+ if ((deviceSupportLevel = [hidAttribsDict objectForKey:kHIDRemoteAluminumRemoteSupportLevel]) != nil)
+ {
+ if ([deviceSupportLevel intValue] > (int)supportLevel)
+ {
+ supportLevel = [deviceSupportLevel intValue];
+ }
+ }
+ }
+
+ return (supportLevel);
+}
+
+#pragma mark -- PUBLIC: Interface / API --
+- (BOOL)startRemoteControl:(HIDRemoteMode)hidRemoteMode
+{
+ if ((_mode == kHIDRemoteModeNone) && (hidRemoteMode != kHIDRemoteModeNone))
+ {
+ kern_return_t kernReturn;
+ CFMutableDictionaryRef matchDict=NULL;
+ io_service_t rootService;
+
+ do
+ {
+ // Get IOKit master port
+ kernReturn = IOMasterPort(bootstrap_port, &_masterPort);
+ if ((kernReturn!=kIOReturnSuccess) || (_masterPort==0)) { break; }
+
+ // Setup notification port
+ _notifyPort = IONotificationPortCreate(_masterPort);
+
+ if ((_notifyRLSource = IONotificationPortGetRunLoopSource(_notifyPort)) != NULL)
+ {
+ CFRunLoopAddSource( CFRunLoopGetCurrent(),
+ _notifyRLSource,
+ kCFRunLoopCommonModes);
+ }
+ else
+ {
+ break;
+ }
+
+ // Setup SecureInput notification
+ if ((hidRemoteMode == kHIDRemoteModeExclusive) || (hidRemoteMode == kHIDRemoteModeExclusiveAuto))
+ {
+ if ((rootService = IORegistryEntryFromPath(_masterPort, kIOServicePlane ":/")) != 0)
+ {
+ kernReturn = IOServiceAddInterestNotification( _notifyPort,
+ rootService,
+ kIOBusyInterest,
+ SecureInputNotificationCallback,
+ (void *)self,
+ &_secureInputNotification);
+ if (kernReturn != kIOReturnSuccess) { break; }
+
+ [self _updateSessionInformation];
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ // Setup notification matching dict
+ matchDict = IOServiceMatching(kIOHIDDeviceKey);
+ CFRetain(matchDict);
+
+ // Actually add notification
+ kernReturn = IOServiceAddMatchingNotification( _notifyPort,
+ kIOFirstMatchNotification,
+ matchDict, // one reference count consumed by this call
+ ServiceMatchingCallback,
+ (void *) self,
+ &_matchingServicesIterator);
+ if (kernReturn != kIOReturnSuccess) { break; }
+
+ // Setup serviceAttribMap
+ _serviceAttribMap = [[NSMutableDictionary alloc] init];
+ if (_serviceAttribMap==nil) { break; }
+
+ // Phew .. everything went well!
+ _mode = hidRemoteMode;
+ CFRelease(matchDict);
+
+ [self _serviceMatching:_matchingServicesIterator];
+
+ [self _postStatusWithAction:kHIDRemoteDNStatusActionStart];
+
+ return (YES);
+
+ }while(0);
+
+ // An error occured. Do necessary clean up.
+ if (matchDict!=NULL)
+ {
+ CFRelease(matchDict);
+ matchDict = NULL;
+ }
+
+ [self stopRemoteControl];
+ }
+
+ return (NO);
+}
+
+- (void)stopRemoteControl
+{
+ UInt32 serviceCount = 0;
+
+ _autoRecover = NO;
+ _isStopping = YES;
+
+ if (_autoRecoveryTimer!=nil)
+ {
+ [_autoRecoveryTimer invalidate];
+ [_autoRecoveryTimer release];
+ _autoRecoveryTimer = nil;
+ }
+
+ if (_serviceAttribMap!=nil)
+ {
+ NSDictionary *cloneDict = [[NSDictionary alloc] initWithDictionary:_serviceAttribMap];
+
+ if (cloneDict!=nil)
+ {
+ NSEnumerator *mapKeyEnum = [cloneDict keyEnumerator];
+ NSNumber *serviceValue;
+
+ while ((serviceValue = [mapKeyEnum nextObject]) != nil)
+ {
+ [self _destructService:(io_object_t)[serviceValue unsignedIntValue]];
+ serviceCount++;
+ };
+
+ [cloneDict release];
+ cloneDict = nil;
+ }
+
+ [_serviceAttribMap release];
+ _serviceAttribMap = nil;
+ }
+
+ if (_matchingServicesIterator!=0)
+ {
+ IOObjectRelease((io_object_t) _matchingServicesIterator);
+ _matchingServicesIterator = 0;
+ }
+
+ if (_secureInputNotification!=0)
+ {
+ IOObjectRelease((io_object_t) _secureInputNotification);
+ _secureInputNotification = 0;
+ }
+
+ if (_notifyRLSource!=NULL)
+ {
+ CFRunLoopSourceInvalidate(_notifyRLSource);
+ _notifyRLSource = NULL;
+ }
+
+ if (_notifyPort!=NULL)
+ {
+ IONotificationPortDestroy(_notifyPort);
+ _notifyPort = NULL;
+ }
+
+ if (_masterPort!=0)
+ {
+ mach_port_deallocate(mach_task_self(), _masterPort);
+ _masterPort = 0;
+ }
+
+ if (_returnToPID!=nil)
+ {
+ [_returnToPID release];
+ _returnToPID = nil;
+ }
+
+ if (_mode!=kHIDRemoteModeNone)
+ {
+ // Post status
+ [self _postStatusWithAction:kHIDRemoteDNStatusActionStop];
+
+ if (_sendStatusNotifications)
+ {
+ // In case we were not ready to lend it earlier, tell other HIDRemote apps that the resources (if any were used) are now again available for use by other applications
+ if (((_mode==kHIDRemoteModeExclusive) || (_mode==kHIDRemoteModeExclusiveAuto)) && (_sendExclusiveResourceReuseNotification==YES) && (_exclusiveLockLending==NO) && (serviceCount>0))
+ {
+ _mode = kHIDRemoteModeNone;
+
+ if (!_isRestarting)
+ {
+ [[NSDistributedNotificationCenter defaultCenter] postNotificationName:kHIDRemoteDNHIDRemoteRetry
+ object:kHIDRemoteDNHIDRemoteRetryGlobalObject
+ userInfo:[NSDictionary dictionaryWithObjectsAndKeys:
+ [NSNumber numberWithUnsignedInt:(unsigned int)getpid()], kHIDRemoteDNStatusPIDKey,
+ [[NSBundle mainBundle] bundleIdentifier], (NSString *)kCFBundleIdentifierKey,
+ nil]
+ deliverImmediately:YES];
+ }
+ }
+ }
+ }
+
+ _mode = kHIDRemoteModeNone;
+ _isStopping = NO;
+}
+
+- (BOOL)isStarted
+{
+ return (_mode != kHIDRemoteModeNone);
+}
+
+- (HIDRemoteMode)startedInMode
+{
+ return (_mode);
+}
+
+- (unsigned)activeRemoteControlCount
+{
+ return ([_serviceAttribMap count]);
+}
+
+- (SInt32)lastSeenRemoteControlID
+{
+ return (_lastSeenRemoteID);
+}
+
+- (HIDRemoteModel)lastSeenModel
+{
+ return (_lastSeenModel);
+}
+
+- (void)setLastSeenModel:(HIDRemoteModel)aModel
+{
+ _lastSeenModel = aModel;
+}
+
+- (void)setSimulateHoldEvents:(BOOL)newSimulateHoldEvents
+{
+ _simulateHoldEvents = newSimulateHoldEvents;
+}
+
+- (BOOL)simulateHoldEvents
+{
+ return (_simulateHoldEvents);
+}
+
+- (NSArray *)unusedButtonCodes
+{
+ return (_unusedButtonCodes);
+}
+
+- (void)setUnusedButtonCodes:(NSArray *)newArrayWithUnusedButtonCodesAsNSNumbers
+{
+ [newArrayWithUnusedButtonCodesAsNSNumbers retain];
+ [_unusedButtonCodes release];
+
+ _unusedButtonCodes = newArrayWithUnusedButtonCodesAsNSNumbers;
+
+ [self _postStatusWithAction:kHIDRemoteDNStatusActionUpdate];
+}
+
+- (void)setDelegate:(NSObject <HIDRemoteDelegate> *)newDelegate
+{
+ _delegate = newDelegate;
+}
+
+- (NSObject <HIDRemoteDelegate> *)delegate
+{
+ return (_delegate);
+}
+
+#pragma mark -- PUBLIC: Expert APIs --
+- (void)setEnableSecureEventInputWorkaround:(BOOL)newEnableSecureEventInputWorkaround
+{
+ _secureEventInputWorkAround = newEnableSecureEventInputWorkaround;
+}
+
+- (BOOL)enableSecureEventInputWorkaround
+{
+ return (_secureEventInputWorkAround);
+}
+
+- (void)setExclusiveLockLendingEnabled:(BOOL)newExclusiveLockLendingEnabled
+{
+ if (newExclusiveLockLendingEnabled != _exclusiveLockLending)
+ {
+ _exclusiveLockLending = newExclusiveLockLendingEnabled;
+
+ if (_exclusiveLockLending)
+ {
+ [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(_handleNotifications:) name:kHIDRemoteDNHIDRemoteStatus object:nil];
+ }
+ else
+ {
+ [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:kHIDRemoteDNHIDRemoteStatus object:nil];
+
+ [_waitForReturnByPID release];
+ _waitForReturnByPID = nil;
+ }
+ }
+}
+
+- (BOOL)exclusiveLockLendingEnabled
+{
+ return (_exclusiveLockLending);
+}
+
+- (void)setSendExclusiveResourceReuseNotification:(BOOL)newSendExclusiveResourceReuseNotification
+{
+ _sendExclusiveResourceReuseNotification = newSendExclusiveResourceReuseNotification;
+}
+
+- (BOOL)sendExclusiveResourceReuseNotification
+{
+ return (_sendExclusiveResourceReuseNotification);
+}
+
+- (BOOL)isApplicationTerminating
+{
+ return (_applicationIsTerminating);
+}
+
+- (BOOL)isStopping
+{
+ return (_isStopping);
+}
+
+#pragma mark -- PRIVATE: Application becomes active / inactive handling for kHIDRemoteModeExclusiveAuto --
+- (void)_appStatusChanged:(NSNotification *)notification
+{
+ #ifdef HIDREMOTE_THREADSAFETY_HARDENED_NOTIFICATION_HANDLING
+ if ([self respondsToSelector:@selector(performSelector:onThread:withObject:waitUntilDone:)]) // OS X 10.5+ only
+ {
+ if ([NSThread currentThread] != _runOnThread)
+ {
+ if ([[notification name] isEqual:NSApplicationDidBecomeActiveNotification])
+ {
+ if (!_autoRecover)
+ {
+ return;
+ }
+ }
+
+ if ([[notification name] isEqual:NSApplicationWillResignActiveNotification])
+ {
+ if (_mode != kHIDRemoteModeExclusiveAuto)
+ {
+ return;
+ }
+ }
+
+ [self performSelector:@selector(_appStatusChanged:) onThread:_runOnThread withObject:notification waitUntilDone:[[notification name] isEqual:NSApplicationWillTerminateNotification]];
+ return;
+ }
+ }
+ #endif
+
+ if (notification!=nil)
+ {
+ if (_autoRecoveryTimer!=nil)
+ {
+ [_autoRecoveryTimer invalidate];
+ [_autoRecoveryTimer release];
+ _autoRecoveryTimer = nil;
+ }
+
+ if ([[notification name] isEqual:NSApplicationDidBecomeActiveNotification])
+ {
+ if (_autoRecover)
+ {
+ // Delay autorecover by 0.1 to avoid race conditions
+ if ((_autoRecoveryTimer = [[NSTimer alloc] initWithFireDate:[NSDate dateWithTimeIntervalSinceNow:0.1] interval:0.1 target:self selector:@selector(_delayedAutoRecovery:) userInfo:nil repeats:NO]) != nil)
+ {
+ // Using CFRunLoopAddTimer instead of [[NSRunLoop currentRunLoop] addTimer:.. for consistency with run loop modes.
+ // The kCFRunLoopCommonModes counterpart NSRunLoopCommonModes is only available in 10.5 and later, whereas this code
+ // is designed to be also compatible with 10.4. CFRunLoopTimerRef is "toll-free-bridged" with NSTimer since 10.0.
+ CFRunLoopAddTimer(CFRunLoopGetCurrent(), (CFRunLoopTimerRef)_autoRecoveryTimer, kCFRunLoopCommonModes);
+ }
+ }
+ }
+
+ if ([[notification name] isEqual:NSApplicationWillResignActiveNotification])
+ {
+ if (_mode == kHIDRemoteModeExclusiveAuto)
+ {
+ [self stopRemoteControl];
+ _autoRecover = YES;
+ }
+ }
+
+ if ([[notification name] isEqual:NSApplicationWillTerminateNotification])
+ {
+ _applicationIsTerminating = YES;
+
+ if ([self isStarted])
+ {
+ [self stopRemoteControl];
+ }
+ }
+ }
+}
+
+- (void)_delayedAutoRecovery:(NSTimer *)aTimer
+{
+ [_autoRecoveryTimer invalidate];
+ [_autoRecoveryTimer release];
+ _autoRecoveryTimer = nil;
+
+ if (_autoRecover)
+ {
+ [self startRemoteControl:kHIDRemoteModeExclusiveAuto];
+ _autoRecover = NO;
+ }
+}
+
+
+#pragma mark -- PRIVATE: Distributed notifiations handling --
+- (void)_postStatusWithAction:(NSString *)action
+{
+ if (_sendStatusNotifications)
+ {
+ [[NSDistributedNotificationCenter defaultCenter] postNotificationName:kHIDRemoteDNHIDRemoteStatus
+ object:((_pidString!=nil) ? _pidString : [NSString stringWithFormat:@"%d",getpid()])
+ userInfo:[NSDictionary dictionaryWithObjectsAndKeys:
+ [NSNumber numberWithInt:1], kHIDRemoteDNStatusHIDRemoteVersionKey,
+ [NSNumber numberWithUnsignedInt:(unsigned int)getpid()], kHIDRemoteDNStatusPIDKey,
+ [NSNumber numberWithInt:(int)_mode], kHIDRemoteDNStatusModeKey,
+ [NSNumber numberWithUnsignedInt:(unsigned int)[self activeRemoteControlCount]], kHIDRemoteDNStatusRemoteControlCountKey,
+ ((_unusedButtonCodes!=nil) ? _unusedButtonCodes : [NSArray array]), kHIDRemoteDNStatusUnusedButtonCodesKey,
+ action, kHIDRemoteDNStatusActionKey,
+ [[NSBundle mainBundle] bundleIdentifier], (NSString *)kCFBundleIdentifierKey,
+ _returnToPID, kHIDRemoteDNStatusReturnToPIDKey,
+ nil]
+ deliverImmediately:YES
+ ];
+ }
+}
+
+- (void)_handleNotifications:(NSNotification *)notification
+{
+ NSString *notificationName;
+
+ #ifdef HIDREMOTE_THREADSAFETY_HARDENED_NOTIFICATION_HANDLING
+ if ([self respondsToSelector:@selector(performSelector:onThread:withObject:waitUntilDone:)]) // OS X 10.5+ only
+ {
+ if ([NSThread currentThread] != _runOnThread)
+ {
+ [self performSelector:@selector(_handleNotifications:) onThread:_runOnThread withObject:notification waitUntilDone:NO];
+ return;
+ }
+ }
+ #endif
+
+ if ((notification!=nil) && ((notificationName = [notification name]) != nil))
+ {
+ if ([notificationName isEqual:kHIDRemoteDNHIDRemotePing])
+ {
+ [self _postStatusWithAction:kHIDRemoteDNStatusActionUpdate];
+ }
+
+ if ([notificationName isEqual:kHIDRemoteDNHIDRemoteRetry])
+ {
+ if ([self isStarted])
+ {
+ BOOL retry = YES;
+
+ // Ignore our own global retry broadcasts
+ if ([[notification object] isEqual:kHIDRemoteDNHIDRemoteRetryGlobalObject])
+ {
+ NSNumber *fromPID;
+
+ if ((fromPID = [[notification userInfo] objectForKey:kHIDRemoteDNStatusPIDKey]) != nil)
+ {
+ if (getpid() == (int)[fromPID unsignedIntValue])
+ {
+ retry = NO;
+ }
+ }
+ }
+
+ if (retry)
+ {
+ if (([self delegate] != nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:shouldRetryExclusiveLockWithInfo:)]))
+ {
+ retry = [[self delegate] hidRemote:self shouldRetryExclusiveLockWithInfo:[notification userInfo]];
+ }
+ }
+
+ if (retry)
+ {
+ HIDRemoteMode restartInMode = _mode;
+
+ if (restartInMode != kHIDRemoteModeNone)
+ {
+ _isRestarting = YES;
+ [self stopRemoteControl];
+
+ [_returnToPID release];
+ _returnToPID = nil;
+
+ [self startRemoteControl:restartInMode];
+ _isRestarting = NO;
+
+ if (restartInMode != kHIDRemoteModeShared)
+ {
+ _returnToPID = [[[notification userInfo] objectForKey:kHIDRemoteDNStatusPIDKey] retain];
+ }
+ }
+ }
+ else
+ {
+ NSNumber *cacheReturnPID = _returnToPID;
+
+ _returnToPID = [[[notification userInfo] objectForKey:kHIDRemoteDNStatusPIDKey] retain];
+ [self _postStatusWithAction:kHIDRemoteDNStatusActionNoNeed];
+ [_returnToPID release];
+
+ _returnToPID = cacheReturnPID;
+ }
+ }
+ }
+
+ if (_exclusiveLockLending)
+ {
+ if ([notificationName isEqual:kHIDRemoteDNHIDRemoteStatus])
+ {
+ NSString *action;
+
+ if ((action = [[notification userInfo] objectForKey:kHIDRemoteDNStatusActionKey]) != nil)
+ {
+ if ((_mode == kHIDRemoteModeNone) && (_waitForReturnByPID!=nil))
+ {
+ NSNumber *pidNumber, *returnToPIDNumber;
+
+ if ((pidNumber = [[notification userInfo] objectForKey:kHIDRemoteDNStatusPIDKey]) != nil)
+ {
+ returnToPIDNumber = [[notification userInfo] objectForKey:kHIDRemoteDNStatusReturnToPIDKey];
+
+ if ([action isEqual:kHIDRemoteDNStatusActionStart])
+ {
+ if ([pidNumber isEqual:_waitForReturnByPID])
+ {
+ NSNumber *startMode;
+
+ if ((startMode = [[notification userInfo] objectForKey:kHIDRemoteDNStatusModeKey]) != nil)
+ {
+ if ([startMode intValue] == kHIDRemoteModeShared)
+ {
+ returnToPIDNumber = [NSNumber numberWithInt:getpid()];
+ action = kHIDRemoteDNStatusActionNoNeed;
+ }
+ }
+ }
+ }
+
+ if (returnToPIDNumber != nil)
+ {
+ if ([action isEqual:kHIDRemoteDNStatusActionStop] || [action isEqual:kHIDRemoteDNStatusActionNoNeed])
+ {
+ if ([pidNumber isEqual:_waitForReturnByPID] && ([returnToPIDNumber intValue] == getpid()))
+ {
+ [_waitForReturnByPID release];
+ _waitForReturnByPID = nil;
+
+ if (([self delegate] != nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:exclusiveLockReleasedByApplicationWithInfo:)]))
+ {
+ [[self delegate] hidRemote:self exclusiveLockReleasedByApplicationWithInfo:[notification userInfo]];
+ }
+ else
+ {
+ [self startRemoteControl:kHIDRemoteModeExclusive];
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (_mode==kHIDRemoteModeExclusive)
+ {
+ if ([action isEqual:kHIDRemoteDNStatusActionStart])
+ {
+ NSNumber *originPID = [[notification userInfo] objectForKey:kHIDRemoteDNStatusPIDKey];
+ BOOL lendLock = YES;
+
+ if ([originPID intValue] != getpid())
+ {
+ if (([self delegate] != nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:lendExclusiveLockToApplicationWithInfo:)]))
+ {
+ lendLock = [[self delegate] hidRemote:self lendExclusiveLockToApplicationWithInfo:[notification userInfo]];
+ }
+
+ if (lendLock)
+ {
+ [_waitForReturnByPID release];
+ _waitForReturnByPID = [originPID retain];
+
+ if (_waitForReturnByPID != nil)
+ {
+ [self stopRemoteControl];
+
+ [[NSDistributedNotificationCenter defaultCenter] postNotificationName:kHIDRemoteDNHIDRemoteRetry
+ object:[NSString stringWithFormat:@"%d", [_waitForReturnByPID intValue]]
+ userInfo:[NSDictionary dictionaryWithObjectsAndKeys:
+ [NSNumber numberWithUnsignedInt:(unsigned int)getpid()], kHIDRemoteDNStatusPIDKey,
+ [[NSBundle mainBundle] bundleIdentifier], (NSString *)kCFBundleIdentifierKey,
+ nil]
+ deliverImmediately:YES];
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+- (void)_setSendStatusNotifications:(BOOL)doSend
+{
+ _sendStatusNotifications = doSend;
+}
+
+- (BOOL)_sendStatusNotifications
+{
+ return (_sendStatusNotifications);
+}
+
+#pragma mark -- PRIVATE: Service setup and destruction --
+- (BOOL)_prematchService:(io_object_t)service
+{
+ BOOL serviceMatches = NO;
+ NSString *ioClass;
+ NSNumber *candelairHIDRemoteCompatibilityMask;
+
+ if (service != 0)
+ {
+ // IOClass matching
+ if ((ioClass = (NSString *)IORegistryEntryCreateCFProperty((io_registry_entry_t)service,
+ CFSTR(kIOClassKey),
+ kCFAllocatorDefault,
+ 0)) != nil)
+ {
+ // Match on Apple's AppleIRController and old versions of the Remote Buddy IR Controller
+ if ([ioClass isEqual:@"AppleIRController"] || [ioClass isEqual:@"RBIOKitAIREmu"])
+ {
+ CFTypeRef candelairHIDRemoteCompatibilityDevice;
+
+ serviceMatches = YES;
+
+ if ((candelairHIDRemoteCompatibilityDevice = IORegistryEntryCreateCFProperty((io_registry_entry_t)service, CFSTR("CandelairHIDRemoteCompatibilityDevice"), kCFAllocatorDefault, 0)) != NULL)
+ {
+ if (CFEqual(kCFBooleanTrue, candelairHIDRemoteCompatibilityDevice))
+ {
+ serviceMatches = NO;
+ }
+
+ CFRelease (candelairHIDRemoteCompatibilityDevice);
+ }
+ }
+
+ // Match on the virtual IOSPIRIT IR Controller
+ if ([ioClass isEqual:@"IOSPIRITIRController"])
+ {
+ serviceMatches = YES;
+ }
+
+ CFRelease((CFTypeRef)ioClass);
+ }
+
+ // Match on services that claim compatibility with the HID Remote class (Candelair or third-party) by having a property of CandelairHIDRemoteCompatibilityMask = 1 <Type: Number>
+ if ((candelairHIDRemoteCompatibilityMask = (NSNumber *)IORegistryEntryCreateCFProperty((io_registry_entry_t)service, CFSTR("CandelairHIDRemoteCompatibilityMask"), kCFAllocatorDefault, 0)) != nil)
+ {
+ if ([candelairHIDRemoteCompatibilityMask isKindOfClass:[NSNumber class]])
+ {
+ if ([candelairHIDRemoteCompatibilityMask unsignedIntValue] & kHIDRemoteCompatibilityFlagsStandardHIDRemoteDevice)
+ {
+ serviceMatches = YES;
+ }
+ else
+ {
+ serviceMatches = NO;
+ }
+ }
+
+ CFRelease((CFTypeRef)candelairHIDRemoteCompatibilityMask);
+ }
+ }
+
+ if (([self delegate]!=nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:inspectNewHardwareWithService:prematchResult:)]))
+ {
+ serviceMatches = [((NSObject <HIDRemoteDelegate> *)[self delegate]) hidRemote:self inspectNewHardwareWithService:service prematchResult:serviceMatches];
+ }
+
+ return (serviceMatches);
+}
+
+- (HIDRemoteButtonCode)buttonCodeForUsage:(unsigned int)usage usagePage:(unsigned int)usagePage
+{
+ HIDRemoteButtonCode buttonCode = kHIDRemoteButtonCodeNone;
+
+ switch (usagePage)
+ {
+ case kHIDPage_Consumer:
+ switch (usage)
+ {
+ case kHIDUsage_Csmr_MenuPick:
+ // Aluminum Remote: Center
+ buttonCode = (kHIDRemoteButtonCodeCenter|kHIDRemoteButtonCodeAluminumMask);
+ break;
+
+ case kHIDUsage_Csmr_ModeStep:
+ // Aluminium Remote: Center Hold
+ buttonCode = (kHIDRemoteButtonCodeCenterHold|kHIDRemoteButtonCodeAluminumMask);
+ break;
+
+ case kHIDUsage_Csmr_PlayOrPause:
+ // Aluminum Remote: Play/Pause
+ buttonCode = (kHIDRemoteButtonCodePlay|kHIDRemoteButtonCodeAluminumMask);
+ break;
+
+ case kHIDUsage_Csmr_Rewind:
+ buttonCode = kHIDRemoteButtonCodeLeftHold;
+ break;
+
+ case kHIDUsage_Csmr_FastForward:
+ buttonCode = kHIDRemoteButtonCodeRightHold;
+ break;
+
+ case kHIDUsage_Csmr_Menu:
+ buttonCode = kHIDRemoteButtonCodeMenuHold;
+ break;
+ }
+ break;
+
+ case kHIDPage_GenericDesktop:
+ switch (usage)
+ {
+ case kHIDUsage_GD_SystemAppMenu:
+ buttonCode = kHIDRemoteButtonCodeMenu;
+ break;
+
+ case kHIDUsage_GD_SystemMenu:
+ buttonCode = kHIDRemoteButtonCodeCenter;
+ break;
+
+ case kHIDUsage_GD_SystemMenuRight:
+ buttonCode = kHIDRemoteButtonCodeRight;
+ break;
+
+ case kHIDUsage_GD_SystemMenuLeft:
+ buttonCode = kHIDRemoteButtonCodeLeft;
+ break;
+
+ case kHIDUsage_GD_SystemMenuUp:
+ buttonCode = kHIDRemoteButtonCodeUp;
+ break;
+
+ case kHIDUsage_GD_SystemMenuDown:
+ buttonCode = kHIDRemoteButtonCodeDown;
+ break;
+ }
+ break;
+
+ case 0x06: /* Reserved */
+ switch (usage)
+ {
+ case 0x22:
+ buttonCode = kHIDRemoteButtonCodeIDChanged;
+ break;
+ }
+ break;
+
+ case 0xFF01: /* Vendor specific */
+ switch (usage)
+ {
+ case 0x23:
+ buttonCode = kHIDRemoteButtonCodeCenterHold;
+ break;
+
+ #ifdef _HIDREMOTE_EXTENSIONS
+ #define _HIDREMOTE_EXTENSIONS_SECTION 2
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+ }
+ break;
+ }
+
+ return (buttonCode);
+}
+
+- (BOOL)_setupService:(io_object_t)service
+{
+ kern_return_t kernResult;
+ IOReturn returnCode;
+ HRESULT hResult;
+ SInt32 score;
+ BOOL opened = NO, queueStarted = NO;
+ IOHIDDeviceInterface122 **hidDeviceInterface = NULL;
+ IOCFPlugInInterface **cfPluginInterface = NULL;
+ IOHIDQueueInterface **hidQueueInterface = NULL;
+ io_object_t serviceNotification = 0;
+ CFRunLoopSourceRef queueEventSource = NULL;
+ NSMutableDictionary *hidAttribsDict = nil;
+ CFArrayRef hidElements = NULL;
+ NSError *error = nil;
+ UInt32 errorCode = 0;
+
+ if (![self _prematchService:service])
+ {
+ return (NO);
+ }
+
+ do
+ {
+ // Create a plugin interface ..
+ kernResult = IOCreatePlugInInterfaceForService( service,
+ kIOHIDDeviceUserClientTypeID,
+ kIOCFPlugInInterfaceID,
+ &cfPluginInterface,
+ &score);
+
+ if (kernResult != kIOReturnSuccess)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:kernResult userInfo:nil];
+ errorCode = 1;
+ break;
+ }
+
+
+ // .. use it to get the HID interface ..
+ hResult = (*cfPluginInterface)->QueryInterface( cfPluginInterface,
+ CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID122),
+ (LPVOID)&hidDeviceInterface);
+
+ if ((hResult!=S_OK) || (hidDeviceInterface==NULL))
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:hResult userInfo:nil];
+ errorCode = 2;
+ break;
+ }
+
+
+ // .. then open it ..
+ switch (_mode)
+ {
+ case kHIDRemoteModeShared:
+ hResult = (*hidDeviceInterface)->open(hidDeviceInterface, kIOHIDOptionsTypeNone);
+ break;
+
+ case kHIDRemoteModeExclusive:
+ case kHIDRemoteModeExclusiveAuto:
+ hResult = (*hidDeviceInterface)->open(hidDeviceInterface, kIOHIDOptionsTypeSeizeDevice);
+ break;
+
+ default:
+ goto cleanUp; // Ugh! But there are no "double breaks" available in C AFAIK ..
+ break;
+ }
+
+ if (hResult!=S_OK)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:hResult userInfo:nil];
+ errorCode = 3;
+ break;
+ }
+
+ opened = YES;
+
+ // .. query the HID elements ..
+ returnCode = (*hidDeviceInterface)->copyMatchingElements(hidDeviceInterface,
+ NULL,
+ &hidElements);
+ if ((returnCode != kIOReturnSuccess) || (hidElements==NULL))
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:returnCode userInfo:nil];
+ errorCode = 4;
+
+ break;
+ }
+
+ // Setup an event queue for HID events!
+ hidQueueInterface = (*hidDeviceInterface)->allocQueue(hidDeviceInterface);
+ if (hidQueueInterface == NULL)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:kIOReturnError userInfo:nil];
+ errorCode = 5;
+
+ break;
+ }
+
+ returnCode = (*hidQueueInterface)->create(hidQueueInterface, 0, 32);
+ if (returnCode != kIOReturnSuccess)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:returnCode userInfo:nil];
+ errorCode = 6;
+
+ break;
+ }
+
+
+ // Setup of attributes stored for this HID device
+ hidAttribsDict = [[NSMutableDictionary alloc] initWithObjectsAndKeys:
+ [NSValue valueWithPointer:(const void *)cfPluginInterface], kHIDRemoteCFPluginInterface,
+ [NSValue valueWithPointer:(const void *)hidDeviceInterface], kHIDRemoteHIDDeviceInterface,
+ [NSValue valueWithPointer:(const void *)hidQueueInterface], kHIDRemoteHIDQueueInterface,
+ nil];
+
+ {
+ UInt32 i, hidElementCnt = CFArrayGetCount(hidElements);
+ NSMutableDictionary *cookieButtonCodeLUT = [[NSMutableDictionary alloc] init];
+ NSMutableDictionary *cookieCount = [[NSMutableDictionary alloc] init];
+
+ if ((cookieButtonCodeLUT==nil) || (cookieCount==nil))
+ {
+ [cookieButtonCodeLUT release];
+ cookieButtonCodeLUT = nil;
+
+ [cookieCount release];
+ cookieCount = nil;
+
+ error = [NSError errorWithDomain:NSMachErrorDomain code:kIOReturnError userInfo:nil];
+ errorCode = 7;
+
+ break;
+ }
+
+ // Analyze the HID elements and find matching elements
+ for (i=0;i<hidElementCnt;i++)
+ {
+ CFDictionaryRef hidDict;
+ NSNumber *usage, *usagePage, *cookie;
+ HIDRemoteButtonCode buttonCode = kHIDRemoteButtonCodeNone;
+
+ hidDict = CFArrayGetValueAtIndex(hidElements, i);
+
+ usage = (NSNumber *) CFDictionaryGetValue(hidDict, CFSTR(kIOHIDElementUsageKey));
+ usagePage = (NSNumber *) CFDictionaryGetValue(hidDict, CFSTR(kIOHIDElementUsagePageKey));
+ cookie = (NSNumber *) CFDictionaryGetValue(hidDict, CFSTR(kIOHIDElementCookieKey));
+
+ if ((usage!=nil) && (usagePage!=nil) && (cookie!=nil))
+ {
+ // Find the button codes for the ID combos
+ buttonCode = [self buttonCodeForUsage:[usage unsignedIntValue] usagePage:[usagePage unsignedIntValue]];
+
+ #ifdef _HIDREMOTE_EXTENSIONS
+ // Debug logging code
+ #define _HIDREMOTE_EXTENSIONS_SECTION 3
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+
+ // Did record match?
+ if (buttonCode != kHIDRemoteButtonCodeNone)
+ {
+ NSString *pairString = [[NSString alloc] initWithFormat:@"%u_%u", [usagePage unsignedIntValue], [usage unsignedIntValue]];
+ NSNumber *buttonCodeNumber = [[NSNumber alloc] initWithUnsignedInt:(unsigned int)buttonCode];
+
+ #ifdef _HIDREMOTE_EXTENSIONS
+ // Debug logging code
+ #define _HIDREMOTE_EXTENSIONS_SECTION 4
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+
+ [cookieCount setObject:buttonCodeNumber forKey:pairString];
+ [cookieButtonCodeLUT setObject:buttonCodeNumber forKey:cookie];
+
+ (*hidQueueInterface)->addElement(hidQueueInterface,
+ (IOHIDElementCookie) [cookie unsignedIntValue],
+ 0);
+
+ #ifdef _HIDREMOTE_EXTENSIONS
+ // Get current Apple Remote ID value
+ #define _HIDREMOTE_EXTENSIONS_SECTION 7
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+
+ [buttonCodeNumber release];
+ [pairString release];
+ }
+ }
+ }
+
+ // Compare number of *unique* matches (thus the cookieCount dictionary) with required minimum
+ if ([cookieCount count] < 10)
+ {
+ [cookieButtonCodeLUT release];
+ cookieButtonCodeLUT = nil;
+
+ [cookieCount release];
+ cookieCount = nil;
+
+ error = [NSError errorWithDomain:NSMachErrorDomain code:kIOReturnError userInfo:nil];
+ errorCode = 8;
+
+ break;
+ }
+
+ [hidAttribsDict setObject:cookieButtonCodeLUT forKey:kHIDRemoteCookieButtonCodeLUT];
+
+ [cookieButtonCodeLUT release];
+ cookieButtonCodeLUT = nil;
+
+ [cookieCount release];
+ cookieCount = nil;
+ }
+
+ // Finish setup of IOHIDQueueInterface with CFRunLoop
+ returnCode = (*hidQueueInterface)->createAsyncEventSource(hidQueueInterface, &queueEventSource);
+ if ((returnCode != kIOReturnSuccess) || (queueEventSource == NULL))
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:returnCode userInfo:nil];
+ errorCode = 9;
+ break;
+ }
+
+ returnCode = (*hidQueueInterface)->setEventCallout(hidQueueInterface, HIDEventCallback, (void *)((intptr_t)service), (void *)self);
+ if (returnCode != kIOReturnSuccess)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:returnCode userInfo:nil];
+ errorCode = 10;
+ break;
+ }
+
+ CFRunLoopAddSource( CFRunLoopGetCurrent(),
+ queueEventSource,
+ kCFRunLoopCommonModes);
+ [hidAttribsDict setObject:[NSValue valueWithPointer:(const void *)queueEventSource] forKey:kHIDRemoteCFRunLoopSource];
+
+ returnCode = (*hidQueueInterface)->start(hidQueueInterface);
+ if (returnCode != kIOReturnSuccess)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:returnCode userInfo:nil];
+ errorCode = 11;
+ break;
+ }
+
+ queueStarted = YES;
+
+ // Setup device notifications
+ returnCode = IOServiceAddInterestNotification( _notifyPort,
+ service,
+ kIOGeneralInterest,
+ ServiceNotificationCallback,
+ self,
+ &serviceNotification);
+ if ((returnCode != kIOReturnSuccess) || (serviceNotification==0))
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:returnCode userInfo:nil];
+ errorCode = 12;
+ break;
+ }
+
+ [hidAttribsDict setObject:[NSNumber numberWithUnsignedInt:(unsigned int)serviceNotification] forKey:kHIDRemoteServiceNotification];
+
+ // Retain service
+ if (IOObjectRetain(service) != kIOReturnSuccess)
+ {
+ error = [NSError errorWithDomain:NSMachErrorDomain code:kIOReturnError userInfo:nil];
+ errorCode = 13;
+ break;
+ }
+
+ [hidAttribsDict setObject:[NSNumber numberWithUnsignedInt:(unsigned int)service] forKey:kHIDRemoteService];
+
+ // Get some (somewhat optional) infos on the device
+ {
+ CFStringRef product, manufacturer, transport;
+
+ if ((product = IORegistryEntryCreateCFProperty( (io_registry_entry_t)service,
+ (CFStringRef) @"Product",
+ kCFAllocatorDefault,
+ 0)) != NULL)
+ {
+ if (CFGetTypeID(product) == CFStringGetTypeID())
+ {
+ [hidAttribsDict setObject:(NSString *)product forKey:kHIDRemoteProduct];
+ }
+
+ CFRelease(product);
+ }
+
+ if ((manufacturer = IORegistryEntryCreateCFProperty( (io_registry_entry_t)service,
+ (CFStringRef) @"Manufacturer",
+ kCFAllocatorDefault,
+ 0)) != NULL)
+ {
+ if (CFGetTypeID(manufacturer) == CFStringGetTypeID())
+ {
+ [hidAttribsDict setObject:(NSString *)manufacturer forKey:kHIDRemoteManufacturer];
+ }
+
+ CFRelease(manufacturer);
+ }
+
+ if ((transport = IORegistryEntryCreateCFProperty( (io_registry_entry_t)service,
+ (CFStringRef) @"Transport",
+ kCFAllocatorDefault,
+ 0)) != NULL)
+ {
+ if (CFGetTypeID(transport) == CFStringGetTypeID())
+ {
+ [hidAttribsDict setObject:(NSString *)transport forKey:kHIDRemoteTransport];
+ }
+
+ CFRelease(transport);
+ }
+ }
+
+ // Determine Aluminum Remote support
+ {
+ CFNumberRef aluSupport;
+ HIDRemoteAluminumRemoteSupportLevel supportLevel = kHIDRemoteAluminumRemoteSupportLevelNone;
+
+ if ((_mode == kHIDRemoteModeExclusive) || (_mode == kHIDRemoteModeExclusiveAuto))
+ {
+ // Determine if this driver offers on-demand support for the Aluminum Remote (only relevant under OS versions < 10.6.2)
+ if ((aluSupport = IORegistryEntryCreateCFProperty((io_registry_entry_t)service,
+ (CFStringRef) @"AluminumRemoteSupportLevelOnDemand",
+ kCFAllocatorDefault,
+ 0)) != nil)
+ {
+ // There is => request the driver to enable it for us
+ if (IORegistryEntrySetCFProperty((io_registry_entry_t)service,
+ CFSTR("EnableAluminumRemoteSupportForMe"),
+ [NSDictionary dictionaryWithObjectsAndKeys:
+ [NSNumber numberWithLongLong:(long long)getpid()], @"pid",
+ [NSNumber numberWithLongLong:(long long)getuid()], @"uid",
+ nil]) == kIOReturnSuccess)
+ {
+ if (CFGetTypeID(aluSupport) == CFNumberGetTypeID())
+ {
+ supportLevel = (HIDRemoteAluminumRemoteSupportLevel) [(NSNumber *)aluSupport intValue];
+ }
+
+ [hidAttribsDict setObject:[NSNumber numberWithBool:YES] forKey:kHIDRemoteAluminumRemoteSupportOnDemand];
+ }
+
+ CFRelease(aluSupport);
+ }
+ }
+
+ if (supportLevel == kHIDRemoteAluminumRemoteSupportLevelNone)
+ {
+ if ((aluSupport = IORegistryEntryCreateCFProperty((io_registry_entry_t)service,
+ (CFStringRef) @"AluminumRemoteSupportLevel",
+ kCFAllocatorDefault,
+ 0)) != nil)
+ {
+ if (CFGetTypeID(aluSupport) == CFNumberGetTypeID())
+ {
+ supportLevel = (HIDRemoteAluminumRemoteSupportLevel) [(NSNumber *)aluSupport intValue];
+ }
+
+ CFRelease(aluSupport);
+ }
+ else
+ {
+ CFStringRef ioKitClassName;
+
+ if ((ioKitClassName = IORegistryEntryCreateCFProperty( (io_registry_entry_t)service,
+ CFSTR(kIOClassKey),
+ kCFAllocatorDefault,
+ 0)) != nil)
+ {
+ if ([(NSString *)ioKitClassName isEqual:@"AppleIRController"])
+ {
+ SInt32 systemVersion;
+
+ if (Gestalt(gestaltSystemVersion, &systemVersion) == noErr)
+ {
+ if (systemVersion >= 0x1062)
+ {
+ // Support for the Aluminum Remote was added only with OS 10.6.2. Previous versions can not distinguish
+ // between the Center and the new, seperate Play/Pause button. They'll recognize both as presses of the
+ // "Center" button.
+ //
+ // You CAN, however, receive Aluminum Remote button presses even under OS 10.5 when using Remote Buddy's
+ // Virtual Remote. While Remote Buddy does support the Aluminum Remote across all OS releases it runs on,
+ // its Virtual Remote can only emulate Aluminum Remote button presses under OS 10.5 and up in order not to
+ // break compatibility with applications whose IR Remote code relies on driver internals. [13-Nov-09]
+ supportLevel = kHIDRemoteAluminumRemoteSupportLevelNative;
+ }
+ }
+ }
+
+ CFRelease(ioKitClassName);
+ }
+ }
+ }
+
+ [hidAttribsDict setObject:(NSNumber *)[NSNumber numberWithInt:(int)supportLevel] forKey:kHIDRemoteAluminumRemoteSupportLevel];
+ }
+
+ // Add it to the serviceAttribMap
+ [_serviceAttribMap setObject:hidAttribsDict forKey:[NSNumber numberWithUnsignedInt:(unsigned int)service]];
+
+ // And we're done with setup ..
+ if (([self delegate]!=nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:foundNewHardwareWithAttributes:)]))
+ {
+ [((NSObject <HIDRemoteDelegate> *)[self delegate]) hidRemote:self foundNewHardwareWithAttributes:hidAttribsDict];
+ }
+
+ [hidAttribsDict release];
+ hidAttribsDict = nil;
+
+ return(YES);
+
+ }while(0);
+
+ cleanUp:
+
+ if (([self delegate]!=nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:failedNewHardwareWithError:)]))
+ {
+ if (error!=nil)
+ {
+ error = [NSError errorWithDomain:[error domain]
+ code:[error code]
+ userInfo:[NSDictionary dictionaryWithObject:[NSNumber numberWithInt:errorCode] forKey:@"InternalErrorCode"]
+ ];
+ }
+
+ [((NSObject <HIDRemoteDelegate> *)[self delegate]) hidRemote:self failedNewHardwareWithError:error];
+ }
+
+ // An error occured or this device is not of interest .. cleanup ..
+ if (serviceNotification!=0)
+ {
+ IOObjectRelease(serviceNotification);
+ serviceNotification = 0;
+ }
+
+ if (queueEventSource!=NULL)
+ {
+ CFRunLoopSourceInvalidate(queueEventSource);
+ queueEventSource=NULL;
+ }
+
+ if (hidQueueInterface!=NULL)
+ {
+ if (queueStarted)
+ {
+ (*hidQueueInterface)->stop(hidQueueInterface);
+ }
+ (*hidQueueInterface)->dispose(hidQueueInterface);
+ (*hidQueueInterface)->Release(hidQueueInterface);
+ hidQueueInterface = NULL;
+ }
+
+ if (hidAttribsDict!=nil)
+ {
+ [hidAttribsDict release];
+ hidAttribsDict = nil;
+ }
+
+ if (hidElements!=NULL)
+ {
+ CFRelease(hidElements);
+ hidElements = NULL;
+ }
+
+ if (hidDeviceInterface!=NULL)
+ {
+ if (opened)
+ {
+ (*hidDeviceInterface)->close(hidDeviceInterface);
+ }
+ (*hidDeviceInterface)->Release(hidDeviceInterface);
+ // opened = NO;
+ hidDeviceInterface = NULL;
+ }
+
+ if (cfPluginInterface!=NULL)
+ {
+ IODestroyPlugInInterface(cfPluginInterface);
+ cfPluginInterface = NULL;
+ }
+
+ return (NO);
+}
+
+- (void)_destructService:(io_object_t)service
+{
+ NSNumber *serviceValue;
+ NSMutableDictionary *serviceDict = NULL;
+
+ if ((serviceValue = [NSNumber numberWithUnsignedInt:(unsigned int)service]) == nil)
+ {
+ return;
+ }
+
+ serviceDict = [_serviceAttribMap objectForKey:serviceValue];
+
+ if (serviceDict!=nil)
+ {
+ IOHIDDeviceInterface122 **hidDeviceInterface = NULL;
+ IOCFPlugInInterface **cfPluginInterface = NULL;
+ IOHIDQueueInterface **hidQueueInterface = NULL;
+ io_object_t serviceNotification = 0;
+ CFRunLoopSourceRef queueEventSource = NULL;
+ io_object_t theService = 0;
+ NSMutableDictionary *cookieButtonMap = nil;
+ NSTimer *simulateHoldTimer = nil;
+
+ serviceNotification = (io_object_t) ([serviceDict objectForKey:kHIDRemoteServiceNotification] ? [[serviceDict objectForKey:kHIDRemoteServiceNotification] unsignedIntValue] : 0);
+ theService = (io_object_t) ([serviceDict objectForKey:kHIDRemoteService] ? [[serviceDict objectForKey:kHIDRemoteService] unsignedIntValue] : 0);
+ queueEventSource = (CFRunLoopSourceRef) ([serviceDict objectForKey:kHIDRemoteCFRunLoopSource] ? [[serviceDict objectForKey:kHIDRemoteCFRunLoopSource] pointerValue] : NULL);
+ hidQueueInterface = (IOHIDQueueInterface **) ([serviceDict objectForKey:kHIDRemoteHIDQueueInterface] ? [[serviceDict objectForKey:kHIDRemoteHIDQueueInterface] pointerValue] : NULL);
+ hidDeviceInterface = (IOHIDDeviceInterface122 **) ([serviceDict objectForKey:kHIDRemoteHIDDeviceInterface] ? [[serviceDict objectForKey:kHIDRemoteHIDDeviceInterface] pointerValue] : NULL);
+ cfPluginInterface = (IOCFPlugInInterface **) ([serviceDict objectForKey:kHIDRemoteCFPluginInterface] ? [[serviceDict objectForKey:kHIDRemoteCFPluginInterface] pointerValue] : NULL);
+ cookieButtonMap = (NSMutableDictionary *) [serviceDict objectForKey:kHIDRemoteCookieButtonCodeLUT];
+ simulateHoldTimer = (NSTimer *) [serviceDict objectForKey:kHIDRemoteSimulateHoldEventsTimer];
+
+ [serviceDict retain];
+ [_serviceAttribMap removeObjectForKey:serviceValue];
+
+ if (([serviceDict objectForKey:kHIDRemoteAluminumRemoteSupportOnDemand]!=nil) && [[serviceDict objectForKey:kHIDRemoteAluminumRemoteSupportOnDemand] boolValue] && (theService != 0))
+ {
+ // We previously requested the driver to enable Aluminum Remote support for us. Tell it to turn it off again - now that we no longer need it
+ IORegistryEntrySetCFProperty( (io_registry_entry_t)theService,
+ CFSTR("DisableAluminumRemoteSupportForMe"),
+ [NSDictionary dictionaryWithObjectsAndKeys:
+ [NSNumber numberWithLongLong:(long long)getpid()], @"pid",
+ [NSNumber numberWithLongLong:(long long)getuid()], @"uid",
+ nil]);
+ }
+
+ if (([self delegate]!=nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:releasedHardwareWithAttributes:)]))
+ {
+ [((NSObject <HIDRemoteDelegate> *)[self delegate]) hidRemote:self releasedHardwareWithAttributes:serviceDict];
+ }
+
+ if (simulateHoldTimer!=nil)
+ {
+ [simulateHoldTimer invalidate];
+ }
+
+ if (serviceNotification!=0)
+ {
+ IOObjectRelease(serviceNotification);
+ }
+
+ if (queueEventSource!=NULL)
+ {
+ CFRunLoopRemoveSource( CFRunLoopGetCurrent(),
+ queueEventSource,
+ kCFRunLoopCommonModes);
+ }
+
+ if ((hidQueueInterface!=NULL) && (cookieButtonMap!=nil))
+ {
+ NSEnumerator *cookieEnum = [cookieButtonMap keyEnumerator];
+ NSNumber *cookie;
+
+ while ((cookie = [cookieEnum nextObject]) != nil)
+ {
+ if ((*hidQueueInterface)->hasElement(hidQueueInterface, (IOHIDElementCookie) [cookie unsignedIntValue]))
+ {
+ (*hidQueueInterface)->removeElement(hidQueueInterface,
+ (IOHIDElementCookie) [cookie unsignedIntValue]);
+ }
+ };
+ }
+
+ if (hidQueueInterface!=NULL)
+ {
+ (*hidQueueInterface)->stop(hidQueueInterface);
+ (*hidQueueInterface)->dispose(hidQueueInterface);
+ (*hidQueueInterface)->Release(hidQueueInterface);
+ }
+
+ if (hidDeviceInterface!=NULL)
+ {
+ (*hidDeviceInterface)->close(hidDeviceInterface);
+ (*hidDeviceInterface)->Release(hidDeviceInterface);
+ }
+
+ if (cfPluginInterface!=NULL)
+ {
+ IODestroyPlugInInterface(cfPluginInterface);
+ }
+
+ if (theService!=0)
+ {
+ IOObjectRelease(theService);
+ }
+
+ [serviceDict release];
+ }
+}
+
+
+#pragma mark -- PRIVATE: HID Event handling --
+- (void)_simulateHoldEvent:(NSTimer *)aTimer
+{
+ NSMutableDictionary *hidAttribsDict;
+ NSTimer *shTimer;
+ NSNumber *shButtonCode;
+
+ if ((hidAttribsDict = (NSMutableDictionary *)[aTimer userInfo]) != nil)
+ {
+ if (((shTimer = [hidAttribsDict objectForKey:kHIDRemoteSimulateHoldEventsTimer]) != nil) &&
+ ((shButtonCode = [hidAttribsDict objectForKey:kHIDRemoteSimulateHoldEventsOriginButtonCode]) != nil))
+ {
+ [shTimer invalidate];
+ [hidAttribsDict removeObjectForKey:kHIDRemoteSimulateHoldEventsTimer];
+
+ [self _sendButtonCode:(((HIDRemoteButtonCode)[shButtonCode unsignedIntValue])|kHIDRemoteButtonCodeHoldMask) isPressed:YES hidAttribsDict:hidAttribsDict];
+ }
+ }
+}
+
+- (void)_handleButtonCode:(HIDRemoteButtonCode)buttonCode isPressed:(BOOL)isPressed hidAttribsDict:(NSMutableDictionary *)hidAttribsDict
+{
+ switch (buttonCode)
+ {
+ case kHIDRemoteButtonCodeIDChanged:
+ // Do nothing, this is handled seperately
+ break;
+
+ case kHIDRemoteButtonCodeUp:
+ case kHIDRemoteButtonCodeDown:
+ if (_simulateHoldEvents)
+ {
+ NSTimer *shTimer = nil;
+ NSNumber *shButtonCode = nil;
+
+ [[hidAttribsDict objectForKey:kHIDRemoteSimulateHoldEventsTimer] invalidate];
+
+ if (isPressed)
+ {
+ [hidAttribsDict setObject:[NSNumber numberWithUnsignedInt:buttonCode] forKey:kHIDRemoteSimulateHoldEventsOriginButtonCode];
+
+ if ((shTimer = [[NSTimer alloc] initWithFireDate:[NSDate dateWithTimeIntervalSinceNow:0.7] interval:0.1 target:self selector:@selector(_simulateHoldEvent:) userInfo:hidAttribsDict repeats:NO]) != nil)
+ {
+ [hidAttribsDict setObject:shTimer forKey:kHIDRemoteSimulateHoldEventsTimer];
+
+ // Using CFRunLoopAddTimer instead of [[NSRunLoop currentRunLoop] addTimer:.. for consistency with run loop modes.
+ // The kCFRunLoopCommonModes counterpart NSRunLoopCommonModes is only available in 10.5 and later, whereas this code
+ // is designed to be also compatible with 10.4. CFRunLoopTimerRef is "toll-free-bridged" with NSTimer since 10.0.
+ CFRunLoopAddTimer(CFRunLoopGetCurrent(), (CFRunLoopTimerRef)shTimer, kCFRunLoopCommonModes);
+
+ [shTimer release];
+
+ break;
+ }
+ }
+ else
+ {
+ shTimer = [hidAttribsDict objectForKey:kHIDRemoteSimulateHoldEventsTimer];
+ shButtonCode = [hidAttribsDict objectForKey:kHIDRemoteSimulateHoldEventsOriginButtonCode];
+
+ if ((shTimer!=nil) && (shButtonCode!=nil))
+ {
+ [self _sendButtonCode:(HIDRemoteButtonCode)[shButtonCode unsignedIntValue] isPressed:YES hidAttribsDict:hidAttribsDict];
+ [self _sendButtonCode:(HIDRemoteButtonCode)[shButtonCode unsignedIntValue] isPressed:NO hidAttribsDict:hidAttribsDict];
+ }
+ else
+ {
+ if (shButtonCode!=nil)
+ {
+ [self _sendButtonCode:(((HIDRemoteButtonCode)[shButtonCode unsignedIntValue])|kHIDRemoteButtonCodeHoldMask) isPressed:NO hidAttribsDict:hidAttribsDict];
+ }
+ }
+ }
+
+ [hidAttribsDict removeObjectForKey:kHIDRemoteSimulateHoldEventsTimer];
+ [hidAttribsDict removeObjectForKey:kHIDRemoteSimulateHoldEventsOriginButtonCode];
+
+ break;
+ }
+
+ default:
+ [self _sendButtonCode:buttonCode isPressed:isPressed hidAttribsDict:hidAttribsDict];
+ break;
+ }
+}
+
+- (void)_sendButtonCode:(HIDRemoteButtonCode)buttonCode isPressed:(BOOL)isPressed hidAttribsDict:(NSMutableDictionary *)hidAttribsDict
+{
+ if (([self delegate]!=nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:eventWithButton:isPressed:fromHardwareWithAttributes:)]))
+ {
+ switch (buttonCode & (~kHIDRemoteButtonCodeAluminumMask))
+ {
+ case kHIDRemoteButtonCodePlay:
+ case kHIDRemoteButtonCodeCenter:
+ if (buttonCode & kHIDRemoteButtonCodeAluminumMask)
+ {
+ _lastSeenModel = kHIDRemoteModelAluminum;
+ _lastSeenModelRemoteID = _lastSeenRemoteID;
+ }
+ else
+ {
+ switch ((HIDRemoteAluminumRemoteSupportLevel)[[hidAttribsDict objectForKey:kHIDRemoteAluminumRemoteSupportLevel] intValue])
+ {
+ case kHIDRemoteAluminumRemoteSupportLevelNone:
+ case kHIDRemoteAluminumRemoteSupportLevelEmulation:
+ // Remote type can't be determined by just the Center button press
+ break;
+
+ case kHIDRemoteAluminumRemoteSupportLevelNative:
+ // Remote type can be safely determined by just the Center button press
+ if (((_lastSeenModel == kHIDRemoteModelAluminum) && (_lastSeenModelRemoteID != _lastSeenRemoteID)) ||
+ (_lastSeenModel == kHIDRemoteModelUndetermined))
+ {
+ _lastSeenModel = kHIDRemoteModelWhitePlastic;
+ }
+ break;
+ }
+ }
+ break;
+ }
+
+ // As soon as we have received a code that's unique to the Aluminum Remote, we can tell kHIDRemoteButtonCodePlayHold and kHIDRemoteButtonCodeCenterHold apart.
+ // Prior to that, a long press of the new "Play" button will be submitted as a "kHIDRemoteButtonCodeCenterHold", not a "kHIDRemoteButtonCodePlayHold" code.
+ if ((buttonCode == kHIDRemoteButtonCodeCenterHold) && (_lastSeenModel == kHIDRemoteModelAluminum))
+ {
+ buttonCode = kHIDRemoteButtonCodePlayHold;
+ }
+
+ [((NSObject <HIDRemoteDelegate> *)[self delegate]) hidRemote:self eventWithButton:(buttonCode & (~kHIDRemoteButtonCodeAluminumMask)) isPressed:isPressed fromHardwareWithAttributes:hidAttribsDict];
+ }
+}
+
+- (void)_hidEventFor:(io_service_t)hidDevice from:(IOHIDQueueInterface **)interface withResult:(IOReturn)result
+{
+ NSMutableDictionary *hidAttribsDict = [[[_serviceAttribMap objectForKey:[NSNumber numberWithUnsignedInt:(unsigned int)hidDevice]] retain] autorelease];
+
+ if (hidAttribsDict!=nil)
+ {
+ IOHIDQueueInterface **queueInterface = NULL;
+
+ queueInterface = [[hidAttribsDict objectForKey:kHIDRemoteHIDQueueInterface] pointerValue];
+
+ if (interface == queueInterface)
+ {
+ NSNumber *lastButtonPressedNumber = nil;
+ HIDRemoteButtonCode lastButtonPressed = kHIDRemoteButtonCodeNone;
+ NSMutableDictionary *cookieButtonMap = nil;
+
+ cookieButtonMap = [hidAttribsDict objectForKey:kHIDRemoteCookieButtonCodeLUT];
+
+ if ((lastButtonPressedNumber = [hidAttribsDict objectForKey:kHIDRemoteLastButtonPressed]) != nil)
+ {
+ lastButtonPressed = [lastButtonPressedNumber unsignedIntValue];
+ }
+
+ while (result == kIOReturnSuccess)
+ {
+ IOHIDEventStruct hidEvent;
+ AbsoluteTime supportedTime = { 0,0 };
+
+ result = (*queueInterface)->getNextEvent( queueInterface,
+ &hidEvent,
+ supportedTime,
+ 0);
+
+ if (result == kIOReturnSuccess)
+ {
+ NSNumber *buttonCodeNumber = [cookieButtonMap objectForKey:[NSNumber numberWithUnsignedInt:(unsigned int) hidEvent.elementCookie]];
+
+ #ifdef _HIDREMOTE_EXTENSIONS
+ // Debug logging code
+ #define _HIDREMOTE_EXTENSIONS_SECTION 5
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+
+ if (buttonCodeNumber!=nil)
+ {
+ HIDRemoteButtonCode buttonCode = [buttonCodeNumber unsignedIntValue];
+
+ if (hidEvent.value == 0)
+ {
+ if (buttonCode == lastButtonPressed)
+ {
+ [self _handleButtonCode:lastButtonPressed isPressed:NO hidAttribsDict:hidAttribsDict];
+ lastButtonPressed = kHIDRemoteButtonCodeNone;
+ }
+ }
+
+ if (hidEvent.value != 0)
+ {
+ if (lastButtonPressed != kHIDRemoteButtonCodeNone)
+ {
+ [self _handleButtonCode:lastButtonPressed isPressed:NO hidAttribsDict:hidAttribsDict];
+ // lastButtonPressed = kHIDRemoteButtonCodeNone;
+ }
+
+ if (buttonCode == kHIDRemoteButtonCodeIDChanged)
+ {
+ if (([self delegate]!=nil) &&
+ ([[self delegate] respondsToSelector:@selector(hidRemote:remoteIDChangedOldID:newID:forHardwareWithAttributes:)]))
+ {
+ [((NSObject <HIDRemoteDelegate> *)[self delegate]) hidRemote:self remoteIDChangedOldID:_lastSeenRemoteID newID:hidEvent.value forHardwareWithAttributes:hidAttribsDict];
+ }
+
+ _lastSeenRemoteID = hidEvent.value;
+ _lastSeenModel = kHIDRemoteModelUndetermined;
+ }
+
+ [self _handleButtonCode:buttonCode isPressed:YES hidAttribsDict:hidAttribsDict];
+ lastButtonPressed = buttonCode;
+ }
+ }
+ }
+ };
+
+ [hidAttribsDict setObject:[NSNumber numberWithUnsignedInt:lastButtonPressed] forKey:kHIDRemoteLastButtonPressed];
+ }
+
+ #ifdef _HIDREMOTE_EXTENSIONS
+ // Debug logging code
+ #define _HIDREMOTE_EXTENSIONS_SECTION 6
+ #include "HIDRemoteAdditions.h"
+ #undef _HIDREMOTE_EXTENSIONS_SECTION
+ #endif /* _HIDREMOTE_EXTENSIONS */
+ }
+}
+
+#pragma mark -- PRIVATE: Notification handling --
+- (void)_serviceMatching:(io_iterator_t)iterator
+{
+ io_object_t matchingService = 0;
+
+ while ((matchingService = IOIteratorNext(iterator)) != 0)
+ {
+ [self _setupService:matchingService];
+
+ IOObjectRelease(matchingService);
+ };
+}
+
+- (void)_serviceNotificationFor:(io_service_t)service messageType:(natural_t)messageType messageArgument:(void *)messageArgument
+{
+ if (messageType == kIOMessageServiceIsTerminated)
+ {
+ [self _destructService:service];
+ }
+}
+
+- (void)_updateSessionInformation
+{
+ NSArray *consoleUsersArray;
+ io_service_t rootService;
+
+ if (_masterPort==0) { return; }
+
+ if ((rootService = IORegistryGetRootEntry(_masterPort)) != 0)
+ {
+ if ((consoleUsersArray = (NSArray *)IORegistryEntryCreateCFProperty((io_registry_entry_t)rootService, CFSTR("IOConsoleUsers"), kCFAllocatorDefault, 0)) != nil)
+ {
+ if ([consoleUsersArray isKindOfClass:[NSArray class]]) // Be careful - ensure this really is an array
+ {
+ NSEnumerator *consoleUsersEnum; // I *love* Obj-C2's fast enumerators, but we need to stay compatible with 10.4 :-/
+
+ if ((consoleUsersEnum = [consoleUsersArray objectEnumerator]) != nil)
+ {
+ UInt64 secureEventInputPIDSum = 0;
+ uid_t frontUserSession = 0;
+ NSDictionary *consoleUserDict;
+
+ while ((consoleUserDict = [consoleUsersEnum nextObject]) != nil)
+ {
+ if ([consoleUserDict isKindOfClass:[NSDictionary class]]) // Be careful - ensure this really is a dictionary
+ {
+ NSNumber *secureInputPID;
+ NSNumber *onConsole;
+ NSNumber *userID;
+
+ if ((secureInputPID = [consoleUserDict objectForKey:@"kCGSSessionSecureInputPID"]) != nil)
+ {
+ if ([secureInputPID isKindOfClass:[NSNumber class]])
+ {
+ secureEventInputPIDSum += ((UInt64) [secureInputPID intValue]);
+ }
+ }
+
+ if (((onConsole = [consoleUserDict objectForKey:@"kCGSSessionOnConsoleKey"]) != nil) &&
+ ((userID = [consoleUserDict objectForKey:@"kCGSSessionUserIDKey"]) != nil))
+ {
+ if ([onConsole isKindOfClass:[NSNumber class]] && [userID isKindOfClass:[NSNumber class]])
+ {
+ if ([onConsole boolValue])
+ {
+ frontUserSession = (uid_t) [userID intValue];
+ }
+ }
+ }
+ }
+ }
+
+ _lastSecureEventInputPIDSum = secureEventInputPIDSum;
+ _lastFrontUserSession = frontUserSession;
+ }
+ }
+
+ CFRelease((CFTypeRef)consoleUsersArray);
+ }
+
+ IOObjectRelease((io_object_t) rootService);
+ }
+}
+
+- (void)_secureInputNotificationFor:(io_service_t)service messageType:(natural_t)messageType messageArgument:(void *)messageArgument
+{
+ if (messageType == kIOMessageServiceBusyStateChange)
+ {
+ UInt64 old_lastSecureEventInputPIDSum = _lastSecureEventInputPIDSum;
+ uid_t old_lastFrontUserSession = _lastFrontUserSession;
+
+ [self _updateSessionInformation];
+
+ if (((old_lastSecureEventInputPIDSum != _lastSecureEventInputPIDSum) || (old_lastFrontUserSession != _lastFrontUserSession)) && _secureEventInputWorkAround)
+ {
+ if ((_mode == kHIDRemoteModeExclusive) || (_mode == kHIDRemoteModeExclusiveAuto))
+ {
+ HIDRemoteMode restartInMode = _mode;
+
+ _isRestarting = YES;
+ [self stopRemoteControl];
+ [self startRemoteControl:restartInMode];
+ _isRestarting = NO;
+ }
+ }
+ }
+}
+
+@end
+
+#pragma mark -- PRIVATE: IOKitLib Callbacks --
+
+static void HIDEventCallback( void * target,
+ IOReturn result,
+ void * refCon,
+ void * sender)
+{
+ HIDRemote *hidRemote = (HIDRemote *)refCon;
+ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+ [hidRemote _hidEventFor:(io_service_t)((intptr_t)target) from:(IOHIDQueueInterface**)sender withResult:(IOReturn)result];
+
+ [pool release];
+}
+
+
+static void ServiceMatchingCallback( void *refCon,
+ io_iterator_t iterator)
+{
+ HIDRemote *hidRemote = (HIDRemote *)refCon;
+ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+ [hidRemote _serviceMatching:iterator];
+
+ [pool release];
+}
+
+static void ServiceNotificationCallback(void * refCon,
+ io_service_t service,
+ natural_t messageType,
+ void * messageArgument)
+{
+ HIDRemote *hidRemote = (HIDRemote *)refCon;
+ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+ [hidRemote _serviceNotificationFor:service
+ messageType:messageType
+ messageArgument:messageArgument];
+
+ [pool release];
+}
+
+static void SecureInputNotificationCallback( void * refCon,
+ io_service_t service,
+ natural_t messageType,
+ void * messageArgument)
+{
+ HIDRemote *hidRemote = (HIDRemote *)refCon;
+ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+ [hidRemote _secureInputNotificationFor:service
+ messageType:messageType
+ messageArgument:messageArgument];
+
+ [pool release];
+}
+
+// Attribute dictionary keys
+NSString *kHIDRemoteCFPluginInterface = @"CFPluginInterface";
+NSString *kHIDRemoteHIDDeviceInterface = @"HIDDeviceInterface";
+NSString *kHIDRemoteCookieButtonCodeLUT = @"CookieButtonCodeLUT";
+NSString *kHIDRemoteHIDQueueInterface = @"HIDQueueInterface";
+NSString *kHIDRemoteServiceNotification = @"ServiceNotification";
+NSString *kHIDRemoteCFRunLoopSource = @"CFRunLoopSource";
+NSString *kHIDRemoteLastButtonPressed = @"LastButtonPressed";
+NSString *kHIDRemoteService = @"Service";
+NSString *kHIDRemoteSimulateHoldEventsTimer = @"SimulateHoldEventsTimer";
+NSString *kHIDRemoteSimulateHoldEventsOriginButtonCode = @"SimulateHoldEventsOriginButtonCode";
+NSString *kHIDRemoteAluminumRemoteSupportLevel = @"AluminumRemoteSupportLevel";
+NSString *kHIDRemoteAluminumRemoteSupportOnDemand = @"AluminumRemoteSupportLevelOnDemand";
+
+NSString *kHIDRemoteManufacturer = @"Manufacturer";
+NSString *kHIDRemoteProduct = @"Product";
+NSString *kHIDRemoteTransport = @"Transport";
+
+// Distributed notifications
+NSString *kHIDRemoteDNHIDRemotePing = @"com.candelair.ping";
+NSString *kHIDRemoteDNHIDRemoteRetry = @"com.candelair.retry";
+NSString *kHIDRemoteDNHIDRemoteStatus = @"com.candelair.status";
+
+NSString *kHIDRemoteDNHIDRemoteRetryGlobalObject = @"global";
+
+// Distributed notifications userInfo keys and values
+NSString *kHIDRemoteDNStatusHIDRemoteVersionKey = @"HIDRemoteVersion";
+NSString *kHIDRemoteDNStatusPIDKey = @"PID";
+NSString *kHIDRemoteDNStatusModeKey = @"Mode";
+NSString *kHIDRemoteDNStatusUnusedButtonCodesKey = @"UnusedButtonCodes";
+NSString *kHIDRemoteDNStatusActionKey = @"Action";
+NSString *kHIDRemoteDNStatusRemoteControlCountKey = @"RemoteControlCount";
+NSString *kHIDRemoteDNStatusReturnToPIDKey = @"ReturnToPID";
+NSString *kHIDRemoteDNStatusActionStart = @"start";
+NSString *kHIDRemoteDNStatusActionStop = @"stop";
+NSString *kHIDRemoteDNStatusActionUpdate = @"update";
+NSString *kHIDRemoteDNStatusActionNoNeed = @"noneed";