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/geometry/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 // Animation distance.
  35 const int kAnimationDistance = 30;
  36
  37 enum KeyboardMode {
  38   // Invalid mode.
  39   NONE,
  40   // Full width virtual keyboard. The virtual keyboard window has the same width
  41   // as the display.
  42   FULL_WIDTH,
  43   // Floating virtual keyboard. The virtual keyboard window has customizable
  44   // width and is draggable.
  45   FLOATING,
  46 };
  47
  48 // Provides control of the virtual keyboard, including providing a container
  49 // and controlling visibility.
  50 class KEYBOARD_EXPORT KeyboardController : public ui::InputMethodObserver,
  51                                            public aura::WindowObserver {
  52  public:
  53   // Different ways to hide the keyboard.
  54   enum HideReason {
  55     // System initiated.
  56     HIDE_REASON_AUTOMATIC,
  57     // User initiated.
  58     HIDE_REASON_MANUAL,
  59   };
  60
  61   // Takes ownership of |proxy|.
  62   explicit KeyboardController(KeyboardControllerProxy* proxy);
  63   ~KeyboardController() override;
  64
  65   // Returns the container for the keyboard, which is owned by
  66   // KeyboardController.
  67   aura::Window* GetContainerWindow();
  68
  69   // Whether the container window for the keyboard has been initialized.
  70   bool keyboard_container_initialized() const {
  71     return container_.get() != NULL;
  72   }
  73
  74   // Reloads the content of the keyboard. No-op if the keyboard content is not
  75   // loaded yet.
  76   void Reload();
  77
  78   // Hides virtual keyboard and notifies observer bounds change.
  79   // This function should be called with a delay to avoid layout flicker
  80   // when the focus of input field quickly change. |automatic| is true when the
  81   // call is made by the system rather than initiated by the user.
  82   void HideKeyboard(HideReason reason);
  83
  84   // Notifies the keyboard observer for keyboard bounds changed.
  85   void NotifyKeyboardBoundsChanging(const gfx::Rect& new_bounds);
  86
  87   // Management of the observer list.
  88   virtual void AddObserver(KeyboardControllerObserver* observer);
  89   virtual void RemoveObserver(KeyboardControllerObserver* observer);
  90
  91   KeyboardControllerProxy* proxy() { return proxy_.get(); }
  92
  93   void set_lock_keyboard(bool lock) { lock_keyboard_ = lock; }
  94
  95   KeyboardMode keyboard_mode() const { return keyboard_mode_; }
  96
  97   void SetKeyboardMode(KeyboardMode mode);
  98
  99   // Force the keyboard to show up if not showing and lock the keyboard if
 100   // |lock| is true.
 101   void ShowKeyboard(bool lock);
 102
 103   // Sets the active keyboard controller. KeyboardController takes ownership of
 104   // the instance. Calling ResetIntance with a new instance destroys the
 105   // previous one. May be called with NULL to clear the instance.
 106   static void ResetInstance(KeyboardController* controller);
 107
 108   // Retrieve the active keyboard controller.
 109   static KeyboardController* GetInstance();
 110
 111   // Returns true if keyboard is currently visible.
 112   bool keyboard_visible() { return keyboard_visible_; }
 113
 114   bool show_on_resize() { return show_on_resize_; }
 115
 116   // Returns the current keyboard bounds. An empty rectangle will get returned
 117   // when the keyboard is not shown or in FLOATING mode.
 118   const gfx::Rect& current_keyboard_bounds() {
 119     return current_keyboard_bounds_;
 120   }
 121
 122   // Determines whether a particular window should have insets for overscroll.
 123   bool ShouldEnableInsets(aura::Window* window);
 124
 125   // Updates insets on web content window
 126   void UpdateWindowInsets(aura::Window* window);
 127
 128  private:
 129   // For access to Observer methods for simulation.
 130   friend class KeyboardControllerTest;
 131
 132   // aura::WindowObserver overrides
 133   void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override;
 134   void OnWindowAddedToRootWindow(aura::Window* window) override;
 135   void OnWindowRemovingFromRootWindow(aura::Window* window,
 136                                       aura::Window* new_root) override;
 137   void OnWindowBoundsChanged(aura::Window* window,
 138                              const gfx::Rect& old_bounds,
 139                              const gfx::Rect& new_bounds) override;
 140
 141   // InputMethodObserver overrides
 142   void OnTextInputTypeChanged(const ui::TextInputClient* client) override {}
 143   void OnFocus() override {}
 144   void OnBlur() override {}
 145   void OnCaretBoundsChanged(const ui::TextInputClient* client) override {}
 146   void OnTextInputStateChanged(const ui::TextInputClient* client) override;
 147   void OnInputMethodDestroyed(const ui::InputMethod* input_method) override;
 148   void OnShowImeIfNeeded() override;
 149
 150   // Show virtual keyboard immediately with animation.
 151   void ShowKeyboardInternal();
 152
 153   // Clears any insets on web content windows.
 154   void ResetWindowInsets();
 155
 156   // Returns true if keyboard is scheduled to hide.
 157   bool WillHideKeyboard() const;
 158
 159   // Called when show and hide animation finished successfully. If the animation
 160   // is aborted, it won't be called.
 161   void ShowAnimationFinished();
 162   void HideAnimationFinished();
 163
 164   // Adds an observer for tracking changes to a window size or
 165   // position while the keyboard is displayed. Any window repositioning
 166   // invalidates insets for overscrolling.
 167   void AddBoundsChangedObserver(aura::Window* window);
 168
 169   scoped_ptr<KeyboardControllerProxy> proxy_;
 170   scoped_ptr<aura::Window> container_;
 171   // CallbackAnimationObserver should destructed before container_ because it
 172   // uses container_'s animator.
 173   scoped_ptr<CallbackAnimationObserver> animation_observer_;
 174
 175   scoped_ptr<WindowBoundsChangeObserver> window_bounds_observer_;
 176
 177   ui::InputMethod* input_method_;
 178   bool keyboard_visible_;
 179   bool show_on_resize_;
 180   bool lock_keyboard_;
 181   KeyboardMode keyboard_mode_;
 182   ui::TextInputType type_;
 183
 184   base::ObserverList<KeyboardControllerObserver> observer_list_;
 185
 186   // The currently used keyboard position.
 187   gfx::Rect current_keyboard_bounds_;
 188
 189   static KeyboardController* instance_;
 190
 191   base::WeakPtrFactory<KeyboardController> weak_factory_;
 192
 193   DISALLOW_COPY_AND_ASSIGN(KeyboardController);
 194 };
 195
 196 }  // namespace keyboard
 197
 198 #endif  // UI_KEYBOARD_KEYBOARD_CONTROLLER_H_