core/java/com/android/internal/inputmethod/InputMethodSubtypeSwitchingController.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.internal.inputmethod;

 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.Slog;
 import android.view.inputmethod.InputMethodInfo;
 import android.view.inputmethod.InputMethodSubtype;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.inputmethod.InputMethodUtils.InputMethodSettings;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.TreeMap;

 /**
  * InputMethodSubtypeSwitchingController controls the switching behavior of the subtypes.
  * <p>
  * This class is designed to be used from and only from {@link InputMethodManagerService} by using
  * {@link InputMethodManagerService#mMethodMap} as a global lock.
  * </p>
  */
 public class InputMethodSubtypeSwitchingController {
     private static final String TAG = InputMethodSubtypeSwitchingController.class.getSimpleName();
     private static final boolean DEBUG = false;
     private static final int NOT_A_SUBTYPE_ID = InputMethodUtils.NOT_A_SUBTYPE_ID;

     public static class ImeSubtypeListItem implements Comparable<ImeSubtypeListItem> {
         public final CharSequence mImeName;
         public final CharSequence mSubtypeName;
         public final InputMethodInfo mImi;
         public final int mSubtypeId;
         private final boolean mIsSystemLocale;
         private final boolean mIsSystemLanguage;

         public ImeSubtypeListItem(CharSequence imeName, CharSequence subtypeName,
                 InputMethodInfo imi, int subtypeId, String subtypeLocale, String systemLocale) {
             mImeName = imeName;
             mSubtypeName = subtypeName;
             mImi = imi;
             mSubtypeId = subtypeId;
             if (TextUtils.isEmpty(subtypeLocale)) {
                 mIsSystemLocale = false;
                 mIsSystemLanguage = false;
             } else {
                 mIsSystemLocale = subtypeLocale.equals(systemLocale);
                 mIsSystemLanguage = mIsSystemLocale
                         || subtypeLocale.startsWith(systemLocale.substring(0, 2));
             }
         }

         @Override
         public int compareTo(ImeSubtypeListItem other) {
             if (TextUtils.isEmpty(mImeName)) {
                 return 1;
             }
             if (TextUtils.isEmpty(other.mImeName)) {
                 return -1;
             }
             if (!TextUtils.equals(mImeName, other.mImeName)) {
                 return mImeName.toString().compareTo(other.mImeName.toString());
             }
             if (TextUtils.equals(mSubtypeName, other.mSubtypeName)) {
                 return 0;
             }
             if (mIsSystemLocale) {
                 return -1;
             }
             if (other.mIsSystemLocale) {
                 return 1;
             }
             if (mIsSystemLanguage) {
                 return -1;
             }
             if (other.mIsSystemLanguage) {
                 return 1;
             }
             if (TextUtils.isEmpty(mSubtypeName)) {
                 return 1;
             }
             if (TextUtils.isEmpty(other.mSubtypeName)) {
                 return -1;
             }
             return mSubtypeName.toString().compareTo(other.mSubtypeName.toString());
         }

         @Override
         public String toString() {
             return "ImeSubtypeListItem{"
                     + "mImeName=" + mImeName
                     + " mSubtypeName=" + mSubtypeName
                     + " mSubtypeId=" + mSubtypeId
                     + " mIsSystemLocale=" + mIsSystemLocale
                     + " mIsSystemLanguage=" + mIsSystemLanguage
                     + "}";
         }
     }

     private static class InputMethodAndSubtypeList {
         private final Context mContext;
         // Used to load label
         private final PackageManager mPm;
         private final String mSystemLocaleStr;
         private final InputMethodSettings mSettings;

         public InputMethodAndSubtypeList(Context context, InputMethodSettings settings) {
             mContext = context;
             mSettings = settings;
             mPm = context.getPackageManager();
             final Locale locale = context.getResources().getConfiguration().locale;
             mSystemLocaleStr = locale != null ? locale.toString() : "";
         }

         private final TreeMap<InputMethodInfo, List<InputMethodSubtype>> mSortedImmis =
                 new TreeMap<InputMethodInfo, List<InputMethodSubtype>>(
                         new Comparator<InputMethodInfo>() {
                             @Override
                             public int compare(InputMethodInfo imi1, InputMethodInfo imi2) {
                                 if (imi2 == null)
                                     return 0;
                                 if (imi1 == null)
                                     return 1;
                                 if (mPm == null) {
                                     return imi1.getId().compareTo(imi2.getId());
                                 }
                                 CharSequence imiId1 = imi1.loadLabel(mPm) + "/" + imi1.getId();
                                 CharSequence imiId2 = imi2.loadLabel(mPm) + "/" + imi2.getId();
                                 return imiId1.toString().compareTo(imiId2.toString());
                             }
                         });

         public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeList() {
             return getSortedInputMethodAndSubtypeList(true, false, false);
         }

         public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeList(
                 boolean showSubtypes, boolean inputShown, boolean isScreenLocked) {
             final ArrayList<ImeSubtypeListItem> imList =
                     new ArrayList<ImeSubtypeListItem>();
             final HashMap<InputMethodInfo, List<InputMethodSubtype>> immis =
                     mSettings.getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked(
                             mContext);
             if (immis == null || immis.size() == 0) {
                 return Collections.emptyList();
             }
             mSortedImmis.clear();
             mSortedImmis.putAll(immis);
             for (InputMethodInfo imi : mSortedImmis.keySet()) {
                 if (imi == null) {
                     continue;
                 }
                 List<InputMethodSubtype> explicitlyOrImplicitlyEnabledSubtypeList = immis.get(imi);
                 HashSet<String> enabledSubtypeSet = new HashSet<String>();
                 for (InputMethodSubtype subtype : explicitlyOrImplicitlyEnabledSubtypeList) {
                     enabledSubtypeSet.add(String.valueOf(subtype.hashCode()));
                 }
                 final CharSequence imeLabel = imi.loadLabel(mPm);
                 if (showSubtypes && enabledSubtypeSet.size() > 0) {
                     final int subtypeCount = imi.getSubtypeCount();
                     if (DEBUG) {
                         Slog.v(TAG, "Add subtypes: " + subtypeCount + ", " + imi.getId());
                     }
                     for (int j = 0; j < subtypeCount; ++j) {
                         final InputMethodSubtype subtype = imi.getSubtypeAt(j);
                         final String subtypeHashCode = String.valueOf(subtype.hashCode());
                         // We show all enabled IMEs and subtypes when an IME is shown.
                         if (enabledSubtypeSet.contains(subtypeHashCode)
                                 && ((inputShown && !isScreenLocked) || !subtype.isAuxiliary())) {
                             final CharSequence subtypeLabel =
                                     subtype.overridesImplicitlyEnabledSubtype() ? null : subtype
                                             .getDisplayName(mContext, imi.getPackageName(),
                                                     imi.getServiceInfo().applicationInfo);
                             imList.add(new ImeSubtypeListItem(imeLabel,
                                     subtypeLabel, imi, j, subtype.getLocale(), mSystemLocaleStr));

                             // Removing this subtype from enabledSubtypeSet because we no
                             // longer need to add an entry of this subtype to imList to avoid
                             // duplicated entries.
                             enabledSubtypeSet.remove(subtypeHashCode);
                         }
                     }
                 } else {
                     imList.add(new ImeSubtypeListItem(imeLabel, null, imi, NOT_A_SUBTYPE_ID, null,
                             mSystemLocaleStr));
                 }
             }
             Collections.sort(imList);
             return imList;
         }
     }

     private static int calculateSubtypeId(InputMethodInfo imi, InputMethodSubtype subtype) {
         return subtype != null ? InputMethodUtils.getSubtypeIdFromHashCode(imi,
                 subtype.hashCode()) : NOT_A_SUBTYPE_ID;
     }

     private static class StaticRotationList {
         private final List<ImeSubtypeListItem> mImeSubtypeList;
         public StaticRotationList(final List<ImeSubtypeListItem> imeSubtypeList) {
             mImeSubtypeList = imeSubtypeList;
         }

         /**
          * Returns the index of the specified input method and subtype in the given list.
          * @param imi The {@link InputMethodInfo} to be searched.
          * @param subtype The {@link InputMethodSubtype} to be searched. null if the input method
          * does not have a subtype.
          * @return The index in the given list. -1 if not found.
          */
         private int getIndex(InputMethodInfo imi, InputMethodSubtype subtype) {
             final int currentSubtypeId = calculateSubtypeId(imi, subtype);
             final int N = mImeSubtypeList.size();
             for (int i = 0; i < N; ++i) {
                 final ImeSubtypeListItem isli = mImeSubtypeList.get(i);
                 // Skip until the current IME/subtype is found.
                 if (imi.equals(isli.mImi) && isli.mSubtypeId == currentSubtypeId) {
                     return i;
                 }
             }
             return -1;
         }

         public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme,
                 InputMethodInfo imi, InputMethodSubtype subtype) {
             if (imi == null) {
                 return null;
             }
             if (mImeSubtypeList.size() <= 1) {
                 return null;
             }
             final int currentIndex = getIndex(imi, subtype);
             if (currentIndex < 0) {
                 return null;
             }
             final int N = mImeSubtypeList.size();
             for (int offset = 1; offset < N; ++offset) {
                 // Start searching the next IME/subtype from the next of the current index.
                 final int candidateIndex = (currentIndex + offset) % N;
                 final ImeSubtypeListItem candidate = mImeSubtypeList.get(candidateIndex);
                 // Skip if searching inside the current IME only, but the candidate is not
                 // the current IME.
                 if (onlyCurrentIme && !imi.equals(candidate.mImi)) {
                     continue;
                 }
                 return candidate;
             }
             return null;
         }
     }

     private static class DynamicRotationList {
         private static final String TAG = DynamicRotationList.class.getSimpleName();
         private final List<ImeSubtypeListItem> mImeSubtypeList;
         private final int[] mUsageHistoryOfSubtypeListItemIndex;

         public DynamicRotationList(final List<ImeSubtypeListItem> imeSubtypeListItems) {
             mImeSubtypeList = imeSubtypeListItems;
             mUsageHistoryOfSubtypeListItemIndex = new int[mImeSubtypeList.size()];
             final int N = mImeSubtypeList.size();
             for (int i = 0; i < N; i++) {
                 mUsageHistoryOfSubtypeListItemIndex[i] = i;
             }
         }

         /**
          * Returns the index of the specified object in
          * {@link #mUsageHistoryOfSubtypeListItemIndex}.
          * <p>We call the index of {@link #mUsageHistoryOfSubtypeListItemIndex} as "Usage Rank"
          * so as not to be confused with the index in {@link #mImeSubtypeList}.
          * @return -1 when the specified item doesn't belong to {@link #mImeSubtypeList} actually.
          */
         private int getUsageRank(final InputMethodInfo imi, InputMethodSubtype subtype) {
             final int currentSubtypeId = calculateSubtypeId(imi, subtype);
             final int N = mUsageHistoryOfSubtypeListItemIndex.length;
             for (int usageRank = 0; usageRank < N; usageRank++) {
                 final int subtypeListItemIndex = mUsageHistoryOfSubtypeListItemIndex[usageRank];
                 final ImeSubtypeListItem subtypeListItem =
                         mImeSubtypeList.get(subtypeListItemIndex);
                 if (subtypeListItem.mImi.equals(imi) &&
                         subtypeListItem.mSubtypeId == currentSubtypeId) {
                     return usageRank;
                 }
             }
             // Not found in the known IME/Subtype list.
             return -1;
         }

         public void onUserAction(InputMethodInfo imi, InputMethodSubtype subtype) {
             final int currentUsageRank = getUsageRank(imi, subtype);
             // Do nothing if currentUsageRank == -1 (not found), or currentUsageRank == 0
             if (currentUsageRank <= 0) {
                 return;
             }
             final int currentItemIndex = mUsageHistoryOfSubtypeListItemIndex[currentUsageRank];
             System.arraycopy(mUsageHistoryOfSubtypeListItemIndex, 0,
                     mUsageHistoryOfSubtypeListItemIndex, 1, currentUsageRank);
             mUsageHistoryOfSubtypeListItemIndex[0] = currentItemIndex;
         }

         public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme,
                 InputMethodInfo imi, InputMethodSubtype subtype) {
             int currentUsageRank = getUsageRank(imi, subtype);
             if (currentUsageRank < 0) {
                 if (DEBUG) {
                     Slog.d(TAG, "IME/subtype is not found: " + imi.getId() + ", " + subtype);
                 }
                 return null;
             }
             final int N = mUsageHistoryOfSubtypeListItemIndex.length;
             for (int i = 1; i < N; i++) {
                 final int subtypeListItemRank = (currentUsageRank + i) % N;
                 final int subtypeListItemIndex =
                         mUsageHistoryOfSubtypeListItemIndex[subtypeListItemRank];
                 final ImeSubtypeListItem subtypeListItem =
                         mImeSubtypeList.get(subtypeListItemIndex);
                 if (onlyCurrentIme && !imi.equals(subtypeListItem.mImi)) {
                     continue;
                 }
                 return subtypeListItem;
             }
             return null;
         }
     }

     @VisibleForTesting
     public static class ControllerImpl {
         // TODO: Switch to DynamicRotationList for smarter rotation.
         private final StaticRotationList mSwitchingAwareSubtypeList;
         private final StaticRotationList mSwitchingUnawareSubtypeList;

         public ControllerImpl(final List<ImeSubtypeListItem> sortedItems) {
             mSwitchingAwareSubtypeList = new StaticRotationList(filterImeSubtypeList(sortedItems,
                     true /* supportsSwitchingToNextInputMethod */));
             mSwitchingUnawareSubtypeList = new StaticRotationList(filterImeSubtypeList(sortedItems,
                     false /* supportsSwitchingToNextInputMethod */));
         }

         public ImeSubtypeListItem getNextInputMethod(boolean onlyCurrentIme, InputMethodInfo imi,
                 InputMethodSubtype subtype) {
             if (imi == null) {
                 return null;
             }
             if (imi.supportsSwitchingToNextInputMethod()) {
                 return mSwitchingAwareSubtypeList.getNextInputMethodLocked(onlyCurrentIme, imi,
                         subtype);
             } else {
                 return mSwitchingUnawareSubtypeList.getNextInputMethodLocked(onlyCurrentIme, imi,
                         subtype);
             }
         }

         public void onUserActionLocked(InputMethodInfo imi, InputMethodSubtype subtype) {
             if (imi == null) {
                 return;
             }
             // TODO: Enable the following code when DynamicRotationList is enabled.
             // if (imi.supportsSwitchingToNextInputMethod()) {
             //     mSwitchingAwareSubtypeList.onUserAction(imi, subtype);
             // }
         }

         private static List<ImeSubtypeListItem> filterImeSubtypeList(
                 final List<ImeSubtypeListItem> items,
                 final boolean supportsSwitchingToNextInputMethod) {
             final ArrayList<ImeSubtypeListItem> result = new ArrayList<>();
             final int ALL_ITEMS_COUNT = items.size();
             for (int i = 0; i < ALL_ITEMS_COUNT; i++) {
                 final ImeSubtypeListItem item = items.get(i);
                 if (item.mImi.supportsSwitchingToNextInputMethod() ==
                         supportsSwitchingToNextInputMethod) {
                     result.add(item);
                 }
             }
             return result;
         }
     }

     private final InputMethodSettings mSettings;
     private InputMethodAndSubtypeList mSubtypeList;
     private ControllerImpl mController;

     private InputMethodSubtypeSwitchingController(InputMethodSettings settings, Context context) {
         mSettings = settings;
         resetCircularListLocked(context);
     }

     public static InputMethodSubtypeSwitchingController createInstanceLocked(
             InputMethodSettings settings, Context context) {
         return new InputMethodSubtypeSwitchingController(settings, context);
     }

     public void onCommitTextLocked(InputMethodInfo imi, InputMethodSubtype subtype) {
         if (mController == null) {
             if (DEBUG) {
                 Log.e(TAG, "mController shouldn't be null.");
             }
             return;
         }
         mController.onUserActionLocked(imi, subtype);
     }

     public void resetCircularListLocked(Context context) {
         mSubtypeList = new InputMethodAndSubtypeList(context, mSettings);
         mController = new ControllerImpl(mSubtypeList.getSortedInputMethodAndSubtypeList());
     }

     public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme, InputMethodInfo imi,
             InputMethodSubtype subtype) {
         if (mController == null) {
             if (DEBUG) {
                 Log.e(TAG, "mController shouldn't be null.");
             }
             return null;
         }
         return mController.getNextInputMethod(onlyCurrentIme, imi, subtype);
     }

     public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeListLocked(boolean showSubtypes,
             boolean inputShown, boolean isScreenLocked) {
         return mSubtypeList.getSortedInputMethodAndSubtypeList(
                 showSubtypes, inputShown, isScreenLocked);
     }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.internal.inputmethod;

	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.text.TextUtils;
	import android.util.Log;
	import android.util.Slog;
	import android.view.inputmethod.InputMethodInfo;
	import android.view.inputmethod.InputMethodSubtype;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.inputmethod.InputMethodUtils.InputMethodSettings;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Locale;
	import java.util.TreeMap;

	/**
	* InputMethodSubtypeSwitchingController controls the switching behavior of the subtypes.
	* <p>
	* This class is designed to be used from and only from {@link InputMethodManagerService} by using
	* {@link InputMethodManagerService#mMethodMap} as a global lock.
	* </p>
	*/
	public class InputMethodSubtypeSwitchingController {
	private static final String TAG = InputMethodSubtypeSwitchingController.class.getSimpleName();
	private static final boolean DEBUG = false;
	private static final int NOT_A_SUBTYPE_ID = InputMethodUtils.NOT_A_SUBTYPE_ID;

	public static class ImeSubtypeListItem implements Comparable<ImeSubtypeListItem> {
	public final CharSequence mImeName;
	public final CharSequence mSubtypeName;
	public final InputMethodInfo mImi;
	public final int mSubtypeId;
	private final boolean mIsSystemLocale;
	private final boolean mIsSystemLanguage;

	public ImeSubtypeListItem(CharSequence imeName, CharSequence subtypeName,
	InputMethodInfo imi, int subtypeId, String subtypeLocale, String systemLocale) {
	mImeName = imeName;
	mSubtypeName = subtypeName;
	mImi = imi;
	mSubtypeId = subtypeId;
	if (TextUtils.isEmpty(subtypeLocale)) {
	mIsSystemLocale = false;
	mIsSystemLanguage = false;
	} else {
	mIsSystemLocale = subtypeLocale.equals(systemLocale);
	mIsSystemLanguage = mIsSystemLocale
	\|\| subtypeLocale.startsWith(systemLocale.substring(0, 2));
	}
	}

	@Override
	public int compareTo(ImeSubtypeListItem other) {
	if (TextUtils.isEmpty(mImeName)) {
	return 1;
	}
	if (TextUtils.isEmpty(other.mImeName)) {
	return -1;
	}
	if (!TextUtils.equals(mImeName, other.mImeName)) {
	return mImeName.toString().compareTo(other.mImeName.toString());
	}
	if (TextUtils.equals(mSubtypeName, other.mSubtypeName)) {
	return 0;
	}
	if (mIsSystemLocale) {
	return -1;
	}
	if (other.mIsSystemLocale) {
	return 1;
	}
	if (mIsSystemLanguage) {
	return -1;
	}
	if (other.mIsSystemLanguage) {
	return 1;
	}
	if (TextUtils.isEmpty(mSubtypeName)) {
	return 1;
	}
	if (TextUtils.isEmpty(other.mSubtypeName)) {
	return -1;
	}
	return mSubtypeName.toString().compareTo(other.mSubtypeName.toString());
	}

	@Override
	public String toString() {
	return "ImeSubtypeListItem{"
	+ "mImeName=" + mImeName
	+ " mSubtypeName=" + mSubtypeName
	+ " mSubtypeId=" + mSubtypeId
	+ " mIsSystemLocale=" + mIsSystemLocale
	+ " mIsSystemLanguage=" + mIsSystemLanguage
	+ "}";
	}
	}

	private static class InputMethodAndSubtypeList {
	private final Context mContext;
	// Used to load label
	private final PackageManager mPm;
	private final String mSystemLocaleStr;
	private final InputMethodSettings mSettings;

	public InputMethodAndSubtypeList(Context context, InputMethodSettings settings) {
	mContext = context;
	mSettings = settings;
	mPm = context.getPackageManager();
	final Locale locale = context.getResources().getConfiguration().locale;
	mSystemLocaleStr = locale != null ? locale.toString() : "";
	}

	private final TreeMap<InputMethodInfo, List<InputMethodSubtype>> mSortedImmis =
	new TreeMap<InputMethodInfo, List<InputMethodSubtype>>(
	new Comparator<InputMethodInfo>() {
	@Override
	public int compare(InputMethodInfo imi1, InputMethodInfo imi2) {
	if (imi2 == null)
	return 0;
	if (imi1 == null)
	return 1;
	if (mPm == null) {
	return imi1.getId().compareTo(imi2.getId());
	}
	CharSequence imiId1 = imi1.loadLabel(mPm) + "/" + imi1.getId();
	CharSequence imiId2 = imi2.loadLabel(mPm) + "/" + imi2.getId();
	return imiId1.toString().compareTo(imiId2.toString());
	}
	});

	public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeList() {
	return getSortedInputMethodAndSubtypeList(true, false, false);
	}

	public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeList(
	boolean showSubtypes, boolean inputShown, boolean isScreenLocked) {
	final ArrayList<ImeSubtypeListItem> imList =
	new ArrayList<ImeSubtypeListItem>();
	final HashMap<InputMethodInfo, List<InputMethodSubtype>> immis =
	mSettings.getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked(
	mContext);
	if (immis == null \|\| immis.size() == 0) {
	return Collections.emptyList();
	}
	mSortedImmis.clear();
	mSortedImmis.putAll(immis);
	for (InputMethodInfo imi : mSortedImmis.keySet()) {
	if (imi == null) {
	continue;
	}
	List<InputMethodSubtype> explicitlyOrImplicitlyEnabledSubtypeList = immis.get(imi);
	HashSet<String> enabledSubtypeSet = new HashSet<String>();
	for (InputMethodSubtype subtype : explicitlyOrImplicitlyEnabledSubtypeList) {
	enabledSubtypeSet.add(String.valueOf(subtype.hashCode()));
	}
	final CharSequence imeLabel = imi.loadLabel(mPm);
	if (showSubtypes && enabledSubtypeSet.size() > 0) {
	final int subtypeCount = imi.getSubtypeCount();
	if (DEBUG) {
	Slog.v(TAG, "Add subtypes: " + subtypeCount + ", " + imi.getId());
	}
	for (int j = 0; j < subtypeCount; ++j) {
	final InputMethodSubtype subtype = imi.getSubtypeAt(j);
	final String subtypeHashCode = String.valueOf(subtype.hashCode());
	// We show all enabled IMEs and subtypes when an IME is shown.
	if (enabledSubtypeSet.contains(subtypeHashCode)
	&& ((inputShown && !isScreenLocked) \|\| !subtype.isAuxiliary())) {
	final CharSequence subtypeLabel =
	subtype.overridesImplicitlyEnabledSubtype() ? null : subtype
	.getDisplayName(mContext, imi.getPackageName(),
	imi.getServiceInfo().applicationInfo);
	imList.add(new ImeSubtypeListItem(imeLabel,
	subtypeLabel, imi, j, subtype.getLocale(), mSystemLocaleStr));

	// Removing this subtype from enabledSubtypeSet because we no
	// longer need to add an entry of this subtype to imList to avoid
	// duplicated entries.
	enabledSubtypeSet.remove(subtypeHashCode);
	}
	}
	} else {
	imList.add(new ImeSubtypeListItem(imeLabel, null, imi, NOT_A_SUBTYPE_ID, null,
	mSystemLocaleStr));
	}
	}
	Collections.sort(imList);
	return imList;
	}
	}

	private static int calculateSubtypeId(InputMethodInfo imi, InputMethodSubtype subtype) {
	return subtype != null ? InputMethodUtils.getSubtypeIdFromHashCode(imi,
	subtype.hashCode()) : NOT_A_SUBTYPE_ID;
	}

	private static class StaticRotationList {
	private final List<ImeSubtypeListItem> mImeSubtypeList;
	public StaticRotationList(final List<ImeSubtypeListItem> imeSubtypeList) {
	mImeSubtypeList = imeSubtypeList;
	}

	/**
	* Returns the index of the specified input method and subtype in the given list.
	* @param imi The {@link InputMethodInfo} to be searched.
	* @param subtype The {@link InputMethodSubtype} to be searched. null if the input method
	* does not have a subtype.
	* @return The index in the given list. -1 if not found.
	*/
	private int getIndex(InputMethodInfo imi, InputMethodSubtype subtype) {
	final int currentSubtypeId = calculateSubtypeId(imi, subtype);
	final int N = mImeSubtypeList.size();
	for (int i = 0; i < N; ++i) {
	final ImeSubtypeListItem isli = mImeSubtypeList.get(i);
	// Skip until the current IME/subtype is found.
	if (imi.equals(isli.mImi) && isli.mSubtypeId == currentSubtypeId) {
	return i;
	}
	}
	return -1;
	}

	public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme,
	InputMethodInfo imi, InputMethodSubtype subtype) {
	if (imi == null) {
	return null;
	}
	if (mImeSubtypeList.size() <= 1) {
	return null;
	}
	final int currentIndex = getIndex(imi, subtype);
	if (currentIndex < 0) {
	return null;
	}
	final int N = mImeSubtypeList.size();
	for (int offset = 1; offset < N; ++offset) {
	// Start searching the next IME/subtype from the next of the current index.
	final int candidateIndex = (currentIndex + offset) % N;
	final ImeSubtypeListItem candidate = mImeSubtypeList.get(candidateIndex);
	// Skip if searching inside the current IME only, but the candidate is not
	// the current IME.
	if (onlyCurrentIme && !imi.equals(candidate.mImi)) {
	continue;
	}
	return candidate;
	}
	return null;
	}
	}

	private static class DynamicRotationList {
	private static final String TAG = DynamicRotationList.class.getSimpleName();
	private final List<ImeSubtypeListItem> mImeSubtypeList;
	private final int[] mUsageHistoryOfSubtypeListItemIndex;

	public DynamicRotationList(final List<ImeSubtypeListItem> imeSubtypeListItems) {
	mImeSubtypeList = imeSubtypeListItems;
	mUsageHistoryOfSubtypeListItemIndex = new int[mImeSubtypeList.size()];
	final int N = mImeSubtypeList.size();
	for (int i = 0; i < N; i++) {
	mUsageHistoryOfSubtypeListItemIndex[i] = i;
	}
	}

	/**
	* Returns the index of the specified object in
	* {@link #mUsageHistoryOfSubtypeListItemIndex}.
	* <p>We call the index of {@link #mUsageHistoryOfSubtypeListItemIndex} as "Usage Rank"
	* so as not to be confused with the index in {@link #mImeSubtypeList}.
	* @return -1 when the specified item doesn't belong to {@link #mImeSubtypeList} actually.
	*/
	private int getUsageRank(final InputMethodInfo imi, InputMethodSubtype subtype) {
	final int currentSubtypeId = calculateSubtypeId(imi, subtype);
	final int N = mUsageHistoryOfSubtypeListItemIndex.length;
	for (int usageRank = 0; usageRank < N; usageRank++) {
	final int subtypeListItemIndex = mUsageHistoryOfSubtypeListItemIndex[usageRank];
	final ImeSubtypeListItem subtypeListItem =
	mImeSubtypeList.get(subtypeListItemIndex);
	if (subtypeListItem.mImi.equals(imi) &&
	subtypeListItem.mSubtypeId == currentSubtypeId) {
	return usageRank;
	}
	}
	// Not found in the known IME/Subtype list.
	return -1;
	}

	public void onUserAction(InputMethodInfo imi, InputMethodSubtype subtype) {
	final int currentUsageRank = getUsageRank(imi, subtype);
	// Do nothing if currentUsageRank == -1 (not found), or currentUsageRank == 0
	if (currentUsageRank <= 0) {
	return;
	}
	final int currentItemIndex = mUsageHistoryOfSubtypeListItemIndex[currentUsageRank];
	System.arraycopy(mUsageHistoryOfSubtypeListItemIndex, 0,
	mUsageHistoryOfSubtypeListItemIndex, 1, currentUsageRank);
	mUsageHistoryOfSubtypeListItemIndex[0] = currentItemIndex;
	}

	public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme,
	InputMethodInfo imi, InputMethodSubtype subtype) {
	int currentUsageRank = getUsageRank(imi, subtype);
	if (currentUsageRank < 0) {
	if (DEBUG) {
	Slog.d(TAG, "IME/subtype is not found: " + imi.getId() + ", " + subtype);
	}
	return null;
	}
	final int N = mUsageHistoryOfSubtypeListItemIndex.length;
	for (int i = 1; i < N; i++) {
	final int subtypeListItemRank = (currentUsageRank + i) % N;
	final int subtypeListItemIndex =
	mUsageHistoryOfSubtypeListItemIndex[subtypeListItemRank];
	final ImeSubtypeListItem subtypeListItem =
	mImeSubtypeList.get(subtypeListItemIndex);
	if (onlyCurrentIme && !imi.equals(subtypeListItem.mImi)) {
	continue;
	}
	return subtypeListItem;
	}
	return null;
	}
	}

	@VisibleForTesting
	public static class ControllerImpl {
	// TODO: Switch to DynamicRotationList for smarter rotation.
	private final StaticRotationList mSwitchingAwareSubtypeList;
	private final StaticRotationList mSwitchingUnawareSubtypeList;

	public ControllerImpl(final List<ImeSubtypeListItem> sortedItems) {
	mSwitchingAwareSubtypeList = new StaticRotationList(filterImeSubtypeList(sortedItems,
	true /* supportsSwitchingToNextInputMethod */));
	mSwitchingUnawareSubtypeList = new StaticRotationList(filterImeSubtypeList(sortedItems,
	false /* supportsSwitchingToNextInputMethod */));
	}

	public ImeSubtypeListItem getNextInputMethod(boolean onlyCurrentIme, InputMethodInfo imi,
	InputMethodSubtype subtype) {
	if (imi == null) {
	return null;
	}
	if (imi.supportsSwitchingToNextInputMethod()) {
	return mSwitchingAwareSubtypeList.getNextInputMethodLocked(onlyCurrentIme, imi,
	subtype);
	} else {
	return mSwitchingUnawareSubtypeList.getNextInputMethodLocked(onlyCurrentIme, imi,
	subtype);
	}
	}

	public void onUserActionLocked(InputMethodInfo imi, InputMethodSubtype subtype) {
	if (imi == null) {
	return;
	}
	// TODO: Enable the following code when DynamicRotationList is enabled.
	// if (imi.supportsSwitchingToNextInputMethod()) {
	// mSwitchingAwareSubtypeList.onUserAction(imi, subtype);
	// }
	}

	private static List<ImeSubtypeListItem> filterImeSubtypeList(
	final List<ImeSubtypeListItem> items,
	final boolean supportsSwitchingToNextInputMethod) {
	final ArrayList<ImeSubtypeListItem> result = new ArrayList<>();
	final int ALL_ITEMS_COUNT = items.size();
	for (int i = 0; i < ALL_ITEMS_COUNT; i++) {
	final ImeSubtypeListItem item = items.get(i);
	if (item.mImi.supportsSwitchingToNextInputMethod() ==
	supportsSwitchingToNextInputMethod) {
	result.add(item);
	}
	}
	return result;
	}
	}

	private final InputMethodSettings mSettings;
	private InputMethodAndSubtypeList mSubtypeList;
	private ControllerImpl mController;

	private InputMethodSubtypeSwitchingController(InputMethodSettings settings, Context context) {
	mSettings = settings;
	resetCircularListLocked(context);
	}

	public static InputMethodSubtypeSwitchingController createInstanceLocked(
	InputMethodSettings settings, Context context) {
	return new InputMethodSubtypeSwitchingController(settings, context);
	}

	public void onCommitTextLocked(InputMethodInfo imi, InputMethodSubtype subtype) {
	if (mController == null) {
	if (DEBUG) {
	Log.e(TAG, "mController shouldn't be null.");
	}
	return;
	}
	mController.onUserActionLocked(imi, subtype);
	}

	public void resetCircularListLocked(Context context) {
	mSubtypeList = new InputMethodAndSubtypeList(context, mSettings);
	mController = new ControllerImpl(mSubtypeList.getSortedInputMethodAndSubtypeList());
	}

	public ImeSubtypeListItem getNextInputMethodLocked(boolean onlyCurrentIme, InputMethodInfo imi,
	InputMethodSubtype subtype) {
	if (mController == null) {
	if (DEBUG) {
	Log.e(TAG, "mController shouldn't be null.");
	}
	return null;
	}
	return mController.getNextInputMethod(onlyCurrentIme, imi, subtype);
	}

	public List<ImeSubtypeListItem> getSortedInputMethodAndSubtypeListLocked(boolean showSubtypes,
	boolean inputShown, boolean isScreenLocked) {
	return mSubtypeList.getSortedInputMethodAndSubtypeList(
	showSubtypes, inputShown, isScreenLocked);
	}
	}