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