mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
1203 lines
47 KiB
Java
1203 lines
47 KiB
Java
/* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
package org.mozilla.gecko;
|
|
|
|
import org.mozilla.gecko.gfx.InputConnectionHandler;
|
|
import org.mozilla.gecko.gfx.LayerView;
|
|
import org.mozilla.gecko.util.ThreadUtils;
|
|
|
|
import android.os.Build;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.text.Editable;
|
|
import android.text.InputFilter;
|
|
import android.text.Selection;
|
|
import android.text.Spannable;
|
|
import android.text.SpannableString;
|
|
import android.text.SpannableStringBuilder;
|
|
import android.text.Spanned;
|
|
import android.text.TextPaint;
|
|
import android.text.TextUtils;
|
|
import android.text.style.CharacterStyle;
|
|
import android.util.Log;
|
|
import android.view.KeyCharacterMap;
|
|
import android.view.KeyEvent;
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationHandler;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Proxy;
|
|
import java.util.concurrent.ConcurrentLinkedQueue;
|
|
import java.util.concurrent.Semaphore;
|
|
|
|
// interface for the IC thread
|
|
interface GeckoEditableClient {
|
|
void sendEvent(GeckoEvent event);
|
|
Editable getEditable();
|
|
void setUpdateGecko(boolean update);
|
|
void setSuppressKeyUp(boolean suppress);
|
|
Handler getInputConnectionHandler();
|
|
boolean setInputConnectionHandler(Handler handler);
|
|
}
|
|
|
|
/* interface for the Editable to listen to the Gecko thread
|
|
and also for the IC thread to listen to the Editable */
|
|
interface GeckoEditableListener {
|
|
// IME notification type for notifyIME(), corresponding to NotificationToIME enum in Gecko
|
|
final int NOTIFY_IME_OPEN_VKB = -2;
|
|
final int NOTIFY_IME_REPLY_EVENT = -1;
|
|
final int NOTIFY_IME_OF_FOCUS = 1;
|
|
final int NOTIFY_IME_OF_BLUR = 2;
|
|
final int NOTIFY_IME_TO_COMMIT_COMPOSITION = 4;
|
|
final int NOTIFY_IME_TO_CANCEL_COMPOSITION = 5;
|
|
// IME enabled state for notifyIMEContext()
|
|
final int IME_STATE_DISABLED = 0;
|
|
final int IME_STATE_ENABLED = 1;
|
|
final int IME_STATE_PASSWORD = 2;
|
|
final int IME_STATE_PLUGIN = 3;
|
|
|
|
void notifyIME(int type);
|
|
void notifyIMEContext(int state, String typeHint,
|
|
String modeHint, String actionHint);
|
|
void onSelectionChange(int start, int end);
|
|
void onTextChange(String text, int start, int oldEnd, int newEnd);
|
|
}
|
|
|
|
/*
|
|
GeckoEditable implements only some functions of Editable
|
|
The field mText contains the actual underlying
|
|
SpannableStringBuilder/Editable that contains our text.
|
|
*/
|
|
final class GeckoEditable
|
|
implements InvocationHandler, Editable,
|
|
GeckoEditableClient, GeckoEditableListener {
|
|
|
|
private static final boolean DEBUG = false;
|
|
private static final String LOGTAG = "GeckoEditable";
|
|
|
|
// Filters to implement Editable's filtering functionality
|
|
private InputFilter[] mFilters;
|
|
|
|
private final SpannableStringBuilder mText;
|
|
private final SpannableStringBuilder mChangedText;
|
|
private final Editable mProxy;
|
|
private final ActionQueue mActionQueue;
|
|
|
|
// mIcRunHandler is the Handler that currently runs Gecko-to-IC Runnables
|
|
// mIcPostHandler is the Handler to post Gecko-to-IC Runnables to
|
|
// The two can be different when switching from one handler to another
|
|
private Handler mIcRunHandler;
|
|
private Handler mIcPostHandler;
|
|
|
|
private GeckoEditableListener mListener;
|
|
private int mSavedSelectionStart;
|
|
private volatile int mGeckoUpdateSeqno;
|
|
private int mIcUpdateSeqno;
|
|
private int mLastIcUpdateSeqno;
|
|
private boolean mUpdateGecko;
|
|
private boolean mFocused;
|
|
private volatile boolean mSuppressKeyUp;
|
|
|
|
/* An action that alters the Editable
|
|
|
|
Each action corresponds to a Gecko event. While the Gecko event is being sent to the Gecko
|
|
thread, the action stays on top of mActions queue. After the Gecko event is processed and
|
|
replied, the action is removed from the queue
|
|
*/
|
|
private static final class Action {
|
|
// For input events (keypress, etc.); use with IME_SYNCHRONIZE
|
|
static final int TYPE_EVENT = 0;
|
|
// For Editable.replace() call; use with IME_REPLACE_TEXT
|
|
static final int TYPE_REPLACE_TEXT = 1;
|
|
/* For Editable.setSpan(Selection...) call; use with IME_SYNCHRONIZE
|
|
Note that we don't use this with IME_SET_SELECTION because we don't want to update the
|
|
Gecko selection at the point of this action. The Gecko selection is updated only after
|
|
IC has updated its selection (during IME_SYNCHRONIZE reply) */
|
|
static final int TYPE_SET_SELECTION = 2;
|
|
// For Editable.setSpan() call; use with IME_SYNCHRONIZE
|
|
static final int TYPE_SET_SPAN = 3;
|
|
// For Editable.removeSpan() call; use with IME_SYNCHRONIZE
|
|
static final int TYPE_REMOVE_SPAN = 4;
|
|
// For focus events (in notifyIME); use with IME_ACKNOWLEDGE_FOCUS
|
|
static final int TYPE_ACKNOWLEDGE_FOCUS = 5;
|
|
// For switching handler; use with IME_SYNCHRONIZE
|
|
static final int TYPE_SET_HANDLER = 6;
|
|
|
|
final int mType;
|
|
int mStart;
|
|
int mEnd;
|
|
CharSequence mSequence;
|
|
Object mSpanObject;
|
|
int mSpanFlags;
|
|
boolean mShouldUpdate;
|
|
Handler mHandler;
|
|
|
|
Action(int type) {
|
|
mType = type;
|
|
}
|
|
|
|
static Action newReplaceText(CharSequence text, int start, int end) {
|
|
if (start < 0 || start > end) {
|
|
throw new IllegalArgumentException(
|
|
"invalid replace text offsets: " + start + " to " + end);
|
|
}
|
|
final Action action = new Action(TYPE_REPLACE_TEXT);
|
|
action.mSequence = text;
|
|
action.mStart = start;
|
|
action.mEnd = end;
|
|
return action;
|
|
}
|
|
|
|
static Action newSetSelection(int start, int end) {
|
|
// start == -1 when the start offset should remain the same
|
|
// end == -1 when the end offset should remain the same
|
|
if (start < -1 || end < -1) {
|
|
throw new IllegalArgumentException(
|
|
"invalid selection offsets: " + start + " to " + end);
|
|
}
|
|
final Action action = new Action(TYPE_SET_SELECTION);
|
|
action.mStart = start;
|
|
action.mEnd = end;
|
|
return action;
|
|
}
|
|
|
|
static Action newSetSpan(Object object, int start, int end, int flags) {
|
|
if (start < 0 || start > end) {
|
|
throw new IllegalArgumentException(
|
|
"invalid span offsets: " + start + " to " + end);
|
|
}
|
|
final Action action = new Action(TYPE_SET_SPAN);
|
|
action.mSpanObject = object;
|
|
action.mStart = start;
|
|
action.mEnd = end;
|
|
action.mSpanFlags = flags;
|
|
return action;
|
|
}
|
|
|
|
static Action newSetHandler(Handler handler) {
|
|
final Action action = new Action(TYPE_SET_HANDLER);
|
|
action.mHandler = handler;
|
|
return action;
|
|
}
|
|
}
|
|
|
|
/* Queue of editing actions sent to Gecko thread that
|
|
the Gecko thread has not responded to yet */
|
|
private final class ActionQueue {
|
|
private final ConcurrentLinkedQueue<Action> mActions;
|
|
private final Semaphore mActionsActive;
|
|
private KeyCharacterMap mKeyMap;
|
|
|
|
ActionQueue() {
|
|
mActions = new ConcurrentLinkedQueue<Action>();
|
|
mActionsActive = new Semaphore(1);
|
|
}
|
|
|
|
void offer(Action action) {
|
|
if (DEBUG) {
|
|
assertOnIcThread();
|
|
Log.d(LOGTAG, "offer: Action(" +
|
|
getConstantName(Action.class, "TYPE_", action.mType) + ")");
|
|
}
|
|
/* Events don't need update because they generate text/selection
|
|
notifications which will do the updating for us */
|
|
if (action.mType != Action.TYPE_EVENT &&
|
|
action.mType != Action.TYPE_ACKNOWLEDGE_FOCUS &&
|
|
action.mType != Action.TYPE_SET_HANDLER) {
|
|
action.mShouldUpdate = mUpdateGecko;
|
|
}
|
|
if (mActions.isEmpty()) {
|
|
mActionsActive.acquireUninterruptibly();
|
|
mActions.offer(action);
|
|
} else synchronized(this) {
|
|
// tryAcquire here in case Gecko thread has just released it
|
|
mActionsActive.tryAcquire();
|
|
mActions.offer(action);
|
|
}
|
|
switch (action.mType) {
|
|
case Action.TYPE_EVENT:
|
|
case Action.TYPE_SET_SELECTION:
|
|
case Action.TYPE_SET_SPAN:
|
|
case Action.TYPE_REMOVE_SPAN:
|
|
case Action.TYPE_SET_HANDLER:
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEEvent(
|
|
GeckoEvent.ImeAction.IME_SYNCHRONIZE));
|
|
break;
|
|
case Action.TYPE_REPLACE_TEXT:
|
|
// try key events first
|
|
sendCharKeyEvents(action);
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEReplaceEvent(
|
|
action.mStart, action.mEnd, action.mSequence.toString()));
|
|
break;
|
|
case Action.TYPE_ACKNOWLEDGE_FOCUS:
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEEvent(
|
|
GeckoEvent.ImeAction.IME_ACKNOWLEDGE_FOCUS));
|
|
break;
|
|
}
|
|
++mIcUpdateSeqno;
|
|
}
|
|
|
|
private KeyEvent [] synthesizeKeyEvents(CharSequence cs) {
|
|
try {
|
|
if (mKeyMap == null) {
|
|
mKeyMap = KeyCharacterMap.load(
|
|
Build.VERSION.SDK_INT < 11 ? KeyCharacterMap.ALPHA :
|
|
KeyCharacterMap.VIRTUAL_KEYBOARD);
|
|
}
|
|
} catch (Exception e) {
|
|
// KeyCharacterMap.UnavailableExcepton is not found on Gingerbread;
|
|
// besides, it seems like HC and ICS will throw something other than
|
|
// KeyCharacterMap.UnavailableExcepton; so use a generic Exception here
|
|
return null;
|
|
}
|
|
KeyEvent [] keyEvents = mKeyMap.getEvents(cs.toString().toCharArray());
|
|
if (keyEvents == null || keyEvents.length == 0) {
|
|
return null;
|
|
}
|
|
return keyEvents;
|
|
}
|
|
|
|
private void sendCharKeyEvents(Action action) {
|
|
if (action.mSequence.length() == 0 ||
|
|
(action.mSequence instanceof Spannable &&
|
|
((Spannable)action.mSequence).nextSpanTransition(
|
|
-1, Integer.MAX_VALUE, null) < Integer.MAX_VALUE)) {
|
|
// Spans are not preserved when we use key events,
|
|
// so we need the sequence to not have any spans
|
|
return;
|
|
}
|
|
KeyEvent [] keyEvents = synthesizeKeyEvents(action.mSequence);
|
|
if (keyEvents == null) {
|
|
return;
|
|
}
|
|
for (KeyEvent event : keyEvents) {
|
|
if (KeyEvent.isModifierKey(event.getKeyCode())) {
|
|
continue;
|
|
}
|
|
if (event.getAction() == KeyEvent.ACTION_UP && mSuppressKeyUp) {
|
|
continue;
|
|
}
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, "sending: " + event);
|
|
}
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEKeyEvent(event));
|
|
}
|
|
}
|
|
|
|
void poll() {
|
|
if (DEBUG) {
|
|
ThreadUtils.assertOnGeckoThread();
|
|
}
|
|
if (mActions.isEmpty()) {
|
|
throw new IllegalStateException("empty actions queue");
|
|
}
|
|
mActions.poll();
|
|
// Don't bother locking if queue is not empty yet
|
|
if (mActions.isEmpty()) {
|
|
synchronized(this) {
|
|
if (mActions.isEmpty()) {
|
|
mActionsActive.release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Action peek() {
|
|
if (DEBUG) {
|
|
ThreadUtils.assertOnGeckoThread();
|
|
}
|
|
if (mActions.isEmpty()) {
|
|
throw new IllegalStateException("empty actions queue");
|
|
}
|
|
return mActions.peek();
|
|
}
|
|
|
|
void syncWithGecko() {
|
|
if (DEBUG) {
|
|
assertOnIcThread();
|
|
}
|
|
if (mFocused && !mActions.isEmpty()) {
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, "syncWithGecko blocking on thread " +
|
|
Thread.currentThread().getName());
|
|
}
|
|
mActionsActive.acquireUninterruptibly();
|
|
mActionsActive.release();
|
|
} else if (DEBUG && !mFocused) {
|
|
Log.d(LOGTAG, "skipped syncWithGecko (no focus)");
|
|
}
|
|
}
|
|
|
|
boolean isEmpty() {
|
|
return mActions.isEmpty();
|
|
}
|
|
}
|
|
|
|
GeckoEditable() {
|
|
mActionQueue = new ActionQueue();
|
|
mSavedSelectionStart = -1;
|
|
mUpdateGecko = true;
|
|
|
|
mText = new SpannableStringBuilder();
|
|
mChangedText = new SpannableStringBuilder();
|
|
|
|
final Class<?>[] PROXY_INTERFACES = { Editable.class };
|
|
mProxy = (Editable)Proxy.newProxyInstance(
|
|
Editable.class.getClassLoader(),
|
|
PROXY_INTERFACES, this);
|
|
|
|
LayerView v = GeckoAppShell.getLayerView();
|
|
mListener = GeckoInputConnection.create(v, this);
|
|
|
|
mIcRunHandler = mIcPostHandler = ThreadUtils.getUiHandler();
|
|
}
|
|
|
|
private boolean onIcThread() {
|
|
return mIcRunHandler.getLooper() == Looper.myLooper();
|
|
}
|
|
|
|
private void assertOnIcThread() {
|
|
ThreadUtils.assertOnThread(mIcRunHandler.getLooper().getThread());
|
|
}
|
|
|
|
private void geckoPostToIc(Runnable runnable) {
|
|
mIcPostHandler.post(runnable);
|
|
}
|
|
|
|
private void geckoUpdateGecko(final boolean force) {
|
|
/* We do not increment the seqno here, but only check it, because geckoUpdateGecko is a
|
|
request for update. If we incremented the seqno here, geckoUpdateGecko would have
|
|
prevented other updates from occurring */
|
|
final int seqnoWhenPosted = mGeckoUpdateSeqno;
|
|
|
|
geckoPostToIc(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mActionQueue.syncWithGecko();
|
|
if (seqnoWhenPosted == mGeckoUpdateSeqno) {
|
|
icUpdateGecko(force);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private Object getField(Object obj, String field, Object def) {
|
|
try {
|
|
return obj.getClass().getField(field).get(obj);
|
|
} catch (Exception e) {
|
|
return def;
|
|
}
|
|
}
|
|
|
|
private void icUpdateGecko(boolean force) {
|
|
|
|
if (!force && mIcUpdateSeqno == mLastIcUpdateSeqno) {
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, "icUpdateGecko() skipped");
|
|
}
|
|
return;
|
|
}
|
|
mLastIcUpdateSeqno = mIcUpdateSeqno;
|
|
mActionQueue.syncWithGecko();
|
|
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, "icUpdateGecko()");
|
|
}
|
|
|
|
final int selStart = mText.getSpanStart(Selection.SELECTION_START);
|
|
final int selEnd = mText.getSpanEnd(Selection.SELECTION_END);
|
|
int composingStart = mText.length();
|
|
int composingEnd = 0;
|
|
Object[] spans = mText.getSpans(0, composingStart, Object.class);
|
|
|
|
for (Object span : spans) {
|
|
if ((mText.getSpanFlags(span) & Spanned.SPAN_COMPOSING) != 0) {
|
|
composingStart = Math.min(composingStart, mText.getSpanStart(span));
|
|
composingEnd = Math.max(composingEnd, mText.getSpanEnd(span));
|
|
}
|
|
}
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, " range = " + composingStart + "-" + composingEnd);
|
|
Log.d(LOGTAG, " selection = " + selStart + "-" + selEnd);
|
|
}
|
|
if (composingStart >= composingEnd) {
|
|
if (selStart >= 0 && selEnd >= 0) {
|
|
GeckoAppShell.sendEventToGecko(
|
|
GeckoEvent.createIMESelectEvent(selStart, selEnd));
|
|
} else {
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEEvent(
|
|
GeckoEvent.ImeAction.IME_REMOVE_COMPOSITION));
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (selEnd >= composingStart && selEnd <= composingEnd) {
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMERangeEvent(
|
|
selEnd - composingStart, selEnd - composingStart,
|
|
GeckoEvent.IME_RANGE_CARETPOSITION, 0, 0, false, 0, 0, 0));
|
|
}
|
|
int rangeStart = composingStart;
|
|
TextPaint tp = new TextPaint();
|
|
TextPaint emptyTp = new TextPaint();
|
|
// set initial foreground color to 0, because we check for tp.getColor() == 0
|
|
// below to decide whether to pass a foreground color to Gecko
|
|
emptyTp.setColor(0);
|
|
do {
|
|
int rangeType, rangeStyles = 0, rangeLineStyle = GeckoEvent.IME_RANGE_LINE_NONE;
|
|
boolean rangeBoldLine = false;
|
|
int rangeForeColor = 0, rangeBackColor = 0, rangeLineColor = 0;
|
|
int rangeEnd = mText.nextSpanTransition(rangeStart, composingEnd, Object.class);
|
|
|
|
if (selStart > rangeStart && selStart < rangeEnd) {
|
|
rangeEnd = selStart;
|
|
} else if (selEnd > rangeStart && selEnd < rangeEnd) {
|
|
rangeEnd = selEnd;
|
|
}
|
|
CharacterStyle[] styleSpans =
|
|
mText.getSpans(rangeStart, rangeEnd, CharacterStyle.class);
|
|
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, " found " + styleSpans.length + " spans @ " +
|
|
rangeStart + "-" + rangeEnd);
|
|
}
|
|
|
|
if (styleSpans.length == 0) {
|
|
rangeType = (selStart == rangeStart && selEnd == rangeEnd)
|
|
? GeckoEvent.IME_RANGE_SELECTEDRAWTEXT
|
|
: GeckoEvent.IME_RANGE_RAWINPUT;
|
|
} else {
|
|
rangeType = (selStart == rangeStart && selEnd == rangeEnd)
|
|
? GeckoEvent.IME_RANGE_SELECTEDCONVERTEDTEXT
|
|
: GeckoEvent.IME_RANGE_CONVERTEDTEXT;
|
|
tp.set(emptyTp);
|
|
for (CharacterStyle span : styleSpans) {
|
|
span.updateDrawState(tp);
|
|
}
|
|
int tpUnderlineColor = 0;
|
|
float tpUnderlineThickness = 0.0f;
|
|
// These TextPaint fields only exist on Android ICS+ and are not in the SDK
|
|
if (Build.VERSION.SDK_INT >= 14) {
|
|
tpUnderlineColor = (Integer)getField(tp, "underlineColor", 0);
|
|
tpUnderlineThickness = (Float)getField(tp, "underlineThickness", 0.0f);
|
|
}
|
|
if (tpUnderlineColor != 0) {
|
|
rangeStyles |= GeckoEvent.IME_RANGE_UNDERLINE | GeckoEvent.IME_RANGE_LINECOLOR;
|
|
rangeLineColor = tpUnderlineColor;
|
|
// Approximately translate underline thickness to what Gecko understands
|
|
if (tpUnderlineThickness <= 0.5f) {
|
|
rangeLineStyle = GeckoEvent.IME_RANGE_LINE_DOTTED;
|
|
} else {
|
|
rangeLineStyle = GeckoEvent.IME_RANGE_LINE_SOLID;
|
|
if (tpUnderlineThickness >= 2.0f) {
|
|
rangeBoldLine = true;
|
|
}
|
|
}
|
|
} else if (tp.isUnderlineText()) {
|
|
rangeStyles |= GeckoEvent.IME_RANGE_UNDERLINE;
|
|
rangeLineStyle = GeckoEvent.IME_RANGE_LINE_SOLID;
|
|
}
|
|
if (tp.getColor() != 0) {
|
|
rangeStyles |= GeckoEvent.IME_RANGE_FORECOLOR;
|
|
rangeForeColor = tp.getColor();
|
|
}
|
|
if (tp.bgColor != 0) {
|
|
rangeStyles |= GeckoEvent.IME_RANGE_BACKCOLOR;
|
|
rangeBackColor = tp.bgColor;
|
|
}
|
|
}
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMERangeEvent(
|
|
rangeStart - composingStart, rangeEnd - composingStart,
|
|
rangeType, rangeStyles, rangeLineStyle, rangeBoldLine,
|
|
rangeForeColor, rangeBackColor, rangeLineColor));
|
|
rangeStart = rangeEnd;
|
|
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, " added " + rangeType +
|
|
" : " + Integer.toHexString(rangeStyles) +
|
|
" : " + Integer.toHexString(rangeForeColor) +
|
|
" : " + Integer.toHexString(rangeBackColor));
|
|
}
|
|
} while (rangeStart < composingEnd);
|
|
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createIMECompositionEvent(
|
|
composingStart, composingEnd));
|
|
}
|
|
|
|
// GeckoEditableClient interface
|
|
|
|
@Override
|
|
public void sendEvent(final GeckoEvent event) {
|
|
if (DEBUG) {
|
|
assertOnIcThread();
|
|
Log.d(LOGTAG, "sendEvent(" + event + ")");
|
|
}
|
|
/*
|
|
We are actually sending two events to Gecko here,
|
|
1. Event from the event parameter (key event, etc.)
|
|
2. Sync event from the mActionQueue.offer call
|
|
The first event is a normal GeckoEvent that does not reply back to us,
|
|
the second sync event will have a reply, during which we see that there is a pending
|
|
event-type action, and update the selection/composition/etc. accordingly.
|
|
*/
|
|
GeckoAppShell.sendEventToGecko(event);
|
|
mActionQueue.offer(new Action(Action.TYPE_EVENT));
|
|
}
|
|
|
|
@Override
|
|
public Editable getEditable() {
|
|
if (!onIcThread()) {
|
|
// Android may be holding an old InputConnection; ignore
|
|
if (DEBUG) {
|
|
Log.i(LOGTAG, "getEditable() called on non-IC thread");
|
|
}
|
|
return null;
|
|
}
|
|
return mProxy;
|
|
}
|
|
|
|
@Override
|
|
public void setUpdateGecko(boolean update) {
|
|
if (!onIcThread()) {
|
|
// Android may be holding an old InputConnection; ignore
|
|
if (DEBUG) {
|
|
Log.i(LOGTAG, "setUpdateGecko() called on non-IC thread");
|
|
}
|
|
return;
|
|
}
|
|
if (update) {
|
|
icUpdateGecko(false);
|
|
}
|
|
mUpdateGecko = update;
|
|
}
|
|
|
|
@Override
|
|
public void setSuppressKeyUp(boolean suppress) {
|
|
if (DEBUG) {
|
|
// only used by key event handler
|
|
ThreadUtils.assertOnUiThread();
|
|
}
|
|
// Suppress key up event generated as a result of
|
|
// translating characters to key events
|
|
mSuppressKeyUp = suppress;
|
|
}
|
|
|
|
@Override
|
|
public Handler getInputConnectionHandler() {
|
|
// Can be called from either UI thread or IC thread;
|
|
// care must be taken to avoid race conditions
|
|
return mIcRunHandler;
|
|
}
|
|
|
|
@Override
|
|
public boolean setInputConnectionHandler(Handler handler) {
|
|
if (handler == mIcPostHandler) {
|
|
return true;
|
|
}
|
|
if (!mFocused) {
|
|
return false;
|
|
}
|
|
if (DEBUG) {
|
|
assertOnIcThread();
|
|
}
|
|
// There are three threads at this point: Gecko thread, old IC thread, and new IC
|
|
// thread, and we want to safely switch from old IC thread to new IC thread.
|
|
// We first send a TYPE_SET_HANDLER action to the Gecko thread; this ensures that
|
|
// the Gecko thread is stopped at a known point. At the same time, the old IC
|
|
// thread blocks on the action; this ensures that the old IC thread is stopped at
|
|
// a known point. Finally, inside the Gecko thread, we post a Runnable to the old
|
|
// IC thread; this Runnable switches from old IC thread to new IC thread. We
|
|
// switch IC thread on the old IC thread to ensure any pending Runnables on the
|
|
// old IC thread are processed before we switch over. Inside the Gecko thread, we
|
|
// also post a Runnable to the new IC thread; this Runnable blocks until the
|
|
// switch is complete; this ensures that the new IC thread won't accept
|
|
// InputConnection calls until after the switch.
|
|
mActionQueue.offer(Action.newSetHandler(handler));
|
|
mActionQueue.syncWithGecko();
|
|
return true;
|
|
}
|
|
|
|
private void geckoSetIcHandler(final Handler newHandler) {
|
|
geckoPostToIc(new Runnable() { // posting to old IC thread
|
|
@Override
|
|
public void run() {
|
|
synchronized (newHandler) {
|
|
mIcRunHandler = newHandler;
|
|
newHandler.notify();
|
|
}
|
|
}
|
|
});
|
|
|
|
// At this point, all future Runnables should be posted to the new IC thread, but
|
|
// we don't switch mIcRunHandler yet because there may be pending Runnables on the
|
|
// old IC thread still waiting to run.
|
|
mIcPostHandler = newHandler;
|
|
|
|
geckoPostToIc(new Runnable() { // posting to new IC thread
|
|
@Override
|
|
public void run() {
|
|
synchronized (newHandler) {
|
|
while (mIcRunHandler != newHandler) {
|
|
try {
|
|
newHandler.wait();
|
|
} catch (InterruptedException e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// GeckoEditableListener interface
|
|
|
|
private void geckoActionReply() {
|
|
if (DEBUG) {
|
|
// GeckoEditableListener methods should all be called from the Gecko thread
|
|
ThreadUtils.assertOnGeckoThread();
|
|
}
|
|
final Action action = mActionQueue.peek();
|
|
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, "reply: Action(" +
|
|
getConstantName(Action.class, "TYPE_", action.mType) + ")");
|
|
}
|
|
switch (action.mType) {
|
|
case Action.TYPE_SET_SELECTION:
|
|
final int len = mText.length();
|
|
final int curStart = Selection.getSelectionStart(mText);
|
|
final int curEnd = Selection.getSelectionEnd(mText);
|
|
// start == -1 when the start offset should remain the same
|
|
// end == -1 when the end offset should remain the same
|
|
final int selStart = Math.min(action.mStart < 0 ? curStart : action.mStart, len);
|
|
final int selEnd = Math.min(action.mEnd < 0 ? curEnd : action.mEnd, len);
|
|
|
|
if (selStart < action.mStart || selEnd < action.mEnd) {
|
|
Log.w(LOGTAG, "IME sync error: selection out of bounds");
|
|
}
|
|
Selection.setSelection(mText, selStart, selEnd);
|
|
geckoPostToIc(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mActionQueue.syncWithGecko();
|
|
final int start = Selection.getSelectionStart(mText);
|
|
final int end = Selection.getSelectionEnd(mText);
|
|
if (selStart == start && selEnd == end) {
|
|
// There has not been another new selection in the mean time that
|
|
// made this notification out-of-date
|
|
mListener.onSelectionChange(start, end);
|
|
}
|
|
}
|
|
});
|
|
break;
|
|
case Action.TYPE_SET_SPAN:
|
|
mText.setSpan(action.mSpanObject, action.mStart, action.mEnd, action.mSpanFlags);
|
|
break;
|
|
case Action.TYPE_SET_HANDLER:
|
|
geckoSetIcHandler(action.mHandler);
|
|
break;
|
|
}
|
|
if (action.mShouldUpdate) {
|
|
geckoUpdateGecko(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void notifyIME(final int type) {
|
|
if (DEBUG) {
|
|
// GeckoEditableListener methods should all be called from the Gecko thread
|
|
ThreadUtils.assertOnGeckoThread();
|
|
// NOTIFY_IME_REPLY_EVENT is logged separately, inside geckoActionReply()
|
|
if (type != NOTIFY_IME_REPLY_EVENT) {
|
|
Log.d(LOGTAG, "notifyIME(" +
|
|
getConstantName(GeckoEditableListener.class, "NOTIFY_IME_", type) +
|
|
")");
|
|
}
|
|
}
|
|
if (type == NOTIFY_IME_REPLY_EVENT) {
|
|
try {
|
|
if (mFocused) {
|
|
// When mFocused is false, the reply is for a stale action,
|
|
// and we should not do anything
|
|
geckoActionReply();
|
|
} else if (DEBUG) {
|
|
Log.d(LOGTAG, "discarding stale reply");
|
|
}
|
|
} finally {
|
|
// Ensure action is always removed from queue
|
|
// even if stale action results in exception in geckoActionReply
|
|
mActionQueue.poll();
|
|
}
|
|
return;
|
|
}
|
|
geckoPostToIc(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (type == NOTIFY_IME_OF_BLUR) {
|
|
mFocused = false;
|
|
} else if (type == NOTIFY_IME_OF_FOCUS) {
|
|
mFocused = true;
|
|
// Unmask events on the Gecko side
|
|
mActionQueue.offer(new Action(Action.TYPE_ACKNOWLEDGE_FOCUS));
|
|
}
|
|
// Make sure there are no other things going on. If we sent
|
|
// GeckoEvent.IME_ACKNOWLEDGE_FOCUS, this line also makes us
|
|
// wait for Gecko to update us on the newly focused content
|
|
mActionQueue.syncWithGecko();
|
|
mListener.notifyIME(type);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void notifyIMEContext(final int state, final String typeHint,
|
|
final String modeHint, final String actionHint) {
|
|
// Because we want to be able to bind GeckoEditable to the newest LayerView instance,
|
|
// this can be called from the Java IC thread in addition to the Gecko thread.
|
|
if (DEBUG) {
|
|
Log.d(LOGTAG, "notifyIMEContext(" +
|
|
getConstantName(GeckoEditableListener.class, "IME_STATE_", state) +
|
|
", \"" + typeHint + "\", \"" + modeHint + "\", \"" + actionHint + "\")");
|
|
}
|
|
geckoPostToIc(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
// Make sure there are no other things going on
|
|
mActionQueue.syncWithGecko();
|
|
// Set InputConnectionHandler in notifyIMEContext because
|
|
// GeckoInputConnection.notifyIMEContext calls restartInput() which will invoke
|
|
// InputConnectionHandler.onCreateInputConnection
|
|
LayerView v = GeckoAppShell.getLayerView();
|
|
if (v != null) {
|
|
mListener = GeckoInputConnection.create(v, GeckoEditable.this);
|
|
v.setInputConnectionHandler((InputConnectionHandler)mListener);
|
|
mListener.notifyIMEContext(state, typeHint, modeHint, actionHint);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void onSelectionChange(final int start, final int end) {
|
|
if (DEBUG) {
|
|
// GeckoEditableListener methods should all be called from the Gecko thread
|
|
ThreadUtils.assertOnGeckoThread();
|
|
Log.d(LOGTAG, "onSelectionChange(" + start + ", " + end + ")");
|
|
}
|
|
if (start < 0 || start > mText.length() || end < 0 || end > mText.length()) {
|
|
throw new IllegalArgumentException("invalid selection notification range: " +
|
|
start + " to " + end + ", length: " + mText.length());
|
|
}
|
|
final int seqnoWhenPosted = ++mGeckoUpdateSeqno;
|
|
|
|
/* An event (keypress, etc.) has potentially changed the selection,
|
|
synchronize the selection here. There is not a race with the IC thread
|
|
because the IC thread should be blocked on the event action */
|
|
if (!mActionQueue.isEmpty() &&
|
|
mActionQueue.peek().mType == Action.TYPE_EVENT) {
|
|
Selection.setSelection(mText, start, end);
|
|
return;
|
|
}
|
|
|
|
geckoPostToIc(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mActionQueue.syncWithGecko();
|
|
/* check to see there has not been another action that potentially changed the
|
|
selection. If so, we can skip this update because we know there is another
|
|
update right after this one that will replace the effect of this update */
|
|
if (mGeckoUpdateSeqno == seqnoWhenPosted) {
|
|
/* In this case, Gecko's selection has changed and it's notifying us to change
|
|
Java's selection. In the normal case, whenever Java's selection changes,
|
|
we go back and set Gecko's selection as well. However, in this case,
|
|
since Gecko's selection is already up-to-date, we skip this step. */
|
|
boolean oldUpdateGecko = mUpdateGecko;
|
|
mUpdateGecko = false;
|
|
Selection.setSelection(mProxy, start, end);
|
|
mUpdateGecko = oldUpdateGecko;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private void geckoReplaceText(int start, int oldEnd, CharSequence newText) {
|
|
// Don't use replace() because Gingerbread has a bug where if the replaced text
|
|
// has the same spans as the original text, the spans will end up being deleted
|
|
mText.delete(start, oldEnd);
|
|
mText.insert(start, newText);
|
|
}
|
|
|
|
@Override
|
|
public void onTextChange(final String text, final int start,
|
|
final int unboundedOldEnd, final int unboundedNewEnd) {
|
|
if (DEBUG) {
|
|
// GeckoEditableListener methods should all be called from the Gecko thread
|
|
ThreadUtils.assertOnGeckoThread();
|
|
StringBuilder sb = new StringBuilder("onTextChange(");
|
|
debugAppend(sb, text);
|
|
sb.append(", ").append(start).append(", ")
|
|
.append(unboundedOldEnd).append(", ")
|
|
.append(unboundedNewEnd).append(")");
|
|
Log.d(LOGTAG, sb.toString());
|
|
}
|
|
if (start < 0 || start > unboundedOldEnd) {
|
|
throw new IllegalArgumentException("invalid text notification range: " +
|
|
start + " to " + unboundedOldEnd);
|
|
}
|
|
/* For the "end" parameters, Gecko can pass in a large
|
|
number to denote "end of the text". Fix that here */
|
|
final int oldEnd = unboundedOldEnd > mText.length() ? mText.length() : unboundedOldEnd;
|
|
// new end should always match text
|
|
if (start != 0 && unboundedNewEnd != (start + text.length())) {
|
|
throw new IllegalArgumentException("newEnd does not match text: " +
|
|
unboundedNewEnd + " vs " + (start + text.length()));
|
|
}
|
|
final int newEnd = start + text.length();
|
|
|
|
/* Text changes affect the selection as well, and we may not receive another selection
|
|
update as a result of selection notification masking on the Gecko side; therefore,
|
|
in order to prevent previous stale selection notifications from occurring, we need
|
|
to increment the seqno here as well */
|
|
++mGeckoUpdateSeqno;
|
|
|
|
mChangedText.clearSpans();
|
|
mChangedText.replace(0, mChangedText.length(), text);
|
|
// Preserve as many spans as possible
|
|
TextUtils.copySpansFrom(mText, start, Math.min(oldEnd, newEnd),
|
|
Object.class, mChangedText, 0);
|
|
|
|
if (!mActionQueue.isEmpty()) {
|
|
final Action action = mActionQueue.peek();
|
|
if (action.mType == Action.TYPE_REPLACE_TEXT &&
|
|
start <= action.mStart &&
|
|
action.mStart + action.mSequence.length() <= newEnd) {
|
|
|
|
// actionNewEnd is the new end of the original replacement action
|
|
final int actionNewEnd = action.mStart + action.mSequence.length();
|
|
int selStart = Selection.getSelectionStart(mText);
|
|
int selEnd = Selection.getSelectionEnd(mText);
|
|
|
|
// Replace old spans with new spans
|
|
mChangedText.replace(action.mStart - start, actionNewEnd - start,
|
|
action.mSequence);
|
|
geckoReplaceText(start, oldEnd, mChangedText);
|
|
|
|
// delete/insert above might have moved our selection to somewhere else
|
|
// this happens when the Gecko text change covers a larger range than
|
|
// the original replacement action. Fix selection here
|
|
if (selStart >= start && selStart <= oldEnd) {
|
|
selStart = selStart < action.mStart ? selStart :
|
|
selStart < action.mEnd ? actionNewEnd :
|
|
selStart + actionNewEnd - action.mEnd;
|
|
mText.setSpan(Selection.SELECTION_START, selStart, selStart,
|
|
Spanned.SPAN_POINT_POINT);
|
|
}
|
|
if (selEnd >= start && selEnd <= oldEnd) {
|
|
selEnd = selEnd < action.mStart ? selEnd :
|
|
selEnd < action.mEnd ? actionNewEnd :
|
|
selEnd + actionNewEnd - action.mEnd;
|
|
mText.setSpan(Selection.SELECTION_END, selEnd, selEnd,
|
|
Spanned.SPAN_POINT_POINT);
|
|
}
|
|
} else {
|
|
geckoReplaceText(start, oldEnd, mChangedText);
|
|
}
|
|
} else {
|
|
geckoReplaceText(start, oldEnd, mChangedText);
|
|
}
|
|
geckoPostToIc(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mListener.onTextChange(text, start, oldEnd, newEnd);
|
|
}
|
|
});
|
|
}
|
|
|
|
// InvocationHandler interface
|
|
|
|
static String getConstantName(Class<?> cls, String prefix, Object value) {
|
|
for (Field fld : cls.getDeclaredFields()) {
|
|
try {
|
|
if (fld.getName().startsWith(prefix) &&
|
|
fld.get(null).equals(value)) {
|
|
return fld.getName();
|
|
}
|
|
} catch (IllegalAccessException e) {
|
|
}
|
|
}
|
|
return String.valueOf(value);
|
|
}
|
|
|
|
static StringBuilder debugAppend(StringBuilder sb, Object obj) {
|
|
if (obj == null) {
|
|
sb.append("null");
|
|
} else if (obj instanceof GeckoEditable) {
|
|
sb.append("GeckoEditable");
|
|
} else if (Proxy.isProxyClass(obj.getClass())) {
|
|
debugAppend(sb, Proxy.getInvocationHandler(obj));
|
|
} else if (obj instanceof CharSequence) {
|
|
sb.append("\"").append(obj.toString().replace('\n', '\u21b2')).append("\"");
|
|
} else if (obj.getClass().isArray()) {
|
|
sb.append(obj.getClass().getComponentType().getSimpleName()).append("[")
|
|
.append(java.lang.reflect.Array.getLength(obj)).append("]");
|
|
} else {
|
|
sb.append(obj.toString());
|
|
}
|
|
return sb;
|
|
}
|
|
|
|
@Override
|
|
public Object invoke(Object proxy, Method method, Object[] args)
|
|
throws Throwable {
|
|
Object target;
|
|
final Class<?> methodInterface = method.getDeclaringClass();
|
|
if (DEBUG) {
|
|
// Editable methods should all be called from the IC thread
|
|
assertOnIcThread();
|
|
}
|
|
if (methodInterface == Editable.class ||
|
|
methodInterface == Appendable.class ||
|
|
methodInterface == Spannable.class) {
|
|
// Method alters the Editable; route calls to our implementation
|
|
target = this;
|
|
} else {
|
|
// Method queries the Editable; must sync with Gecko first
|
|
// then call on the inner Editable itself
|
|
mActionQueue.syncWithGecko();
|
|
target = mText;
|
|
}
|
|
Object ret;
|
|
try {
|
|
ret = method.invoke(target, args);
|
|
} catch (InvocationTargetException e) {
|
|
// Bug 817386
|
|
// Most likely Gecko has changed the text while GeckoInputConnection is
|
|
// trying to access the text. If we pass through the exception here, Fennec
|
|
// will crash due to a lack of exception handler. Log the exception and
|
|
// return an empty value instead.
|
|
if (!(e.getCause() instanceof IndexOutOfBoundsException)) {
|
|
// Only handle IndexOutOfBoundsException for now,
|
|
// as other exceptions might signal other bugs
|
|
throw e;
|
|
}
|
|
Log.w(LOGTAG, "Exception in GeckoEditable." + method.getName(), e.getCause());
|
|
Class<?> retClass = method.getReturnType();
|
|
if (retClass == Character.TYPE) {
|
|
ret = '\0';
|
|
} else if (retClass == Integer.TYPE) {
|
|
ret = 0;
|
|
} else if (retClass == String.class) {
|
|
ret = "";
|
|
} else {
|
|
ret = null;
|
|
}
|
|
}
|
|
if (DEBUG) {
|
|
StringBuilder log = new StringBuilder(method.getName());
|
|
log.append("(");
|
|
for (Object arg : args) {
|
|
debugAppend(log, arg).append(", ");
|
|
}
|
|
if (args.length > 0) {
|
|
log.setLength(log.length() - 2);
|
|
}
|
|
if (method.getReturnType().equals(Void.TYPE)) {
|
|
log.append(")");
|
|
} else {
|
|
debugAppend(log.append(") = "), ret);
|
|
}
|
|
Log.d(LOGTAG, log.toString());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Spannable interface
|
|
|
|
@Override
|
|
public void removeSpan(Object what) {
|
|
if (what == Selection.SELECTION_START ||
|
|
what == Selection.SELECTION_END) {
|
|
Log.w(LOGTAG, "selection removed with removeSpan()");
|
|
}
|
|
if (mText.getSpanStart(what) >= 0) { // only remove if it's there
|
|
// Okay to remove immediately
|
|
mText.removeSpan(what);
|
|
mActionQueue.offer(new Action(Action.TYPE_REMOVE_SPAN));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setSpan(Object what, int start, int end, int flags) {
|
|
if (what == Selection.SELECTION_START) {
|
|
if ((flags & Spanned.SPAN_INTERMEDIATE) != 0) {
|
|
// We will get the end offset next, just save the start for now
|
|
mSavedSelectionStart = start;
|
|
} else {
|
|
mActionQueue.offer(Action.newSetSelection(start, -1));
|
|
}
|
|
} else if (what == Selection.SELECTION_END) {
|
|
mActionQueue.offer(Action.newSetSelection(mSavedSelectionStart, end));
|
|
mSavedSelectionStart = -1;
|
|
} else {
|
|
mActionQueue.offer(Action.newSetSpan(what, start, end, flags));
|
|
}
|
|
}
|
|
|
|
// Appendable interface
|
|
|
|
@Override
|
|
public Editable append(CharSequence text) {
|
|
return replace(mProxy.length(), mProxy.length(), text, 0, text.length());
|
|
}
|
|
|
|
@Override
|
|
public Editable append(CharSequence text, int start, int end) {
|
|
return replace(mProxy.length(), mProxy.length(), text, start, end);
|
|
}
|
|
|
|
@Override
|
|
public Editable append(char text) {
|
|
return replace(mProxy.length(), mProxy.length(), String.valueOf(text), 0, 1);
|
|
}
|
|
|
|
// Editable interface
|
|
|
|
@Override
|
|
public InputFilter[] getFilters() {
|
|
return mFilters;
|
|
}
|
|
|
|
@Override
|
|
public void setFilters(InputFilter[] filters) {
|
|
mFilters = filters;
|
|
}
|
|
|
|
@Override
|
|
public void clearSpans() {
|
|
/* XXX this clears the selection spans too,
|
|
but there is no way to clear the corresponding selection in Gecko */
|
|
Log.w(LOGTAG, "selection cleared with clearSpans()");
|
|
mText.clearSpans();
|
|
}
|
|
|
|
@Override
|
|
public Editable replace(int st, int en,
|
|
CharSequence source, int start, int end) {
|
|
|
|
CharSequence text = source;
|
|
if (start < 0 || start > end || end > text.length()) {
|
|
throw new IllegalArgumentException("invalid replace offsets: " +
|
|
start + " to " + end + ", length: " + text.length());
|
|
}
|
|
if (start != 0 || end != text.length()) {
|
|
text = text.subSequence(start, end);
|
|
}
|
|
if (mFilters != null) {
|
|
// Filter text before sending the request to Gecko
|
|
for (int i = 0; i < mFilters.length; ++i) {
|
|
final CharSequence cs = mFilters[i].filter(
|
|
text, 0, text.length(), mProxy, st, en);
|
|
if (cs != null) {
|
|
text = cs;
|
|
}
|
|
}
|
|
}
|
|
if (text == source) {
|
|
// Always create a copy
|
|
text = new SpannableString(source);
|
|
}
|
|
mActionQueue.offer(Action.newReplaceText(text,
|
|
Math.min(st, en), Math.max(st, en)));
|
|
return mProxy;
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
replace(0, mProxy.length(), "", 0, 0);
|
|
}
|
|
|
|
@Override
|
|
public Editable delete(int st, int en) {
|
|
return replace(st, en, "", 0, 0);
|
|
}
|
|
|
|
@Override
|
|
public Editable insert(int where, CharSequence text,
|
|
int start, int end) {
|
|
return replace(where, where, text, start, end);
|
|
}
|
|
|
|
@Override
|
|
public Editable insert(int where, CharSequence text) {
|
|
return replace(where, where, text, 0, text.length());
|
|
}
|
|
|
|
@Override
|
|
public Editable replace(int st, int en, CharSequence text) {
|
|
return replace(st, en, text, 0, text.length());
|
|
}
|
|
|
|
/* GetChars interface */
|
|
|
|
@Override
|
|
public void getChars(int start, int end, char[] dest, int destoff) {
|
|
/* overridden Editable interface methods in GeckoEditable must not be called directly
|
|
outside of GeckoEditable. Instead, the call must go through mProxy, which ensures
|
|
that Java is properly synchronized with Gecko */
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
/* Spanned interface */
|
|
|
|
@Override
|
|
public int getSpanEnd(Object tag) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
public int getSpanFlags(Object tag) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
public int getSpanStart(Object tag) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
public <T> T[] getSpans(int start, int end, Class<T> type) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings("rawtypes") // nextSpanTransition uses raw Class in its Android declaration
|
|
public int nextSpanTransition(int start, int limit, Class type) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
/* CharSequence interface */
|
|
|
|
@Override
|
|
public char charAt(int index) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
public int length() {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
public CharSequence subSequence(int start, int end) {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
throw new UnsupportedOperationException("method must be called through mProxy");
|
|
}
|
|
}
|
|
|