core/java/android/inputmethodservice/IInputMethodWrapper.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.inputmethodservice;
  18
  19 import com.android.internal.os.HandlerCaller;
  20 import com.android.internal.os.SomeArgs;
  21 import com.android.internal.view.IInputContext;
  22 import com.android.internal.view.IInputMethod;
  23 import com.android.internal.view.IInputMethodSession;
  24 import com.android.internal.view.IInputSessionCallback;
  25 import com.android.internal.view.InputConnectionWrapper;
  26
  27 import android.content.Context;
  28 import android.content.pm.PackageManager;
  29 import android.os.Binder;
  30 import android.os.IBinder;
  31 import android.os.Message;
  32 import android.os.RemoteException;
  33 import android.os.ResultReceiver;
  34 import android.util.Log;
  35 import android.view.InputChannel;
  36 import android.view.inputmethod.EditorInfo;
  37 import android.view.inputmethod.InputBinding;
  38 import android.view.inputmethod.InputConnection;
  39 import android.view.inputmethod.InputConnectionInspector;
  40 import android.view.inputmethod.InputMethod;
  41 import android.view.inputmethod.InputMethodSession;
  42 import android.view.inputmethod.InputMethodSubtype;
  43
  44 import java.io.FileDescriptor;
  45 import java.io.PrintWriter;
  46 import java.lang.ref.WeakReference;
  47 import java.util.concurrent.CountDownLatch;
  48 import java.util.concurrent.TimeUnit;
  49
  50 /**
  51  * Implements the internal IInputMethod interface to convert incoming calls
  52  * on to it back to calls on the public InputMethod interface, scheduling
  53  * them on the main thread of the process.
  54  */
  55 class IInputMethodWrapper extends IInputMethod.Stub
  56         implements HandlerCaller.Callback {
  57     private static final String TAG = "InputMethodWrapper";
  58
  59     private static final int DO_DUMP = 1;
  60     private static final int DO_ATTACH_TOKEN = 10;
  61     private static final int DO_SET_INPUT_CONTEXT = 20;
  62     private static final int DO_UNSET_INPUT_CONTEXT = 30;
  63     private static final int DO_START_INPUT = 32;
  64     private static final int DO_RESTART_INPUT = 34;
  65     private static final int DO_CREATE_SESSION = 40;
  66     private static final int DO_SET_SESSION_ENABLED = 45;
  67     private static final int DO_REVOKE_SESSION = 50;
  68     private static final int DO_SHOW_SOFT_INPUT = 60;
  69     private static final int DO_HIDE_SOFT_INPUT = 70;
  70     private static final int DO_CHANGE_INPUTMETHOD_SUBTYPE = 80;
  71
  72     final WeakReference<AbstractInputMethodService> mTarget;
  73     final Context mContext;
  74     final HandlerCaller mCaller;
  75     final WeakReference<InputMethod> mInputMethod;
  76     final int mTargetSdkVersion;
  77
  78     static class Notifier {
  79         boolean notified;
  80     }
  81
  82     // NOTE: we should have a cache of these.
  83     static final class InputMethodSessionCallbackWrapper implements InputMethod.SessionCallback {
  84         final Context mContext;
  85         final InputChannel mChannel;
  86         final IInputSessionCallback mCb;
  87
  88         InputMethodSessionCallbackWrapper(Context context, InputChannel channel,
  89                 IInputSessionCallback cb) {
  90             mContext = context;
  91             mChannel = channel;
  92             mCb = cb;
  93         }
  94
  95         @Override
  96         public void sessionCreated(InputMethodSession session) {
  97             try {
  98                 if (session != null) {
  99                     IInputMethodSessionWrapper wrap =
 100                             new IInputMethodSessionWrapper(mContext, session, mChannel);
 101                     mCb.sessionCreated(wrap);
 102                 } else {
 103                     if (mChannel != null) {
 104                         mChannel.dispose();
 105                     }
 106                     mCb.sessionCreated(null);
 107                 }
 108             } catch (RemoteException e) {
 109             }
 110         }
 111     }
 112
 113     public IInputMethodWrapper(AbstractInputMethodService context,
 114             InputMethod inputMethod) {
 115         mTarget = new WeakReference<AbstractInputMethodService>(context);
 116         mContext = context.getApplicationContext();
 117         mCaller = new HandlerCaller(mContext, null, this, true /*asyncHandler*/);
 118         mInputMethod = new WeakReference<InputMethod>(inputMethod);
 119         mTargetSdkVersion = context.getApplicationInfo().targetSdkVersion;
 120     }
 121
 122     public InputMethod getInternalInputMethod() {
 123         return mInputMethod.get();
 124     }
 125
 126     @Override
 127     public void executeMessage(Message msg) {
 128         InputMethod inputMethod = mInputMethod.get();
 129         // Need a valid reference to the inputMethod for everything except a dump.
 130         if (inputMethod == null && msg.what != DO_DUMP) {
 131             Log.w(TAG, "Input method reference was null, ignoring message: " + msg.what);
 132             return;
 133         }
 134
 135         switch (msg.what) {
 136             case DO_DUMP: {
 137                 AbstractInputMethodService target = mTarget.get();
 138                 if (target == null) {
 139                     return;
 140                 }
 141                 SomeArgs args = (SomeArgs)msg.obj;
 142                 try {
 143                     target.dump((FileDescriptor)args.arg1,
 144                             (PrintWriter)args.arg2, (String[])args.arg3);
 145                 } catch (RuntimeException e) {
 146                     ((PrintWriter)args.arg2).println("Exception: " + e);
 147                 }
 148                 synchronized (args.arg4) {
 149                     ((CountDownLatch)args.arg4).countDown();
 150                 }
 151                 args.recycle();
 152                 return;
 153             }
 154
 155             case DO_ATTACH_TOKEN: {
 156                 inputMethod.attachToken((IBinder)msg.obj);
 157                 return;
 158             }
 159             case DO_SET_INPUT_CONTEXT: {
 160                 inputMethod.bindInput((InputBinding)msg.obj);
 161                 return;
 162             }
 163             case DO_UNSET_INPUT_CONTEXT:
 164                 inputMethod.unbindInput();
 165                 return;
 166             case DO_START_INPUT: {
 167                 SomeArgs args = (SomeArgs)msg.obj;
 168                 int missingMethods = msg.arg1;
 169                 IInputContext inputContext = (IInputContext)args.arg1;
 170                 InputConnection ic = inputContext != null
 171                         ? new InputConnectionWrapper(mTarget, inputContext, missingMethods) : null;
 172                 EditorInfo info = (EditorInfo)args.arg2;
 173                 info.makeCompatible(mTargetSdkVersion);
 174                 inputMethod.startInput(ic, info);
 175                 args.recycle();
 176                 return;
 177             }
 178             case DO_RESTART_INPUT: {
 179                 SomeArgs args = (SomeArgs)msg.obj;
 180                 int missingMethods = msg.arg1;
 181                 IInputContext inputContext = (IInputContext)args.arg1;
 182                 InputConnection ic = inputContext != null
 183                         ? new InputConnectionWrapper(mTarget, inputContext, missingMethods) : null;
 184                 EditorInfo info = (EditorInfo)args.arg2;
 185                 info.makeCompatible(mTargetSdkVersion);
 186                 inputMethod.restartInput(ic, info);
 187                 args.recycle();
 188                 return;
 189             }
 190             case DO_CREATE_SESSION: {
 191                 SomeArgs args = (SomeArgs)msg.obj;
 192                 inputMethod.createSession(new InputMethodSessionCallbackWrapper(
 193                         mContext, (InputChannel)args.arg1,
 194                         (IInputSessionCallback)args.arg2));
 195                 args.recycle();
 196                 return;
 197             }
 198             case DO_SET_SESSION_ENABLED:
 199                 inputMethod.setSessionEnabled((InputMethodSession)msg.obj,
 200                         msg.arg1 != 0);
 201                 return;
 202             case DO_REVOKE_SESSION:
 203                 inputMethod.revokeSession((InputMethodSession)msg.obj);
 204                 return;
 205             case DO_SHOW_SOFT_INPUT:
 206                 inputMethod.showSoftInput(msg.arg1, (ResultReceiver)msg.obj);
 207                 return;
 208             case DO_HIDE_SOFT_INPUT:
 209                 inputMethod.hideSoftInput(msg.arg1, (ResultReceiver)msg.obj);
 210                 return;
 211             case DO_CHANGE_INPUTMETHOD_SUBTYPE:
 212                 inputMethod.changeInputMethodSubtype((InputMethodSubtype)msg.obj);
 213                 return;
 214         }
 215         Log.w(TAG, "Unhandled message code: " + msg.what);
 216     }
 217
 218     @Override
 219     protected void dump(FileDescriptor fd, PrintWriter fout, String[] args) {
 220         AbstractInputMethodService target = mTarget.get();
 221         if (target == null) {
 222             return;
 223         }
 224         if (target.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
 225                 != PackageManager.PERMISSION_GRANTED) {
 226
 227             fout.println("Permission Denial: can't dump InputMethodManager from from pid="
 228                     + Binder.getCallingPid()
 229                     + ", uid=" + Binder.getCallingUid());
 230             return;
 231         }
 232
 233         CountDownLatch latch = new CountDownLatch(1);
 234         mCaller.executeOrSendMessage(mCaller.obtainMessageOOOO(DO_DUMP,
 235                 fd, fout, args, latch));
 236         try {
 237             if (!latch.await(5, TimeUnit.SECONDS)) {
 238                 fout.println("Timeout waiting for dump");
 239             }
 240         } catch (InterruptedException e) {
 241             fout.println("Interrupted waiting for dump");
 242         }
 243     }
 244
 245     @Override
 246     public void attachToken(IBinder token) {
 247         mCaller.executeOrSendMessage(mCaller.obtainMessageO(DO_ATTACH_TOKEN, token));
 248     }
 249
 250     @Override
 251     public void bindInput(InputBinding binding) {
 252         // This IInputContext is guaranteed to implement all the methods.
 253         final int missingMethodFlags = 0;
 254         InputConnection ic = new InputConnectionWrapper(mTarget,
 255                 IInputContext.Stub.asInterface(binding.getConnectionToken()), missingMethodFlags);
 256         InputBinding nu = new InputBinding(ic, binding);
 257         mCaller.executeOrSendMessage(mCaller.obtainMessageO(DO_SET_INPUT_CONTEXT, nu));
 258     }
 259
 260     @Override
 261     public void unbindInput() {
 262         mCaller.executeOrSendMessage(mCaller.obtainMessage(DO_UNSET_INPUT_CONTEXT));
 263     }
 264
 265     @Override
 266     public void startInput(IInputContext inputContext,
 267             @InputConnectionInspector.MissingMethodFlags final int missingMethods,
 268             EditorInfo attribute) {
 269         mCaller.executeOrSendMessage(mCaller.obtainMessageIOO(DO_START_INPUT,
 270                 missingMethods, inputContext, attribute));
 271     }
 272
 273     @Override
 274     public void restartInput(IInputContext inputContext,
 275             @InputConnectionInspector.MissingMethodFlags final int missingMethods,
 276             EditorInfo attribute) {
 277         mCaller.executeOrSendMessage(mCaller.obtainMessageIOO(DO_RESTART_INPUT,
 278                 missingMethods, inputContext, attribute));
 279     }
 280
 281     @Override
 282     public void createSession(InputChannel channel, IInputSessionCallback callback) {
 283         mCaller.executeOrSendMessage(mCaller.obtainMessageOO(DO_CREATE_SESSION,
 284                 channel, callback));
 285     }
 286
 287     @Override
 288     public void setSessionEnabled(IInputMethodSession session, boolean enabled) {
 289         try {
 290             InputMethodSession ls = ((IInputMethodSessionWrapper)
 291                     session).getInternalInputMethodSession();
 292             if (ls == null) {
 293                 Log.w(TAG, "Session is already finished: " + session);
 294                 return;
 295             }
 296             mCaller.executeOrSendMessage(mCaller.obtainMessageIO(
 297                     DO_SET_SESSION_ENABLED, enabled ? 1 : 0, ls));
 298         } catch (ClassCastException e) {
 299             Log.w(TAG, "Incoming session not of correct type: " + session, e);
 300         }
 301     }
 302
 303     @Override
 304     public void revokeSession(IInputMethodSession session) {
 305         try {
 306             InputMethodSession ls = ((IInputMethodSessionWrapper)
 307                     session).getInternalInputMethodSession();
 308             if (ls == null) {
 309                 Log.w(TAG, "Session is already finished: " + session);
 310                 return;
 311             }
 312             mCaller.executeOrSendMessage(mCaller.obtainMessageO(DO_REVOKE_SESSION, ls));
 313         } catch (ClassCastException e) {
 314             Log.w(TAG, "Incoming session not of correct type: " + session, e);
 315         }
 316     }
 317
 318     @Override
 319     public void showSoftInput(int flags, ResultReceiver resultReceiver) {
 320         mCaller.executeOrSendMessage(mCaller.obtainMessageIO(DO_SHOW_SOFT_INPUT,
 321                 flags, resultReceiver));
 322     }
 323
 324     @Override
 325     public void hideSoftInput(int flags, ResultReceiver resultReceiver) {
 326         mCaller.executeOrSendMessage(mCaller.obtainMessageIO(DO_HIDE_SOFT_INPUT,
 327                 flags, resultReceiver));
 328     }
 329
 330     @Override
 331     public void changeInputMethodSubtype(InputMethodSubtype subtype) {
 332         mCaller.executeOrSendMessage(mCaller.obtainMessageO(DO_CHANGE_INPUTMETHOD_SUBTYPE,
 333                 subtype));
 334     }
 335 }