1// Copyright (c) 2012 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 CHROMEOS_IME_INPUT_METHOD_MANAGER_H_
6#define CHROMEOS_IME_INPUT_METHOD_MANAGER_H_
7
8#include <map>
9#include <string>
10#include <vector>
11
12#include "base/memory/scoped_ptr.h"
13#include "chromeos/chromeos_export.h"
14#include "chromeos/ime/input_method_config.h"
15#include "chromeos/ime/input_method_descriptor.h"
16#include "chromeos/ime/input_method_property.h"
17
18namespace ui {
19class Accelerator;
20}  // namespace ui
21
22namespace chromeos {
23class ComponentExtensionIMEManager;
24class InputMethodEngine;
25namespace input_method {
26
27class InputMethodUtil;
28class XKeyboard;
29
30// This class manages input methodshandles.  Classes can add themselves as
31// observers. Clients can get an instance of this library class by:
32// GetInputMethodManager().
33class CHROMEOS_EXPORT InputMethodManager {
34 public:
35  enum State {
36    STATE_LOGIN_SCREEN = 0,
37    STATE_BROWSER_SCREEN,
38    STATE_LOCK_SCREEN,
39    STATE_TERMINATING,
40  };
41
42  class Observer {
43   public:
44    virtual ~Observer() {}
45    // Called when the current input method is changed.  |show_message|
46    // indicates whether the user should be notified of this change.
47    virtual void InputMethodChanged(InputMethodManager* manager,
48                                    bool show_message) = 0;
49    // Called when the list of properties is changed.
50    virtual void InputMethodPropertyChanged(InputMethodManager* manager) = 0;
51  };
52
53  // CandidateWindowObserver is notified of events related to the candidate
54  // window.  The "suggestion window" used by IMEs such as ibus-mozc does not
55  // count as the candidate window (this may change if we later want suggestion
56  // window events as well).  These events also won't occur when the virtual
57  // keyboard is used, since it controls its own candidate window.
58  class CandidateWindowObserver {
59   public:
60    virtual ~CandidateWindowObserver() {}
61    // Called when the candidate window is opened.
62    virtual void CandidateWindowOpened(InputMethodManager* manager) = 0;
63    // Called when the candidate window is closed.
64    virtual void CandidateWindowClosed(InputMethodManager* manager) = 0;
65  };
66
67  virtual ~InputMethodManager() {}
68
69  // Gets the global instance of InputMethodManager. Initialize() must be called
70  // first.
71  static CHROMEOS_EXPORT InputMethodManager* Get();
72
73  // Sets the global instance. |instance| will be owned by the internal pointer
74  // and deleted by Shutdown().
75  // TODO(nona): Instanciate InputMethodManagerImpl inside of this function once
76  //             crbug.com/164375 is fixed.
77  static CHROMEOS_EXPORT void Initialize(InputMethodManager* instance);
78
79  // Destroy the global instance.
80  static CHROMEOS_EXPORT void Shutdown();
81
82  // Adds an observer to receive notifications of input method related
83  // changes as desribed in the Observer class above.
84  virtual void AddObserver(Observer* observer) = 0;
85  virtual void AddCandidateWindowObserver(
86      CandidateWindowObserver* observer) = 0;
87  virtual void RemoveObserver(Observer* observer) = 0;
88  virtual void RemoveCandidateWindowObserver(
89      CandidateWindowObserver* observer) = 0;
90
91  // Returns all input methods that are supported, including ones not active.
92  // This function never returns NULL. Note that input method extensions are NOT
93  // included in the result.
94  virtual scoped_ptr<InputMethodDescriptors>
95      GetSupportedInputMethods() const = 0;
96
97  // Returns the list of input methods we can select (i.e. active) including
98  // extension input methods.
99  virtual scoped_ptr<InputMethodDescriptors> GetActiveInputMethods() const = 0;
100
101  // Returns the list of input methods we can select (i.e. active) including
102  // extension input methods.
103  // The same as GetActiveInputMethods but returns reference to internal list.
104  virtual const std::vector<std::string>& GetActiveInputMethodIds() const = 0;
105
106  // Returns the number of active input methods including extension input
107  // methods.
108  virtual size_t GetNumActiveInputMethods() const = 0;
109
110  // Changes the current input method to |input_method_id|. If |input_method_id|
111  // is not active, switch to the first one in the active input method list.
112  virtual void ChangeInputMethod(const std::string& input_method_id) = 0;
113
114  // Enables keyboard layouts (e.g. US Qwerty, US Dvorak, French Azerty) that
115  // are necessary for the |language_code| and then switches to |initial_layout|
116  // if the string is not empty. For example, if |language_code| is "en-US", US
117  // Qwerty, US International, US Extended, US Dvorak, and US Colemak layouts
118  // would be enabled. Likewise, for Germany locale, US Qwerty which corresponds
119  // to the hardware keyboard layout and several keyboard layouts for Germany
120  // would be enabled.
121  // This method is for setting up i18n keyboard layouts for the login screen.
122  virtual void EnableLayouts(const std::string& language_code,
123                             const std::string& initial_layout) = 0;
124
125  // Activates the input method property specified by the |key|.
126  virtual void ActivateInputMethodProperty(const std::string& key) = 0;
127
128  // Updates the list of active input method IDs, and then starts or stops the
129  // system input method framework as needed.
130  virtual bool EnableInputMethods(
131      const std::vector<std::string>& new_active_input_method_ids) = 0;
132
133  // Adds one entry to the list of active input method IDs, and then starts or
134  // stops the system input method framework as needed.
135  virtual bool EnableInputMethod(
136      const std::string& new_active_input_method_id) = 0;
137
138  // Remaps old input methods like "mozc" to new input methods. Return true if
139  // at least one IME is migrated.
140  // TODO(nona): Remove this function after few milestones are passed.
141  //             (http://crbug.com/236747)
142  virtual bool MigrateOldInputMethods(
143      std::vector<std::string>* input_method_ids) = 0;
144  virtual bool MigrateKoreanKeyboard(
145      const std::string& keyboard_id,
146      std::vector<std::string>* input_method_ids) = 0;
147
148  // Updates a configuration of a system input method engine with |value|.
149  // Returns true if the configuration is correctly set.
150  virtual bool SetInputMethodConfig(const std::string& section,
151                                    const std::string& config_name,
152                                    const InputMethodConfigValue& value) = 0;
153
154  // Adds an input method extension. This function does not takes ownership of
155  // |instance|.
156  virtual void AddInputMethodExtension(
157      const std::string& id,
158      const std::string& name,
159      const std::vector<std::string>& layouts,
160      const std::vector<std::string>& languages,
161      const GURL& options_url,
162      InputMethodEngine* instance) = 0;
163
164  // Removes an input method extension.
165  virtual void RemoveInputMethodExtension(const std::string& id) = 0;
166
167  // Returns a list of descriptors for all Input Method Extensions.
168  virtual void GetInputMethodExtensions(InputMethodDescriptors* result) = 0;
169
170  // Sets the list of extension IME ids which should be enabled.
171  virtual void SetEnabledExtensionImes(std::vector<std::string>* ids) = 0;
172
173  // Sets current input method to default (first owners, then hardware).
174  virtual void SetInputMethodDefault() = 0;
175
176  // Gets the descriptor of the input method which is currently selected.
177  virtual InputMethodDescriptor GetCurrentInputMethod() const = 0;
178
179  // Gets the list of input method properties. The list could be empty().
180  virtual InputMethodPropertyList GetCurrentInputMethodProperties() const = 0;
181
182  // Returns an X keyboard object which could be used to change the current XKB
183  // layout, change the caps lock status, and set the auto repeat rate/interval.
184  virtual XKeyboard* GetXKeyboard() = 0;
185
186  // Returns an InputMethodUtil object.
187  virtual InputMethodUtil* GetInputMethodUtil() = 0;
188
189  // Returns a ComponentExtentionIMEManager object.
190  virtual ComponentExtensionIMEManager* GetComponentExtensionIMEManager() = 0;
191
192  // Switches the current input method (or keyboard layout) to the next one.
193  virtual bool SwitchToNextInputMethod() = 0;
194
195  // Switches the current input method (or keyboard layout) to the previous one.
196  virtual bool SwitchToPreviousInputMethod(
197      const ui::Accelerator& accelerator) = 0;
198
199  // Switches to an input method (or keyboard layout) which is associated with
200  // the |accelerator|.
201  virtual bool SwitchInputMethod(const ui::Accelerator& accelerator) = 0;
202
203  // If keyboard layout can be uset at login screen
204  virtual bool IsFullLatinKeyboard(const std::string& layout) const = 0;
205};
206
207}  // namespace input_method
208}  // namespace chromeos
209
210#endif  // CHROMEOS_IME_INPUT_METHOD_MANAGER_H_
211