auto import from //branches/cupcake/...@130745

1 files changed, 475 insertions, 5 deletions

diff --git a/core/java/android/view/inputmethod/BaseInputConnection.java b/core/java/android/view/inputmethod/BaseInputConnection.java
index a6ce293..56c6c92 100644
--- a/core/java/android/view/inputmethod/BaseInputConnection.java
+++ b/core/java/android/view/inputmethod/BaseInputConnection.java
@@ -17,35 +17,365 @@
 package android.view.inputmethod;
 
 import android.content.Context;
+import android.content.res.TypedArray;
+import android.os.Bundle;
 import android.os.Handler;
-import android.os.Message;
+import android.os.SystemClock;
+import android.text.Editable;
+import android.text.NoCopySpan;
+import android.text.Selection;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.method.MetaKeyKeyListener;
+import android.util.Log;
+import android.util.LogPrinter;
+import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.ViewRoot;
 
+class ComposingText implements NoCopySpan {
+}
+
 /**
  * Base class for implementors of the InputConnection interface, taking care
- * of implementing common system-oriented parts of the functionality.
+ * of most of the common behavior for providing a connection to an Editable.
+ * Implementors of this class will want to be sure to implement
+ * {@link #getEditable} to provide access to their own editable object.
  */
-public abstract class BaseInputConnection implements InputConnection {
+public class BaseInputConnection implements InputConnection {
+    private static final boolean DEBUG = false;
+    private static final String TAG = "BaseInputConnection";
+    static final Object COMPOSING = new ComposingText();
+    
     final InputMethodManager mIMM;
     final Handler mH;
     final View mTargetView;
+    final boolean mDummyMode;
+    
+    private Object[] mDefaultComposingSpans;
+    
+    Editable mEditable;
+    KeyCharacterMap mKeyCharacterMap;
     
-    BaseInputConnection(InputMethodManager mgr) {
+    BaseInputConnection(InputMethodManager mgr, boolean dummyMode) {
         mIMM = mgr;
         mTargetView = null;
         mH = null;
+        mDummyMode = dummyMode;
     }
     
-    public BaseInputConnection(View targetView) {
+    public BaseInputConnection(View targetView, boolean dummyMode) {
         mIMM = (InputMethodManager)targetView.getContext().getSystemService(
                 Context.INPUT_METHOD_SERVICE);
         mH = targetView.getHandler();
         mTargetView = targetView;
+        mDummyMode = dummyMode;
+    }
+    
+    public static final void removeComposingSpans(Spannable text) {
+        text.removeSpan(COMPOSING);
+        Object[] sps = text.getSpans(0, text.length(), Object.class);
+        if (sps != null) {
+            for (int i=sps.length-1; i>=0; i--) {
+                Object o = sps[i];
+                if ((text.getSpanFlags(o)&Spanned.SPAN_COMPOSING) != 0) {
+                    text.removeSpan(o);
+                }
+            }
+        }
+    }
+    
+    public static void setComposingSpans(Spannable text) {
+        final Object[] sps = text.getSpans(0, text.length(), Object.class);
+        if (sps != null) {
+            for (int i=sps.length-1; i>=0; i--) {
+                final Object o = sps[i];
+                if (o == COMPOSING) {
+                    text.removeSpan(o);
+                    continue;
+                }
+                final int fl = text.getSpanFlags(o);
+                if ((fl&(Spanned.SPAN_COMPOSING|Spanned.SPAN_POINT_MARK_MASK)) 
+                        != (Spanned.SPAN_COMPOSING|Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)) {
+                    text.setSpan(o, text.getSpanStart(o), text.getSpanEnd(o),
+                            (fl&Spanned.SPAN_POINT_MARK_MASK)
+                                    | Spanned.SPAN_COMPOSING
+                                    | Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+                }
+            }
+        }
+        
+        text.setSpan(COMPOSING, 0, text.length(),
+                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_COMPOSING);
+    }
+    
+    public static int getComposingSpanStart(Spannable text) {
+        return text.getSpanStart(COMPOSING);
+    }
+    
+    public static int getComposingSpanEnd(Spannable text) {
+        return text.getSpanEnd(COMPOSING);
+    }
+    
+    /**
+     * Return the target of edit operations.  The default implementation
+     * returns its own fake editable that is just used for composing text;
+     * subclasses that are real text editors should override this and
+     * supply their own.
+     */
+    public Editable getEditable() {
+        if (mEditable == null) {
+            mEditable = Editable.Factory.getInstance().newEditable("");
+            Selection.setSelection(mEditable, 0);
+        }
+        return mEditable;
     }
     
     /**
+     * Default implementation does nothing.
+     */
+    public boolean beginBatchEdit() {
+        return false;
+    }
+
+    /**
+     * Default implementation does nothing.
+     */
+    public boolean endBatchEdit() {
+        return false;
+    }
+
+    /**
+     * Default implementation uses
+     * {@link MetaKeyKeyListener#clearMetaKeyState(long, int)
+     * MetaKeyKeyListener.clearMetaKeyState(long, int)} to clear the state.
+     */
+    public boolean clearMetaKeyStates(int states) {
+        final Editable content = getEditable();
+        if (content == null) return false;
+        MetaKeyKeyListener.clearMetaKeyState(content, states);
+        return true;
+    }
+
+    /**
+     * Default implementation does nothing.
+     */
+    public boolean commitCompletion(CompletionInfo text) {
+        return false;
+    }
+
+    /**
+     * Default implementation replaces any existing composing text with
+     * the given text.  In addition, only if dummy mode, a key event is
+     * sent for the new text and the current editable buffer cleared.
+     */
+    public boolean commitText(CharSequence text, int newCursorPosition) {
+        if (DEBUG) Log.v(TAG, "commitText " + text);
+        replaceText(text, newCursorPosition, false);
+        sendCurrentText();
+        return true;
+    }
+
+    /**
+     * The default implementation performs the deletion around the current
+     * selection position of the editable text.
+     */
+    public boolean deleteSurroundingText(int leftLength, int rightLength) {
+        if (DEBUG) Log.v(TAG, "deleteSurroundingText " + leftLength
+                + " / " + rightLength);
+        final Editable content = getEditable();
+        if (content == null) return false;
+
+        beginBatchEdit();
+        
+        int a = Selection.getSelectionStart(content);
+        int b = Selection.getSelectionEnd(content);
+
+        if (a > b) {
+            int tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        // ignore the composing text.
+        int ca = getComposingSpanStart(content);
+        int cb = getComposingSpanEnd(content);
+        if (cb < ca) {
+            int tmp = ca;
+            ca = cb;
+            cb = tmp;
+        }
+        if (ca != -1 && cb != -1) {
+            if (ca < a) a = ca;
+            if (cb > b) b = cb;
+        }
+
+        int deleted = 0;
+
+        if (leftLength > 0) {
+            int start = a - leftLength;
+            if (start < 0) start = 0;
+            content.delete(start, a);
+            deleted = a - start;
+        }
+
+        if (rightLength > 0) {
+            b = b - deleted;
+
+            int end = b + rightLength;
+            if (end > content.length()) end = content.length();
+
+            content.delete(b, end);
+        }
+        
+        endBatchEdit();
+        
+        return true;
+    }
+
+    /**
+     * The default implementation removes the composing state from the
+     * current editable text.  In addition, only if dummy mode, a key event is
+     * sent for the new text and the current editable buffer cleared.
+     */
+    public boolean finishComposingText() {
+        if (DEBUG) Log.v(TAG, "finishComposingText");
+        final Editable content = getEditable();
+        if (content != null) {
+            beginBatchEdit();
+            removeComposingSpans(content);
+            endBatchEdit();
+            sendCurrentText();
+        }
+        return true;
+    }
+
+    /**
+     * The default implementation uses TextUtils.getCapsMode to get the
+     * cursor caps mode for the current selection position in the editable
+     * text, unless in dummy mode in which case 0 is always returned.
+     */
+    public int getCursorCapsMode(int reqModes) {
+        if (mDummyMode) return 0;
+        
+        final Editable content = getEditable();
+        if (content == null) return 0;
+        
+        int a = Selection.getSelectionStart(content);
+        int b = Selection.getSelectionEnd(content);
+
+        if (a > b) {
+            int tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        return TextUtils.getCapsMode(content, a, reqModes);
+    }
+
+    /**
+     * The default implementation always returns null.
+     */
+    public ExtractedText getExtractedText(ExtractedTextRequest request, int flags) {
+        return null;
+    }
+
+    /**
+     * The default implementation returns the given amount of text from the
+     * current cursor position in the buffer.
+     */
+    public CharSequence getTextBeforeCursor(int length, int flags) {
+        final Editable content = getEditable();
+        if (content == null) return null;
+
+        int a = Selection.getSelectionStart(content);
+        int b = Selection.getSelectionEnd(content);
+
+        if (a > b) {
+            int tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        if (length > a) {
+            length = a;
+        }
+
+        if ((flags&GET_TEXT_WITH_STYLES) != 0) {
+            return content.subSequence(a - length, a);
+        }
+        return TextUtils.substring(content, a - length, a);
+    }
+
+    /**
+     * The default implementation returns the given amount of text from the
+     * current cursor position in the buffer.
+     */
+    public CharSequence getTextAfterCursor(int length, int flags) {
+        final Editable content = getEditable();
+        if (content == null) return null;
+
+        int a = Selection.getSelectionStart(content);
+        int b = Selection.getSelectionEnd(content);
+
+        if (a > b) {
+            int tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        if (b + length > content.length()) {
+            length = content.length() - b;
+        }
+
+
+        if ((flags&GET_TEXT_WITH_STYLES) != 0) {
+            return content.subSequence(b, b + length);
+        }
+        return TextUtils.substring(content, b, b + length);
+    }
+
+    /**
+     * The default implementation does nothing.
+     */
+    public boolean performContextMenuAction(int id) {
+        return false;
+    }
+
+    /**
+     * The default implementation does nothing.
+     */
+    public boolean performPrivateCommand(String action, Bundle data) {
+        return false;
+    }
+
+    /**
+     * The default implementation places the given text into the editable,
+     * replacing any existing composing text.  The new text is marked as
+     * in a composing state with the composing style.
+     */
+    public boolean setComposingText(CharSequence text, int newCursorPosition) {
+        if (DEBUG) Log.v(TAG, "setComposingText " + text);
+        replaceText(text, newCursorPosition, true);
+        return true;
+    }
+
+    /**
+     * The default implementation changes the selection position in the
+     * current editable text.
+     */
+    public boolean setSelection(int start, int end) {
+        if (DEBUG) Log.v(TAG, "setSelection " + start + ", " + end);
+        final Editable content = getEditable();
+        if (content == null) return false;
+        Selection.setSelection(content, start, end);
+        return true;
+    }
+
+    /**
      * Provides standard implementation for sending a key event to the window
      * attached to the input connection's view.
      */
@@ -82,4 +412,144 @@ public abstract class BaseInputConnection implements InputConnection {
         mIMM.updateStatusIcon(resId, packageName);
         return true;
     }
+    
+    private void sendCurrentText() {
+        if (!mDummyMode) {
+            return;
+        }
+        
+        Editable content = getEditable();
+        if (content != null) {
+            if (content.length() == 1) {
+                // If it's 1 character, we have a chance of being
+                // able to generate normal key events...
+                if (mKeyCharacterMap == null) {
+                    mKeyCharacterMap = KeyCharacterMap.load(
+                            KeyCharacterMap.BUILT_IN_KEYBOARD);
+                }
+                char[] chars = new char[1];
+                content.getChars(0, 1, chars, 0);
+                KeyEvent[] events = mKeyCharacterMap.getEvents(chars);
+                if (events != null) {
+                    for (int i=0; i<events.length; i++) {
+                        if (DEBUG) Log.v(TAG, "Sending: " + events[i]);
+                        sendKeyEvent(events[i]);
+                    }
+                    content.clear();
+                    return;
+                }
+            }
+            
+            // Otherwise, revert to the special key event containing
+            // the actual characters.
+            KeyEvent event = new KeyEvent(SystemClock.uptimeMillis(),
+                    content.toString(), KeyCharacterMap.BUILT_IN_KEYBOARD, 0);
+            sendKeyEvent(event);
+            content.clear();
+        }
+    }
+    
+    private void replaceText(CharSequence text, int newCursorPosition,
+            boolean composing) {
+        final Editable content = getEditable();
+        if (content == null) {
+            return;
+        }
+        
+        beginBatchEdit();
+        
+        // delete composing text set previously.
+        int a = getComposingSpanStart(content);
+        int b = getComposingSpanEnd(content);
+
+        if (DEBUG) Log.v(TAG, "Composing span: " + a + " to " + b);
+        
+        if (b < a) {
+            int tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        if (a != -1 && b != -1) {
+            removeComposingSpans(content);
+        } else {
+            a = Selection.getSelectionStart(content);
+            b = Selection.getSelectionEnd(content);
+            if (a >=0 && b>= 0 && a != b) {
+                if (b < a) {
+                    int tmp = a;
+                    a = b;
+                    b = tmp;
+                }
+            }
+        }
+
+        if (composing) {
+            Spannable sp = null;
+            if (!(text instanceof Spannable)) {
+                sp = new SpannableStringBuilder(text);
+                text = sp;
+                if (mDefaultComposingSpans == null) {
+                    Context context;
+                    if (mTargetView != null) {
+                        context = mTargetView.getContext();
+                    } else if (mIMM.mServedView != null) {
+                        context = mIMM.mServedView.getContext();
+                    } else {
+                        context = null;
+                    }
+                    if (context != null) {
+                        TypedArray ta = context.getTheme()
+                                .obtainStyledAttributes(new int[] {
+                                        com.android.internal.R.attr.candidatesTextStyleSpans
+                                });
+                        CharSequence style = ta.getText(0);
+                        ta.recycle();
+                        if (style != null && style instanceof Spanned) {
+                            mDefaultComposingSpans = ((Spanned)style).getSpans(
+                                    0, style.length(), Object.class);
+                        }
+                    }
+                }
+                if (mDefaultComposingSpans != null) {
+                    for (int i = 0; i < mDefaultComposingSpans.length; ++i) {
+                        sp.setSpan(mDefaultComposingSpans[i], 0, sp.length(),
+                                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+                    }
+                }
+            } else {
+                sp = (Spannable)text;
+            }
+            setComposingSpans(sp);
+        }
+        
+        // Adjust newCursorPosition to be relative the start of the text.
+        newCursorPosition += a;
+
+        if (DEBUG) Log.v(TAG, "Replacing from " + a + " to " + b + " with \""
+                + text + "\", composing=" + composing
+                + ", type=" + text.getClass().getCanonicalName());
+        
+        if (DEBUG) {
+            LogPrinter lp = new LogPrinter(Log.VERBOSE, TAG);
+            lp.println("Current text:");
+            TextUtils.dumpSpans(content, lp, "  ");
+            lp.println("Composing text:");
+            TextUtils.dumpSpans(text, lp, "  ");
+        }
+        
+        content.replace(a, b, text);
+        if (newCursorPosition < 0) newCursorPosition = 0;
+        if (newCursorPosition > content.length())
+            newCursorPosition = content.length();
+        Selection.setSelection(content, newCursorPosition);
+        
+        if (DEBUG) {
+            LogPrinter lp = new LogPrinter(Log.VERBOSE, TAG);
+            lp.println("Final text:");
+            TextUtils.dumpSpans(content, lp, "  ");
+        }
+        
+        endBatchEdit();
+    }
 }