remoting/host/local_input_monitor_mac.mm

   1 // Copyright (c) 2012 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 "remoting/host/local_input_monitor.h"
   6
   7 #import <AppKit/AppKit.h>
   8 #include <set>
   9
  10 #include "base/bind.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/mac/scoped_cftyperef.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/single_thread_task_runner.h"
  17 #include "base/synchronization/lock.h"
  18 #include "base/threading/non_thread_safe.h"
  19 #include "remoting/host/client_session_control.h"
  20 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMCarbonEvent.h"
  21 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
  22
  23 // Esc Key Code is 53.
  24 // http://boredzo.org/blog/wp-content/uploads/2007/05/IMTx-virtual-keycodes.pdf
  25 static const NSUInteger kEscKeyCode = 53;
  26
  27 namespace remoting {
  28 namespace {
  29
  30 class LocalInputMonitorMac : public base::NonThreadSafe,
  31                              public LocalInputMonitor {
  32  public:
  33   // Invoked by LocalInputMonitorManager.
  34   class EventHandler {
  35    public:
  36     virtual ~EventHandler() {}
  37
  38     virtual void OnLocalMouseMoved(const webrtc::DesktopVector& position) = 0;
  39     virtual void OnDisconnectShortcut() = 0;
  40   };
  41
  42   LocalInputMonitorMac(
  43       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  44       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
  45       base::WeakPtr<ClientSessionControl> client_session_control);
  46   ~LocalInputMonitorMac() override;
  47
  48  private:
  49   // The actual implementation resides in LocalInputMonitorMac::Core class.
  50   class Core;
  51   scoped_refptr<Core> core_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorMac);
  54 };
  55
  56 }  // namespace
  57 }  // namespace remoting
  58
  59 @interface LocalInputMonitorManager : NSObject {
  60  @private
  61   GTMCarbonHotKey* hotKey_;
  62   CFRunLoopSourceRef mouseRunLoopSource_;
  63   base::ScopedCFTypeRef<CFMachPortRef> mouseMachPort_;
  64   remoting::LocalInputMonitorMac::EventHandler* monitor_;
  65 }
  66
  67 - (id)initWithMonitor:(remoting::LocalInputMonitorMac::EventHandler*)monitor;
  68
  69 // Called when the hotKey is hit.
  70 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey;
  71
  72 // Called when the local mouse moves
  73 - (void)localMouseMoved:(const webrtc::DesktopVector&)mousePos;
  74
  75 // Must be called when the LocalInputMonitorManager is no longer to be used.
  76 // Similar to NSTimer in that more than a simple release is required.
  77 - (void)invalidate;
  78
  79 @end
  80
  81 static CGEventRef LocalMouseMoved(CGEventTapProxy proxy, CGEventType type,
  82                                   CGEventRef event, void* context) {
  83   int64_t pid = CGEventGetIntegerValueField(event, kCGEventSourceUnixProcessID);
  84   if (pid == 0) {
  85     CGPoint cgMousePos = CGEventGetLocation(event);
  86     webrtc::DesktopVector mousePos(cgMousePos.x, cgMousePos.y);
  87     [static_cast<LocalInputMonitorManager*>(context) localMouseMoved:mousePos];
  88   }
  89   return nullptr;
  90 }
  91
  92 @implementation LocalInputMonitorManager
  93
  94 - (id)initWithMonitor:(remoting::LocalInputMonitorMac::EventHandler*)monitor {
  95   if ((self = [super init])) {
  96     monitor_ = monitor;
  97
  98     GTMCarbonEventDispatcherHandler* handler =
  99         [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
 100     hotKey_ = [handler registerHotKey:kEscKeyCode
 101                              modifiers:(NSAlternateKeyMask | NSControlKeyMask)
 102                                 target:self
 103                                 action:@selector(hotKeyHit:)
 104                               userInfo:nil
 105                            whenPressed:YES];
 106     if (!hotKey_) {
 107       LOG(ERROR) << "registerHotKey failed.";
 108     }
 109     mouseMachPort_.reset(CGEventTapCreate(
 110         kCGSessionEventTap, kCGHeadInsertEventTap, kCGEventTapOptionListenOnly,
 111         1 << kCGEventMouseMoved, LocalMouseMoved, self));
 112     if (mouseMachPort_) {
 113       mouseRunLoopSource_ = CFMachPortCreateRunLoopSource(
 114           nullptr, mouseMachPort_, 0);
 115       CFRunLoopAddSource(
 116           CFRunLoopGetMain(), mouseRunLoopSource_, kCFRunLoopCommonModes);
 117     } else {
 118       LOG(ERROR) << "CGEventTapCreate failed.";
 119     }
 120     if (!hotKey_ && !mouseMachPort_) {
 121       [self release];
 122       return nil;
 123     }
 124   }
 125   return self;
 126 }
 127
 128 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey {
 129   monitor_->OnDisconnectShortcut();
 130 }
 131
 132 - (void)localMouseMoved:(const webrtc::DesktopVector&)mousePos {
 133   monitor_->OnLocalMouseMoved(mousePos);
 134 }
 135
 136 - (void)invalidate {
 137   if (hotKey_) {
 138     GTMCarbonEventDispatcherHandler* handler =
 139         [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
 140     [handler unregisterHotKey:hotKey_];
 141     hotKey_ = nullptr;
 142   }
 143   if (mouseRunLoopSource_) {
 144     CFMachPortInvalidate(mouseMachPort_);
 145     CFRunLoopRemoveSource(
 146         CFRunLoopGetMain(), mouseRunLoopSource_, kCFRunLoopCommonModes);
 147     CFRelease(mouseRunLoopSource_);
 148     mouseMachPort_.reset(0);
 149     mouseRunLoopSource_ = nullptr;
 150   }
 151 }
 152
 153 @end
 154
 155 namespace remoting {
 156 namespace {
 157
 158 class LocalInputMonitorMac::Core
 159     : public base::RefCountedThreadSafe<Core>,
 160       public EventHandler {
 161  public:
 162   Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 163        scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 164        base::WeakPtr<ClientSessionControl> client_session_control);
 165
 166   void Start();
 167   void Stop();
 168
 169  private:
 170   friend class base::RefCountedThreadSafe<Core>;
 171   ~Core() override;
 172
 173   void StartOnUiThread();
 174   void StopOnUiThread();
 175
 176   // EventHandler interface.
 177   void OnLocalMouseMoved(const webrtc::DesktopVector& position) override;
 178   void OnDisconnectShortcut() override;
 179
 180   // Task runner on which public methods of this class must be called.
 181   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 182
 183   // Task runner on which |window_| is created.
 184   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 185
 186   LocalInputMonitorManager* manager_;
 187
 188   // Invoked in the |caller_task_runner_| thread to report local mouse events
 189   // and session disconnect requests.
 190   base::WeakPtr<ClientSessionControl> client_session_control_;
 191
 192   webrtc::DesktopVector mouse_position_;
 193
 194   DISALLOW_COPY_AND_ASSIGN(Core);
 195 };
 196
 197 LocalInputMonitorMac::LocalInputMonitorMac(
 198     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 199     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 200     base::WeakPtr<ClientSessionControl> client_session_control)
 201     : core_(new Core(caller_task_runner,
 202                      ui_task_runner,
 203                      client_session_control)) {
 204   core_->Start();
 205 }
 206
 207 LocalInputMonitorMac::~LocalInputMonitorMac() {
 208   core_->Stop();
 209 }
 210
 211 LocalInputMonitorMac::Core::Core(
 212     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 213     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 214     base::WeakPtr<ClientSessionControl> client_session_control)
 215     : caller_task_runner_(caller_task_runner),
 216       ui_task_runner_(ui_task_runner),
 217       manager_(nil),
 218       client_session_control_(client_session_control) {
 219   DCHECK(client_session_control_);
 220 }
 221
 222 void LocalInputMonitorMac::Core::Start() {
 223   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 224
 225   ui_task_runner_->PostTask(FROM_HERE,
 226                             base::Bind(&Core::StartOnUiThread, this));
 227 }
 228
 229 void LocalInputMonitorMac::Core::Stop() {
 230   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 231
 232   ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::StopOnUiThread, this));
 233 }
 234
 235 LocalInputMonitorMac::Core::~Core() {
 236   DCHECK(manager_ == nil);
 237 }
 238
 239 void LocalInputMonitorMac::Core::StartOnUiThread() {
 240   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 241
 242   manager_ = [[LocalInputMonitorManager alloc] initWithMonitor:this];
 243 }
 244
 245 void LocalInputMonitorMac::Core::StopOnUiThread() {
 246   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 247
 248   [manager_ invalidate];
 249   [manager_ release];
 250   manager_ = nil;
 251 }
 252
 253 void LocalInputMonitorMac::Core::OnLocalMouseMoved(
 254     const webrtc::DesktopVector& position) {
 255   // In some cases OS may emit bogus mouse-move events even when cursor is not
 256   // actually moving. To handle this case properly verify that mouse position
 257   // has changed. See crbug.com/360912 .
 258   if (position.equals(mouse_position_)) {
 259     return;
 260   }
 261
 262   mouse_position_ = position;
 263
 264   caller_task_runner_->PostTask(
 265       FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
 266                             client_session_control_,
 267                             position));
 268 }
 269
 270 void LocalInputMonitorMac::Core::OnDisconnectShortcut() {
 271   caller_task_runner_->PostTask(
 272       FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
 273                             client_session_control_));
 274 }
 275
 276 }  // namespace
 277
 278 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
 279     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 280     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
 281     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 282     base::WeakPtr<ClientSessionControl> client_session_control) {
 283   return make_scoped_ptr(new LocalInputMonitorMac(
 284       caller_task_runner, ui_task_runner, client_session_control));
 285 }
 286
 287 }  // namespace remoting