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 "ui/base/ime/chromeos/extension_ime_util.h"
6 
7 #include "base/strings/string_util.h"
8 #include "build/branding_buildflags.h"
9 
10 namespace chromeos {
11 
12 namespace {
13 
14 const char kExtensionIMEPrefix[] = "_ext_ime_";
15 const int kExtensionIMEPrefixLength =
16     sizeof(kExtensionIMEPrefix) / sizeof(kExtensionIMEPrefix[0]) - 1;
17 const char kComponentExtensionIMEPrefix[] = "_comp_ime_";
18 const int kComponentExtensionIMEPrefixLength =
19     sizeof(kComponentExtensionIMEPrefix) /
20         sizeof(kComponentExtensionIMEPrefix[0]) - 1;
21 const char kArcIMEPrefix[] = "_arc_ime_";
22 const int kArcIMEPrefixLength =
23     sizeof(kArcIMEPrefix) / sizeof(kArcIMEPrefix[0]) - 1;
24 const int kExtensionIdLength = 32;
25 
26 }  // namespace
27 
28 namespace extension_ime_util {
29 
30 #if BUILDFLAG(GOOGLE_CHROME_BRANDING)
31 const char kXkbExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
32 const char kM17nExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
33 const char kHangulExtensionId[] = "bdgdidmhaijohebebipajioienkglgfo";
34 const char kMozcExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
35 const char kT13nExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
36 const char kChinesePinyinExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
37 const char kChineseZhuyinExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
38 const char kChineseCangjieExtensionId[] = "jkghodnilhceideoidjikpgommlajknk";
39 #else
40 const char kXkbExtensionId[] = "fgoepimhcoialccpbmpnnblemnepkkao";
41 const char kM17nExtensionId[] = "jhffeifommiaekmbkkjlpmilogcfdohp";
42 const char kHangulExtensionId[] = "bdgdidmhaijohebebipajioienkglgfo";
43 const char kMozcExtensionId[] = "bbaiamgfapehflhememkfglaehiobjnk";
44 const char kT13nExtensionId[] = "gjaehgfemfahhmlgpdfknkhdnemmolop";
45 const char kChinesePinyinExtensionId[] = "cpgalbafkoofkjmaeonnfijgpfennjjn";
46 const char kChineseZhuyinExtensionId[] = "ekbifjdfhkmdeeajnolmgdlmkllopefi";
47 const char kChineseCangjieExtensionId[] = "aeebooiibjahgpgmhkeocbeekccfknbj";
48 #endif
49 
50 const char kBrailleImeExtensionId[] = "jddehjeebkoimngcbdkaahpobgicbffp";
51 const char kBrailleImeExtensionPath[] = "chromeos/accessibility/braille_ime";
52 const char kBrailleImeEngineId[] =
53     "_comp_ime_jddehjeebkoimngcbdkaahpobgicbffpbraille";
54 
55 const char kArcImeLanguage[] = "_arc_ime_language_";
56 
GetInputMethodID(const std::string & extension_id,const std::string & engine_id)57 std::string GetInputMethodID(const std::string& extension_id,
58                              const std::string& engine_id) {
59   DCHECK(!extension_id.empty());
60   DCHECK(!engine_id.empty());
61   return kExtensionIMEPrefix + extension_id + engine_id;
62 }
63 
GetComponentInputMethodID(const std::string & extension_id,const std::string & engine_id)64 std::string GetComponentInputMethodID(const std::string& extension_id,
65                                       const std::string& engine_id) {
66   DCHECK(!extension_id.empty());
67   DCHECK(!engine_id.empty());
68   return kComponentExtensionIMEPrefix + extension_id + engine_id;
69 }
70 
GetArcInputMethodID(const std::string & extension_id,const std::string & engine_id)71 std::string GetArcInputMethodID(const std::string& extension_id,
72                                 const std::string& engine_id) {
73   DCHECK(!extension_id.empty());
74   DCHECK(!engine_id.empty());
75   return kArcIMEPrefix + extension_id + engine_id;
76 }
77 
GetExtensionIDFromInputMethodID(const std::string & input_method_id)78 std::string GetExtensionIDFromInputMethodID(
79     const std::string& input_method_id) {
80   if (IsExtensionIME(input_method_id)) {
81     return input_method_id.substr(kExtensionIMEPrefixLength,
82                                   kExtensionIdLength);
83   }
84   if (IsComponentExtensionIME(input_method_id)) {
85     return input_method_id.substr(kComponentExtensionIMEPrefixLength,
86                                   kExtensionIdLength);
87   }
88   if (IsArcIME(input_method_id))
89     return input_method_id.substr(kArcIMEPrefixLength, kExtensionIdLength);
90   return "";
91 }
92 
GetComponentIDByInputMethodID(const std::string & input_method_id)93 std::string GetComponentIDByInputMethodID(const std::string& input_method_id) {
94   if (IsComponentExtensionIME(input_method_id))
95     return input_method_id.substr(kComponentExtensionIMEPrefixLength +
96                                   kExtensionIdLength);
97   if (IsExtensionIME(input_method_id))
98     return input_method_id.substr(kExtensionIMEPrefixLength +
99                                   kExtensionIdLength);
100   if (IsArcIME(input_method_id))
101     return input_method_id.substr(kArcIMEPrefixLength + kExtensionIdLength);
102   return input_method_id;
103 }
104 
GetInputMethodIDByEngineID(const std::string & engine_id)105 std::string GetInputMethodIDByEngineID(const std::string& engine_id) {
106   if (base::StartsWith(engine_id, kComponentExtensionIMEPrefix,
107                        base::CompareCase::SENSITIVE) ||
108       base::StartsWith(engine_id, kExtensionIMEPrefix,
109                        base::CompareCase::SENSITIVE) ||
110       base::StartsWith(engine_id, kArcIMEPrefix,
111                        base::CompareCase::SENSITIVE)) {
112     return engine_id;
113   }
114   if (base::StartsWith(engine_id, "xkb:", base::CompareCase::SENSITIVE))
115     return GetComponentInputMethodID(kXkbExtensionId, engine_id);
116   if (base::StartsWith(engine_id, "vkd_", base::CompareCase::SENSITIVE))
117     return GetComponentInputMethodID(kM17nExtensionId, engine_id);
118   if (base::StartsWith(engine_id, "nacl_mozc_", base::CompareCase::SENSITIVE))
119     return GetComponentInputMethodID(kMozcExtensionId, engine_id);
120   if (base::StartsWith(engine_id, "hangul_",
121                        base::CompareCase::SENSITIVE))
122     return GetComponentInputMethodID(kHangulExtensionId, engine_id);
123 
124   if (base::StartsWith(engine_id, "zh-", base::CompareCase::SENSITIVE) &&
125       engine_id.find("pinyin") != std::string::npos) {
126     return GetComponentInputMethodID(kChinesePinyinExtensionId, engine_id);
127   }
128   if (base::StartsWith(engine_id, "zh-", base::CompareCase::SENSITIVE) &&
129       engine_id.find("zhuyin") != std::string::npos) {
130     return GetComponentInputMethodID(kChineseZhuyinExtensionId, engine_id);
131   }
132   if (base::StartsWith(engine_id, "zh-", base::CompareCase::SENSITIVE) &&
133       engine_id.find("cangjie") != std::string::npos) {
134     return GetComponentInputMethodID(kChineseCangjieExtensionId, engine_id);
135   }
136   if (engine_id.find("-t-i0-") != std::string::npos)
137     return GetComponentInputMethodID(kT13nExtensionId, engine_id);
138 
139   return engine_id;
140 }
141 
IsExtensionIME(const std::string & input_method_id)142 bool IsExtensionIME(const std::string& input_method_id) {
143   return base::StartsWith(input_method_id, kExtensionIMEPrefix,
144                           base::CompareCase::SENSITIVE) &&
145          input_method_id.size() >
146              kExtensionIMEPrefixLength + kExtensionIdLength;
147 }
148 
IsComponentExtensionIME(const std::string & input_method_id)149 bool IsComponentExtensionIME(const std::string& input_method_id) {
150   return base::StartsWith(input_method_id, kComponentExtensionIMEPrefix,
151                           base::CompareCase::SENSITIVE) &&
152          input_method_id.size() >
153              kComponentExtensionIMEPrefixLength + kExtensionIdLength;
154 }
155 
IsArcIME(const std::string & input_method_id)156 bool IsArcIME(const std::string& input_method_id) {
157   return base::StartsWith(input_method_id, kArcIMEPrefix,
158                           base::CompareCase::SENSITIVE) &&
159          input_method_id.size() > kArcIMEPrefixLength + kExtensionIdLength;
160 }
161 
IsMemberOfExtension(const std::string & input_method_id,const std::string & extension_id)162 bool IsMemberOfExtension(const std::string& input_method_id,
163                          const std::string& extension_id) {
164   return base::StartsWith(input_method_id,
165                           kExtensionIMEPrefix + extension_id,
166                           base::CompareCase::SENSITIVE);
167 }
168 
IsKeyboardLayoutExtension(const std::string & input_method_id)169 bool IsKeyboardLayoutExtension(const std::string& input_method_id) {
170   if (IsComponentExtensionIME(input_method_id))
171     return base::StartsWith(GetComponentIDByInputMethodID(input_method_id),
172                             "xkb:", base::CompareCase::SENSITIVE);
173   return false;
174 }
175 
176 }  // namespace extension_ime_util
177 }  // namespace chromeos
178