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.graphics.Matrix;
+import android.os.Build;
 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.InputConnection;
+import android.view.inputmethod.InputMethodManager;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.ui.picker.InputDialogContainer;
 
 import java.lang.CharSequence;
 
 /**
  * Adapts and plumbs android IME service onto the chrome text input API.
@@ skipping 107 matching lines @@
     private long mNativeImeAdapterAndroid;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
     private AdapterInputConnection mInputConnection;
     private final ImeAdapterDelegate mViewEmbedder;
     private final Handler mHandler;
     private DelayedDismissInput mDismissInput = null;
     private int mTextInputType;
     private int mTextInputFlags;
     private String mLastComposeText;
 
+    private static class CursorAnchorInfoSource {
+        private String mText;
+        private int mSelectionStart;
+        private int mSelectionEnd;
+        private int mCompositionStart;
+        private int mCompositionEnd;
+        private float[] mLastCharacterBounds;
+    }
+    private CursorAnchorInfoSource mCursorAnchorInfoSource = new CursorAnchorInfoSource();
+
+    private static class CursorAnchorInfoBuilderWrapper {
+
+        public static boolean isSupported() {
+            return false;
+        }
+
+        public static CursorAnchorInfoBuilderWrapper create() {
+            return new CursorAnchorInfoBuilderWrapper();
+        }
+
+        protected CursorAnchorInfoBuilderWrapper() {
+        }
+
+        public void update(CursorAnchorInfoSource source, Matrix matrix, boolean hasInertionMarker,
+                float insertionMarkerX, float insertionMarkerTop, float insertionMarkerBottom) {
+            // This is a stub for platforms that do not support CursorAnchorInfo.
+        }
+
+        public boolean hasData() {
+            // This is a stub for platforms that do not support CursorAnchorInfo.
+            return false;
+        }
+
+        public void reset() {
+            // This is a stub for platforms that do not support CursorAnchorInfo.
+        }
+
+        public void send(InputMethodManagerWrapper inputMethodManagerWrapper, View view) {
+            // This is a stub for platforms that do not support CursorAnchorInfo.
+        }
+    }
+
+    private CursorAnchorInfoBuilderWrapper mCursorAnchorInfoBuilder =
+            CursorAnchorInfoBuilderWrapper.create();
+    private boolean mCursorAnchorInfoMonitorEnabled = false;
+    private boolean mOneshotUpdateCursorAnchorInfoEnabled = false;
+
     @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.
@@ skipping 458 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;
     }
 
+    /**
+     * @return Whether the {@link CursorAnchorInfo} is available or not on this device.
+     */
+    public boolean isCursorAnchorInfoSupported() {
+        return CursorAnchorInfoBuilderWrapper.isSupported();
+    }
+
+    /**
+     * Start or stop calling
+     * {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)}.
+     * @param enabled {@code true} if {@link InputConnection#requestCursorUpdates(int)} is called
+     * with {@link InputConnection#CURSOR_UPDATE_MONITOR} bit.
+     */
+    public void setCursorAnchorInfoMonitorEnabled(boolean enabled) {
+        mCursorAnchorInfoMonitorEnabled = enabled;
+    }
+
+    /**
+     * Make sure {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)} is called
+     * at least once immediately when the latest position becomes available.
+     * @param view The view to be passed to
+     * {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)} if the latest
+     * position is already available. Otherwise ignored.
+     */
+    public void scheduleOneshotUpdateCursorAnchorInfo(View view) {
+        if (!mCursorAnchorInfoBuilder.hasData()) {
+            // If there is no data, send the data later when it becomes available.
+            mOneshotUpdateCursorAnchorInfoEnabled = true;
+            return;
+        }
+        mCursorAnchorInfoBuilder.send(mInputMethodManagerWrapper, view);
+        mOneshotUpdateCursorAnchorInfoEnabled = false;
+    }
+
+    /**
+     * Update the parameters that are to be passed to the IME through
+     * {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)}.
+     * @param text The 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 updateCursorAnchorInfoSource(String text, int selectionStart, int selectionEnd,
+            int compositionStart, int compositionEnd) {
+        mCursorAnchorInfoSource.mText = text;
+        mCursorAnchorInfoSource.mSelectionStart = selectionStart;
+        mCursorAnchorInfoSource.mSelectionEnd = selectionEnd;
+        mCursorAnchorInfoSource.mCompositionStart = compositionStart;
+        mCursorAnchorInfoSource.mCompositionEnd = compositionEnd;
+    }
+
+    /**
+     * Call {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)} if it is
+     * available and the active IME is actually requested it.
+     * @param view The view to be passed to
+     * {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)}
+     * @param matrix The matrix from CSS coordinates to the absolute display coordinates.
+     * @param hasInsertionMaerker Whether the insertion marker exists or not.
+     * @param insertionMarkerX The X position of the insertion marker, in CSS coordinates.
+     * @param insertionMarkerTop The top position of the insertion marker, in CSS coordinates.
+     * @param insertionMarkerBottom The bottom position of the insertion marker, in CSS coordinates.
+     */
+    public void updateCursorAnchorInfo(View view, Matrix matrix, boolean hasInsertionMaerker,
+            float insertionMarkerX, float insertionMarkerTop, float insertionMarkerBottom) {
+        mCursorAnchorInfoBuilder.update(mCursorAnchorInfoSource, matrix, hasInsertionMaerker,
+                insertionMarkerX, insertionMarkerTop, insertionMarkerBottom);
+        if (!mCursorAnchorInfoMonitorEnabled && !mOneshotUpdateCursorAnchorInfoEnabled) return;
+        mCursorAnchorInfoBuilder.send(mInputMethodManagerWrapper, view);
+        mOneshotUpdateCursorAnchorInfoEnabled = false;
+    }
+
     // Calls from C++ to Java
 
     @CalledByNative
     private static void initializeWebInputEvents(int eventTypeRawKeyDown, int eventTypeKeyUp,
             int eventTypeChar, int modifierShift, int modifierAlt, int modifierCtrl,
             int modifierCapsLockOn, int modifierNumLockOn) {
         sEventTypeRawKeyDown = eventTypeRawKeyDown;
         sEventTypeKeyUp = eventTypeKeyUp;
         sEventTypeChar = eventTypeChar;
         sModifierShift = modifierShift;
@@ skipping 58 matching lines @@
     }
 
     @CalledByNative
     private void cancelComposition() {
         if (mInputConnection != null) mInputConnection.restartInput();
         mLastComposeText = null;
     }
 
     @CalledByNative
     private void setCharacterBounds(float[] characterBounds) {
-        // TODO(yukawa): Implement this.
+        mCursorAnchorInfoSource.mLastCharacterBounds = characterBounds;
     }
 
     @CalledByNative
     void detach() {
         if (mDismissInput != null) {
             mHandler.removeCallbacks(mDismissInput);
             mDismissInput.detach();
         }
         mNativeImeAdapterAndroid = 0;
         mTextInputType = 0;
+        mCursorAnchorInfoBuilder.reset();
     }
 
     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);
 }