OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "chrome/browser/extensions/global_shortcut_listener_mac.h" |
| 6 |
| 7 #include <ApplicationServices/ApplicationServices.h> |
| 8 #import <Cocoa/Cocoa.h> |
| 9 #include <IOKit/hidsystem/ev_keymap.h> |
| 10 |
| 11 #include "chrome/browser/extensions/api/commands/command_service.h" |
| 12 #include "content/public/browser/browser_thread.h" |
| 13 #include "ui/base/accelerators/accelerator.h" |
| 14 #include "ui/events/event.h" |
| 15 #import "ui/events/keycodes/keyboard_code_conversion_mac.h" |
| 16 |
| 17 using content::BrowserThread; |
| 18 using extensions::GlobalShortcutListenerMac; |
| 19 |
| 20 namespace { |
| 21 |
| 22 // The media keys subtype. |
| 23 const int kSystemDefinedEventMediaKeys = 8; |
| 24 |
| 25 OSStatus HotKeyHandler( |
| 26 EventHandlerCallRef next_handler, EventRef event, void* user_data) { |
| 27 DVLOG(0) << "HotKeyHandler fired with event: " << event; |
| 28 // Extract the hotkey from the event. |
| 29 EventHotKeyID hot_key_id; |
| 30 int result = GetEventParameter(event, kEventParamDirectObject, |
| 31 typeEventHotKeyID, NULL, sizeof(hot_key_id), NULL, &hot_key_id); |
| 32 if (result != noErr) |
| 33 return result; |
| 34 |
| 35 GlobalShortcutListenerMac* shortcut_listener = |
| 36 static_cast<GlobalShortcutListenerMac*>(user_data); |
| 37 shortcut_listener->OnKeyEvent(hot_key_id); |
| 38 return noErr; |
| 39 } |
| 40 |
| 41 static base::LazyInstance<extensions::GlobalShortcutListenerMac> g_instance = |
| 42 LAZY_INSTANCE_INITIALIZER; |
| 43 |
| 44 } // namespace |
| 45 |
| 46 namespace extensions { |
| 47 |
| 48 // static |
| 49 GlobalShortcutListener* GlobalShortcutListener::GetInstance() { |
| 50 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 51 return g_instance.Pointer(); |
| 52 } |
| 53 |
| 54 GlobalShortcutListenerMac::GlobalShortcutListenerMac() |
| 55 : is_listening_(false) { |
| 56 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 57 } |
| 58 |
| 59 GlobalShortcutListenerMac::~GlobalShortcutListenerMac() { |
| 60 if (is_listening_) |
| 61 StopListening(); |
| 62 |
| 63 // If media keys are still registered, make sure we stop the tap. |
| 64 if (AreMediaKeysRegistered()) |
| 65 StopWatchingMediaKeys(); |
| 66 } |
| 67 |
| 68 void GlobalShortcutListenerMac::StartListening() { |
| 69 DCHECK(!is_listening_); // Don't start twice. |
| 70 DCHECK(!hot_key_ids_.empty()); // Don't start if no hot key registered. |
| 71 DCHECK(!id_hot_keys_.empty()); |
| 72 is_listening_ = true; |
| 73 } |
| 74 |
| 75 void GlobalShortcutListenerMac::StopListening() { |
| 76 DCHECK(is_listening_); // No point if we are not already listening. |
| 77 DCHECK(hot_key_ids_.empty()); // Make sure the set is clean. |
| 78 DCHECK(id_hot_keys_.empty()); |
| 79 is_listening_ = false; |
| 80 } |
| 81 |
| 82 bool GlobalShortcutListenerMac::OnKeyEvent(EventHotKeyID hot_key_id) { |
| 83 // Look up the accelerator based on this hot key ID. |
| 84 DVLOG(0) << "OnKeyEvent! hot_key_id: " << hot_key_id.id; |
| 85 const ui::Accelerator& accelerator = id_hot_keys_[hot_key_id.id]; |
| 86 DVLOG(0) << "Key code: " << accelerator.key_code() |
| 87 << " modifiers: " << accelerator.modifiers(); |
| 88 NotifyKeyPressed(accelerator); |
| 89 return true; |
| 90 } |
| 91 |
| 92 bool GlobalShortcutListenerMac::OnMediaKeyEvent(int media_key_code) { |
| 93 ui::KeyboardCode key_code = MediaKeyCodeToKeyboardCode(media_key_code); |
| 94 DVLOG(0) << "OnMediaKeyEvent! keyCode: " << key_code; |
| 95 // Create an accelerator corresponding to the keyCode. |
| 96 ui::Accelerator accelerator(key_code, 0); |
| 97 // Look for a match with a bound hot_key. |
| 98 if (hot_key_ids_.find(accelerator) != hot_key_ids_.end()) { |
| 99 // If matched, callback to the event handling system. |
| 100 NotifyKeyPressed(accelerator); |
| 101 return true; |
| 102 } |
| 103 return false; |
| 104 } |
| 105 |
| 106 void GlobalShortcutListenerMac::RegisterAccelerator( |
| 107 const ui::Accelerator& accelerator, |
| 108 GlobalShortcutListener::Observer* observer) { |
| 109 DVLOG(0) << "Registered keyCode: " << accelerator.key_code() |
| 110 << ", modifiers: " << accelerator.modifiers(); |
| 111 |
| 112 // If this is the first media key registered, start the event tap. |
| 113 if (CommandService::IsMediaKey(accelerator) && !AreMediaKeysRegistered()) { |
| 114 DVLOG(0) << "Registered the first media key, so starting event tap."; |
| 115 StartWatchingMediaKeys(); |
| 116 } |
| 117 |
| 118 // Register hot_key if they are non-media keyboard shortcuts. |
| 119 if (!CommandService::IsMediaKey(accelerator)) |
| 120 RegisterHotKey(accelerator); |
| 121 |
| 122 // Store the hotkey-ID mappings we will need for lookup later. |
| 123 id_hot_keys_[hot_key_id_] = accelerator; |
| 124 hot_key_ids_[accelerator] = hot_key_id_; |
| 125 ++hot_key_id_; |
| 126 GlobalShortcutListener::RegisterAccelerator(accelerator, observer); |
| 127 } |
| 128 |
| 129 void GlobalShortcutListenerMac::UnregisterAccelerator( |
| 130 const ui::Accelerator& accelerator, |
| 131 GlobalShortcutListener::Observer* observer) { |
| 132 // Unregister the hot_key if it's a keyboard shortcut. |
| 133 if (!CommandService::IsMediaKey(accelerator)) |
| 134 UnregisterHotKey(accelerator); |
| 135 |
| 136 // Remove hot_key from the mappings. |
| 137 int id = hot_key_ids_[accelerator]; |
| 138 id_hot_keys_.erase(id); |
| 139 hot_key_ids_.erase(accelerator); |
| 140 GlobalShortcutListener::UnregisterAccelerator(accelerator, observer); |
| 141 |
| 142 // If we unregistered a media key, and now if no media keys are registered, |
| 143 // stop the media key tap. |
| 144 if (CommandService::IsMediaKey(accelerator) && !AreMediaKeysRegistered()) { |
| 145 DVLOG(0) << "Unregistered the last media key, stopping event tap."; |
| 146 StopWatchingMediaKeys(); |
| 147 } |
| 148 } |
| 149 |
| 150 void GlobalShortcutListenerMac::RegisterHotKey( |
| 151 const ui::Accelerator& accelerator) { |
| 152 DVLOG(0) << "Registering hot_key. Keycode: " << accelerator.key_code(); |
| 153 EventHotKeyRef hot_key_ref; |
| 154 EventHotKeyID event_hot_key_id; |
| 155 EventHandlerUPP hot_key_function = NewEventHandlerUPP(HotKeyHandler); |
| 156 |
| 157 EventTypeSpec event_type; |
| 158 event_type.eventClass = kEventClassKeyboard; |
| 159 event_type.eventKind = kEventHotKeyPressed; |
| 160 InstallApplicationEventHandler(hot_key_function, 1, &event_type, this, NULL); |
| 161 |
| 162 // Signature uniquely identifies the application that owns this hot_key. |
| 163 event_hot_key_id.signature = 'rimZ'; |
| 164 event_hot_key_id.id = hot_key_id_; |
| 165 |
| 166 // Translate ui::Accelerator modifiers to cmdKey, altKey, etc. |
| 167 int modifiers = 0; |
| 168 modifiers += (accelerator.IsShiftDown() ? shiftKey : 0); |
| 169 modifiers += (accelerator.IsCtrlDown() ? controlKey : 0); |
| 170 modifiers += (accelerator.IsAltDown() ? optionKey : 0); |
| 171 modifiers += (accelerator.IsCmdDown() ? cmdKey : 0); |
| 172 |
| 173 unichar character; |
| 174 unichar character_nomods; |
| 175 int key_code = ui::MacKeyCodeForWindowsKeyCode(accelerator.key_code(), 0, |
| 176 &character, &character_nomods); |
| 177 DVLOG(0) << "RegisterHotKey. Code: " << key_code |
| 178 << " modifier: " << modifiers; |
| 179 |
| 180 // Register the event hot key. |
| 181 RegisterEventHotKey(key_code, modifiers, event_hot_key_id, |
| 182 GetApplicationEventTarget(), 0, &hot_key_ref); |
| 183 |
| 184 // Note: hot_key_id_ will be incremented in the caller (RegisterAccelerator). |
| 185 id_hot_key_refs_[hot_key_id_] = hot_key_ref; |
| 186 } |
| 187 |
| 188 void GlobalShortcutListenerMac::UnregisterHotKey( |
| 189 const ui::Accelerator& accelerator) { |
| 190 // Get the ref corresponding to this accelerator. |
| 191 int id = hot_key_ids_[accelerator]; |
| 192 EventHotKeyRef ref = id_hot_key_refs_[id]; |
| 193 // Unregister the event hot key. |
| 194 UnregisterEventHotKey(ref); |
| 195 |
| 196 // Remove the event from the mapping. |
| 197 id_hot_key_refs_.erase(id); |
| 198 } |
| 199 |
| 200 void GlobalShortcutListenerMac::StartWatchingMediaKeys() { |
| 201 DVLOG(0) << "StartWatchingMediaKeys"; |
| 202 // Make sure there's no existing event tap. |
| 203 DCHECK(event_tap_ == NULL); |
| 204 |
| 205 // Add an event tap to intercept the system defined media key events. |
| 206 event_tap_ = CGEventTapCreate(kCGSessionEventTap, |
| 207 kCGHeadInsertEventTap, |
| 208 kCGEventTapOptionDefault, |
| 209 CGEventMaskBit(NX_SYSDEFINED), |
| 210 EventTapCallback, |
| 211 this); |
| 212 if (event_tap_ == NULL) { |
| 213 LOG(ERROR) << "Error: failed to create event tap."; |
| 214 return; |
| 215 } |
| 216 |
| 217 event_tap_source_ = CFMachPortCreateRunLoopSource(kCFAllocatorSystemDefault, |
| 218 event_tap_, 0); |
| 219 if (event_tap_source_ == NULL) { |
| 220 LOG(ERROR) << "Error: failed to create new run loop source."; |
| 221 return; |
| 222 } |
| 223 |
| 224 CFRunLoopAddSource(CFRunLoopGetCurrent(), event_tap_source_, |
| 225 kCFRunLoopCommonModes); |
| 226 } |
| 227 |
| 228 void GlobalShortcutListenerMac::StopWatchingMediaKeys() { |
| 229 DVLOG(0) << "StopWatchingMediaKeys"; |
| 230 // Invalidate the event tap. |
| 231 DCHECK(event_tap_ != NULL); |
| 232 CFMachPortInvalidate(event_tap_); |
| 233 CFRelease(event_tap_); |
| 234 event_tap_ = NULL; |
| 235 |
| 236 // Release the event tap source. |
| 237 DCHECK(event_tap_source_ != NULL); |
| 238 CFRelease(event_tap_source_); |
| 239 event_tap_source_ = NULL; |
| 240 } |
| 241 |
| 242 ui::KeyboardCode GlobalShortcutListenerMac::MediaKeyCodeToKeyboardCode( |
| 243 int key_code) { |
| 244 switch (key_code) { |
| 245 case NX_KEYTYPE_PLAY: |
| 246 return ui::VKEY_MEDIA_PLAY_PAUSE; |
| 247 case NX_KEYTYPE_PREVIOUS: |
| 248 case NX_KEYTYPE_REWIND: |
| 249 return ui::VKEY_MEDIA_PREV_TRACK; |
| 250 case NX_KEYTYPE_NEXT: |
| 251 case NX_KEYTYPE_FAST: |
| 252 return ui::VKEY_MEDIA_NEXT_TRACK; |
| 253 } |
| 254 return ui::VKEY_UNKNOWN; |
| 255 } |
| 256 |
| 257 bool GlobalShortcutListenerMac::AreMediaKeysRegistered() { |
| 258 // Iterate through registered accelerators, looking for media keys. |
| 259 HotKeyIdMap::iterator iter; |
| 260 for (iter = hot_key_ids_.begin(); iter != hot_key_ids_.end(); ++iter) { |
| 261 if (CommandService::IsMediaKey(iter->first)) |
| 262 return true; |
| 263 } |
| 264 return false; |
| 265 } |
| 266 |
| 267 void GlobalShortcutListenerMac::EnableTap() { |
| 268 CGEventTapEnable(event_tap_, TRUE); |
| 269 } |
| 270 |
| 271 // Processed events should propagate if they aren't handled by any listeners. |
| 272 // For events that don't matter, this handler should return as quickly as |
| 273 // possible. |
| 274 // Returning event causes the event to propagate to other applications. |
| 275 // Returning NULL prevents the event from propagating. |
| 276 // static |
| 277 CGEventRef GlobalShortcutListenerMac::EventTapCallback( |
| 278 CGEventTapProxy proxy, CGEventType type, CGEventRef event, void* refcon) { |
| 279 GlobalShortcutListenerMac* shortcut_listener = |
| 280 static_cast<GlobalShortcutListenerMac*>(refcon); |
| 281 |
| 282 // Handle the timeout case by re-enabling the tap. |
| 283 if (type == kCGEventTapDisabledByTimeout) { |
| 284 shortcut_listener->EnableTap(); |
| 285 return event; |
| 286 } |
| 287 |
| 288 // TODO(smus): do some error handling since eventWithCGEvent can fail. |
| 289 NSEvent* ns_event = [NSEvent eventWithCGEvent:event]; |
| 290 |
| 291 // Ignore events that are not system defined media keys. |
| 292 if (type != NX_SYSDEFINED || |
| 293 [ns_event subtype] != kSystemDefinedEventMediaKeys) { |
| 294 return event; |
| 295 } |
| 296 |
| 297 NSInteger data1 = [ns_event data1]; |
| 298 // Ignore media keys that aren't previous, next and play/pause. |
| 299 int key_code = ((data1 & 0xFFFF0000) >> 16); |
| 300 if (key_code != NX_KEYTYPE_PLAY && key_code != NX_KEYTYPE_NEXT && |
| 301 key_code != NX_KEYTYPE_PREVIOUS && key_code != NX_KEYTYPE_FAST && |
| 302 key_code != NX_KEYTYPE_REWIND) { |
| 303 return event; |
| 304 } |
| 305 |
| 306 int key_flags = (data1 & 0x0000FFFF); |
| 307 bool is_key_pressed = (((key_flags & 0xFF00) >> 8)) == 0xA; |
| 308 |
| 309 // If the key wasn't pressed (eg. was released), ignore this event. |
| 310 if (!is_key_pressed) |
| 311 return event; |
| 312 |
| 313 // Now we have a media key that we care about. Send it to the caller. |
| 314 bool was_handled = shortcut_listener->OnMediaKeyEvent(key_code); |
| 315 |
| 316 // Prevent event from proagating to other apps if handled by Chrome. |
| 317 if (was_handled) |
| 318 return NULL; |
| 319 |
| 320 // By default, pass the event through. |
| 321 return event; |
| 322 } |
| 323 |
| 324 } // namespace extensions |
OLD | NEW |