| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/chromeos/input_method/input_method_util.h" |
| |
| #include <algorithm> |
| #include <functional> |
| #include <map> |
| #include <utility> |
| |
| #include "base/basictypes.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/prefs/pref_service.h" |
| #include "base/strings/string_split.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "chrome/common/extensions/extension_constants.h" |
| // TODO(nona): move this header from this file. |
| #include "chrome/grit/generated_resources.h" |
| #include "chromeos/ime/component_extension_ime_manager.h" |
| #include "chromeos/ime/extension_ime_util.h" |
| // For SetHardwareKeyboardLayoutForTesting. |
| #include "chromeos/ime/fake_input_method_delegate.h" |
| #include "chromeos/ime/input_method_delegate.h" |
| #include "chromeos/ime/input_method_whitelist.h" |
| |
| namespace { |
| |
| // A mapping from an input method id to a resource id for a |
| // medium length language indicator. |
| // For those languages that want to display a slightly longer text in the |
| // "Your input method has changed to..." bubble than in the status tray. |
| // If an entry is not found in this table the short name is used. |
| const struct { |
| const char* engine_id; |
| const int resource_id; |
| } kMappingImeIdToMediumLenNameResourceId[] = { |
| { "hangul_2set", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN }, |
| { "hangul_3set390", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN }, |
| { "hangul_3setfinal", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN }, |
| { "hangul_3setnoshift", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN }, |
| { "hangul_3setromaja", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN }, |
| { "zh-t-i0-pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED}, |
| { "zh-t-i0-wubi-1986", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED }, |
| { "zh-hant-t-i0-und", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL }, |
| { "zh-hant-t-i0-cangjie-1987", |
| IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL }, |
| { "zh-hant-t-i0-cangjie-1987-x-m0-simplified", |
| IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL }, |
| { extension_misc::kBrailleImeEngineId, |
| IDS_LANGUAGES_MEDIUM_LEN_NAME_BRAILLE }, |
| }; |
| const size_t kMappingImeIdToMediumLenNameResourceIdLen = |
| arraysize(kMappingImeIdToMediumLenNameResourceId); |
| |
| // Due to asynchronous initialization of component extension manager, |
| // GetFirstLogingInputMethodIds may miss component extension IMEs. To enable |
| // component extension IME as the first loging input method, we have to prepare |
| // component extension IME IDs. |
| // Note: empty layout means the rule applies for all layouts. |
| const struct { |
| const char* locale; |
| const char* layout; |
| const char* engine_id; |
| } kDefaultInputMethodRecommendation[] = { |
| { "ja", "jp", "nacl_mozc_jp" }, |
| { "ja", "", "nacl_mozc_us" }, |
| { "zh-CN", "", "zh-t-i0-pinyin" }, |
| { "zh-TW", "", "zh-hant-t-i0-und" }, |
| { "th", "", "vkd_th" }, |
| { "vi", "", "vkd_vi_tcvn" }, |
| { "ru", "", "xkb:ru::rus" }, |
| }; |
| |
| // The engine ID map for migration. This migration is for input method IDs from |
| // VPD so it's NOT a temporary migration. |
| const char* const kEngineIdMigrationMap[][2] = { |
| {"ime:jp:mozc_jp", "nacl_mozc_jp"}, |
| {"ime:jp:mozc_us", "nacl_mozc_us"}, |
| {"ime:ko:hangul_2set", "hangul_2set"}, |
| {"ime:ko:hangul", "hangul_2set"}, |
| {"ime:zh-t:array", "zh-hant-t-i0-array-1992"}, |
| {"ime:zh-t:cangjie", "zh-hant-t-i0-cangjie-1987"}, |
| {"ime:zh-t:dayi", "zh-hant-t-i0-dayi-1988"}, |
| {"ime:zh-t:pinyin", "zh-hant-t-i0-pinyin"}, |
| {"ime:zh-t:quick", "zh-hant-t-i0-cangjie-1987-x-m0-simplified"}, |
| {"ime:zh-t:zhuyin", "zh-hant-t-i0-und"}, |
| {"ime:zh:pinyin", "zh-t-i0-pinyin"}, |
| {"ime:zh:wubi", "zh-t-i0-wubi-1986"}, |
| {"m17n:", "vkd_"}, |
| {"t13n:am", "am-t-i0-und"}, |
| {"t13n:ar", "ar-t-i0-und"}, |
| {"t13n:bn", "bn-t-i0-und"}, |
| {"t13n:el", "el-t-i0-und"}, |
| {"t13n:fa", "fa-t-i0-und"}, |
| {"t13n:gu", "gu-t-i0-und"}, |
| {"t13n:he", "he-t-i0-und"}, |
| {"t13n:hi", "hi-t-i0-und"}, |
| {"t13n:kn", "kn-t-i0-und"}, |
| {"t13n:ml", "ml-t-i0-und"}, |
| {"t13n:mr", "mr-t-i0-und"}, |
| {"t13n:ne", "ne-t-i0-und"}, |
| {"t13n:or", "or-t-i0-und"}, |
| {"t13n:pa", "pa-t-i0-und"}, |
| {"t13n:sa", "sa-t-i0-und"}, |
| {"t13n:sr", "sr-t-i0-und"}, |
| {"t13n:ta", "ta-t-i0-und"}, |
| {"t13n:te", "te-t-i0-und"}, |
| {"t13n:ti", "ti-t-i0-und"}, |
| {"t13n:ur", "ur-t-i0-und"}, |
| }; |
| |
| const struct EnglishToResouceId { |
| const char* english_string_from_ibus; |
| int resource_id; |
| } kEnglishToResourceIdArray[] = { |
| // For xkb-layouts. |
| { "xkb:am:phonetic:arm", IDS_STATUSBAR_LAYOUT_ARMENIAN_PHONETIC }, |
| { "xkb:be::fra", IDS_STATUSBAR_LAYOUT_BELGIUM }, |
| { "xkb:be::ger", IDS_STATUSBAR_LAYOUT_BELGIUM }, |
| { "xkb:be::nld", IDS_STATUSBAR_LAYOUT_BELGIUM }, |
| { "xkb:bg::bul", IDS_STATUSBAR_LAYOUT_BULGARIA }, |
| { "xkb:bg:phonetic:bul", IDS_STATUSBAR_LAYOUT_BULGARIA_PHONETIC }, |
| { "xkb:br::por", IDS_STATUSBAR_LAYOUT_BRAZIL }, |
| { "xkb:by::bel", IDS_STATUSBAR_LAYOUT_BELARUSIAN }, |
| { "xkb:ca::fra", IDS_STATUSBAR_LAYOUT_CANADA }, |
| { "xkb:ca:eng:eng", IDS_STATUSBAR_LAYOUT_CANADA_ENGLISH }, |
| { "xkb:ca:multix:fra", IDS_STATUSBAR_LAYOUT_CANADIAN_MULTILINGUAL }, |
| { "xkb:ch::ger", IDS_STATUSBAR_LAYOUT_SWITZERLAND }, |
| { "xkb:ch:fr:fra", IDS_STATUSBAR_LAYOUT_SWITZERLAND_FRENCH }, |
| { "xkb:cz::cze", IDS_STATUSBAR_LAYOUT_CZECHIA }, |
| { "xkb:cz:qwerty:cze", IDS_STATUSBAR_LAYOUT_CZECHIA_QWERTY }, |
| { "xkb:de::ger", IDS_STATUSBAR_LAYOUT_GERMANY }, |
| { "xkb:de:neo:ger", IDS_STATUSBAR_LAYOUT_GERMANY_NEO2 }, |
| { "xkb:dk::dan", IDS_STATUSBAR_LAYOUT_DENMARK }, |
| { "xkb:ee::est", IDS_STATUSBAR_LAYOUT_ESTONIA }, |
| { "xkb:es::spa", IDS_STATUSBAR_LAYOUT_SPAIN }, |
| { "xkb:es:cat:cat", IDS_STATUSBAR_LAYOUT_SPAIN_CATALAN }, |
| { "xkb:fi::fin", IDS_STATUSBAR_LAYOUT_FINLAND }, |
| { "xkb:fr::fra", IDS_STATUSBAR_LAYOUT_FRANCE }, |
| { "xkb:gb:dvorak:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM_DVORAK }, |
| { "xkb:gb:extd:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM }, |
| { "xkb:ge::geo", IDS_STATUSBAR_LAYOUT_GEORGIAN }, |
| { "xkb:gr::gre", IDS_STATUSBAR_LAYOUT_GREECE }, |
| { "xkb:hr::scr", IDS_STATUSBAR_LAYOUT_CROATIA }, |
| { "xkb:hu::hun", IDS_STATUSBAR_LAYOUT_HUNGARY }, |
| { "xkb:ie::ga", IDS_STATUSBAR_LAYOUT_IRISH }, |
| { "xkb:il::heb", IDS_STATUSBAR_LAYOUT_ISRAEL }, |
| { "xkb:is::ice", IDS_STATUSBAR_LAYOUT_ICELANDIC }, |
| { "xkb:it::ita", IDS_STATUSBAR_LAYOUT_ITALY }, |
| { "xkb:jp::jpn", IDS_STATUSBAR_LAYOUT_JAPAN }, |
| { "xkb:latam::spa", IDS_STATUSBAR_LAYOUT_LATIN_AMERICAN }, |
| { "xkb:lt::lit", IDS_STATUSBAR_LAYOUT_LITHUANIA }, |
| { "xkb:lv:apostrophe:lav", IDS_STATUSBAR_LAYOUT_LATVIA }, |
| { "xkb:mn::mon", IDS_STATUSBAR_LAYOUT_MONGOLIAN }, |
| { "xkb:nl::nld", IDS_STATUSBAR_LAYOUT_NETHERLANDS }, |
| { "xkb:no::nob", IDS_STATUSBAR_LAYOUT_NORWAY }, |
| { "xkb:pl::pol", IDS_STATUSBAR_LAYOUT_POLAND }, |
| { "xkb:pt::por", IDS_STATUSBAR_LAYOUT_PORTUGAL }, |
| { "xkb:ro::rum", IDS_STATUSBAR_LAYOUT_ROMANIA }, |
| { "xkb:rs::srp", IDS_STATUSBAR_LAYOUT_SERBIA }, |
| { "xkb:ru::rus", IDS_STATUSBAR_LAYOUT_RUSSIA }, |
| { "xkb:ru:phonetic:rus", IDS_STATUSBAR_LAYOUT_RUSSIA_PHONETIC }, |
| { "xkb:se::swe", IDS_STATUSBAR_LAYOUT_SWEDEN }, |
| { "xkb:si::slv", IDS_STATUSBAR_LAYOUT_SLOVENIA }, |
| { "xkb:sk::slo", IDS_STATUSBAR_LAYOUT_SLOVAKIA }, |
| { "xkb:tr::tur", IDS_STATUSBAR_LAYOUT_TURKEY }, |
| { "xkb:ua::ukr", IDS_STATUSBAR_LAYOUT_UKRAINE }, |
| { "xkb:us::eng", IDS_STATUSBAR_LAYOUT_USA }, |
| { "xkb:us::fil", IDS_STATUSBAR_LAYOUT_USA }, |
| { "xkb:us::ind", IDS_STATUSBAR_LAYOUT_USA }, |
| { "xkb:us::msa", IDS_STATUSBAR_LAYOUT_USA }, |
| { "xkb:us:altgr-intl:eng", IDS_STATUSBAR_LAYOUT_USA_EXTENDED }, |
| { "xkb:us:colemak:eng", IDS_STATUSBAR_LAYOUT_USA_COLEMAK }, |
| { "xkb:us:dvorak:eng", IDS_STATUSBAR_LAYOUT_USA_DVORAK }, |
| { "xkb:us:intl:eng", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL }, |
| { "xkb:us:intl:nld", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL }, |
| { "xkb:us:intl:por", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL }, |
| }; |
| const size_t kEnglishToResourceIdArraySize = |
| arraysize(kEnglishToResourceIdArray); |
| |
| } // namespace |
| |
| namespace chromeos { |
| |
| namespace input_method { |
| |
| InputMethodUtil::InputMethodUtil(InputMethodDelegate* delegate) |
| : delegate_(delegate) { |
| InputMethodDescriptors default_input_methods; |
| default_input_methods.push_back(GetFallbackInputMethodDescriptor()); |
| ResetInputMethods(default_input_methods); |
| |
| // Initialize a map from English string to Chrome string resource ID as well. |
| for (size_t i = 0; i < kEnglishToResourceIdArraySize; ++i) { |
| const EnglishToResouceId& map_entry = kEnglishToResourceIdArray[i]; |
| const bool result = english_to_resource_id_.insert(std::make_pair( |
| map_entry.english_string_from_ibus, map_entry.resource_id)).second; |
| DCHECK(result) << "Duplicated string is found: " |
| << map_entry.english_string_from_ibus; |
| } |
| } |
| |
| InputMethodUtil::~InputMethodUtil() { |
| } |
| |
| bool InputMethodUtil::TranslateStringInternal( |
| const std::string& english_string, base::string16 *out_string) const { |
| DCHECK(out_string); |
| // |english_string| could be an input method id. So legacy xkb id is required |
| // to get the translated string. |
| std::string key_string = extension_ime_util::MaybeGetLegacyXkbId( |
| english_string); |
| HashType::const_iterator iter = english_to_resource_id_.find(key_string); |
| |
| if (iter == english_to_resource_id_.end()) { |
| // TODO(yusukes): Write Autotest which checks if all display names and all |
| // property names for supported input methods are listed in the resource |
| // ID array (crosbug.com/4572). |
| LOG(ERROR) << "Resource ID is not found for: " << english_string |
| << ", " << key_string; |
| return false; |
| } |
| |
| *out_string = delegate_->GetLocalizedString(iter->second); |
| return true; |
| } |
| |
| base::string16 InputMethodUtil::TranslateString( |
| const std::string& english_string) const { |
| base::string16 localized_string; |
| if (TranslateStringInternal(english_string, &localized_string)) { |
| return localized_string; |
| } |
| return base::UTF8ToUTF16(english_string); |
| } |
| |
| bool InputMethodUtil::IsValidInputMethodId( |
| const std::string& input_method_id) const { |
| // We can't check the component extension is whilelisted or not here because |
| // it might not be initialized. |
| return GetInputMethodDescriptorFromId(input_method_id) != NULL || |
| extension_ime_util::IsComponentExtensionIME(input_method_id); |
| } |
| |
| // static |
| bool InputMethodUtil::IsKeyboardLayout(const std::string& input_method_id) { |
| return StartsWithASCII(input_method_id, "xkb:", false) || |
| extension_ime_util::IsKeyboardLayoutExtension(input_method_id); |
| } |
| |
| std::string InputMethodUtil::GetKeyboardLayoutName( |
| const std::string& input_method_id) const { |
| InputMethodIdToDescriptorMap::const_iterator iter |
| = id_to_descriptor_.find(input_method_id); |
| return (iter == id_to_descriptor_.end()) ? |
| "" : iter->second.GetPreferredKeyboardLayout(); |
| } |
| |
| std::string InputMethodUtil::GetInputMethodDisplayNameFromId( |
| const std::string& input_method_id) const { |
| base::string16 display_name; |
| if (!extension_ime_util::IsExtensionIME(input_method_id) && |
| TranslateStringInternal(input_method_id, &display_name)) { |
| return base::UTF16ToUTF8(display_name); |
| } |
| // Return an empty string if the display name is not found. |
| return ""; |
| } |
| |
| base::string16 InputMethodUtil::GetInputMethodShortName( |
| const InputMethodDescriptor& input_method) const { |
| // TODO(shuchen): remove this method, as the client can directly use |
| // input_method.GetIndicator(). |
| return base::UTF8ToUTF16(input_method.GetIndicator()); |
| } |
| |
| base::string16 InputMethodUtil::GetInputMethodMediumName( |
| const InputMethodDescriptor& input_method) const { |
| // For the "Your input method has changed to..." bubble. In most cases |
| // it uses the same name as the short name, unless found in a table |
| // for medium length names. |
| for (size_t i = 0; i < kMappingImeIdToMediumLenNameResourceIdLen; ++i) { |
| if (extension_ime_util::GetInputMethodIDByEngineID( |
| kMappingImeIdToMediumLenNameResourceId[i].engine_id) == |
| input_method.id()) { |
| return delegate_->GetLocalizedString( |
| kMappingImeIdToMediumLenNameResourceId[i].resource_id); |
| } |
| } |
| return GetInputMethodShortName(input_method); |
| } |
| |
| base::string16 InputMethodUtil::GetInputMethodLongNameInternal( |
| const InputMethodDescriptor& input_method, bool short_name) const { |
| if (!input_method.name().empty() && !IsKeyboardLayout(input_method.id())) { |
| // If the descriptor has a name, use it. |
| return base::UTF8ToUTF16(input_method.name()); |
| } |
| |
| // We don't show language here. Name of keyboard layout or input method |
| // usually imply (or explicitly include) its language. |
| // Special case for German, French and Dutch: these languages have multiple |
| // keyboard layouts and share the same layout of keyboard (Belgian). We need |
| // to show explicitly the language for the layout. |
| DCHECK(!input_method.language_codes().empty()); |
| const std::string language_code = input_method.language_codes().at(0); |
| |
| base::string16 text = (short_name || input_method.name().empty()) |
| ? TranslateString(input_method.id()) |
| : base::UTF8ToUTF16(input_method.name()); |
| if (language_code == "de" || language_code == "fr" || language_code == "nl") { |
| const base::string16 language_name = delegate_->GetDisplayLanguageName( |
| language_code); |
| text = language_name + base::UTF8ToUTF16(" - ") + text; |
| } |
| |
| DCHECK(!text.empty()); |
| return text; |
| } |
| |
| |
| base::string16 InputMethodUtil::GetInputMethodLongNameStripped( |
| const InputMethodDescriptor& input_method) const { |
| return GetInputMethodLongNameInternal(input_method, true /* short_name */); |
| } |
| |
| base::string16 InputMethodUtil::GetInputMethodLongName( |
| const InputMethodDescriptor& input_method) const { |
| return GetInputMethodLongNameInternal(input_method, false /* short_name */); |
| } |
| |
| const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromId( |
| const std::string& input_method_id) const { |
| InputMethodIdToDescriptorMap::const_iterator iter = |
| id_to_descriptor_.find(input_method_id); |
| if (iter == id_to_descriptor_.end()) |
| return NULL; |
| return &(iter->second); |
| } |
| |
| bool InputMethodUtil::GetInputMethodIdsFromLanguageCode( |
| const std::string& normalized_language_code, |
| InputMethodType type, |
| std::vector<std::string>* out_input_method_ids) const { |
| return GetInputMethodIdsFromLanguageCodeInternal( |
| language_code_to_ids_, |
| normalized_language_code, type, out_input_method_ids); |
| } |
| |
| bool InputMethodUtil::GetInputMethodIdsFromLanguageCodeInternal( |
| const std::multimap<std::string, std::string>& language_code_to_ids, |
| const std::string& normalized_language_code, |
| InputMethodType type, |
| std::vector<std::string>* out_input_method_ids) const { |
| DCHECK(out_input_method_ids); |
| out_input_method_ids->clear(); |
| |
| bool result = false; |
| std::pair<LanguageCodeToIdsMap::const_iterator, |
| LanguageCodeToIdsMap::const_iterator> range = |
| language_code_to_ids.equal_range(normalized_language_code); |
| for (LanguageCodeToIdsMap::const_iterator iter = range.first; |
| iter != range.second; ++iter) { |
| const std::string& input_method_id = iter->second; |
| if ((type == kAllInputMethods) || IsKeyboardLayout(input_method_id)) { |
| out_input_method_ids->push_back(input_method_id); |
| result = true; |
| } |
| } |
| if ((type == kAllInputMethods) && !result) { |
| DVLOG(1) << "Unknown language code: " << normalized_language_code; |
| } |
| return result; |
| } |
| |
| void InputMethodUtil::GetFirstLoginInputMethodIds( |
| const std::string& language_code, |
| const InputMethodDescriptor& current_input_method, |
| std::vector<std::string>* out_input_method_ids) const { |
| out_input_method_ids->clear(); |
| |
| // First, add the current keyboard layout (one used on the login screen). |
| out_input_method_ids->push_back(current_input_method.id()); |
| |
| const std::string current_layout |
| = current_input_method.GetPreferredKeyboardLayout(); |
| for (size_t i = 0; i < arraysize(kDefaultInputMethodRecommendation); |
| ++i) { |
| if (kDefaultInputMethodRecommendation[i].locale == language_code && ( |
| !kDefaultInputMethodRecommendation[i].layout[0] || |
| kDefaultInputMethodRecommendation[i].layout == current_layout)) { |
| out_input_method_ids->push_back( |
| extension_ime_util::GetInputMethodIDByEngineID( |
| kDefaultInputMethodRecommendation[i].engine_id)); |
| return; |
| } |
| } |
| |
| // Second, find the most popular input method associated with the |
| // current UI language. The input method IDs returned from |
| // GetInputMethodIdsFromLanguageCode() are sorted by popularity, hence |
| // our basic strategy is to pick the first one, but it's a bit more |
| // complicated as shown below. |
| std::string most_popular_id; |
| std::vector<std::string> input_method_ids; |
| // This returns the input methods sorted by popularity. |
| GetInputMethodIdsFromLanguageCode( |
| language_code, kAllInputMethods, &input_method_ids); |
| for (size_t i = 0; i < input_method_ids.size(); ++i) { |
| const std::string& input_method_id = input_method_ids[i]; |
| // Pick the first one. |
| if (most_popular_id.empty()) |
| most_popular_id = input_method_id; |
| |
| // Check if there is one that matches the current keyboard layout, but |
| // not the current keyboard itself. This is useful if there are |
| // multiple keyboard layout choices for one input method. For |
| // instance, Mozc provides three choices: mozc (US keyboard), mozc-jp |
| // (JP keyboard), mozc-dv (Dvorak). |
| const InputMethodDescriptor* descriptor = |
| GetInputMethodDescriptorFromId(input_method_id); |
| if (descriptor && |
| descriptor->id() != current_input_method.id() && |
| descriptor->GetPreferredKeyboardLayout() == |
| current_input_method.GetPreferredKeyboardLayout()) { |
| most_popular_id = input_method_id; |
| break; |
| } |
| } |
| // Add the most popular input method ID, if it's different from the |
| // current input method. |
| if (most_popular_id != current_input_method.id()) { |
| out_input_method_ids->push_back(most_popular_id); |
| } |
| } |
| |
| void InputMethodUtil::GetLanguageCodesFromInputMethodIds( |
| const std::vector<std::string>& input_method_ids, |
| std::vector<std::string>* out_language_codes) const { |
| out_language_codes->clear(); |
| |
| for (size_t i = 0; i < input_method_ids.size(); ++i) { |
| const std::string& input_method_id = input_method_ids[i]; |
| const InputMethodDescriptor* input_method = |
| GetInputMethodDescriptorFromId(input_method_id); |
| if (!input_method) { |
| DVLOG(1) << "Unknown input method ID: " << input_method_ids[i]; |
| continue; |
| } |
| DCHECK(!input_method->language_codes().empty()); |
| const std::string language_code = input_method->language_codes().at(0); |
| // Add it if it's not already present. |
| if (std::count(out_language_codes->begin(), out_language_codes->end(), |
| language_code) == 0) { |
| out_language_codes->push_back(language_code); |
| } |
| } |
| } |
| |
| std::string InputMethodUtil::GetLanguageDefaultInputMethodId( |
| const std::string& language_code) { |
| std::vector<std::string> candidates; |
| GetInputMethodIdsFromLanguageCode( |
| language_code, input_method::kKeyboardLayoutsOnly, &candidates); |
| if (candidates.size()) |
| return candidates.front(); |
| |
| return std::string(); |
| } |
| |
| bool InputMethodUtil::MigrateInputMethods( |
| std::vector<std::string>* input_method_ids) { |
| bool rewritten = false; |
| std::vector<std::string>& ids = *input_method_ids; |
| for (size_t i = 0; i < ids.size(); ++i) { |
| std::string engine_id = ids[i]; |
| // Migrates some Engine IDs from VPD. |
| for (size_t j = 0; j < arraysize(kEngineIdMigrationMap); ++j) { |
| size_t pos = engine_id.find(kEngineIdMigrationMap[j][0]); |
| if (pos == 0) { |
| engine_id.replace(0, |
| strlen(kEngineIdMigrationMap[j][0]), |
| kEngineIdMigrationMap[j][1]); |
| break; |
| } |
| } |
| // Migrates the extension IDs. |
| std::string id = |
| extension_ime_util::GetInputMethodIDByEngineID(engine_id); |
| if (extension_ime_util::IsComponentExtensionIME(id)) { |
| std::string id_new = extension_ime_util::GetInputMethodIDByEngineID( |
| extension_ime_util::GetComponentIDByInputMethodID(id)); |
| if (extension_ime_util::IsComponentExtensionIME(id_new)) |
| id = id_new; |
| } |
| if (id != ids[i]) { |
| ids[i] = id; |
| rewritten = true; |
| } |
| } |
| if (rewritten) { |
| // Removes the duplicates. |
| std::vector<std::string> new_ids; |
| for (size_t i = 0; i < ids.size(); ++i) { |
| if (std::find(new_ids.begin(), new_ids.end(), ids[i]) == new_ids.end()) |
| new_ids.push_back(ids[i]); |
| } |
| ids.swap(new_ids); |
| } |
| return rewritten; |
| } |
| |
| void InputMethodUtil::UpdateHardwareLayoutCache() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| hardware_layouts_.clear(); |
| hardware_login_layouts_.clear(); |
| if (cached_hardware_layouts_.empty()) |
| Tokenize(delegate_->GetHardwareKeyboardLayouts(), ",", |
| &cached_hardware_layouts_); |
| hardware_layouts_ = cached_hardware_layouts_; |
| MigrateInputMethods(&hardware_layouts_); |
| |
| for (size_t i = 0; i < hardware_layouts_.size(); ++i) { |
| if (IsLoginKeyboard(hardware_layouts_[i])) |
| hardware_login_layouts_.push_back(hardware_layouts_[i]); |
| } |
| if (hardware_layouts_.empty()) { |
| // This is totally fine if it's empty. The hardware keyboard layout is |
| // not stored if startup_manifest.json (OEM customization data) is not |
| // present (ex. Cr48 doen't have that file). |
| hardware_layouts_.push_back(GetFallbackInputMethodDescriptor().id()); |
| } |
| |
| if (hardware_login_layouts_.empty()) |
| hardware_login_layouts_.push_back(GetFallbackInputMethodDescriptor().id()); |
| } |
| |
| void InputMethodUtil::SetHardwareKeyboardLayoutForTesting( |
| const std::string& layout) { |
| delegate_->SetHardwareKeyboardLayoutForTesting(layout); |
| cached_hardware_layouts_.clear(); |
| UpdateHardwareLayoutCache(); |
| } |
| |
| const std::vector<std::string>& |
| InputMethodUtil::GetHardwareInputMethodIds() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| UpdateHardwareLayoutCache(); |
| return hardware_layouts_; |
| } |
| |
| const std::vector<std::string>& |
| InputMethodUtil::GetHardwareLoginInputMethodIds() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| UpdateHardwareLayoutCache(); |
| return hardware_login_layouts_; |
| } |
| |
| bool InputMethodUtil::IsLoginKeyboard(const std::string& input_method_id) |
| const { |
| const InputMethodDescriptor* ime = |
| GetInputMethodDescriptorFromId(input_method_id); |
| return ime ? ime->is_login_keyboard() : false; |
| } |
| |
| void InputMethodUtil::AppendInputMethods(const InputMethodDescriptors& imes) { |
| for (size_t i = 0; i < imes.size(); ++i) { |
| const InputMethodDescriptor& input_method = imes[i]; |
| DCHECK(!input_method.language_codes().empty()); |
| const std::vector<std::string>& language_codes = |
| input_method.language_codes(); |
| id_to_descriptor_[input_method.id()] = input_method; |
| |
| typedef LanguageCodeToIdsMap::const_iterator It; |
| for (size_t j = 0; j < language_codes.size(); ++j) { |
| std::pair<It, It> range = |
| language_code_to_ids_.equal_range(language_codes[j]); |
| It it = range.first; |
| for (; it != range.second; ++it) { |
| if (it->second == input_method.id()) |
| break; |
| } |
| if (it == range.second) |
| language_code_to_ids_.insert( |
| std::make_pair(language_codes[j], input_method.id())); |
| } |
| } |
| } |
| |
| void InputMethodUtil::ResetInputMethods(const InputMethodDescriptors& imes) { |
| // Clear the existing maps. |
| language_code_to_ids_.clear(); |
| id_to_descriptor_.clear(); |
| |
| AppendInputMethods(imes); |
| } |
| |
| void InputMethodUtil::InitXkbInputMethodsForTesting() { |
| cached_hardware_layouts_.clear(); |
| ResetInputMethods(*(InputMethodWhitelist().GetSupportedInputMethods())); |
| } |
| |
| const InputMethodUtil::InputMethodIdToDescriptorMap& |
| InputMethodUtil::GetIdToDesciptorMapForTesting() { |
| return id_to_descriptor_; |
| } |
| |
| InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() { |
| std::vector<std::string> layouts; |
| layouts.push_back("us"); |
| std::vector<std::string> languages; |
| languages.push_back("en-US"); |
| return InputMethodDescriptor( |
| extension_ime_util::GetInputMethodIDByEngineID("xkb:us::eng"), |
| "", |
| "US", |
| layouts, |
| languages, |
| true, // login keyboard. |
| GURL(), // options page, not available. |
| GURL()); // input view page, not available. |
| } |
| |
| } // namespace input_method |
| } // namespace chromeos |