| /* |
| * Copyright (C) 2011 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.textservice; |
| |
| import android.annotation.BinderThread; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.SuppressLint; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.os.Binder; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Message; |
| import android.os.Process; |
| import android.os.RemoteException; |
| import android.util.Log; |
| import android.view.inputmethod.InputMethodManager; |
| |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.textservice.ISpellCheckerSession; |
| import com.android.internal.textservice.ISpellCheckerSessionListener; |
| import com.android.internal.textservice.ITextServicesSessionListener; |
| |
| import dalvik.system.CloseGuard; |
| |
| import java.util.ArrayDeque; |
| import java.util.Locale; |
| import java.util.Queue; |
| import java.util.concurrent.Executor; |
| |
| /** |
| * The SpellCheckerSession interface provides the per client functionality of SpellCheckerService. |
| * |
| * |
| * <a name="Applications"></a> |
| * <h3>Applications</h3> |
| * |
| * <p>In most cases, applications that are using the standard |
| * {@link android.widget.TextView} or its subclasses will have little they need |
| * to do to work well with spell checker services. The main things you need to |
| * be aware of are:</p> |
| * |
| * <ul> |
| * <li> Properly set the {@link android.R.attr#inputType} in your editable |
| * text views, so that the spell checker will have enough context to help the |
| * user in editing text in them. |
| * </ul> |
| * |
| * <p>For the rare people amongst us writing client applications that use the spell checker service |
| * directly, you will need to use {@link #getSuggestions(TextInfo, int)} or |
| * {@link #getSuggestions(TextInfo[], int, boolean)} for obtaining results from the spell checker |
| * service by yourself.</p> |
| * |
| * <h3>Security</h3> |
| * |
| * <p>There are a lot of security issues associated with spell checkers, |
| * since they could monitor all the text being sent to them |
| * through, for instance, {@link android.widget.TextView}. |
| * The Android spell checker framework also allows |
| * arbitrary third party spell checkers, so care must be taken to restrict their |
| * selection and interactions.</p> |
| * |
| * <p>Here are some key points about the security architecture behind the |
| * spell checker framework:</p> |
| * |
| * <ul> |
| * <li>Only the system is allowed to directly access a spell checker framework's |
| * {@link android.service.textservice.SpellCheckerService} interface, via the |
| * {@link android.Manifest.permission#BIND_TEXT_SERVICE} permission. This is |
| * enforced in the system by not binding to a spell checker service that does |
| * not require this permission. |
| * |
| * <li>The user must explicitly enable a new spell checker in settings before |
| * they can be enabled, to confirm with the system that they know about it |
| * and want to make it available for use. |
| * </ul> |
| * |
| */ |
| public class SpellCheckerSession { |
| private static final String TAG = SpellCheckerSession.class.getSimpleName(); |
| private static final boolean DBG = false; |
| /** |
| * Name under which a SpellChecker service component publishes information about itself. |
| * This meta-data must reference an XML resource. |
| **/ |
| public static final String SERVICE_META_DATA = "android.view.textservice.scs"; |
| |
| private static final int MSG_ON_GET_SUGGESTION_MULTIPLE = 1; |
| private static final int MSG_ON_GET_SUGGESTION_MULTIPLE_FOR_SENTENCE = 2; |
| |
| private final InternalListener mInternalListener; |
| private final TextServicesManager mTextServicesManager; |
| private final SpellCheckerInfo mSpellCheckerInfo; |
| @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) |
| private final SpellCheckerSessionListener mSpellCheckerSessionListener; |
| private final SpellCheckerSessionListenerImpl mSpellCheckerSessionListenerImpl; |
| private final Executor mExecutor; |
| |
| private final CloseGuard mGuard = CloseGuard.get(); |
| |
| /** |
| * Constructor |
| * @hide |
| */ |
| public SpellCheckerSession( |
| SpellCheckerInfo info, TextServicesManager tsm, SpellCheckerSessionListener listener, |
| Executor executor) { |
| if (info == null || listener == null || tsm == null) { |
| throw new NullPointerException(); |
| } |
| mSpellCheckerInfo = info; |
| mSpellCheckerSessionListenerImpl = new SpellCheckerSessionListenerImpl(this); |
| mInternalListener = new InternalListener(mSpellCheckerSessionListenerImpl); |
| mTextServicesManager = tsm; |
| mSpellCheckerSessionListener = listener; |
| mExecutor = executor; |
| |
| mGuard.open("finishSession"); |
| } |
| |
| /** |
| * @return true if the connection to a text service of this session is disconnected and not |
| * alive. |
| */ |
| public boolean isSessionDisconnected() { |
| return mSpellCheckerSessionListenerImpl.isDisconnected(); |
| } |
| |
| /** |
| * Get the spell checker service info this spell checker session has. |
| * @return SpellCheckerInfo for the specified locale. |
| */ |
| public SpellCheckerInfo getSpellChecker() { |
| return mSpellCheckerInfo; |
| } |
| |
| /** |
| * Cancel pending and running spell check tasks |
| */ |
| public void cancel() { |
| mSpellCheckerSessionListenerImpl.cancel(); |
| } |
| |
| /** |
| * Finish this session and allow TextServicesManagerService to disconnect the bound spell |
| * checker. |
| */ |
| public void close() { |
| mGuard.close(); |
| mSpellCheckerSessionListenerImpl.close(); |
| mTextServicesManager.finishSpellCheckerService(mSpellCheckerSessionListenerImpl); |
| } |
| |
| /** |
| * Get suggestions from the specified sentences |
| * @param textInfos an array of text metadata for a spell checker |
| * @param suggestionsLimit the maximum number of suggestions that will be returned |
| */ |
| public void getSentenceSuggestions(TextInfo[] textInfos, int suggestionsLimit) { |
| final InputMethodManager imm = mTextServicesManager.getInputMethodManager(); |
| if (imm != null && imm.isInputMethodSuppressingSpellChecker()) { |
| handleOnGetSentenceSuggestionsMultiple(new SentenceSuggestionsInfo[0]); |
| return; |
| } |
| mSpellCheckerSessionListenerImpl.getSentenceSuggestionsMultiple( |
| textInfos, suggestionsLimit); |
| } |
| |
| /** |
| * Get candidate strings for a substring of the specified text. |
| * @param textInfo text metadata for a spell checker |
| * @param suggestionsLimit the maximum number of suggestions that will be returned |
| * @deprecated use {@link SpellCheckerSession#getSentenceSuggestions(TextInfo[], int)} instead |
| */ |
| @Deprecated |
| public void getSuggestions(TextInfo textInfo, int suggestionsLimit) { |
| getSuggestions(new TextInfo[] {textInfo}, suggestionsLimit, false); |
| } |
| |
| /** |
| * A batch process of getSuggestions |
| * @param textInfos an array of text metadata for a spell checker |
| * @param suggestionsLimit the maximum number of suggestions that will be returned |
| * @param sequentialWords true if textInfos can be treated as sequential words. |
| * @deprecated use {@link SpellCheckerSession#getSentenceSuggestions(TextInfo[], int)} instead |
| */ |
| @Deprecated |
| public void getSuggestions( |
| TextInfo[] textInfos, int suggestionsLimit, boolean sequentialWords) { |
| if (DBG) { |
| Log.w(TAG, "getSuggestions from " + mSpellCheckerInfo.getId()); |
| } |
| final InputMethodManager imm = mTextServicesManager.getInputMethodManager(); |
| if (imm != null && imm.isInputMethodSuppressingSpellChecker()) { |
| handleOnGetSuggestionsMultiple(new SuggestionsInfo[0]); |
| return; |
| } |
| mSpellCheckerSessionListenerImpl.getSuggestionsMultiple( |
| textInfos, suggestionsLimit, sequentialWords); |
| } |
| |
| void handleOnGetSuggestionsMultiple(SuggestionsInfo[] suggestionsInfos) { |
| mExecutor.execute(() -> mSpellCheckerSessionListener.onGetSuggestions(suggestionsInfos)); |
| } |
| |
| void handleOnGetSentenceSuggestionsMultiple(SentenceSuggestionsInfo[] suggestionsInfos) { |
| mExecutor.execute(() -> |
| mSpellCheckerSessionListener.onGetSentenceSuggestions(suggestionsInfos)); |
| } |
| |
| private static final class SpellCheckerSessionListenerImpl |
| extends ISpellCheckerSessionListener.Stub { |
| private static final int TASK_CANCEL = 1; |
| private static final int TASK_GET_SUGGESTIONS_MULTIPLE = 2; |
| private static final int TASK_CLOSE = 3; |
| private static final int TASK_GET_SUGGESTIONS_MULTIPLE_FOR_SENTENCE = 4; |
| private static String taskToString(int task) { |
| switch (task) { |
| case TASK_CANCEL: |
| return "TASK_CANCEL"; |
| case TASK_GET_SUGGESTIONS_MULTIPLE: |
| return "TASK_GET_SUGGESTIONS_MULTIPLE"; |
| case TASK_CLOSE: |
| return "TASK_CLOSE"; |
| case TASK_GET_SUGGESTIONS_MULTIPLE_FOR_SENTENCE: |
| return "TASK_GET_SUGGESTIONS_MULTIPLE_FOR_SENTENCE"; |
| default: |
| return "Unexpected task=" + task; |
| } |
| } |
| |
| private final Queue<SpellCheckerParams> mPendingTasks = new ArrayDeque<>(); |
| @GuardedBy("SpellCheckerSessionListenerImpl.this") |
| private SpellCheckerSession mSpellCheckerSession; |
| |
| private static final int STATE_WAIT_CONNECTION = 0; |
| private static final int STATE_CONNECTED = 1; |
| private static final int STATE_CLOSED_AFTER_CONNECTION = 2; |
| private static final int STATE_CLOSED_BEFORE_CONNECTION = 3; |
| private static String stateToString(int state) { |
| switch (state) { |
| case STATE_WAIT_CONNECTION: return "STATE_WAIT_CONNECTION"; |
| case STATE_CONNECTED: return "STATE_CONNECTED"; |
| case STATE_CLOSED_AFTER_CONNECTION: return "STATE_CLOSED_AFTER_CONNECTION"; |
| case STATE_CLOSED_BEFORE_CONNECTION: return "STATE_CLOSED_BEFORE_CONNECTION"; |
| default: return "Unexpected state=" + state; |
| } |
| } |
| private int mState = STATE_WAIT_CONNECTION; |
| |
| private ISpellCheckerSession mISpellCheckerSession; |
| private HandlerThread mThread; |
| private Handler mAsyncHandler; |
| |
| SpellCheckerSessionListenerImpl(SpellCheckerSession spellCheckerSession) { |
| mSpellCheckerSession = spellCheckerSession; |
| } |
| |
| private static class SpellCheckerParams { |
| public final int mWhat; |
| public final TextInfo[] mTextInfos; |
| public final int mSuggestionsLimit; |
| public final boolean mSequentialWords; |
| public ISpellCheckerSession mSession; |
| public SpellCheckerParams(int what, TextInfo[] textInfos, int suggestionsLimit, |
| boolean sequentialWords) { |
| mWhat = what; |
| mTextInfos = textInfos; |
| mSuggestionsLimit = suggestionsLimit; |
| mSequentialWords = sequentialWords; |
| } |
| } |
| |
| private void processTask(ISpellCheckerSession session, SpellCheckerParams scp, |
| boolean async) { |
| if (DBG) { |
| synchronized (this) { |
| Log.d(TAG, "entering processTask:" |
| + " session.hashCode()=#" + Integer.toHexString(session.hashCode()) |
| + " scp.mWhat=" + taskToString(scp.mWhat) + " async=" + async |
| + " mAsyncHandler=" + mAsyncHandler |
| + " mState=" + stateToString(mState)); |
| } |
| } |
| if (async || mAsyncHandler == null) { |
| switch (scp.mWhat) { |
| case TASK_CANCEL: |
| try { |
| session.onCancel(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to cancel " + e); |
| } |
| break; |
| case TASK_GET_SUGGESTIONS_MULTIPLE: |
| try { |
| session.onGetSuggestionsMultiple(scp.mTextInfos, |
| scp.mSuggestionsLimit, scp.mSequentialWords); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to get suggestions " + e); |
| } |
| break; |
| case TASK_GET_SUGGESTIONS_MULTIPLE_FOR_SENTENCE: |
| try { |
| session.onGetSentenceSuggestionsMultiple( |
| scp.mTextInfos, scp.mSuggestionsLimit); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to get suggestions " + e); |
| } |
| break; |
| case TASK_CLOSE: |
| try { |
| session.onClose(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to close " + e); |
| } |
| break; |
| } |
| } else { |
| // The interface is to a local object, so need to execute it |
| // asynchronously. |
| scp.mSession = session; |
| mAsyncHandler.sendMessage(Message.obtain(mAsyncHandler, 1, scp)); |
| } |
| |
| if (scp.mWhat == TASK_CLOSE) { |
| // If we are closing, we want to clean up our state now even |
| // if it is pending as an async operation. |
| synchronized (this) { |
| processCloseLocked(); |
| } |
| } |
| } |
| |
| @GuardedBy("SpellCheckerSessionListenerImpl.this") |
| private void processCloseLocked() { |
| if (DBG) Log.d(TAG, "entering processCloseLocked:" |
| + " session" + (mISpellCheckerSession != null ? ".hashCode()=#" |
| + Integer.toHexString(mISpellCheckerSession.hashCode()) : "=null") |
| + " mState=" + stateToString(mState)); |
| mISpellCheckerSession = null; |
| if (mThread != null) { |
| mThread.quit(); |
| } |
| mSpellCheckerSession = null; |
| mPendingTasks.clear(); |
| mThread = null; |
| mAsyncHandler = null; |
| switch (mState) { |
| case STATE_WAIT_CONNECTION: |
| mState = STATE_CLOSED_BEFORE_CONNECTION; |
| break; |
| case STATE_CONNECTED: |
| mState = STATE_CLOSED_AFTER_CONNECTION; |
| break; |
| default: |
| Log.e(TAG, "processCloseLocked is called unexpectedly. mState=" + |
| stateToString(mState)); |
| break; |
| } |
| } |
| |
| public void onServiceConnected(ISpellCheckerSession session) { |
| synchronized (this) { |
| switch (mState) { |
| case STATE_WAIT_CONNECTION: |
| // OK, go ahead. |
| break; |
| case STATE_CLOSED_BEFORE_CONNECTION: |
| // This is possible, and not an error. The client no longer is interested |
| // in this connection. OK to ignore. |
| if (DBG) Log.i(TAG, "ignoring onServiceConnected since the session is" |
| + " already closed."); |
| return; |
| default: |
| Log.e(TAG, "ignoring onServiceConnected due to unexpected mState=" |
| + stateToString(mState)); |
| return; |
| } |
| if (session == null) { |
| Log.e(TAG, "ignoring onServiceConnected due to session=null"); |
| return; |
| } |
| mISpellCheckerSession = session; |
| if (session.asBinder() instanceof Binder && mThread == null) { |
| if (DBG) Log.d(TAG, "starting HandlerThread in onServiceConnected."); |
| // If this is a local object, we need to do our own threading |
| // to make sure we handle it asynchronously. |
| mThread = new HandlerThread("SpellCheckerSession", |
| Process.THREAD_PRIORITY_BACKGROUND); |
| mThread.start(); |
| mAsyncHandler = new Handler(mThread.getLooper()) { |
| @Override public void handleMessage(Message msg) { |
| SpellCheckerParams scp = (SpellCheckerParams)msg.obj; |
| processTask(scp.mSession, scp, true); |
| } |
| }; |
| } |
| mState = STATE_CONNECTED; |
| if (DBG) { |
| Log.d(TAG, "processed onServiceConnected: mISpellCheckerSession.hashCode()=#" |
| + Integer.toHexString(mISpellCheckerSession.hashCode()) |
| + " mPendingTasks.size()=" + mPendingTasks.size()); |
| } |
| while (!mPendingTasks.isEmpty()) { |
| processTask(session, mPendingTasks.poll(), false); |
| } |
| } |
| } |
| |
| public void cancel() { |
| processOrEnqueueTask(new SpellCheckerParams(TASK_CANCEL, null, 0, false)); |
| } |
| |
| public void getSuggestionsMultiple( |
| TextInfo[] textInfos, int suggestionsLimit, boolean sequentialWords) { |
| processOrEnqueueTask( |
| new SpellCheckerParams(TASK_GET_SUGGESTIONS_MULTIPLE, textInfos, |
| suggestionsLimit, sequentialWords)); |
| } |
| |
| public void getSentenceSuggestionsMultiple(TextInfo[] textInfos, int suggestionsLimit) { |
| processOrEnqueueTask( |
| new SpellCheckerParams(TASK_GET_SUGGESTIONS_MULTIPLE_FOR_SENTENCE, |
| textInfos, suggestionsLimit, false)); |
| } |
| |
| public void close() { |
| processOrEnqueueTask(new SpellCheckerParams(TASK_CLOSE, null, 0, false)); |
| } |
| |
| public boolean isDisconnected() { |
| synchronized (this) { |
| return mState != STATE_CONNECTED; |
| } |
| } |
| |
| private void processOrEnqueueTask(SpellCheckerParams scp) { |
| ISpellCheckerSession session; |
| synchronized (this) { |
| if (scp.mWhat == TASK_CLOSE && (mState == STATE_CLOSED_AFTER_CONNECTION |
| || mState == STATE_CLOSED_BEFORE_CONNECTION)) { |
| // It is OK to call SpellCheckerSession#close() multiple times. |
| // Don't output confusing/misleading warning messages. |
| return; |
| } |
| if (mState != STATE_WAIT_CONNECTION && mState != STATE_CONNECTED) { |
| Log.e(TAG, "ignoring processOrEnqueueTask due to unexpected mState=" |
| + stateToString(mState) |
| + " scp.mWhat=" + taskToString(scp.mWhat)); |
| return; |
| } |
| |
| if (mState == STATE_WAIT_CONNECTION) { |
| // If we are still waiting for the connection. Need to pay special attention. |
| if (scp.mWhat == TASK_CLOSE) { |
| processCloseLocked(); |
| return; |
| } |
| // Enqueue the task to task queue. |
| SpellCheckerParams closeTask = null; |
| if (scp.mWhat == TASK_CANCEL) { |
| if (DBG) Log.d(TAG, "canceling pending tasks in processOrEnqueueTask."); |
| while (!mPendingTasks.isEmpty()) { |
| final SpellCheckerParams tmp = mPendingTasks.poll(); |
| if (tmp.mWhat == TASK_CLOSE) { |
| // Only one close task should be processed, while we need to remove |
| // all close tasks from the queue |
| closeTask = tmp; |
| } |
| } |
| } |
| mPendingTasks.offer(scp); |
| if (closeTask != null) { |
| mPendingTasks.offer(closeTask); |
| } |
| if (DBG) Log.d(TAG, "queueing tasks in processOrEnqueueTask since the" |
| + " connection is not established." |
| + " mPendingTasks.size()=" + mPendingTasks.size()); |
| return; |
| } |
| |
| session = mISpellCheckerSession; |
| } |
| // session must never be null here. |
| processTask(session, scp, false); |
| } |
| |
| @BinderThread |
| @Override |
| public void onGetSuggestions(SuggestionsInfo[] results) { |
| SpellCheckerSession session = getSpellCheckerSession(); |
| if (session != null) { |
| // Lock should not be held when calling callback, in order to avoid deadlock. |
| session.handleOnGetSuggestionsMultiple(results); |
| } |
| } |
| |
| @BinderThread |
| @Override |
| public void onGetSentenceSuggestions(SentenceSuggestionsInfo[] results) { |
| SpellCheckerSession session = getSpellCheckerSession(); |
| if (session != null) { |
| // Lock should not be held when calling callback, in order to avoid deadlock. |
| session.handleOnGetSentenceSuggestionsMultiple(results); |
| } |
| } |
| |
| @Nullable |
| private SpellCheckerSession getSpellCheckerSession() { |
| synchronized (SpellCheckerSessionListenerImpl.this) { |
| return mSpellCheckerSession; |
| } |
| } |
| } |
| |
| /** Parameters used to create a {@link SpellCheckerSession}. */ |
| public static class SpellCheckerSessionParams { |
| @Nullable |
| private final Locale mLocale; |
| private final boolean mShouldReferToSpellCheckerLanguageSettings; |
| private final @SuggestionsInfo.ResultAttrs int mSupportedAttributes; |
| private final Bundle mExtras; |
| |
| private SpellCheckerSessionParams(Locale locale, |
| boolean referToSpellCheckerLanguageSettings, int supportedAttributes, |
| Bundle extras) { |
| mLocale = locale; |
| mShouldReferToSpellCheckerLanguageSettings = referToSpellCheckerLanguageSettings; |
| mSupportedAttributes = supportedAttributes; |
| mExtras = extras; |
| } |
| |
| /** |
| * Returns the locale in which the spell checker should operate. |
| * |
| * @see android.service.textservice.SpellCheckerService.Session#getLocale() |
| */ |
| @SuppressLint("UseIcu") |
| @Nullable |
| public Locale getLocale() { |
| return mLocale; |
| } |
| |
| /** |
| * Returns true if the user's spell checker language settings should be used to determine |
| * the spell checker locale. |
| */ |
| public boolean shouldReferToSpellCheckerLanguageSettings() { |
| return mShouldReferToSpellCheckerLanguageSettings; |
| } |
| |
| /** |
| * Returns a bitmask of {@link SuggestionsInfo} attributes that the spell checker can set |
| * in {@link SuggestionsInfo} it returns. |
| * |
| * @see android.service.textservice.SpellCheckerService.Session#getSupportedAttributes() |
| */ |
| public @SuggestionsInfo.ResultAttrs int getSupportedAttributes() { |
| return mSupportedAttributes; |
| } |
| |
| /** |
| * Returns a bundle containing extra parameters for the spell checker. |
| * |
| * <p>This bundle can be used to pass implementation-specific parameters to the |
| * {@link android.service.textservice.SpellCheckerService} implementation. |
| * |
| * @see android.service.textservice.SpellCheckerService.Session#getBundle() |
| */ |
| @NonNull |
| public Bundle getExtras() { |
| return mExtras; |
| } |
| |
| /** Builder of {@link SpellCheckerSessionParams}. */ |
| public static final class Builder { |
| @Nullable |
| private Locale mLocale; |
| private boolean mShouldReferToSpellCheckerLanguageSettings = false; |
| private @SuggestionsInfo.ResultAttrs int mSupportedAttributes = 0; |
| private Bundle mExtras = Bundle.EMPTY; |
| |
| /** Constructs a {@code Builder}. */ |
| public Builder() { |
| } |
| |
| /** |
| * Returns constructed {@link SpellCheckerSession} instance. |
| * |
| * <p>Before calling this method, either {@link #setLocale(Locale)} should be called |
| * with a non-null locale or |
| * {@link #setShouldReferToSpellCheckerLanguageSettings(boolean)} should be called with |
| * {@code true}. |
| */ |
| @NonNull |
| public SpellCheckerSessionParams build() { |
| if (mLocale == null && !mShouldReferToSpellCheckerLanguageSettings) { |
| throw new IllegalArgumentException("mLocale should not be null if " |
| + " mShouldReferToSpellCheckerLanguageSettings is false."); |
| } |
| return new SpellCheckerSessionParams(mLocale, |
| mShouldReferToSpellCheckerLanguageSettings, mSupportedAttributes, mExtras); |
| } |
| |
| /** |
| * Sets the locale in which the spell checker should operate. |
| * |
| * @see android.service.textservice.SpellCheckerService.Session#getLocale() |
| */ |
| @NonNull |
| public Builder setLocale(@SuppressLint("UseIcu") @Nullable Locale locale) { |
| mLocale = locale; |
| return this; |
| } |
| |
| /** |
| * Sets whether or not the user's spell checker language settings should be used to |
| * determine spell checker locale. |
| * |
| * <p>If {@code shouldReferToSpellCheckerLanguageSettings} is true, the exact way of |
| * determining spell checker locale differs based on {@code locale} specified in |
| * {@link #setLocale(Locale)}. |
| * If {@code shouldReferToSpellCheckerLanguageSettings} is true and {@code locale} is |
| * null, the locale specified in Settings will be used. If |
| * {@code shouldReferToSpellCheckerLanguageSettings} is true and {@code locale} is not |
| * null, {@link SpellCheckerSession} can be created only when the locale specified in |
| * Settings is the same as {@code locale}. Exceptionally, if |
| * {@code shouldReferToSpellCheckerLanguageSettings} is true and {@code locale} is |
| * language only (e.g. "en"), the specified locale in Settings (e.g. "en_US") will be |
| * used. |
| * |
| * @see #setLocale(Locale) |
| */ |
| @NonNull |
| public Builder setShouldReferToSpellCheckerLanguageSettings( |
| boolean shouldReferToSpellCheckerLanguageSettings) { |
| mShouldReferToSpellCheckerLanguageSettings = |
| shouldReferToSpellCheckerLanguageSettings; |
| return this; |
| } |
| |
| /** |
| * Sets a bitmask of {@link SuggestionsInfo} attributes that the spell checker can set |
| * in {@link SuggestionsInfo} it returns. |
| * |
| * @see android.service.textservice.SpellCheckerService.Session#getSupportedAttributes() |
| */ |
| @NonNull |
| public Builder setSupportedAttributes( |
| @SuggestionsInfo.ResultAttrs int supportedAttributes) { |
| mSupportedAttributes = supportedAttributes; |
| return this; |
| } |
| |
| /** |
| * Sets a bundle containing extra parameters for the spell checker. |
| * |
| * <p>This bundle can be used to pass implementation-specific parameters to the |
| * {@link android.service.textservice.SpellCheckerService} implementation. |
| * |
| * @see android.service.textservice.SpellCheckerService.Session#getBundle() |
| */ |
| @NonNull |
| public Builder setExtras(@NonNull Bundle extras) { |
| mExtras = extras; |
| return this; |
| } |
| } |
| } |
| |
| /** |
| * Callback for getting results from text services |
| */ |
| public interface SpellCheckerSessionListener { |
| /** |
| * Callback for {@link SpellCheckerSession#getSuggestions(TextInfo, int)} |
| * and {@link SpellCheckerSession#getSuggestions(TextInfo[], int, boolean)} |
| * @param results an array of {@link SuggestionsInfo}s. |
| * These results are suggestions for {@link TextInfo}s queried by |
| * {@link SpellCheckerSession#getSuggestions(TextInfo, int)} or |
| * {@link SpellCheckerSession#getSuggestions(TextInfo[], int, boolean)} |
| */ |
| public void onGetSuggestions(SuggestionsInfo[] results); |
| /** |
| * Callback for {@link SpellCheckerSession#getSentenceSuggestions(TextInfo[], int)} |
| * @param results an array of {@link SentenceSuggestionsInfo}s. |
| * These results are suggestions for {@link TextInfo}s |
| * queried by {@link SpellCheckerSession#getSentenceSuggestions(TextInfo[], int)}. |
| */ |
| public void onGetSentenceSuggestions(SentenceSuggestionsInfo[] results); |
| } |
| |
| private static final class InternalListener extends ITextServicesSessionListener.Stub { |
| private final SpellCheckerSessionListenerImpl mParentSpellCheckerSessionListenerImpl; |
| |
| public InternalListener(SpellCheckerSessionListenerImpl spellCheckerSessionListenerImpl) { |
| mParentSpellCheckerSessionListenerImpl = spellCheckerSessionListenerImpl; |
| } |
| |
| @Override |
| public void onServiceConnected(ISpellCheckerSession session) { |
| mParentSpellCheckerSessionListenerImpl.onServiceConnected(session); |
| } |
| } |
| |
| @Override |
| protected void finalize() throws Throwable { |
| try { |
| // Note that mGuard will be null if the constructor threw. |
| if (mGuard != null) { |
| mGuard.warnIfOpen(); |
| close(); |
| } |
| } finally { |
| super.finalize(); |
| } |
| } |
| |
| /** |
| * @hide |
| */ |
| public ITextServicesSessionListener getTextServicesSessionListener() { |
| return mInternalListener; |
| } |
| |
| /** |
| * @hide |
| */ |
| public ISpellCheckerSessionListener getSpellCheckerSessionListener() { |
| return mSpellCheckerSessionListenerImpl; |
| } |
| } |
