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 CHROME_BROWSER_EXTENSIONS_API_INPUT_IME_INPUT_IME_API_H_ 6 #define CHROME_BROWSER_EXTENSIONS_API_INPUT_IME_INPUT_IME_API_H_ 7 8 #include <map> 9 #include <string> 10 #include <vector> 11 12 #include "base/memory/singleton.h" 13 #include "base/scoped_observer.h" 14 #include "base/values.h" 15 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h" 16 #include "chrome/browser/profiles/profile.h" 17 #include "components/keyed_service/core/keyed_service.h" 18 #include "extensions/browser/browser_context_keyed_api_factory.h" 19 #include "extensions/browser/event_router.h" 20 #include "extensions/browser/extension_function.h" 21 #include "extensions/browser/extension_registry_observer.h" 22 #include "extensions/common/extension.h" 23 24 class Profile; 25 26 namespace chromeos { 27 class InputMethodEngineInterface; 28 class ImeObserver; 29 } // namespace chromeos 30 31 namespace extensions { 32 class ExtensionRegistry; 33 struct InputComponentInfo; 34 35 class InputImeEventRouter { 36 public: 37 static InputImeEventRouter* GetInstance(); 38 39 bool RegisterIme(Profile*, 40 const std::string& extension_id, 41 const extensions::InputComponentInfo& component); 42 void UnregisterAllImes(const std::string& extension_id); 43 chromeos::InputMethodEngineInterface* GetEngine( 44 const std::string& extension_id, 45 const std::string& engine_id); 46 chromeos::InputMethodEngineInterface* GetActiveEngine( 47 const std::string& extension_id); 48 49 50 // Called when a key event was handled. 51 void OnKeyEventHandled(const std::string& extension_id, 52 const std::string& request_id, 53 bool handled); 54 55 std::string AddRequest(const std::string& engine_id, 56 chromeos::input_method::KeyEventHandle* key_data); 57 58 private: 59 friend struct DefaultSingletonTraits<InputImeEventRouter>; 60 typedef std::map<std::string, std::pair<std::string, 61 chromeos::input_method::KeyEventHandle*> > RequestMap; 62 63 InputImeEventRouter(); 64 ~InputImeEventRouter(); 65 66 // The engine map for event routing. 67 // { Profile : { extension_id : { engine_id : Engine } } }. 68 // TODO(shuchen): reuse the engine map in InputMethodManagerImpl. 69 typedef std::map<std::string, chromeos::InputMethodEngineInterface*> 70 EngineMap; 71 typedef std::map<std::string, EngineMap> ExtensionMap; 72 typedef std::map<Profile*, ExtensionMap, ProfileCompare> 73 ProfileEngineMap; 74 ProfileEngineMap profile_engine_map_; 75 76 unsigned int next_request_id_; 77 RequestMap request_map_; 78 79 DISALLOW_COPY_AND_ASSIGN(InputImeEventRouter); 80 }; 81 82 class InputImeSetCompositionFunction : public SyncExtensionFunction { 83 public: 84 DECLARE_EXTENSION_FUNCTION("input.ime.setComposition", 85 INPUT_IME_SETCOMPOSITION) 86 87 protected: 88 virtual ~InputImeSetCompositionFunction() {} 89 90 // ExtensionFunction: 91 virtual bool RunSync() OVERRIDE; 92 }; 93 94 class InputImeClearCompositionFunction : public SyncExtensionFunction { 95 public: 96 DECLARE_EXTENSION_FUNCTION("input.ime.clearComposition", 97 INPUT_IME_CLEARCOMPOSITION) 98 99 protected: 100 virtual ~InputImeClearCompositionFunction() {} 101 102 // ExtensionFunction: 103 virtual bool RunSync() OVERRIDE; 104 }; 105 106 class InputImeCommitTextFunction : public SyncExtensionFunction { 107 public: 108 DECLARE_EXTENSION_FUNCTION("input.ime.commitText", INPUT_IME_COMMITTEXT) 109 110 protected: 111 virtual ~InputImeCommitTextFunction() {} 112 113 // ExtensionFunction: 114 virtual bool RunSync() OVERRIDE; 115 }; 116 117 class InputImeSetCandidateWindowPropertiesFunction 118 : public SyncExtensionFunction { 119 public: 120 DECLARE_EXTENSION_FUNCTION("input.ime.setCandidateWindowProperties", 121 INPUT_IME_SETCANDIDATEWINDOWPROPERTIES) 122 123 protected: 124 virtual ~InputImeSetCandidateWindowPropertiesFunction() {} 125 126 // ExtensionFunction: 127 virtual bool RunSync() OVERRIDE; 128 }; 129 130 class InputImeSetCandidatesFunction : public SyncExtensionFunction { 131 public: 132 DECLARE_EXTENSION_FUNCTION("input.ime.setCandidates", INPUT_IME_SETCANDIDATES) 133 134 protected: 135 virtual ~InputImeSetCandidatesFunction() {} 136 137 // ExtensionFunction: 138 virtual bool RunSync() OVERRIDE; 139 }; 140 141 class InputImeSetCursorPositionFunction : public SyncExtensionFunction { 142 public: 143 DECLARE_EXTENSION_FUNCTION("input.ime.setCursorPosition", 144 INPUT_IME_SETCURSORPOSITION) 145 146 protected: 147 virtual ~InputImeSetCursorPositionFunction() {} 148 149 // ExtensionFunction: 150 virtual bool RunSync() OVERRIDE; 151 }; 152 153 class InputImeSetMenuItemsFunction : public SyncExtensionFunction { 154 public: 155 DECLARE_EXTENSION_FUNCTION("input.ime.setMenuItems", INPUT_IME_SETMENUITEMS) 156 157 protected: 158 virtual ~InputImeSetMenuItemsFunction() {} 159 160 // ExtensionFunction: 161 virtual bool RunSync() OVERRIDE; 162 }; 163 164 class InputImeUpdateMenuItemsFunction : public SyncExtensionFunction { 165 public: 166 DECLARE_EXTENSION_FUNCTION("input.ime.updateMenuItems", 167 INPUT_IME_UPDATEMENUITEMS) 168 169 protected: 170 virtual ~InputImeUpdateMenuItemsFunction() {} 171 172 // ExtensionFunction: 173 virtual bool RunSync() OVERRIDE; 174 }; 175 176 class InputImeDeleteSurroundingTextFunction : public SyncExtensionFunction { 177 public: 178 DECLARE_EXTENSION_FUNCTION("input.ime.deleteSurroundingText", 179 INPUT_IME_DELETESURROUNDINGTEXT) 180 protected: 181 virtual ~InputImeDeleteSurroundingTextFunction() {} 182 183 // ExtensionFunction: 184 virtual bool RunSync() OVERRIDE; 185 }; 186 187 class InputImeKeyEventHandledFunction : public AsyncExtensionFunction { 188 public: 189 DECLARE_EXTENSION_FUNCTION("input.ime.keyEventHandled", 190 INPUT_IME_KEYEVENTHANDLED) 191 192 protected: 193 virtual ~InputImeKeyEventHandledFunction() {} 194 195 // ExtensionFunction: 196 virtual bool RunAsync() OVERRIDE; 197 }; 198 199 class InputImeSendKeyEventsFunction : public AsyncExtensionFunction { 200 public: 201 DECLARE_EXTENSION_FUNCTION("input.ime.sendKeyEvents", 202 INPUT_IME_SENDKEYEVENTS) 203 204 protected: 205 virtual ~InputImeSendKeyEventsFunction() {} 206 207 // ExtensionFunction: 208 virtual bool RunAsync() OVERRIDE; 209 }; 210 211 class InputImeHideInputViewFunction : public AsyncExtensionFunction { 212 public: 213 DECLARE_EXTENSION_FUNCTION("input.ime.hideInputView", 214 INPUT_IME_HIDEINPUTVIEW) 215 216 protected: 217 virtual ~InputImeHideInputViewFunction() {} 218 219 // ExtensionFunction: 220 virtual bool RunAsync() OVERRIDE; 221 }; 222 223 class InputImeAPI : public BrowserContextKeyedAPI, 224 public ExtensionRegistryObserver, 225 public EventRouter::Observer { 226 public: 227 explicit InputImeAPI(content::BrowserContext* context); 228 virtual ~InputImeAPI(); 229 230 // BrowserContextKeyedAPI implementation. 231 static BrowserContextKeyedAPIFactory<InputImeAPI>* GetFactoryInstance(); 232 233 // ExtensionRegistryObserver implementation. 234 virtual void OnExtensionLoaded(content::BrowserContext* browser_context, 235 const Extension* extension) OVERRIDE; 236 virtual void OnExtensionUnloaded( 237 content::BrowserContext* browser_context, 238 const Extension* extension, 239 UnloadedExtensionInfo::Reason reason) OVERRIDE; 240 241 // EventRouter::Observer implementation. 242 virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE; 243 244 private: 245 friend class BrowserContextKeyedAPIFactory<InputImeAPI>; 246 InputImeEventRouter* input_ime_event_router(); 247 248 // BrowserContextKeyedAPI implementation. 249 static const char* service_name() { 250 return "InputImeAPI"; 251 } 252 static const bool kServiceIsNULLWhileTesting = true; 253 254 content::BrowserContext* const browser_context_; 255 256 // Listen to extension load, unloaded notifications. 257 ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver> 258 extension_registry_observer_; 259 }; 260 261 } // namespace extensions 262 263 #endif // CHROME_BROWSER_EXTENSIONS_API_INPUT_IME_INPUT_IME_API_H_ 264