Home | History | Annotate | Download | only in keyboard 
      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 "ui/keyboard/keyboard_controller.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/command_line.h"
      9 #include "content/public/browser/render_widget_host.h"
     10 #include "content/public/browser/render_widget_host_iterator.h"
     11 #include "content/public/browser/render_widget_host_view.h"
     12 #include "ui/aura/window.h"
     13 #include "ui/aura/window_delegate.h"
     14 #include "ui/base/cursor/cursor.h"
     15 #include "ui/base/hit_test.h"
     16 #include "ui/base/ime/input_method.h"
     17 #include "ui/base/ime/text_input_client.h"
     18 #include "ui/compositor/layer_animation_observer.h"
     19 #include "ui/compositor/scoped_layer_animation_settings.h"
     20 #include "ui/gfx/path.h"
     21 #include "ui/gfx/rect.h"
     22 #include "ui/gfx/skia_util.h"
     23 #include "ui/keyboard/keyboard_controller_observer.h"
     24 #include "ui/keyboard/keyboard_controller_proxy.h"
     25 #include "ui/keyboard/keyboard_layout_manager.h"
     26 #include "ui/keyboard/keyboard_switches.h"
     27 #include "ui/keyboard/keyboard_util.h"
     28 #include "ui/wm/core/masked_window_targeter.h"
     29 
     30 #if defined(OS_CHROMEOS)
     31 #include "base/process/launch.h"
     32 #include "base/sys_info.h"
     33 #endif
     34 
     35 namespace {
     36 
     37 const int kHideKeyboardDelayMs = 100;
     38 
     39 // The virtual keyboard show/hide animation duration.
     40 const int kAnimationDurationMs = 200;
     41 
     42 // The opacity of virtual keyboard container when show animation starts or
     43 // hide animation finishes.
     44 const float kAnimationStartOrAfterHideOpacity = 0.2f;
     45 
     46 // Event targeter for the keyboard container.
     47 class KeyboardContainerTargeter : public wm::MaskedWindowTargeter {
     48  public:
     49   KeyboardContainerTargeter(aura::Window* container,
     50                             keyboard::KeyboardControllerProxy* proxy)
     51       : wm::MaskedWindowTargeter(container),
     52         proxy_(proxy) {
     53   }
     54 
     55   virtual ~KeyboardContainerTargeter() {}
     56 
     57  private:
     58   // wm::MaskedWindowTargeter:
     59   virtual bool GetHitTestMask(aura::Window* window,
     60                               gfx::Path* mask) const OVERRIDE {
     61     if (proxy_ && !proxy_->HasKeyboardWindow())
     62       return true;
     63     gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds() :
     64         keyboard::DefaultKeyboardBoundsFromWindowBounds(window->bounds());
     65     mask->addRect(RectToSkRect(keyboard_bounds));
     66     return true;
     67   }
     68 
     69   keyboard::KeyboardControllerProxy* proxy_;
     70 
     71   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerTargeter);
     72 };
     73 
     74 // The KeyboardWindowDelegate makes sure the keyboard-window does not get focus.
     75 // This is necessary to make sure that the synthetic key-events reach the target
     76 // window.
     77 // The delegate deletes itself when the window is destroyed.
     78 class KeyboardWindowDelegate : public aura::WindowDelegate {
     79  public:
     80   explicit KeyboardWindowDelegate(keyboard::KeyboardControllerProxy* proxy)
     81       : proxy_(proxy) {}
     82   virtual ~KeyboardWindowDelegate() {}
     83 
     84  private:
     85   // Overridden from aura::WindowDelegate:
     86   virtual gfx::Size GetMinimumSize() const OVERRIDE { return gfx::Size(); }
     87   virtual gfx::Size GetMaximumSize() const OVERRIDE { return gfx::Size(); }
     88   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
     89                                const gfx::Rect& new_bounds) OVERRIDE {
     90     bounds_ = new_bounds;
     91   }
     92   virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
     93     return gfx::kNullCursor;
     94   }
     95   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
     96     return HTNOWHERE;
     97   }
     98   virtual bool ShouldDescendIntoChildForEventHandling(
     99       aura::Window* child,
    100       const gfx::Point& location) OVERRIDE {
    101     return true;
    102   }
    103   virtual bool CanFocus() OVERRIDE { return false; }
    104   virtual void OnCaptureLost() OVERRIDE {}
    105   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {}
    106   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
    107   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {}
    108   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE { delete this; }
    109   virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {}
    110   virtual bool HasHitTestMask() const OVERRIDE {
    111     return !proxy_ || proxy_->HasKeyboardWindow();
    112   }
    113   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {
    114     if (proxy_ && !proxy_->HasKeyboardWindow())
    115       return;
    116     gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds() :
    117         keyboard::DefaultKeyboardBoundsFromWindowBounds(bounds_);
    118     mask->addRect(RectToSkRect(keyboard_bounds));
    119   }
    120 
    121   gfx::Rect bounds_;
    122   keyboard::KeyboardControllerProxy* proxy_;
    123 
    124   DISALLOW_COPY_AND_ASSIGN(KeyboardWindowDelegate);
    125 };
    126 
    127 void ToggleTouchEventLogging(bool enable) {
    128 #if defined(OS_CHROMEOS)
    129   if (!base::SysInfo::IsRunningOnChromeOS())
    130     return;
    131   CommandLine command(
    132       base::FilePath("/opt/google/touchscreen/toggle_touch_event_logging"));
    133   if (enable)
    134     command.AppendArg("1");
    135   else
    136     command.AppendArg("0");
    137   VLOG(1) << "Running " << command.GetCommandLineString();
    138   base::LaunchOptions options;
    139   options.wait = true;
    140   base::LaunchProcess(command, options, NULL);
    141 #endif
    142 }
    143 
    144 }  // namespace
    145 
    146 namespace keyboard {
    147 
    148 // Observer for both keyboard show and hide animations. It should be owned by
    149 // KeyboardController.
    150 class CallbackAnimationObserver : public ui::LayerAnimationObserver {
    151  public:
    152   CallbackAnimationObserver(ui::LayerAnimator* animator,
    153                             base::Callback<void(void)> callback);
    154   virtual ~CallbackAnimationObserver();
    155 
    156  private:
    157   // Overridden from ui::LayerAnimationObserver:
    158   virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) OVERRIDE;
    159   virtual void OnLayerAnimationAborted(
    160       ui::LayerAnimationSequence* seq) OVERRIDE;
    161   virtual void OnLayerAnimationScheduled(
    162       ui::LayerAnimationSequence* seq) OVERRIDE {}
    163 
    164   ui::LayerAnimator* animator_;
    165   base::Callback<void(void)> callback_;
    166 
    167   DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
    168 };
    169 
    170 CallbackAnimationObserver::CallbackAnimationObserver(
    171     ui::LayerAnimator* animator, base::Callback<void(void)> callback)
    172     : animator_(animator), callback_(callback) {
    173 }
    174 
    175 CallbackAnimationObserver::~CallbackAnimationObserver() {
    176   animator_->RemoveObserver(this);
    177 }
    178 
    179 void CallbackAnimationObserver::OnLayerAnimationEnded(
    180     ui::LayerAnimationSequence* seq) {
    181   if (animator_->is_animating())
    182     return;
    183   animator_->RemoveObserver(this);
    184   callback_.Run();
    185 }
    186 
    187 void CallbackAnimationObserver::OnLayerAnimationAborted(
    188     ui::LayerAnimationSequence* seq) {
    189   animator_->RemoveObserver(this);
    190 }
    191 
    192 // static
    193 KeyboardController* KeyboardController::instance_ = NULL;
    194 
    195 KeyboardController::KeyboardController(KeyboardControllerProxy* proxy)
    196     : proxy_(proxy),
    197       input_method_(NULL),
    198       keyboard_visible_(false),
    199       lock_keyboard_(false),
    200       type_(ui::TEXT_INPUT_TYPE_NONE),
    201       weak_factory_(this) {
    202   CHECK(proxy);
    203   input_method_ = proxy_->GetInputMethod();
    204   input_method_->AddObserver(this);
    205 }
    206 
    207 KeyboardController::~KeyboardController() {
    208   if (container_)
    209     container_->RemoveObserver(this);
    210   if (input_method_)
    211     input_method_->RemoveObserver(this);
    212   ResetWindowInsets();
    213 }
    214 
    215 // static
    216 void KeyboardController::ResetInstance(KeyboardController* controller) {
    217   if (instance_ && instance_ != controller)
    218     delete instance_;
    219   instance_ = controller;
    220 }
    221 
    222 // static
    223 KeyboardController* KeyboardController::GetInstance() {
    224   return instance_;
    225 }
    226 
    227 aura::Window* KeyboardController::GetContainerWindow() {
    228   if (!container_.get()) {
    229     container_.reset(new aura::Window(
    230         new KeyboardWindowDelegate(proxy_.get())));
    231     container_->SetEventTargeter(scoped_ptr<ui::EventTargeter>(
    232         new KeyboardContainerTargeter(container_.get(), proxy_.get())));
    233     container_->SetName("KeyboardContainer");
    234     container_->set_owned_by_parent(false);
    235     container_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
    236     container_->AddObserver(this);
    237     container_->SetLayoutManager(new KeyboardLayoutManager(this));
    238   }
    239   return container_.get();
    240 }
    241 
    242 void KeyboardController::NotifyKeyboardBoundsChanging(
    243     const gfx::Rect& new_bounds) {
    244   current_keyboard_bounds_ = new_bounds;
    245   if (proxy_->HasKeyboardWindow() && proxy_->GetKeyboardWindow()->IsVisible()) {
    246     FOR_EACH_OBSERVER(KeyboardControllerObserver,
    247                       observer_list_,
    248                       OnKeyboardBoundsChanging(new_bounds));
    249     if (keyboard::IsKeyboardOverscrollEnabled()) {
    250       // Adjust the height of the viewport for visible windows on the primary
    251       // display.
    252       // TODO(kevers): Add EnvObserver to properly initialize insets if a
    253       // window is created while the keyboard is visible.
    254       scoped_ptr<content::RenderWidgetHostIterator> widgets(
    255           content::RenderWidgetHost::GetRenderWidgetHosts());
    256       aura::Window *keyboard_window = proxy_->GetKeyboardWindow();
    257       aura::Window *root_window = keyboard_window->GetRootWindow();
    258       while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
    259         content::RenderWidgetHostView* view = widget->GetView();
    260         // Can be NULL, e.g. if the RenderWidget is being destroyed or
    261         // the render process crashed.
    262         if (view) {
    263           aura::Window *window = view->GetNativeView();
    264           if (window != keyboard_window &&
    265               window->GetRootWindow() == root_window) {
    266             gfx::Rect window_bounds = window->GetBoundsInScreen();
    267             gfx::Rect intersect = gfx::IntersectRects(window_bounds,
    268                                                       new_bounds);
    269             int overlap = intersect.height();
    270             if (overlap > 0 && overlap < window_bounds.height())
    271               view->SetInsets(gfx::Insets(0, 0, overlap, 0));
    272             else
    273               view->SetInsets(gfx::Insets(0, 0, 0, 0));
    274             // TODO(kevers): Add window observer to native window to update
    275             // insets on a window move or resize.
    276           }
    277         }
    278       }
    279     } else {
    280       ResetWindowInsets();
    281     }
    282   }
    283 }
    284 
    285 void KeyboardController::HideKeyboard(HideReason reason) {
    286   keyboard_visible_ = false;
    287   ToggleTouchEventLogging(true);
    288 
    289   keyboard::LogKeyboardControlEvent(
    290       reason == HIDE_REASON_AUTOMATIC ?
    291           keyboard::KEYBOARD_CONTROL_HIDE_AUTO :
    292           keyboard::KEYBOARD_CONTROL_HIDE_USER);
    293 
    294   NotifyKeyboardBoundsChanging(gfx::Rect());
    295 
    296   set_lock_keyboard(false);
    297 
    298   ui::LayerAnimator* container_animator = container_->layer()->GetAnimator();
    299   animation_observer_.reset(new CallbackAnimationObserver(
    300       container_animator,
    301       base::Bind(&KeyboardController::HideAnimationFinished,
    302                  base::Unretained(this))));
    303   container_animator->AddObserver(animation_observer_.get());
    304 
    305   ui::ScopedLayerAnimationSettings settings(container_animator);
    306   settings.SetTweenType(gfx::Tween::EASE_OUT);
    307   settings.SetTransitionDuration(
    308       base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
    309   gfx::Transform transform;
    310   transform.Translate(0, proxy_->GetKeyboardWindow()->bounds().height());
    311   container_->SetTransform(transform);
    312   container_->layer()->SetOpacity(kAnimationStartOrAfterHideOpacity);
    313 }
    314 
    315 void KeyboardController::AddObserver(KeyboardControllerObserver* observer) {
    316   observer_list_.AddObserver(observer);
    317 }
    318 
    319 void KeyboardController::RemoveObserver(KeyboardControllerObserver* observer) {
    320   observer_list_.RemoveObserver(observer);
    321 }
    322 
    323 void KeyboardController::ShowKeyboard(bool lock) {
    324   set_lock_keyboard(lock);
    325   ShowKeyboardInternal();
    326 }
    327 
    328 void KeyboardController::OnWindowHierarchyChanged(
    329     const HierarchyChangeParams& params) {
    330   if (params.new_parent && params.target == container_.get())
    331     OnTextInputStateChanged(proxy_->GetInputMethod()->GetTextInputClient());
    332 }
    333 
    334 void KeyboardController::Reload() {
    335   if (proxy_->HasKeyboardWindow())
    336     proxy_->ReloadKeyboardIfNeeded();
    337 }
    338 
    339 void KeyboardController::OnTextInputStateChanged(
    340     const ui::TextInputClient* client) {
    341   if (!container_.get())
    342     return;
    343 
    344   if (IsKeyboardUsabilityExperimentEnabled()) {
    345     ShowKeyboardInternal();
    346     return;
    347   }
    348 
    349   type_ = client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
    350 
    351   if (type_ == ui::TEXT_INPUT_TYPE_NONE && !lock_keyboard_) {
    352     if (keyboard_visible_) {
    353       // Set the visibility state here so that any queries for visibility
    354       // before the timer fires returns the correct future value.
    355       keyboard_visible_ = false;
    356       base::MessageLoop::current()->PostDelayedTask(
    357           FROM_HERE,
    358           base::Bind(&KeyboardController::HideKeyboard,
    359                      weak_factory_.GetWeakPtr(), HIDE_REASON_AUTOMATIC),
    360           base::TimeDelta::FromMilliseconds(kHideKeyboardDelayMs));
    361     }
    362   } else {
    363     // Abort a pending keyboard hide.
    364     if (WillHideKeyboard()) {
    365       weak_factory_.InvalidateWeakPtrs();
    366       keyboard_visible_ = true;
    367     }
    368     proxy_->SetUpdateInputType(type_);
    369     // Do not explicitly show the Virtual keyboard unless it is in the process
    370     // of hiding. Instead, the virtual keyboard is shown in response to a user
    371     // gesture (mouse or touch) that is received while an element has input
    372     // focus. Showing the keyboard requires an explicit call to
    373     // OnShowImeIfNeeded.
    374   }
    375 }
    376 
    377 void KeyboardController::OnInputMethodDestroyed(
    378     const ui::InputMethod* input_method) {
    379   DCHECK_EQ(input_method_, input_method);
    380   input_method_ = NULL;
    381 }
    382 
    383 void KeyboardController::OnShowImeIfNeeded() {
    384   ShowKeyboardInternal();
    385 }
    386 
    387 void KeyboardController::ShowKeyboardInternal() {
    388   if (!container_.get())
    389     return;
    390 
    391   if (container_->children().empty()) {
    392     keyboard::MarkKeyboardLoadStarted();
    393     aura::Window* keyboard = proxy_->GetKeyboardWindow();
    394     keyboard->Show();
    395     container_->AddChild(keyboard);
    396     keyboard->set_owned_by_parent(false);
    397   }
    398 
    399   proxy_->ReloadKeyboardIfNeeded();
    400 
    401   if (keyboard_visible_ || proxy_->GetKeyboardWindow()->bounds().height() == 0)
    402     return;
    403 
    404   keyboard_visible_ = true;
    405 
    406   // If the controller is in the process of hiding the keyboard, do not log
    407   // the stat here since the keyboard will not actually be shown.
    408   if (!WillHideKeyboard())
    409     keyboard::LogKeyboardControlEvent(keyboard::KEYBOARD_CONTROL_SHOW);
    410 
    411   weak_factory_.InvalidateWeakPtrs();
    412 
    413   // If |container_| has hide animation, its visibility is set to false when
    414   // hide animation finished. So even if the container is visible at this
    415   // point, it may in the process of hiding. We still need to show keyboard
    416   // container in this case.
    417   if (container_->IsVisible() &&
    418       !container_->layer()->GetAnimator()->is_animating())
    419     return;
    420 
    421   ToggleTouchEventLogging(false);
    422   ui::LayerAnimator* container_animator = container_->layer()->GetAnimator();
    423 
    424   // If the container is not animating, makes sure the position and opacity
    425   // are at begin states for animation.
    426   if (!container_animator->is_animating()) {
    427     gfx::Transform transform;
    428     transform.Translate(0, proxy_->GetKeyboardWindow()->bounds().height());
    429     container_->SetTransform(transform);
    430     container_->layer()->SetOpacity(kAnimationStartOrAfterHideOpacity);
    431   }
    432 
    433   container_animator->set_preemption_strategy(
    434       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
    435   animation_observer_.reset(new CallbackAnimationObserver(
    436       container_animator,
    437       base::Bind(&KeyboardController::ShowAnimationFinished,
    438                  base::Unretained(this))));
    439   container_animator->AddObserver(animation_observer_.get());
    440 
    441   proxy_->ShowKeyboardContainer(container_.get());
    442 
    443   {
    444     // Scope the following animation settings as we don't want to animate
    445     // visibility change that triggered by a call to the base class function
    446     // ShowKeyboardContainer with these settings. The container should become
    447     // visible immediately.
    448     ui::ScopedLayerAnimationSettings settings(container_animator);
    449     settings.SetTweenType(gfx::Tween::EASE_IN);
    450     settings.SetTransitionDuration(
    451         base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
    452     container_->SetTransform(gfx::Transform());
    453     container_->layer()->SetOpacity(1.0);
    454   }
    455 }
    456 
    457 void KeyboardController::ResetWindowInsets() {
    458   const gfx::Insets insets;
    459   scoped_ptr<content::RenderWidgetHostIterator> widgets(
    460       content::RenderWidgetHost::GetRenderWidgetHosts());
    461   while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
    462     content::RenderWidgetHostView* view = widget->GetView();
    463     if (view)
    464       view->SetInsets(insets);
    465   }
    466 }
    467 
    468 bool KeyboardController::WillHideKeyboard() const {
    469   return weak_factory_.HasWeakPtrs();
    470 }
    471 
    472 void KeyboardController::ShowAnimationFinished() {
    473   // Notify observers after animation finished to prevent reveal desktop
    474   // background during animation.
    475   NotifyKeyboardBoundsChanging(proxy_->GetKeyboardWindow()->bounds());
    476   proxy_->EnsureCaretInWorkArea();
    477 }
    478 
    479 void KeyboardController::HideAnimationFinished() {
    480   proxy_->HideKeyboardContainer(container_.get());
    481 }
    482 
    483 }  // namespace keyboard
    484