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.Handler;
 import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.text.Editable;
 import android.text.SpannableString;
 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.CursorAnchorInfo;
 import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputMethodManager;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.blink_public.web.WebInputEventModifier;
 import org.chromium.blink_public.web.WebInputEventType;
 import org.chromium.blink_public.web.WebTextInputFlags;
+import org.chromium.content.browser.RenderCoordinates;
 import org.chromium.ui.base.ime.TextInputType;
 import org.chromium.ui.picker.InputDialogContainer;
 
 import java.lang.CharSequence;
 
 /**
  * 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.
@@ skipping 66 matching lines @@
 
     private long mNativeImeAdapterAndroid;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
     private AdapterInputConnection mInputConnection;
     private final ImeAdapterDelegate mViewEmbedder;
     private final Handler mHandler;
     private int mTextInputType;
     private int mTextInputFlags;
     private String mLastComposeText;
 
+    private final CursorAnchorInfoController mCursorAnchorInfoController;
+
     @VisibleForTesting
     int mLastSyntheticKeyCode;
 
     @VisibleForTesting
     boolean mIsShowWithoutHideOutstanding = false;
 
     /**
      * @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;
         mHandler = new Handler();
+        mCursorAnchorInfoController = CursorAnchorInfoController.create(wrapper);
     }
 
     /**
      * Default factory for AdapterInputConnection classes.
      */
     public static class AdapterInputConnectionFactory {
         public AdapterInputConnection get(View view, ImeAdapter imeAdapter,
                 Editable editable, EditorInfo outAttrs) {
             return new AdapterInputConnection(view, imeAdapter, editable, outAttrs);
         }
     }
 
     /**
      * Overrides the InputMethodManagerWrapper that ImeAdapter uses to make calls to
      * InputMethodManager.
      * @param immw InputMethodManagerWrapper that should be used to call InputMethodManager.
      */
     @VisibleForTesting
     public void setInputMethodManagerWrapper(InputMethodManagerWrapper immw) {
         mInputMethodManagerWrapper = immw;
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.setInputMethodManagerWrapper(immw);
+        }
     }
 
     /**
      * Should be only used by AdapterInputConnection.
      * @return InputMethodManagerWrapper that should receive all the calls directed to
      *         InputMethodManager.
      */
     InputMethodManagerWrapper getInputMethodManagerWrapper() {
         return mInputMethodManagerWrapper;
     }
@@ skipping 444 matching lines @@
     /**
      * Send a request to the native counterpart of ImeAdapter to paste the text from the clipboard.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
     public boolean paste() {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativePaste(mNativeImeAdapterAndroid);
         return true;
     }
 
+    public boolean onRequestCursorUpdates(int cursorUpdateMode) {
+        if (mCursorAnchorInfoController == null) return false;
+        return mCursorAnchorInfoController.onRequestCursorUpdates(cursorUpdateMode,
+                mViewEmbedder.getAttachedView());
+    }
+
+    /**
+     * Update the parameters that are to be passed to the IME through
+     * {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)}.
+     * @param text Text in the focused text field.
+     * @param selectionStart Index where the text selection starts. {@code -1} if there is no
+     * selection.
+     * @param selectionEnd Index where the text selection ends. {@code -1} if there is no
+     * selection.
+     * @param compositionStart Index where the text composition starts. {@code -1} if there is no
+     * selection.
+     * @param compositionEnd Index where the text composition ends. {@code -1} if there is no
+     * selection.
+     */
+    public void updateTextAndSelection(String text, int selectionStart, int selectionEnd,
+            int compositionStart, int compositionEnd) {
+        if (mCursorAnchorInfoController == null) return;
+        mCursorAnchorInfoController.updateTextAndSelection(text, compositionStart, compositionEnd,
+                selectionStart, selectionEnd);
+    }
+
+    /**
+     * 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 of the insertion marker if it exists.
+     * Will be ignored otherwise.
+     * @param insertionMarkerTop Y coordinates of the top of the insertion marker if it exists.
+     * Will be ignored otherwise.
+     * @param insertionMarkerBottom Y coordinates 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());
+    }
+
     // Calls from C++ to Java
 
     @CalledByNative
     private void focusedNodeChanged(boolean isEditable) {
+        // Update controller before the connection is restarted.
+        if (mCursorAnchorInfoController != null) {
+            mCursorAnchorInfoController.focusedNodeChanged(isEditable);
+        }
         if (mInputConnection != null && isEditable) mInputConnection.restartInput();
     }
 
     @CalledByNative
     private void populateUnderlinesFromSpans(CharSequence text, long 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 (mInputConnection != null) mInputConnection.restartInput();
         mLastComposeText = null;
     }
 
     @CalledByNative
+    private void setCharacterBounds(float[] characterBounds) {
+        if (mCursorAnchorInfoController == null) return;
+        mCursorAnchorInfoController.setCompositionCharacterBounds(characterBounds);
+    }
+
+    @CalledByNative
     void detach() {
         mHandler.removeCallbacks(mDismissInputRunnable);
         mNativeImeAdapterAndroid = 0;
         mTextInputType = 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, boolean isSystemKey,
             int unicodeChar);
 
     private static native void nativeAppendUnderlineSpan(long underlinePtr, int start, int end);
@@ skipping 18 matching lines @@
     private native void nativeDeleteSurroundingText(long nativeImeAdapterAndroid,
             int before, int after);
 
     private native void nativeUnselect(long nativeImeAdapterAndroid);
     private native void nativeSelectAll(long nativeImeAdapterAndroid);
     private native void nativeCut(long nativeImeAdapterAndroid);
     private native void nativeCopy(long nativeImeAdapterAndroid);
     private native void nativePaste(long nativeImeAdapterAndroid);
     private native void nativeResetImeAdapter(long nativeImeAdapterAndroid);
 }