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.Build;
 import android.os.ResultReceiver;
 import android.os.SystemClock;
 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.CommandLine;
 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.content.common.ContentSwitches;
 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 51 matching lines @@
 
     static char[] sSingleCharArray = new char[1];
     static KeyCharacterMap sKeyCharacterMap;
 
     private long mNativeImeAdapterAndroid;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
     private ChromiumBaseInputConnection mInputConnection;
     private ChromiumBaseInputConnection.Factory mInputConnectionFactory;
 
     private final ImeAdapterDelegate mViewEmbedder;
+    // 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;
 
     private int mTextInputType = TextInputType.NONE;
     private int mTextInputFlags;
 
     // Keep the current configuration to detect the change when onConfigurationChanged() is called.
     private Configuration mCurrentConfig;
 
     private int mLastSelectionStart;
     private int mLastSelectionEnd;
+    private String mLastText;
+    private int mLastCompositionStart;
+    private int mLastCompositionEnd;
 
     /**
      * @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;
         resetInputConnectionFactory();
         // Deep copy newConfig so that we can notice the difference.
         mCurrentConfig = new Configuration(
                 mViewEmbedder.getAttachedView().getResources().getConfiguration());
+        // CursorAnchroInfo is supported only after L.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            mCursorAnchorInfoController = CursorAnchorInfoController.create(wrapper,
+                    new CursorAnchorInfoController.ComposingTextDelegate() {
+                        @Override
+                        public CharSequence getText() {
+                            return mLastText;
+                        }
+                        @Override
+                        public int getSelectionStart() {
+                            return mLastSelectionStart;
+                        }
+                        @Override
+                        public int getSelectionEnd() {
+                            return mLastSelectionEnd;
+                        }
+                        @Override
+                        public int getComposingTextStart() {
+                            return mLastCompositionStart;
+                        }
+                        @Override
+                        public int getComposingTextEnd() {
+                            return mLastCompositionEnd;
+                        }
+                    });
+        } else {
+            mCursorAnchorInfoController = null;
+        }
     }
 
     void resetInputConnectionFactory() {
         if (shouldUseImeThread()) {
             mInputConnectionFactory =
                     new ThreadedInputConnectionFactory(mInputMethodManagerWrapper);
         } else {
             mInputConnectionFactory = new ReplicaInputConnection.Factory();
         }
     }
@@ skipping 24 matching lines @@
             // Even when InputConnection methods are blocked IMM can still call this.
             if (mInputConnection != null) mInputConnection.unblockOnUiThread();
             mInputConnection = null;
             if (DEBUG_LOGS) Log.w(TAG, "onCreateInputConnection returns null.");
             return null;
         }
         mInputConnection = mInputConnectionFactory.initializeAndGet(
                 mViewEmbedder.getAttachedView(), this, mTextInputType, mTextInputFlags,
                 mLastSelectionStart, mLastSelectionEnd, outAttrs);
         if (DEBUG_LOGS) Log.w(TAG, "onCreateInputConnection: " + mInputConnection);
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.resetMonitoringState();
+        }
         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);

[Ted C, 2016/03/07 21:31:45]

Should this method also be called setInputMethodManagerWrapperForTest?

Or do you call it for normal paths as well?

[kinaba, 2016/03/10 06:24:12]

Good point. It's only for testing. Done.

+        }
     }
 
     @VisibleForTesting
     void setInputConnectionFactory(ChromiumBaseInputConnection.Factory factory) {
         mInputConnectionFactory = factory;
     }
 
     @VisibleForTesting
     ChromiumBaseInputConnection.Factory getInputConnectionFactoryForTest() {
         return mInputConnectionFactory;
@@ skipping 65 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 (mCursorAnchorInfoController != null && (!TextUtils.equals(mLastText, text)
+                || mLastSelectionStart != selectionStart || mLastSelectionEnd != selectionEnd
+                || mLastCompositionStart != compositionStart
+                || mLastCompositionEnd != compositionEnd)) {
+            mCursorAnchorInfoController.invalidateLastCursorAnchorInfo();
+        }
+        mLastText = text;
         mLastSelectionStart = selectionStart;
         mLastSelectionEnd = selectionEnd;
+        mLastCompositionStart = compositionStart;
+        mLastCompositionEnd = compositionEnd;
+
         if (mInputConnection == null) return;
         boolean singleLine = mTextInputType != TextInputType.TEXT_AREA
                 && mTextInputType != TextInputType.CONTENT_EDITABLE;
         mInputConnection.updateStateOnUiThread(text, selectionStart, selectionEnd, compositionStart,
                 compositionEnd, singleLine, isNonImeChange);
     }
 
     /**
      * Attaches the imeAdapter to its native counterpart. This is needed to start forwarding
      * keyboard events to WebKit.
@@ skipping 276 matching lines @@
      */
     boolean setComposingRegion(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();
         }
     }
 
     /**
      * Send a request to the native counterpart to give the latest text input state update.
      */
     boolean requestTextInputStateUpdate() {
         if (mNativeImeAdapterAndroid == 0) return false;
         // You won't get state update anyways.
         if (mInputConnection == null) return false;
         return nativeRequestTextInputStateUpdate(mNativeImeAdapterAndroid);
     }
 
+    /*

[Ted C, 2016/03/07 21:31:45]

add another *

[kinaba, 2016/03/10 06:24:12]

Done.

+     * Forward the cursor update request to CursorAnchorInfoController.

[Ted C, 2016/03/07 21:31:45]

This comment describes the code not why you should call it, which is not
particularly helpful.

[kinaba, 2016/03/10 06:24:12]

Done.

+     */
+    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.

[Ted C, 2016/03/07 21:31:45]

Again this comment isn't really a good description of this method.

This should just state something like "Notified when a frame has been produced
by the renderer and all the associated metadata".

onUpdateFrameInfo has not directly associated with composing characters.  Or you
can rename it like updateComposingCharacterPositions or something.

[kinaba, 2016/03/10 06:24:12]

Done.

+     * @param renderCoordinates coordinate information to convert CSS (document) coordinates to
+     * View-local Physical (screen) coordinates

[Ted C, 2016/03/07 21:31:45]

align with the start of the sentence above (coordinate information ...).  Same
for subsequent lines.

[kinaba, 2016/03/10 06:24:12]

Done.

+     * @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;
+        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);
     private static native void nativeAppendBackgroundColorSpan(long underlinePtr, int start,
             int end, int backgroundColor);
     private native void nativeSetComposingText(long nativeImeAdapterAndroid, CharSequence text,
             String textStr, int newCursorPosition);
     private native void nativeCommitText(long nativeImeAdapterAndroid, String textStr);
     private native void nativeFinishComposingText(long nativeImeAdapterAndroid);
     private native void nativeAttachImeAdapter(long nativeImeAdapterAndroid);
     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);
     private native boolean nativeRequestTextInputStateUpdate(long nativeImeAdapterAndroid);
 }