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 #include "base/logging.h"
      6 #include "base/strings/string_util.h"
      7 #include "chromeos/ime/component_extension_ime_manager.h"
      8 
      9 namespace chromeos {
     10 namespace {
     11 const char* kComponentExtensionIMEPrefix = "_comp_ime_";
     12 }  // namespace
     13 
     14 ComponentExtensionEngine::ComponentExtensionEngine() {
     15 }
     16 
     17 ComponentExtensionEngine::~ComponentExtensionEngine() {
     18 }
     19 
     20 ComponentExtensionIME::ComponentExtensionIME() {
     21 }
     22 
     23 ComponentExtensionIME::~ComponentExtensionIME() {
     24 }
     25 
     26 ComponentExtensionIMEManagerDelegate::ComponentExtensionIMEManagerDelegate() {
     27 }
     28 
     29 ComponentExtensionIMEManagerDelegate::~ComponentExtensionIMEManagerDelegate() {
     30 }
     31 
     32 ComponentExtensionIMEManager::ComponentExtensionIMEManager()
     33     : is_initialized_(false) {
     34 }
     35 
     36 ComponentExtensionIMEManager::~ComponentExtensionIMEManager() {
     37 }
     38 
     39 void ComponentExtensionIMEManager::Initialize(
     40     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
     41   delegate_ = delegate.Pass();
     42   component_extension_imes_ = delegate_->ListIME();
     43   is_initialized_ = true;
     44   FOR_EACH_OBSERVER(Observer, observers_, OnInitialized());
     45 }
     46 
     47 bool ComponentExtensionIMEManager::IsInitialized() {
     48   return is_initialized_;
     49 }
     50 
     51 bool ComponentExtensionIMEManager::LoadComponentExtensionIME(
     52     const std::string& input_method_id) {
     53   ComponentExtensionIME ime;
     54   if (FindEngineEntry(input_method_id, &ime, NULL))
     55     return delegate_->Load(ime.id, ime.manifest, ime.path);
     56   else
     57     return false;
     58 }
     59 
     60 bool ComponentExtensionIMEManager::UnloadComponentExtensionIME(
     61     const std::string& input_method_id) {
     62   ComponentExtensionIME ime;
     63   if (FindEngineEntry(input_method_id, &ime, NULL))
     64     return delegate_->Unload(ime.id, ime.path);
     65   else
     66     return false;
     67 }
     68 
     69 // static
     70 std::string ComponentExtensionIMEManager::GetComponentExtensionIMEId(
     71     const std::string& extension_id,
     72     const std::string& engine_id) {
     73   return kComponentExtensionIMEPrefix + extension_id + engine_id;
     74 }
     75 
     76 // static
     77 bool ComponentExtensionIMEManager::IsComponentExtensionIMEId(
     78     const std::string& input_method_id) {
     79   return StartsWithASCII(input_method_id,
     80                          kComponentExtensionIMEPrefix,
     81                          true);  // Case sensitive.
     82 }
     83 
     84 bool ComponentExtensionIMEManager::IsWhitelisted(
     85     const std::string& input_method_id) {
     86   return IsComponentExtensionIMEId(input_method_id) &&
     87       FindEngineEntry(input_method_id, NULL, NULL);
     88 }
     89 
     90 bool ComponentExtensionIMEManager::IsWhitelistedExtension(
     91     const std::string& extension_id) {
     92   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
     93     if (component_extension_imes_[i].id == extension_id)
     94       return true;
     95   }
     96   return false;
     97 }
     98 
     99 std::string ComponentExtensionIMEManager::GetId(
    100     const std::string& extension_id,
    101     const std::string& engine_id) {
    102   ComponentExtensionEngine engine;
    103   const std::string& input_method_id =
    104       GetComponentExtensionIMEId(extension_id, engine_id);
    105   if (!FindEngineEntry(input_method_id, NULL, &engine))
    106     return "";
    107   return input_method_id;
    108 }
    109 
    110 std::string ComponentExtensionIMEManager::GetName(
    111     const std::string& input_method_id) {
    112   ComponentExtensionEngine engine;
    113   if (!FindEngineEntry(input_method_id, NULL, &engine))
    114     return "";
    115   return engine.display_name;
    116 }
    117 
    118 std::string ComponentExtensionIMEManager::GetDescription(
    119     const std::string& input_method_id) {
    120   ComponentExtensionEngine engine;
    121   if (!FindEngineEntry(input_method_id, NULL, &engine))
    122     return "";
    123   return engine.description;
    124 }
    125 
    126 std::vector<std::string> ComponentExtensionIMEManager::ListIMEByLanguage(
    127     const std::string& language) {
    128   std::vector<std::string> result;
    129   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
    130     for (size_t j = 0; j < component_extension_imes_[i].engines.size(); ++j) {
    131       const ComponentExtensionIME& ime = component_extension_imes_[i];
    132       if (std::find(ime.engines[j].language_codes.begin(),
    133                     ime.engines[j].language_codes.end(),
    134                     language) != ime.engines[j].language_codes.end()) {
    135         result.push_back(GetComponentExtensionIMEId(ime.id,
    136                                                     ime.engines[j].engine_id));
    137       }
    138     }
    139   }
    140   return result;
    141 }
    142 
    143 input_method::InputMethodDescriptors
    144     ComponentExtensionIMEManager::GetAllIMEAsInputMethodDescriptor() {
    145   input_method::InputMethodDescriptors result;
    146   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
    147     for (size_t j = 0; j < component_extension_imes_[i].engines.size(); ++j) {
    148       result.push_back(
    149           input_method::InputMethodDescriptor(
    150               GetComponentExtensionIMEId(
    151                   component_extension_imes_[i].id,
    152                   component_extension_imes_[i].engines[j].engine_id),
    153               component_extension_imes_[i].engines[j].display_name,
    154               component_extension_imes_[i].engines[j].layouts,
    155               component_extension_imes_[i].engines[j].language_codes,
    156               component_extension_imes_[i].options_page_url));
    157     }
    158   }
    159   return result;
    160 }
    161 
    162 void ComponentExtensionIMEManager::AddObserver(Observer* observer) {
    163   observers_.AddObserver(observer);
    164 }
    165 
    166 void ComponentExtensionIMEManager::RemoveObserver(Observer* observer) {
    167   observers_.RemoveObserver(observer);
    168 }
    169 
    170 bool ComponentExtensionIMEManager::FindEngineEntry(
    171     const std::string& input_method_id,
    172     ComponentExtensionIME* out_extension,
    173     ComponentExtensionEngine* out_engine) {
    174   if (!IsComponentExtensionIMEId(input_method_id))
    175     return false;
    176   for (size_t i = 0; i < component_extension_imes_.size(); ++i) {
    177     const std::string extension_id = component_extension_imes_[i].id;
    178     const std::vector<ComponentExtensionEngine>& engines =
    179         component_extension_imes_[i].engines;
    180 
    181     for (size_t j = 0; j < engines.size(); ++j) {
    182       const std::string trial_ime_id = GetComponentExtensionIMEId(
    183           extension_id, engines[j].engine_id);
    184       if (trial_ime_id != input_method_id)
    185         continue;
    186 
    187       if (out_extension)
    188         *out_extension = component_extension_imes_[i];
    189       if (out_engine)
    190         *out_engine = component_extension_imes_[i].engines[j];
    191       return true;
    192     }
    193   }
    194   return false;
    195 }
    196 
    197 }  // namespace chromeos
    198