InputMethodManagerService.java revision b7b7907fb5e4b2252b3c594a6bc4402217fe662a 
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 (isScreenLocked()) return false;
1468        synchronized (mMethodMap) {
1469            List<InputMethodInfo> imis = mSettings.getEnabledInputMethodListLocked();
1470            final int N = imis.size();
1471            if (N > 2) return true;
1472            if (N < 1) return false;
1473            int nonAuxCount = 0;
1474            int auxCount = 0;
1475            InputMethodSubtype nonAuxSubtype = null;
1476            InputMethodSubtype auxSubtype = null;
1477            for(int i = 0; i < N; ++i) {
1478                final InputMethodInfo imi = imis.get(i);
1479                final List<InputMethodSubtype> subtypes =
1480                        mSettings.getEnabledInputMethodSubtypeListLocked(mContext, imi, true);
1481                final int subtypeCount = subtypes.size();
1482                if (subtypeCount == 0) {
1483                    ++nonAuxCount;
1484                } else {
1485                    for (int j = 0; j < subtypeCount; ++j) {
1486                        final InputMethodSubtype subtype = subtypes.get(j);
1487                        if (!subtype.isAuxiliary()) {
1488                            ++nonAuxCount;
1489                            nonAuxSubtype = subtype;
1490                        } else {
1491                            ++auxCount;
1492                            auxSubtype = subtype;
1493                        }
1494                    }
1495                }
1496            }
1497            if (nonAuxCount > 1 || auxCount > 1) {
1498                return true;
1499            } else if (nonAuxCount == 1 && auxCount == 1) {
1500                if (nonAuxSubtype != null && auxSubtype != null
1501                        && (nonAuxSubtype.getLocale().equals(auxSubtype.getLocale())
1502                                || auxSubtype.overridesImplicitlyEnabledSubtype()
1503                                || nonAuxSubtype.overridesImplicitlyEnabledSubtype())
1504                        && nonAuxSubtype.containsExtraValueKey(TAG_TRY_SUPPRESSING_IME_SWITCHER)) {
1505                    return false;
1506                }
1507                return true;
1508            }
1509            return false;
1510        }
1511    }
1512
1513    private boolean isKeyguardLocked() {
1514        return mKeyguardManager != null && mKeyguardManager.isKeyguardLocked();
1515    }
1516
1517    // Caution! This method is called in this class. Handle multi-user carefully
1518    @SuppressWarnings("deprecation")
1519    @Override
1520    public void setImeWindowStatus(IBinder token, int vis, int backDisposition) {
1521        final long ident = Binder.clearCallingIdentity();
1522        try {
1523            if (token == null || mCurToken != token) {
1524                int uid = Binder.getCallingUid();
1525                Slog.w(TAG, "Ignoring setImeWindowStatus of uid " + uid + " token: " + token);
1526                return;
1527            }
1528            synchronized (mMethodMap) {
1529                // apply policy for binder calls
1530                if (vis != 0 && isKeyguardLocked() && !mCurClientInKeyguard) {
1531                    vis = 0;
1532                }
1533                mImeWindowVis = vis;
1534                mBackDisposition = backDisposition;
1535                if (mStatusBar != null) {
1536                    mStatusBar.setImeWindowStatus(token, vis, backDisposition);
1537                }
1538                final boolean iconVisibility = ((vis & (InputMethodService.IME_ACTIVE)) != 0)
1539                        && (mWindowManagerService.isHardKeyboardAvailable()
1540                                || (vis & (InputMethodService.IME_VISIBLE)) != 0);
1541                final InputMethodInfo imi = mMethodMap.get(mCurMethodId);
1542                if (imi != null && iconVisibility && needsToShowImeSwitchOngoingNotification()) {
1543                    // Used to load label
1544                    final CharSequence title = mRes.getText(
1545                            com.android.internal.R.string.select_input_method);
1546                    final CharSequence summary = InputMethodUtils.getImeAndSubtypeDisplayName(
1547                            mContext, imi, mCurrentSubtype);
1548
1549                    mImeSwitcherNotification.setLatestEventInfo(
1550                            mContext, title, summary, mImeSwitchPendingIntent);
1551                    if (mNotificationManager != null) {
1552                        if (DEBUG) {
1553                            Slog.d(TAG, "--- show notification: label =  " + summary);
1554                        }
1555                        mNotificationManager.notifyAsUser(null,
1556                                com.android.internal.R.string.select_input_method,
1557                                mImeSwitcherNotification, UserHandle.ALL);
1558                        mNotificationShown = true;
1559                    }
1560                } else {
1561                    if (mNotificationShown && mNotificationManager != null) {
1562                        if (DEBUG) {
1563                            Slog.d(TAG, "--- hide notification");
1564                        }
1565                        mNotificationManager.cancelAsUser(null,
1566                                com.android.internal.R.string.select_input_method, UserHandle.ALL);
1567                        mNotificationShown = false;
1568                    }
1569                }
1570            }
1571        } finally {
1572            Binder.restoreCallingIdentity(ident);
1573        }
1574    }
1575
1576    @Override
1577    public void registerSuggestionSpansForNotification(SuggestionSpan[] spans) {
1578        if (!calledFromValidUser()) {
1579            return;
1580        }
1581        synchronized (mMethodMap) {
1582            final InputMethodInfo currentImi = mMethodMap.get(mCurMethodId);
1583            for (int i = 0; i < spans.length; ++i) {
1584                SuggestionSpan ss = spans[i];
1585                if (!TextUtils.isEmpty(ss.getNotificationTargetClassName())) {
1586                    mSecureSuggestionSpans.put(ss, currentImi);
1587                }
1588            }
1589        }
1590    }
1591
1592    @Override
1593    public boolean notifySuggestionPicked(SuggestionSpan span, String originalString, int index) {
1594        if (!calledFromValidUser()) {
1595            return false;
1596        }
1597        synchronized (mMethodMap) {
1598            final InputMethodInfo targetImi = mSecureSuggestionSpans.get(span);
1599            // TODO: Do not send the intent if the process of the targetImi is already dead.
1600            if (targetImi != null) {
1601                final String[] suggestions = span.getSuggestions();
1602                if (index < 0 || index >= suggestions.length) return false;
1603                final String className = span.getNotificationTargetClassName();
1604                final Intent intent = new Intent();
1605                // Ensures that only a class in the original IME package will receive the
1606                // notification.
1607                intent.setClassName(targetImi.getPackageName(), className);
1608                intent.setAction(SuggestionSpan.ACTION_SUGGESTION_PICKED);
1609                intent.putExtra(SuggestionSpan.SUGGESTION_SPAN_PICKED_BEFORE, originalString);
1610                intent.putExtra(SuggestionSpan.SUGGESTION_SPAN_PICKED_AFTER, suggestions[index]);
1611                intent.putExtra(SuggestionSpan.SUGGESTION_SPAN_PICKED_HASHCODE, span.hashCode());
1612                final long ident = Binder.clearCallingIdentity();
1613                try {
1614                    mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT);
1615                } finally {
1616                    Binder.restoreCallingIdentity(ident);
1617                }
1618                return true;
1619            }
1620        }
1621        return false;
1622    }
1623
1624    void updateFromSettingsLocked(boolean enabledMayChange) {
1625        if (enabledMayChange) {
1626            List<InputMethodInfo> enabled = mSettings.getEnabledInputMethodListLocked();
1627            for (int i=0; i<enabled.size(); i++) {
1628                // We allow the user to select "disabled until used" apps, so if they
1629                // are enabling one of those here we now need to make it enabled.
1630                InputMethodInfo imm = enabled.get(i);
1631                try {
1632                    ApplicationInfo ai = mIPackageManager.getApplicationInfo(imm.getPackageName(),
1633                            PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS,
1634                            mSettings.getCurrentUserId());
1635                    if (ai != null && ai.enabledSetting
1636                            == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED) {
1637                        if (DEBUG) {
1638                            Slog.d(TAG, "Update state(" + imm.getId()
1639                                    + "): DISABLED_UNTIL_USED -> DEFAULT");
1640                        }
1641                        mIPackageManager.setApplicationEnabledSetting(imm.getPackageName(),
1642                                PackageManager.COMPONENT_ENABLED_STATE_DEFAULT,
1643                                PackageManager.DONT_KILL_APP, mSettings.getCurrentUserId(),
1644                                mContext.getBasePackageName());
1645                    }
1646                } catch (RemoteException e) {
1647                }
1648            }
1649        }
1650        // We are assuming that whoever is changing DEFAULT_INPUT_METHOD and
1651        // ENABLED_INPUT_METHODS is taking care of keeping them correctly in
1652        // sync, so we will never have a DEFAULT_INPUT_METHOD that is not
1653        // enabled.
1654        String id = mSettings.getSelectedInputMethod();
1655        // There is no input method selected, try to choose new applicable input method.
1656        if (TextUtils.isEmpty(id) && chooseNewDefaultIMELocked()) {
1657            id = mSettings.getSelectedInputMethod();
1658        }
1659        if (!TextUtils.isEmpty(id)) {
1660            try {
1661                setInputMethodLocked(id, mSettings.getSelectedInputMethodSubtypeId(id));
1662            } catch (IllegalArgumentException e) {
1663                Slog.w(TAG, "Unknown input method from prefs: " + id, e);
1664                mCurMethodId = null;
1665                unbindCurrentMethodLocked(true, false);
1666            }
1667            mShortcutInputMethodsAndSubtypes.clear();
1668        } else {
1669            // There is no longer an input method set, so stop any current one.
1670            mCurMethodId = null;
1671            unbindCurrentMethodLocked(true, false);
1672        }
1673    }
1674
1675    /* package */ void setInputMethodLocked(String id, int subtypeId) {
1676        InputMethodInfo info = mMethodMap.get(id);
1677        if (info == null) {
1678            throw new IllegalArgumentException("Unknown id: " + id);
1679        }
1680
1681        // See if we need to notify a subtype change within the same IME.
1682        if (id.equals(mCurMethodId)) {
1683            final int subtypeCount = info.getSubtypeCount();
1684            if (subtypeCount <= 0) {
1685                return;
1686            }
1687            final InputMethodSubtype oldSubtype = mCurrentSubtype;
1688            final InputMethodSubtype newSubtype;
1689            if (subtypeId >= 0 && subtypeId < subtypeCount) {
1690                newSubtype = info.getSubtypeAt(subtypeId);
1691            } else {
1692                // If subtype is null, try to find the most applicable one from
1693                // getCurrentInputMethodSubtype.
1694                newSubtype = getCurrentInputMethodSubtypeLocked();
1695            }
1696            if (newSubtype == null || oldSubtype == null) {
1697                Slog.w(TAG, "Illegal subtype state: old subtype = " + oldSubtype
1698                        + ", new subtype = " + newSubtype);
1699                return;
1700            }
1701            if (newSubtype != oldSubtype) {
1702                setSelectedInputMethodAndSubtypeLocked(info, subtypeId, true);
1703                if (mCurMethod != null) {
1704                    try {
1705                        refreshImeWindowVisibilityLocked();
1706                        mCurMethod.changeInputMethodSubtype(newSubtype);
1707                    } catch (RemoteException e) {
1708                        Slog.w(TAG, "Failed to call changeInputMethodSubtype");
1709                    }
1710                }
1711            }
1712            return;
1713        }
1714
1715        // Changing to a different IME.
1716        final long ident = Binder.clearCallingIdentity();
1717        try {
1718            // Set a subtype to this input method.
1719            // subtypeId the name of a subtype which will be set.
1720            setSelectedInputMethodAndSubtypeLocked(info, subtypeId, false);
1721            // mCurMethodId should be updated after setSelectedInputMethodAndSubtypeLocked()
1722            // because mCurMethodId is stored as a history in
1723            // setSelectedInputMethodAndSubtypeLocked().
1724            mCurMethodId = id;
1725
1726            if (ActivityManagerNative.isSystemReady()) {
1727                Intent intent = new Intent(Intent.ACTION_INPUT_METHOD_CHANGED);
1728                intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
1729                intent.putExtra("input_method_id", id);
1730                mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT);
1731            }
1732            unbindCurrentClientLocked();
1733        } finally {
1734            Binder.restoreCallingIdentity(ident);
1735        }
1736    }
1737
1738    @Override
1739    public boolean showSoftInput(IInputMethodClient client, int flags,
1740            ResultReceiver resultReceiver) {
1741        if (!calledFromValidUser()) {
1742            return false;
1743        }
1744        int uid = Binder.getCallingUid();
1745        long ident = Binder.clearCallingIdentity();
1746        try {
1747            synchronized (mMethodMap) {
1748                if (mCurClient == null || client == null
1749                        || mCurClient.client.asBinder() != client.asBinder()) {
1750                    try {
1751                        // We need to check if this is the current client with
1752                        // focus in the window manager, to allow this call to
1753                        // be made before input is started in it.
1754                        if (!mIWindowManager.inputMethodClientHasFocus(client)) {
1755                            Slog.w(TAG, "Ignoring showSoftInput of uid " + uid + ": " + client);
1756                            return false;
1757                        }
1758                    } catch (RemoteException e) {
1759                        return false;
1760                    }
1761                }
1762
1763                if (DEBUG) Slog.v(TAG, "Client requesting input be shown");
1764                return showCurrentInputLocked(flags, resultReceiver);
1765            }
1766        } finally {
1767            Binder.restoreCallingIdentity(ident);
1768        }
1769    }
1770
1771    boolean showCurrentInputLocked(int flags, ResultReceiver resultReceiver) {
1772        mShowRequested = true;
1773        if ((flags&InputMethodManager.SHOW_IMPLICIT) == 0) {
1774            mShowExplicitlyRequested = true;
1775        }
1776        if ((flags&InputMethodManager.SHOW_FORCED) != 0) {
1777            mShowExplicitlyRequested = true;
1778            mShowForced = true;
1779        }
1780
1781        if (!mSystemReady) {
1782            return false;
1783        }
1784
1785        boolean res = false;
1786        if (mCurMethod != null) {
1787            if (DEBUG) Slog.d(TAG, "showCurrentInputLocked: mCurToken=" + mCurToken);
1788            executeOrSendMessage(mCurMethod, mCaller.obtainMessageIOO(
1789                    MSG_SHOW_SOFT_INPUT, getImeShowFlags(), mCurMethod,
1790                    resultReceiver));
1791            mInputShown = true;
1792            if (mHaveConnection && !mVisibleBound) {
1793                bindCurrentInputMethodService(
1794                        mCurIntent, mVisibleConnection, Context.BIND_AUTO_CREATE
1795                                | Context.BIND_TREAT_LIKE_ACTIVITY);
1796                mVisibleBound = true;
1797            }
1798            res = true;
1799        } else if (mHaveConnection && SystemClock.uptimeMillis()
1800                >= (mLastBindTime+TIME_TO_RECONNECT)) {
1801            // The client has asked to have the input method shown, but
1802            // we have been sitting here too long with a connection to the
1803            // service and no interface received, so let's disconnect/connect
1804            // to try to prod things along.
1805            EventLog.writeEvent(EventLogTags.IMF_FORCE_RECONNECT_IME, mCurMethodId,
1806                    SystemClock.uptimeMillis()-mLastBindTime,1);
1807            Slog.w(TAG, "Force disconnect/connect to the IME in showCurrentInputLocked()");
1808            mContext.unbindService(this);
1809            bindCurrentInputMethodService(mCurIntent, this, Context.BIND_AUTO_CREATE
1810                    | Context.BIND_NOT_VISIBLE);
1811        } else {
1812            if (DEBUG) {
1813                Slog.d(TAG, "Can't show input: connection = " + mHaveConnection + ", time = "
1814                        + ((mLastBindTime+TIME_TO_RECONNECT) - SystemClock.uptimeMillis()));
1815            }
1816        }
1817
1818        return res;
1819    }
1820
1821    @Override
1822    public boolean hideSoftInput(IInputMethodClient client, int flags,
1823            ResultReceiver resultReceiver) {
1824        if (!calledFromValidUser()) {
1825            return false;
1826        }
1827        int uid = Binder.getCallingUid();
1828        long ident = Binder.clearCallingIdentity();
1829        try {
1830            synchronized (mMethodMap) {
1831                if (mCurClient == null || client == null
1832                        || mCurClient.client.asBinder() != client.asBinder()) {
1833                    try {
1834                        // We need to check if this is the current client with
1835                        // focus in the window manager, to allow this call to
1836                        // be made before input is started in it.
1837                        if (!mIWindowManager.inputMethodClientHasFocus(client)) {
1838                            if (DEBUG) Slog.w(TAG, "Ignoring hideSoftInput of uid "
1839                                    + uid + ": " + client);
1840                            setImeWindowVisibilityStatusHiddenLocked();
1841                            return false;
1842                        }
1843                    } catch (RemoteException e) {
1844                        setImeWindowVisibilityStatusHiddenLocked();
1845                        return false;
1846                    }
1847                }
1848
1849                if (DEBUG) Slog.v(TAG, "Client requesting input be hidden");
1850                return hideCurrentInputLocked(flags, resultReceiver);
1851            }
1852        } finally {
1853            Binder.restoreCallingIdentity(ident);
1854        }
1855    }
1856
1857    boolean hideCurrentInputLocked(int flags, ResultReceiver resultReceiver) {
1858        if ((flags&InputMethodManager.HIDE_IMPLICIT_ONLY) != 0
1859                && (mShowExplicitlyRequested || mShowForced)) {
1860            if (DEBUG) Slog.v(TAG, "Not hiding: explicit show not cancelled by non-explicit hide");
1861            return false;
1862        }
1863        if (mShowForced && (flags&InputMethodManager.HIDE_NOT_ALWAYS) != 0) {
1864            if (DEBUG) Slog.v(TAG, "Not hiding: forced show not cancelled by not-always hide");
1865            return false;
1866        }
1867        boolean res;
1868        if (mInputShown && mCurMethod != null) {
1869            executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO(
1870                    MSG_HIDE_SOFT_INPUT, mCurMethod, resultReceiver));
1871            res = true;
1872        } else {
1873            res = false;
1874        }
1875        if (mHaveConnection && mVisibleBound) {
1876            mContext.unbindService(mVisibleConnection);
1877            mVisibleBound = false;
1878        }
1879        mInputShown = false;
1880        mShowRequested = false;
1881        mShowExplicitlyRequested = false;
1882        mShowForced = false;
1883        return res;
1884    }
1885
1886    @Override
1887    public InputBindResult windowGainedFocus(IInputMethodClient client, IBinder windowToken,
1888            int controlFlags, int softInputMode, int windowFlags,
1889            EditorInfo attribute, IInputContext inputContext) {
1890        // Needs to check the validity before clearing calling identity
1891        final boolean calledFromValidUser = calledFromValidUser();
1892
1893        InputBindResult res = null;
1894        long ident = Binder.clearCallingIdentity();
1895        try {
1896            synchronized (mMethodMap) {
1897                if (DEBUG) Slog.v(TAG, "windowGainedFocus: " + client.asBinder()
1898                        + " controlFlags=#" + Integer.toHexString(controlFlags)
1899                        + " softInputMode=#" + Integer.toHexString(softInputMode)
1900                        + " windowFlags=#" + Integer.toHexString(windowFlags));
1901
1902                ClientState cs = mClients.get(client.asBinder());
1903                if (cs == null) {
1904                    throw new IllegalArgumentException("unknown client "
1905                            + client.asBinder());
1906                }
1907
1908                try {
1909                    if (!mIWindowManager.inputMethodClientHasFocus(cs.client)) {
1910                        // Check with the window manager to make sure this client actually
1911                        // has a window with focus.  If not, reject.  This is thread safe
1912                        // because if the focus changes some time before or after, the
1913                        // next client receiving focus that has any interest in input will
1914                        // be calling through here after that change happens.
1915                        Slog.w(TAG, "Focus gain on non-focused client " + cs.client
1916                                + " (uid=" + cs.uid + " pid=" + cs.pid + ")");
1917                        return null;
1918                    }
1919                } catch (RemoteException e) {
1920                }
1921
1922                if (!calledFromValidUser) {
1923                    Slog.w(TAG, "A background user is requesting window. Hiding IME.");
1924                    Slog.w(TAG, "If you want to interect with IME, you need "
1925                            + "android.permission.INTERACT_ACROSS_USERS_FULL");
1926                    hideCurrentInputLocked(0, null);
1927                    return null;
1928                }
1929
1930                if (mCurFocusedWindow == windowToken) {
1931                    Slog.w(TAG, "Window already focused, ignoring focus gain of: " + client
1932                            + " attribute=" + attribute + ", token = " + windowToken);
1933                    if (attribute != null) {
1934                        return startInputUncheckedLocked(cs, inputContext, attribute,
1935                                controlFlags);
1936                    }
1937                    return null;
1938                }
1939                mCurFocusedWindow = windowToken;
1940
1941                // Should we auto-show the IME even if the caller has not
1942                // specified what should be done with it?
1943                // We only do this automatically if the window can resize
1944                // to accommodate the IME (so what the user sees will give
1945                // them good context without input information being obscured
1946                // by the IME) or if running on a large screen where there
1947                // is more room for the target window + IME.
1948                final boolean doAutoShow =
1949                        (softInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST)
1950                                == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
1951                        || mRes.getConfiguration().isLayoutSizeAtLeast(
1952                                Configuration.SCREENLAYOUT_SIZE_LARGE);
1953                final boolean isTextEditor =
1954                        (controlFlags&InputMethodManager.CONTROL_WINDOW_IS_TEXT_EDITOR) != 0;
1955
1956                // We want to start input before showing the IME, but after closing
1957                // it.  We want to do this after closing it to help the IME disappear
1958                // more quickly (not get stuck behind it initializing itself for the
1959                // new focused input, even if its window wants to hide the IME).
1960                boolean didStart = false;
1961
1962                switch (softInputMode&WindowManager.LayoutParams.SOFT_INPUT_MASK_STATE) {
1963                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED:
1964                        if (!isTextEditor || !doAutoShow) {
1965                            if (WindowManager.LayoutParams.mayUseInputMethod(windowFlags)) {
1966                                // There is no focus view, and this window will
1967                                // be behind any soft input window, so hide the
1968                                // soft input window if it is shown.
1969                                if (DEBUG) Slog.v(TAG, "Unspecified window will hide input");
1970                                hideCurrentInputLocked(InputMethodManager.HIDE_NOT_ALWAYS, null);
1971                            }
1972                        } else if (isTextEditor && doAutoShow && (softInputMode &
1973                                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
1974                            // There is a focus view, and we are navigating forward
1975                            // into the window, so show the input window for the user.
1976                            // We only do this automatically if the window can resize
1977                            // to accommodate the IME (so what the user sees will give
1978                            // them good context without input information being obscured
1979                            // by the IME) or if running on a large screen where there
1980                            // is more room for the target window + IME.
1981                            if (DEBUG) Slog.v(TAG, "Unspecified window will show input");
1982                            if (attribute != null) {
1983                                res = startInputUncheckedLocked(cs, inputContext, attribute,
1984                                        controlFlags);
1985                                didStart = true;
1986                            }
1987                            showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT, null);
1988                        }
1989                        break;
1990                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED:
1991                        // Do nothing.
1992                        break;
1993                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN:
1994                        if ((softInputMode &
1995                                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
1996                            if (DEBUG) Slog.v(TAG, "Window asks to hide input going forward");
1997                            hideCurrentInputLocked(0, null);
1998                        }
1999                        break;
2000                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN:
2001                        if (DEBUG) Slog.v(TAG, "Window asks to hide input");
2002                        hideCurrentInputLocked(0, null);
2003                        break;
2004                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE:
2005                        if ((softInputMode &
2006                                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
2007                            if (DEBUG) Slog.v(TAG, "Window asks to show input going forward");
2008                            if (attribute != null) {
2009                                res = startInputUncheckedLocked(cs, inputContext, attribute,
2010                                        controlFlags);
2011                                didStart = true;
2012                            }
2013                            showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT, null);
2014                        }
2015                        break;
2016                    case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE:
2017                        if (DEBUG) Slog.v(TAG, "Window asks to always show input");
2018                        if (attribute != null) {
2019                            res = startInputUncheckedLocked(cs, inputContext, attribute,
2020                                    controlFlags);
2021                            didStart = true;
2022                        }
2023                        showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT, null);
2024                        break;
2025                }
2026
2027                if (!didStart && attribute != null) {
2028                    res = startInputUncheckedLocked(cs, inputContext, attribute,
2029                            controlFlags);
2030                }
2031            }
2032        } finally {
2033            Binder.restoreCallingIdentity(ident);
2034        }
2035
2036        return res;
2037    }
2038
2039    @Override
2040    public void showInputMethodPickerFromClient(IInputMethodClient client) {
2041        if (!calledFromValidUser()) {
2042            return;
2043        }
2044        synchronized (mMethodMap) {
2045            if (mCurClient == null || client == null
2046                    || mCurClient.client.asBinder() != client.asBinder()) {
2047                Slog.w(TAG, "Ignoring showInputMethodPickerFromClient of uid "
2048                        + Binder.getCallingUid() + ": " + client);
2049            }
2050
2051            // Always call subtype picker, because subtype picker is a superset of input method
2052            // picker.
2053            mHandler.sendEmptyMessage(MSG_SHOW_IM_SUBTYPE_PICKER);
2054        }
2055    }
2056
2057    @Override
2058    public void setInputMethod(IBinder token, String id) {
2059        if (!calledFromValidUser()) {
2060            return;
2061        }
2062        setInputMethodWithSubtypeId(token, id, NOT_A_SUBTYPE_ID);
2063    }
2064
2065    @Override
2066    public void setInputMethodAndSubtype(IBinder token, String id, InputMethodSubtype subtype) {
2067        if (!calledFromValidUser()) {
2068            return;
2069        }
2070        synchronized (mMethodMap) {
2071            if (subtype != null) {
2072                setInputMethodWithSubtypeId(token, id, InputMethodUtils.getSubtypeIdFromHashCode(
2073                        mMethodMap.get(id), subtype.hashCode()));
2074            } else {
2075                setInputMethod(token, id);
2076            }
2077        }
2078    }
2079
2080    @Override
2081    public void showInputMethodAndSubtypeEnablerFromClient(
2082            IInputMethodClient client, String inputMethodId) {
2083        if (!calledFromValidUser()) {
2084            return;
2085        }
2086        synchronized (mMethodMap) {
2087            if (mCurClient == null || client == null
2088                || mCurClient.client.asBinder() != client.asBinder()) {
2089                Slog.w(TAG, "Ignoring showInputMethodAndSubtypeEnablerFromClient of: " + client);
2090            }
2091            executeOrSendMessage(mCurMethod, mCaller.obtainMessageO(
2092                    MSG_SHOW_IM_SUBTYPE_ENABLER, inputMethodId));
2093        }
2094    }
2095
2096    @Override
2097    public boolean switchToLastInputMethod(IBinder token) {
2098        if (!calledFromValidUser()) {
2099            return false;
2100        }
2101        synchronized (mMethodMap) {
2102            final Pair<String, String> lastIme = mSettings.getLastInputMethodAndSubtypeLocked();
2103            final InputMethodInfo lastImi;
2104            if (lastIme != null) {
2105                lastImi = mMethodMap.get(lastIme.first);
2106            } else {
2107                lastImi = null;
2108            }
2109            String targetLastImiId = null;
2110            int subtypeId = NOT_A_SUBTYPE_ID;
2111            if (lastIme != null && lastImi != null) {
2112                final boolean imiIdIsSame = lastImi.getId().equals(mCurMethodId);
2113                final int lastSubtypeHash = Integer.valueOf(lastIme.second);
2114                final int currentSubtypeHash = mCurrentSubtype == null ? NOT_A_SUBTYPE_ID
2115                        : mCurrentSubtype.hashCode();
2116                // If the last IME is the same as the current IME and the last subtype is not
2117                // defined, there is no need to switch to the last IME.
2118                if (!imiIdIsSame || lastSubtypeHash != currentSubtypeHash) {
2119                    targetLastImiId = lastIme.first;
2120                    subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);
2121                }
2122            }
2123
2124            if (TextUtils.isEmpty(targetLastImiId)
2125                    && !InputMethodUtils.canAddToLastInputMethod(mCurrentSubtype)) {
2126                // This is a safety net. If the currentSubtype can't be added to the history
2127                // and the framework couldn't find the last ime, we will make the last ime be
2128                // the most applicable enabled keyboard subtype of the system imes.
2129                final List<InputMethodInfo> enabled = mSettings.getEnabledInputMethodListLocked();
2130                if (enabled != null) {
2131                    final int N = enabled.size();
2132                    final String locale = mCurrentSubtype == null
2133                            ? mRes.getConfiguration().locale.toString()
2134                            : mCurrentSubtype.getLocale();
2135                    for (int i = 0; i < N; ++i) {
2136                        final InputMethodInfo imi = enabled.get(i);
2137                        if (imi.getSubtypeCount() > 0 && InputMethodUtils.isSystemIme(imi)) {
2138                            InputMethodSubtype keyboardSubtype =
2139                                    InputMethodUtils.findLastResortApplicableSubtypeLocked(mRes,
2140                                            InputMethodUtils.getSubtypes(imi),
2141                                            InputMethodUtils.SUBTYPE_MODE_KEYBOARD, locale, true);
2142                            if (keyboardSubtype != null) {
2143                                targetLastImiId = imi.getId();
2144                                subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(
2145                                        imi, keyboardSubtype.hashCode());
2146                                if(keyboardSubtype.getLocale().equals(locale)) {
2147                                    break;
2148                                }
2149                            }
2150                        }
2151                    }
2152                }
2153            }
2154
2155            if (!TextUtils.isEmpty(targetLastImiId)) {
2156                if (DEBUG) {
2157                    Slog.d(TAG, "Switch to: " + lastImi.getId() + ", " + lastIme.second
2158                            + ", from: " + mCurMethodId + ", " + subtypeId);
2159                }
2160                setInputMethodWithSubtypeId(token, targetLastImiId, subtypeId);
2161                return true;
2162            } else {
2163                return false;
2164            }
2165        }
2166    }
2167
2168    @Override
2169    public boolean switchToNextInputMethod(IBinder token, boolean onlyCurrentIme) {
2170        if (!calledFromValidUser()) {
2171            return false;
2172        }
2173        synchronized (mMethodMap) {
2174            final ImeSubtypeListItem nextSubtype = mSwitchingController.getNextInputMethod(
2175                    onlyCurrentIme, mMethodMap.get(mCurMethodId), mCurrentSubtype);
2176            if (nextSubtype == null) {
2177                return false;
2178            }
2179            setInputMethodWithSubtypeId(token, nextSubtype.mImi.getId(), nextSubtype.mSubtypeId);
2180            return true;
2181        }
2182    }
2183
2184    @Override
2185    public boolean shouldOfferSwitchingToNextInputMethod(IBinder token) {
2186        if (!calledFromValidUser()) {
2187            return false;
2188        }
2189        synchronized (mMethodMap) {
2190            final ImeSubtypeListItem nextSubtype = mSwitchingController.getNextInputMethod(
2191                    false /* onlyCurrentIme */, mMethodMap.get(mCurMethodId), mCurrentSubtype);
2192            if (nextSubtype == null) {
2193                return false;
2194            }
2195            return true;
2196        }
2197    }
2198
2199    @Override
2200    public InputMethodSubtype getLastInputMethodSubtype() {
2201        if (!calledFromValidUser()) {
2202            return null;
2203        }
2204        synchronized (mMethodMap) {
2205            final Pair<String, String> lastIme = mSettings.getLastInputMethodAndSubtypeLocked();
2206            // TODO: Handle the case of the last IME with no subtypes
2207            if (lastIme == null || TextUtils.isEmpty(lastIme.first)
2208                    || TextUtils.isEmpty(lastIme.second)) return null;
2209            final InputMethodInfo lastImi = mMethodMap.get(lastIme.first);
2210            if (lastImi == null) return null;
2211            try {
2212                final int lastSubtypeHash = Integer.valueOf(lastIme.second);
2213                final int lastSubtypeId =
2214                        InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);
2215                if (lastSubtypeId < 0 || lastSubtypeId >= lastImi.getSubtypeCount()) {
2216                    return null;
2217                }
2218                return lastImi.getSubtypeAt(lastSubtypeId);
2219            } catch (NumberFormatException e) {
2220                return null;
2221            }
2222        }
2223    }
2224
2225    @Override
2226    public void setAdditionalInputMethodSubtypes(String imiId, InputMethodSubtype[] subtypes) {
2227        if (!calledFromValidUser()) {
2228            return;
2229        }
2230        // By this IPC call, only a process which shares the same uid with the IME can add
2231        // additional input method subtypes to the IME.
2232        if (TextUtils.isEmpty(imiId) || subtypes == null || subtypes.length == 0) return;
2233        synchronized (mMethodMap) {
2234            final InputMethodInfo imi = mMethodMap.get(imiId);
2235            if (imi == null) return;
2236            final String[] packageInfos;
2237            try {
2238                packageInfos = mIPackageManager.getPackagesForUid(Binder.getCallingUid());
2239            } catch (RemoteException e) {
2240                Slog.e(TAG, "Failed to get package infos");
2241                return;
2242            }
2243            if (packageInfos != null) {
2244                final int packageNum = packageInfos.length;
2245                for (int i = 0; i < packageNum; ++i) {
2246                    if (packageInfos[i].equals(imi.getPackageName())) {
2247                        mFileManager.addInputMethodSubtypes(imi, subtypes);
2248                        final long ident = Binder.clearCallingIdentity();
2249                        try {
2250                            buildInputMethodListLocked(mMethodList, mMethodMap,
2251                                    false /* resetDefaultEnabledIme */);
2252                        } finally {
2253                            Binder.restoreCallingIdentity(ident);
2254                        }
2255                        return;
2256                    }
2257                }
2258            }
2259        }
2260        return;
2261    }
2262
2263    @Override
2264    public int getInputMethodWindowVisibleHeight() {
2265        return mWindowManagerService.getInputMethodWindowVisibleHeight();
2266    }
2267
2268    @Override
2269    public void notifyTextCommitted() {
2270        if (DEBUG) {
2271            Slog.d(TAG, "Got the notification of commitText");
2272        }
2273        final InputMethodInfo imi = mMethodMap.get(mCurMethodId);
2274        if (imi != null) {
2275            mSwitchingController.onCommitText(imi, mCurrentSubtype);
2276        }
2277    }
2278
2279    @Override
2280    public void setCursorAnchorMonitorMode(IBinder token, int monitorMode) {
2281        if (DEBUG) {
2282            Slog.d(TAG, "setCursorAnchorMonitorMode: monitorMode=" + monitorMode);
2283        }
2284        if (!calledFromValidUser()) {
2285            return;
2286        }
2287        synchronized (mMethodMap) {
2288            if (token == null || mCurToken != token) {
2289                if (DEBUG) {
2290                    Slog.w(TAG, "Ignoring setCursorAnchorMonitorMode from uid "
2291                            + Binder.getCallingUid() + " token: " + token);
2292                }
2293                return;
2294            }
2295            executeOrSendMessage(mCurMethod, mCaller.obtainMessageIO(
2296                    MSG_SET_CURSOR_ANCHOR_MONITOR_MODE, monitorMode, mCurClient));
2297        }
2298    }
2299
2300    private void setInputMethodWithSubtypeId(IBinder token, String id, int subtypeId) {
2301        synchronized (mMethodMap) {
2302            if (token == null) {
2303                if (mContext.checkCallingOrSelfPermission(
2304                        android.Manifest.permission.WRITE_SECURE_SETTINGS)
2305                        != PackageManager.PERMISSION_GRANTED) {
2306                    throw new SecurityException(
2307                            "Using null token requires permission "
2308                            + android.Manifest.permission.WRITE_SECURE_SETTINGS);
2309                }
2310            } else if (mCurToken != token) {
2311                Slog.w(TAG, "Ignoring setInputMethod of uid " + Binder.getCallingUid()
2312                        + " token: " + token);
2313                return;
2314            }
2315
2316            final long ident = Binder.clearCallingIdentity();
2317            try {
2318                setInputMethodLocked(id, subtypeId);
2319            } finally {
2320                Binder.restoreCallingIdentity(ident);
2321            }
2322        }
2323    }
2324
2325    @Override
2326    public void hideMySoftInput(IBinder token, int flags) {
2327        if (!calledFromValidUser()) {
2328            return;
2329        }
2330        synchronized (mMethodMap) {
2331            if (token == null || mCurToken != token) {
2332                if (DEBUG) Slog.w(TAG, "Ignoring hideInputMethod of uid "
2333                        + Binder.getCallingUid() + " token: " + token);
2334                return;
2335            }
2336            long ident = Binder.clearCallingIdentity();
2337            try {
2338                hideCurrentInputLocked(flags, null);
2339            } finally {
2340                Binder.restoreCallingIdentity(ident);
2341            }
2342        }
2343    }
2344
2345    @Override
2346    public void showMySoftInput(IBinder token, int flags) {
2347        if (!calledFromValidUser()) {
2348            return;
2349        }
2350        synchronized (mMethodMap) {
2351            if (token == null || mCurToken != token) {
2352                Slog.w(TAG, "Ignoring showMySoftInput of uid "
2353                        + Binder.getCallingUid() + " token: " + token);
2354                return;
2355            }
2356            long ident = Binder.clearCallingIdentity();
2357            try {
2358                showCurrentInputLocked(flags, null);
2359            } finally {
2360                Binder.restoreCallingIdentity(ident);
2361            }
2362        }
2363    }
2364
2365    void setEnabledSessionInMainThread(SessionState session) {
2366        if (mEnabledSession != session) {
2367            if (mEnabledSession != null) {
2368                try {
2369                    if (DEBUG) Slog.v(TAG, "Disabling: " + mEnabledSession);
2370                    mEnabledSession.method.setSessionEnabled(
2371                            mEnabledSession.session, false);
2372                } catch (RemoteException e) {
2373                }
2374            }
2375            mEnabledSession = session;
2376            try {
2377                if (DEBUG) Slog.v(TAG, "Enabling: " + mEnabledSession);
2378                session.method.setSessionEnabled(
2379                        session.session, true);
2380            } catch (RemoteException e) {
2381            }
2382        }
2383    }
2384
2385    @Override
2386    public boolean handleMessage(Message msg) {
2387        SomeArgs args;
2388        switch (msg.what) {
2389            case MSG_SHOW_IM_PICKER:
2390                showInputMethodMenu();
2391                return true;
2392
2393            case MSG_SHOW_IM_SUBTYPE_PICKER:
2394                showInputMethodSubtypeMenu();
2395                return true;
2396
2397            case MSG_SHOW_IM_SUBTYPE_ENABLER:
2398                args = (SomeArgs)msg.obj;
2399                showInputMethodAndSubtypeEnabler((String)args.arg1);
2400                args.recycle();
2401                return true;
2402
2403            case MSG_SHOW_IM_CONFIG:
2404                showConfigureInputMethods();
2405                return true;
2406
2407            // ---------------------------------------------------------
2408
2409            case MSG_UNBIND_INPUT:
2410                try {
2411                    ((IInputMethod)msg.obj).unbindInput();
2412                } catch (RemoteException e) {
2413                    // There is nothing interesting about the method dying.
2414                }
2415                return true;
2416            case MSG_BIND_INPUT:
2417                args = (SomeArgs)msg.obj;
2418                try {
2419                    ((IInputMethod)args.arg1).bindInput((InputBinding)args.arg2);
2420                } catch (RemoteException e) {
2421                }
2422                args.recycle();
2423                return true;
2424            case MSG_SHOW_SOFT_INPUT:
2425                args = (SomeArgs)msg.obj;
2426                try {
2427                    if (DEBUG) Slog.v(TAG, "Calling " + args.arg1 + ".showSoftInput("
2428                            + msg.arg1 + ", " + args.arg2 + ")");
2429                    ((IInputMethod)args.arg1).showSoftInput(msg.arg1, (ResultReceiver)args.arg2);
2430                } catch (RemoteException e) {
2431                }
2432                args.recycle();
2433                return true;
2434            case MSG_HIDE_SOFT_INPUT:
2435                args = (SomeArgs)msg.obj;
2436                try {
2437                    if (DEBUG) Slog.v(TAG, "Calling " + args.arg1 + ".hideSoftInput(0, "
2438                            + args.arg2 + ")");
2439                    ((IInputMethod)args.arg1).hideSoftInput(0, (ResultReceiver)args.arg2);
2440                } catch (RemoteException e) {
2441                }
2442                args.recycle();
2443                return true;
2444            case MSG_ATTACH_TOKEN:
2445                args = (SomeArgs)msg.obj;
2446                try {
2447                    if (DEBUG) Slog.v(TAG, "Sending attach of token: " + args.arg2);
2448                    ((IInputMethod)args.arg1).attachToken((IBinder)args.arg2);
2449                } catch (RemoteException e) {
2450                }
2451                args.recycle();
2452                return true;
2453            case MSG_CREATE_SESSION: {
2454                args = (SomeArgs)msg.obj;
2455                IInputMethod method = (IInputMethod)args.arg1;
2456                InputChannel channel = (InputChannel)args.arg2;
2457                try {
2458                    method.createSession(channel, (IInputSessionCallback)args.arg3);
2459                } catch (RemoteException e) {
2460                } finally {
2461                    // Dispose the channel if the input method is not local to this process
2462                    // because the remote proxy will get its own copy when unparceled.
2463                    if (channel != null && Binder.isProxy(method)) {
2464                        channel.dispose();
2465                    }
2466                }
2467                args.recycle();
2468                return true;
2469            }
2470            // ---------------------------------------------------------
2471
2472            case MSG_START_INPUT:
2473                args = (SomeArgs)msg.obj;
2474                try {
2475                    SessionState session = (SessionState)args.arg1;
2476                    setEnabledSessionInMainThread(session);
2477                    session.method.startInput((IInputContext)args.arg2,
2478                            (EditorInfo)args.arg3);
2479                } catch (RemoteException e) {
2480                }
2481                args.recycle();
2482                return true;
2483            case MSG_RESTART_INPUT:
2484                args = (SomeArgs)msg.obj;
2485                try {
2486                    SessionState session = (SessionState)args.arg1;
2487                    setEnabledSessionInMainThread(session);
2488                    session.method.restartInput((IInputContext)args.arg2,
2489                            (EditorInfo)args.arg3);
2490                } catch (RemoteException e) {
2491                }
2492                args.recycle();
2493                return true;
2494
2495            // ---------------------------------------------------------
2496
2497            case MSG_UNBIND_METHOD:
2498                try {
2499                    ((IInputMethodClient)msg.obj).onUnbindMethod(msg.arg1);
2500                } catch (RemoteException e) {
2501                    // There is nothing interesting about the last client dying.
2502                }
2503                return true;
2504            case MSG_BIND_METHOD: {
2505                args = (SomeArgs)msg.obj;
2506                IInputMethodClient client = (IInputMethodClient)args.arg1;
2507                InputBindResult res = (InputBindResult)args.arg2;
2508                try {
2509                    client.onBindMethod(res);
2510                } catch (RemoteException e) {
2511                    Slog.w(TAG, "Client died receiving input method " + args.arg2);
2512                } finally {
2513                    // Dispose the channel if the input method is not local to this process
2514                    // because the remote proxy will get its own copy when unparceled.
2515                    if (res.channel != null && Binder.isProxy(client)) {
2516                        res.channel.dispose();
2517                    }
2518                }
2519                args.recycle();
2520                return true;
2521            }
2522            case MSG_SET_ACTIVE:
2523                try {
2524                    ((ClientState)msg.obj).client.setActive(msg.arg1 != 0);
2525                } catch (RemoteException e) {
2526                    Slog.w(TAG, "Got RemoteException sending setActive(false) notification to pid "
2527                            + ((ClientState)msg.obj).pid + " uid "
2528                            + ((ClientState)msg.obj).uid);
2529                }
2530                return true;
2531            case MSG_SET_CURSOR_ANCHOR_MONITOR_MODE:
2532                try {
2533                    ((ClientState)msg.obj).client.setCursorAnchorMonitorMode(msg.arg1);
2534                } catch (RemoteException e) {
2535                    Slog.w(TAG, "Got RemoteException sending setCursorAnchorMonitorMode "
2536                            + "notification to pid " + ((ClientState)msg.obj).pid
2537                            + " uid " + ((ClientState)msg.obj).uid);
2538                }
2539                return true;
2540
2541            // --------------------------------------------------------------
2542            case MSG_HARD_KEYBOARD_SWITCH_CHANGED:
2543                mHardKeyboardListener.handleHardKeyboardStatusChange(
2544                        msg.arg1 == 1, msg.arg2 == 1);
2545                return true;
2546        }
2547        return false;
2548    }
2549
2550    private boolean chooseNewDefaultIMELocked() {
2551        final InputMethodInfo imi = InputMethodUtils.getMostApplicableDefaultIME(
2552                mSettings.getEnabledInputMethodListLocked());
2553        if (imi != null) {
2554            if (DEBUG) {
2555                Slog.d(TAG, "New default IME was selected: " + imi.getId());
2556            }
2557            resetSelectedInputMethodAndSubtypeLocked(imi.getId());
2558            return true;
2559        }
2560
2561        return false;
2562    }
2563
2564    void buildInputMethodListLocked(ArrayList<InputMethodInfo> list,
2565            HashMap<String, InputMethodInfo> map, boolean resetDefaultEnabledIme) {
2566        if (DEBUG) {
2567            Slog.d(TAG, "--- re-buildInputMethodList reset = " + resetDefaultEnabledIme
2568                    + " \n ------ \n" + InputMethodUtils.getStackTrace());
2569        }
2570        list.clear();
2571        map.clear();
2572
2573        // Use for queryIntentServicesAsUser
2574        final PackageManager pm = mContext.getPackageManager();
2575        String disabledSysImes = mSettings.getDisabledSystemInputMethods();
2576        if (disabledSysImes == null) disabledSysImes = "";
2577
2578        final List<ResolveInfo> services = pm.queryIntentServicesAsUser(
2579                new Intent(InputMethod.SERVICE_INTERFACE),
2580                PackageManager.GET_META_DATA | PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS,
2581                mSettings.getCurrentUserId());
2582
2583        final HashMap<String, List<InputMethodSubtype>> additionalSubtypes =
2584                mFileManager.getAllAdditionalInputMethodSubtypes();
2585        for (int i = 0; i < services.size(); ++i) {
2586            ResolveInfo ri = services.get(i);
2587            ServiceInfo si = ri.serviceInfo;
2588            ComponentName compName = new ComponentName(si.packageName, si.name);
2589            if (!android.Manifest.permission.BIND_INPUT_METHOD.equals(
2590                    si.permission)) {
2591                Slog.w(TAG, "Skipping input method " + compName
2592                        + ": it does not require the permission "
2593                        + android.Manifest.permission.BIND_INPUT_METHOD);
2594                continue;
2595            }
2596
2597            if (DEBUG) Slog.d(TAG, "Checking " + compName);
2598
2599            try {
2600                InputMethodInfo p = new InputMethodInfo(mContext, ri, additionalSubtypes);
2601                list.add(p);
2602                final String id = p.getId();
2603                map.put(id, p);
2604
2605                if (DEBUG) {
2606                    Slog.d(TAG, "Found an input method " + p);
2607                }
2608
2609            } catch (XmlPullParserException e) {
2610                Slog.w(TAG, "Unable to load input method " + compName, e);
2611            } catch (IOException e) {
2612                Slog.w(TAG, "Unable to load input method " + compName, e);
2613            }
2614        }
2615
2616        if (resetDefaultEnabledIme) {
2617            final ArrayList<InputMethodInfo> defaultEnabledIme =
2618                    InputMethodUtils.getDefaultEnabledImes(mContext, mSystemReady, list);
2619            for (int i = 0; i < defaultEnabledIme.size(); ++i) {
2620                final InputMethodInfo imi =  defaultEnabledIme.get(i);
2621                if (DEBUG) {
2622                    Slog.d(TAG, "--- enable ime = " + imi);
2623                }
2624                setInputMethodEnabledLocked(imi.getId(), true);
2625            }
2626        }
2627
2628        final String defaultImiId = mSettings.getSelectedInputMethod();
2629        if (!TextUtils.isEmpty(defaultImiId)) {
2630            if (!map.containsKey(defaultImiId)) {
2631                Slog.w(TAG, "Default IME is uninstalled. Choose new default IME.");
2632                if (chooseNewDefaultIMELocked()) {
2633                    updateFromSettingsLocked(true);
2634                }
2635            } else {
2636                // Double check that the default IME is certainly enabled.
2637                setInputMethodEnabledLocked(defaultImiId, true);
2638            }
2639        }
2640    }
2641
2642    // ----------------------------------------------------------------------
2643
2644    private void showInputMethodMenu() {
2645        showInputMethodMenuInternal(false);
2646    }
2647
2648    private void showInputMethodSubtypeMenu() {
2649        showInputMethodMenuInternal(true);
2650    }
2651
2652    private void showInputMethodAndSubtypeEnabler(String inputMethodId) {
2653        Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SUBTYPE_SETTINGS);
2654        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
2655                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
2656                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
2657        if (!TextUtils.isEmpty(inputMethodId)) {
2658            intent.putExtra(Settings.EXTRA_INPUT_METHOD_ID, inputMethodId);
2659        }
2660        mContext.startActivityAsUser(intent, null, UserHandle.CURRENT);
2661    }
2662
2663    private void showConfigureInputMethods() {
2664        Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SETTINGS);
2665        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
2666                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
2667                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
2668        mContext.startActivityAsUser(intent, null, UserHandle.CURRENT);
2669    }
2670
2671    private boolean isScreenLocked() {
2672        return mKeyguardManager != null
2673                && mKeyguardManager.isKeyguardLocked() && mKeyguardManager.isKeyguardSecure();
2674    }
2675    private void showInputMethodMenuInternal(boolean showSubtypes) {
2676        if (DEBUG) Slog.v(TAG, "Show switching menu");
2677
2678        final Context context = mContext;
2679        final boolean isScreenLocked = isScreenLocked();
2680
2681        final String lastInputMethodId = mSettings.getSelectedInputMethod();
2682        int lastInputMethodSubtypeId = mSettings.getSelectedInputMethodSubtypeId(lastInputMethodId);
2683        if (DEBUG) Slog.v(TAG, "Current IME: " + lastInputMethodId);
2684
2685        synchronized (mMethodMap) {
2686            final HashMap<InputMethodInfo, List<InputMethodSubtype>> immis =
2687                    mSettings.getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked(
2688                            mContext);
2689            if (immis == null || immis.size() == 0) {
2690                return;
2691            }
2692
2693            hideInputMethodMenuLocked();
2694
2695            final List<ImeSubtypeListItem> imList =
2696                    mSwitchingController.getSortedInputMethodAndSubtypeList(
2697                            showSubtypes, mInputShown, isScreenLocked);
2698
2699            if (lastInputMethodSubtypeId == NOT_A_SUBTYPE_ID) {
2700                final InputMethodSubtype currentSubtype = getCurrentInputMethodSubtypeLocked();
2701                if (currentSubtype != null) {
2702                    final InputMethodInfo currentImi = mMethodMap.get(mCurMethodId);
2703                    lastInputMethodSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(
2704                            currentImi, currentSubtype.hashCode());
2705                }
2706            }
2707
2708            final int N = imList.size();
2709            mIms = new InputMethodInfo[N];
2710            mSubtypeIds = new int[N];
2711            int checkedItem = 0;
2712            for (int i = 0; i < N; ++i) {
2713                final ImeSubtypeListItem item = imList.get(i);
2714                mIms[i] = item.mImi;
2715                mSubtypeIds[i] = item.mSubtypeId;
2716                if (mIms[i].getId().equals(lastInputMethodId)) {
2717                    int subtypeId = mSubtypeIds[i];
2718                    if ((subtypeId == NOT_A_SUBTYPE_ID)
2719                            || (lastInputMethodSubtypeId == NOT_A_SUBTYPE_ID && subtypeId == 0)
2720                            || (subtypeId == lastInputMethodSubtypeId)) {
2721                        checkedItem = i;
2722                    }
2723                }
2724            }
2725            final TypedArray a = context.obtainStyledAttributes(null,
2726                    com.android.internal.R.styleable.DialogPreference,
2727                    com.android.internal.R.attr.alertDialogStyle, 0);
2728            mDialogBuilder = new AlertDialog.Builder(context)
2729                    .setOnCancelListener(new OnCancelListener() {
2730                        @Override
2731                        public void onCancel(DialogInterface dialog) {
2732                            hideInputMethodMenu();
2733                        }
2734                    })
2735                    .setIcon(a.getDrawable(
2736                            com.android.internal.R.styleable.DialogPreference_dialogTitle));
2737            a.recycle();
2738            final LayoutInflater inflater =
2739                    (LayoutInflater)mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
2740            final View tv = inflater.inflate(
2741                    com.android.internal.R.layout.input_method_switch_dialog_title, null);
2742            mDialogBuilder.setCustomTitle(tv);
2743
2744            // Setup layout for a toggle switch of the hardware keyboard
2745            mSwitchingDialogTitleView = tv;
2746            mSwitchingDialogTitleView.findViewById(
2747                    com.android.internal.R.id.hard_keyboard_section).setVisibility(
2748                            mWindowManagerService.isHardKeyboardAvailable() ?
2749                                    View.VISIBLE : View.GONE);
2750            final Switch hardKeySwitch =  ((Switch)mSwitchingDialogTitleView.findViewById(
2751                    com.android.internal.R.id.hard_keyboard_switch));
2752            hardKeySwitch.setChecked(mWindowManagerService.isHardKeyboardEnabled());
2753            hardKeySwitch.setOnCheckedChangeListener(
2754                    new OnCheckedChangeListener() {
2755                        @Override
2756                        public void onCheckedChanged(
2757                                CompoundButton buttonView, boolean isChecked) {
2758                            mWindowManagerService.setHardKeyboardEnabled(isChecked);
2759                            // Ensure that the input method dialog is dismissed when changing
2760                            // the hardware keyboard state.
2761                            hideInputMethodMenu();
2762                        }
2763                    });
2764
2765            final ImeSubtypeListAdapter adapter = new ImeSubtypeListAdapter(context,
2766                    com.android.internal.R.layout.simple_list_item_2_single_choice, imList,
2767                    checkedItem);
2768
2769            mDialogBuilder.setSingleChoiceItems(adapter, checkedItem,
2770                    new AlertDialog.OnClickListener() {
2771                        @Override
2772                        public void onClick(DialogInterface dialog, int which) {
2773                            synchronized (mMethodMap) {
2774                                if (mIms == null || mIms.length <= which
2775                                        || mSubtypeIds == null || mSubtypeIds.length <= which) {
2776                                    return;
2777                                }
2778                                InputMethodInfo im = mIms[which];
2779                                int subtypeId = mSubtypeIds[which];
2780                                adapter.mCheckedItem = which;
2781                                adapter.notifyDataSetChanged();
2782                                hideInputMethodMenu();
2783                                if (im != null) {
2784                                    if ((subtypeId < 0)
2785                                            || (subtypeId >= im.getSubtypeCount())) {
2786                                        subtypeId = NOT_A_SUBTYPE_ID;
2787                                    }
2788                                    setInputMethodLocked(im.getId(), subtypeId);
2789                                }
2790                            }
2791                        }
2792                    });
2793
2794            if (showSubtypes && !isScreenLocked) {
2795                mDialogBuilder.setPositiveButton(
2796                        com.android.internal.R.string.configure_input_methods,
2797                        new DialogInterface.OnClickListener() {
2798                            @Override
2799                            public void onClick(DialogInterface dialog, int whichButton) {
2800                                showConfigureInputMethods();
2801                            }
2802                        });
2803            }
2804            mSwitchingDialog = mDialogBuilder.create();
2805            mSwitchingDialog.setCanceledOnTouchOutside(true);
2806            mSwitchingDialog.getWindow().setType(
2807                    WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG);
2808            mSwitchingDialog.getWindow().getAttributes().privateFlags |=
2809                    WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
2810            mSwitchingDialog.getWindow().getAttributes().setTitle("Select input method");
2811            mSwitchingDialog.show();
2812        }
2813    }
2814
2815    private static class ImeSubtypeListAdapter extends ArrayAdapter<ImeSubtypeListItem> {
2816        private final LayoutInflater mInflater;
2817        private final int mTextViewResourceId;
2818        private final List<ImeSubtypeListItem> mItemsList;
2819        public int mCheckedItem;
2820        public ImeSubtypeListAdapter(Context context, int textViewResourceId,
2821                List<ImeSubtypeListItem> itemsList, int checkedItem) {
2822            super(context, textViewResourceId, itemsList);
2823            mTextViewResourceId = textViewResourceId;
2824            mItemsList = itemsList;
2825            mCheckedItem = checkedItem;
2826            mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
2827        }
2828
2829        @Override
2830        public View getView(int position, View convertView, ViewGroup parent) {
2831            final View view = convertView != null ? convertView
2832                    : mInflater.inflate(mTextViewResourceId, null);
2833            if (position < 0 || position >= mItemsList.size()) return view;
2834            final ImeSubtypeListItem item = mItemsList.get(position);
2835            final CharSequence imeName = item.mImeName;
2836            final CharSequence subtypeName = item.mSubtypeName;
2837            final TextView firstTextView = (TextView)view.findViewById(android.R.id.text1);
2838            final TextView secondTextView = (TextView)view.findViewById(android.R.id.text2);
2839            if (TextUtils.isEmpty(subtypeName)) {
2840                firstTextView.setText(imeName);
2841                secondTextView.setVisibility(View.GONE);
2842            } else {
2843                firstTextView.setText(subtypeName);
2844                secondTextView.setText(imeName);
2845                secondTextView.setVisibility(View.VISIBLE);
2846            }
2847            final RadioButton radioButton =
2848                    (RadioButton)view.findViewById(com.android.internal.R.id.radio);
2849            radioButton.setChecked(position == mCheckedItem);
2850            return view;
2851        }
2852    }
2853
2854    void hideInputMethodMenu() {
2855        synchronized (mMethodMap) {
2856            hideInputMethodMenuLocked();
2857        }
2858    }
2859
2860    void hideInputMethodMenuLocked() {
2861        if (DEBUG) Slog.v(TAG, "Hide switching menu");
2862
2863        if (mSwitchingDialog != null) {
2864            mSwitchingDialog.dismiss();
2865            mSwitchingDialog = null;
2866        }
2867
2868        mDialogBuilder = null;
2869        mIms = null;
2870    }
2871
2872    // ----------------------------------------------------------------------
2873
2874    @Override
2875    public boolean setInputMethodEnabled(String id, boolean enabled) {
2876        // TODO: Make this work even for non-current users?
2877        if (!calledFromValidUser()) {
2878            return false;
2879        }
2880        synchronized (mMethodMap) {
2881            if (mContext.checkCallingOrSelfPermission(
2882                    android.Manifest.permission.WRITE_SECURE_SETTINGS)
2883                    != PackageManager.PERMISSION_GRANTED) {
2884                throw new SecurityException(
2885                        "Requires permission "
2886                        + android.Manifest.permission.WRITE_SECURE_SETTINGS);
2887            }
2888
2889            long ident = Binder.clearCallingIdentity();
2890            try {
2891                return setInputMethodEnabledLocked(id, enabled);
2892            } finally {
2893                Binder.restoreCallingIdentity(ident);
2894            }
2895        }
2896    }
2897
2898    boolean setInputMethodEnabledLocked(String id, boolean enabled) {
2899        // Make sure this is a valid input method.
2900        InputMethodInfo imm = mMethodMap.get(id);
2901        if (imm == null) {
2902            throw new IllegalArgumentException("Unknown id: " + mCurMethodId);
2903        }
2904
2905        List<Pair<String, ArrayList<String>>> enabledInputMethodsList = mSettings
2906                .getEnabledInputMethodsAndSubtypeListLocked();
2907
2908        if (enabled) {
2909            for (Pair<String, ArrayList<String>> pair: enabledInputMethodsList) {
2910                if (pair.first.equals(id)) {
2911                    // We are enabling this input method, but it is already enabled.
2912                    // Nothing to do. The previous state was enabled.
2913                    return true;
2914                }
2915            }
2916            mSettings.appendAndPutEnabledInputMethodLocked(id, false);
2917            // Previous state was disabled.
2918            return false;
2919        } else {
2920            StringBuilder builder = new StringBuilder();
2921            if (mSettings.buildAndPutEnabledInputMethodsStrRemovingIdLocked(
2922                    builder, enabledInputMethodsList, id)) {
2923                // Disabled input method is currently selected, switch to another one.
2924                final String selId = mSettings.getSelectedInputMethod();
2925                if (id.equals(selId) && !chooseNewDefaultIMELocked()) {
2926                    Slog.i(TAG, "Can't find new IME, unsetting the current input method.");
2927                    resetSelectedInputMethodAndSubtypeLocked("");
2928                }
2929                // Previous state was enabled.
2930                return true;
2931            } else {
2932                // We are disabling the input method but it is already disabled.
2933                // Nothing to do.  The previous state was disabled.
2934                return false;
2935            }
2936        }
2937    }
2938
2939    private void setSelectedInputMethodAndSubtypeLocked(InputMethodInfo imi, int subtypeId,
2940            boolean setSubtypeOnly) {
2941        // Update the history of InputMethod and Subtype
2942        mSettings.saveCurrentInputMethodAndSubtypeToHistory(mCurMethodId, mCurrentSubtype);
2943
2944        // Set Subtype here
2945        if (imi == null || subtypeId < 0) {
2946            mSettings.putSelectedSubtype(NOT_A_SUBTYPE_ID);
2947            mCurrentSubtype = null;
2948        } else {
2949            if (subtypeId < imi.getSubtypeCount()) {
2950                InputMethodSubtype subtype = imi.getSubtypeAt(subtypeId);
2951                mSettings.putSelectedSubtype(subtype.hashCode());
2952                mCurrentSubtype = subtype;
2953            } else {
2954                mSettings.putSelectedSubtype(NOT_A_SUBTYPE_ID);
2955                // If the subtype is not specified, choose the most applicable one
2956                mCurrentSubtype = getCurrentInputMethodSubtypeLocked();
2957            }
2958        }
2959
2960        // Workaround.
2961        // ASEC is not ready in the IMMS constructor. Accordingly, forward-locked
2962        // IMEs are not recognized and considered uninstalled.
2963        // Actually, we can't move everything after SystemReady because
2964        // IMMS needs to run in the encryption lock screen. So, we just skip changing
2965        // the default IME here and try cheking the default IME again in systemReady().
2966        // TODO: Do nothing before system ready and implement a separated logic for
2967        // the encryption lock screen.
2968        // TODO: ASEC should be ready before IMMS is instantiated.
2969        if (mSystemReady && !setSubtypeOnly) {
2970            // Set InputMethod here
2971            mSettings.putSelectedInputMethod(imi != null ? imi.getId() : "");
2972        }
2973    }
2974
2975    private void resetSelectedInputMethodAndSubtypeLocked(String newDefaultIme) {
2976        InputMethodInfo imi = mMethodMap.get(newDefaultIme);
2977        int lastSubtypeId = NOT_A_SUBTYPE_ID;
2978        // newDefaultIme is empty when there is no candidate for the selected IME.
2979        if (imi != null && !TextUtils.isEmpty(newDefaultIme)) {
2980            String subtypeHashCode = mSettings.getLastSubtypeForInputMethodLocked(newDefaultIme);
2981            if (subtypeHashCode != null) {
2982                try {
2983                    lastSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(
2984                            imi, Integer.valueOf(subtypeHashCode));
2985                } catch (NumberFormatException e) {
2986                    Slog.w(TAG, "HashCode for subtype looks broken: " + subtypeHashCode, e);
2987                }
2988            }
2989        }
2990        setSelectedInputMethodAndSubtypeLocked(imi, lastSubtypeId, false);
2991    }
2992
2993    // If there are no selected shortcuts, tries finding the most applicable ones.
2994    private Pair<InputMethodInfo, InputMethodSubtype>
2995            findLastResortApplicableShortcutInputMethodAndSubtypeLocked(String mode) {
2996        List<InputMethodInfo> imis = mSettings.getEnabledInputMethodListLocked();
2997        InputMethodInfo mostApplicableIMI = null;
2998        InputMethodSubtype mostApplicableSubtype = null;
2999        boolean foundInSystemIME = false;
3000
3001        // Search applicable subtype for each InputMethodInfo
3002        for (InputMethodInfo imi: imis) {
3003            final String imiId = imi.getId();
3004            if (foundInSystemIME && !imiId.equals(mCurMethodId)) {
3005                continue;
3006            }
3007            InputMethodSubtype subtype = null;
3008            final List<InputMethodSubtype> enabledSubtypes =
3009                    mSettings.getEnabledInputMethodSubtypeListLocked(mContext, imi, true);
3010            // 1. Search by the current subtype's locale from enabledSubtypes.
3011            if (mCurrentSubtype != null) {
3012                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3013                        mRes, enabledSubtypes, mode, mCurrentSubtype.getLocale(), false);
3014            }
3015            // 2. Search by the system locale from enabledSubtypes.
3016            // 3. Search the first enabled subtype matched with mode from enabledSubtypes.
3017            if (subtype == null) {
3018                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3019                        mRes, enabledSubtypes, mode, null, true);
3020            }
3021            final ArrayList<InputMethodSubtype> overridingImplicitlyEnabledSubtypes =
3022                    InputMethodUtils.getOverridingImplicitlyEnabledSubtypes(imi, mode);
3023            final ArrayList<InputMethodSubtype> subtypesForSearch =
3024                    overridingImplicitlyEnabledSubtypes.isEmpty()
3025                            ? InputMethodUtils.getSubtypes(imi)
3026                            : overridingImplicitlyEnabledSubtypes;
3027            // 4. Search by the current subtype's locale from all subtypes.
3028            if (subtype == null && mCurrentSubtype != null) {
3029                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3030                        mRes, subtypesForSearch, mode, mCurrentSubtype.getLocale(), false);
3031            }
3032            // 5. Search by the system locale from all subtypes.
3033            // 6. Search the first enabled subtype matched with mode from all subtypes.
3034            if (subtype == null) {
3035                subtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3036                        mRes, subtypesForSearch, mode, null, true);
3037            }
3038            if (subtype != null) {
3039                if (imiId.equals(mCurMethodId)) {
3040                    // The current input method is the most applicable IME.
3041                    mostApplicableIMI = imi;
3042                    mostApplicableSubtype = subtype;
3043                    break;
3044                } else if (!foundInSystemIME) {
3045                    // The system input method is 2nd applicable IME.
3046                    mostApplicableIMI = imi;
3047                    mostApplicableSubtype = subtype;
3048                    if ((imi.getServiceInfo().applicationInfo.flags
3049                            & ApplicationInfo.FLAG_SYSTEM) != 0) {
3050                        foundInSystemIME = true;
3051                    }
3052                }
3053            }
3054        }
3055        if (DEBUG) {
3056            if (mostApplicableIMI != null) {
3057                Slog.w(TAG, "Most applicable shortcut input method was:"
3058                        + mostApplicableIMI.getId());
3059                if (mostApplicableSubtype != null) {
3060                    Slog.w(TAG, "Most applicable shortcut input method subtype was:"
3061                            + "," + mostApplicableSubtype.getMode() + ","
3062                            + mostApplicableSubtype.getLocale());
3063                }
3064            }
3065        }
3066        if (mostApplicableIMI != null) {
3067            return new Pair<InputMethodInfo, InputMethodSubtype> (mostApplicableIMI,
3068                    mostApplicableSubtype);
3069        } else {
3070            return null;
3071        }
3072    }
3073
3074    /**
3075     * @return Return the current subtype of this input method.
3076     */
3077    @Override
3078    public InputMethodSubtype getCurrentInputMethodSubtype() {
3079        // TODO: Make this work even for non-current users?
3080        if (!calledFromValidUser()) {
3081            return null;
3082        }
3083        synchronized (mMethodMap) {
3084            return getCurrentInputMethodSubtypeLocked();
3085        }
3086    }
3087
3088    private InputMethodSubtype getCurrentInputMethodSubtypeLocked() {
3089        if (mCurMethodId == null) {
3090            return null;
3091        }
3092        final boolean subtypeIsSelected = mSettings.isSubtypeSelected();
3093        final InputMethodInfo imi = mMethodMap.get(mCurMethodId);
3094        if (imi == null || imi.getSubtypeCount() == 0) {
3095            return null;
3096        }
3097        if (!subtypeIsSelected || mCurrentSubtype == null
3098                || !InputMethodUtils.isValidSubtypeId(imi, mCurrentSubtype.hashCode())) {
3099            int subtypeId = mSettings.getSelectedInputMethodSubtypeId(mCurMethodId);
3100            if (subtypeId == NOT_A_SUBTYPE_ID) {
3101                // If there are no selected subtypes, the framework will try to find
3102                // the most applicable subtype from explicitly or implicitly enabled
3103                // subtypes.
3104                List<InputMethodSubtype> explicitlyOrImplicitlyEnabledSubtypes =
3105                        mSettings.getEnabledInputMethodSubtypeListLocked(mContext, imi, true);
3106                // If there is only one explicitly or implicitly enabled subtype,
3107                // just returns it.
3108                if (explicitlyOrImplicitlyEnabledSubtypes.size() == 1) {
3109                    mCurrentSubtype = explicitlyOrImplicitlyEnabledSubtypes.get(0);
3110                } else if (explicitlyOrImplicitlyEnabledSubtypes.size() > 1) {
3111                    mCurrentSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3112                            mRes, explicitlyOrImplicitlyEnabledSubtypes,
3113                            InputMethodUtils.SUBTYPE_MODE_KEYBOARD, null, true);
3114                    if (mCurrentSubtype == null) {
3115                        mCurrentSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(
3116                                mRes, explicitlyOrImplicitlyEnabledSubtypes, null, null,
3117                                true);
3118                    }
3119                }
3120            } else {
3121                mCurrentSubtype = InputMethodUtils.getSubtypes(imi).get(subtypeId);
3122            }
3123        }
3124        return mCurrentSubtype;
3125    }
3126
3127    private void addShortcutInputMethodAndSubtypes(InputMethodInfo imi,
3128            InputMethodSubtype subtype) {
3129        if (mShortcutInputMethodsAndSubtypes.containsKey(imi)) {
3130            mShortcutInputMethodsAndSubtypes.get(imi).add(subtype);
3131        } else {
3132            ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();
3133            subtypes.add(subtype);
3134            mShortcutInputMethodsAndSubtypes.put(imi, subtypes);
3135        }
3136    }
3137
3138    // TODO: We should change the return type from List to List<Parcelable>
3139    @SuppressWarnings("rawtypes")
3140    @Override
3141    public List getShortcutInputMethodsAndSubtypes() {
3142        synchronized (mMethodMap) {
3143            ArrayList<Object> ret = new ArrayList<Object>();
3144            if (mShortcutInputMethodsAndSubtypes.size() == 0) {
3145                // If there are no selected shortcut subtypes, the framework will try to find
3146                // the most applicable subtype from all subtypes whose mode is
3147                // SUBTYPE_MODE_VOICE. This is an exceptional case, so we will hardcode the mode.
3148                Pair<InputMethodInfo, InputMethodSubtype> info =
3149                    findLastResortApplicableShortcutInputMethodAndSubtypeLocked(
3150                            InputMethodUtils.SUBTYPE_MODE_VOICE);
3151                if (info != null) {
3152                    ret.add(info.first);
3153                    ret.add(info.second);
3154                }
3155                return ret;
3156            }
3157            for (InputMethodInfo imi: mShortcutInputMethodsAndSubtypes.keySet()) {
3158                ret.add(imi);
3159                for (InputMethodSubtype subtype: mShortcutInputMethodsAndSubtypes.get(imi)) {
3160                    ret.add(subtype);
3161                }
3162            }
3163            return ret;
3164        }
3165    }
3166
3167    @Override
3168    public boolean setCurrentInputMethodSubtype(InputMethodSubtype subtype) {
3169        // TODO: Make this work even for non-current users?
3170        if (!calledFromValidUser()) {
3171            return false;
3172        }
3173        synchronized (mMethodMap) {
3174            if (subtype != null && mCurMethodId != null) {
3175                InputMethodInfo imi = mMethodMap.get(mCurMethodId);
3176                int subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(imi, subtype.hashCode());
3177                if (subtypeId != NOT_A_SUBTYPE_ID) {
3178                    setInputMethodLocked(mCurMethodId, subtypeId);
3179                    return true;
3180                }
3181            }
3182            return false;
3183        }
3184    }
3185
3186    // TODO: Cache the state for each user and reset when the cached user is removed.
3187    private static class InputMethodFileManager {
3188        private static final String SYSTEM_PATH = "system";
3189        private static final String INPUT_METHOD_PATH = "inputmethod";
3190        private static final String ADDITIONAL_SUBTYPES_FILE_NAME = "subtypes.xml";
3191        private static final String NODE_SUBTYPES = "subtypes";
3192        private static final String NODE_SUBTYPE = "subtype";
3193        private static final String NODE_IMI = "imi";
3194        private static final String ATTR_ID = "id";
3195        private static final String ATTR_LABEL = "label";
3196        private static final String ATTR_ICON = "icon";
3197        private static final String ATTR_IME_SUBTYPE_LOCALE = "imeSubtypeLocale";
3198        private static final String ATTR_IME_SUBTYPE_MODE = "imeSubtypeMode";
3199        private static final String ATTR_IME_SUBTYPE_EXTRA_VALUE = "imeSubtypeExtraValue";
3200        private static final String ATTR_IS_AUXILIARY = "isAuxiliary";
3201        private final AtomicFile mAdditionalInputMethodSubtypeFile;
3202        private final HashMap<String, InputMethodInfo> mMethodMap;
3203        private final HashMap<String, List<InputMethodSubtype>> mAdditionalSubtypesMap =
3204                new HashMap<String, List<InputMethodSubtype>>();
3205        public InputMethodFileManager(HashMap<String, InputMethodInfo> methodMap, int userId) {
3206            if (methodMap == null) {
3207                throw new NullPointerException("methodMap is null");
3208            }
3209            mMethodMap = methodMap;
3210            final File systemDir = userId == UserHandle.USER_OWNER
3211                    ? new File(Environment.getDataDirectory(), SYSTEM_PATH)
3212                    : Environment.getUserSystemDirectory(userId);
3213            final File inputMethodDir = new File(systemDir, INPUT_METHOD_PATH);
3214            if (!inputMethodDir.mkdirs()) {
3215                Slog.w(TAG, "Couldn't create dir.: " + inputMethodDir.getAbsolutePath());
3216            }
3217            final File subtypeFile = new File(inputMethodDir, ADDITIONAL_SUBTYPES_FILE_NAME);
3218            mAdditionalInputMethodSubtypeFile = new AtomicFile(subtypeFile);
3219            if (!subtypeFile.exists()) {
3220                // If "subtypes.xml" doesn't exist, create a blank file.
3221                writeAdditionalInputMethodSubtypes(
3222                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile, methodMap);
3223            } else {
3224                readAdditionalInputMethodSubtypes(
3225                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile);
3226            }
3227        }
3228
3229        private void deleteAllInputMethodSubtypes(String imiId) {
3230            synchronized (mMethodMap) {
3231                mAdditionalSubtypesMap.remove(imiId);
3232                writeAdditionalInputMethodSubtypes(
3233                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile, mMethodMap);
3234            }
3235        }
3236
3237        public void addInputMethodSubtypes(
3238                InputMethodInfo imi, InputMethodSubtype[] additionalSubtypes) {
3239            synchronized (mMethodMap) {
3240                final ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();
3241                final int N = additionalSubtypes.length;
3242                for (int i = 0; i < N; ++i) {
3243                    final InputMethodSubtype subtype = additionalSubtypes[i];
3244                    if (!subtypes.contains(subtype)) {
3245                        subtypes.add(subtype);
3246                    } else {
3247                        Slog.w(TAG, "Duplicated subtype definition found: "
3248                                + subtype.getLocale() + ", " + subtype.getMode());
3249                    }
3250                }
3251                mAdditionalSubtypesMap.put(imi.getId(), subtypes);
3252                writeAdditionalInputMethodSubtypes(
3253                        mAdditionalSubtypesMap, mAdditionalInputMethodSubtypeFile, mMethodMap);
3254            }
3255        }
3256
3257        public HashMap<String, List<InputMethodSubtype>> getAllAdditionalInputMethodSubtypes() {
3258            synchronized (mMethodMap) {
3259                return mAdditionalSubtypesMap;
3260            }
3261        }
3262
3263        private static void writeAdditionalInputMethodSubtypes(
3264                HashMap<String, List<InputMethodSubtype>> allSubtypes, AtomicFile subtypesFile,
3265                HashMap<String, InputMethodInfo> methodMap) {
3266            // Safety net for the case that this function is called before methodMap is set.
3267            final boolean isSetMethodMap = methodMap != null && methodMap.size() > 0;
3268            FileOutputStream fos = null;
3269            try {
3270                fos = subtypesFile.startWrite();
3271                final XmlSerializer out = new FastXmlSerializer();
3272                out.setOutput(fos, "utf-8");
3273                out.startDocument(null, true);
3274                out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
3275                out.startTag(null, NODE_SUBTYPES);
3276                for (String imiId : allSubtypes.keySet()) {
3277                    if (isSetMethodMap && !methodMap.containsKey(imiId)) {
3278                        Slog.w(TAG, "IME uninstalled or not valid.: " + imiId);
3279                        continue;
3280                    }
3281                    out.startTag(null, NODE_IMI);
3282                    out.attribute(null, ATTR_ID, imiId);
3283                    final List<InputMethodSubtype> subtypesList = allSubtypes.get(imiId);
3284                    final int N = subtypesList.size();
3285                    for (int i = 0; i < N; ++i) {
3286                        final InputMethodSubtype subtype = subtypesList.get(i);
3287                        out.startTag(null, NODE_SUBTYPE);
3288                        out.attribute(null, ATTR_ICON, String.valueOf(subtype.getIconResId()));
3289                        out.attribute(null, ATTR_LABEL, String.valueOf(subtype.getNameResId()));
3290                        out.attribute(null, ATTR_IME_SUBTYPE_LOCALE, subtype.getLocale());
3291                        out.attribute(null, ATTR_IME_SUBTYPE_MODE, subtype.getMode());
3292                        out.attribute(null, ATTR_IME_SUBTYPE_EXTRA_VALUE, subtype.getExtraValue());
3293                        out.attribute(null, ATTR_IS_AUXILIARY,
3294                                String.valueOf(subtype.isAuxiliary() ? 1 : 0));
3295                        out.endTag(null, NODE_SUBTYPE);
3296                    }
3297                    out.endTag(null, NODE_IMI);
3298                }
3299                out.endTag(null, NODE_SUBTYPES);
3300                out.endDocument();
3301                subtypesFile.finishWrite(fos);
3302            } catch (java.io.IOException e) {
3303                Slog.w(TAG, "Error writing subtypes", e);
3304                if (fos != null) {
3305                    subtypesFile.failWrite(fos);
3306                }
3307            }
3308        }
3309
3310        private static void readAdditionalInputMethodSubtypes(
3311                HashMap<String, List<InputMethodSubtype>> allSubtypes, AtomicFile subtypesFile) {
3312            if (allSubtypes == null || subtypesFile == null) return;
3313            allSubtypes.clear();
3314            FileInputStream fis = null;
3315            try {
3316                fis = subtypesFile.openRead();
3317                final XmlPullParser parser = Xml.newPullParser();
3318                parser.setInput(fis, null);
3319                int type = parser.getEventType();
3320                // Skip parsing until START_TAG
3321                while ((type = parser.next()) != XmlPullParser.START_TAG
3322                        && type != XmlPullParser.END_DOCUMENT) {}
3323                String firstNodeName = parser.getName();
3324                if (!NODE_SUBTYPES.equals(firstNodeName)) {
3325                    throw new XmlPullParserException("Xml doesn't start with subtypes");
3326                }
3327                final int depth =parser.getDepth();
3328                String currentImiId = null;
3329                ArrayList<InputMethodSubtype> tempSubtypesArray = null;
3330                while (((type = parser.next()) != XmlPullParser.END_TAG
3331                        || parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
3332                    if (type != XmlPullParser.START_TAG)
3333                        continue;
3334                    final String nodeName = parser.getName();
3335                    if (NODE_IMI.equals(nodeName)) {
3336                        currentImiId = parser.getAttributeValue(null, ATTR_ID);
3337                        if (TextUtils.isEmpty(currentImiId)) {
3338                            Slog.w(TAG, "Invalid imi id found in subtypes.xml");
3339                            continue;
3340                        }
3341                        tempSubtypesArray = new ArrayList<InputMethodSubtype>();
3342                        allSubtypes.put(currentImiId, tempSubtypesArray);
3343                    } else if (NODE_SUBTYPE.equals(nodeName)) {
3344                        if (TextUtils.isEmpty(currentImiId) || tempSubtypesArray == null) {
3345                            Slog.w(TAG, "IME uninstalled or not valid.: " + currentImiId);
3346                            continue;
3347                        }
3348                        final int icon = Integer.valueOf(
3349                                parser.getAttributeValue(null, ATTR_ICON));
3350                        final int label = Integer.valueOf(
3351                                parser.getAttributeValue(null, ATTR_LABEL));
3352                        final String imeSubtypeLocale =
3353                                parser.getAttributeValue(null, ATTR_IME_SUBTYPE_LOCALE);
3354                        final String imeSubtypeMode =
3355                                parser.getAttributeValue(null, ATTR_IME_SUBTYPE_MODE);
3356                        final String imeSubtypeExtraValue =
3357                                parser.getAttributeValue(null, ATTR_IME_SUBTYPE_EXTRA_VALUE);
3358                        final boolean isAuxiliary = "1".equals(String.valueOf(
3359                                parser.getAttributeValue(null, ATTR_IS_AUXILIARY)));
3360                        final InputMethodSubtype subtype =
3361                                new InputMethodSubtype(label, icon, imeSubtypeLocale,
3362                                        imeSubtypeMode, imeSubtypeExtraValue, isAuxiliary);
3363                        tempSubtypesArray.add(subtype);
3364                    }
3365                }
3366            } catch (XmlPullParserException e) {
3367                Slog.w(TAG, "Error reading subtypes: " + e);
3368                return;
3369            } catch (java.io.IOException e) {
3370                Slog.w(TAG, "Error reading subtypes: " + e);
3371                return;
3372            } catch (NumberFormatException e) {
3373                Slog.w(TAG, "Error reading subtypes: " + e);
3374                return;
3375            } finally {
3376                if (fis != null) {
3377                    try {
3378                        fis.close();
3379                    } catch (java.io.IOException e1) {
3380                        Slog.w(TAG, "Failed to close.");
3381                    }
3382                }
3383            }
3384        }
3385    }
3386
3387    @Override
3388    protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
3389        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
3390                != PackageManager.PERMISSION_GRANTED) {
3391
3392            pw.println("Permission Denial: can't dump InputMethodManager from from pid="
3393                    + Binder.getCallingPid()
3394                    + ", uid=" + Binder.getCallingUid());
3395            return;
3396        }
3397
3398        IInputMethod method;
3399        ClientState client;
3400
3401        final Printer p = new PrintWriterPrinter(pw);
3402
3403        synchronized (mMethodMap) {
3404            p.println("Current Input Method Manager state:");
3405            int N = mMethodList.size();
3406            p.println("  Input Methods:");
3407            for (int i=0; i<N; i++) {
3408                InputMethodInfo info = mMethodList.get(i);
3409                p.println("  InputMethod #" + i + ":");
3410                info.dump(p, "    ");
3411            }
3412            p.println("  Clients:");
3413            for (ClientState ci : mClients.values()) {
3414                p.println("  Client " + ci + ":");
3415                p.println("    client=" + ci.client);
3416                p.println("    inputContext=" + ci.inputContext);
3417                p.println("    sessionRequested=" + ci.sessionRequested);
3418                p.println("    curSession=" + ci.curSession);
3419            }
3420            p.println("  mCurMethodId=" + mCurMethodId);
3421            client = mCurClient;
3422            p.println("  mCurClient=" + client + " mCurSeq=" + mCurSeq);
3423            p.println("  mCurFocusedWindow=" + mCurFocusedWindow);
3424            p.println("  mCurId=" + mCurId + " mHaveConnect=" + mHaveConnection
3425                    + " mBoundToMethod=" + mBoundToMethod);
3426            p.println("  mCurToken=" + mCurToken);
3427            p.println("  mCurIntent=" + mCurIntent);
3428            method = mCurMethod;
3429            p.println("  mCurMethod=" + mCurMethod);
3430            p.println("  mEnabledSession=" + mEnabledSession);
3431            p.println("  mShowRequested=" + mShowRequested
3432                    + " mShowExplicitlyRequested=" + mShowExplicitlyRequested
3433                    + " mShowForced=" + mShowForced
3434                    + " mInputShown=" + mInputShown);
3435            p.println("  mSystemReady=" + mSystemReady + " mScreenOn=" + mScreenOn);
3436        }
3437
3438        p.println(" ");
3439        if (client != null) {
3440            pw.flush();
3441            try {
3442                client.client.asBinder().dump(fd, args);
3443            } catch (RemoteException e) {
3444                p.println("Input method client dead: " + e);
3445            }
3446        } else {
3447            p.println("No input method client.");
3448        }
3449
3450        p.println(" ");
3451        if (method != null) {
3452            pw.flush();
3453            try {
3454                method.asBinder().dump(fd, args);
3455            } catch (RemoteException e) {
3456                p.println("Input method service dead: " + e);
3457            }
3458        } else {
3459            p.println("No input method service.");
3460        }
3461    }
3462}
3463