1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.android.internal.inputmethod;
18
19 import android.content.Context;
20 import android.content.pm.PackageManager;
21 import android.text.TextUtils;
22 import android.util.Log;
23 import android.util.Printer;
24 import android.util.Slog;
25 import android.view.inputmethod.InputMethodInfo;
26 import android.view.inputmethod.InputMethodSubtype;
27
28 import com.android.internal.annotations.VisibleForTesting;
29 import com.android.internal.inputmethod.InputMethodUtils.InputMethodSettings;
30
31 import java.util.ArrayList;
32 import java.util.Collections;
33 import java.util.Comparator;
34 import java.util.HashMap;
35 import java.util.HashSet;
36 import java.util.List;
37 import java.util.Locale;
38 import java.util.Objects;
39 import java.util.TreeMap;
40
41 /**
42 * InputMethodSubtypeSwitchingController controls the switching behavior of the subtypes.
43 * <p>
44 * This class is designed to be used from and only from {@link InputMethodManagerService} by using
45 * {@link InputMethodManagerService#mMethodMap} as a global lock.
46 * </p>
47 */
48 public class InputMethodSubtypeSwitchingController {
49 private static final String TAG = InputMethodSubtypeSwitchingController.class.getSimpleName();
50 private static final boolean DEBUG = false;
51 private static final int NOT_A_SUBTYPE_ID = InputMethodUtils.NOT_A_SUBTYPE_ID;
52
53 public static class ImeSubtypeListItem implements Comparable<ImeSubtypeListItem> {
54 public final CharSequence mImeName;
55 public final CharSequence mSubtypeName;
56 public final InputMethodInfo mImi;
57 public final int mSubtypeId;
58 public final boolean mIsSystemLocale;
59 public final boolean mIsSystemLanguage;
60
61 public ImeSubtypeListItem(CharSequence imeName, CharSequence subtypeName,
62 InputMethodInfo imi, int subtypeId, String subtypeLocale, String systemLocale) {
63 mImeName = imeName;
64 mSubtypeName = subtypeName;
65 mImi = imi;
66 mSubtypeId = subtypeId;
67 if (TextUtils.isEmpty(subtypeLocale)) {
68 mIsSystemLocale = false;
69 mIsSystemLanguage = false;
70 } else {
71 mIsSystemLocale = subtypeLocale.equals(systemLocale);
72 if (mIsSystemLocale) {
73 mIsSystemLanguage = true;
74 } else {
75 // TODO: Use Locale#getLanguage or Locale#toLanguageTag
76 final String systemLanguage = parseLanguageFromLocaleString(systemLocale);
77 final String subtypeLanguage = parseLanguageFromLocaleString(subtypeLocale);
78 mIsSystemLanguage = systemLanguage.length() >= 2 &&
79 systemLanguage.equals(subtypeLanguage);
80 }
81 }
82 }
83
84 /**
85 * Returns the language component of a given locale string.
86 * TODO: Use {@link Locale#getLanguage()} instead.
87 */
88 private static String parseLanguageFromLocaleString(final String locale) {
89 final int idx = locale.indexOf('_');
90 if (idx < 0) {
91 return locale;
92 } else {
93 return locale.substring(0, idx);
94 }
95 }
96
97 @Override
98 public int compareTo(ImeSubtypeListItem other) {
99 if (TextUtils.isEmpty(mImeName)) {
100 return 1;
101 }
102 if (TextUtils.isEmpty(other.mImeName)) {
103 return -1;
104 }
105 if (!TextUtils.equals(mImeName, other.mImeName)) {
106 return mImeName.toString().compareTo(other.mImeName.toString());
107 }
108 if (TextUtils.equals(mSubtypeName, other.mSubtypeName)) {
109 return 0;
110 }
111 if (mIsSystemLocale) {
112 return -1;
113 }
114 if (other.mIsSystemLocale) {
115 return 1;
116 }
117 if (mIsSystemLanguage) {
118 return -1;
119 }
120 if (other.mIsSystemLanguage) {
121 return 1;
122 }
123 if (TextUtils.isEmpty(mSubtypeName)) {
124 return 1;
125 }
126 if (TextUtils.isEmpty(other.mSubtypeName)) {
127 return -1;
128 }
129 return mSubtypeName.toString().compareTo(other.mSubtypeName.toString());
130 }
131
132 @Override
133 public String toString() {
134 return "ImeSubtypeListItem{"
135 + "mImeName=" + mImeName
136 + " mSubtypeName=" + mSubtypeName
137 + " mSubtypeId=" + mSubtypeId
138 + " mIsSystemLocale=" + mIsSystemLocale
139 + " mIsSystemLanguage=" + mIsSystemLanguage
140 + "}";
141 }
142
143 @Override
144 public boolean equals(Object o) {
145 if (o == this) {
146 return true;
147 }
148 if (o instanceof ImeSubtypeListItem) {
149 final ImeSubtypeListItem that = (ImeSubtypeListItem)o;
150 if (!Objects.equals(this.mImi, that.mImi)) {
151 return false;
152 }
153 if (this.mSubtypeId != that.mSubtypeId) {
154 return false;
155 }
156 return true;
157 }
158 return false;
159 }
160 }
161
162 private static class InputMethodAndSubtypeList {
163 private final Context mContext;
164 // Used to load label
165 private final PackageManager mPm;
166 private final String mSystemLocaleStr;
167 private final InputMethodSettings mSettings;
168
169 public InputMethodAndSubtypeList(Context context, InputMethodSettings settings) {
170 mContext = context;
171 mSettings = settings;
172 mPm = context.getPackageManager();
173 final Locale locale = context.getResources().getConfiguration().locale;
174 mSystemLocaleStr = locale != null ? locale.toString() : "";
175 }
176
177 private final TreeMap<InputMethodInfo, List<InputMethodSubtype>> mSortedImmis =
178 new TreeMap<InputMethodInfo, List<InputMethodSubtype>>(
179 new Comparator<InputMethodInfo>() {
180 @Override
181 public int compare(InputMethodInfo imi1, InputMethodInfo imi2) {
182 if (imi2 == null)
183 return 0;
184 if (imi1 == null)
185 return 1;
186 if (mPm == null) {
187 return imi1.getId().compareTo(imi2.getId());
188 }
189 CharSequence imiId1 = imi1.loadLabel(mPm) + "/" + imi1.getId();
190 CharSequence imiId2 = imi2.loadLabel(mPm) + "/" + imi2.getId();
191 return imiId1.toString().compareTo(imiId2.toString());
192 }
193 });
194
195 public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeList() {
196 return getSortedInputMethodAndSubtypeList(true, false, false);
197 }
198
199 public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeList(
200 boolean showSubtypes, boolean includeAuxiliarySubtypes, boolean isScreenLocked) {
201 final ArrayList<ImeSubtypeListItem> imList =
202 new ArrayList<ImeSubtypeListItem>();
203 final HashMap<InputMethodInfo, List<InputMethodSubtype>> immis =
204 mSettings.getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked(
205 mContext);
206 if (immis == null || immis.size() == 0) {
207 return Collections.emptyList();
208 }
209 if (isScreenLocked && includeAuxiliarySubtypes) {
210 if (DEBUG) {
211 Slog.w(TAG, "Auxiliary subtypes are not allowed to be shown in lock screen.");
212 }
213 includeAuxiliarySubtypes = false;
214 }
215 mSortedImmis.clear();
216 mSortedImmis.putAll(immis);
217 for (InputMethodInfo imi : mSortedImmis.keySet()) {
218 if (imi == null) {
219 continue;
220 }
221 List<InputMethodSubtype> explicitlyOrImplicitlyEnabledSubtypeList = immis.get(imi);
222 HashSet<String> enabledSubtypeSet = new HashSet<String>();
223 for (InputMethodSubtype subtype : explicitlyOrImplicitlyEnabledSubtypeList) {
224 enabledSubtypeSet.add(String.valueOf(subtype.hashCode()));
225 }
226 final CharSequence imeLabel = imi.loadLabel(mPm);
227 if (showSubtypes && enabledSubtypeSet.size() > 0) {
228 final int subtypeCount = imi.getSubtypeCount();
229 if (DEBUG) {
230 Slog.v(TAG, "Add subtypes: " + subtypeCount + ", " + imi.getId());
231 }
232 for (int j = 0; j < subtypeCount; ++j) {
233 final InputMethodSubtype subtype = imi.getSubtypeAt(j);
234 final String subtypeHashCode = String.valueOf(subtype.hashCode());
235 // We show all enabled IMEs and subtypes when an IME is shown.
236 if (enabledSubtypeSet.contains(subtypeHashCode)
237 && (includeAuxiliarySubtypes || !subtype.isAuxiliary())) {
238 final CharSequence subtypeLabel =
239 subtype.overridesImplicitlyEnabledSubtype() ? null : subtype
240 .getDisplayName(mContext, imi.getPackageName(),
241 imi.getServiceInfo().applicationInfo);
242 imList.add(new ImeSubtypeListItem(imeLabel,
243 subtypeLabel, imi, j, subtype.getLocale(), mSystemLocaleStr));
244
245 // Removing this subtype from enabledSubtypeSet because we no
246 // longer need to add an entry of this subtype to imList to avoid
247 // duplicated entries.
248 enabledSubtypeSet.remove(subtypeHashCode);
249 }
250 }
251 } else {
252 imList.add(new ImeSubtypeListItem(imeLabel, null, imi, NOT_A_SUBTYPE_ID, null,
253 mSystemLocaleStr));
254 }
255 }
256 Collections.sort(imList);
257 return imList;
258 }
259 }
260
261 private static int calculateSubtypeId(InputMethodInfo imi, InputMethodSubtype subtype) {
262 return subtype != null ? InputMethodUtils.getSubtypeIdFromHashCode(imi,
263 subtype.hashCode()) : NOT_A_SUBTYPE_ID;
264 }
265
266 private static class StaticRotationList {
267 private final List<ImeSubtypeListItem> mImeSubtypeList;
268 public StaticRotationList(final List<ImeSubtypeListItem> imeSubtypeList) {
269 mImeSubtypeList = imeSubtypeList;
270 }
271
272 /**
273 * Returns the index of the specified input method and subtype in the given list.
274 * @param imi The {@link InputMethodInfo} to be searched.
275 * @param subtype The {@link InputMethodSubtype} to be searched. null if the input method
276 * does not have a subtype.
277 * @return The index in the given list. -1 if not found.
278 */
279 private int getIndex(InputMethodInfo imi, InputMethodSubtype subtype) {
280 final int currentSubtypeId = calculateSubtypeId(imi, subtype);
281 final int N = mImeSubtypeList.size();
282 for (int i = 0; i < N; ++i) {
283 final ImeSubtypeListItem isli = mImeSubtypeList.get(i);
284 // Skip until the current IME/subtype is found.
285 if (imi.equals(isli.mImi) && isli.mSubtypeId == currentSubtypeId) {
286 return i;
287 }
288 }
289 return -1;
290 }
291
292 public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme,
293 InputMethodInfo imi, InputMethodSubtype subtype) {
294 if (imi == null) {
295 return null;
296 }
297 if (mImeSubtypeList.size() <= 1) {
298 return null;
299 }
300 final int currentIndex = getIndex(imi, subtype);
301 if (currentIndex < 0) {
302 return null;
303 }
304 final int N = mImeSubtypeList.size();
305 for (int offset = 1; offset < N; ++offset) {
306 // Start searching the next IME/subtype from the next of the current index.
307 final int candidateIndex = (currentIndex + offset) % N;
308 final ImeSubtypeListItem candidate = mImeSubtypeList.get(candidateIndex);
309 // Skip if searching inside the current IME only, but the candidate is not
310 // the current IME.
311 if (onlyCurrentIme && !imi.equals(candidate.mImi)) {
312 continue;
313 }
314 return candidate;
315 }
316 return null;
317 }
318
319 protected void dump(final Printer pw, final String prefix) {
320 final int N = mImeSubtypeList.size();
321 for (int i = 0; i < N; ++i) {
322 final int rank = i;
323 final ImeSubtypeListItem item = mImeSubtypeList.get(i);
324 pw.println(prefix + "rank=" + rank + " item=" + item);
325 }
326 }
327 }
328
329 private static class DynamicRotationList {
330 private static final String TAG = DynamicRotationList.class.getSimpleName();
331 private final List<ImeSubtypeListItem> mImeSubtypeList;
332 private final int[] mUsageHistoryOfSubtypeListItemIndex;
333
334 private DynamicRotationList(final List<ImeSubtypeListItem> imeSubtypeListItems) {
335 mImeSubtypeList = imeSubtypeListItems;
336 mUsageHistoryOfSubtypeListItemIndex = new int[mImeSubtypeList.size()];
337 final int N = mImeSubtypeList.size();
338 for (int i = 0; i < N; i++) {
339 mUsageHistoryOfSubtypeListItemIndex[i] = i;
340 }
341 }
342
343 /**
344 * Returns the index of the specified object in
345 * {@link #mUsageHistoryOfSubtypeListItemIndex}.
346 * <p>We call the index of {@link #mUsageHistoryOfSubtypeListItemIndex} as "Usage Rank"
347 * so as not to be confused with the index in {@link #mImeSubtypeList}.
348 * @return -1 when the specified item doesn't belong to {@link #mImeSubtypeList} actually.
349 */
350 private int getUsageRank(final InputMethodInfo imi, InputMethodSubtype subtype) {
351 final int currentSubtypeId = calculateSubtypeId(imi, subtype);
352 final int N = mUsageHistoryOfSubtypeListItemIndex.length;
353 for (int usageRank = 0; usageRank < N; usageRank++) {
354 final int subtypeListItemIndex = mUsageHistoryOfSubtypeListItemIndex[usageRank];
355 final ImeSubtypeListItem subtypeListItem =
356 mImeSubtypeList.get(subtypeListItemIndex);
357 if (subtypeListItem.mImi.equals(imi) &&
358 subtypeListItem.mSubtypeId == currentSubtypeId) {
359 return usageRank;
360 }
361 }
362 // Not found in the known IME/Subtype list.
363 return -1;
364 }
365
366 public void onUserAction(InputMethodInfo imi, InputMethodSubtype subtype) {
367 final int currentUsageRank = getUsageRank(imi, subtype);
368 // Do nothing if currentUsageRank == -1 (not found), or currentUsageRank == 0
369 if (currentUsageRank <= 0) {
370 return;
371 }
372 final int currentItemIndex = mUsageHistoryOfSubtypeListItemIndex[currentUsageRank];
373 System.arraycopy(mUsageHistoryOfSubtypeListItemIndex, 0,
374 mUsageHistoryOfSubtypeListItemIndex, 1, currentUsageRank);
375 mUsageHistoryOfSubtypeListItemIndex[0] = currentItemIndex;
376 }
377
378 public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme,
379 InputMethodInfo imi, InputMethodSubtype subtype) {
380 int currentUsageRank = getUsageRank(imi, subtype);
381 if (currentUsageRank < 0) {
382 if (DEBUG) {
383 Slog.d(TAG, "IME/subtype is not found: " + imi.getId() + ", " + subtype);
384 }
385 return null;
386 }
387 final int N = mUsageHistoryOfSubtypeListItemIndex.length;
388 for (int i = 1; i < N; i++) {
389 final int subtypeListItemRank = (currentUsageRank + i) % N;
390 final int subtypeListItemIndex =
391 mUsageHistoryOfSubtypeListItemIndex[subtypeListItemRank];
392 final ImeSubtypeListItem subtypeListItem =
393 mImeSubtypeList.get(subtypeListItemIndex);
394 if (onlyCurrentIme && !imi.equals(subtypeListItem.mImi)) {
395 continue;
396 }
397 return subtypeListItem;
398 }
399 return null;
400 }
401
402 protected void dump(final Printer pw, final String prefix) {
403 for (int i = 0; i < mUsageHistoryOfSubtypeListItemIndex.length; ++i) {
404 final int rank = mUsageHistoryOfSubtypeListItemIndex[i];
405 final ImeSubtypeListItem item = mImeSubtypeList.get(i);
406 pw.println(prefix + "rank=" + rank + " item=" + item);
407 }
408 }
409 }
410
411 @VisibleForTesting
412 public static class ControllerImpl {
413 private final DynamicRotationList mSwitchingAwareRotationList;
414 private final StaticRotationList mSwitchingUnawareRotationList;
415
416 public static ControllerImpl createFrom(final ControllerImpl currentInstance,
417 final List<ImeSubtypeListItem> sortedEnabledItems) {
418 DynamicRotationList switchingAwareRotationList = null;
419 {
420 final List<ImeSubtypeListItem> switchingAwareImeSubtypes =
421 filterImeSubtypeList(sortedEnabledItems,
422 true /* supportsSwitchingToNextInputMethod */);
423 if (currentInstance != null &&
424 currentInstance.mSwitchingAwareRotationList != null &&
425 Objects.equals(currentInstance.mSwitchingAwareRotationList.mImeSubtypeList,
426 switchingAwareImeSubtypes)) {
427 // Can reuse the current instance.
428 switchingAwareRotationList = currentInstance.mSwitchingAwareRotationList;
429 }
430 if (switchingAwareRotationList == null) {
431 switchingAwareRotationList = new DynamicRotationList(switchingAwareImeSubtypes);
432 }
433 }
434
435 StaticRotationList switchingUnawareRotationList = null;
436 {
437 final List<ImeSubtypeListItem> switchingUnawareImeSubtypes = filterImeSubtypeList(
438 sortedEnabledItems, false /* supportsSwitchingToNextInputMethod */);
439 if (currentInstance != null &&
440 currentInstance.mSwitchingUnawareRotationList != null &&
441 Objects.equals(
442 currentInstance.mSwitchingUnawareRotationList.mImeSubtypeList,
443 switchingUnawareImeSubtypes)) {
444 // Can reuse the current instance.
445 switchingUnawareRotationList = currentInstance.mSwitchingUnawareRotationList;
446 }
447 if (switchingUnawareRotationList == null) {
448 switchingUnawareRotationList =
449 new StaticRotationList(switchingUnawareImeSubtypes);
450 }
451 }
452
453 return new ControllerImpl(switchingAwareRotationList, switchingUnawareRotationList);
454 }
455
456 private ControllerImpl(final DynamicRotationList switchingAwareRotationList,
457 final StaticRotationList switchingUnawareRotationList) {
458 mSwitchingAwareRotationList = switchingAwareRotationList;
459 mSwitchingUnawareRotationList = switchingUnawareRotationList;
460 }
461
462 public ImeSubtypeListItem getNextInputMethod(boolean onlyCurrentIme, InputMethodInfo imi,
463 InputMethodSubtype subtype) {
464 if (imi == null) {
465 return null;
466 }
467 if (imi.supportsSwitchingToNextInputMethod()) {
468 return mSwitchingAwareRotationList.getNextInputMethodLocked(onlyCurrentIme, imi,
469 subtype);
470 } else {
471 return mSwitchingUnawareRotationList.getNextInputMethodLocked(onlyCurrentIme, imi,
472 subtype);
473 }
474 }
475
476 public void onUserActionLocked(InputMethodInfo imi, InputMethodSubtype subtype) {
477 if (imi == null) {
478 return;
479 }
480 if (imi.supportsSwitchingToNextInputMethod()) {
481 mSwitchingAwareRotationList.onUserAction(imi, subtype);
482 }
483 }
484
485 private static List<ImeSubtypeListItem> filterImeSubtypeList(
486 final List<ImeSubtypeListItem> items,
487 final boolean supportsSwitchingToNextInputMethod) {
488 final ArrayList<ImeSubtypeListItem> result = new ArrayList<>();
489 final int ALL_ITEMS_COUNT = items.size();
490 for (int i = 0; i < ALL_ITEMS_COUNT; i++) {
491 final ImeSubtypeListItem item = items.get(i);
492 if (item.mImi.supportsSwitchingToNextInputMethod() ==
493 supportsSwitchingToNextInputMethod) {
494 result.add(item);
495 }
496 }
497 return result;
498 }
499
500 protected void dump(final Printer pw) {
501 pw.println(" mSwitchingAwareRotationList:");
502 mSwitchingAwareRotationList.dump(pw, " ");
503 pw.println(" mSwitchingUnawareRotationList:");
504 mSwitchingUnawareRotationList.dump(pw, " ");
505 }
506 }
507
508 private final InputMethodSettings mSettings;
509 private InputMethodAndSubtypeList mSubtypeList;
510 private ControllerImpl mController;
511
512 private InputMethodSubtypeSwitchingController(InputMethodSettings settings, Context context) {
513 mSettings = settings;
514 resetCircularListLocked(context);
515 }
516
517 public static InputMethodSubtypeSwitchingController createInstanceLocked(
518 InputMethodSettings settings, Context context) {
519 return new InputMethodSubtypeSwitchingController(settings, context);
520 }
521
522 public void onUserActionLocked(InputMethodInfo imi, InputMethodSubtype subtype) {
523 if (mController == null) {
524 if (DEBUG) {
525 Log.e(TAG, "mController shouldn't be null.");
526 }
527 return;
528 }
529 mController.onUserActionLocked(imi, subtype);
530 }
531
532 public void resetCircularListLocked(Context context) {
533 mSubtypeList = new InputMethodAndSubtypeList(context, mSettings);
534 mController = ControllerImpl.createFrom(mController,
535 mSubtypeList.getSortedInputMethodAndSubtypeList());
536 }
537
538 public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme, InputMethodInfo imi,
539 InputMethodSubtype subtype) {
540 if (mController == null) {
541 if (DEBUG) {
542 Log.e(TAG, "mController shouldn't be null.");
543 }
544 return null;
545 }
546 return mController.getNextInputMethod(onlyCurrentIme, imi, subtype);
547 }
548
549 public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeListLocked(boolean showSubtypes,
550 boolean includingAuxiliarySubtypes, boolean isScreenLocked) {
551 return mSubtypeList.getSortedInputMethodAndSubtypeList(
552 showSubtypes, includingAuxiliarySubtypes, isScreenLocked);
553 }
554
555 public void dump(final Printer pw) {
556 if (mController != null) {
557 mController.dump(pw);
558 } else {
559 pw.println(" mController=null");
560 }
561 }
562 }
浙公网安备 33010602011771号