chromeos/ime/component_extension_ime_manager.h

   1 // Copyright 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 CHROMEOS_IME_COMPONENT_EXTENSION_IME_MANAGER_H_
   6 #define CHROMEOS_IME_COMPONENT_EXTENSION_IME_MANAGER_H_
   7
   8 #include <set>
   9
  10 #include "base/files/file_path.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/observer_list.h"
  13 #include "chromeos/chromeos_export.h"
  14 #include "chromeos/ime/input_method_descriptor.h"
  15
  16 namespace chromeos {
  17
  18 // Represents an engine in component extension IME.
  19 struct CHROMEOS_EXPORT ComponentExtensionEngine {
  20   ComponentExtensionEngine();
  21   ~ComponentExtensionEngine();
  22   std::string engine_id;  // The engine id.
  23   std::string display_name;  // The display name.
  24   std::vector<std::string> language_codes;  // The engine's language(ex. "en").
  25   std::string description;  // The engine description.
  26   std::vector<std::string> layouts;  // The list of keyboard layout of engine.
  27 };
  28
  29 // Represents a component extension IME.
  30 struct CHROMEOS_EXPORT ComponentExtensionIME {
  31   ComponentExtensionIME();
  32   ~ComponentExtensionIME();
  33   std::string id;  // extension id.
  34   std::string manifest;  // the contents of manifest.json
  35   std::string description;  // description of extension.
  36   GURL options_page_url; // an URL to option page.
  37   GURL input_view_url; // an URL to input view page.
  38   base::FilePath path;
  39   std::vector<ComponentExtensionEngine> engines;
  40 };
  41
  42 // Provides an interface to list/load/unload for component extension IME.
  43 class CHROMEOS_EXPORT ComponentExtensionIMEManagerDelegate {
  44  public:
  45   ComponentExtensionIMEManagerDelegate();
  46   virtual ~ComponentExtensionIMEManagerDelegate();
  47
  48   // Lists installed component extension IMEs.
  49   virtual std::vector<ComponentExtensionIME> ListIME() = 0;
  50
  51   // Loads component extension IME associated with |extension_id|.
  52   // Returns false if it fails, otherwise returns true.
  53   virtual bool Load(const std::string& extension_id,
  54                     const std::string& manifest,
  55                     const base::FilePath& path) = 0;
  56
  57   // Unloads component extension IME associated with |extension_id|.
  58   virtual void Unload(const std::string& extension_id,
  59                       const base::FilePath& path) = 0;
  60 };
  61
  62 // This class manages component extension input method.
  63 class CHROMEOS_EXPORT ComponentExtensionIMEManager {
  64  public:
  65   class Observer {
  66    public:
  67     // Called when the initialization is done.
  68     virtual void OnImeComponentExtensionInitialized() = 0;
  69   };
  70
  71   ComponentExtensionIMEManager();
  72   virtual ~ComponentExtensionIMEManager();
  73
  74   // Initializes component extension manager. This function create internal
  75   // mapping between input method id and engine components. This function must
  76   // be called before using any other function.
  77   void Initialize(scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate);
  78
  79   // Notifies the observers for the component extension IMEs are initialized.
  80   void NotifyInitialized();
  81
  82   // Returns true if the initialization is done, otherwise returns false.
  83   bool IsInitialized();
  84
  85   // Loads |input_method_id| component extension IME. This function returns true
  86   // on success. This function is safe to call multiple times. Returns false if
  87   // already corresponding component extension is loaded.
  88   bool LoadComponentExtensionIME(const std::string& input_method_id);
  89
  90   // Unloads |input_method_id| component extension IME. This function returns
  91   // true on success. This function is safe to call multiple times. Returns
  92   // false if already corresponding component extension is unloaded.
  93   bool UnloadComponentExtensionIME(const std::string& input_method_id);
  94
  95   // Returns true if |input_method_id| is whitelisted component extension input
  96   // method.
  97   bool IsWhitelisted(const std::string& input_method_id);
  98
  99   // Returns true if |extension_id| is whitelisted component extension.
 100   bool IsWhitelistedExtension(const std::string& extension_id);
 101
 102   // Returns InputMethodId. This function returns empty string if |extension_id|
 103   // and |engine_id| is not a whitelisted component extention IME.
 104   std::string GetId(const std::string& extension_id,
 105                     const std::string& engine_id);
 106
 107   // Returns localized name of |input_method_id|.
 108   std::string GetName(const std::string& input_method_id);
 109
 110   // Returns localized description of |input_method_id|.
 111   std::string GetDescription(const std::string& input_method_id);
 112
 113   // Returns list of input method id associated with |language|.
 114   std::vector<std::string> ListIMEByLanguage(const std::string& language);
 115
 116   // Returns all IME as InputMethodDescriptors.
 117   input_method::InputMethodDescriptors GetAllIMEAsInputMethodDescriptor();
 118
 119   // Returns all XKB keyboard IME as InputMethodDescriptors.
 120   input_method::InputMethodDescriptors GetXkbIMEAsInputMethodDescriptor();
 121
 122   void AddObserver(Observer* observer);
 123   void RemoveObserver(Observer* observer);
 124
 125  private:
 126   // Finds ComponentExtensionIME and EngineDescription associated with
 127   // |input_method_id|. This function retruns true if it is found, otherwise
 128   // returns false. |out_extension| and |out_engine| can be NULL.
 129   bool FindEngineEntry(const std::string& input_method_id,
 130                        ComponentExtensionIME* out_extension,
 131                        ComponentExtensionEngine* out_engine);
 132
 133   bool IsInLoginLayoutWhitelist(const std::vector<std::string>& layouts);
 134
 135   scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate_;
 136
 137   std::vector<ComponentExtensionIME> component_extension_imes_;
 138
 139   ObserverList<Observer> observers_;
 140
 141   bool is_initialized_;
 142
 143   bool was_initialization_notified_;
 144
 145   std::set<std::string> login_layout_set_;
 146
 147   DISALLOW_COPY_AND_ASSIGN(ComponentExtensionIMEManager);
 148 };
 149
 150 }  // namespace chromeos
 151
 152 #endif  // CHROMEOS_IME_COMPONENT_EXTENSION_IME_MANAGER_H_