InputMethodManagerService.java revision 807ef76e23e08405532a0e7e2d71e7433bf7ae9a 
1/*
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 * use this file except in compliance with the License. You may obtain a copy of
5 * the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 * License for the specific language governing permissions and limitations under
13 * the License.
14 */
15
16package com.android.server;
17
18import com.android.internal.content.PackageMonitor;
19import com.android.internal.inputmethod.InputMethodSubtypeSwitchingController;
20import com.android.internal.inputmethod.InputMethodSubtypeSwitchingController.ImeSubtypeListItem;
21import com.android.internal.inputmethod.InputMethodUtils;
22import com.android.internal.inputmethod.InputMethodUtils.InputMethodSettings;
23import com.android.internal.os.HandlerCaller;
24import com.android.internal.os.SomeArgs;
25import com.android.internal.util.FastXmlSerializer;
26import com.android.internal.view.IInputContext;
27import com.android.internal.view.IInputMethod;
28import com.android.internal.view.IInputSessionCallback;
29import com.android.internal.view.IInputMethodClient;
30import com.android.internal.view.IInputMethodManager;
31import com.android.internal.view.IInputMethodSession;
32import com.android.internal.view.InputBindResult;
33import com.android.server.statusbar.StatusBarManagerService;
34import com.android.server.wm.WindowManagerService;
35
36import org.xmlpull.v1.XmlPullParser;
37import org.xmlpull.v1.XmlPullParserException;
38import org.xmlpull.v1.XmlSerializer;
39
40import android.app.ActivityManagerNative;
41import android.app.AppGlobals;
42import android.app.AlertDialog;
43import android.app.IUserSwitchObserver;
44import android.app.KeyguardManager;
45import android.app.Notification;
46import android.app.NotificationManager;
47import android.app.PendingIntent;
48import android.content.BroadcastReceiver;
49import android.content.ComponentName;
50import android.content.ContentResolver;
51import android.content.Context;
52import android.content.DialogInterface;
53import android.content.DialogInterface.OnCancelListener;
54import android.content.Intent;
55import android.content.IntentFilter;
56import android.content.ServiceConnection;
57import android.content.pm.ApplicationInfo;
58import android.content.pm.IPackageManager;
59import android.content.pm.PackageManager;
60import android.content.pm.ResolveInfo;
61import android.content.pm.ServiceInfo;
62import android.content.pm.UserInfo;
63import android.content.res.Configuration;
64import android.content.res.Resources;
65import android.content.res.TypedArray;
66import android.database.ContentObserver;
67import android.inputmethodservice.InputMethodService;
68import android.os.Binder;
69import android.os.Environment;
70import android.os.Handler;
71import android.os.IBinder;
72import android.os.IInterface;
73import android.os.IRemoteCallback;
74import android.os.Message;
75import android.os.Process;
76import android.os.Parcel;
77import android.os.RemoteException;
78import android.os.ResultReceiver;
79import android.os.ServiceManager;
80import android.os.SystemClock;
81import android.os.UserHandle;
82import android.os.UserManager;
83import android.provider.Settings;
84import android.text.TextUtils;
85import android.text.style.SuggestionSpan;
86import android.util.AtomicFile;
87import android.util.EventLog;
88import android.util.LruCache;
89import android.util.Pair;
90import android.util.PrintWriterPrinter;
91import android.util.Printer;
92import android.util.Slog;
93import android.util.Xml;
94import android.view.IWindowManager;
95import android.view.InputChannel;
96import android.view.LayoutInflater;
97import android.view.View;
98import android.view.ViewGroup;
99import android.view.WindowManager;
100import android.view.inputmethod.EditorInfo;
101import android.view.inputmethod.InputBinding;
102import android.view.inputmethod.InputMethod;
103import android.view.inputmethod.InputMethodInfo;
104import android.view.inputmethod.InputMethodManager;
105import android.view.inputmethod.InputMethodSubtype;
106import android.widget.ArrayAdapter;
107import android.widget.CompoundButton;
108import android.widget.CompoundButton.OnCheckedChangeListener;
109import android.widget.RadioButton;
110import android.widget.Switch;
111import android.widget.TextView;
112
113import java.io.File;
114import java.io.FileDescriptor;
115import java.io.FileInputStream;
116import java.io.FileOutputStream;
117import java.io.IOException;
118import java.io.PrintWriter;
119import java.util.ArrayList;
120import java.util.Collections;
121import java.util.HashMap;
122import java.util.List;
123import java.util.Locale;
124
125/**
126 * This class provides a system service that manages input methods.
127 */
128public class InputMethodManagerService extends IInputMethodManager.Stub
129        implements ServiceConnection, Handler.Callback {
130    static final boolean DEBUG = false;
131    static final String TAG = "InputMethodManagerService";
132
133    static final int MSG_SHOW_IM_PICKER = 1;
134    static final int MSG_SHOW_IM_SUBTYPE_PICKER = 2;
135    static final int MSG_SHOW_IM_SUBTYPE_ENABLER = 3;
136    static final int MSG_SHOW_IM_CONFIG = 4;
137
138    static final int MSG_UNBIND_INPUT = 1000;
139    static final int MSG_BIND_INPUT = 1010;
140    static final int MSG_SHOW_SOFT_INPUT = 1020;
141    static final int MSG_HIDE_SOFT_INPUT = 1030;
142    static final int MSG_ATTACH_TOKEN = 1040;
143    static final int MSG_CREATE_SESSION = 1050;
144
145    static final int MSG_START_INPUT = 2000;
146    static final int MSG_RESTART_INPUT = 2010;
147
148    static final int MSG_UNBIND_METHOD = 3000;
149    static final int MSG_BIND_METHOD = 3010;
150    static final int MSG_SET_ACTIVE = 3020;
151    static final int MSG_SET_CURSOR_ANCHOR_MONITOR_MODE = 3030;
152
153    static final int MSG_HARD_KEYBOARD_SWITCH_CHANGED = 4000;
154
155    static final long TIME_TO_RECONNECT = 3 * 1000;
156
157    static final int SECURE_SUGGESTION_SPANS_MAX_SIZE = 20;
158
159    private static final int NOT_A_SUBTYPE_ID = InputMethodUtils.NOT_A_SUBTYPE_ID;
160    private static final String TAG_TRY_SUPPRESSING_IME_SWITCHER = "TrySuppressingImeSwitcher";
161
162
163    final Context mContext;
164    final Resources mRes;
165    final Handler mHandler;
166    final InputMethodSettings mSettings;
167    final SettingsObserver mSettingsObserver;
168    final IWindowManager mIWindowManager;
169    final HandlerCaller mCaller;
170    final boolean mHasFeature;
171    private InputMethodFileManager mFileManager;
172    private final HardKeyboardListener mHardKeyboardListener;
173    private final WindowManagerService mWindowManagerService;
174
175    final InputBindResult mNoBinding = new InputBindResult(null, null, null, -1);
176
177    // All known input methods.  mMethodMap also serves as the global
178    // lock for this class.
179    final ArrayList<InputMethodInfo> mMethodList = new ArrayList<InputMethodInfo>();
180    final HashMap<String, InputMethodInfo> mMethodMap = new HashMap<String, InputMethodInfo>();
181    private final LruCache<SuggestionSpan, InputMethodInfo> mSecureSuggestionSpans =
182            new LruCache<SuggestionSpan, InputMethodInfo>(SECURE_SUGGESTION_SPANS_MAX_SIZE);
183    private final InputMethodSubtypeSwitchingController mSwitchingController;
184
185    // Used to bring IME service up to visible adjustment while it is being shown.
186    final ServiceConnection mVisibleConnection = new ServiceConnection() {
187        @Override public void onServiceConnected(ComponentName name, IBinder service) {
188        }
189
190        @Override public void onServiceDisconnected(ComponentName name) {
191        }
192    };
193    boolean mVisibleBound = false;
194
195    // Ongoing notification
196    private NotificationManager mNotificationManager;
197    private KeyguardManager mKeyguardManager;
198    private StatusBarManagerService mStatusBar;
199    private Notification mImeSwitcherNotification;
200    private PendingIntent mImeSwitchPendingIntent;
201    private boolean mShowOngoingImeSwitcherForPhones;
202    private boolean mNotificationShown;
203    private final boolean mImeSelectedOnBoot;
204
205    class SessionState {
206        final ClientState client;
207        final IInputMethod method;
208
209        IInputMethodSession session;
210        InputChannel channel;
211
212        @Override
213        public String toString() {
214            return "SessionState{uid " + client.uid + " pid " + client.pid
215                    + " method " + Integer.toHexString(
216                            System.identityHashCode(method))
217                    + " session " + Integer.toHexString(
218                            System.identityHashCode(session))
219                    + " channel " + channel
220                    + "}";
221        }
222
223        SessionState(ClientState _client, IInputMethod _method,
224                IInputMethodSession _session, InputChannel _channel) {
225            client = _client;
226            method = _method;
227            session = _session;
228            channel = _channel;
229        }
230    }
231
232    static final class ClientState {
233        final IInputMethodClient client;
234        final IInputContext inputContext;
235        final int uid;
236        final int pid;
237        final InputBinding binding;
238
239        boolean sessionRequested;
240        SessionState curSession;
241
242        @Override
243        public String toString() {
244            return "ClientState{" + Integer.toHexString(
245                    System.identityHashCode(this)) + " uid " + uid
246                    + " pid " + pid + "}";
247        }
248
249        ClientState(IInputMethodClient _client, IInputContext _inputContext,
250                int _uid, int _pid) {
251            client = _client;
252            inputContext = _inputContext;
253            uid = _uid;
254            pid = _pid;
255            binding = new InputBinding(null, inputContext.asBinder(), uid, pid);
256        }
257    }
258
259    final HashMap<IBinder, ClientState> mClients
260            = new HashMap<IBinder, ClientState>();
261
262    /**
263     * Set once the system is ready to run third party code.
264     */
265    boolean mSystemReady;
266
267    /**
268     * Id of the currently selected input method.
269     */
270    String mCurMethodId;
271
272    /**
273     * The current binding sequence number, incremented every time there is
274     * a new bind performed.
275     */
276    int mCurSeq;
277
278    /**
279     * The client that is currently bound to an input method.
280     */
281    ClientState mCurClient;
282
283    /**
284     * The last window token that gained focus.
285     */
286    IBinder mCurFocusedWindow;
287
288    /**
289     * The input context last provided by the current client.
290     */
291    IInputContext mCurInputContext;
292
293    /**
294     * The attributes last provided by the current client.
295     */
296    EditorInfo mCurAttribute;
297
298    /**
299     * The input method ID of the input method service that we are currently
300     * connected to or in the process of connecting to.
301     */
302    String mCurId;
303
304    /**
305     * The current subtype of the current input method.
306     */
307    private InputMethodSubtype mCurrentSubtype;
308
309    // This list contains the pairs of InputMethodInfo and InputMethodSubtype.
310    private final HashMap<InputMethodInfo, ArrayList<InputMethodSubtype>>
311            mShortcutInputMethodsAndSubtypes =
312                new HashMap<InputMethodInfo, ArrayList<InputMethodSubtype>>();
313
314    // Was the keyguard locked when this client became current?
315    private boolean mCurClientInKeyguard;
316
317    /**
318     * Set to true if our ServiceConnection is currently actively bound to
319     * a service (whether or not we have gotten its IBinder back yet).
320     */
321    boolean mHaveConnection;
322
323    /**
324     * Set if the client has asked for the input method to be shown.
325     */
326    boolean mShowRequested;
327
328    /**
329     * Set if we were explicitly told to show the input method.
330     */
331    boolean mShowExplicitlyRequested;
332
333    /**
334     * Set if we were forced to be shown.
335     */
336    boolean mShowForced;
337
338    /**
339     * Set if we last told the input method to show itself.
340     */
341    boolean mInputShown;
342
343    /**
344     * The Intent used to connect to the current input method.
345     */
346    Intent mCurIntent;
347
348    /**
349     * The token we have made for the currently active input method, to
350     * identify it in the future.
351     */
352    IBinder mCurToken;
353
354    /**
355     * If non-null, this is the input method service we are currently connected
356     * to.
357     */
358    IInputMethod mCurMethod;
359
360    /**
361     * Time that we last initiated a bind to the input method, to determine
362     * if we should try to disconnect and reconnect to it.
363     */
364    long mLastBindTime;
365
366    /**
367     * Have we called mCurMethod.bindInput()?
368     */
369    boolean mBoundToMethod;
370
371    /**
372     * Currently enabled session.  Only touched by service thread, not
373     * protected by a lock.
374     */
375    SessionState mEnabledSession;
376
377    /**
378     * True if the screen is on.  The value is true initially.
379     */
380    boolean mScreenOn = true;
381
382    int mBackDisposition = InputMethodService.BACK_DISPOSITION_DEFAULT;
383    int mImeWindowVis;
384
385    private AlertDialog.Builder mDialogBuilder;
386    private AlertDialog mSwitchingDialog;
387    private View mSwitchingDialogTitleView;
388    private InputMethodInfo[] mIms;
389    private int[] mSubtypeIds;
390    private Locale mLastSystemLocale;
391    private final MyPackageMonitor mMyPackageMonitor = new MyPackageMonitor();
392    private final IPackageManager mIPackageManager;
393
394    class SettingsObserver extends ContentObserver {
395        String mLastEnabled = "";
396
397        SettingsObserver(Handler handler) {
398            super(handler);
399            ContentResolver resolver = mContext.getContentResolver();
400            resolver.registerContentObserver(Settings.Secure.getUriFor(
401                    Settings.Secure.DEFAULT_INPUT_METHOD), false, this);
402            resolver.registerContentObserver(Settings.Secure.getUriFor(
403                    Settings.Secure.ENABLED_INPUT_METHODS), false, this);
404            resolver.registerContentObserver(Settings.Secure.getUriFor(
405                    Settings.Secure.SELECTED_INPUT_METHOD_SUBTYPE), false, this);
406        }
407
408        @Override public void onChange(boolean selfChange) {
409            synchronized (mMethodMap) {
410                boolean enabledChanged = false;
411                String newEnabled = mSettings.getEnabledInputMethodsStr();
412                if (!mLastEnabled.equals(newEnabled)) {
413                    mLastEnabled = newEnabled;
414                    enabledChanged = true;
415                }
416                updateFromSettingsLocked(enabledChanged);
417            }
418        }
419    }
420
421    class ImmsBroadcastReceiver extends android.content.BroadcastReceiver {
422        private void updateActive() {
423            // Inform the current client of the change in active status
424            if (mCurClient != null && mCurClient.client != null) {
425                executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO(
426                        MSG_SET_ACTIVE, mScreenOn ? 1 : 0, mCurClient));
427            }
428        }
429
430        @Override
431        public void onReceive(Context context, Intent intent) {
432            final String action = intent.getAction();
433            if (Intent.ACTION_SCREEN_ON.equals(action)) {
434                mScreenOn = true;
435                refreshImeWindowVisibilityLocked();
436                updateActive();
437                return;
438            } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {
439                mScreenOn = false;
440                setImeWindowVisibilityStatusHiddenLocked();
441                updateActive();
442                return;
443            } else if (Intent.ACTION_CLOSE_SYSTEM_DIALOGS.equals(action)) {
444                hideInputMethodMenu();
445                // No need to updateActive
446                return;
447            } else if (Intent.ACTION_USER_ADDED.equals(action)
448                    || Intent.ACTION_USER_REMOVED.equals(action)) {
449                updateCurrentProfileIds();
450                return;
451            } else {
452                Slog.w(TAG, "Unexpected intent " + intent);
453            }
454        }
455    }
456
457    class MyPackageMonitor extends PackageMonitor {
458        private boolean isChangingPackagesOfCurrentUser() {
459            final int userId = getChangingUserId();
460            final boolean retval = userId == mSettings.getCurrentUserId();
461            if (DEBUG) {
462                if (!retval) {
463                    Slog.d(TAG, "--- ignore this call back from a background user: " + userId);
464                }
465            }
466            return retval;
467        }
468
469        @Override
470        public boolean onHandleForceStop(Intent intent, String[] packages, int uid, boolean doit) {
471            if (!isChangingPackagesOfCurrentUser()) {
472                return false;
473            }
474            synchronized (mMethodMap) {
475                String curInputMethodId = mSettings.getSelectedInputMethod();
476                final int N = mMethodList.size();
477                if (curInputMethodId != null) {
478                    for (int i=0; i<N; i++) {
479                        InputMethodInfo imi = mMethodList.get(i);
480                        if (imi.getId().equals(curInputMethodId)) {
481                            for (String pkg : packages) {
482                                if (imi.getPackageName().equals(pkg)) {
483                                    if (!doit) {
484                                        return true;
485                                    }
486                                    resetSelectedInputMethodAndSubtypeLocked("");
487                                    chooseNewDefaultIMELocked();
488                                    return true;
489                                }
490                            }
491                        }
492                    }
493                }
494            }
495            return false;
496        }
497
498        @Override
499        public void onSomePackagesChanged() {
500            if (!isChangingPackagesOfCurrentUser()) {
501                return;
502            }
503            synchronized (mMethodMap) {
504                InputMethodInfo curIm = null;
505                String curInputMethodId = mSettings.getSelectedInputMethod();
506                final int N = mMethodList.size();
507                if (curInputMethodId != null) {
508                    for (int i=0; i<N; i++) {
509                        InputMethodInfo imi = mMethodList.get(i);
510                        final String imiId = imi.getId();
511                        if (imiId.equals(curInputMethodId)) {
512                            curIm = imi;
513                        }
514
515                        int change = isPackageDisappearing(imi.getPackageName());
516                        if (isPackageModified(imi.getPackageName())) {
517                            mFileManager.deleteAllInputMethodSubtypes(imiId);
518                        }
519                        if (change == PACKAGE_TEMPORARY_CHANGE
520                                || change == PACKAGE_PERMANENT_CHANGE) {
521                            Slog.i(TAG, "Input method uninstalled, disabling: "
522                                    + imi.getComponent());
523                            setInputMethodEnabledLocked(imi.getId(), false);
524                        }
525                    }
526                }
527
528                buildInputMethodListLocked(
529                        mMethodList, mMethodMap, false /* resetDefaultEnabledIme */);
530
531                boolean changed = false;
532
533                if (curIm != null) {
534                    int change = isPackageDisappearing(curIm.getPackageName());
535                    if (change == PACKAGE_TEMPORARY_CHANGE
536                            || change == PACKAGE_PERMANENT_CHANGE) {
537                        ServiceInfo si = null;
538                        try {
539                            si = mIPackageManager.getServiceInfo(
540                                    curIm.getComponent(), 0, mSettings.getCurrentUserId());
541                        } catch (RemoteException ex) {
542                        }
543                        if (si == null) {
544                            // Uh oh, current input method is no longer around!
545                            // Pick another one...
546                            Slog.i(TAG, "Current input method removed: " + curInputMethodId);
547                            setImeWindowVisibilityStatusHiddenLocked();
548                            if (!chooseNewDefaultIMELocked()) {
549                                changed = true;
550                                curIm = null;
551                                Slog.i(TAG, "Unsetting current input method");
552                                resetSelectedInputMethodAndSubtypeLocked("");
553                            }
554                        }
555                    }
556                }
557
558                if (curIm == null) {
559                    // We currently don't have a default input method... is
560                    // one now available?
561                    changed = chooseNewDefaultIMELocked();
562                }
563
564                if (changed) {
565                    updateFromSettingsLocked(false);
566                }
567            }
568        }
569    }
570
571    private static final class MethodCallback extends IInputSessionCallback.Stub {
572        private final InputMethodManagerService mParentIMMS;
573        private final IInputMethod mMethod;
574        private final InputChannel mChannel;
575
576        MethodCallback(InputMethodManagerService imms, IInputMethod method,
577                InputChannel channel) {
578            mParentIMMS = imms;
579            mMethod = method;
580            mChannel = channel;
581        }
582
583        @Override
584        public void sessionCreated(IInputMethodSession session) {
585            long ident = Binder.clearCallingIdentity();
586            try {
587                mParentIMMS.onSessionCreated(mMethod, session, mChannel);
588            } finally {
589                Binder.restoreCallingIdentity(ident);
590            }
591        }
592    }
593
594    private class HardKeyboardListener
595            implements WindowManagerService.OnHardKeyboardStatusChangeListener {
596        @Override
597        public void onHardKeyboardStatusChange(boolean available, boolean enabled) {
598            mHandler.sendMessage(mHandler.obtainMessage(
599                    MSG_HARD_KEYBOARD_SWITCH_CHANGED, available ? 1 : 0, enabled ? 1 : 0));
600        }
601
602        public void handleHardKeyboardStatusChange(boolean available, boolean enabled) {
603            if (DEBUG) {
604                Slog.w(TAG, "HardKeyboardStatusChanged: available = " + available + ", enabled = "
605                        + enabled);
606            }
607            synchronized(mMethodMap) {
608                if (mSwitchingDialog != null && mSwitchingDialogTitleView != null
609                        && mSwitchingDialog.isShowing()) {
610                    mSwitchingDialogTitleView.findViewById(
611                            com.android.internal.R.id.hard_keyboard_section).setVisibility(
612                                    available ? View.VISIBLE : View.GONE);
613                }
614            }
615        }
616    }
617
618    public InputMethodManagerService(Context context, WindowManagerService windowManager) {
619        mIPackageManager = AppGlobals.getPackageManager();
620        mContext = context;
621        mRes = context.getResources();
622        mHandler = new Handler(this);
623        mIWindowManager = IWindowManager.Stub.asInterface(
624                ServiceManager.getService(Context.WINDOW_SERVICE));
625        mCaller = new HandlerCaller(context, null, new HandlerCaller.Callback() {
626            @Override
627            public void executeMessage(Message msg) {
628                handleMessage(msg);
629            }
630        }, true /*asyncHandler*/);
631        mWindowManagerService = windowManager;
632        mHardKeyboardListener = new HardKeyboardListener();
633        mHasFeature = context.getPackageManager().hasSystemFeature(
634                PackageManager.FEATURE_INPUT_METHODS);
635
636        mImeSwitcherNotification = new Notification();
637        mImeSwitcherNotification.icon = com.android.internal.R.drawable.ic_notification_ime_default;
638        mImeSwitcherNotification.when = 0;
639        mImeSwitcherNotification.flags = Notification.FLAG_ONGOING_EVENT;
640        mImeSwitcherNotification.tickerText = null;
641        mImeSwitcherNotification.defaults = 0; // please be quiet
642        mImeSwitcherNotification.sound = null;
643        mImeSwitcherNotification.vibrate = null;
644
645        // Tag this notification specially so SystemUI knows it's important
646        mImeSwitcherNotification.extras.putBoolean(Notification.EXTRA_ALLOW_DURING_SETUP, true);
647        mImeSwitcherNotification.category = Notification.CATEGORY_SYSTEM;
648
649        Intent intent = new Intent(Settings.ACTION_SHOW_INPUT_METHOD_PICKER);
650        mImeSwitchPendingIntent = PendingIntent.getBroadcast(mContext, 0, intent, 0);
651
652        mShowOngoingImeSwitcherForPhones = false;
653
654        final IntentFilter broadcastFilter = new IntentFilter();
655        broadcastFilter.addAction(Intent.ACTION_SCREEN_ON);
656        broadcastFilter.addAction(Intent.ACTION_SCREEN_OFF);
657        broadcastFilter.addAction(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
658        broadcastFilter.addAction(Intent.ACTION_USER_ADDED);
659        broadcastFilter.addAction(Intent.ACTION_USER_REMOVED);
660        mContext.registerReceiver(new ImmsBroadcastReceiver(), broadcastFilter);
661
662        mNotificationShown = false;
663        int userId = 0;
664        try {
665            ActivityManagerNative.getDefault().registerUserSwitchObserver(
666                    new IUserSwitchObserver.Stub() {
667                        @Override
668                        public void onUserSwitching(int newUserId, IRemoteCallback reply) {
669                            synchronized(mMethodMap) {
670                                switchUserLocked(newUserId);
671                            }
672                            if (reply != null) {
673                                try {
674                                    reply.sendResult(null);
675                                } catch (RemoteException e) {
676                                }
677                            }
678                        }
679
680                        @Override
681                        public void onUserSwitchComplete(int newUserId) throws RemoteException {
682                        }
683                    });
684            userId = ActivityManagerNative.getDefault().getCurrentUser().id;
685        } catch (RemoteException e) {
686            Slog.w(TAG, "Couldn't get current user ID; guessing it's 0", e);
687        }
688        mMyPackageMonitor.register(mContext, null, UserHandle.ALL, true);
689
690        // mSettings should be created before buildInputMethodListLocked
691        mSettings = new InputMethodSettings(
692                mRes, context.getContentResolver(), mMethodMap, mMethodList, userId);
693        updateCurrentProfileIds();
694        mFileManager = new InputMethodFileManager(mMethodMap, userId);
695        mSwitchingController = new InputMethodSubtypeSwitchingController(mSettings);
696        mSwitchingController.resetCircularListLocked(context);
697
698        // Just checking if defaultImiId is empty or not
699        final String defaultImiId = mSettings.getSelectedInputMethod();
700        if (DEBUG) {
701            Slog.d(TAG, "Initial default ime = " + defaultImiId);
702        }
703        mImeSelectedOnBoot = !TextUtils.isEmpty(defaultImiId);
704
705        buildInputMethodListLocked(mMethodList, mMethodMap,
706                !mImeSelectedOnBoot /* resetDefaultEnabledIme */);
707        mSettings.enableAllIMEsIfThereIsNoEnabledIME();
708
709        if (!mImeSelectedOnBoot) {
710            Slog.w(TAG, "No IME selected. Choose the most applicable IME.");
711            resetDefaultImeLocked(context);
712        }
713
714        mSettingsObserver = new SettingsObserver(mHandler);
715        updateFromSettingsLocked(true);
716
717        // IMMS wants to receive Intent.ACTION_LOCALE_CHANGED in order to update the current IME
718        // according to the new system locale.
719        final IntentFilter filter = new IntentFilter();
720        filter.addAction(Intent.ACTION_LOCALE_CHANGED);
721        mContext.registerReceiver(
722                new BroadcastReceiver() {
723                    @Override
724                    public void onReceive(Context context, Intent intent) {
725                        synchronized(mMethodMap) {
726                            resetStateIfCurrentLocaleChangedLocked();
727                        }
728                    }
729                }, filter);
730    }
731
732    private void resetDefaultImeLocked(Context context) {
733        // Do not reset the default (current) IME when it is a 3rd-party IME
734        if (mCurMethodId != null
735                && !InputMethodUtils.isSystemIme(mMethodMap.get(mCurMethodId))) {
736            return;
737        }
738
739        InputMethodInfo defIm = null;
740        for (InputMethodInfo imi : mMethodList) {
741            if (defIm == null) {
742                if (InputMethodUtils.isValidSystemDefaultIme(
743                        mSystemReady, imi, context)) {
744                    defIm = imi;
745                    Slog.i(TAG, "Selected default: " + imi.getId());
746                }
747            }
748        }
749        if (defIm == null && mMethodList.size() > 0) {
750            defIm = InputMethodUtils.getMostApplicableDefaultIME(
751                    mSettings.getEnabledInputMethodListLocked());
752            Slog.i(TAG, "No default found, using " + defIm.getId());
753        }
754        if (defIm != null) {
755            setSelectedInputMethodAndSubtypeLocked(defIm, NOT_A_SUBTYPE_ID, false);
756        }
757    }
758
759    private void resetAllInternalStateLocked(final boolean updateOnlyWhenLocaleChanged,
760            final boolean resetDefaultEnabledIme) {
761        if (!mSystemReady) {
762            // not system ready
763            return;
764        }
765        final Locale newLocale = mRes.getConfiguration().locale;
766        if (!updateOnlyWhenLocaleChanged
767                || (newLocale != null && !newLocale.equals(mLastSystemLocale))) {
768            if (!updateOnlyWhenLocaleChanged) {
769                hideCurrentInputLocked(0, null);
770                mCurMethodId = null;
771                unbindCurrentMethodLocked(true, false);
772            }
773            if (DEBUG) {
774                Slog.i(TAG, "Locale has been changed to " + newLocale);
775            }
776            // CircularList should be reset when the locale is changed.
777            mSwitchingController.resetCircularListLocked(mContext);
778            buildInputMethodListLocked(mMethodList, mMethodMap, resetDefaultEnabledIme);
779            if (!updateOnlyWhenLocaleChanged) {
780                final String selectedImiId = mSettings.getSelectedInputMethod();
781                if (TextUtils.isEmpty(selectedImiId)) {
782                    // This is the first time of the user switch and
783                    // set the current ime to the proper one.
784                    resetDefaultImeLocked(mContext);
785                }
786            } else {
787                // If the locale is changed, needs to reset the default ime
788                resetDefaultImeLocked(mContext);
789            }
790            updateFromSettingsLocked(true);
791            mLastSystemLocale = newLocale;
792            if (!updateOnlyWhenLocaleChanged) {
793                try {
794                    startInputInnerLocked();
795                } catch (RuntimeException e) {
796                    Slog.w(TAG, "Unexpected exception", e);
797                }
798            }
799        }
800    }
801
802    private void resetStateIfCurrentLocaleChangedLocked() {
803        resetAllInternalStateLocked(true /* updateOnlyWhenLocaleChanged */,
804                true /* resetDefaultImeLocked */);
805    }
806
807    private void switchUserLocked(int newUserId) {
808        mSettings.setCurrentUserId(newUserId);
809        updateCurrentProfileIds();
810        // InputMethodFileManager should be reset when the user is changed
811        mFileManager = new InputMethodFileManager(mMethodMap, newUserId);
812        final String defaultImiId = mSettings.getSelectedInputMethod();
813        // For secondary users, the list of enabled IMEs may not have been updated since the
814        // callbacks to PackageMonitor are ignored for the secondary user. Here, defaultImiId may
815        // not be empty even if the IME has been uninstalled by the primary user.
816        // Even in such cases, IMMS works fine because it will find the most applicable
817        // IME for that user.
818        final boolean initialUserSwitch = TextUtils.isEmpty(defaultImiId);
819        if (DEBUG) {
820            Slog.d(TAG, "Switch user: " + newUserId + " current ime = " + defaultImiId);
821        }
822        resetAllInternalStateLocked(false  /* updateOnlyWhenLocaleChanged */,
823                initialUserSwitch /* needsToResetDefaultIme */);
824        if (initialUserSwitch) {
825            InputMethodUtils.setNonSelectedSystemImesDisabledUntilUsed(mContext.getPackageManager(),
826                    mSettings.getEnabledInputMethodListLocked());
827        }
828    }
829
830    void updateCurrentProfileIds() {
831        List<UserInfo> profiles =
832                UserManager.get(mContext).getProfiles(mSettings.getCurrentUserId());
833        int[] currentProfileIds = new int[profiles.size()]; // profiles will not be null
834        for (int i = 0; i < currentProfileIds.length; i++) {
835            currentProfileIds[i] = profiles.get(i).id;
836        }
837        mSettings.setCurrentProfileIds(currentProfileIds);
838    }
839
840    @Override
841    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
842            throws RemoteException {
843        try {
844            return super.onTransact(code, data, reply, flags);
845        } catch (RuntimeException e) {
846            // The input method manager only throws security exceptions, so let's
847            // log all others.
848            if (!(e instanceof SecurityException)) {
849                Slog.wtf(TAG, "Input Method Manager Crash", e);
850            }
851            throw e;
852        }
853    }
854
855    public void systemRunning(StatusBarManagerService statusBar) {
856        synchronized (mMethodMap) {
857            if (DEBUG) {
858                Slog.d(TAG, "--- systemReady");
859            }
860            if (!mSystemReady) {
861                mSystemReady = true;
862                mKeyguardManager =
863                        (KeyguardManager) mContext.getSystemService(Context.KEYGUARD_SERVICE);
864                mNotificationManager = (NotificationManager)
865                        mContext.getSystemService(Context.NOTIFICATION_SERVICE);
866                mStatusBar = statusBar;
867                statusBar.setIconVisibility("ime", false);
868                updateImeWindowStatusLocked();
869                mShowOngoingImeSwitcherForPhones = mRes.getBoolean(
870                        com.android.internal.R.bool.show_ongoing_ime_switcher);
871                if (mShowOngoingImeSwitcherForPhones) {
872                    mWindowManagerService.setOnHardKeyboardStatusChangeListener(
873                            mHardKeyboardListener);
874                }
875                buildInputMethodListLocked(mMethodList, mMethodMap,
876                        !mImeSelectedOnBoot /* resetDefaultEnabledIme */);
877                if (!mImeSelectedOnBoot) {
878                    Slog.w(TAG, "Reset the default IME as \"Resource\" is ready here.");
879                    resetStateIfCurrentLocaleChangedLocked();
880                    InputMethodUtils.setNonSelectedSystemImesDisabledUntilUsed(
881                            mContext.getPackageManager(),
882                            mSettings.getEnabledInputMethodListLocked());
883                }
884                mLastSystemLocale = mRes.getConfiguration().locale;
885                try {
886                    startInputInnerLocked();
887                } catch (RuntimeException e) {
888                    Slog.w(TAG, "Unexpected exception", e);
889                }
890            }
891        }
892    }
893
894    private void setImeWindowVisibilityStatusHiddenLocked() {
895        mImeWindowVis = 0;
896        updateImeWindowStatusLocked();
897    }
898
899    private void refreshImeWindowVisibilityLocked() {
900        final Configuration conf = mRes.getConfiguration();
901        final boolean haveHardKeyboard = conf.keyboard
902                != Configuration.KEYBOARD_NOKEYS;
903        final boolean hardKeyShown = haveHardKeyboard
904                && conf.hardKeyboardHidden
905                        != Configuration.HARDKEYBOARDHIDDEN_YES;
906
907        final boolean isScreenLocked = isKeyguardLocked();
908        final boolean inputActive = !isScreenLocked && (mInputShown || hardKeyShown);
909        // We assume the softkeyboard is shown when the input is active as long as the
910        // hard keyboard is not shown.
911        final boolean inputVisible = inputActive && !hardKeyShown;
912        mImeWindowVis = (inputActive ? InputMethodService.IME_ACTIVE : 0)
913                | (inputVisible ? InputMethodService.IME_VISIBLE : 0);
914        updateImeWindowStatusLocked();
915    }
916
917    private void updateImeWindowStatusLocked() {
918        setImeWindowStatus(mCurToken, mImeWindowVis, mBackDisposition);
919    }
920
921    // ---------------------------------------------------------------------------------------
922    // Check whether or not this is a valid IPC. Assumes an IPC is valid when either
923    // 1) it comes from the system process
924    // 2) the calling process' user id is identical to the current user id IMMS thinks.
925    private boolean calledFromValidUser() {
926        final int uid = Binder.getCallingUid();
927        final int userId = UserHandle.getUserId(uid);
928        if (DEBUG) {
929            Slog.d(TAG, "--- calledFromForegroundUserOrSystemProcess ? "
930                    + "calling uid = " + uid + " system uid = " + Process.SYSTEM_UID
931                    + " calling userId = " + userId + ", foreground user id = "
932                    + mSettings.getCurrentUserId() + ", calling pid = " + Binder.getCallingPid()
933                    + InputMethodUtils.getApiCallStack());
934        }
935        if (uid == Process.SYSTEM_UID || mSettings.isCurrentProfile(userId)) {
936            return true;
937        }
938
939        // Caveat: A process which has INTERACT_ACROSS_USERS_FULL gets results for the
940        // foreground user, not for the user of that process. Accordingly InputMethodManagerService
941        // must not manage background users' states in any functions.
942        // Note that privacy-sensitive IPCs, such as setInputMethod, are still securely guarded
943        // by a token.
944        if (mContext.checkCallingOrSelfPermission(
945                android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
946                        == PackageManager.PERMISSION_GRANTED) {
947            if (DEBUG) {
948                Slog.d(TAG, "--- Access granted because the calling process has "
949                        + "the INTERACT_ACROSS_USERS_FULL permission");
950            }
951            return true;
952        }
953        Slog.w(TAG, "--- IPC called from background users. Ignore. \n"
954                + InputMethodUtils.getStackTrace());
955        return false;
956    }
957
958    private boolean bindCurrentInputMethodService(
959            Intent service, ServiceConnection conn, int flags) {
960        if (service == null || conn == null) {
961            Slog.e(TAG, "--- bind failed: service = " + service + ", conn = " + conn);
962            return false;
963        }
964        return mContext.bindServiceAsUser(service, conn, flags,
965                new UserHandle(mSettings.getCurrentUserId()));
966    }
967
968    @Override
969    public List<InputMethodInfo> getInputMethodList() {
970        // TODO: Make this work even for non-current users?
971        if (!calledFromValidUser()) {
972            return Collections.emptyList();
973        }
974        synchronized (mMethodMap) {
975            return new ArrayList<InputMethodInfo>(mMethodList);
976        }
977    }
978
979    @Override
980    public List<InputMethodInfo> getEnabledInputMethodList() {
981        // TODO: Make this work even for non-current users?
982        if (!calledFromValidUser()) {
983            return Collections.emptyList();
984        }
985        synchronized (mMethodMap) {
986            return mSettings.getEnabledInputMethodListLocked();
987        }
988    }
989
990    /**
991     * @param imiId if null, returns enabled subtypes for the current imi
992     * @return enabled subtypes of the specified imi
993     */
994    @Override
995    public List<InputMethodSubtype> getEnabledInputMethodSubtypeList(String imiId,
996            boolean allowsImplicitlySelectedSubtypes) {
997        // TODO: Make this work even for non-current users?
998        if (!calledFromValidUser()) {
999            return Collections.<InputMethodSubtype>emptyList();
1000        }
1001        synchronized (mMethodMap) {
1002            final InputMethodInfo imi;
1003            if (imiId == null && mCurMethodId != null) {
1004                imi = mMethodMap.get(mCurMethodId);
1005            } else {
1006                imi = mMethodMap.get(imiId);
1007            }
1008            if (imi == null) {
1009                return Collections.<InputMethodSubtype>emptyList();
1010            }
1011            return mSettings.getEnabledInputMethodSubtypeListLocked(
1012                    mContext, imi, allowsImplicitlySelectedSubtypes);
1013        }
1014    }
1015
1016    @Override
1017    public void addClient(IInputMethodClient client,
1018            IInputContext inputContext, int uid, int pid) {
1019        if (!calledFromValidUser()) {
1020            return;
1021        }
1022        synchronized (mMethodMap) {
1023            mClients.put(client.asBinder(), new ClientState(client,
1024                    inputContext, uid, pid));
1025        }
1026    }
1027
1028    @Override
1029    public void removeClient(IInputMethodClient client) {
1030        if (!calledFromValidUser()) {
1031            return;
1032        }
1033        synchronized (mMethodMap) {
1034            ClientState cs = mClients.remove(client.asBinder());
1035            if (cs != null) {
1036                clearClientSessionLocked(cs);
1037            }
1038        }
1039    }
1040
1041    void executeOrSendMessage(IInterface target, Message msg) {
1042         if (target.asBinder() instanceof Binder) {
1043             mCaller.sendMessage(msg);
1044         } else {
1045             handleMessage(msg);
1046             msg.recycle();
1047         }
1048    }
1049
1050    void unbindCurrentClientLocked() {
1051        if (mCurClient != null) {
1052            if (DEBUG) Slog.v(TAG, "unbindCurrentInputLocked: client = "
1053                    + mCurClient.client.asBinder());
1054            if (mBoundToMethod) {
1055                mBoundToMethod = false;
1056                if (mCurMethod != null) {
1057                    executeOrSendMessage(mCurMethod, mCaller.obtainMessageO(
1058                            MSG_UNBIND_INPUT, mCurMethod));
1059                }
1060            }
1061
1062            executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO(
1063                    MSG_SET_ACTIVE, 0, mCurClient));
1064            executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO(
1065                    MSG_UNBIND_METHOD, mCurSeq, mCurClient.client));
1066            mCurClient.sessionRequested = false;
1067            mCurClient = null;
1068
1069            hideInputMethodMenuLocked();
1070        }
1071    }
1072
1073    private int getImeShowFlags() {
1074        int flags = 0;
1075        if (mShowForced) {
1076            flags |= InputMethod.SHOW_FORCED
1077                    | InputMethod.SHOW_EXPLICIT;
1078        } else if (mShowExplicitlyRequested) {
1079            flags |= InputMethod.SHOW_EXPLICIT;
1080        }
1081        return flags;
1082    }
1083
1084    private int getAppShowFlags() {
1085        int flags = 0;
1086        if (mShowForced) {
1087            flags |= InputMethodManager.SHOW_FORCED;
1088        } else if (!mShowExplicitlyRequested) {
1089            flags |= InputMethodManager.SHOW_IMPLICIT;
1090        }
1091        return flags;
1092    }
1093
1094    InputBindResult attachNewInputLocked(boolean initial) {
1095        if (!mBoundToMethod) {
1096            executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
1097                    MSG_BIND_INPUT, mCurMethod, mCurClient.binding));
1098            mBoundToMethod = true;
1099        }
1100        final SessionState session = mCurClient.curSession;
1101        if (initial) {
1102            executeOrSendMessage(session.method, mCaller.obtainMessageOOO(
1103                    MSG_START_INPUT, session, mCurInputContext, mCurAttribute));
1104        } else {
1105            executeOrSendMessage(session.method, mCaller.obtainMessageOOO(
1106                    MSG_RESTART_INPUT, session, mCurInputContext, mCurAttribute));
1107        }
1108        if (mShowRequested) {
1109            if (DEBUG) Slog.v(TAG, "Attach new input asks to show input");
1110            showCurrentInputLocked(getAppShowFlags(), null);
1111        }
1112        return new InputBindResult(session.session,
1113                session.channel != null ? session.channel.dup() : null, mCurId, mCurSeq);
1114    }
1115
1116    InputBindResult startInputLocked(IInputMethodClient client,
1117            IInputContext inputContext, EditorInfo attribute, int controlFlags) {
1118        // If no method is currently selected, do nothing.
1119        if (mCurMethodId == null) {
1120            return mNoBinding;
1121        }
1122
1123        ClientState cs = mClients.get(client.asBinder());
1124        if (cs == null) {
1125            throw new IllegalArgumentException("unknown client "
1126                    + client.asBinder());
1127        }
1128
1129        try {
1130            if (!mIWindowManager.inputMethodClientHasFocus(cs.client)) {
1131                // Check with the window manager to make sure this client actually
1132                // has a window with focus.  If not, reject.  This is thread safe
1133                // because if the focus changes some time before or after, the
1134                // next client receiving focus that has any interest in input will
1135                // be calling through here after that change happens.
1136                Slog.w(TAG, "Starting input on non-focused client " + cs.client
1137                        + " (uid=" + cs.uid + " pid=" + cs.pid + ")");
1138                return null;
1139            }
1140        } catch (RemoteException e) {
1141        }
1142
1143        return startInputUncheckedLocked(cs, inputContext, attribute, controlFlags);
1144    }
1145
1146    InputBindResult startInputUncheckedLocked(ClientState cs,
1147            IInputContext inputContext, EditorInfo attribute, int controlFlags) {
1148        // If no method is currently selected, do nothing.
1149        if (mCurMethodId == null) {
1150            return mNoBinding;
1151        }
1152
1153        if (mCurClient != cs) {
1154            // Was the keyguard locked when switching over to the new client?
1155            mCurClientInKeyguard = isKeyguardLocked();
1156            // If the client is changing, we need to switch over to the new
1157            // one.
1158            unbindCurrentClientLocked();
1159            if (DEBUG) Slog.v(TAG, "switching to client: client = "
1160                    + cs.client.asBinder() + " keyguard=" + mCurClientInKeyguard);
1161
1162            // If the screen is on, inform the new client it is active
1163            if (mScreenOn) {
1164                executeOrSendMessage(cs.client, mCaller.obtainMessageIO(
1165                        MSG_SET_ACTIVE, mScreenOn ? 1 : 0, cs));
1166            }
1167        }
1168
1169        // Bump up the sequence for this client and attach it.
1170        mCurSeq++;
1171        if (mCurSeq <= 0) mCurSeq = 1;
1172        mCurClient = cs;
1173        mCurInputContext = inputContext;
1174        mCurAttribute = attribute;
1175
1176        // Check if the input method is changing.
1177        if (mCurId != null && mCurId.equals(mCurMethodId)) {
1178            if (cs.curSession != null) {
1179                // Fast case: if we are already connected to the input method,
1180                // then just return it.
1181                return attachNewInputLocked(
1182                        (controlFlags&InputMethodManager.CONTROL_START_INITIAL) != 0);
1183            }
1184            if (mHaveConnection) {
1185                if (mCurMethod != null) {
1186                    // Return to client, and we will get back with it when
1187                    // we have had a session made for it.
1188                    requestClientSessionLocked(cs);
1189                    return new InputBindResult(null, null, mCurId, mCurSeq);
1190                } else if (SystemClock.uptimeMillis()
1191                        < (mLastBindTime+TIME_TO_RECONNECT)) {
1192                    // In this case we have connected to the service, but
1193                    // don't yet have its interface.  If it hasn't been too
1194                    // long since we did the connection, we'll return to
1195                    // the client and wait to get the service interface so
1196                    // we can report back.  If it has been too long, we want
1197                    // to fall through so we can try a disconnect/reconnect
1198                    // to see if we can get back in touch with the service.
1199                    return new InputBindResult(null, null, mCurId, mCurSeq);
1200                } else {
1201                    EventLog.writeEvent(EventLogTags.IMF_FORCE_RECONNECT_IME,
1202                            mCurMethodId, SystemClock.uptimeMillis()-mLastBindTime, 0);
1203                }
1204            }
1205        }
1206
1207        return startInputInnerLocked();
1208    }
1209
1210    InputBindResult startInputInnerLocked() {
1211        if (mCurMethodId == null) {
1212            return mNoBinding;
1213        }
1214
1215        if (!mSystemReady) {
1216            // If the system is not yet ready, we shouldn't be running third
1217            // party code.
1218            return new InputBindResult(null, null, mCurMethodId, mCurSeq);
1219        }
1220
1221        InputMethodInfo info = mMethodMap.get(mCurMethodId);
1222        if (info == null) {
1223            throw new IllegalArgumentException("Unknown id: " + mCurMethodId);
1224        }
1225
1226        unbindCurrentMethodLocked(false, true);
1227
1228        mCurIntent = new Intent(InputMethod.SERVICE_INTERFACE);
1229        mCurIntent.setComponent(info.getComponent());
1230        mCurIntent.putExtra(Intent.EXTRA_CLIENT_LABEL,
1231                com.android.internal.R.string.input_method_binding_label);
1232        mCurIntent.putExtra(Intent.EXTRA_CLIENT_INTENT, PendingIntent.getActivity(
1233                mContext, 0, new Intent(Settings.ACTION_INPUT_METHOD_SETTINGS), 0));
1234        if (bindCurrentInputMethodService(mCurIntent, this, Context.BIND_AUTO_CREATE
1235                | Context.BIND_NOT_VISIBLE | Context.BIND_NOT_FOREGROUND
1236                | Context.BIND_SHOWING_UI)) {
1237            mLastBindTime = SystemClock.uptimeMillis();
1238            mHaveConnection = true;
1239            mCurId = info.getId();
1240            mCurToken = new Binder();
1241            try {
1242                if (true || DEBUG) Slog.v(TAG, "Adding window token: " + mCurToken);
1243                mIWindowManager.addWindowToken(mCurToken,
1244                        WindowManager.LayoutParams.TYPE_INPUT_METHOD);
1245            } catch (RemoteException e) {
1246            }
1247            return new InputBindResult(null, null, mCurId, mCurSeq);
1248        } else {
1249            mCurIntent = null;
1250            Slog.w(TAG, "Failure connecting to input method service: "
1251                    + mCurIntent);
1252        }
1253        return null;
1254    }
1255
1256    @Override
1257    public InputBindResult startInput(IInputMethodClient client,
1258            IInputContext inputContext, EditorInfo attribute, int controlFlags) {
1259        if (!calledFromValidUser()) {
1260            return null;
1261        }
1262        synchronized (mMethodMap) {
1263            final long ident = Binder.clearCallingIdentity();
1264            try {
1265                return startInputLocked(client, inputContext, attribute, controlFlags);
1266            } finally {
1267                Binder.restoreCallingIdentity(ident);
1268            }
1269        }
1270    }
1271
1272    @Override
1273    public void finishInput(IInputMethodClient client) {
1274    }
1275
1276    @Override
1277    public void onServiceConnected(ComponentName name, IBinder service) {
1278        synchronized (mMethodMap) {
1279            if (mCurIntent != null && name.equals(mCurIntent.getComponent())) {
1280                mCurMethod = IInputMethod.Stub.asInterface(service);
1281                if (mCurToken == null) {
1282                    Slog.w(TAG, "Service connected without a token!");
1283                    unbindCurrentMethodLocked(false, false);
1284                    return;
1285                }
1286                if (DEBUG) Slog.v(TAG, "Initiating attach with token: " + mCurToken);
1287                executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
1288                        MSG_ATTACH_TOKEN, mCurMethod, mCurToken));
1289                if (mCurClient != null) {
1290                    clearClientSessionLocked(mCurClient);
1291                    requestClientSessionLocked(mCurClient);
1292                }
1293            }
1294        }
1295    }
1296
1297    void onSessionCreated(IInputMethod method, IInputMethodSession session,
1298            InputChannel channel) {
1299        synchronized (mMethodMap) {
1300            if (mCurMethod != null && method != null
1301                    && mCurMethod.asBinder() == method.asBinder()) {
1302                if (mCurClient != null) {
1303                    clearClientSessionLocked(mCurClient);
1304                    mCurClient.curSession = new SessionState(mCurClient,
1305                            method, session, channel);
1306                    InputBindResult res = attachNewInputLocked(true);
1307                    if (res.method != null) {
1308                        executeOrSendMessage(mCurClient.client, mCaller.obtainMessageOO(
1309                                MSG_BIND_METHOD, mCurClient.client, res));
1310                    }
1311                    return;
1312                }
1313            }
1314        }
1315
1316        // Session abandoned.  Close its associated input channel.
1317        channel.dispose();
1318    }
1319
1320    void unbindCurrentMethodLocked(boolean reportToClient, boolean savePosition) {
1321        if (mVisibleBound) {
1322            mContext.unbindService(mVisibleConnection);
1323            mVisibleBound = false;
1324        }
1325
1326        if (mHaveConnection) {
1327            mContext.unbindService(this);
1328            mHaveConnection = false;
1329        }
1330
1331        if (mCurToken != null) {
1332            try {
1333                if (DEBUG) Slog.v(TAG, "Removing window token: " + mCurToken);
1334                if ((mImeWindowVis & InputMethodService.IME_ACTIVE) != 0 && savePosition) {
1335                    // The current IME is shown. Hence an IME switch (transition) is happening.
1336                    mWindowManagerService.saveLastInputMethodWindowForTransition();
1337                }
1338                mIWindowManager.removeWindowToken(mCurToken);
1339            } catch (RemoteException e) {
1340            }
1341            mCurToken = null;
1342        }
1343
1344        mCurId = null;
1345        clearCurMethodLocked();
1346
1347        if (reportToClient && mCurClient != null) {
1348            executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO(
1349                    MSG_UNBIND_METHOD, mCurSeq, mCurClient.client));
1350        }
1351    }
1352
1353    void requestClientSessionLocked(ClientState cs) {
1354        if (!cs.sessionRequested) {
1355            if (DEBUG) Slog.v(TAG, "Creating new session for client " + cs);
1356            InputChannel[] channels = InputChannel.openInputChannelPair(cs.toString());
1357            cs.sessionRequested = true;
1358            executeOrSendMessage(mCurMethod, mCaller.obtainMessageOOO(
1359                    MSG_CREATE_SESSION, mCurMethod, channels[1],
1360                    new MethodCallback(this, mCurMethod, channels[0])));
1361        }
1362    }
1363
1364    void clearClientSessionLocked(ClientState cs) {
1365        finishSessionLocked(cs.curSession);
1366        cs.curSession = null;
1367        cs.sessionRequested = false;
1368    }
1369
1370    private void finishSessionLocked(SessionState sessionState) {
1371        if (sessionState != null) {
1372            if (sessionState.session != null) {
1373                try {
1374                    sessionState.session.finishSession();
1375                } catch (RemoteException e) {
1376                    Slog.w(TAG, "Session failed to close due to remote exception", e);
1377                    setImeWindowVisibilityStatusHiddenLocked();
1378                }
1379                sessionState.session = null;
1380            }
1381            if (sessionState.channel != null) {
1382                sessionState.channel.dispose();
1383                sessionState.channel = null;
1384            }
1385        }
1386    }
1387
1388    void clearCurMethodLocked() {
1389        if (mCurMethod != null) {
1390            for (ClientState cs : mClients.values()) {
1391                clearClientSessionLocked(cs);
1392            }
1393
1394            finishSessionLocked(mEnabledSession);
1395            mEnabledSession = null;
1396            mCurMethod = null;
1397        }
1398        if (mStatusBar != null) {
1399            mStatusBar.setIconVisibility("ime", false);
1400        }
1401    }
1402
1403    @Override
1404    public void onServiceDisconnected(ComponentName name) {
1405        synchronized (mMethodMap) {
1406            if (DEBUG) Slog.v(TAG, "Service disconnected: " + name
1407                    + " mCurIntent=" + mCurIntent);
1408            if (mCurMethod != null && mCurIntent != null
1409                    && name.equals(mCurIntent.getComponent())) {
1410                clearCurMethodLocked();
1411                // We consider this to be a new bind attempt, since the system
1412                // should now try to restart the service for us.
1413                mLastBindTime = SystemClock.uptimeMillis();
1414                mShowRequested = mInputShown;
1415                mInputShown = false;
1416                if (mCurClient != null) {
1417                    executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO(
1418                            MSG_UNBIND_METHOD, mCurSeq, mCurClient.client));
1419                }
1420            }
1421        }
1422    }
1423
1424    @Override
1425    public void updateStatusIcon(IBinder token, String packageName, int iconId) {
1426        int uid = Binder.getCallingUid();
1427        long ident = Binder.clearCallingIdentity();
1428        try {
1429            if (token == null || mCurToken != token) {
1430                Slog.w(TAG, "Ignoring setInputMethod of uid " + uid + " token: " + token);
1431                return;
1432            }
1433
1434            synchronized (mMethodMap) {
1435                if (iconId == 0) {
1436                    if (DEBUG) Slog.d(TAG, "hide the small icon for the input method");
1437                    if (mStatusBar != null) {
1438                        mStatusBar.setIconVisibility("ime", false);
1439                    }
1440                } else if (packageName != null) {
1441                    if (DEBUG) Slog.d(TAG, "show a small icon for the input method");
1442                    CharSequence contentDescription = null;
1443                    try {
1444                        // Use PackageManager to load label
1445                        final PackageManager packageManager = mContext.getPackageManager();
1446                        contentDescription = packageManager.getApplicationLabel(
1447                                mIPackageManager.getApplicationInfo(packageName, 0,
1448                                        mSettings.getCurrentUserId()));
1449                    } catch (RemoteException e) {
1450                        /* ignore */
1451                    }
1452                    if (mStatusBar != null) {
1453                        mStatusBar.setIcon("ime", packageName, iconId, 0,
1454                                contentDescription  != null
1455                                        ? contentDescription.toString() : null);
1456                        mStatusBar.setIconVisibility("ime", true);
1457                    }
1458                }
1459            }
1460        } finally {
1461            Binder.restoreCallingIdentity(ident);
1462        }
1463    }
1464
1465    private boolean needsToShowImeSwitchOngoingNotification() {
1466        if (!mShowOngoingImeSwitcherForPhones) return false;
1467        if (mSwitchingDialog != null) return false;
1468        if (isScreenLocked()) return false;
1469        synchronized (mMethodMap) {
1470            List<InputMethodInfo> imis = mSettings.getEnabledInputMethodListLocked();
1471            final int N = imis.size();
1472            if (N > 2) return true;
1473            if (N < 1) return false;
1474            int nonAuxCount = 0;
1475            int auxCount = 0;
1476            InputMethodSubtype nonAuxSubtype = null;
1477            InputMethodSubtype auxSubtype = null;
1478            for(int i = 0; i < N; ++i) {
1479                final InputMethodInfo imi = imis.get(i);
1480                final List<InputMethodSubtype> subtypes =
1481                        mSettings.getEnabledInputMethodSubtypeListLocked(mContext, imi, true);
1482                final int subtypeCount = subtypes.size();
1483                if (subtypeCount == 0) {
1484                    ++nonAuxCount;
1485                } else {
1486                    for (int j = 0; j < subtypeCount; ++j) {
1487                        final InputMethodSubtype subtype = subtypes.get(j);
1488                        if (!subtype.isAuxiliary()) {
1489                            ++nonAuxCount;
1490                            nonAuxSubtype = subtype;
1491                        } else {
1492                            ++auxCount;
1493                            auxSubtype = subtype;
1494                        }
1495                    }
1496                }
1497            }
1498            if (nonAuxCount > 1 || auxCount > 1) {
1499                return true;
1500            } else if (nonAuxCount == 1 && auxCount == 1) {
1501                if (nonAuxSubtype != null && auxSubtype != null
1502                        && (nonAuxSubtype.getLocale().equals(auxSubtype.getLocale())
1503                                || auxSubtype.overridesImplicitlyEnabledSubtype()
1504                                || nonAuxSubtype.overridesImplicitlyEnabledSubtype())
1505                        && nonAuxSubtype.containsExtraValueKey(TAG_TRY_SUPPRESSING_IME_SWITCHER)) {
1506                    return false;
1507                }
1508                return true;
1509            }
1510            return false;
1511        }
1512    }
1513
1514    private boolean isKeyguardLocked() {
1515        return mKeyguardManager != null && mKeyguardManager.isKeyguardLocked();
1516    }
1517
1518    // Caution! This method is called in this class. Handle multi-user carefully
1519    @SuppressWarnings("deprecation")
1520    @Override
1521    public void setImeWindowStatus(IBinder token, int vis, int backDisposition) {
1522        final long ident = Binder.clearCallingIdentity();
1523        try {
1524            if (token == null || mCurToken != token) {
1525                int uid = Binder.getCallingUid();
1526                Slog.w(TAG, "Ignoring setImeWindowStatus of uid " + uid + " token: " + token);
1527                return;
1528            }
1529            synchronized (mMethodMap) {
1530                // apply policy for binder calls
1531                if (vis != 0 && isKeyguardLocked() && !mCurClientInKeyguard) {
1532                    vis = 0;
1533                }
1534                mImeWindowVis = vis;
1535                mBackDisposition = backDisposition;
1536                final boolean iconVisibility = ((vis & (InputMethodService.IME_ACTIVE)) != 0)
1537                        && (mWindowManagerService.isHardKeyboardAvailable()
1538                                || (vis & (InputMethodService.IME_VISIBLE)) != 0);
1539                final boolean needsToShowImeSwitcher = iconVisibility
1540                        && needsToShowImeSwitchOngoingNotification();
1541                if (mStatusBar != null) {
1542                    mStatusBar.setImeWindowStatus(token, vis, backDisposition,
1543                            needsToShowImeSwitcher);
1544                }
1545                final InputMethodInfo imi = mMethodMap.get(mCurMethodId);
1546                if (imi != null && needsToShowImeSwitcher) {
1547                    // Used to load label
1548                    final CharSequence title = mRes.getText(
1549                            com.android.internal.R.string.select_input_method);
1550                    final CharSequence summary = InputMethodUtils.getImeAndSubtypeDisplayName(
1551                            mContext, imi, mCurrentSubtype);
1552
1553                    mImeSwitcherNotification.setLatestEventInfo(
1554                            mContext, title, summary, mImeSwitchPendingIntent);
1555                    if ((mNotificationManager != null)
1556                            && !mWindowManagerService.hasNavigationBar()) {
1557                        if (DEBUG) {
1558                            Slog.d(TAG, "--- show notification: label =  " + summary);
1559                        }
1560                        mNotificationManager.notifyAsUser(null,
1561                                com.android.internal.R.string.select_input_method,
1562                                mImeSwitcherNotification, UserHandle.ALL);
1563                        mNotificationShown = true;
1564                    }
1565                } else {
1566                    if (mNotificationShown && mNotificationManager != null) {
1567                        if (DEBUG) {
1568                            Slog.d(TAG, "--- hide notification");
1569                        }
1570                        mNotificationManager.cancelAsUser(null,
1571                                com.android.internal.R.string.select_input_method, UserHandle.ALL);
1572                        mNotificationShown = false;
1573                    }
1574                }
1575            }
1576        } finally {
1577            Binder.restoreCallingIdentity(ident);
1578        }
1579    }
1580
1581    @Override
1582    public void registerSuggestionSpansForNotification(SuggestionSpan[] spans) {
1583        if (!calledFromValidUser()) {
1584            return;
1585        }
1586        synchronized (mMethodMap) {
1587            final InputMethodInfo currentImi = mMethodMap.get(mCurMethodId);
1588            for (int i = 0; i < spans.length; ++i) {
1589                SuggestionSpan ss = spans[i];
1590                if (!TextUtils.isEmpty(ss.getNotificationTargetClassName())) {
1591                    mSecureSuggestionSpans.put(ss, currentImi);
1592                }
1593            }
1594        }
1595    }
1596
1597    @Override
1598    public boolean notifySuggestionPicked(SuggestionSpan span, String originalString, int index) {
1599        if (!calledFromValidUser()) {
1600            return false;
1601        }
1602        synchronized (mMethodMap) {
1603            final InputMethodInfo targetImi = mSecureSuggestionSpans.get(span);
1604            // TODO: Do not send the intent if the process of the targetImi is already dead.
1605            if (targetImi != null) {
1606                final String[] suggestions = span.getSuggestions();
1607                if (index < 0 || index >= suggestions.length) return false;
1608                final String className = span.getNotificationTargetClassName();
1609                final Intent intent = new Intent();
1610                // Ensures that only a class in the original IME package will receive the
1611                // notification.
1612                intent.setClassName(targetImi.getPackageName(), className);
1613                intent.setAction(SuggestionSpan.ACTION_SUGGESTION_PICKED);
1614                intent.putExtra(SuggestionSpan.SUGGESTION_SPAN_PICKED_BEFORE, originalString);
1615                intent.putExtra(SuggestionSpan.SUGGESTION_SPAN_PICKED_AFTER, suggestions[index]);
1616                intent.putExtra(SuggestionSpan.SUGGESTION_SPAN_PICKED_HASHCODE, span.hashCode());
1617                final long ident = Binder.clearCallingIdentity();
1618                try {
1619                    mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT);
1620                } finally {
1621                    Binder.restoreCallingIdentity(ident);
1622                }
1623                return true;
1624            }
1625        }
1626        return false;
1627    }
1628
1629    void updateFromSettingsLocked(boolean enabledMayChange) {
1630        if (enabledMayChange) {
1631            List<InputMethodInfo> enabled = mSettings.getEnabledInputMethodListLocked();
1632            for (int i=0; i<enabled.size(); i++) {
1633                // We allow the user to select "disabled until used" apps, so if they
1634                // are enabling one of those here we now need to make it enabled.
1635                InputMethodInfo imm = enabled.get(i);
1636                try {
1637                    ApplicationInfo ai = mIPackageManager.getApplicationInfo(imm.getPackageName(),
1638                            PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS,
1639                            mSettings.getCurrentUserId());
1640                    if (ai != null && ai.enabledSetting
1641                            == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED) {
1642                        if (DEBUG) {
1643                            Slog.d(TAG, "Update state(" + imm.getId()
1644                                    + "): DISABLED_UNTIL_USED -> DEFAULT");
1645                        }
1646                        mIPackageManager.setApplicationEnabledSetting(imm.getPackageName(),
1647                                PackageManager.COMPONENT_ENABLED_STATE_DEFAULT,
1648                                PackageManager.DONT_KILL_APP, mSettings.getCurrentUserId(),
1649                                mContext.getBasePackageName());
1650                    }
1651                } catch (RemoteException e) {
1652                }
1653            }
1654        }
1655        // We are assuming that whoever is changing DEFAULT_INPUT_METHOD and
1656        // ENABLED_INPUT_METHODS is taking care of keeping them correctly in
1657        // sync, so we will never have a DEFAULT_INPUT_METHOD that is not
1658        // enabled.
1659        String id = mSettings.getSelectedInputMethod();
1660        // There is no input method selected, try to choose new applicable input method.
1661        if (TextUtils.isEmpty(id) && chooseNewDefaultIMELocked()) {
1662            id = mSettings.getSelectedInputMethod();
1663        }
1664        if (!TextUtils.isEmpty(id)) {
1665            try {
1666                setInputMethodLocked(id, mSettings.getSelectedInputMethodSubtypeId(id));
1667            } catch (IllegalArgumentException e) {
1668                Slog.w(TAG, "Unknown input method from prefs: " + id, e);
1669                mCurMethodId = null;
1670                unbindCurrentMethodLocked(true, false);
1671            }
1672            mShortcutInputMethodsAndSubtypes.clear();
1673        } else {
1674            // There is no longer an input method set, so stop any current one.
1675            mCurMethodId = null;
1676            unbindCurrentMethodLocked(true, false);
1677        }
1678    }
1679
1680    /* package */ void setInputMethodLocked(String id, int subtypeId) {
1681        InputMethodInfo info = mMethodMap.get(id);
1682        if (info == null) {
1683            throw new IllegalArgumentException("Unknown id: " + id);
1684        }
1685
1686        // See if we need to notify a subtype change within the same IME.
1687        if (id.equals(mCurMethodId)) {
1688            final int subtypeCount = info.getSubtypeCount();
1689            if (subtypeCount <= 0) {
1690                return;
1691            }
1692            final InputMethodSubtype oldSubtype = mCurrentSubtype;
1693            final InputMethodSubtype newSubtype;
1694            if (subtypeId >= 0 && subtypeId < subtypeCount) {
1695                newSubtype = info.getSubtypeAt(subtypeId);
1696            } else {
1697                // If subtype is null, try to find the most applicable one from
1698                // getCurrentInputMethodSubtype.
1699                newSubtype = getCurrentInputMethodSubtypeLocked();
1700            }
1701            if (newSubtype == null || oldSubtype == null) {
1702                Slog.w(TAG, "Illegal subtype state: old subtype = " + oldSubtype
1703                        + ", new subtype = " + newSubtype);
1704                return;
1705            }
1706            if (newSubtype != oldSubtype) {
1707                setSelectedInputMethodAndSubtypeLocked(info, subtypeId, true);
1708                if (mCurMethod != null) {
1709                    try {
1710                        refreshImeWindowVisibilityLocked();
1711                        mCurMethod.changeInputMethodSubtype(newSubtype);
1712                    } catch (RemoteException e) {
1713                        Slog.w(TAG, "Failed to call changeInputMethodSubtype");
1714                    }
1715                }
1716            }
1717            return;
1718        }
1719
1720        // Changing to a different IME.
1721        final long ident = Binder.clearCallingIdentity();
1722        try {
1723            // Set a subtype to this input method.
1724            // subtypeId the name of a subtype which will be set.
1725            setSelectedInputMethodAndSubtypeLocked(info, subtypeId, false);
1726            // mCurMethodId should be updated after setSelectedInputMethodAndSubtypeLocked()
1727            // because mCurMethodId is stored as a history in
1728            // setSelectedInputMethodAndSubtypeLocked().
1729            mCurMethodId = id;
1730
1731            if (ActivityManagerNative.isSystemReady()) {
1732                Intent intent = new Intent(Intent.ACTION_INPUT_METHOD_CHANGED);
1733                intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
1734                intent.putExtra("input_method_id", id);
1735                mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT);
1736            }
1737            unbindCurrentClientLocked();
1738        } finally {
1739            Binder.restoreCallingIdentity(ident);
1740        }
1741    }
1742
1743    @Override
1744    public boolean showSoftInput(IInputMethodClient client, int flags,
1745            ResultReceiver resultReceiver) {
1746        if (!calledFromValidUser()) {
1747            return false;
1748        }
1749        int uid = Binder.getCallingUid();
1750        long ident = Binder.clearCallingIdentity();
1751        try {
1752            synchronized (mMethodMap) {
1753                if (mCurClient == null || client == null
1754                        || mCurClient.client.asBinder() != client.asBinder()) {
1755                    try {
1756                        // We need to check if this is the current client with
1757                        // focus in the window manager, to allow this call to
1758                        // be made before input is started in it.
1759                        if (!mIWindowManager.inputMethodClientHasFocus(client)) {
1760                            Slog.w(TAG, "Ignoring showSoftInput of uid " + uid + ": " + client);
1761                            return false;
1762                        }
1763                    } catch (RemoteException e) {
1764                        return false;
1765                    }
1766                }
1767
1768                if (DEBUG) Slog.v(TAG, "Client requesting input be shown");
1769                return showCurrentInputLocked(flags, resultReceiver);
1770            }
1771        } finally {
1772            Binder.restoreCallingIdentity(ident);
1773        }
1774    }
1775
1776    boolean showCurrentInputLocked(int flags, ResultReceiver resultReceiver) {
1777        mShowRequested = true;
1778        if ((flags&InputMethodManager.SHOW_IMPLICIT) == 0) {
1779            mShowExplicitlyRequested = true;
1780        }
1781        if ((flags&InputMethodManager.SHOW_FORCED) != 0) {
1782            mShowExplicitlyRequested = true;
1783            mShowForced = true;
1784        }
1785
1786        if (!mSystemReady) {
1787            return false;
1788        }
1789
1790        boolean res = false;
1791        if (mCurMethod != null) {
1792            if (DEBUG) Slog.d(TAG, "showCurrentInputLocked: mCurToken=" + mCurToken);
1793            executeOrSendMessage(mCurMethod, mCaller.obtainMessageIOO(
1794                    MSG_SHOW_SOFT_INPUT, getImeShowFlags(), mCurMethod,
1795                    resultReceiver));
1796            mInputShown = true;
1797            if (mHaveConnection && !mVisibleBound) {
1798                bindCurrentInputMethodService(
1799                        mCurIntent, mVisibleConnection, Context.BIND_AUTO_CREATE
1800                                | Context.BIND_TREAT_LIKE_ACTIVITY);
1801                mVisibleBound = true;
1802            }
1803            res = true;
1804        } else if (mHaveConnection && SystemClock.uptimeMillis()
1805                >= (mLastBindTime+TIME_TO_RECONNECT)) {
1806            // The client has asked to have the input method shown, but
1807            // we have been sitting here too long with a connection to the
1808            // service and no interface received, so let's disconnect/connect
1809            // to try to prod things along.
1810            EventLog.writeEvent(EventLogTags.IMF_FORCE_RECONNECT_IME, mCurMethodId,
1811                    SystemClock.uptimeMillis()-mLastBindTime,1);
1812            Slog.w(TAG, "Force disconnect/connect to the IME in showCurrentInputLocked()");
1813            mContext.unbindService(this);
1814            bindCurrentInputMethodService(mCurIntent, this, Context.BIND_AUTO_CREATE
1815                    | Context.BIND_NOT_VISIBLE);
1816        } else {
1817            if (DEBUG) {
1818                Slog.d(TAG, "Can't show input: connection = " + mHaveConnection + ", time = "
1819                        + ((mLastBindTime+TIME_TO_RECONNECT) - SystemClock.uptimeMillis()));
1820            }
1821        }
1822
1823        return res;
1824    }
1825
1826    @Override
1827    public boolean hideSoftInput(IInputMethodClient client, int flags,
1828            ResultReceiver resultReceiver) {
1829        if (!calledFromValidUser()) {
1830            return false;
1831        }
1832        int uid = Binder.getCallingUid();
1833        long ident = Binder.clearCallingIdentity();
1834        try {
1835            synchronized (mMethodMap) {
1836                if (mCurClient == null || client == null
1837                        || mCurClient.client.asBinder() != client.asBinder()) {
1838                    try {
1839                        // We need to check if this is the current client with
1840                        // focus in the window manager, to allow this call to
1841                        // be made before input is started in it.
1842                        if (!mIWindowManager.inputMethodClientHasFocus(client)) {
1843                            if (DEBUG) Slog.w(TAG, "Ignoring hideSoftInput of uid "
1844                                    + uid + ": " + client);
1845                            setImeWindowVisibilityStatusHiddenLocked();
1846                            return false;
1847                        }
1848                    } catch (RemoteException e) {
1849                        setImeWindowVisibilityStatusHiddenLocked();
1850                        return false;
1851                    }
1852                }
1853
1854                if (DEBUG) Slog.v(TAG, "Client requesting input be hidden");
1855                return hideCurrentInputLocked(flags, resultReceiver);
1856            }
1857        } finally {
1858            Binder.restoreCallingIdentity(ident);
1859        }
1860    }
1861
1862    boolean hideCurrentInputLocked(int flags, ResultReceiver resultReceiver) {
1863        if ((flags&InputMethodManager.HIDE_IMPLICIT_ONLY) != 0
1864                && (mShowExplicitlyRequested || mShowForced)) {
1865            if (DEBUG) Slog.v(TAG, "Not hiding: explicit show not cancelled by non-explicit hide");
1866            return false;
1867        }
1868        if (mShowForced && (flags&InputMethodManager.HIDE_NOT_ALWAYS) != 0) {
1869            if (DEBUG) Slog.v(TAG, "Not hiding: forced show not cancelled by not-always hide");
1870            return false;
1871        }
1872        boolean res;
1873        if (mInputShown && mCurMethod != null) {
1874            executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
1875                    MSG_HIDE_SOFT_INPUT, mCurMethod, resultReceiver));
1876            res = true;
1877        } else {
1878            res = false;
1879        }
1880        if (mHaveConnection && mVisibleBound) {
1881            mContext.unbindService(mVisibleConnection);
1882            mVisibleBound = false;
1883        }
1884        mInputShown = false;
1885        mShowRequested = false;
1886        mShowExplicitlyRequested = false;
1887        mShowForced = false;
1888        return res;
1889    }
1890
1891    @Override
1892    public InputBindResult windowGainedFocus(IInputMethodClient client, IBinder windowToken,
1893            int controlFlags, int softInputMode, int windowFlags,
1894            EditorInfo attribute, IInputContext inputContext) {
1895        // Needs to check the validity before clearing calling identity
1896        final boolean calledFromValidUser = calledFromValidUser();
1897
1898        InputBindResult res = null;
1899        long ident = Binder.clearCallingIdentity();
1900        try {
1901            synchronized (mMethodMap) {
1902                if (DEBUG) Slog.v(TAG, "windowGainedFocus: " + client.asBinder()
1903                        + " controlFlags=#" + Integer.toHexString(controlFlags)
1904                        + " softInputMode=#" + Integer.toHexString(softInputMode)
1905                        + " windowFlags=#" + Integer.toHexString(windowFlags));
1906
1907                ClientState cs = mClients.get(client.asBinder());
1908                if (cs == null) {
1909                    throw new IllegalArgumentException("unknown client "
1910                            + client.asBinder());
1911                }
1912
1913                try {
1914                    if (!mIWindowManager.inputMethodClientHasFocus(cs.client)) {
1915                        // Check with the window manager to make sure this client actually
1916                        // has a window with focus.  If not, reject.  This is thread safe
1917                        // because if the focus changes some time before or after, the
1918                        // next client receiving focus that has any interest in input will
1919                        // be calling through here after that change happens.
1920                        Slog.w(TAG, "Focus gain on non-focused client " + cs.client
1921                                + " (uid=" + cs.uid + " pid=" + cs.pid + ")");
1922                        return null;
1923                    }
1924                } catch (RemoteException e) {
1925                }
1926
1927                if (!calledFromValidUser) {
1928                    Slog.w(TAG, "A background user is requesting window. Hiding IME.");
1929                    Slog.w(TAG, "If you want to interect with IME, you need "
1930                            + "android.permission.INTERACT_ACROSS_USERS_FULL");
1931                    hideCurrentInputLocked(0, null);
1932                    return null;
1933                }
1934
1935                if (mCurFocusedWindow == windowToken) {
1936                    Slog.w(TAG, "Window already focused, ignoring focus gain of: " + client
1937                            + " attribute=" + attribute + ", token = " + windowToken);
1938                    if (attribute != null) {
1939                        return startInputUncheckedLocked(cs, inputContext, attribute,
1940                                controlFlags);
1941                    }
1942                    return null;
1943                }
1944                mCurFocusedWindow = windowToken;
1945
1946                // Should we auto-show the IME even if the caller has not
1947                // specified what should be done with it?
1948                // We only do this automatically if the window can resize
1949                // to accommodate the IME (so what the user sees will give
1950                // them good context without input information being obscured
1951                // by the IME) or if running on a large screen where there
1952                // is more room for the target window + IME.
1953                final boolean doAutoShow =
1954                        (softInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST)
1955                                == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
1956                        || mRes.getConfiguration().isLayoutSizeAtLeast(
1957                                Configuration.SCREENLAYOUT_SIZE_LARGE);
1958                final boolean isTextEditor =
1959                        (controlFlags&InputMethodManager.CONTROL_WINDOW_IS_TEXT_EDITOR) != 0;
1960
1961                // We want to start input before showing the IME, but after closing
1962                // it.  We want to do this after closing it to help the IME disappear
1963                // more quickly (not get stuck behind it initializing itself for the
1964                // new focused input, even if its window wants to hide the IME).
1965                boolean didStart = false;
1966
1967                switch (softInputMode&WindowManager.LayoutParams.SOFT_INPUT_MASK_STATE) {
1968                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED:
1969                        if (!isTextEditor || !doAutoShow) {
1970                            if (WindowManager.LayoutParams.mayUseInputMethod(windowFlags)) {
1971                                // There is no focus view, and this window will
1972                                // be behind any soft input window, so hide the
1973                                // soft input window if it is shown.
1974                                if (DEBUG) Slog.v(TAG, "Unspecified window will hide input");
1975                                hideCurrentInputLocked(InputMethodManager.HIDE_NOT_ALWAYS, null);
1976                            }
1977                        } else if (isTextEditor && doAutoShow && (softInputMode &
1978                                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
1979                            // There is a focus view, and we are navigating forward
1980                            // into the window, so show the input window for the user.
1981                            // We only do this automatically if the window can resize
1982                            // to accommodate the IME (so what the user sees will give
1983                            // them good context without input information being obscured
1984                            // by the IME) or if running on a large screen where there
1985                            // is more room for the target window + IME.
1986                            if (DEBUG) Slog.v(TAG, "Unspecified window will show input");
1987                            if (attribute != null) {
1988                                res = startInputUncheckedLocked(cs, inputContext, attribute,
1989                                        controlFlags);
1990                                didStart = true;
1991                            }
1992                            showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT, null);
1993                        }
1994                        break;
1995                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED:
1996                        // Do nothing.
1997                        break;
1998                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN:
1999                        if ((softInputMode &
2000                                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
2001                            if (DEBUG) Slog.v(TAG, "Window asks to hide input going forward");
2002                            hideCurrentInputLocked(0, null);
2003                        }
2004                        break;
2005                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN:
2006                        if (DEBUG) Slog.v(TAG, "Window asks to hide input");
2007                        hideCurrentInputLocked(0, null);
2008                        break;
2009                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE:
2010                        if ((softInputMode &
2011                                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
2012                            if (DEBUG) Slog.v(TAG, "Window asks to show input going forward");
2013                            if (attribute != null) {
2014                                res = startInputUncheckedLocked(cs, inputContext, attribute,
2015                                        controlFlags);
2016                                didStart = true;
2017                            }
2018                            showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT, null);
2019                        }
2020                        break;
2021                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE:
2022                        if (DEBUG) Slog.v(TAG, "Window asks to always show input");
2023                        if (attribute != null) {
2024                            res = startInputUncheckedLocked(cs, inputContext, attribute,
2025                                    controlFlags);
2026                            didStart = true;
2027                        }
2028                        showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT, null);
2029                        break;
2030                }
2031
2032                if (!didStart && attribute != null) {
2033                    res = startInputUncheckedLocked(cs, inputContext, attribute,
2034                            controlFlags);
2035                }
2036            }
2037        } finally {
2038            Binder.restoreCallingIdentity(ident);
2039        }
2040
2041        return res;
2042    }
2043
2044    @Override
2045    public void showInputMethodPickerFromClient(IInputMethodClient client) {
2046        if (!calledFromValidUser()) {
2047            return;
2048        }
2049        synchronized (mMethodMap) {
2050            if (mCurClient == null || client == null
2051                    || mCurClient.client.asBinder() != client.asBinder()) {
2052                Slog.w(TAG, "Ignoring showInputMethodPickerFromClient of uid "
2053                        + Binder.getCallingUid() + ": " + client);
2054            }
2055
2056            // Always call subtype picker, because subtype picker is a superset of input method
2057            // picker.
2058            mHandler.sendEmptyMessage(MSG_SHOW_IM_SUBTYPE_PICKER);
2059        }
2060    }
2061
2062    @Override
2063    public void setInputMethod(IBinder token, String id) {
2064        if (!calledFromValidUser()) {
2065            return;
2066        }
2067        setInputMethodWithSubtypeId(token, id, NOT_A_SUBTYPE_ID);
2068    }
2069
2070    @Override
2071    public void setInputMethodAndSubtype(IBinder token, String id, InputMethodSubtype subtype) {
2072        if (!calledFromValidUser()) {
2073            return;
2074        }
2075        synchronized (mMethodMap) {
2076            if (subtype != null) {
2077                setInputMethodWithSubtypeId(token, id, InputMethodUtils.getSubtypeIdFromHashCode(
2078                        mMethodMap.get(id), subtype.hashCode()));
2079            } else {
2080                setInputMethod(token, id);
2081            }
2082        }
2083    }
2084
2085    @Override
2086    public void showInputMethodAndSubtypeEnablerFromClient(
2087            IInputMethodClient client, String inputMethodId) {
2088        if (!calledFromValidUser()) {
2089            return;
2090        }
2091        synchronized (mMethodMap) {
2092            if (mCurClient == null || client == null
2093                || mCurClient.client.asBinder() != client.asBinder()) {
2094                Slog.w(TAG, "Ignoring showInputMethodAndSubtypeEnablerFromClient of: " + client);
2095            }
2096            executeOrSendMessage(mCurMethod, mCaller.obtainMessageO(
2097                    MSG_SHOW_IM_SUBTYPE_ENABLER, inputMethodId));
2098        }
2099    }
2100
2101    @Override
2102    public boolean switchToLastInputMethod(IBinder token) {
2103        if (!calledFromValidUser()) {
2104            return false;
2105        }
2106        synchronized (mMethodMap) {
2107            final Pair<String, String> lastIme = mSettings.getLastInputMethodAndSubtypeLocked();
2108            final InputMethodInfo lastImi;
2109            if (lastIme != null) {
2110                lastImi = mMethodMap.get(lastIme.first);
2111            } else {
2112                lastImi = null;
2113            }
2114            String targetLastImiId = null;
2115            int subtypeId = NOT_A_SUBTYPE_ID;
2116            if (lastIme != null && lastImi != null) {
2117                final boolean imiIdIsSame = lastImi.getId().equals(mCurMethodId);
2118                final int lastSubtypeHash = Integer.valueOf(lastIme.second);
2119                final int currentSubtypeHash = mCurrentSubtype == null ? NOT_A_SUBTYPE_ID
2120                        : mCurrentSubtype.hashCode();
2121                // If the last IME is the same as the current IME and the last subtype is not
2122                // defined, there is no need to switch to the last IME.
2123                if (!imiIdIsSame || lastSubtypeHash != currentSubtypeHash) {
2124                    targetLastImiId = lastIme.first;
2125                    subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);
2126                }
2127            }
2128
2129            if (TextUtils.isEmpty(targetLastImiId)
2130                    && !InputMethodUtils.canAddToLastInputMethod(mCurrentSubtype)) {
2131                // This is a safety net. If the currentSubtype can't be added to the history
2132                // and the framework couldn't find the last ime, we will make the last ime be
2133                // the most applicable enabled keyboard subtype of the system imes.
2134                final List<InputMethodInfo> enabled = mSettings.getEnabledInputMethodListLocked();
2135                if (enabled != null) {
2136                    final int N = enabled.size();
2137                    final String locale = mCurrentSubtype == null
2138                            ? mRes.getConfiguration().locale.toString()
2139                            : mCurrentSubtype.getLocale();
2140                    for (int i = 0; i < N; ++i) {
2141                        final InputMethodInfo imi = enabled.get(i);
2142                        if (imi.getSubtypeCount() > 0 && InputMethodUtils.isSystemIme(imi)) {
2143                            InputMethodSubtype keyboardSubtype =
2144                                    InputMethodUtils.findLastResortApplicableSubtypeLocked(mRes,
2145                                            InputMethodUtils.getSubtypes(imi),
2146                                            InputMethodUtils.SUBTYPE_MODE_KEYBOARD, locale, true);
2147                            if (keyboardSubtype != null) {
2148                                targetLastImiId = imi.getId();
2149                                subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(
2150                                        imi, keyboardSubtype.hashCode());
2151                                if(keyboardSubtype.getLocale().equals(locale)) {
2152                                    break;
2153                                }
2154                            }
2155                        }
2156                    }
2157                }
2158            }
2159
2160            if (!TextUtils.isEmpty(targetLastImiId)) {
2161                if (DEBUG) {
2162                    Slog.d(TAG, "Switch to: " + lastImi.getId() + ", " + lastIme.second
2163                            + ", from: " + mCurMethodId + ", " + subtypeId);
2164                }
2165                setInputMethodWithSubtypeId(token, targetLastImiId, subtypeId);
2166                return true;
2167            } else {
2168                return false;
2169            }
2170        }
2171    }
2172
2173    @Override
2174    public boolean switchToNextInputMethod(IBinder token, boolean onlyCurrentIme) {
2175        if (!calledFromValidUser()) {
2176            return false;
2177        }
2178        synchronized (mMethodMap) {
2179            final ImeSubtypeListItem nextSubtype = mSwitchingController.getNextInputMethod(
2180                    onlyCurrentIme, mMethodMap.get(mCurMethodId), mCurrentSubtype);
2181            if (nextSubtype == null) {
2182                return false;
2183            }
2184            setInputMethodWithSubtypeId(token, nextSubtype.mImi.getId(), nextSubtype.mSubtypeId);
2185            return true;
2186        }
2187    }
2188
2189    @Override
2190    public boolean shouldOfferSwitchingToNextInputMethod(IBinder token) {
2191        if (!calledFromValidUser()) {
2192            return false;
2193        }
2194        synchronized (mMethodMap) {
2195            final ImeSubtypeListItem nextSubtype = mSwitchingController.getNextInputMethod(
2196                    false /* onlyCurrentIme */, mMethodMap.get(mCurMethodId), mCurrentSubtype);
2197            if (nextSubtype == null) {
2198                return false;
2199            }
2200            return true;
2201        }
2202    }
2203
2204    @Override
2205    public InputMethodSubtype getLastInputMethodSubtype() {
2206        if (!calledFromValidUser()) {
2207            return null;
2208        }
2209        synchronized (mMethodMap) {
2210            final Pair<String, String> lastIme = mSettings.getLastInputMethodAndSubtypeLocked();
2211            // TODO: Handle the case of the last IME with no subtypes
2212            if (lastIme == null || TextUtils.isEmpty(lastIme.first)
2213                    || TextUtils.isEmpty(lastIme.second)) return null;
2214            final InputMethodInfo lastImi = mMethodMap.get(lastIme.first);
2215            if (lastImi == null) return null;
2216            try {
2217                final int lastSubtypeHash = Integer.valueOf(lastIme.second);
2218                final int lastSubtypeId =
2219                        InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);
2220                if (lastSubtypeId < 0 || lastSubtypeId >= lastImi.getSubtypeCount()) {
2221                    return null;
2222                }
2223                return lastImi.getSubtypeAt(lastSubtypeId);
2224            } catch (NumberFormatException e) {
2225                return null;
2226            }
2227        }
2228    }
2229
2230    @Override
2231    public void setAdditionalInputMethodSubtypes(String imiId, InputMethodSubtype[] subtypes) {
2232        if (!calledFromValidUser()) {
2233            return;
2234        }
2235        // By this IPC call, only a process which shares the same uid with the IME can add
2236        // additional input method subtypes to the IME.
2237        if (TextUtils.isEmpty(imiId) || subtypes == null || subtypes.length == 0) return;
2238        synchronized (mMethodMap) {
2239            final InputMethodInfo imi = mMethodMap.get(imiId);
2240            if (imi == null) return;
2241            final String[] packageInfos;
2242            try {
2243                packageInfos = mIPackageManager.getPackagesForUid(Binder.getCallingUid());
2244            } catch (RemoteException e) {
2245                Slog.e(TAG, "Failed to get package infos");
2246                return;
2247            }
2248            if (packageInfos != null) {
2249                final int packageNum = packageInfos.length;
2250                for (int i = 0; i < packageNum; ++i) {
2251                    if (packageInfos[i].equals(imi.getPackageName())) {
2252                        mFileManager.addInputMethodSubtypes(imi, subtypes);
2253                        final long ident = Binder.clearCallingIdentity();
2254                        try {
2255                            buildInputMethodListLocked(mMethodList, mMethodMap,
2256                                    false /* resetDefaultEnabledIme */);
2257                        } finally {
2258                            Binder.restoreCallingIdentity(ident);
2259                        }
2260                        return;
2261                    }
2262                }
2263            }
2264        }
2265        return;
2266    }
2267
2268    @Override
2269    public int getInputMethodWindowVisibleHeight() {
2270        return mWindowManagerService.getInputMethodWindowVisibleHeight();
2271    }
2272
2273    @Override
2274    public void notifyTextCommitted() {
2275        if (DEBUG) {
2276            Slog.d(TAG, "Got the notification of commitText");
2277        }
2278        final InputMethodInfo imi = mMethodMap.get(mCurMethodId);
2279        if (imi != null) {
2280            mSwitchingController.onCommitText(imi, mCurrentSubtype);
2281        }
2282    }
2283
2284    @Override
2285    public void setCursorAnchorMonitorMode(IBinder token, int monitorMode) {
2286        if (DEBUG) {
2287            Slog.d(TAG, "setCursorAnchorMonitorMode: monitorMode=" + monitorMode);
2288        }
2289        if (!calledFromValidUser()) {
2290            return;
2291        }
2292        synchronized (mMethodMap) {
2293            if (token == null || mCurToken != token) {
2294                if (DEBUG) {
2295                    Slog.w(TAG, "Ignoring setCursorAnchorMonitorMode from uid "
2296                            + Binder.getCallingUid() + " token: " + token);
2297                }
2298                return;
2299            }
2300            executeOrSendMessage(mCurMethod, mCaller.obtainMessageIO(
2301                    MSG_SET_CURSOR_ANCHOR_MONITOR_MODE, monitorMode, mCurClient));
2302        }
2303    }
2304
2305    private void setInputMethodWithSubtypeId(IBinder token, String id, int subtypeId) {
2306        synchronized (mMethodMap) {
2307            if (token == null) {
2308                if (mContext.checkCallingOrSelfPermission(
2309                        android.Manifest.permission.WRITE_SECURE_SETTINGS)
2310                        != PackageManager.PERMISSION_GRANTED) {
2311                    throw new SecurityException(
2312                            "Using null token requires permission "
2313                            + android.Manifest.permission.WRITE_SECURE_SETTINGS);
2314                }
2315            } else if (mCurToken != token) {
2316                Slog.w(TAG, "Ignoring setInputMethod of uid " + Binder.getCallingUid()
2317                        + " token: " + token);
2318                return;
2319            }
2320
2321            final long ident = Binder.clearCallingIdentity();
2322            try {
2323                setInputMethodLocked(id, subtypeId);
2324            } finally {
2325                Binder.restoreCallingIdentity(ident);
2326            }
2327        }
2328    }
2329
2330    @Override
2331    public void hideMySoftInput(IBinder token, int flags) {
2332        if (!calledFromValidUser()) {
2333            return;
2334        }
2335        synchronized (mMethodMap) {
2336            if (token == null || mCurToken != token) {
2337                if (DEBUG) Slog.w(TAG, "Ignoring hideInputMethod of uid "
2338                        + Binder.getCallingUid() + " token: " + token);
2339                return;
2340            }
2341            long ident = Binder.clearCallingIdentity();
2342            try {
2343                hideCurrentInputLocked(flags, null);
2344            } finally {
2345                Binder.restoreCallingIdentity(ident);
2346            }
2347        }
2348    }
2349
2350    @Override
2351    public void showMySoftInput(IBinder token, int flags) {
2352        if (!calledFromValidUser()) {
2353            return;
2354        }
2355        synchronized (mMethodMap) {
2356            if (token == null || mCurToken != token) {
2357                Slog.w(TAG, "Ignoring showMySoftInput of uid "
2358                        + Binder.getCallingUid() + " token: " + token);
2359                return;
2360            }
2361            long ident = Binder.clearCallingIdentity();
2362            try {
2363                showCurrentInputLocked(flags, null);
2364            } finally {
2365                Binder.restoreCallingIdentity(ident);
2366            }
2367        }
2368    }
2369
2370    void setEnabledSessionInMainThread(SessionState session) {
2371        if (mEnabledSession != session) {
2372            if (mEnabledSession != null) {
2373                try {
2374                    if (DEBUG) Slog.v(TAG, "Disabling: " + mEnabledSession);
2375                    mEnabledSession.method.setSessionEnabled(
2376                            mEnabledSession.session, false);
2377                } catch (RemoteException e) {
2378                }
2379            }
2380            mEnabledSession = session;
2381            try {
2382                if (DEBUG) Slog.v(TAG, "Enabling: " + mEnabledSession);
2383                session.method.setSessionEnabled(
2384                        session.session, true);
2385            } catch (RemoteException e) {
2386            }
2387        }
2388    }
2389
2390    @Override
2391    public boolean handleMessage(Message msg) {
2392        SomeArgs args;
2393        switch (msg.what) {
2394            case MSG_SHOW_IM_PICKER:
2395                showInputMethodMenu();
2396                return true;
2397
2398            case MSG_SHOW_IM_SUBTYPE_PICKER:
2399                showInputMethodSubtypeMenu();
2400                return true;
2401
2402            case MSG_SHOW_IM_SUBTYPE_ENABLER:
2403                args = (SomeArgs)msg.obj;
2404                showInputMethodAndSubtypeEnabler((String)args.arg1);
2405                args.recycle();
2406                return true;
2407
2408            case MSG_SHOW_IM_CONFIG:
2409                showConfigureInputMethods();
2410                return true;
2411
2412            // ---------------------------------------------------------
2413
2414            case MSG_UNBIND_INPUT:
2415                try {
2416                    ((IInputMethod)msg.obj).unbindInput();
2417                } catch (RemoteException e) {
2418                    // There is nothing interesting about the method dying.
2419                }
2420                return true;
2421            case MSG_BIND_INPUT:
2422                args = (SomeArgs)msg.obj;
2423                try {
2424                    ((IInputMethod)args.arg1).bindInput((InputBinding)args.arg2);
2425                } catch (RemoteException e) {
2426                }
2427                args.recycle();
2428                return true;
2429            case MSG_SHOW_SOFT_INPUT:
2430                args = (SomeArgs)msg.obj;
2431                try {
2432                    if (DEBUG) Slog.v(TAG, "Calling " + args.arg1 + ".showSoftInput("
2433                            + msg.arg1 + ", " + args.arg2 + ")");
2434                    ((IInputMethod)args.arg1).showSoftInput(msg.arg1, (ResultReceiver)args.arg2);
2435                } catch (RemoteException e) {
2436                }
2437                args.recycle();
2438                return true;
2439            case MSG_HIDE_SOFT_INPUT:
2440                args = (SomeArgs)msg.obj;
2441                try {
2442                    if (DEBUG) Slog.v(TAG, "Calling " + args.arg1 + ".hideSoftInput(0, "
2443                            + args.arg2 + ")");
2444                    ((IInputMethod)args.arg1).hideSoftInput(0, (ResultReceiver)args.arg2);
2445                } catch (RemoteException e) {
2446                }
2447                args.recycle();
2448                return true;
2449            case MSG_ATTACH_TOKEN:
2450                args = (SomeArgs)msg.obj;
2451                try {
2452                    if (DEBUG) Slog.v(TAG, "Sending attach of token: " + args.arg2);
2453                    ((IInputMethod)args.arg1).attachToken((IBinder)args.arg2);
2454                } catch (RemoteException e) {
2455                }
2456                args.recycle();
2457                return true;
2458            case MSG_CREATE_SESSION: {
2459                args = (SomeArgs)msg.obj;
2460                IInputMethod method = (IInputMethod)args.arg1;
2461                InputChannel channel = (InputChannel)args.arg2;
2462                try {
2463                    method.createSession(channel, (IInputSessionCallback)args.arg3);
2464                } catch (RemoteException e) {
2465                } finally {
2466                    // Dispose the channel if the input method is not local to this process
2467                    // because the remote proxy will get its own copy when unparceled.
2468                    if (channel != null && Binder.isProxy(method)) {
2469                        channel.dispose();
2470                    }
2471                }
2472                args.recycle();
2473                return true;
2474            }
2475            // ---------------------------------------------------------
2476
2477            case MSG_START_INPUT:
2478                args = (SomeArgs)msg.obj;
2479                try {
2480                    SessionState session = (SessionState)args.arg1;
2481                    setEnabledSessionInMainThread(session);
2482                    session.method.startInput((IInputContext)args.arg2,
2483                            (EditorInfo)args.arg3);
2484                } catch (RemoteException e) {
2485                }
2486                args.recycle();
2487                return true;
2488            case MSG_RESTART_INPUT:
2489                args = (SomeArgs)msg.obj;
2490                try {
2491                    SessionState session = (SessionState)args.arg1;
2492                    setEnabledSessionInMainThread(session);
2493                    session.method.restartInput((IInputContext)args.arg2,
2494                            (EditorInfo)args.arg3);
2495                } catch (RemoteException e) {
2496                }
2497                args.recycle();
2498                return true;
2499
2500            // ---------------------------------------------------------
2501
2502            case MSG_UNBIND_METHOD:
2503                try {
2504                    ((IInputMethodClient)msg.obj).onUnbindMethod(msg.arg1);
2505                } catch (RemoteException e) {
2506                    // There is nothing interesting about the last client dying.
2507                }
2508                return true;
2509            case MSG_BIND_METHOD: {
2510                args = (SomeArgs)msg.obj;
2511                IInputMethodClient client = (IInputMethodClient)args.arg1;
2512                InputBindResult res = (InputBindResult)args.arg2;
2513                try {
2514                    client.onBindMethod(res);
2515                } catch (RemoteException e) {
2516                    Slog.w(TAG, "Client died receiving input method " + args.arg2);
2517                } finally {
2518                    // Dispose the channel if the input method is not local to this process
2519                    // because the remote proxy will get its own copy when unparceled.
2520                    if (res.channel != null && Binder.isProxy(client)) {
2521                        res.channel.dispose();
2522                    }
2523                }
2524                args.recycle();
2525                return true;
2526            }
2527            case MSG_SET_ACTIVE:
2528                try {
2529                    ((ClientState)msg.obj).client.setActive(msg.arg1 != 0);
2530                } catch (RemoteException e) {
2531                    Slog.w(TAG, "Got RemoteException sending setActive(false) notification to pid "
2532                            + ((ClientState)msg.obj).pid + " uid "
2533                            + ((ClientState)msg.obj).uid);
2534                }
2535                return true;
2536            case MSG_SET_CURSOR_ANCHOR_MONITOR_MODE:
2537                try {
2538                    ((ClientState)msg.obj).client.setCursorAnchorMonitorMode(msg.arg1);
2539                } catch (RemoteException e) {
2540                    Slog.w(TAG, "Got RemoteException sending setCursorAnchorMonitorMode "
2541                            + "notification to pid " + ((ClientState)msg.obj).pid
2542                            + " uid " + ((ClientState)msg.obj).uid);
2543                }
2544                return true;
2545
2546            // --------------------------------------------------------------
2547            case MSG_HARD_KEYBOARD_SWITCH_CHANGED:
2548                mHardKeyboardListener.handleHardKeyboardStatusChange(
2549                        msg.arg1 == 1, msg.arg2 == 1);
2550                return true;
2551        }
2552        return false;
2553    }
2554
2555    private boolean chooseNewDefaultIMELocked() {
2556        final InputMethodInfo imi = InputMethodUtils.getMostApplicableDefaultIME(
2557                mSettings.getEnabledInputMethodListLocked());
2558        if (imi != null) {
2559            if (DEBUG) {
2560                Slog.d(TAG, "New default IME was selected: " + imi.getId());
2561            }
2562            resetSelectedInputMethodAndSubtypeLocked(imi.getId());
2563            return true;
2564        }
2565
2566        return false;
2567    }
2568
2569    void buildInputMethodListLocked(ArrayList<InputMethodInfo> list,
2570            HashMap<String, InputMethodInfo> map, boolean resetDefaultEnabledIme) {
2571        if (DEBUG) {
2572            Slog.d(TAG, "--- re-buildInputMethodList reset = " + resetDefaultEnabledIme
2573                    + " \n ------ \n" + InputMethodUtils.getStackTrace());
2574        }
2575        list.clear();
2576        map.clear();
2577
2578        // Use for queryIntentServicesAsUser
2579        final PackageManager pm = mContext.getPackageManager();
2580        String disabledSysImes = mSettings.getDisabledSystemInputMethods();
2581        if (disabledSysImes == null) disabledSysImes = "";
2582
2583        final List<ResolveInfo> services = pm.queryIntentServicesAsUser(
2584                new Intent(InputMethod.SERVICE_INTERFACE),
2585                PackageManager.GET_META_DATA | PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS,
2586                mSettings.getCurrentUserId());
2587
2588        final HashMap<String, List<InputMethodSubtype>> additionalSubtypes =
2589                mFileManager.getAllAdditionalInputMethodSubtypes();
2590        for (int i = 0; i < services.size(); ++i) {
2591            ResolveInfo ri = services.get(i);
2592            ServiceInfo si = ri.serviceInfo;
2593            ComponentName compName = new ComponentName(si.packageName, si.name);
2594            if (!android.Manifest.permission.BIND_INPUT_METHOD.equals(
2595                    si.permission)) {
2596                Slog.w(TAG, "Skipping input method " + compName
2597                        + ": it does not require the permission "
2598                        + android.Manifest.permission.BIND_INPUT_METHOD);
2599                continue;
2600            }
2601
2602            if (DEBUG) Slog.d(TAG, "Checking " + compName);
2603
2604            try {
2605                InputMethodInfo p = new InputMethodInfo(mContext, ri, additionalSubtypes);
2606                list.add(p);
2607                final String id = p.getId();
2608                map.put(id, p);
2609
2610                if (DEBUG) {
2611                    Slog.d(TAG, "Found an input method " + p);
2612                }
2613
2614            } catch (XmlPullParserException e) {
2615                Slog.w(TAG, "Unable to load input method " + compName, e);
2616            } catch (IOException e) {
2617                Slog.w(TAG, "Unable to load input method " + compName, e);
2618            }
2619        }
2620
2621        if (resetDefaultEnabledIme) {
2622            final ArrayList<InputMethodInfo> defaultEnabledIme =
2623                    InputMethodUtils.getDefaultEnabledImes(mContext, mSystemReady, list);
2624            for (int i = 0; i < defaultEnabledIme.size(); ++i) {
2625                final InputMethodInfo imi =  defaultEnabledIme.get(i);
2626                if (DEBUG) {
2627                    Slog.d(TAG, "--- enable ime = " + imi);
2628                }
2629                setInputMethodEnabledLocked(imi.getId(), true);
2630            }
2631        }
2632
2633        final String defaultImiId = mSettings.getSelectedInputMethod();
2634        if (!TextUtils.isEmpty(defaultImiId)) {
2635            if (!map.containsKey(defaultImiId)) {
2636                Slog.w(TAG, "Default IME is uninstalled. Choose new default IME.");
2637                if (chooseNewDefaultIMELocked()) {
2638                    updateFromSettingsLocked(true);
2639                }
2640            } else {
2641                // Double check that the default IME is certainly enabled.
2642                setInputMethodEnabledLocked(defaultImiId, true);
2643            }
2644        }
2645    }
2646
2647    // ----------------------------------------------------------------------
2648
2649    private void showInputMethodMenu() {
2650        showInputMethodMenuInternal(false);
2651    }
2652
2653    private void showInputMethodSubtypeMenu() {
2654        showInputMethodMenuInternal(true);
2655    }
2656
2657    private void showInputMethodAndSubtypeEnabler(String inputMethodId) {
2658        Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SUBTYPE_SETTINGS);
2659        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
2660                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
2661                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
2662        if (!TextUtils.isEmpty(inputMethodId)) {
2663            intent.putExtra(Settings.EXTRA_INPUT_METHOD_ID, inputMethodId);
2664        }
2665        mContext.startActivityAsUser(intent, null, UserHandle.CURRENT);
2666    }
2667
2668    private void showConfigureInputMethods() {
2669        Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SETTINGS);
2670        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
2671                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
2672                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
2673        mContext.startActivityAsUser(intent, null, UserHandle.CURRENT);
2674    }
2675
2676    private boolean isScreenLocked() {
2677        return mKeyguardManager != null
2678                && mKeyguardManager.isKeyguardLocked() && mKeyguardManager.isKeyguardSecure();
2679    }
2680    private void showInputMethodMenuInternal(boolean showSubtypes) {
2681        if (DEBUG) Slog.v(TAG, "Show switching menu");
2682
2683        final Context context = mContext;
2684        final boolean isScreenLocked = isScreenLocked();
2685
2686        final String lastInputMethodId = mSettings.getSelectedInputMethod();
2687        int lastInputMethodSubtypeId = mSettings.getSelectedInputMethodSubtypeId(lastInputMethodId);
2688        if (DEBUG) Slog.v(TAG, "Current IME: " + lastInputMethodId);
2689
2690        synchronized (mMethodMap) {
2691            final HashMap<InputMethodInfo, List<InputMethodSubtype>> immis =
2692                    mSettings.getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked(
2693                            mContext);
2694            if (immis == null || immis.size() == 0) {
2695                return;
2696            }
2697
2698            hideInputMethodMenuLocked();
2699
2700            final List<ImeSubtypeListItem> imList =
2701                    mSwitchingController.getSortedInputMethodAndSubtypeList(
2702                            showSubtypes, mInputShown, isScreenLocked);
2703
2704            if (lastInputMethodSubtypeId == NOT_A_SUBTYPE_ID) {
2705                final InputMethodSubtype currentSubtype = getCurrentInputMethodSubtypeLocked();
2706                if (currentSubtype != null) {
2707                    final InputMethodInfo currentImi = mMethodMap.get(mCurMethodId);
2708                    lastInputMethodSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(
2709                            currentImi, currentSubtype.hashCode());
2710                }
2711            }
2712
2713            final int N = imList.size();
2714            mIms = new InputMethodInfo[N];
2715            mSubtypeIds = new int[N];
2716            int checkedItem = 0;
2717            for (int i = 0; i < N; ++i) {
2718                final ImeSubtypeListItem item = imList.get(i);
2719                mIms[i] = item.mImi;
2720                mSubtypeIds[i] = item.mSubtypeId;
2721                if (mIms[i].getId().equals(lastInputMethodId)) {
2722                    int subtypeId = mSubtypeIds[i];
2723                    if ((subtypeId == NOT_A_SUBTYPE_ID)
2724                            || (lastInputMethodSubtypeId == NOT_A_SUBTYPE_ID && subtypeId == 0)
2725                            || (subtypeId == lastInputMethodSubtypeId)) {
2726                        checkedItem = i;
2727                    }
2728                }
2729            }
2730            final TypedArray a = context.obtainStyledAttributes(null,
2731                    com.android.internal.R.styleable.DialogPreference,
2732                    com.android.internal.R.attr.alertDialogStyle, 0);
2733            mDialogBuilder = new AlertDialog.Builder(context)
2734                    .setOnCancelListener(new OnCancelListener() {
2735                        @Override
2736                        public void onCancel(DialogInterface dialog) {
2737                            hideInputMethodMenu();
2738                        }
2739                    })
2740                    .setIcon(a.getDrawable(
2741                            com.android.internal.R.styleable.DialogPreference_dialogTitle));
2742            a.recycle();
2743            final LayoutInflater inflater =
2744                    (LayoutInflater)mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
2745            final View tv = inflater.inflate(
2746                    com.android.internal.R.layout.input_method_switch_dialog_title, null);
2747            mDialogBuilder.setCustomTitle(tv);
2748
2749            // Setup layout for a toggle switch of the hardware keyboard
2750            mSwitchingDialogTitleView = tv;
2751            mSwitchingDialogTitleView.findViewById(
2752                    com.android.internal.R.id.hard_keyboard_section).setVisibility(
2753                            mWindowManagerService.isHardKeyboardAvailable() ?
2754                                    View.VISIBLE : View.GONE);
2755            final Switch hardKeySwitch =  ((Switch)mSwitchingDialogTitleView.findViewById(
2756                    com.android.internal.R.id.hard_keyboard_switch));
2757            hardKeySwitch.setChecked(mWindowManagerService.isHardKeyboardEnabled());
2758            hardKeySwitch.setOnCheckedChangeListener(
2759                    new OnCheckedChangeListener() {
2760                        @Override
2761                        public void onCheckedChanged(
2762                                CompoundButton buttonView, boolean isChecked) {
2763                            mWindowManagerService.setHardKeyboardEnabled(isChecked);
2764                            // Ensure that the input method dialog is dismissed when changing
2765                            // the hardware keyboard state.
2766                            hideInputMethodMenu();
2767                        }
2768                    });
2769
2770            final ImeSubtypeListAdapter adapter = new ImeSubtypeListAdapter(context,
2771                    com.android.internal.R.layout.simple_list_item_2_single_choice, imList,
2772                    checkedItem);
2773
2774            mDialogBuilder.setSingleChoiceItems(adapter, checkedItem,
2775                    new AlertDialog.OnClickListener() {
2776                        @Override
2777                        public void onClick(DialogInterface dialog, int which) {
2778                            synchronized (mMethodMap) {
2779                                if (mIms == null || mIms.length <= which
2780                                        || mSubtypeIds == null || mSubtypeIds.length <= which) {
2781                                    return;
2782                                }
2783                                InputMethodInfo im = mIms[which];
2784                                int subtypeId = mSubtypeIds[which];
2785                                adapter.mCheckedItem = which;
2786                                adapter.notifyDataSetChanged();
2787                                hideInputMethodMenu();
2788                                if (im != null) {
2789                                    if ((subtypeId < 0)
2790                                            || (subtypeId >= im.getSubtypeCount())) {
2791                                        subtypeId = NOT_A_SUBTYPE_ID;
2792                                    }
2793                                    setInputMethodLocked(im.getId(), subtypeId);
2794                                }
2795                            }
2796                        }
2797                    });
2798
2799            if (showSubtypes && !isScreenLocked) {
2800                mDialogBuilder.setPositiveButton(
2801                        com.android.internal.R.string.configure_input_methods,
2802                        new DialogInterface.OnClickListener() {
2803                            @Override
2804                            public void onClick(DialogInterface dialog, int whichButton) {
2805                                showConfigureInputMethods();
2806                            }
2807                        });
2808            }
2809            mSwitchingDialog = mDialogBuilder.create();
2810            mSwitchingDialog.setCanceledOnTouchOutside(true);
2811            mSwitchingDialog.getWindow().setType(
2812                    WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG);
2813            mSwitchingDialog.getWindow().getAttributes().privateFlags |=
2814                    WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
2815            mSwitchingDialog.getWindow().getAttributes().setTitle("Select input method");
2816            updateImeWindowStatusLocked();
2817            mSwitchingDialog.show();
2818        }
2819    }
2820
2821    private static class ImeSubtypeListAdapter extends ArrayAdapter<ImeSubtypeListItem> {
2822        private final LayoutInflater mInflater;
2823        private final int mTextViewResourceId;
2824        private final List<ImeSubtypeListItem> mItemsList;
2825        public int mCheckedItem;
2826        public ImeSubtypeListAdapter(Context context, int textViewResourceId,
2827                List<ImeSubtypeListItem> itemsList, int checkedItem) {
2828            super(context, textViewResourceId, itemsList);
2829            mTextViewResourceId = textViewResourceId;
2830            mItemsList = itemsList;
2831            mCheckedItem = checkedItem;
2832            mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
2833        }
2834
2835        @Override
2836        public View getView(int position, View convertView, ViewGroup parent) {
2837            final View view = convertView != null ? convertView
2838                    : mInflater.inflate(mTextViewResourceId, null);
2839            if (position < 0 || position >= mItemsList.size()) return view;
2840            final ImeSubtypeListItem item = mItemsList.get(position);
2841            final CharSequence imeName = item.mImeName;
2842            final CharSequence subtypeName = item.mSubtypeName;
2843            final TextView firstTextView = (TextView)view.findViewById(android.R.id.text1);
2844            final TextView secondTextView = (TextView)view.findViewById(android.R.id.text2);
2845            if (TextUtils.isEmpty(subtypeName)) {
2846                firstTextView.setText(imeName);
2847                secondTextView.setVisibility(View.GONE);
2848            } else {
2849                firstTextView.setText(subtypeName);
2850                secondTextView.setText(imeName);
2851                secondTextView.setVisibility(View.VISIBLE);
2852            }
2853            final RadioButton radioButton =
2854                    (RadioButton)view.findViewById(com.android.internal.R.id.radio);
2855            radioButton.setChecked(position == mCheckedItem);
2856            return view;
2857        }
2858    }
2859
2860    void hideInputMethodMenu() {
2861        synchronized (mMethodMap) {
2862            hideInputMethodMenuLocked();
2863        }
2864    }
2865
2866    void hideInputMethodMenuLocked() {
2867        if (DEBUG) Slog.v(TAG, "Hide switching menu");
2868
2869        if (mSwitchingDialog != null) {
2870            mSwitchingDialog.dismiss();
2871            mSwitchingDialog = null;
2872        }
2873
2874        updateImeWindowStatusLocked();
2875        mDialogBuilder = null;
2876        mIms = null;
2877    }
2878
2879    // ----------------------------------------------------------------------
2880
2881    @Override
2882    public boolean setInputMethodEnabled(String id, boolean enabled) {
2883        // TODO: Make this work even for non-current users?
2884        if (!calledFromValidUser()) {
2885            return false;
2886        }
2887        synchronized (mMethodMap) {
2888            if (mContext.checkCallingOrSelfPermission(
2889                    android.Manifest.permission.WRITE_SECURE_SETTINGS)
2890                    != PackageManager.PERMISSION_GRANTED) {
2891                throw new SecurityException(
2892                        "Requires permission "
2893                        + android.Manifest.permission.WRITE_SECURE_SETTINGS);
2894            }
2895
2896            long ident = Binder.clearCallingIdentity();
2897            try {
2898                return setInputMethodEnabledLocked(id, enabled);
2899            } finally {
2900                Binder.restoreCallingIdentity(ident);
2901            }
2902        }
2903    }
2904
2905    boolean setInputMethodEnabledLocked(String id, boolean enabled) {
2906        // Make sure this is a valid input method.
2907        InputMethodInfo imm = mMethodMap.get(id);
2908        if (imm == null) {
2909            throw new IllegalArgumentException("Unknown id: " + mCurMethodId);
2910        }
2911
2912        List<Pair<String, ArrayList<String>>> enabledInputMethodsList = mSettings
2913                .getEnabledInputMethodsAndSubtypeListLocked();
2914
2915        if (enabled) {
2916            for (Pair<String, ArrayList<String>> pair: enabledInputMethodsList) {
2917                if (pair.first.equals(id)) {
2918                    // We are enabling this input method, but it is already enabled.
2919                    // Nothing to do. The previous state was enabled.
2920                    return true;
2921                }
2922            }
2923            mSettings.appendAndPutEnabledInputMethodLocked(id, false);
2924            // Previous state was disabled.
2925            return false;
2926        } else {
2927            StringBuilder builder = new StringBuilder();
2928            if (mSettings.buildAndPutEnabledInputMethodsStrRemovingIdLocked(
2929                    builder, enabledInputMethodsList, id)) {
2930                // Disabled input method is currently selected, switch to another one.
2931                final String selId = mSettings.getSelectedInputMethod();
2932                if (id.equals(selId) && !chooseNewDefaultIMELocked()) {
2933                    Slog.i(TAG, "Can't find new IME, unsetting the current input method.");
2934                    resetSelectedInputMethodAndSubtypeLocked("");
2935                }
2936                // Previous state was enabled.
2937                return true;
2938            } else {
2939                // We are disabling the input method but it is already disabled.
2940                // Nothing to do.  The previous state was disabled.
2941                return false;
2942            }
2943        }
2944    }
2945
2946    private void setSelectedInputMethodAndSubtypeLocked(InputMethodInfo imi, int subtypeId,
2947            boolean setSubtypeOnly) {
2948        // Update the history of InputMethod and Subtype
2949        mSettings.saveCurrentInputMethodAndSubtypeToHistory(mCurMethodId, mCurrentSubtype);
2950
2951        // Set Subtype here
2952        if (imi == null || subtypeId < 0) {
2953            mSettings.putSelectedSubtype(NOT_A_SUBTYPE_ID);
2954            mCurrentSubtype = null;
2955        } else {
2956            if (subtypeId < imi.getSubtypeCount()) {
2957                InputMethodSubtype subtype = imi.getSubtypeAt(subtypeId);
2958                mSettings.putSelectedSubtype(subtype.hashCode());
2959                mCurrentSubtype = subtype;
2960            } else {
2961                mSettings.putSelectedSubtype(NOT_A_SUBTYPE_ID);
2962                // If the subtype is not specified, choose the most applicable one
2963                mCurrentSubtype = getCurrentInputMethodSubtypeLocked();
2964            }
2965        }
2966
2967        // Workaround.
2968        // ASEC is not ready in the IMMS constructor. Accordingly, forward-locked
2969        // IMEs are not recognized and considered uninstalled.
2970        // Actually, we can't move everything after SystemReady because
2971        // IMMS needs to run in the encryption lock screen. So, we just skip changing
2972        // the default IME here and try cheking the default IME again in systemReady().
2973        // TODO: Do nothing before system ready and implement a separated logic for
2974        // the encryption lock screen.
2975        // TODO: ASEC should be ready before IMMS is instantiated.
2976        if (mSystemReady && !setSubtypeOnly) {
2977            // Set InputMethod here
2978            mSettings.putSelectedInputMethod(imi != null ? imi.getId() : "");
2979        }
2980    }
2981
2982    private void resetSelectedInputMethodAndSubtypeLocked(String newDefaultIme) {
2983        InputMethodInfo imi = mMethodMap.get(newDefaultIme);
2984        int lastSubtypeId = NOT_A_SUBTYPE_ID;
2985        // newDefaultIme is empty when there is no candidate for the selected IME.
2986        if (imi != null && !TextUtils.isEmpty(newDefaultIme)) {
2987            String subtypeHashCode = mSettings.getLastSubtypeForInputMethodLocked(newDefaultIme);
2988            if (subtypeHashCode != null) {
2989                try {
2990                    lastSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(
2991                            imi, Integer.valueOf(subtypeHashCode));
2992                } catch (NumberFormatException e) {
2993                    Slog.w(TAG, "HashCode for subtype looks broken: " + subtypeHashCode, e);
2994                }
2995            }
2996        }
2997        setSelectedInputMethodAndSubtypeLocked(imi, lastSubtypeId, false);
2998    }
2999
3000    // If there are no selected shortcuts, tries finding the most applicable ones.
3001    private Pair<InputMethodInfo, InputMethodSubtype>
3002            findLastResortApplicableShortcutInputMethodAndSubtypeLocked(String mode) {
3003        List<InputMethodInfo> imis = mSettings.getEnabledInputMethodListLocked();
3004        InputMethodInfo mostApplicableIMI = null;
3005        InputMethodSubtype mostApplicableSubtype = null;
3006        boolean foundInSystemIME = false;
3007
3008        // Search applicable subtype for each InputMethodInfo
3009        for (InputMethodInfo imi: imis) {
3010            final String imiId = imi.getId();
3011            if (foundInSystemIME && !imiId.equals(mCurMethodId)) {
3012                continue;
3013            }
3014            InputMethodSubtype subtype = null;
3015            final List<InputMethodSubtype> enabledSubtypes =
3016                    mSettings.getEnabledInputMethodSubtypeListLocked(mContext, imi, true);
3017            // 1. Search by the current subtype's locale from enabledSubtypes.
3018            if (mCurrentSubtype != null) {
3019                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3020                        mRes, enabledSubtypes, mode, mCurrentSubtype.getLocale(), false);
3021            }
3022            // 2. Search by the system locale from enabledSubtypes.
3023            // 3. Search the first enabled subtype matched with mode from enabledSubtypes.
3024            if (subtype == null) {
3025                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3026                        mRes, enabledSubtypes, mode, null, true);
3027            }
3028            final ArrayList<InputMethodSubtype> overridingImplicitlyEnabledSubtypes =
3029                    InputMethodUtils.getOverridingImplicitlyEnabledSubtypes(imi, mode);
3030            final ArrayList<InputMethodSubtype> subtypesForSearch =
3031                    overridingImplicitlyEnabledSubtypes.isEmpty()
3032                            ? InputMethodUtils.getSubtypes(imi)
3033                            : overridingImplicitlyEnabledSubtypes;
3034            // 4. Search by the current subtype's locale from all subtypes.
3035            if (subtype == null && mCurrentSubtype != null) {
3036                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3037                        mRes, subtypesForSearch, mode, mCurrentSubtype.getLocale(), false);
3038            }
3039            // 5. Search by the system locale from all subtypes.
3040            // 6. Search the first enabled subtype matched with mode from all subtypes.
3041            if (subtype == null) {
3042                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3043                        mRes, subtypesForSearch, mode, null, true);
3044            }
3045            if (subtype != null) {
3046                if (imiId.equals(mCurMethodId)) {
3047                    // The current input method is the most applicable IME.
3048                    mostApplicableIMI = imi;
3049                    mostApplicableSubtype = subtype;
3050                    break;
3051                } else if (!foundInSystemIME) {
3052                    // The system input method is 2nd applicable IME.
3053                    mostApplicableIMI = imi;
3054                    mostApplicableSubtype = subtype;
3055                    if ((imi.getServiceInfo().applicationInfo.flags
3056                            & ApplicationInfo.FLAG_SYSTEM) != 0) {
3057                        foundInSystemIME = true;
3058                    }
3059                }
3060            }
3061        }
3062        if (DEBUG) {
3063            if (mostApplicableIMI != null) {
3064                Slog.w(TAG, "Most applicable shortcut input method was:"
3065                        + mostApplicableIMI.getId());
3066                if (mostApplicableSubtype != null) {
3067                    Slog.w(TAG, "Most applicable shortcut input method subtype was:"
3068                            + "," + mostApplicableSubtype.getMode() + ","
3069                            + mostApplicableSubtype.getLocale());
3070                }
3071            }
3072        }
3073        if (mostApplicableIMI != null) {
3074            return new Pair<InputMethodInfo, InputMethodSubtype> (mostApplicableIMI,
3075                    mostApplicableSubtype);
3076        } else {
3077            return null;
3078        }
3079    }
3080
3081    /**
3082     * @return Return the current subtype of this input method.
3083     */
3084    @Override
3085    public InputMethodSubtype getCurrentInputMethodSubtype() {
3086        // TODO: Make this work even for non-current users?
3087        if (!calledFromValidUser()) {
3088            return null;
3089        }
3090        synchronized (mMethodMap) {
3091            return getCurrentInputMethodSubtypeLocked();
3092        }
3093    }
3094
3095    private InputMethodSubtype getCurrentInputMethodSubtypeLocked() {
3096        if (mCurMethodId == null) {
3097            return null;
3098        }
3099        final boolean subtypeIsSelected = mSettings.isSubtypeSelected();
3100        final InputMethodInfo imi = mMethodMap.get(mCurMethodId);
3101        if (imi == null || imi.getSubtypeCount() == 0) {
3102            return null;
3103        }
3104        if (!subtypeIsSelected || mCurrentSubtype == null
3105                || !InputMethodUtils.isValidSubtypeId(imi, mCurrentSubtype.hashCode())) {
3106            int subtypeId = mSettings.getSelectedInputMethodSubtypeId(mCurMethodId);
3107            if (subtypeId == NOT_A_SUBTYPE_ID) {
3108                // If there are no selected subtypes, the framework will try to find
3109                // the most applicable subtype from explicitly or implicitly enabled
3110                // subtypes.
3111                List<InputMethodSubtype> explicitlyOrImplicitlyEnabledSubtypes =
3112                        mSettings.getEnabledInputMethodSubtypeListLocked(mContext, imi, true);
3113                // If there is only one explicitly or implicitly enabled subtype,
3114                // just returns it.
3115                if (explicitlyOrImplicitlyEnabledSubtypes.size() == 1) {
3116                    mCurrentSubtype = explicitlyOrImplicitlyEnabledSubtypes.get(0);
3117                } else if (explicitlyOrImplicitlyEnabledSubtypes.size() > 1) {
3118                    mCurrentSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3119                            mRes, explicitlyOrImplicitlyEnabledSubtypes,
3120                            InputMethodUtils.SUBTYPE_MODE_KEYBOARD, null, true);
3121                    if (mCurrentSubtype == null) {
3122                        mCurrentSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3123                                mRes, explicitlyOrImplicitlyEnabledSubtypes, null, null,
3124                                true);
3125                    }
3126                }
3127            } else {
3128                mCurrentSubtype = InputMethodUtils.getSubtypes(imi).get(subtypeId);
3129            }
3130        }
3131        return mCurrentSubtype;
3132    }
3133
3134    private void addShortcutInputMethodAndSubtypes(InputMethodInfo imi,
3135            InputMethodSubtype subtype) {
3136        if (mShortcutInputMethodsAndSubtypes.containsKey(imi)) {
3137            mShortcutInputMethodsAndSubtypes.get(imi).add(subtype);
3138        } else {
3139            ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();
3140            subtypes.add(subtype);
3141            mShortcutInputMethodsAndSubtypes.put(imi, subtypes);
3142        }
3143    }
3144
3145    // TODO: We should change the return type from List to List<Parcelable>
3146    @SuppressWarnings("rawtypes")
3147    @Override
3148    public List getShortcutInputMethodsAndSubtypes() {
3149        synchronized (mMethodMap) {
3150            ArrayList<Object> ret = new ArrayList<Object>();
3151            if (mShortcutInputMethodsAndSubtypes.size() == 0) {
3152                // If there are no selected shortcut subtypes, the framework will try to find
3153                // the most applicable subtype from all subtypes whose mode is
3154                // SUBTYPE_MODE_VOICE. This is an exceptional case, so we will hardcode the mode.
3155                Pair<InputMethodInfo, InputMethodSubtype> info =
3156                    findLastResortApplicableShortcutInputMethodAndSubtypeLocked(
3157                            InputMethodUtils.SUBTYPE_MODE_VOICE);
3158                if (info != null) {
3159                    ret.add(info.first);
3160                    ret.add(info.second);
3161                }
3162                return ret;
3163            }
3164            for (InputMethodInfo imi: mShortcutInputMethodsAndSubtypes.keySet()) {
3165                ret.add(imi);
3166                for (InputMethodSubtype subtype: mShortcutInputMethodsAndSubtypes.get(imi)) {
3167                    ret.add(subtype);
3168                }
3169            }
3170            return ret;
3171        }
3172    }
3173
3174    @Override
3175    public boolean setCurrentInputMethodSubtype(InputMethodSubtype subtype) {
3176        // TODO: Make this work even for non-current users?
3177        if (!calledFromValidUser()) {
3178            return false;
3179        }
3180        synchronized (mMethodMap) {
3181            if (subtype != null && mCurMethodId != null) {
3182                InputMethodInfo imi = mMethodMap.get(mCurMethodId);
3183                int subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(imi, subtype.hashCode());
3184                if (subtypeId != NOT_A_SUBTYPE_ID) {
3185                    setInputMethodLocked(mCurMethodId, subtypeId);
3186                    return true;
3187                }
3188            }
3189            return false;
3190        }
3191    }
3192
3193    // TODO: Cache the state for each user and reset when the cached user is removed.
3194    private static class InputMethodFileManager {
3195        private static final String SYSTEM_PATH = "system";
3196        private static final String INPUT_METHOD_PATH = "inputmethod";
3197        private static final String ADDITIONAL_SUBTYPES_FILE_NAME = "subtypes.xml";
3198        private static final String NODE_SUBTYPES = "subtypes";
3199        private static final String NODE_SUBTYPE = "subtype";
3200        private static final String NODE_IMI = "imi";
3201        private static final String ATTR_ID = "id";
3202        private static final String ATTR_LABEL = "label";
3203        private static final String ATTR_ICON = "icon";
3204        private static final String ATTR_IME_SUBTYPE_LOCALE = "imeSubtypeLocale";
3205        private static final String ATTR_IME_SUBTYPE_MODE = "imeSubtypeMode";
3206        private static final String ATTR_IME_SUBTYPE_EXTRA_VALUE = "imeSubtypeExtraValue";
3207        private static final String ATTR_IS_AUXILIARY = "isAuxiliary";
3208        private final AtomicFile mAdditionalInputMethodSubtypeFile;
3209        private final HashMap<String, InputMethodInfo> mMethodMap;
3210        private final HashMap<String, List<InputMethodSubtype>> mAdditionalSubtypesMap =
3211                new HashMap<String, List<InputMethodSubtype>>();
3212        public InputMethodFileManager(HashMap<String, InputMethodInfo> methodMap, int userId) {
3213            if (methodMap == null) {
3214                throw new NullPointerException("methodMap is null");
3215            }
3216            mMethodMap = methodMap;
3217            final File systemDir = userId == UserHandle.USER_OWNER
3218                    ? new File(Environment.getDataDirectory(), SYSTEM_PATH)
3219                    : Environment.getUserSystemDirectory(userId);
3220            final File inputMethodDir = new File(systemDir, INPUT_METHOD_PATH);
3221            if (!inputMethodDir.mkdirs()) {
3222                Slog.w(TAG, "Couldn't create dir.: " + inputMethodDir.getAbsolutePath());
3223            }
3224            final File subtypeFile = new File(inputMethodDir, ADDITIONAL_SUBTYPES_FILE_NAME);
3225            mAdditionalInputMethodSubtypeFile = new AtomicFile(subtypeFile);
3226            if (!subtypeFile.exists()) {
3227                // If "subtypes.xml" doesn't exist, create a blank file.
3228                writeAdditionalInputMethodSubtypes(
3229                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile, methodMap);
3230            } else {
3231                readAdditionalInputMethodSubtypes(
3232                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile);
3233            }
3234        }
3235
3236        private void deleteAllInputMethodSubtypes(String imiId) {
3237            synchronized (mMethodMap) {
3238                mAdditionalSubtypesMap.remove(imiId);
3239                writeAdditionalInputMethodSubtypes(
3240                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile, mMethodMap);
3241            }
3242        }
3243
3244        public void addInputMethodSubtypes(
3245                InputMethodInfo imi, InputMethodSubtype[] additionalSubtypes) {
3246            synchronized (mMethodMap) {
3247                final ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();
3248                final int N = additionalSubtypes.length;
3249                for (int i = 0; i < N; ++i) {
3250                    final InputMethodSubtype subtype = additionalSubtypes[i];
3251                    if (!subtypes.contains(subtype)) {
3252                        subtypes.add(subtype);
3253                    } else {
3254                        Slog.w(TAG, "Duplicated subtype definition found: "
3255                                + subtype.getLocale() + ", " + subtype.getMode());
3256                    }
3257                }
3258                mAdditionalSubtypesMap.put(imi.getId(), subtypes);
3259                writeAdditionalInputMethodSubtypes(
3260                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile, mMethodMap);
3261            }
3262        }
3263
3264        public HashMap<String, List<InputMethodSubtype>> getAllAdditionalInputMethodSubtypes() {
3265            synchronized (mMethodMap) {
3266                return mAdditionalSubtypesMap;
3267            }
3268        }
3269
3270        private static void writeAdditionalInputMethodSubtypes(
3271                HashMap<String, List<InputMethodSubtype>> allSubtypes, AtomicFile subtypesFile,
3272                HashMap<String, InputMethodInfo> methodMap) {
3273            // Safety net for the case that this function is called before methodMap is set.
3274            final boolean isSetMethodMap = methodMap != null && methodMap.size() > 0;
3275            FileOutputStream fos = null;
3276            try {
3277                fos = subtypesFile.startWrite();
3278                final XmlSerializer out = new FastXmlSerializer();
3279                out.setOutput(fos, "utf-8");
3280                out.startDocument(null, true);
3281                out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
3282                out.startTag(null, NODE_SUBTYPES);
3283                for (String imiId : allSubtypes.keySet()) {
3284                    if (isSetMethodMap && !methodMap.containsKey(imiId)) {
3285                        Slog.w(TAG, "IME uninstalled or not valid.: " + imiId);
3286                        continue;
3287                    }
3288                    out.startTag(null, NODE_IMI);
3289                    out.attribute(null, ATTR_ID, imiId);
3290                    final List<InputMethodSubtype> subtypesList = allSubtypes.get(imiId);
3291                    final int N = subtypesList.size();
3292                    for (int i = 0; i < N; ++i) {
3293                        final InputMethodSubtype subtype = subtypesList.get(i);
3294                        out.startTag(null, NODE_SUBTYPE);
3295                        out.attribute(null, ATTR_ICON, String.valueOf(subtype.getIconResId()));
3296                        out.attribute(null, ATTR_LABEL, String.valueOf(subtype.getNameResId()));
3297                        out.attribute(null, ATTR_IME_SUBTYPE_LOCALE, subtype.getLocale());
3298                        out.attribute(null, ATTR_IME_SUBTYPE_MODE, subtype.getMode());
3299                        out.attribute(null, ATTR_IME_SUBTYPE_EXTRA_VALUE, subtype.getExtraValue());
3300                        out.attribute(null, ATTR_IS_AUXILIARY,
3301                                String.valueOf(subtype.isAuxiliary() ? 1 : 0));
3302                        out.endTag(null, NODE_SUBTYPE);
3303                    }
3304                    out.endTag(null, NODE_IMI);
3305                }
3306                out.endTag(null, NODE_SUBTYPES);
3307                out.endDocument();
3308                subtypesFile.finishWrite(fos);
3309            } catch (java.io.IOException e) {
3310                Slog.w(TAG, "Error writing subtypes", e);
3311                if (fos != null) {
3312                    subtypesFile.failWrite(fos);
3313                }
3314            }
3315        }
3316
3317        private static void readAdditionalInputMethodSubtypes(
3318                HashMap<String, List<InputMethodSubtype>> allSubtypes, AtomicFile subtypesFile) {
3319            if (allSubtypes == null || subtypesFile == null) return;
3320            allSubtypes.clear();
3321            FileInputStream fis = null;
3322            try {
3323                fis = subtypesFile.openRead();
3324                final XmlPullParser parser = Xml.newPullParser();
3325                parser.setInput(fis, null);
3326                int type = parser.getEventType();
3327                // Skip parsing until START_TAG
3328                while ((type = parser.next()) != XmlPullParser.START_TAG
3329                        && type != XmlPullParser.END_DOCUMENT) {}
3330                String firstNodeName = parser.getName();
3331                if (!NODE_SUBTYPES.equals(firstNodeName)) {
3332                    throw new XmlPullParserException("Xml doesn't start with subtypes");
3333                }
3334                final int depth =parser.getDepth();
3335                String currentImiId = null;
3336                ArrayList<InputMethodSubtype> tempSubtypesArray = null;
3337                while (((type = parser.next()) != XmlPullParser.END_TAG
3338                        || parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
3339                    if (type != XmlPullParser.START_TAG)
3340                        continue;
3341                    final String nodeName = parser.getName();
3342                    if (NODE_IMI.equals(nodeName)) {
3343                        currentImiId = parser.getAttributeValue(null, ATTR_ID);
3344                        if (TextUtils.isEmpty(currentImiId)) {
3345                            Slog.w(TAG, "Invalid imi id found in subtypes.xml");
3346                            continue;
3347                        }
3348                        tempSubtypesArray = new ArrayList<InputMethodSubtype>();
3349                        allSubtypes.put(currentImiId, tempSubtypesArray);
3350                    } else if (NODE_SUBTYPE.equals(nodeName)) {
3351                        if (TextUtils.isEmpty(currentImiId) || tempSubtypesArray == null) {
3352                            Slog.w(TAG, "IME uninstalled or not valid.: " + currentImiId);
3353                            continue;
3354                        }
3355                        final int icon = Integer.valueOf(
3356                                parser.getAttributeValue(null, ATTR_ICON));
3357                        final int label = Integer.valueOf(
3358                                parser.getAttributeValue(null, ATTR_LABEL));
3359                        final String imeSubtypeLocale =
3360                                parser.getAttributeValue(null, ATTR_IME_SUBTYPE_LOCALE);
3361                        final String imeSubtypeMode =
3362                                parser.getAttributeValue(null, ATTR_IME_SUBTYPE_MODE);
3363                        final String imeSubtypeExtraValue =
3364                                parser.getAttributeValue(null, ATTR_IME_SUBTYPE_EXTRA_VALUE);
3365                        final boolean isAuxiliary = "1".equals(String.valueOf(
3366                                parser.getAttributeValue(null, ATTR_IS_AUXILIARY)));
3367                        final InputMethodSubtype subtype =
3368                                new InputMethodSubtype(label, icon, imeSubtypeLocale,
3369                                        imeSubtypeMode, imeSubtypeExtraValue, isAuxiliary);
3370                        tempSubtypesArray.add(subtype);
3371                    }
3372                }
3373            } catch (XmlPullParserException e) {
3374                Slog.w(TAG, "Error reading subtypes: " + e);
3375                return;
3376            } catch (java.io.IOException e) {
3377                Slog.w(TAG, "Error reading subtypes: " + e);
3378                return;
3379            } catch (NumberFormatException e) {
3380                Slog.w(TAG, "Error reading subtypes: " + e);
3381                return;
3382            } finally {
3383                if (fis != null) {
3384                    try {
3385                        fis.close();
3386                    } catch (java.io.IOException e1) {
3387                        Slog.w(TAG, "Failed to close.");
3388                    }
3389                }
3390            }
3391        }
3392    }
3393
3394    @Override
3395    protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
3396        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
3397                != PackageManager.PERMISSION_GRANTED) {
3398
3399            pw.println("Permission Denial: can't dump InputMethodManager from from pid="
3400                    + Binder.getCallingPid()
3401                    + ", uid=" + Binder.getCallingUid());
3402            return;
3403        }
3404
3405        IInputMethod method;
3406        ClientState client;
3407
3408        final Printer p = new PrintWriterPrinter(pw);
3409
3410        synchronized (mMethodMap) {
3411            p.println("Current Input Method Manager state:");
3412            int N = mMethodList.size();
3413            p.println("  Input Methods:");
3414            for (int i=0; i<N; i++) {
3415                InputMethodInfo info = mMethodList.get(i);
3416                p.println("  InputMethod #" + i + ":");
3417                info.dump(p, "    ");
3418            }
3419            p.println("  Clients:");
3420            for (ClientState ci : mClients.values()) {
3421                p.println("  Client " + ci + ":");
3422                p.println("    client=" + ci.client);
3423                p.println("    inputContext=" + ci.inputContext);
3424                p.println("    sessionRequested=" + ci.sessionRequested);
3425                p.println("    curSession=" + ci.curSession);
3426            }
3427            p.println("  mCurMethodId=" + mCurMethodId);
3428            client = mCurClient;
3429            p.println("  mCurClient=" + client + " mCurSeq=" + mCurSeq);
3430            p.println("  mCurFocusedWindow=" + mCurFocusedWindow);
3431            p.println("  mCurId=" + mCurId + " mHaveConnect=" + mHaveConnection
3432                    + " mBoundToMethod=" + mBoundToMethod);
3433            p.println("  mCurToken=" + mCurToken);
3434            p.println("  mCurIntent=" + mCurIntent);
3435            method = mCurMethod;
3436            p.println("  mCurMethod=" + mCurMethod);
3437            p.println("  mEnabledSession=" + mEnabledSession);
3438            p.println("  mShowRequested=" + mShowRequested
3439                    + " mShowExplicitlyRequested=" + mShowExplicitlyRequested
3440                    + " mShowForced=" + mShowForced
3441                    + " mInputShown=" + mInputShown);
3442            p.println("  mSystemReady=" + mSystemReady + " mScreenOn=" + mScreenOn);
3443        }
3444
3445        p.println(" ");
3446        if (client != null) {
3447            pw.flush();
3448            try {
3449                client.client.asBinder().dump(fd, args);
3450            } catch (RemoteException e) {
3451                p.println("Input method client dead: " + e);
3452            }
3453        } else {
3454            p.println("No input method client.");
3455        }
3456
3457        p.println(" ");
3458        if (method != null) {
3459            pw.flush();
3460            try {
3461                method.asBinder().dump(fd, args);
3462            } catch (RemoteException e) {
3463                p.println("Input method service dead: " + e);
3464            }
3465        } else {
3466            p.println("No input method service.");
3467        }
3468    }
3469}
3470