| /* |
| * Copyright (C) 2007-2008 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 android.view.inputmethod; |
| |
| import android.annotation.FlaggedApi; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.SuppressLint; |
| import android.annotation.SystemApi; |
| import android.annotation.TestApi; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.pm.ActivityInfo; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.PackageManager.NameNotFoundException; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.ServiceInfo; |
| import android.content.res.Configuration; |
| import android.content.res.Resources; |
| import android.content.res.Resources.NotFoundException; |
| import android.content.res.TypedArray; |
| import android.content.res.XmlResourceParser; |
| import android.graphics.drawable.Drawable; |
| import android.icu.util.ULocale; |
| import android.inputmethodservice.InputMethodService; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.text.TextUtils; |
| import android.util.AttributeSet; |
| import android.util.Printer; |
| import android.util.Slog; |
| import android.util.Xml; |
| import android.view.inputmethod.InputMethodSubtype.InputMethodSubtypeBuilder; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| /** |
| * This class is used to specify meta information of an input method. |
| * |
| * <p>It should be defined in an XML resource file with an {@code <input-method>} element. |
| * For more information, see the guide to |
| * <a href="{@docRoot}guide/topics/text/creating-input-method.html"> |
| * Creating an Input Method</a>.</p> |
| * |
| * @see InputMethodSubtype |
| * |
| * @attr ref android.R.styleable#InputMethod_settingsActivity |
| * @attr ref android.R.styleable#InputMethod_isDefault |
| * @attr ref android.R.styleable#InputMethod_supportsSwitchingToNextInputMethod |
| * @attr ref android.R.styleable#InputMethod_supportsInlineSuggestions |
| * @attr ref android.R.styleable#InputMethod_supportsInlineSuggestionsWithTouchExploration |
| * @attr ref android.R.styleable#InputMethod_suppressesSpellChecker |
| * @attr ref android.R.styleable#InputMethod_showInInputMethodPicker |
| * @attr ref android.R.styleable#InputMethod_configChanges |
| */ |
| public final class InputMethodInfo implements Parcelable { |
| |
| /** |
| * {@link Intent#getAction() Intent action} for IME that |
| * {@link #supportsStylusHandwriting() supports stylus handwriting}. |
| * |
| * @see #createStylusHandwritingSettingsActivityIntent() |
| */ |
| public static final String ACTION_STYLUS_HANDWRITING_SETTINGS = |
| "android.view.inputmethod.action.STYLUS_HANDWRITING_SETTINGS"; |
| |
| /** |
| * {@link Intent#getAction() Intent action} for the IME language settings. |
| * |
| * @see #createImeLanguageSettingsActivityIntent() |
| */ |
| @FlaggedApi(android.view.inputmethod.Flags.FLAG_IME_SWITCHER_REVAMP) |
| public static final String ACTION_IME_LANGUAGE_SETTINGS = |
| "android.view.inputmethod.action.IME_LANGUAGE_SETTINGS"; |
| |
| /** |
| * Maximal length of a component name |
| * @hide |
| */ |
| @TestApi |
| public static final int COMPONENT_NAME_MAX_LENGTH = 1000; |
| |
| /** |
| * The maximum amount of IMEs that are loaded per package (in order). |
| * If a package contains more IMEs, they will be ignored and cannot be enabled. |
| * @hide |
| */ |
| @TestApi |
| @SuppressLint("MinMaxConstant") |
| public static final int MAX_IMES_PER_PACKAGE = 20; |
| |
| static final String TAG = "InputMethodInfo"; |
| |
| /** |
| * The Service that implements this input method component. |
| */ |
| final ResolveInfo mService; |
| |
| /** |
| * IME only supports VR mode. |
| */ |
| final boolean mIsVrOnly; |
| |
| /** |
| * IME only supports virtual devices. |
| */ |
| final boolean mIsVirtualDeviceOnly; |
| |
| /** |
| * The unique string Id to identify the input method. This is generated |
| * from the input method component. |
| */ |
| final String mId; |
| |
| /** |
| * The input method setting activity's name, used by the system settings to |
| * launch the setting activity of this input method. |
| */ |
| final String mSettingsActivityName; |
| |
| /** |
| * The input method language settings activity's name, used to |
| * launch the language settings activity of this input method. |
| */ |
| @Nullable |
| private final String mLanguageSettingsActivityName; |
| |
| /** |
| * The resource in the input method's .apk that holds a boolean indicating |
| * whether it should be considered the default input method for this |
| * system. This is a resource ID instead of the final value so that it |
| * can change based on the configuration (in particular locale). |
| */ |
| final int mIsDefaultResId; |
| |
| /** |
| * An array-like container of the subtypes. |
| */ |
| @UnsupportedAppUsage |
| private final InputMethodSubtypeArray mSubtypes; |
| |
| private final boolean mIsAuxIme; |
| |
| /** |
| * Caveat: mForceDefault must be false for production. This flag is only for test. |
| */ |
| private final boolean mForceDefault; |
| |
| /** |
| * The flag whether this IME supports ways to switch to a next input method (e.g. globe key.) |
| */ |
| private final boolean mSupportsSwitchingToNextInputMethod; |
| |
| /** |
| * The flag whether this IME supports inline suggestions. |
| */ |
| private final boolean mInlineSuggestionsEnabled; |
| |
| /** |
| * The flag whether this IME supports inline suggestions when touch exploration is enabled. |
| */ |
| private final boolean mSupportsInlineSuggestionsWithTouchExploration; |
| |
| /** |
| * The flag whether this IME suppresses spell checker. |
| */ |
| private final boolean mSuppressesSpellChecker; |
| |
| /** |
| * The flag whether this IME should be shown as an option in the IME picker. |
| */ |
| private final boolean mShowInInputMethodPicker; |
| |
| /** |
| * The flag for configurations IME assumes the responsibility for handling in |
| * {@link InputMethodService#onConfigurationChanged(Configuration)}}. |
| */ |
| private final int mHandledConfigChanges; |
| |
| /** |
| * The flag whether this IME supports Handwriting using stylus input. |
| */ |
| private final boolean mSupportsStylusHandwriting; |
| |
| /** The flag whether this IME supports connectionless stylus handwriting sessions. */ |
| private final boolean mSupportsConnectionlessStylusHandwriting; |
| |
| /** |
| * The stylus handwriting setting activity's name, used by the system settings to |
| * launch the stylus handwriting specific setting activity of this input method. |
| */ |
| private final String mStylusHandwritingSettingsActivityAttr; |
| |
| /** |
| * @param service the {@link ResolveInfo} corresponds in which the IME is implemented. |
| * @return a unique ID to be returned by {@link #getId()}. We have used |
| * {@link ComponentName#flattenToShortString()} for this purpose (and it is already |
| * unrealistic to switch to a different scheme as it is already implicitly assumed in |
| * many places). |
| * @hide |
| */ |
| public static String computeId(@NonNull ResolveInfo service) { |
| final ServiceInfo si = service.serviceInfo; |
| return new ComponentName(si.packageName, si.name).flattenToShortString(); |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param context The Context in which we are parsing the input method. |
| * @param service The ResolveInfo returned from the package manager about |
| * this input method's component. |
| */ |
| public InputMethodInfo(Context context, ResolveInfo service) |
| throws XmlPullParserException, IOException { |
| this(context, service, null); |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param context The Context in which we are parsing the input method. |
| * @param service The ResolveInfo returned from the package manager about |
| * this input method's component. |
| * @param additionalSubtypes additional subtypes being added to this InputMethodInfo |
| * @hide |
| */ |
| public InputMethodInfo(Context context, ResolveInfo service, |
| List<InputMethodSubtype> additionalSubtypes) |
| throws XmlPullParserException, IOException { |
| mService = service; |
| ServiceInfo si = service.serviceInfo; |
| mId = computeId(service); |
| boolean isAuxIme = true; |
| boolean supportsSwitchingToNextInputMethod = false; // false as default |
| boolean inlineSuggestionsEnabled = false; // false as default |
| boolean supportsInlineSuggestionsWithTouchExploration = false; // false as default |
| boolean suppressesSpellChecker = false; // false as default |
| boolean showInInputMethodPicker = true; // true as default |
| mForceDefault = false; |
| |
| PackageManager pm = context.getPackageManager(); |
| String settingsActivityComponent = null; |
| String languageSettingsActivityComponent = null; |
| String stylusHandwritingSettingsActivity = null; |
| boolean isVrOnly; |
| boolean isVirtualDeviceOnly; |
| int isDefaultResId = 0; |
| |
| XmlResourceParser parser = null; |
| final ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>(); |
| try { |
| parser = si.loadXmlMetaData(pm, InputMethod.SERVICE_META_DATA); |
| if (parser == null) { |
| throw new XmlPullParserException("No " |
| + InputMethod.SERVICE_META_DATA + " meta-data"); |
| } |
| |
| Resources res = pm.getResourcesForApplication(si.applicationInfo); |
| |
| AttributeSet attrs = Xml.asAttributeSet(parser); |
| |
| int type; |
| while ((type=parser.next()) != XmlPullParser.END_DOCUMENT |
| && type != XmlPullParser.START_TAG) { |
| } |
| |
| String nodeName = parser.getName(); |
| if (!"input-method".equals(nodeName)) { |
| throw new XmlPullParserException( |
| "Meta-data does not start with input-method tag"); |
| } |
| |
| TypedArray sa = res.obtainAttributes(attrs, |
| com.android.internal.R.styleable.InputMethod); |
| settingsActivityComponent = sa.getString( |
| com.android.internal.R.styleable.InputMethod_settingsActivity); |
| if (Flags.imeSwitcherRevamp()) { |
| languageSettingsActivityComponent = sa.getString( |
| com.android.internal.R.styleable.InputMethod_languageSettingsActivity); |
| } |
| if ((si.name != null && si.name.length() > COMPONENT_NAME_MAX_LENGTH) |
| || (settingsActivityComponent != null |
| && settingsActivityComponent.length() |
| > COMPONENT_NAME_MAX_LENGTH) |
| || (languageSettingsActivityComponent != null |
| && languageSettingsActivityComponent.length() |
| > COMPONENT_NAME_MAX_LENGTH)) { |
| throw new XmlPullParserException( |
| "Activity name exceeds maximum of 1000 characters"); |
| } |
| |
| isVrOnly = sa.getBoolean(com.android.internal.R.styleable.InputMethod_isVrOnly, false); |
| isVirtualDeviceOnly = sa.getBoolean( |
| com.android.internal.R.styleable.InputMethod_isVirtualDeviceOnly, false); |
| isDefaultResId = sa.getResourceId( |
| com.android.internal.R.styleable.InputMethod_isDefault, 0); |
| supportsSwitchingToNextInputMethod = sa.getBoolean( |
| com.android.internal.R.styleable.InputMethod_supportsSwitchingToNextInputMethod, |
| false); |
| inlineSuggestionsEnabled = sa.getBoolean( |
| com.android.internal.R.styleable.InputMethod_supportsInlineSuggestions, false); |
| supportsInlineSuggestionsWithTouchExploration = sa.getBoolean( |
| com.android.internal.R.styleable |
| .InputMethod_supportsInlineSuggestionsWithTouchExploration, false); |
| suppressesSpellChecker = sa.getBoolean( |
| com.android.internal.R.styleable.InputMethod_suppressesSpellChecker, false); |
| showInInputMethodPicker = sa.getBoolean( |
| com.android.internal.R.styleable.InputMethod_showInInputMethodPicker, true); |
| mHandledConfigChanges = sa.getInt( |
| com.android.internal.R.styleable.InputMethod_configChanges, 0); |
| mSupportsStylusHandwriting = sa.getBoolean( |
| com.android.internal.R.styleable.InputMethod_supportsStylusHandwriting, false); |
| mSupportsConnectionlessStylusHandwriting = sa.getBoolean( |
| com.android.internal.R.styleable |
| .InputMethod_supportsConnectionlessStylusHandwriting, false); |
| stylusHandwritingSettingsActivity = sa.getString( |
| com.android.internal.R.styleable.InputMethod_stylusHandwritingSettingsActivity); |
| sa.recycle(); |
| |
| final int depth = parser.getDepth(); |
| // Parse all subtypes |
| while (((type = parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth) |
| && type != XmlPullParser.END_DOCUMENT) { |
| if (type == XmlPullParser.START_TAG) { |
| nodeName = parser.getName(); |
| if (!"subtype".equals(nodeName)) { |
| throw new XmlPullParserException( |
| "Meta-data in input-method does not start with subtype tag"); |
| } |
| final TypedArray a = res.obtainAttributes( |
| attrs, com.android.internal.R.styleable.InputMethod_Subtype); |
| String pkLanguageTag = a.getString(com.android.internal.R.styleable |
| .InputMethod_Subtype_physicalKeyboardHintLanguageTag); |
| String pkLayoutType = a.getString(com.android.internal.R.styleable |
| .InputMethod_Subtype_physicalKeyboardHintLayoutType); |
| final InputMethodSubtype subtype = new InputMethodSubtypeBuilder() |
| .setSubtypeNameResId(a.getResourceId(com.android.internal.R.styleable |
| .InputMethod_Subtype_label, 0)) |
| .setSubtypeIconResId(a.getResourceId(com.android.internal.R.styleable |
| .InputMethod_Subtype_icon, 0)) |
| .setPhysicalKeyboardHint( |
| pkLanguageTag == null ? null : new ULocale(pkLanguageTag), |
| pkLayoutType == null ? "" : pkLayoutType) |
| .setLanguageTag(a.getString(com.android.internal.R.styleable |
| .InputMethod_Subtype_languageTag)) |
| .setSubtypeLocale(a.getString(com.android.internal.R.styleable |
| .InputMethod_Subtype_imeSubtypeLocale)) |
| .setSubtypeMode(a.getString(com.android.internal.R.styleable |
| .InputMethod_Subtype_imeSubtypeMode)) |
| .setSubtypeExtraValue(a.getString(com.android.internal.R.styleable |
| .InputMethod_Subtype_imeSubtypeExtraValue)) |
| .setIsAuxiliary(a.getBoolean(com.android.internal.R.styleable |
| .InputMethod_Subtype_isAuxiliary, false)) |
| .setOverridesImplicitlyEnabledSubtype(a.getBoolean( |
| com.android.internal.R.styleable |
| .InputMethod_Subtype_overridesImplicitlyEnabledSubtype, false)) |
| .setSubtypeId(a.getInt(com.android.internal.R.styleable |
| .InputMethod_Subtype_subtypeId, 0 /* use Arrays.hashCode */)) |
| .setIsAsciiCapable(a.getBoolean(com.android.internal.R.styleable |
| .InputMethod_Subtype_isAsciiCapable, false)).build(); |
| a.recycle(); |
| if (!subtype.isAuxiliary()) { |
| isAuxIme = false; |
| } |
| subtypes.add(subtype); |
| } |
| } |
| } catch (NameNotFoundException | IndexOutOfBoundsException | NumberFormatException e) { |
| throw new XmlPullParserException( |
| "Unable to create context for: " + si.packageName); |
| } finally { |
| if (parser != null) parser.close(); |
| } |
| |
| if (subtypes.size() == 0) { |
| isAuxIme = false; |
| } |
| |
| if (additionalSubtypes != null) { |
| final int N = additionalSubtypes.size(); |
| for (int i = 0; i < N; ++i) { |
| final InputMethodSubtype subtype = additionalSubtypes.get(i); |
| if (!subtypes.contains(subtype)) { |
| subtypes.add(subtype); |
| } else { |
| Slog.w(TAG, "Duplicated subtype definition found: " |
| + subtype.getLocale() + ", " + subtype.getMode()); |
| } |
| } |
| } |
| mSubtypes = new InputMethodSubtypeArray(subtypes); |
| mSettingsActivityName = settingsActivityComponent; |
| mLanguageSettingsActivityName = languageSettingsActivityComponent; |
| mStylusHandwritingSettingsActivityAttr = stylusHandwritingSettingsActivity; |
| mIsDefaultResId = isDefaultResId; |
| mIsAuxIme = isAuxIme; |
| mSupportsSwitchingToNextInputMethod = supportsSwitchingToNextInputMethod; |
| mInlineSuggestionsEnabled = inlineSuggestionsEnabled; |
| mSupportsInlineSuggestionsWithTouchExploration = |
| supportsInlineSuggestionsWithTouchExploration; |
| mSuppressesSpellChecker = suppressesSpellChecker; |
| mShowInInputMethodPicker = showInInputMethodPicker; |
| mIsVrOnly = isVrOnly; |
| mIsVirtualDeviceOnly = isVirtualDeviceOnly; |
| } |
| |
| /** |
| * @hide |
| */ |
| public InputMethodInfo(InputMethodInfo source) { |
| this(source, Collections.emptyList()); |
| } |
| |
| /** |
| * @hide |
| */ |
| public InputMethodInfo(@NonNull InputMethodInfo source, |
| @NonNull List<InputMethodSubtype> additionalSubtypes) { |
| mId = source.mId; |
| mSettingsActivityName = source.mSettingsActivityName; |
| mLanguageSettingsActivityName = source.mLanguageSettingsActivityName; |
| mIsDefaultResId = source.mIsDefaultResId; |
| mIsAuxIme = source.mIsAuxIme; |
| mSupportsSwitchingToNextInputMethod = source.mSupportsSwitchingToNextInputMethod; |
| mInlineSuggestionsEnabled = source.mInlineSuggestionsEnabled; |
| mSupportsInlineSuggestionsWithTouchExploration = |
| source.mSupportsInlineSuggestionsWithTouchExploration; |
| mSuppressesSpellChecker = source.mSuppressesSpellChecker; |
| mShowInInputMethodPicker = source.mShowInInputMethodPicker; |
| mIsVrOnly = source.mIsVrOnly; |
| mIsVirtualDeviceOnly = source.mIsVirtualDeviceOnly; |
| mService = source.mService; |
| if (additionalSubtypes.isEmpty()) { |
| mSubtypes = source.mSubtypes; |
| } else { |
| final ArrayList<InputMethodSubtype> subtypes = source.mSubtypes.toList(); |
| final int additionalSubtypeCount = additionalSubtypes.size(); |
| for (int i = 0; i < additionalSubtypeCount; ++i) { |
| final InputMethodSubtype additionalSubtype = additionalSubtypes.get(i); |
| if (!subtypes.contains(additionalSubtype)) { |
| subtypes.add(additionalSubtype); |
| } |
| } |
| mSubtypes = new InputMethodSubtypeArray(subtypes); |
| } |
| mHandledConfigChanges = source.mHandledConfigChanges; |
| mSupportsStylusHandwriting = source.mSupportsStylusHandwriting; |
| mSupportsConnectionlessStylusHandwriting = source.mSupportsConnectionlessStylusHandwriting; |
| mForceDefault = source.mForceDefault; |
| mStylusHandwritingSettingsActivityAttr = source.mStylusHandwritingSettingsActivityAttr; |
| } |
| |
| InputMethodInfo(Parcel source) { |
| mId = source.readString(); |
| mSettingsActivityName = source.readString(); |
| mLanguageSettingsActivityName = source.readString8(); |
| mIsDefaultResId = source.readInt(); |
| mIsAuxIme = source.readInt() == 1; |
| mSupportsSwitchingToNextInputMethod = source.readInt() == 1; |
| mInlineSuggestionsEnabled = source.readInt() == 1; |
| mSupportsInlineSuggestionsWithTouchExploration = source.readInt() == 1; |
| mSuppressesSpellChecker = source.readBoolean(); |
| mShowInInputMethodPicker = source.readBoolean(); |
| mIsVrOnly = source.readBoolean(); |
| mIsVirtualDeviceOnly = source.readBoolean(); |
| mService = ResolveInfo.CREATOR.createFromParcel(source); |
| mSubtypes = new InputMethodSubtypeArray(source); |
| mHandledConfigChanges = source.readInt(); |
| mSupportsStylusHandwriting = source.readBoolean(); |
| mSupportsConnectionlessStylusHandwriting = source.readBoolean(); |
| mStylusHandwritingSettingsActivityAttr = source.readString8(); |
| mForceDefault = false; |
| } |
| |
| /** |
| * Temporary API for creating a built-in input method for test. |
| */ |
| public InputMethodInfo(String packageName, String className, |
| CharSequence label, String settingsActivity) { |
| this(buildFakeResolveInfo(packageName, className, label), false /* isAuxIme */, |
| settingsActivity, null /* languageSettingsActivity */, null /* subtypes */, |
| 0 /* isDefaultResId */, false /* forceDefault */, |
| true /* supportsSwitchingToNextInputMethod */, |
| false /* inlineSuggestionsEnabled */, false /* isVrOnly */, |
| false /* isVirtualDeviceOnly */, 0 /* handledConfigChanges */, |
| false /* supportsStylusHandwriting */, |
| false /* supportConnectionlessStylusHandwriting */, |
| null /* stylusHandwritingSettingsActivityAttr */, |
| false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Test API for creating a built-in input method to verify stylus handwriting. |
| * @hide |
| */ |
| @TestApi |
| public InputMethodInfo(@NonNull String packageName, @NonNull String className, |
| @NonNull CharSequence label, @NonNull String settingsActivity, |
| boolean supportStylusHandwriting, |
| @NonNull String stylusHandwritingSettingsActivityAttr) { |
| this(buildFakeResolveInfo(packageName, className, label), false /* isAuxIme */, |
| settingsActivity, null /* languageSettingsActivity */, |
| null /* subtypes */, 0 /* isDefaultResId */, |
| false /* forceDefault */, true /* supportsSwitchingToNextInputMethod */, |
| false /* inlineSuggestionsEnabled */, false /* isVrOnly */, |
| false /* isVirtualDeviceOnly */, 0 /* handledConfigChanges */, |
| supportStylusHandwriting, false /* supportConnectionlessStylusHandwriting */, |
| stylusHandwritingSettingsActivityAttr, false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Test API for creating a built-in input method to verify stylus handwriting. |
| * @hide |
| */ |
| @TestApi |
| public InputMethodInfo(@NonNull String packageName, @NonNull String className, |
| @NonNull CharSequence label, @NonNull String settingsActivity, |
| @NonNull String languageSettingsActivity, boolean supportStylusHandwriting, |
| @NonNull String stylusHandwritingSettingsActivityAttr) { |
| this(buildFakeResolveInfo(packageName, className, label), false /* isAuxIme */, |
| settingsActivity, languageSettingsActivity, null /* subtypes */, |
| 0 /* isDefaultResId */, false /* forceDefault */, |
| true /* supportsSwitchingToNextInputMethod */, |
| false /* inlineSuggestionsEnabled */, false /* isVrOnly */, |
| false /* isVirtualDeviceOnly */, 0 /* handledConfigChanges */, |
| supportStylusHandwriting, false /* supportConnectionlessStylusHandwriting */, |
| stylusHandwritingSettingsActivityAttr, false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Test API for creating a built-in input method to verify stylus handwriting. |
| * @hide |
| */ |
| @TestApi |
| @FlaggedApi(Flags.FLAG_CONNECTIONLESS_HANDWRITING) |
| public InputMethodInfo(@NonNull String packageName, @NonNull String className, |
| @NonNull CharSequence label, @NonNull String settingsActivity, |
| @NonNull String languageSettingsActivity, boolean supportStylusHandwriting, |
| boolean supportConnectionlessStylusHandwriting, |
| @NonNull String stylusHandwritingSettingsActivityAttr) { |
| this(buildFakeResolveInfo(packageName, className, label), false /* isAuxIme */, |
| settingsActivity, languageSettingsActivity, null /* subtypes */, |
| 0 /* isDefaultResId */, false /* forceDefault */, |
| true /* supportsSwitchingToNextInputMethod */, |
| false /* inlineSuggestionsEnabled */, false /* isVrOnly */, |
| false /* isVirtualDeviceOnly */, 0 /* handledConfigChanges */, |
| supportStylusHandwriting, supportConnectionlessStylusHandwriting, |
| stylusHandwritingSettingsActivityAttr, false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Temporary API for creating a built-in input method for test. |
| * @hide |
| */ |
| @TestApi |
| public InputMethodInfo(@NonNull String packageName, @NonNull String className, |
| @NonNull CharSequence label, @NonNull String settingsActivity, |
| int handledConfigChanges) { |
| this(buildFakeResolveInfo(packageName, className, label), false /* isAuxIme */, |
| settingsActivity, null /* languageSettingsActivity */, null /* subtypes */, |
| 0 /* isDefaultResId */, false /* forceDefault */, |
| true /* supportsSwitchingToNextInputMethod */, |
| false /* inlineSuggestionsEnabled */, false /* isVrOnly */, |
| false /* isVirtualDeviceOnly */, handledConfigChanges, |
| false /* supportsStylusHandwriting */, |
| false /* supportConnectionlessStylusHandwriting */, |
| null /* stylusHandwritingSettingsActivityAttr */, |
| false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Temporary API for creating a built-in input method for test. |
| * @hide |
| */ |
| public InputMethodInfo(ResolveInfo ri, boolean isAuxIme, |
| String settingsActivity, List<InputMethodSubtype> subtypes, int isDefaultResId, |
| boolean forceDefault) { |
| this(ri, isAuxIme, settingsActivity, null /* languageSettingsActivity */, subtypes, |
| isDefaultResId, forceDefault, |
| true /* supportsSwitchingToNextInputMethod */, false /* inlineSuggestionsEnabled */, |
| false /* isVrOnly */, false /* isVirtualDeviceOnly */, 0 /* handledconfigChanges */, |
| false /* supportsStylusHandwriting */, |
| false /* supportConnectionlessStylusHandwriting */, |
| null /* stylusHandwritingSettingsActivityAttr */, |
| false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Temporary API for creating a built-in input method for test. |
| * @hide |
| */ |
| public InputMethodInfo(ResolveInfo ri, boolean isAuxIme, String settingsActivity, |
| List<InputMethodSubtype> subtypes, int isDefaultResId, boolean forceDefault, |
| boolean supportsSwitchingToNextInputMethod, boolean isVrOnly) { |
| this(ri, isAuxIme, settingsActivity, null /* languageSettingsActivity */, subtypes, |
| isDefaultResId, forceDefault, |
| supportsSwitchingToNextInputMethod, false /* inlineSuggestionsEnabled */, isVrOnly, |
| false /* isVirtualDeviceOnly */, |
| 0 /* handledConfigChanges */, false /* supportsStylusHandwriting */, |
| false /* supportConnectionlessStylusHandwriting */, |
| null /* stylusHandwritingSettingsActivityAttr */, |
| false /* inlineSuggestionsEnabled */); |
| } |
| |
| /** |
| * Temporary API for creating a built-in input method for test. |
| * @hide |
| */ |
| public InputMethodInfo(ResolveInfo ri, boolean isAuxIme, String settingsActivity, |
| @Nullable String languageSettingsActivity, List<InputMethodSubtype> subtypes, |
| int isDefaultResId, boolean forceDefault, |
| boolean supportsSwitchingToNextInputMethod, boolean inlineSuggestionsEnabled, |
| boolean isVrOnly, boolean isVirtualDeviceOnly, int handledConfigChanges, |
| boolean supportsStylusHandwriting, boolean supportsConnectionlessStylusHandwriting, |
| String stylusHandwritingSettingsActivityAttr, |
| boolean supportsInlineSuggestionsWithTouchExploration) { |
| final ServiceInfo si = ri.serviceInfo; |
| mService = ri; |
| mId = new ComponentName(si.packageName, si.name).flattenToShortString(); |
| mSettingsActivityName = settingsActivity; |
| mLanguageSettingsActivityName = languageSettingsActivity; |
| mIsDefaultResId = isDefaultResId; |
| mIsAuxIme = isAuxIme; |
| mSubtypes = new InputMethodSubtypeArray(subtypes); |
| mForceDefault = forceDefault; |
| mSupportsSwitchingToNextInputMethod = supportsSwitchingToNextInputMethod; |
| mInlineSuggestionsEnabled = inlineSuggestionsEnabled; |
| mSupportsInlineSuggestionsWithTouchExploration = |
| supportsInlineSuggestionsWithTouchExploration; |
| mSuppressesSpellChecker = false; |
| mShowInInputMethodPicker = true; |
| mIsVrOnly = isVrOnly; |
| mIsVirtualDeviceOnly = isVirtualDeviceOnly; |
| mHandledConfigChanges = handledConfigChanges; |
| mSupportsStylusHandwriting = supportsStylusHandwriting; |
| mSupportsConnectionlessStylusHandwriting = supportsConnectionlessStylusHandwriting; |
| mStylusHandwritingSettingsActivityAttr = stylusHandwritingSettingsActivityAttr; |
| } |
| |
| private static ResolveInfo buildFakeResolveInfo(String packageName, String className, |
| CharSequence label) { |
| ResolveInfo ri = new ResolveInfo(); |
| ServiceInfo si = new ServiceInfo(); |
| ApplicationInfo ai = new ApplicationInfo(); |
| ai.packageName = packageName; |
| ai.enabled = true; |
| si.applicationInfo = ai; |
| si.enabled = true; |
| si.packageName = packageName; |
| si.name = className; |
| si.exported = true; |
| si.nonLocalizedLabel = label; |
| ri.serviceInfo = si; |
| return ri; |
| } |
| |
| /** |
| * @return a unique ID for this input method, which is guaranteed to be the same as the result |
| * of {@code getComponent().flattenToShortString()}. |
| * @see ComponentName#unflattenFromString(String) |
| */ |
| public String getId() { |
| return mId; |
| } |
| |
| /** |
| * Return the .apk package that implements this input method. |
| */ |
| public String getPackageName() { |
| return mService.serviceInfo.packageName; |
| } |
| |
| /** |
| * Return the class name of the service component that implements |
| * this input method. |
| */ |
| public String getServiceName() { |
| return mService.serviceInfo.name; |
| } |
| |
| /** |
| * Return the raw information about the Service implementing this |
| * input method. Do not modify the returned object. |
| */ |
| public ServiceInfo getServiceInfo() { |
| return mService.serviceInfo; |
| } |
| |
| /** |
| * Return the component of the service that implements this input |
| * method. |
| */ |
| public ComponentName getComponent() { |
| return new ComponentName(mService.serviceInfo.packageName, |
| mService.serviceInfo.name); |
| } |
| |
| /** |
| * Load the user-displayed label for this input method. |
| * |
| * @param pm Supply a PackageManager used to load the input method's |
| * resources. |
| */ |
| public CharSequence loadLabel(PackageManager pm) { |
| return mService.loadLabel(pm); |
| } |
| |
| /** |
| * Load the user-displayed icon for this input method. |
| * |
| * @param pm Supply a PackageManager used to load the input method's |
| * resources. |
| */ |
| public Drawable loadIcon(PackageManager pm) { |
| return mService.loadIcon(pm); |
| } |
| |
| /** |
| * Return the class name of an activity that provides a settings UI for |
| * the input method. You can launch this activity be starting it with |
| * an {@link android.content.Intent} whose action is MAIN and with an |
| * explicit {@link android.content.ComponentName} |
| * composed of {@link #getPackageName} and the class name returned here. |
| * |
| * <p>A null will be returned if there is no settings activity associated |
| * with the input method.</p> |
| * @see #createStylusHandwritingSettingsActivityIntent() |
| */ |
| public String getSettingsActivity() { |
| return mSettingsActivityName; |
| } |
| |
| /** |
| * Returns true if IME supports VR mode only. |
| * @hide |
| */ |
| public boolean isVrOnly() { |
| return mIsVrOnly; |
| } |
| |
| /** |
| * Returns true if IME supports only virtual devices. |
| * @hide |
| */ |
| @FlaggedApi(android.companion.virtual.flags.Flags.FLAG_VDM_CUSTOM_IME) |
| @SystemApi |
| public boolean isVirtualDeviceOnly() { |
| return mIsVirtualDeviceOnly; |
| } |
| |
| /** |
| * Return the count of the subtypes of Input Method. |
| */ |
| public int getSubtypeCount() { |
| return mSubtypes.getCount(); |
| } |
| |
| /** |
| * Return the Input Method's subtype at the specified index. |
| * |
| * @param index the index of the subtype to return. |
| */ |
| public InputMethodSubtype getSubtypeAt(int index) { |
| return mSubtypes.get(index); |
| } |
| |
| /** |
| * Return the resource identifier of a resource inside of this input |
| * method's .apk that determines whether it should be considered a |
| * default input method for the system. |
| */ |
| public int getIsDefaultResourceId() { |
| return mIsDefaultResId; |
| } |
| |
| /** |
| * Return whether or not this ime is a default ime or not. |
| * @hide |
| */ |
| @UnsupportedAppUsage |
| public boolean isDefault(Context context) { |
| if (mForceDefault) { |
| return true; |
| } |
| try { |
| if (getIsDefaultResourceId() == 0) { |
| return false; |
| } |
| final Resources res = context.createPackageContext(getPackageName(), 0).getResources(); |
| return res.getBoolean(getIsDefaultResourceId()); |
| } catch (NameNotFoundException | NotFoundException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Returns the bit mask of kinds of configuration changes that this IME |
| * can handle itself (without being restarted by the system). |
| * |
| * @attr ref android.R.styleable#InputMethod_configChanges |
| */ |
| @ActivityInfo.Config |
| public int getConfigChanges() { |
| return mHandledConfigChanges; |
| } |
| |
| /** |
| * Returns if IME supports handwriting using stylus input. |
| * @attr ref android.R.styleable#InputMethod_supportsStylusHandwriting |
| * @see #createStylusHandwritingSettingsActivityIntent() |
| */ |
| public boolean supportsStylusHandwriting() { |
| return mSupportsStylusHandwriting; |
| } |
| |
| /** |
| * Returns whether the IME supports connectionless stylus handwriting sessions. |
| * |
| * @attr ref android.R.styleable#InputMethod_supportsConnectionlessStylusHandwriting |
| */ |
| @FlaggedApi(Flags.FLAG_CONNECTIONLESS_HANDWRITING) |
| public boolean supportsConnectionlessStylusHandwriting() { |
| return mSupportsConnectionlessStylusHandwriting; |
| } |
| |
| /** |
| * Returns {@link Intent} for stylus handwriting settings activity with |
| * {@link Intent#getAction() Intent action} {@link #ACTION_STYLUS_HANDWRITING_SETTINGS} |
| * if IME {@link #supportsStylusHandwriting() supports stylus handwriting}, else |
| * <code>null</code> if there are no associated settings for stylus handwriting / handwriting |
| * is not supported or if |
| * {@link android.R.styleable#InputMethod_stylusHandwritingSettingsActivity} is not defined. |
| * |
| * <p>To launch stylus settings, use this method to get the {@link android.content.Intent} to |
| * launch the stylus handwriting settings activity.</p> |
| * <p>e.g.<pre><code>startActivity(createStylusHandwritingSettingsActivityIntent());</code> |
| * </pre></p> |
| * |
| * @attr ref R.styleable#InputMethod_stylusHandwritingSettingsActivity |
| * @see #getSettingsActivity() |
| * @see #supportsStylusHandwriting() |
| */ |
| @Nullable |
| public Intent createStylusHandwritingSettingsActivityIntent() { |
| if (TextUtils.isEmpty(mStylusHandwritingSettingsActivityAttr) |
| || !mSupportsStylusHandwriting) { |
| return null; |
| } |
| // TODO(b/210039666): consider returning null if component is not enabled. |
| return new Intent(ACTION_STYLUS_HANDWRITING_SETTINGS).setComponent( |
| new ComponentName(getServiceInfo().packageName, |
| mStylusHandwritingSettingsActivityAttr)); |
| } |
| |
| /** |
| * Returns {@link Intent} for IME language settings activity with |
| * {@link Intent#getAction() Intent action} {@link #ACTION_IME_LANGUAGE_SETTINGS}, |
| * else <code>null</code> if |
| * {@link android.R.styleable#InputMethod_languageSettingsActivity} is not defined. |
| * |
| * <p>To launch IME language settings, use this method to get the {@link Intent} to launch |
| * the IME language settings activity.</p> |
| * <p>e.g.<pre><code>startActivity(createImeLanguageSettingsActivityIntent());</code></pre></p> |
| * |
| * @attr ref R.styleable#InputMethod_languageSettingsActivity |
| */ |
| @FlaggedApi(android.view.inputmethod.Flags.FLAG_IME_SWITCHER_REVAMP) |
| @Nullable |
| public Intent createImeLanguageSettingsActivityIntent() { |
| if (TextUtils.isEmpty(mLanguageSettingsActivityName)) { |
| return null; |
| } |
| return new Intent(ACTION_IME_LANGUAGE_SETTINGS).setComponent( |
| new ComponentName(getServiceInfo().packageName, |
| mLanguageSettingsActivityName) |
| ); |
| } |
| |
| public void dump(Printer pw, String prefix) { |
| pw.println(prefix + "mId=" + mId |
| + " mSettingsActivityName=" + mSettingsActivityName |
| + " mLanguageSettingsActivityName=" + mLanguageSettingsActivityName |
| + " mIsVrOnly=" + mIsVrOnly |
| + " mIsVirtualDeviceOnly=" + mIsVirtualDeviceOnly |
| + " mSupportsSwitchingToNextInputMethod=" + mSupportsSwitchingToNextInputMethod |
| + " mInlineSuggestionsEnabled=" + mInlineSuggestionsEnabled |
| + " mSupportsInlineSuggestionsWithTouchExploration=" |
| + mSupportsInlineSuggestionsWithTouchExploration |
| + " mSuppressesSpellChecker=" + mSuppressesSpellChecker |
| + " mShowInInputMethodPicker=" + mShowInInputMethodPicker |
| + " mSupportsStylusHandwriting=" + mSupportsStylusHandwriting |
| + " mSupportsConnectionlessStylusHandwriting=" |
| + mSupportsConnectionlessStylusHandwriting |
| + " mStylusHandwritingSettingsActivityAttr=" |
| + mStylusHandwritingSettingsActivityAttr); |
| pw.println(prefix + "mIsDefaultResId=0x" |
| + Integer.toHexString(mIsDefaultResId)); |
| pw.println(prefix + "Service:"); |
| mService.dump(pw, prefix + " "); |
| pw.println(prefix + "InputMethodSubtype array: count=" + mSubtypes.getCount()); |
| mSubtypes.dump(pw, prefix + " "); |
| } |
| |
| @Override |
| public String toString() { |
| return "InputMethodInfo{" + mId |
| + ", settings: " + mSettingsActivityName |
| + ", languageSettings: " + mLanguageSettingsActivityName |
| + "}"; |
| } |
| |
| /** |
| * Used to test whether the given parameter object is an |
| * {@link InputMethodInfo} and its Id is the same to this one. |
| * |
| * @return true if the given parameter object is an |
| * {@link InputMethodInfo} and its Id is the same to this one. |
| */ |
| @Override |
| public boolean equals(@Nullable Object o) { |
| if (o == this) return true; |
| if (o == null) return false; |
| |
| if (!(o instanceof InputMethodInfo)) return false; |
| |
| InputMethodInfo obj = (InputMethodInfo) o; |
| return mId.equals(obj.mId); |
| } |
| |
| @Override |
| public int hashCode() { |
| return mId.hashCode(); |
| } |
| |
| /** |
| * @hide |
| * @return {@code true} if the IME is a trusted system component (e.g. pre-installed) |
| */ |
| public boolean isSystem() { |
| return (mService.serviceInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0; |
| } |
| |
| /** |
| * @hide |
| */ |
| public boolean isAuxiliaryIme() { |
| return mIsAuxIme; |
| } |
| |
| /** |
| * @return true if this input method supports ways to switch to a next input method. |
| * @hide |
| */ |
| public boolean supportsSwitchingToNextInputMethod() { |
| return mSupportsSwitchingToNextInputMethod; |
| } |
| |
| /** |
| * @return true if this input method supports inline suggestions. |
| * @hide |
| */ |
| public boolean isInlineSuggestionsEnabled() { |
| return mInlineSuggestionsEnabled; |
| } |
| |
| /** |
| * Returns {@code true} if this input method supports inline suggestions when touch exploration |
| * is enabled. |
| * @hide |
| */ |
| public boolean supportsInlineSuggestionsWithTouchExploration() { |
| return mSupportsInlineSuggestionsWithTouchExploration; |
| } |
| |
| /** |
| * Return {@code true} if this input method suppresses spell checker. |
| */ |
| public boolean suppressesSpellChecker() { |
| return mSuppressesSpellChecker; |
| } |
| |
| /** |
| * Returns {@code true} if this input method should be shown in menus for selecting an Input |
| * Method, such as the system Input Method Picker. This is {@code false} if the IME is intended |
| * to be accessed programmatically. |
| */ |
| public boolean shouldShowInInputMethodPicker() { |
| return mShowInInputMethodPicker; |
| } |
| |
| /** |
| * Used to package this object into a {@link Parcel}. |
| * |
| * @param dest The {@link Parcel} to be written. |
| * @param flags The flags used for parceling. |
| */ |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| dest.writeString(mId); |
| dest.writeString(mSettingsActivityName); |
| dest.writeString8(mLanguageSettingsActivityName); |
| dest.writeInt(mIsDefaultResId); |
| dest.writeInt(mIsAuxIme ? 1 : 0); |
| dest.writeInt(mSupportsSwitchingToNextInputMethod ? 1 : 0); |
| dest.writeInt(mInlineSuggestionsEnabled ? 1 : 0); |
| dest.writeInt(mSupportsInlineSuggestionsWithTouchExploration ? 1 : 0); |
| dest.writeBoolean(mSuppressesSpellChecker); |
| dest.writeBoolean(mShowInInputMethodPicker); |
| dest.writeBoolean(mIsVrOnly); |
| dest.writeBoolean(mIsVirtualDeviceOnly); |
| mService.writeToParcel(dest, flags); |
| mSubtypes.writeToParcel(dest); |
| dest.writeInt(mHandledConfigChanges); |
| dest.writeBoolean(mSupportsStylusHandwriting); |
| dest.writeBoolean(mSupportsConnectionlessStylusHandwriting); |
| dest.writeString8(mStylusHandwritingSettingsActivityAttr); |
| } |
| |
| /** |
| * Used to make this class parcelable. |
| */ |
| public static final @android.annotation.NonNull Parcelable.Creator<InputMethodInfo> CREATOR |
| = new Parcelable.Creator<InputMethodInfo>() { |
| @Override |
| public InputMethodInfo createFromParcel(Parcel source) { |
| return new InputMethodInfo(source); |
| } |
| |
| @Override |
| public InputMethodInfo[] newArray(int size) { |
| return new InputMethodInfo[size]; |
| } |
| }; |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| } |
