Automatic deployment of the virtual keyboard.

ash/virtual_keyboard_controller.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/virtual_keyboard_controller.h"
 
+#include <vector>
+
 #include "ash/shell.h"
+#include "ash/wm/maximize_mode/maximize_mode_controller.h"
+#include "base/command_line.h"
+#include "base/strings/string_util.h"
+#include "ui/events/device_data_manager.h"
+#include "ui/events/input_device.h"
+#include "ui/events/keyboard_device.h"
+#include "ui/events/touchscreen_device.h"
+#include "ui/gfx/x/x11_types.h"
+#include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_util.h"
 
 namespace ash {
 
-VirtualKeyboardController::VirtualKeyboardController() {
-  Shell::GetInstance()->AddShellObserver(this);
+VirtualKeyboardController::VirtualKeyboardController()
+    : has_external_keyboard_(false),
+      has_internal_keyboard_(false),
+      has_touchscreen_(false) {
+  ui::DeviceDataManager::GetInstance()->AddObserver(this);
+  UpdateDevices();
+  // Do not actually create the keyboard object since Ash environment may not be
+  // ready yet.
+  keyboard::SetTouchKeyboardEnabled(ShouldShowKeyboard());
 }
 
 VirtualKeyboardController::~VirtualKeyboardController() {
-  Shell::GetInstance()->RemoveShellObserver(this);
+  ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
 }
 
-void VirtualKeyboardController::OnMaximizeModeStarted() {
-  keyboard::SetTouchKeyboardEnabled(true);
-  Shell::GetInstance()->CreateKeyboard();
+// Determines the active input devices.
+void VirtualKeyboardController::UpdateDevices() {
+  ui::DeviceDataManager* device_data_manager =
+      ui::DeviceDataManager::GetInstance();
+
+  // Checks for internal touchscreens.
+  std::vector<ui::TouchscreenDevice> screens =
+      device_data_manager->touchscreen_devices();
+  has_touchscreen_ = screens.size() > 0;
+
+  // Checks for keyboards.
+  has_external_keyboard_ = false;
+  has_internal_keyboard_ = false;
+  std::vector<ui::KeyboardDevice> keyboards =
+      device_data_manager->keyboard_devices();
+  std::vector<ui::KeyboardDevice>::const_iterator iter;
+  for (iter = keyboards.begin(); iter != keyboards.end(); ++iter) {
+    ui::InputDeviceType type = (*iter).type;
+    if (type == ui::InputDeviceType::INPUT_DEVICE_INTERNAL)
+      has_internal_keyboard_ = true;
+    if (type == ui::InputDeviceType::INPUT_DEVICE_EXTERNAL)
+      has_external_keyboard_ = true;
+  }
 }
 
-void VirtualKeyboardController::OnMaximizeModeEnded() {
-  keyboard::SetTouchKeyboardEnabled(false);
-  if (!keyboard::IsKeyboardEnabled())
-    Shell::GetInstance()->DeactivateKeyboard();
+// Updates the virtual keyboard state.
+void VirtualKeyboardController::SetKeyboardEnabled(bool enabled) {
+  keyboard::SetTouchKeyboardEnabled(enabled);
+  if (enabled) {
+    Shell::GetInstance()->CreateKeyboard();
+  } else {
+    if (!keyboard::IsKeyboardEnabled())
+      Shell::GetInstance()->DeactivateKeyboard();
+  }
+}
+
+// Whether the keyboard should be shown.
+bool VirtualKeyboardController::ShouldShowKeyboard() {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          keyboard::switches::kAutoVirtualKeyboard)) {
+    MaximizeModeController* controller =
+        Shell::GetInstance()->maximize_mode_controller();
+    // Prevent keyboard from deploying while testing on a desktop.
+    if (!controller || !controller->CanEnterMaximizeMode())

[flackr, 2014/10/24 14:54:23]

I think controller should always exist. Also, keep in mind that
CanEnterMaximizeMode is not correct at startup. It's initialized false and
requires an asynchronous response from the accelerometer before it updates to
true. We could consider adding a notification if you need to know this as soon
as possible at startup.

[rsadam, 2014/10/24 15:32:32]

I was getting segfaults that the controller was not ready without the check. My
thought process was that if it's ready we're fine, if it isn't, that means it'll
disable the internal keyboard some point in the future when it is ready and
we'll get a KeyboardDeviceConfigurationEvent at that point.

+      return false;
+    // The internal keyboard is disabled when the user enters maximize mode.
+    return !has_internal_keyboard_;
+  }
+  // TODO(rsadam@): Add logic for a repressed keyboard. For now just enable the
+  // keyboard.
+  return !has_internal_keyboard_ && has_touchscreen_;

[flackr, 2014/10/24 14:54:23]

Since this is behind a flag, can we try adding && !has_external_keyboard_ and
add the UI for re-enabling it later? This should get us most of the feature.

[rsadam, 2014/10/24 15:32:32]

Done.

+}
+
+void VirtualKeyboardController::OnTouchscreenDeviceConfigurationChanged() {
+  UpdateDevices();
+  SetKeyboardEnabled(ShouldShowKeyboard());
+}
+
+void VirtualKeyboardController::OnKeyboardDeviceConfigurationChanged() {
+  UpdateDevices();
+  SetKeyboardEnabled(ShouldShowKeyboard());
 }
 
 }  // namespace ash