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