1// Copyright 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 "media/base/user_input_monitor.h"
6
7#include "base/bind.h"
8#include "base/location.h"
9#include "base/logging.h"
10#include "base/memory/weak_ptr.h"
11#include "base/message_loop/message_loop.h"
12#include "base/single_thread_task_runner.h"
13#include "base/strings/stringprintf.h"
14#include "base/synchronization/lock.h"
15#include "base/win/message_window.h"
16#include "media/base/keyboard_event_counter.h"
17#include "third_party/skia/include/core/SkPoint.h"
18#include "ui/events/keycodes/keyboard_code_conversion_win.h"
19
20namespace media {
21namespace {
22
23// From the HID Usage Tables specification.
24const USHORT kGenericDesktopPage = 1;
25const USHORT kMouseUsage = 2;
26const USHORT kKeyboardUsage = 6;
27
28// This is the actual implementation of event monitoring. It's separated from
29// UserInputMonitorWin since it needs to be deleted on the UI thread.
30class UserInputMonitorWinCore
31    : public base::SupportsWeakPtr<UserInputMonitorWinCore>,
32      public base::MessageLoop::DestructionObserver {
33 public:
34  enum EventBitMask {
35    MOUSE_EVENT_MASK = 1,
36    KEYBOARD_EVENT_MASK = 2,
37  };
38
39  explicit UserInputMonitorWinCore(
40      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
41      const scoped_refptr<UserInputMonitor::MouseListenerList>&
42          mouse_listeners);
43  ~UserInputMonitorWinCore();
44
45  // DestructionObserver overrides.
46  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
47
48  size_t GetKeyPressCount() const;
49  void StartMonitor(EventBitMask type);
50  void StopMonitor(EventBitMask type);
51
52 private:
53  // Handles WM_INPUT messages.
54  LRESULT OnInput(HRAWINPUT input_handle);
55  // Handles messages received by |window_|.
56  bool HandleMessage(UINT message,
57                     WPARAM wparam,
58                     LPARAM lparam,
59                     LRESULT* result);
60  RAWINPUTDEVICE* GetRawInputDevices(EventBitMask event, DWORD flags);
61
62  // Task runner on which |window_| is created.
63  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
64  scoped_refptr<ObserverListThreadSafe<UserInputMonitor::MouseEventListener> >
65      mouse_listeners_;
66
67  // These members are only accessed on the UI thread.
68  scoped_ptr<base::win::MessageWindow> window_;
69  uint8 events_monitored_;
70  KeyboardEventCounter counter_;
71
72  DISALLOW_COPY_AND_ASSIGN(UserInputMonitorWinCore);
73};
74
75class UserInputMonitorWin : public UserInputMonitor {
76 public:
77  explicit UserInputMonitorWin(
78      const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner);
79  virtual ~UserInputMonitorWin();
80
81  // Public UserInputMonitor overrides.
82  virtual size_t GetKeyPressCount() const OVERRIDE;
83
84 private:
85  // Private UserInputMonitor overrides.
86  virtual void StartKeyboardMonitoring() OVERRIDE;
87  virtual void StopKeyboardMonitoring() OVERRIDE;
88  virtual void StartMouseMonitoring() OVERRIDE;
89  virtual void StopMouseMonitoring() OVERRIDE;
90
91  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
92  UserInputMonitorWinCore* core_;
93
94  DISALLOW_COPY_AND_ASSIGN(UserInputMonitorWin);
95};
96
97UserInputMonitorWinCore::UserInputMonitorWinCore(
98    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
99    const scoped_refptr<UserInputMonitor::MouseListenerList>& mouse_listeners)
100    : ui_task_runner_(ui_task_runner),
101      mouse_listeners_(mouse_listeners),
102      events_monitored_(0) {}
103
104UserInputMonitorWinCore::~UserInputMonitorWinCore() {
105  DCHECK(!window_);
106  DCHECK(!events_monitored_);
107}
108
109void UserInputMonitorWinCore::WillDestroyCurrentMessageLoop() {
110  DCHECK(ui_task_runner_->BelongsToCurrentThread());
111  StopMonitor(MOUSE_EVENT_MASK);
112  StopMonitor(KEYBOARD_EVENT_MASK);
113}
114
115size_t UserInputMonitorWinCore::GetKeyPressCount() const {
116  return counter_.GetKeyPressCount();
117}
118
119void UserInputMonitorWinCore::StartMonitor(EventBitMask type) {
120  DCHECK(ui_task_runner_->BelongsToCurrentThread());
121
122  if (events_monitored_ & type)
123    return;
124
125  if (type == KEYBOARD_EVENT_MASK)
126    counter_.Reset();
127
128  if (!window_) {
129    window_.reset(new base::win::MessageWindow());
130    if (!window_->Create(base::Bind(&UserInputMonitorWinCore::HandleMessage,
131                                    base::Unretained(this)))) {
132      LOG_GETLASTERROR(ERROR) << "Failed to create the raw input window";
133      window_.reset();
134      return;
135    }
136  }
137
138  // Register to receive raw mouse and/or keyboard input.
139  scoped_ptr<RAWINPUTDEVICE> device(GetRawInputDevices(type, RIDEV_INPUTSINK));
140  if (!RegisterRawInputDevices(device.get(), 1, sizeof(*device))) {
141    LOG_GETLASTERROR(ERROR)
142        << "RegisterRawInputDevices() failed for RIDEV_INPUTSINK";
143    window_.reset();
144    return;
145  }
146
147  // Start observing message loop destruction if we start monitoring the first
148  // event.
149  if (!events_monitored_)
150    base::MessageLoop::current()->AddDestructionObserver(this);
151
152  events_monitored_ |= type;
153}
154
155void UserInputMonitorWinCore::StopMonitor(EventBitMask type) {
156  DCHECK(ui_task_runner_->BelongsToCurrentThread());
157
158  if (!(events_monitored_ & type))
159    return;
160
161  // Stop receiving raw input.
162  DCHECK(window_);
163  scoped_ptr<RAWINPUTDEVICE> device(GetRawInputDevices(type, RIDEV_REMOVE));
164
165  if (!RegisterRawInputDevices(device.get(), 1, sizeof(*device))) {
166    LOG_GETLASTERROR(INFO)
167        << "RegisterRawInputDevices() failed for RIDEV_REMOVE";
168  }
169
170  events_monitored_ &= ~type;
171  if (events_monitored_ == 0) {
172    window_.reset();
173
174    // Stop observing message loop destruction if no event is being monitored.
175    base::MessageLoop::current()->RemoveDestructionObserver(this);
176  }
177}
178
179LRESULT UserInputMonitorWinCore::OnInput(HRAWINPUT input_handle) {
180  DCHECK(ui_task_runner_->BelongsToCurrentThread());
181
182  // Get the size of the input record.
183  UINT size = 0;
184  UINT result = GetRawInputData(
185      input_handle, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));
186  if (result == -1) {
187    LOG_GETLASTERROR(ERROR) << "GetRawInputData() failed";
188    return 0;
189  }
190  DCHECK_EQ(0u, result);
191
192  // Retrieve the input record itself.
193  scoped_ptr<uint8[]> buffer(new uint8[size]);
194  RAWINPUT* input = reinterpret_cast<RAWINPUT*>(buffer.get());
195  result = GetRawInputData(
196      input_handle, RID_INPUT, buffer.get(), &size, sizeof(RAWINPUTHEADER));
197  if (result == -1) {
198    LOG_GETLASTERROR(ERROR) << "GetRawInputData() failed";
199    return 0;
200  }
201  DCHECK_EQ(size, result);
202
203  // Notify the observer about events generated locally.
204  if (input->header.dwType == RIM_TYPEMOUSE && input->header.hDevice != NULL) {
205    POINT position;
206    if (!GetCursorPos(&position)) {
207      position.x = 0;
208      position.y = 0;
209    }
210    mouse_listeners_->Notify(
211        &UserInputMonitor::MouseEventListener::OnMouseMoved,
212        SkIPoint::Make(position.x, position.y));
213  } else if (input->header.dwType == RIM_TYPEKEYBOARD &&
214             input->header.hDevice != NULL) {
215    ui::EventType event = (input->data.keyboard.Flags & RI_KEY_BREAK)
216                              ? ui::ET_KEY_RELEASED
217                              : ui::ET_KEY_PRESSED;
218    ui::KeyboardCode key_code =
219        ui::KeyboardCodeForWindowsKeyCode(input->data.keyboard.VKey);
220    counter_.OnKeyboardEvent(event, key_code);
221  }
222
223  return DefRawInputProc(&input, 1, sizeof(RAWINPUTHEADER));
224}
225
226bool UserInputMonitorWinCore::HandleMessage(UINT message,
227                                            WPARAM wparam,
228                                            LPARAM lparam,
229                                            LRESULT* result) {
230  DCHECK(ui_task_runner_->BelongsToCurrentThread());
231
232  switch (message) {
233    case WM_INPUT:
234      *result = OnInput(reinterpret_cast<HRAWINPUT>(lparam));
235      return true;
236
237    default:
238      return false;
239  }
240}
241
242RAWINPUTDEVICE* UserInputMonitorWinCore::GetRawInputDevices(EventBitMask event,
243                                                            DWORD flags) {
244  DCHECK(ui_task_runner_->BelongsToCurrentThread());
245
246  scoped_ptr<RAWINPUTDEVICE> device(new RAWINPUTDEVICE());
247  if (event == MOUSE_EVENT_MASK) {
248    device->dwFlags = flags;
249    device->usUsagePage = kGenericDesktopPage;
250    device->usUsage = kMouseUsage;
251    device->hwndTarget = window_->hwnd();
252  } else {
253    DCHECK_EQ(KEYBOARD_EVENT_MASK, event);
254    device->dwFlags = flags;
255    device->usUsagePage = kGenericDesktopPage;
256    device->usUsage = kKeyboardUsage;
257    device->hwndTarget = window_->hwnd();
258  }
259  return device.release();
260}
261
262//
263// Implementation of UserInputMonitorWin.
264//
265
266UserInputMonitorWin::UserInputMonitorWin(
267    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
268    : ui_task_runner_(ui_task_runner),
269      core_(new UserInputMonitorWinCore(ui_task_runner, mouse_listeners())) {}
270
271UserInputMonitorWin::~UserInputMonitorWin() {
272  if (!ui_task_runner_->DeleteSoon(FROM_HERE, core_))
273    delete core_;
274}
275
276size_t UserInputMonitorWin::GetKeyPressCount() const {
277  return core_->GetKeyPressCount();
278}
279
280void UserInputMonitorWin::StartKeyboardMonitoring() {
281  ui_task_runner_->PostTask(
282      FROM_HERE,
283      base::Bind(&UserInputMonitorWinCore::StartMonitor,
284                 core_->AsWeakPtr(),
285                 UserInputMonitorWinCore::KEYBOARD_EVENT_MASK));
286}
287
288void UserInputMonitorWin::StopKeyboardMonitoring() {
289  ui_task_runner_->PostTask(
290      FROM_HERE,
291      base::Bind(&UserInputMonitorWinCore::StopMonitor,
292                 core_->AsWeakPtr(),
293                 UserInputMonitorWinCore::KEYBOARD_EVENT_MASK));
294}
295
296void UserInputMonitorWin::StartMouseMonitoring() {
297  ui_task_runner_->PostTask(
298      FROM_HERE,
299      base::Bind(&UserInputMonitorWinCore::StartMonitor,
300                 core_->AsWeakPtr(),
301                 UserInputMonitorWinCore::MOUSE_EVENT_MASK));
302}
303
304void UserInputMonitorWin::StopMouseMonitoring() {
305  ui_task_runner_->PostTask(
306      FROM_HERE,
307      base::Bind(&UserInputMonitorWinCore::StopMonitor,
308                 core_->AsWeakPtr(),
309                 UserInputMonitorWinCore::MOUSE_EVENT_MASK));
310}
311
312}  // namespace
313
314scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
315    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
316    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
317  return scoped_ptr<UserInputMonitor>(new UserInputMonitorWin(ui_task_runner));
318}
319
320}  // namespace media
321