ui/keyboard/keyboard_controller.h

   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 #ifndef UI_KEYBOARD_KEYBOARD_CONTROLLER_H_
   6 #define UI_KEYBOARD_KEYBOARD_CONTROLLER_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/event_types.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/observer_list.h"
  12 #include "ui/aura/window_observer.h"
  13 #include "ui/base/ime/input_method_observer.h"
  14 #include "ui/base/ime/text_input_type.h"
  15 #include "ui/gfx/rect.h"
  16 #include "ui/keyboard/keyboard_export.h"
  17 #include "url/gurl.h"
  18
  19 namespace aura {
  20 class Window;
  21 }
  22 namespace ui {
  23 class InputMethod;
  24 class TextInputClient;
  25 }
  26
  27 namespace keyboard {
  28
  29 class CallbackAnimationObserver;
  30 class WindowBoundsChangeObserver;
  31 class KeyboardControllerObserver;
  32 class KeyboardControllerProxy;
  33
  34 // Provides control of the virtual keyboard, including providing a container
  35 // and controlling visibility.
  36 class KEYBOARD_EXPORT KeyboardController : public ui::InputMethodObserver,
  37                                            public aura::WindowObserver {
  38  public:
  39   // Different ways to hide the keyboard.
  40   enum HideReason {
  41     // System initiated.
  42     HIDE_REASON_AUTOMATIC,
  43     // User initiated.
  44     HIDE_REASON_MANUAL,
  45   };
  46
  47   // Takes ownership of |proxy|.
  48   explicit KeyboardController(KeyboardControllerProxy* proxy);
  49   virtual ~KeyboardController();
  50
  51   // Returns the container for the keyboard, which is owned by
  52   // KeyboardController.
  53   aura::Window* GetContainerWindow();
  54
  55   // Whether the container window for the keyboard has been initialized.
  56   bool keyboard_container_initialized() const {
  57     return container_.get() != NULL;
  58   }
  59
  60   // Reloads the content of the keyboard. No-op if the keyboard content is not
  61   // loaded yet.
  62   void Reload();
  63
  64   // Hides virtual keyboard and notifies observer bounds change.
  65   // This function should be called with a delay to avoid layout flicker
  66   // when the focus of input field quickly change. |automatic| is true when the
  67   // call is made by the system rather than initiated by the user.
  68   void HideKeyboard(HideReason reason);
  69
  70   // Notifies the keyboard observer for keyboard bounds changed.
  71   void NotifyKeyboardBoundsChanging(const gfx::Rect& new_bounds);
  72
  73   // Management of the observer list.
  74   virtual void AddObserver(KeyboardControllerObserver* observer);
  75   virtual void RemoveObserver(KeyboardControllerObserver* observer);
  76
  77   KeyboardControllerProxy* proxy() { return proxy_.get(); }
  78
  79   void set_lock_keyboard(bool lock) { lock_keyboard_ = lock; }
  80
  81   // Force the keyboard to show up if not showing and lock the keyboard if
  82   // |lock| is true.
  83   void ShowKeyboard(bool lock);
  84
  85   // Sets the active keyboard controller. KeyboardController takes ownership of
  86   // the instance. Calling ResetIntance with a new instance destroys the
  87   // previous one. May be called with NULL to clear the instance.
  88   static void ResetInstance(KeyboardController* controller);
  89
  90   // Retrieve the active keyboard controller.
  91   static KeyboardController* GetInstance();
  92
  93   // Returns true if keyboard is currently visible.
  94   bool keyboard_visible() { return keyboard_visible_; }
  95
  96   bool show_on_resize() { return show_on_resize_; }
  97
  98   // Returns the current keyboard bounds. When the keyboard is not shown,
  99   // an empty rectangle will get returned.
 100   const gfx::Rect& current_keyboard_bounds() {
 101     return current_keyboard_bounds_;
 102   }
 103
 104   // Updates insets on web content window
 105   void UpdateWindowInsets(aura::Window* window);
 106
 107  private:
 108   // For access to Observer methods for simulation.
 109   friend class KeyboardControllerTest;
 110
 111   // aura::WindowObserver overrides
 112   virtual void OnWindowHierarchyChanged(
 113       const HierarchyChangeParams& params) OVERRIDE;
 114
 115   // InputMethodObserver overrides
 116   virtual void OnTextInputTypeChanged(
 117       const ui::TextInputClient* client) OVERRIDE {}
 118   virtual void OnFocus() OVERRIDE {}
 119   virtual void OnBlur() OVERRIDE {}
 120   virtual void OnCaretBoundsChanged(
 121       const ui::TextInputClient* client) OVERRIDE {}
 122   virtual void OnTextInputStateChanged(
 123       const ui::TextInputClient* client) OVERRIDE;
 124   virtual void OnInputMethodDestroyed(
 125       const ui::InputMethod* input_method) OVERRIDE;
 126   virtual void OnShowImeIfNeeded() OVERRIDE;
 127
 128   // Show virtual keyboard immediately with animation.
 129   void ShowKeyboardInternal();
 130
 131   // Clears any insets on web content windows.
 132   void ResetWindowInsets();
 133
 134   // Returns true if keyboard is scheduled to hide.
 135   bool WillHideKeyboard() const;
 136
 137   // Called when show and hide animation finished successfully. If the animation
 138   // is aborted, it won't be called.
 139   void ShowAnimationFinished();
 140   void HideAnimationFinished();
 141
 142   // Adds or removes an observer for tracking changes to a window size or
 143   // position while the keyboard is displayed. Any window repositioning
 144   // invalidates insets for overscrolling.
 145   void AddBoundsChangedObserver(aura::Window* window);
 146   void RemoveBoundsChangedObserver(aura::Window* window);
 147
 148   scoped_ptr<KeyboardControllerProxy> proxy_;
 149   scoped_ptr<aura::Window> container_;
 150   // CallbackAnimationObserver should destructed before container_ because it
 151   // uses container_'s animator.
 152   scoped_ptr<CallbackAnimationObserver> animation_observer_;
 153
 154   scoped_ptr<WindowBoundsChangeObserver> window_bounds_observer_;
 155
 156   ui::InputMethod* input_method_;
 157   bool keyboard_visible_;
 158   bool show_on_resize_;
 159   bool lock_keyboard_;
 160   ui::TextInputType type_;
 161
 162   ObserverList<KeyboardControllerObserver> observer_list_;
 163
 164   base::WeakPtrFactory<KeyboardController> weak_factory_;
 165
 166   // The currently used keyboard position.
 167   gfx::Rect current_keyboard_bounds_;
 168
 169   static KeyboardController* instance_;
 170
 171   DISALLOW_COPY_AND_ASSIGN(KeyboardController);
 172 };
 173
 174 }  // namespace keyboard
 175
 176 #endif  // UI_KEYBOARD_KEYBOARD_CONTROLLER_H_