ui/events/ozone/evdev/input_controller_evdev.cc

   1 // Copyright 2014 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 "ui/events/ozone/evdev/input_controller_evdev.h"
   6
   7 #include <algorithm>
   8 #include <linux/input.h>
   9
  10 #include "base/thread_task_runner_handle.h"
  11 #include "ui/events/ozone/evdev/input_device_factory_evdev_proxy.h"
  12 #include "ui/events/ozone/evdev/keyboard_evdev.h"
  13 #include "ui/events/ozone/evdev/mouse_button_map_evdev.h"
  14
  15 namespace ui {
  16
  17 InputControllerEvdev::InputControllerEvdev(KeyboardEvdev* keyboard,
  18                                            MouseButtonMapEvdev* button_map)
  19     : settings_update_pending_(false),
  20       input_device_factory_(nullptr),
  21       keyboard_(keyboard),
  22       button_map_(button_map),
  23       has_mouse_(false),
  24       has_touchpad_(false),
  25       caps_lock_led_state_(false),
  26       weak_ptr_factory_(this) {
  27 }
  28
  29 InputControllerEvdev::~InputControllerEvdev() {
  30 }
  31
  32 void InputControllerEvdev::SetInputDeviceFactory(
  33     InputDeviceFactoryEvdevProxy* input_device_factory) {
  34   input_device_factory_ = input_device_factory;
  35
  36   UpdateDeviceSettings();
  37   UpdateCapsLockLed();
  38 }
  39
  40 void InputControllerEvdev::set_has_mouse(bool has_mouse) {
  41   has_mouse_ = has_mouse;
  42 }
  43
  44 void InputControllerEvdev::set_has_touchpad(bool has_touchpad) {
  45   has_touchpad_ = has_touchpad;
  46 }
  47
  48 bool InputControllerEvdev::HasMouse() {
  49   return has_mouse_;
  50 }
  51
  52 bool InputControllerEvdev::HasTouchpad() {
  53   return has_touchpad_;
  54 }
  55
  56 bool InputControllerEvdev::IsCapsLockEnabled() {
  57   return keyboard_->IsCapsLockEnabled();
  58 }
  59
  60 void InputControllerEvdev::SetCapsLockEnabled(bool enabled) {
  61   keyboard_->SetCapsLockEnabled(enabled);
  62   UpdateCapsLockLed();
  63 }
  64
  65 void InputControllerEvdev::SetNumLockEnabled(bool enabled) {
  66   NOTIMPLEMENTED();
  67 }
  68
  69 bool InputControllerEvdev::IsAutoRepeatEnabled() {
  70   return keyboard_->IsAutoRepeatEnabled();
  71 }
  72
  73 void InputControllerEvdev::SetAutoRepeatEnabled(bool enabled) {
  74   keyboard_->SetAutoRepeatEnabled(enabled);
  75 }
  76
  77 void InputControllerEvdev::SetAutoRepeatRate(const base::TimeDelta& delay,
  78                                              const base::TimeDelta& interval) {
  79   keyboard_->SetAutoRepeatRate(delay, interval);
  80 }
  81
  82 void InputControllerEvdev::GetAutoRepeatRate(base::TimeDelta* delay,
  83                                              base::TimeDelta* interval) {
  84   keyboard_->GetAutoRepeatRate(delay, interval);
  85 }
  86
  87 void InputControllerEvdev::DisableInternalTouchpad() {
  88   if (input_device_factory_)
  89     input_device_factory_->DisableInternalTouchpad();
  90 }
  91
  92 void InputControllerEvdev::EnableInternalTouchpad() {
  93   if (input_device_factory_)
  94     input_device_factory_->EnableInternalTouchpad();
  95 }
  96
  97 void InputControllerEvdev::DisableInternalKeyboardExceptKeys(
  98     scoped_ptr<std::set<DomCode>> excepted_keys) {
  99   if (input_device_factory_) {
 100     input_device_factory_->DisableInternalKeyboardExceptKeys(
 101         excepted_keys.Pass());
 102
 103     // Release keys since we may block key up events.
 104     keyboard_->Reset();
 105   }
 106 }
 107
 108 void InputControllerEvdev::EnableInternalKeyboard() {
 109   if (input_device_factory_)
 110     input_device_factory_->EnableInternalKeyboard();
 111 }
 112
 113 void InputControllerEvdev::SetTouchpadSensitivity(int value) {
 114   input_device_settings_.touchpad_sensitivity = value;
 115   ScheduleUpdateDeviceSettings();
 116 }
 117
 118 void InputControllerEvdev::SetTapToClick(bool enabled) {
 119   input_device_settings_.tap_to_click_enabled = enabled;
 120   ScheduleUpdateDeviceSettings();
 121 }
 122
 123 void InputControllerEvdev::SetThreeFingerClick(bool enabled) {
 124   input_device_settings_.three_finger_click_enabled = enabled;
 125   ScheduleUpdateDeviceSettings();
 126 }
 127
 128 void InputControllerEvdev::SetTapDragging(bool enabled) {
 129   input_device_settings_.tap_dragging_enabled = enabled;
 130   ScheduleUpdateDeviceSettings();
 131 }
 132
 133 void InputControllerEvdev::SetNaturalScroll(bool enabled) {
 134   input_device_settings_.natural_scroll_enabled = enabled;
 135   ScheduleUpdateDeviceSettings();
 136 }
 137
 138 void InputControllerEvdev::SetMouseSensitivity(int value) {
 139   input_device_settings_.mouse_sensitivity = value;
 140   ScheduleUpdateDeviceSettings();
 141 }
 142
 143 void InputControllerEvdev::SetPrimaryButtonRight(bool right) {
 144   button_map_->UpdateButtonMap(BTN_LEFT, right ? BTN_RIGHT : BTN_LEFT);
 145   button_map_->UpdateButtonMap(BTN_RIGHT, right ? BTN_LEFT : BTN_RIGHT);
 146 }
 147
 148 void InputControllerEvdev::SetTapToClickPaused(bool state) {
 149   input_device_settings_.tap_to_click_paused = state;
 150   ScheduleUpdateDeviceSettings();
 151 }
 152
 153 void InputControllerEvdev::GetTouchDeviceStatus(
 154     const GetTouchDeviceStatusReply& reply) {
 155   if (input_device_factory_)
 156     input_device_factory_->GetTouchDeviceStatus(reply);
 157   else
 158     reply.Run(make_scoped_ptr(new std::string));
 159 }
 160
 161 void InputControllerEvdev::GetTouchEventLog(
 162     const base::FilePath& out_dir,
 163     const GetTouchEventLogReply& reply) {
 164   if (input_device_factory_)
 165     input_device_factory_->GetTouchEventLog(out_dir, reply);
 166   else
 167     reply.Run(make_scoped_ptr(new std::vector<base::FilePath>));
 168 }
 169
 170 void InputControllerEvdev::ScheduleUpdateDeviceSettings() {
 171   if (!input_device_factory_ || settings_update_pending_)
 172     return;
 173   base::ThreadTaskRunnerHandle::Get()->PostTask(
 174       FROM_HERE, base::Bind(&InputControllerEvdev::UpdateDeviceSettings,
 175                             weak_ptr_factory_.GetWeakPtr()));
 176   settings_update_pending_ = true;
 177 }
 178
 179 void InputControllerEvdev::UpdateDeviceSettings() {
 180   input_device_factory_->UpdateInputDeviceSettings(input_device_settings_);
 181   settings_update_pending_ = false;
 182 }
 183
 184 void InputControllerEvdev::UpdateCapsLockLed() {
 185   if (!input_device_factory_)
 186     return;
 187   bool caps_lock_state = IsCapsLockEnabled();
 188   if (caps_lock_state != caps_lock_led_state_)
 189     input_device_factory_->SetCapsLockLed(caps_lock_state);
 190   caps_lock_led_state_ = caps_lock_state;
 191 }
 192
 193 }  // namespace ui