Support InputMethodManager#updateCursorAnchorInfo for Android 5.0

content/public/android/java/src/org/chromium/content/browser/input/ImeAdapter.java

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser.input;
 
 import android.content.res.Configuration;
 import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.text.Editable;
 import android.text.Selection;
 import android.text.SpannableString;
 import android.text.TextUtils;
 import android.text.style.BackgroundColorSpan;
 import android.text.style.CharacterStyle;
 import android.text.style.UnderlineSpan;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.inputmethod.BaseInputConnection;
 import android.view.inputmethod.EditorInfo;
 
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.blink_public.web.WebInputEventModifier;
 import org.chromium.blink_public.web.WebInputEventType;
+import org.chromium.content.browser.RenderCoordinates;
 import org.chromium.ui.base.ime.TextInputType;
 import org.chromium.ui.picker.InputDialogContainer;
 
 /**
  * Adapts and plumbs android IME service onto the chrome text input API.
  * ImeAdapter provides an interface in both ways native <-> java:
  * 1. InputConnectionAdapter notifies native code of text composition state and
  *    dispatch key events from java -> WebKit.
  * 2. Native ImeAdapter notifies java side to clear composition text.
  *
@@ skipping 55 matching lines @@
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
     private AdapterInputConnection mInputConnection;
     private AdapterInputConnectionFactory mInputConnectionFactory;
     private final ImeAdapterDelegate mViewEmbedder;
 
     // This holds the state of editable text (e.g. contents of <input>, contenteditable) of
     // a focused element.
     // Every time the user, IME, javascript (Blink), autofill etc. modifies the content, the new
     // state must be reflected to this to keep consistency.
     private final Editable mEditable;
+    // This holds the information necessary for constructing CursorAnchorInfo, and notifies to
+    // InputMethodManager on appropriate timing, depending on how IME requested the information
+    // via InputConnection. The update request is per InputConnection, hence for each time it is
+    // re-created, the monitoring status will be reset.
+    private final CursorAnchorInfoController mCursorAnchorInfoController;
+
+    @VisibleForTesting
+    int mLastSyntheticKeyCode;

[aelias_OOO_until_Jul13, 2016/02/26 08:25:33]

Looks like you accidentally reintroduced this deleted line of code during
conflict resolution.

[kinaba, 2016/03/01 08:46:46]

Ooops, removed.

 
     private int mTextInputType = TextInputType.NONE;
     private int mTextInputFlags;
 
     // Keep the current configuration to detect the change when onConfigurationChanged() is called.
     private Configuration mCurrentConfig;
 
     /**
      * @param wrapper InputMethodManagerWrapper that should receive all the call directed to
      *                InputMethodManager.
      * @param embedder The view that is used for callbacks from ImeAdapter.
      */
     public ImeAdapter(InputMethodManagerWrapper wrapper, ImeAdapterDelegate embedder) {
         mInputMethodManagerWrapper = wrapper;
         mViewEmbedder = embedder;
         mInputConnectionFactory = new AdapterInputConnectionFactory();
         mEditable = Editable.Factory.getInstance().newEditable("");
         Selection.setSelection(mEditable, 0);
         // Deep copy newConfig so that we can notice the difference.
         mCurrentConfig = new Configuration(
                 mViewEmbedder.getAttachedView().getResources().getConfiguration());
+        mCursorAnchorInfoController = CursorAnchorInfoController.create(wrapper,
+                new CursorAnchorInfoController.ComposingTextDelegate() {

[aelias_OOO_until_Jul13, 2016/02/26 08:25:33]

It's a bit odd to be new'ing this object just to immediately abandon it on K and
below.  Could you pull out the isSupported() branch to be in this method
instead, and just never call create() if it's not?

[kinaba, 2016/03/01 08:46:46]

Done.

+                    @Override
+                    public CharSequence getText() {
+                        return mEditable;
+                    }
+                    @Override
+                    public int getSelectionStart() {
+                        return Selection.getSelectionStart(mEditable);
+                    }
+                    @Override
+                    public int getSelectionEnd() {
+                        return Selection.getSelectionEnd(mEditable);
+                    }
+                    @Override
+                    public int getComposingTextStart() {
+                        return BaseInputConnection.getComposingSpanStart(mEditable);

[aelias_OOO_until_Jul13, 2016/02/26 08:25:33]

The refactoring https://codereview.chromium.org/1278593004/ just landed and
you'll need to rebaseline on it.  The main substantive conflict is that you
can't do this anymore, as the new approach doesn't use Editable nor
BaseInputConnection.  The information you need still passes through
ImeAdapter.updateState() though.

[kinaba, 2016/03/01 08:46:46]

Done.

+                    }
+                    @Override
+                    public int getComposingTextEnd() {
+                        return BaseInputConnection.getComposingSpanEnd(mEditable);
+                    }
+                });
     }
 
     /**
      * Default factory for AdapterInputConnection classes.
      */
     static class AdapterInputConnectionFactory {
         AdapterInputConnection get(View view, ImeAdapter imeAdapter, int initialSelStart,
                 int initialSelEnd, EditorInfo outAttrs) {
             return new AdapterInputConnection(
                     view, imeAdapter, initialSelStart, initialSelEnd, outAttrs);
@@ skipping 20 matching lines @@
         if (!isTextInputType(mTextInputType)) {
             // Although onCheckIsTextEditor will return false in this case, the EditorInfo
             // is still used by the InputMethodService. Need to make sure the IME doesn't
             // enter fullscreen mode.
             outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN;
         }
         int initialSelStart = Selection.getSelectionStart(mEditable);
         int initialSelEnd = outAttrs.initialSelEnd = Selection.getSelectionEnd(mEditable);
         mInputConnection = mInputConnectionFactory.get(
                 mViewEmbedder.getAttachedView(), this, initialSelStart, initialSelEnd, outAttrs);
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.resetMonitoringState();
+        }
         if (DEBUG_LOGS) Log.w(TAG, "onCreateInputConnection");
         return mInputConnection;
     }
 
     /**
      * Overrides the InputMethodManagerWrapper that ImeAdapter uses to make calls to
      * InputMethodManager.
      * @param immw InputMethodManagerWrapper that should be used to call InputMethodManager.
      */
     @VisibleForTesting
     public void setInputMethodManagerWrapperForTest(InputMethodManagerWrapper immw) {
         mInputMethodManagerWrapper = immw;
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.setInputMethodManagerWrapper(immw);
+        }
     }
 
     @VisibleForTesting
     void setInputConnectionFactory(AdapterInputConnectionFactory factory) {
         mInputConnectionFactory = factory;
     }
 
     /**
      * Set the current active InputConnection when a new InputConnection is constructed.
      * @param inputConnection The input connection that is currently used with IME.
@@ skipping 91 matching lines @@
      * @param selectionEnd The character offset of the selection end, or the caret position if there
      *                     is no selection.
      * @param compositionStart The character offset of the composition start, or -1 if there is no
      *                         composition.
      * @param compositionEnd The character offset of the composition end, or -1 if there is no
      *                       selection.
      * @param isNonImeChange True when the update was caused by non-IME (e.g. Javascript).
      */
     public void updateState(String text, int selectionStart, int selectionEnd, int compositionStart,
             int compositionEnd, boolean isNonImeChange) {
-        if (mInputConnection == null) return;
-        mInputConnection.updateState(text, selectionStart, selectionEnd, compositionStart,
-                compositionEnd, isNonImeChange);
+        if (mInputConnection != null) {
+            mInputConnection.updateState(text, selectionStart, selectionEnd, compositionStart,
+                    compositionEnd, isNonImeChange);
+        }
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.invalidateLastCursorAnchorInfo();
+        }
     }
 
     /**
      * Attaches the imeAdapter to its native counterpart. This is needed to start forwarding
      * keyboard events to WebKit.
      * @param nativeImeAdapter The pointer to the native ImeAdapter object.
      */
     public void attach(long nativeImeAdapter) {
         if (mNativeImeAdapterAndroid == nativeImeAdapter) return;
         if (mNativeImeAdapterAndroid != 0) {
@@ skipping 254 matching lines @@
      */
     boolean setComposingRegion(CharSequence text, int start, int end) {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativeSetComposingRegion(mNativeImeAdapterAndroid, start, end);
         return true;
     }
 
     @CalledByNative
     private void focusedNodeChanged(boolean isEditable) {
         if (DEBUG_LOGS) Log.w(TAG, "focusedNodeChanged: isEditable [%b]", isEditable);
+
+        // Update controller before the connection is restarted.
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.focusedNodeChanged(isEditable);
+        }
+
         if (mTextInputType != TextInputType.NONE && mInputConnection != null && isEditable) {
             restartInput();
         }
     }
 
+    public boolean onRequestCursorUpdates(int cursorUpdateMode) {
+        if (mCursorAnchorInfoController == null) return false;
+        return mCursorAnchorInfoController.onRequestCursorUpdates(cursorUpdateMode,
+                mViewEmbedder.getAttachedView());
+    }
+
+    /**
+     * Notify the location of composing characters to the IME if it explicitly requested them.
+     * @param renderCoordinates coordinate information to convert CSS (document) coordinates to
+     * View-local Physical (screen) coordinates
+     * @param hasInsertionMarker Whether the insertion marker is visible or not.
+     * @param insertionMarkerHorizontal X coordinates (in view-local DIP pixels) of the insertion
+     * marker if it exists. Will be ignored otherwise.
+     * @param insertionMarkerTop Y coordinates (in view-local DIP pixels) of the top of the
+     * insertion marker if it exists. Will be ignored otherwise.
+     * @param insertionMarkerBottom Y coordinates (in view-local DIP pixels) of the bottom of
+     * the insertion marker if it exists. Will be ignored otherwise.
+     */
+    public void onUpdateFrameInfo(RenderCoordinates renderCoordinates, boolean hasInsertionMarker,
+            boolean isInsertionMarkerVisible, float insertionMarkerHorizontal,
+            float insertionMarkerTop, float insertionMarkerBottom) {
+        if (mCursorAnchorInfoController == null) return;
+        mCursorAnchorInfoController.onUpdateFrameInfo(renderCoordinates, hasInsertionMarker,
+                isInsertionMarkerVisible, insertionMarkerHorizontal, insertionMarkerTop,
+                insertionMarkerBottom, mViewEmbedder.getAttachedView());
+    }
+
     @CalledByNative
     private void populateUnderlinesFromSpans(CharSequence text, long underlines) {
         if (DEBUG_LOGS) {
             Log.w(TAG, "populateUnderlinesFromSpans: text [%s], underlines [%d]", text, underlines);
         }
         if (!(text instanceof SpannableString)) return;
 
         SpannableString spannableString = ((SpannableString) text);
         CharacterStyle spans[] =
                 spannableString.getSpans(0, text.length(), CharacterStyle.class);
         for (CharacterStyle span : spans) {
             if (span instanceof BackgroundColorSpan) {
                 nativeAppendBackgroundColorSpan(underlines, spannableString.getSpanStart(span),
                         spannableString.getSpanEnd(span),
                         ((BackgroundColorSpan) span).getBackgroundColor());
             } else if (span instanceof UnderlineSpan) {
                 nativeAppendUnderlineSpan(underlines, spannableString.getSpanStart(span),
                         spannableString.getSpanEnd(span));
             }
         }
     }
 
     @CalledByNative
     private void cancelComposition() {
         if (DEBUG_LOGS) Log.w(TAG, "cancelComposition");
         if (mInputConnection != null) restartInput();
     }
 
     @CalledByNative
+    private void setCharacterBounds(float[] characterBounds) {
+        if (mCursorAnchorInfoController == null) return;
+        mCursorAnchorInfoController.setCompositionCharacterBounds(characterBounds);
+    }
+
+    @CalledByNative
     private void detach() {
         if (DEBUG_LOGS) Log.w(TAG, "detach");
         mNativeImeAdapterAndroid = 0;
+        mTextInputType = 0;

[aelias_OOO_until_Jul13, 2016/02/26 08:25:33]

Another deleted line accidentally reintroduced?

[kinaba, 2016/03/01 08:46:46]

Ouch. Sorry for my carelessness.. Done,.

+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.focusedNodeChanged(false);
+        }
     }
 
     private native boolean nativeSendSyntheticKeyEvent(long nativeImeAdapterAndroid,
             int eventType, long timestampMs, int keyCode, int modifiers, int unicodeChar);
 
     private native boolean nativeSendKeyEvent(long nativeImeAdapterAndroid, KeyEvent event,
             int action, int modifiers, long timestampMs, int keyCode, int scanCode,
             boolean isSystemKey, int unicodeChar);
 
     private static native void nativeAppendUnderlineSpan(long underlinePtr, int start, int end);
@@ skipping 13 matching lines @@
     private native void nativeSetEditableSelectionOffsets(long nativeImeAdapterAndroid,
             int start, int end);
 
     private native void nativeSetComposingRegion(long nativeImeAdapterAndroid, int start, int end);
 
     private native void nativeDeleteSurroundingText(long nativeImeAdapterAndroid,
             int before, int after);
 
     private native void nativeResetImeAdapter(long nativeImeAdapterAndroid);
 }