コード例 #1
0
 @Override
 public boolean sendKeyEvent(KeyEvent event) {
   // BaseInputConnection.sendKeyEvent() dispatches the key event to the main thread.
   // In order to ensure events are processed in the proper order, we must block the
   // IC thread until the main thread finishes processing the key event
   super.sendKeyEvent(event);
   final View v = getView();
   if (v == null) {
     return false;
   }
   final Handler icHandler = mEditableClient.getInputConnectionHandler();
   final Handler mainHandler = v.getRootView().getHandler();
   if (icHandler.getLooper() != mainHandler.getLooper()) {
     // We are on separate IC thread but the event is queued on the main thread;
     // wait on IC thread until the main thread processes our posted Runnable. At
     // that point the key event has already been processed.
     mainHandler.post(
         new Runnable() {
           @Override
           public void run() {
             InputThreadUtils.sInstance.endWaitForUiThread();
           }
         });
     InputThreadUtils.sInstance.waitForUiThread(icHandler);
   }
   return false; // seems to always return false
 }
コード例 #2
0
 public void runOnIcThread(
     final Handler uiHandler, final GoannaEditableClient client, final Runnable runnable) {
   final Handler icHandler = client.getInputConnectionHandler();
   if (icHandler.getLooper() == uiHandler.getLooper()) {
     // IC thread is UI thread; safe to run directly
     runnable.run();
     return;
   }
   runOnIcThread(icHandler, runnable);
 }
コード例 #3
0
 @Override
 public Handler getHandler(Handler defHandler) {
   if (!canReturnCustomHandler()) {
     return defHandler;
   }
   final Handler newHandler = getBackgroundHandler();
   if (mEditableClient.setInputConnectionHandler(newHandler)) {
     return newHandler;
   }
   // Setting new IC handler failed; return old IC handler
   return mEditableClient.getInputConnectionHandler();
 }
コード例 #4
0
 public Editable getEditableForUiThread(
     final Handler uiHandler, final GoannaEditableClient client) {
   if (DEBUG) {
     ThreadUtils.assertOnThread(uiHandler.getLooper().getThread(), AssertBehavior.THROW);
   }
   final Handler icHandler = client.getInputConnectionHandler();
   if (icHandler.getLooper() == uiHandler.getLooper()) {
     // IC thread is UI thread; safe to use Editable directly
     return client.getEditable();
   }
   // IC thread is not UI thread; we need to return a proxy Editable in order
   // to safely use the Editable from the UI thread
   if (mUiEditable != null) {
     return mUiEditable;
   }
   final InvocationHandler invokeEditable =
       new InvocationHandler() {
         @Override
         public Object invoke(final Object proxy, final Method method, final Object[] args)
             throws Throwable {
           if (DEBUG) {
             ThreadUtils.assertOnThread(uiHandler.getLooper().getThread(), AssertBehavior.THROW);
             Log.d(LOGTAG, "UiEditable." + method.getName() + "() blocking");
           }
           synchronized (icHandler) {
             // Now we are on UI thread
             mUiEditableReturn = null;
             mUiEditableException = null;
             // Post a Runnable that calls the real Editable and saves any
             // result/exception. Then wait on the Runnable to finish
             runOnIcThread(
                 icHandler,
                 new Runnable() {
                   @Override
                   public void run() {
                     synchronized (icHandler) {
                       try {
                         mUiEditableReturn = method.invoke(client.getEditable(), args);
                       } catch (Exception e) {
                         mUiEditableException = e;
                       }
                       if (DEBUG) {
                         Log.d(LOGTAG, "UiEditable." + method.getName() + "() returning");
                       }
                       icHandler.notify();
                     }
                   }
                 });
             // let InterruptedException propagate
             icHandler.wait();
             if (mUiEditableException != null) {
               throw mUiEditableException;
             }
             return mUiEditableReturn;
           }
         }
       };
   mUiEditable =
       (Editable)
           Proxy.newProxyInstance(
               Editable.class.getClassLoader(), new Class<?>[] {Editable.class}, invokeEditable);
   return mUiEditable;
 }