diff --git a/Android.mk b/Android.mk index 45f0f18cfe896..8da1cfc6e7cb2 100644 --- a/Android.mk +++ b/Android.mk @@ -100,6 +100,7 @@ LOCAL_SRC_FILES += \ core/java/com/android/internal/app/IUsageStats.aidl \ core/java/com/android/internal/gadget/IGadgetService.aidl \ core/java/com/android/internal/gadget/IGadgetHost.aidl \ + core/java/com/android/internal/os/IResultReceiver.aidl \ core/java/com/android/internal/view/IInputContext.aidl \ core/java/com/android/internal/view/IInputContextCallback.aidl \ core/java/com/android/internal/view/IInputMethod.aidl \ diff --git a/api/current.xml b/api/current.xml index 25295cad06422..6999a43ee3c4d 100644 --- a/api/current.xml +++ b/api/current.xml @@ -58576,19 +58576,6 @@ visibility="public" > - - - - + + + + + + + + + + + + + + + + - - - - - - - - + + + + + + + + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -138532,6 +138908,21 @@ visibility="public" > + + + + + + @@ -155451,6 +155842,17 @@ + + - - handler if given, or from an arbitrary thread if null. + */ + public ResultReceiver(Handler handler) { + mLocal = true; + mHandler = handler; + } + + /** + * Deliver a result to this receiver. Will call {@link #onReceiveResult}, + * always asynchronously if the receiver has supplied a Handler in which + * to dispatch the result. + * @param resultCode Arbitrary result code to deliver, as defined by you. + * @param resultData Any additional data provided by you. + */ + public void send(int resultCode, Bundle resultData) { + if (mLocal) { + if (mHandler != null) { + mHandler.post(new MyRunnable(resultCode, resultData)); + } else { + onReceiveResult(resultCode, resultData); + } + return; + } + + if (mReceiver != null) { + try { + mReceiver.send(resultCode, resultData); + } catch (RemoteException e) { + } + } + } + + /** + * Override to receive results delivered to this object. + * + * @param resultCode Arbitrary result code delivered by the sender, as + * defined by the sender. + * @param resultData Any additional data provided by the sender. + */ + protected void onReceiveResult(int resultCode, Bundle resultData) { + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel out, int flags) { + synchronized (this) { + if (mReceiver == null) { + mReceiver = new MyResultReceiver(); + } + out.writeStrongBinder(mReceiver.asBinder()); + } + } + + ResultReceiver(Parcel in) { + mLocal = false; + mHandler = null; + mReceiver = IResultReceiver.Stub.asInterface(in.readStrongBinder()); + } + + public static final Parcelable.Creator CREATOR + = new Parcelable.Creator() { + public ResultReceiver createFromParcel(Parcel in) { + return new ResultReceiver(in); + } + public ResultReceiver[] newArray(int size) { + return new ResultReceiver[size]; + } + }; +} diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java index b536b0d07b684..b0ee479fcddbe 100644 --- a/core/java/android/provider/Settings.java +++ b/core/java/android/provider/Settings.java @@ -2825,6 +2825,11 @@ public final class Settings { public static final String BATTERY_DISCHARGE_DURATION_THRESHOLD = "battery_discharge_duration_threshold"; public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold"; + + /** + * An email address that anr bugreports should be sent to. + */ + public static final String ANR_BUGREPORT_RECIPIENT = "anr_bugreport_recipient"; /** * @deprecated diff --git a/core/java/android/provider/Telephony.java b/core/java/android/provider/Telephony.java index 18c64ed182030..d802c14dfcab3 100644 --- a/core/java/android/provider/Telephony.java +++ b/core/java/android/provider/Telephony.java @@ -1023,6 +1023,11 @@ public final class Telephony { *

Type: INTEGER

*/ public static final String ERROR = "error"; + /** + * Indicates whether this thread contains any attachments. + *

Type: INTEGER

+ */ + public static final String HAS_ATTACHMENT = "has_attachment"; } /** diff --git a/core/java/android/text/InputType.java b/core/java/android/text/InputType.java index f643f9256c989..d50684af911d5 100644 --- a/core/java/android/text/InputType.java +++ b/core/java/android/text/InputType.java @@ -178,10 +178,28 @@ public interface InputType { */ public static final int TYPE_TEXT_VARIATION_PASSWORD = 0x00000080; + /** + * Variation of {@link #TYPE_CLASS_TEXT}: entering a password, which should + * be visible to the user. + */ + public static final int TYPE_TEXT_VARIATION_VISIBLE_PASSWORD = 0x00000090; + /** * Variation of {@link #TYPE_CLASS_TEXT}: entering text inside of a web form. */ - public static final int TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x00000090; + public static final int TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x000000a0; + + /** + * Variation of {@link #TYPE_CLASS_TEXT}: entering text to filter contents + * of a list etc. + */ + public static final int TYPE_TEXT_VARIATION_FILTER = 0x000000b0; + + /** + * Variation of {@link #TYPE_CLASS_TEXT}: entering text for phonetic + * pronunciation, such as a phonetic name field in contacts. + */ + public static final int TYPE_TEXT_VARIATION_PHONETIC = 0x000000c0; // ---------------------------------------------------------------------- // ---------------------------------------------------------------------- diff --git a/core/java/android/text/method/ArrowKeyMovementMethod.java b/core/java/android/text/method/ArrowKeyMovementMethod.java index 6df0b35cb497a..8aa49afe45c5b 100644 --- a/core/java/android/text/method/ArrowKeyMovementMethod.java +++ b/core/java/android/text/method/ArrowKeyMovementMethod.java @@ -204,7 +204,7 @@ implements MovementMethod MotionEvent event) { boolean handled = Touch.onTouchEvent(widget, buffer, event); - if (widget.isFocused()) { + if (widget.isFocused() && !widget.didTouchFocusSelectAll()) { if (event.getAction() == MotionEvent.ACTION_UP) { int x = (int) event.getX(); int y = (int) event.getY(); diff --git a/core/java/android/text/method/QwertyKeyListener.java b/core/java/android/text/method/QwertyKeyListener.java index 0b3951755e94c..3f8288c83e69c 100644 --- a/core/java/android/text/method/QwertyKeyListener.java +++ b/core/java/android/text/method/QwertyKeyListener.java @@ -296,20 +296,27 @@ public class QwertyKeyListener extends BaseKeyListener { String old = new String(repl[0].mText); content.removeSpan(repl[0]); - content.setSpan(TextKeyListener.INHIBIT_REPLACEMENT, - en, en, Spannable.SPAN_POINT_POINT); - content.replace(st, en, old); - en = content.getSpanStart(TextKeyListener.INHIBIT_REPLACEMENT); - if (en - 1 >= 0) { + // only cancel the autocomplete if the cursor is at the end of + // the replaced span + if (selStart == en) { content.setSpan(TextKeyListener.INHIBIT_REPLACEMENT, - en - 1, en, - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); - } else { - content.removeSpan(TextKeyListener.INHIBIT_REPLACEMENT); - } + en, en, Spannable.SPAN_POINT_POINT); + content.replace(st, en, old); - adjustMetaAfterKeypress(content); + en = content.getSpanStart(TextKeyListener.INHIBIT_REPLACEMENT); + if (en - 1 >= 0) { + content.setSpan(TextKeyListener.INHIBIT_REPLACEMENT, + en - 1, en, + Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); + } else { + content.removeSpan(TextKeyListener.INHIBIT_REPLACEMENT); + } + adjustMetaAfterKeypress(content); + } else { + adjustMetaAfterKeypress(content); + return super.onKeyDown(view, content, keyCode, event); + } return true; } diff --git a/core/java/android/view/ViewGroup.java b/core/java/android/view/ViewGroup.java index 70cc2a9c3390b..dc7b299cade7a 100644 --- a/core/java/android/view/ViewGroup.java +++ b/core/java/android/view/ViewGroup.java @@ -1387,14 +1387,10 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager // The child need to draw an animation, potentially offscreen, so // make sure we do not cancel invalidate requests mPrivateFlags |= DRAW_ANIMATION; - // Enlarge the invalidate region to account for rounding errors - // in Animation#getInvalidateRegion(); Using 0.5f is unfortunately - // not enough for some types of animations (e.g. scale down.) - final int left = cl + (int) (region.left - 1.0f); - final int top = ct + (int) (region.top - 1.0f); - invalidate(left, top, - left + (int) (region.width() + 1.0f), - top + (int) (region.height() + 1.0f)); + + final int left = cl + (int) region.left; + final int top = ct + (int) region.top; + invalidate(left, top, left + (int) region.width(), top + (int) region.height()); } } } else if ((flags & FLAG_SUPPORT_STATIC_TRANSFORMATIONS) == diff --git a/core/java/android/view/animation/Animation.java b/core/java/android/view/animation/Animation.java index b9c8ec35637f2..a6627609e3be9 100644 --- a/core/java/android/view/animation/Animation.java +++ b/core/java/android/view/animation/Animation.java @@ -340,6 +340,7 @@ public abstract class Animation implements Cloneable { * to run. */ public void restrictDuration(long durationMillis) { + // If we start after the duration, then we just won't run. if (mStartOffset > durationMillis) { mStartOffset = durationMillis; mDuration = 0; @@ -349,11 +350,26 @@ public abstract class Animation implements Cloneable { long dur = mDuration + mStartOffset; if (dur > durationMillis) { - mDuration = dur = durationMillis-mStartOffset; + mDuration = durationMillis-mStartOffset; + dur = durationMillis; } + // If the duration is 0 or less, then we won't run. + if (mDuration <= 0) { + mDuration = 0; + mRepeatCount = 0; + return; + } + // Reduce the number of repeats to keep below the maximum duration. + // The comparison between mRepeatCount and duration is to catch + // overflows after multiplying them. if (mRepeatCount < 0 || mRepeatCount > durationMillis || (dur*mRepeatCount) > durationMillis) { - mRepeatCount = (int)(durationMillis/dur); + // Figure out how many times to do the animation. Subtract 1 since + // repeat count is the number of times to repeat so 0 runs once. + mRepeatCount = (int)(durationMillis/dur) - 1; + if (mRepeatCount < 0) { + mRepeatCount = 0; + } } } @@ -416,7 +432,7 @@ public abstract class Animation implements Cloneable { * Sets how many times the animation should be repeated. If the repeat * count is 0, the animation is never repeated. If the repeat count is * greater than 0 or {@link #INFINITE}, the repeat mode will be taken - * into account. The repeat count if 0 by default. + * into account. The repeat count is 0 by default. * * @param repeatCount the number of times the animation should be repeated * @attr ref android.R.styleable#Animation_repeatCount @@ -806,6 +822,8 @@ public abstract class Animation implements Cloneable { invalidate.set(left, top, right, bottom); transformation.getMatrix().mapRect(invalidate); + // Enlarge the invalidate region to account for rounding errors + invalidate.inset(-1.0f, -1.0f); tempRegion.set(invalidate); invalidate.union(previousRegion); @@ -830,6 +848,8 @@ public abstract class Animation implements Cloneable { public void initializeInvalidateRegion(int left, int top, int right, int bottom) { final RectF region = mPreviousRegion; region.set(left, top, right, bottom); + // Enlarge the invalidate region to account for rounding errors + region.inset(-1.0f, -1.0f); if (mFillBefore) { final Transformation previousTransformation = mPreviousTransformation; applyTransformation(0.0f, previousTransformation); diff --git a/core/java/android/view/animation/AnimationSet.java b/core/java/android/view/animation/AnimationSet.java index 590ce062eb525..98b259451ae18 100644 --- a/core/java/android/view/animation/AnimationSet.java +++ b/core/java/android/view/animation/AnimationSet.java @@ -263,35 +263,13 @@ public class AnimationSet extends Animation { return duration; } - /** - * @hide - */ - public void getInvalidateRegion(int left, int top, int right, int bottom, - RectF invalidate, Transformation transformation) { - - final RectF previousRegion = mPreviousRegion; - - invalidate.set(left, top, right, bottom); - transformation.getMatrix().mapRect(invalidate); - invalidate.union(previousRegion); - - previousRegion.set(left, top, right, bottom); - transformation.getMatrix().mapRect(previousRegion); - - final Transformation tempTransformation = mTransformation; - final Transformation previousTransformation = mPreviousTransformation; - - tempTransformation.set(transformation); - transformation.set(previousTransformation); - previousTransformation.set(tempTransformation); - } - /** * @hide */ public void initializeInvalidateRegion(int left, int top, int right, int bottom) { final RectF region = mPreviousRegion; region.set(left, top, right, bottom); + region.inset(-1.0f, -1.0f); if (mFillBefore) { final int count = mAnimations.size(); @@ -400,8 +378,12 @@ public class AnimationSet extends Animation { long[] storedOffsets = mStoredOffsets; - if (storedOffsets == null || storedOffsets.length != count) { - storedOffsets = mStoredOffsets = new long[count]; + if (startOffsetSet) { + if (storedOffsets == null || storedOffsets.length != count) { + storedOffsets = mStoredOffsets = new long[count]; + } + } else if (storedOffsets != null) { + storedOffsets = mStoredOffsets = null; } for (int i = 0; i < count; i++) { @@ -446,7 +428,6 @@ public class AnimationSet extends Animation { final ArrayList children = mAnimations; final int count = children.size(); - for (int i = 0; i < count; i++) { children.get(i).setStartOffset(offsets[i]); } diff --git a/core/java/android/view/inputmethod/EditorInfo.java b/core/java/android/view/inputmethod/EditorInfo.java index 0405371d6db7b..1c0d42a2c8ef6 100644 --- a/core/java/android/view/inputmethod/EditorInfo.java +++ b/core/java/android/view/inputmethod/EditorInfo.java @@ -65,6 +65,12 @@ public class EditorInfo implements InputType, Parcelable { */ public static final int IME_ACTION_NEXT = 0x00000004; + /** + * Bits of {@link #IME_MASK_ACTION}: the action key performs a "done" + * operation, typically meaning the IME will be closed. + */ + public static final int IME_ACTION_DONE = 0x00000005; + /** * Flag of {@link #imeOptions}: used in conjunction with * {@link #IME_MASK_ACTION}, this indicates that the action should not diff --git a/core/java/android/view/inputmethod/InputMethod.java b/core/java/android/view/inputmethod/InputMethod.java index 740dca83d7ae6..a5e0e9491d1e2 100644 --- a/core/java/android/view/inputmethod/InputMethod.java +++ b/core/java/android/view/inputmethod/InputMethod.java @@ -18,6 +18,7 @@ package android.view.inputmethod; import android.inputmethodservice.InputMethodService; import android.os.IBinder; +import android.os.ResultReceiver; /** * The InputMethod interface represents an input method which can generate key @@ -171,7 +172,7 @@ public interface InputMethod { public void revokeSession(InputMethodSession session); /** - * Flag for {@link #showSoftInput(int)}: this show has been explicitly + * Flag for {@link #showSoftInput}: this show has been explicitly * requested by the user. If not set, the system has decided it may be * a good idea to show the input method based on a navigation operation * in the UI. @@ -179,7 +180,7 @@ public interface InputMethod { public static final int SHOW_EXPLICIT = 0x00001; /** - * Flag for {@link #showSoftInput(int)}: this show has been forced to + * Flag for {@link #showSoftInput}: this show has been forced to * happen by the user. If set, the input method should remain visible * until deliberated dismissed by the user in its UI. */ @@ -188,13 +189,29 @@ public interface InputMethod { /** * Request that any soft input part of the input method be shown to the user. * - * @param flags Provide additional information about the show request. + * @param flags Provides additional information about the show request. * Currently may be 0 or have the bit {@link #SHOW_EXPLICIT} set. + * @param resultReceiver The client requesting the show may wish to + * be told the impact of their request, which should be supplied here. + * The result code should be + * {@link InputMethodManager#RESULT_UNCHANGED_SHOWN InputMethodManager.RESULT_UNCHANGED_SHOWN}, + * {@link InputMethodManager#RESULT_UNCHANGED_HIDDEN InputMethodManager.RESULT_UNCHANGED_HIDDEN}, + * {@link InputMethodManager#RESULT_SHOWN InputMethodManager.RESULT_SHOWN}, or + * {@link InputMethodManager#RESULT_HIDDEN InputMethodManager.RESULT_HIDDEN}. */ - public void showSoftInput(int flags); + public void showSoftInput(int flags, ResultReceiver resultReceiver); /** * Request that any soft input part of the input method be hidden from the user. + * @param flags Provides additional information about the show request. + * Currently always 0. + * @param resultReceiver The client requesting the show may wish to + * be told the impact of their request, which should be supplied here. + * The result code should be + * {@link InputMethodManager#RESULT_UNCHANGED_SHOWN InputMethodManager.RESULT_UNCHANGED_SHOWN}, + * {@link InputMethodManager#RESULT_UNCHANGED_HIDDEN InputMethodManager.RESULT_UNCHANGED_HIDDEN}, + * {@link InputMethodManager#RESULT_SHOWN InputMethodManager.RESULT_SHOWN}, or + * {@link InputMethodManager#RESULT_HIDDEN InputMethodManager.RESULT_HIDDEN}. */ - public void hideSoftInput(); + public void hideSoftInput(int flags, ResultReceiver resultReceiver); } diff --git a/core/java/android/view/inputmethod/InputMethodManager.java b/core/java/android/view/inputmethod/InputMethodManager.java index 0aa1d6c11fe4b..916ffea6a7a82 100644 --- a/core/java/android/view/inputmethod/InputMethodManager.java +++ b/core/java/android/view/inputmethod/InputMethodManager.java @@ -24,6 +24,7 @@ import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.RemoteException; +import android.os.ResultReceiver; import android.os.ServiceManager; import android.util.Log; import android.util.PrintWriterPrinter; @@ -287,6 +288,9 @@ public final class InputMethodManager { // ----------------------------------------------------------- static final int MSG_DUMP = 1; + static final int MSG_BIND = 2; + static final int MSG_UNBIND = 3; + static final int MSG_SET_ACTIVE = 4; class H extends Handler { H(Looper looper) { @@ -309,6 +313,68 @@ public final class InputMethodManager { } return; } + case MSG_BIND: { + final InputBindResult res = (InputBindResult)msg.obj; + synchronized (mH) { + if (mBindSequence < 0 || mBindSequence != res.sequence) { + Log.w(TAG, "Ignoring onBind: cur seq=" + mBindSequence + + ", given seq=" + res.sequence); + return; + } + + mCurMethod = res.method; + mCurId = res.id; + mBindSequence = res.sequence; + } + startInputInner(); + return; + } + case MSG_UNBIND: { + final int sequence = msg.arg1; + synchronized (mH) { + if (mBindSequence == sequence) { + if (false) { + // XXX the server has already unbound! + if (mCurMethod != null && mCurrentTextBoxAttribute != null) { + try { + mCurMethod.finishInput(); + } catch (RemoteException e) { + Log.w(TAG, "IME died: " + mCurId, e); + } + } + } + clearBindingLocked(); + + // If we were actively using the last input method, then + // we would like to re-connect to the next input method. + if (mServedView != null && mServedView.isFocused()) { + mServedConnecting = true; + } + } + startInputInner(); + } + return; + } + case MSG_SET_ACTIVE: { + final boolean active = msg.arg1 != 0; + synchronized (mH) { + mActive = active; + mFullscreenMode = false; + if (!active) { + // Some other client has starting using the IME, so note + // that this happened and make sure our own editor's + // state is reset. + mHasBeenInactive = true; + try { + // Note that finishComposingText() is allowed to run + // even when we are not active. + mIInputContext.finishComposingText(); + } catch (RemoteException e) { + } + } + } + return; + } } } } @@ -348,62 +414,15 @@ public final class InputMethodManager { } public void onBindMethod(InputBindResult res) { - synchronized (mH) { - if (mBindSequence < 0 || mBindSequence != res.sequence) { - Log.w(TAG, "Ignoring onBind: cur seq=" + mBindSequence - + ", given seq=" + res.sequence); - return; - } - - mCurMethod = res.method; - mCurId = res.id; - mBindSequence = res.sequence; - } - startInputInner(); + mH.sendMessage(mH.obtainMessage(MSG_BIND, res)); } public void onUnbindMethod(int sequence) { - synchronized (mH) { - if (mBindSequence == sequence) { - if (false) { - // XXX the server has already unbound! - if (mCurMethod != null && mCurrentTextBoxAttribute != null) { - try { - mCurMethod.finishInput(); - } catch (RemoteException e) { - Log.w(TAG, "IME died: " + mCurId, e); - } - } - } - clearBindingLocked(); - - // If we were actively using the last input method, then - // we would like to re-connect to the next input method. - if (mServedView != null && mServedView.isFocused()) { - mServedConnecting = true; - } - } - startInputInner(); - } + mH.sendMessage(mH.obtainMessage(MSG_UNBIND, sequence, 0)); } public void setActive(boolean active) { - synchronized (mH) { - mActive = active; - mFullscreenMode = false; - if (!active) { - // Some other client has starting using the IME, so note - // that this happened and make sure our own editor's - // state is reset. - mHasBeenInactive = true; - try { - // Note that finishComposingText() is allowed to run - // even when we are not active. - mIInputContext.finishComposingText(); - } catch (RemoteException e) { - } - } - } + mH.sendMessage(mH.obtainMessage(MSG_SET_ACTIVE, active ? 1 : 0, 0)); } }; @@ -645,6 +664,52 @@ public final class InputMethodManager { */ public static final int SHOW_FORCED = 0x0002; + /** + * Synonym for {@link #showSoftInput(View, int, ResultReceiver)} without + * a result receiver: explicitly request that the current input method's + * soft input area be shown to the user, if needed. + * + * @param view The currently focused view, which would like to receive + * soft keyboard input. + * @param flags Provides additional operating flags. Currently may be + * 0 or have the {@link #SHOW_IMPLICIT} bit set. + */ + public boolean showSoftInput(View view, int flags) { + return showSoftInput(view, flags, null); + } + + /** + * Flag for the {@link ResultReceiver} result code from + * {@link #showSoftInput(View, int, ResultReceiver)} and + * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the + * state of the soft input window was unchanged and remains shown. + */ + public static final int RESULT_UNCHANGED_SHOWN = 0; + + /** + * Flag for the {@link ResultReceiver} result code from + * {@link #showSoftInput(View, int, ResultReceiver)} and + * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the + * state of the soft input window was unchanged and remains hidden. + */ + public static final int RESULT_UNCHANGED_HIDDEN = 1; + + /** + * Flag for the {@link ResultReceiver} result code from + * {@link #showSoftInput(View, int, ResultReceiver)} and + * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the + * state of the soft input window changed from hidden to shown. + */ + public static final int RESULT_SHOWN = 2; + + /** + * Flag for the {@link ResultReceiver} result code from + * {@link #showSoftInput(View, int, ResultReceiver)} and + * {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver)}: the + * state of the soft input window changed from shown to hidden. + */ + public static final int RESULT_HIDDEN = 3; + /** * Explicitly request that the current input method's soft input area be * shown to the user, if needed. Call this if the user interacts with @@ -655,25 +720,33 @@ public final class InputMethodManager { * soft keyboard input. * @param flags Provides additional operating flags. Currently may be * 0 or have the {@link #SHOW_IMPLICIT} bit set. + * @param resultReceiver If non-null, this will be called by the IME when + * it has processed your request to tell you what it has done. The result + * code you receive may be either {@link #RESULT_UNCHANGED_SHOWN}, + * {@link #RESULT_UNCHANGED_HIDDEN}, {@link #RESULT_SHOWN}, or + * {@link #RESULT_HIDDEN}. */ - public void showSoftInput(View view, int flags) { + public boolean showSoftInput(View view, int flags, + ResultReceiver resultReceiver) { checkFocus(); synchronized (mH) { if (mServedView != view) { - return; + return false; } try { - mService.showSoftInput(mClient, flags); + return mService.showSoftInput(mClient, flags, resultReceiver); } catch (RemoteException e) { } + + return false; } } /** @hide */ - public void showSoftInputUnchecked(int flags) { + public void showSoftInputUnchecked(int flags, ResultReceiver resultReceiver) { try { - mService.showSoftInput(mClient, flags); + mService.showSoftInput(mClient, flags, resultReceiver); } catch (RemoteException e) { } } @@ -692,6 +765,20 @@ public final class InputMethodManager { */ public static final int HIDE_NOT_ALWAYS = 0x0002; + /** + * Synonym for {@link #hideSoftInputFromWindow(IBinder, int, ResultReceiver) + * without a result: request to hide the soft input window from the + * context of the window that is currently accepting input. + * + * @param windowToken The token of the window that is making the request, + * as returned by {@link View#getWindowToken() View.getWindowToken()}. + * @param flags Provides additional operating flags. Currently may be + * 0 or have the {@link #HIDE_IMPLICIT_ONLY} bit set. + */ + public boolean hideSoftInputFromWindow(IBinder windowToken, int flags) { + return hideSoftInputFromWindow(windowToken, flags, null); + } + /** * Request to hide the soft input window from the context of the window * that is currently accepting input. This should be called as a result @@ -702,21 +789,77 @@ public final class InputMethodManager { * as returned by {@link View#getWindowToken() View.getWindowToken()}. * @param flags Provides additional operating flags. Currently may be * 0 or have the {@link #HIDE_IMPLICIT_ONLY} bit set. + * @param resultReceiver If non-null, this will be called by the IME when + * it has processed your request to tell you what it has done. The result + * code you receive may be either {@link #RESULT_UNCHANGED_SHOWN}, + * {@link #RESULT_UNCHANGED_HIDDEN}, {@link #RESULT_SHOWN}, or + * {@link #RESULT_HIDDEN}. */ - public void hideSoftInputFromWindow(IBinder windowToken, int flags) { + public boolean hideSoftInputFromWindow(IBinder windowToken, int flags, + ResultReceiver resultReceiver) { checkFocus(); + synchronized (mH) { + if (mServedView == null || mServedView.getWindowToken() != windowToken) { + return false; + } + + try { + return mService.hideSoftInput(mClient, flags, resultReceiver); + } catch (RemoteException e) { + } + return false; + } + } + + + /** + * This method toggles the input method window display. + * If the input window is already displayed, it gets hidden. + * If not the input window will be displayed. + * @param windowToken The token of the window that is making the request, + * as returned by {@link View#getWindowToken() View.getWindowToken()}. + * @param showFlags Provides additional operating flags. May be + * 0 or have the {@link #SHOW_IMPLICIT}, + * {@link #SHOW_FORCED} bit set. + * @param hideFlags Provides additional operating flags. May be + * 0 or have the {@link #HIDE_IMPLICIT_ONLY}, + * {@link #HIDE_NOT_ALWAYS} bit set. + **/ + public void toggleSoftInputFromWindow(IBinder windowToken, int showFlags, int hideFlags) { synchronized (mH) { if (mServedView == null || mServedView.getWindowToken() != windowToken) { return; } + if (mCurMethod != null) { + try { + mCurMethod.toggleSoftInput(showFlags, hideFlags); + } catch (RemoteException e) { + } + } + } + } + /* + * This method toggles the input method window display. + * If the input window is already displayed, it gets hidden. + * If not the input window will be displayed. + * @param showFlags Provides additional operating flags. May be + * 0 or have the {@link #SHOW_IMPLICIT}, + * {@link #SHOW_FORCED} bit set. + * @param hideFlags Provides additional operating flags. May be + * 0 or have the {@link #HIDE_IMPLICIT_ONLY}, + * {@link #HIDE_NOT_ALWAYS} bit set. + * @hide + */ + public void toggleSoftInput(int showFlags, int hideFlags) { + if (mCurMethod != null) { try { - mService.hideSoftInput(mClient, flags); + mCurMethod.toggleSoftInput(showFlags, hideFlags); } catch (RemoteException e) { } } } - + /** * If the input method is currently connected to the given view, * restart it with its new contents. You should call this when the text @@ -956,7 +1099,7 @@ public final class InputMethodManager { void closeCurrentInput() { try { - mService.hideSoftInput(mClient, HIDE_NOT_ALWAYS); + mService.hideSoftInput(mClient, HIDE_NOT_ALWAYS, null); } catch (RemoteException e) { } } @@ -1118,7 +1261,8 @@ public final class InputMethodManager { * when it was started, which allows it to perform this operation on * itself. * @param flags Provides additional operating flags. Currently may be - * 0 or have the {@link #HIDE_IMPLICIT_ONLY} bit set. + * 0 or have the {@link #HIDE_IMPLICIT_ONLY}, + * {@link #HIDE_NOT_ALWAYS} bit set. */ public void hideSoftInputFromInputMethod(IBinder token, int flags) { try { @@ -1128,6 +1272,27 @@ public final class InputMethodManager { } } + /** + * Show the input method's soft input area, so the user + * sees the input method window and can interact with it. + * This can only be called from the currently active input method, + * as validated by the given token. + * + * @param token Supplies the identifying token given to an input method + * when it was started, which allows it to perform this operation on + * itself. + * @param flags Provides additional operating flags. Currently may be + * 0 or have the {@link #SHOW_IMPLICIT} or + * {@link #SHOW_FORCED} bit set. + */ + public void showSoftInputFromInputMethod(IBinder token, int flags) { + try { + mService.showMySoftInput(token, flags); + } catch (RemoteException e) { + throw new RuntimeException(e); + } + } + /** * @hide */ @@ -1204,7 +1369,7 @@ public final class InputMethodManager { } } } - + void doDump(FileDescriptor fd, PrintWriter fout, String[] args) { final Printer p = new PrintWriterPrinter(fout); p.println("Input method client state for " + this + ":"); diff --git a/core/java/android/view/inputmethod/InputMethodSession.java b/core/java/android/view/inputmethod/InputMethodSession.java index b5bbaffdbf4f4..bb03afad56ae0 100644 --- a/core/java/android/view/inputmethod/InputMethodSession.java +++ b/core/java/android/view/inputmethod/InputMethodSession.java @@ -139,4 +139,16 @@ public interface InputMethodSession { * @param data Any data to include with the command. */ public void appPrivateCommand(String action, Bundle data); + + /** + * Toggle the soft input window. + * Applications can toggle the state of the soft input window. + * @param showFlags Provides additional operating flags. May be + * 0 or have the {@link InputMethodManager#SHOW_IMPLICIT}, + * {@link InputMethodManager#SHOW_FORCED} bit set. + * @param hideFlags Provides additional operating flags. May be + * 0 or have the {@link InputMethodManager#HIDE_IMPLICIT_ONLY}, + * {@link InputMethodManager#HIDE_NOT_ALWAYS} bit set. + */ + public void toggleSoftInput(int showFlags, int hideFlags); } diff --git a/core/java/android/webkit/BrowserFrame.java b/core/java/android/webkit/BrowserFrame.java index 451af6d047cf9..5401a6e0af12a 100644 --- a/core/java/android/webkit/BrowserFrame.java +++ b/core/java/android/webkit/BrowserFrame.java @@ -201,10 +201,14 @@ class BrowserFrame extends Handler { final String failingUrl) { // As this is called for the main resource and loading will be stopped // after, reset the state variables. + resetLoadingStates(); + mCallbackProxy.onReceivedError(errorCode, description, failingUrl); + } + + private void resetLoadingStates() { mCommitted = true; mWebViewCore.mEndScaleZoom = mFirstLayoutDone == false; mFirstLayoutDone = true; - mCallbackProxy.onReceivedError(errorCode, description, failingUrl); } /* package */boolean committed() { @@ -290,6 +294,7 @@ class BrowserFrame extends Handler { if (isMainFrame || loadType == FRAME_LOADTYPE_STANDARD) { if (isMainFrame) { + resetLoadingStates(); mCallbackProxy.switchOutDrawHistory(); mCallbackProxy.onPageFinished(url); } @@ -555,8 +560,11 @@ class BrowserFrame extends Handler { method, isHighPriority); loader.setHeaders(headers); loader.setPostData(postData); - loader.setCacheMode(cacheMode); // Set the load mode to the mode used - // for the current page. + // Set the load mode to the mode used for the current page. + // If WebKit wants validation, go to network directly. + loader.setCacheMode(headers.containsKey("If-Modified-Since") + || headers.containsKey("If-None-Match") ? + WebSettings.LOAD_NO_CACHE : cacheMode); // Set referrer to current URL? if (!loader.executeLoad()) { checker.responseAlert("startLoadingResource fail"); @@ -751,7 +759,14 @@ class BrowserFrame extends Handler { /** * Stop loading the current page. */ - public native void stopLoading(); + public void stopLoading() { + if (mIsMainFrame) { + resetLoadingStates(); + } + nativeStopLoading(); + } + + private native void nativeStopLoading(); /** * Return true if the document has images. diff --git a/core/java/android/webkit/FrameLoader.java b/core/java/android/webkit/FrameLoader.java index 5e323ebb67a57..42d03f0dcc99b 100644 --- a/core/java/android/webkit/FrameLoader.java +++ b/core/java/android/webkit/FrameLoader.java @@ -21,7 +21,6 @@ import android.net.http.RequestHandle; import android.util.Config; import android.util.Log; import android.webkit.CacheManager.CacheResult; -import android.webkit.UrlInterceptRegistry; import java.util.HashMap; import java.util.Map; @@ -234,12 +233,14 @@ class FrameLoader { private boolean handleUrlIntercept() { // Check if the URL can be served from UrlIntercept. If // successful, return the data just like a cache hit. - CacheResult result = UrlInterceptRegistry.getSurrogate( + + PluginData data = UrlInterceptRegistry.getPluginData( mListener.url(), mHeaders); - if(result != null) { - // Intercepted. The data is stored in result.stream. Setup - // a load from the CacheResult. - startCacheLoad(result); + + if(data != null) { + PluginContentLoader loader = + new PluginContentLoader(mListener, data); + loader.load(); return true; } // Not intercepted. Carry on as normal. diff --git a/core/java/android/webkit/LoadListener.java b/core/java/android/webkit/LoadListener.java index dfae17da6da14..8d4b2208d1019 100644 --- a/core/java/android/webkit/LoadListener.java +++ b/core/java/android/webkit/LoadListener.java @@ -1126,6 +1126,7 @@ class LoadListener extends Handler implements EventHandler { mCacheResult = null; } + // This will strip the anchor setUrl(redirectTo); // Redirect may be in the cache @@ -1143,7 +1144,7 @@ class LoadListener extends Handler implements EventHandler { // mRequestHandle can be null when the request was satisfied // by the cache, and the cache returned a redirect if (mRequestHandle != null) { - mRequestHandle.setupRedirect(redirectTo, mStatusCode, + mRequestHandle.setupRedirect(mUrl, mStatusCode, mRequestHeaders); } else { // If the original request came from the cache, there is no @@ -1336,19 +1337,16 @@ class LoadListener extends Handler implements EventHandler { */ void setUrl(String url) { if (url != null) { - if (URLUtil.isDataUrl(url)) { - // Don't strip anchor as that is a valid part of the URL - mUrl = url; - } else { - mUrl = URLUtil.stripAnchor(url); - } mUri = null; - if (URLUtil.isNetworkUrl(mUrl)) { + if (URLUtil.isNetworkUrl(url)) { + mUrl = URLUtil.stripAnchor(url); try { mUri = new WebAddress(mUrl); } catch (ParseException e) { e.printStackTrace(); } + } else { + mUrl = url; } } } diff --git a/core/java/android/webkit/PluginContentLoader.java b/core/java/android/webkit/PluginContentLoader.java new file mode 100644 index 0000000000000..2069599803557 --- /dev/null +++ b/core/java/android/webkit/PluginContentLoader.java @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.webkit; + +import android.net.http.Headers; + +import java.io.InputStream; +import java.util.*; + +import org.apache.http.util.CharArrayBuffer; + +/** + * This class is a concrete implementation of StreamLoader that uses a + * PluginData object as the source for the stream. + */ +class PluginContentLoader extends StreamLoader { + + private PluginData mData; // Content source + + /** + * Constructs a PluginDataLoader for use when loading content from + * a plugin. + * + * @param loadListener LoadListener to pass the content to + * @param data PluginData used as the source for the content. + */ + PluginContentLoader(LoadListener loadListener, PluginData data) { + super(loadListener); + mData = data; + } + + @Override + protected boolean setupStreamAndSendStatus() { + mDataStream = mData.getInputStream(); + mContentLength = mData.getContentLength(); + mHandler.status(1, 1, mData.getStatusCode(), "OK"); + return true; + } + + @Override + protected void buildHeaders(Headers headers) { + // Crate a CharArrayBuffer with an arbitrary initial capacity. + CharArrayBuffer buffer = new CharArrayBuffer(100); + Iterator> responseHeadersIt = + mData.getHeaders().entrySet().iterator(); + while (responseHeadersIt.hasNext()) { + Map.Entry entry = responseHeadersIt.next(); + // Headers.parseHeader() expects lowercase keys, so keys + // such as "Accept-Ranges" will fail to parse. + // + // UrlInterceptHandler instances supply a mapping of + // lowercase key to [ unmodified key, value ], so for + // Headers.parseHeader() to succeed, we need to construct + // a string using the key (i.e. entry.getKey()) and the + // element denoting the header value in the + // [ unmodified key, value ] pair (i.e. entry.getValue()[1). + // + // The reason why UrlInterceptHandler instances supply such a + // mapping in the first place is historical. Early versions of + // the Gears plugin used java.net.HttpURLConnection, which always + // returned headers names as capitalized strings. When these were + // fed back into webkit, they failed to parse. + // + // Mewanwhile, Gears was modified to use Apache HTTP library + // instead, so this design is now obsolete. Changing it however, + // would require changes to the Gears C++ codebase and QA-ing and + // submitting a new binary to the Android tree. Given the + // timelines for the next Android release, we will not do this + // for now. + // + // TODO: fix C++ Gears to remove the need for this + // design. + String keyValue = entry.getKey() + ": " + entry.getValue()[1]; + buffer.ensureCapacity(keyValue.length()); + buffer.append(keyValue); + // Parse it into the header container. + headers.parseHeader(buffer); + // Clear the buffer + buffer.clear(); + } + } +} diff --git a/core/java/android/webkit/PluginData.java b/core/java/android/webkit/PluginData.java new file mode 100644 index 0000000000000..2b539fe0a76ef --- /dev/null +++ b/core/java/android/webkit/PluginData.java @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.webkit; + +import java.io.InputStream; +import java.util.Map; + +/** + * This class encapsulates the content generated by a plugin. The + * data itself is meant to be loaded into webkit via the + * PluginContentLoader class, which needs to be able to construct an + * HTTP response. For this, it needs a stream with the response body, + * the length of the body, the response headers, and the response + * status code. The PluginData class is the container for all these + * parts. + * + */ +public final class PluginData { + /** + * The content stream. + */ + private InputStream mStream; + /** + * The content length. + */ + private long mContentLength; + /** + * The associated HTTP response headers stored as a map of + * lowercase header name to [ unmodified header name, header value]. + * TODO: This design was always a hack. Remove (involves updating + * the Gears C++ side). + */ + private Map mHeaders; + + /** + * The index of the header value in the above mapping. + */ + private int mHeaderValueIndex; + /** + * The associated HTTP response code. + */ + private int mStatusCode; + + /** + * Creates a PluginData instance. + * + * @param stream The stream that supplies content for the plugin. + * @param length The length of the plugin content. + * @param headers The response headers. Map of + * lowercase header name to [ unmodified header name, header value] + * @param length The HTTP response status code. + */ + public PluginData( + InputStream stream, + long length, + Map headers, + int code) { + mStream = stream; + mContentLength = length; + mHeaders = headers; + mStatusCode = code; + } + + /** + * Returns the input stream that contains the plugin content. + * + * @return An InputStream instance with the plugin content. + */ + public InputStream getInputStream() { + return mStream; + } + + /** + * Returns the length of the plugin content. + * + * @return the length of the plugin content. + */ + public long getContentLength() { + return mContentLength; + } + + /** + * Returns the HTTP response headers associated with the plugin + * content. + * + * @return A Map containing all headers. The + * mapping is 'lowercase header name' to ['unmodified header + * name', header value]. + */ + public Map getHeaders() { + return mHeaders; + } + + /** + * Returns the HTTP status code for the response. + * + * @return The HTTP statue code, e.g 200. + */ + public int getStatusCode() { + return mStatusCode; + } +} diff --git a/core/java/android/webkit/TextDialog.java b/core/java/android/webkit/TextDialog.java index 8a82411ec1936..39806dc4b299d 100644 --- a/core/java/android/webkit/TextDialog.java +++ b/core/java/android/webkit/TextDialog.java @@ -113,13 +113,7 @@ import java.util.ArrayList; // that other applications that use embedded WebViews will properly // display the text in textfields. setTextColor(Color.BLACK); - } - - @Override - protected boolean shouldAdvanceFocusOnEnter() { - // In the browser, single line textfields use enter as a form submit, - // so we never want to advance the focus on enter. - return false; + setImeOptions(EditorInfo.IME_ACTION_NONE); } @Override diff --git a/core/java/android/webkit/UrlInterceptHandler.java b/core/java/android/webkit/UrlInterceptHandler.java index e1c9d61b518fb..9216413c4a753 100644 --- a/core/java/android/webkit/UrlInterceptHandler.java +++ b/core/java/android/webkit/UrlInterceptHandler.java @@ -17,6 +17,7 @@ package android.webkit; import android.webkit.CacheManager.CacheResult; +import android.webkit.PluginData; import java.util.Map; public interface UrlInterceptHandler { @@ -29,6 +30,20 @@ public interface UrlInterceptHandler { * @param url URL string. * @param headers The headers associated with the request. May be null. * @return The CacheResult containing the surrogate response. + * @Deprecated Use PluginData getPluginData(String url, + * Map headers); instead */ + @Deprecated public CacheResult service(String url, Map headers); + + /** + * Given an URL, returns the PluginData which contains the + * surrogate response for the request, or null if the handler is + * not interested. + * + * @param url URL string. + * @param headers The headers associated with the request. May be null. + * @return The PluginData containing the surrogate response. + */ + public PluginData getPluginData(String url, Map headers); } diff --git a/core/java/android/webkit/UrlInterceptRegistry.java b/core/java/android/webkit/UrlInterceptRegistry.java index a218191db27de..6051f290dffe1 100644 --- a/core/java/android/webkit/UrlInterceptRegistry.java +++ b/core/java/android/webkit/UrlInterceptRegistry.java @@ -17,6 +17,7 @@ package android.webkit; import android.webkit.CacheManager.CacheResult; +import android.webkit.PluginData; import android.webkit.UrlInterceptHandler; import java.util.Iterator; @@ -82,17 +83,21 @@ public final class UrlInterceptRegistry { UrlInterceptHandler handler) { return getHandlers().remove(handler); } - + /** * Given an url, returns the CacheResult of the first * UrlInterceptHandler interested, or null if none are. - * + * * @return A CacheResult containing surrogate content. + * @Deprecated Use PluginData getPluginData( String url, + * Map headers) instead. */ + @Deprecated public static synchronized CacheResult getSurrogate( String url, Map headers) { - if (urlInterceptDisabled()) + if (urlInterceptDisabled()) { return null; + } Iterator iter = getHandlers().listIterator(); while (iter.hasNext()) { UrlInterceptHandler handler = (UrlInterceptHandler) iter.next(); @@ -103,4 +108,27 @@ public final class UrlInterceptRegistry { } return null; } + + /** + * Given an url, returns the PluginData of the first + * UrlInterceptHandler interested, or null if none are or if + * intercepts are disabled. + * + * @return A PluginData instance containing surrogate content. + */ + public static synchronized PluginData getPluginData( + String url, Map headers) { + if (urlInterceptDisabled()) { + return null; + } + Iterator iter = getHandlers().listIterator(); + while (iter.hasNext()) { + UrlInterceptHandler handler = (UrlInterceptHandler) iter.next(); + PluginData data = handler.getPluginData(url, headers); + if (data != null) { + return data; + } + } + return null; + } } diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java index 5126ef06fbd56..91795a3dc25f7 100644 --- a/core/java/android/webkit/WebView.java +++ b/core/java/android/webkit/WebView.java @@ -689,7 +689,10 @@ public class WebView extends AbsoluteLayout return true; } - public void onSimpleZoom(boolean zoomIn) { + public void onSimpleZoom(boolean zoomIn, int centerX, int centerY) { + mZoomCenterX = (float) centerX; + mZoomCenterY = (float) centerY; + if (zoomIn) { zoomIn(); } else { @@ -736,12 +739,12 @@ public class WebView extends AbsoluteLayout mFocusData.mY = 0; mScroller = new Scroller(context); mZoomRingController = new ZoomRingController(context, this); - mZoomRingController.setResetThumbAutomatically(false); mZoomRingController.setCallback(mZoomListener); - mZoomRingController.setZoomRingTrack( + mZoomRingController.setTrackDrawable( com.android.internal.R.drawable.zoom_ring_track_absolute); - mZoomRingController.setPannerAcceleration(160); - mZoomRingController.setPannerStartAcceleratingDuration(700); + float density = context.getResources().getDisplayMetrics().density; + mZoomRingController.setPannerAcceleration((int) (160 * density)); + mZoomRingController.setPannerStartAcceleratingDuration((int) (700 * density)); createZoomRingOverviewTab(); mZoomButtonsController = new ZoomButtonsController(context, this); mZoomButtonsController.setOverviewVisible(true); @@ -760,7 +763,7 @@ public class WebView extends AbsoluteLayout } public void onZoom(boolean zoomIn) { - mZoomListener.onSimpleZoom(zoomIn); + mZoomListener.onSimpleZoom(zoomIn, getWidth() / 2, getHeight() / 2); } }); } @@ -4491,6 +4494,14 @@ public class WebView extends AbsoluteLayout return zoomControls; } + // This used to be the value returned by ViewConfiguration.getTouchSlop(). + // We pass this to the navigation cache to find where the user clicked. + // TouchSlop has been increased for other purposes, but for the + // navigation cache it is too big, and may result in clicking the wrong + // spot. This is a concern when the cache is out of date, and clicking + // finds a node which is wrong but nearby. + private static final int NAV_SLOP = 12; + private void updateSelection() { if (mNativeClass == 0) { return; @@ -4498,7 +4509,7 @@ public class WebView extends AbsoluteLayout // mLastTouchX and mLastTouchY are the point in the current viewport int contentX = viewToContent((int) mLastTouchX + mScrollX); int contentY = viewToContent((int) mLastTouchY + mScrollY); - int contentSize = ViewConfiguration.getTouchSlop(); + int contentSize = NAV_SLOP; Rect rect = new Rect(contentX - contentSize, contentY - contentSize, contentX + contentSize, contentY + contentSize); // If we were already focused on a textfield, update its cache. @@ -4513,7 +4524,7 @@ public class WebView extends AbsoluteLayout View v = mTextEntry; int x = viewToContent((v.getLeft() + v.getRight()) >> 1); int y = viewToContent((v.getTop() + v.getBottom()) >> 1); - int contentSize = ViewConfiguration.get(getContext()).getScaledTouchSlop(); + int contentSize = NAV_SLOP; nativeMotionUp(x, y, contentSize, true); } } @@ -4526,7 +4537,7 @@ public class WebView extends AbsoluteLayout // mLastTouchX and mLastTouchY are the point in the current viewport int contentX = viewToContent((int) mLastTouchX + mScrollX); int contentY = viewToContent((int) mLastTouchY + mScrollY); - int contentSize = ViewConfiguration.get(getContext()).getScaledTouchSlop(); + int contentSize = NAV_SLOP; if (nativeMotionUp(contentX, contentY, contentSize, true)) { if (mLogEvent) { Checkin.updateStats(mContext.getContentResolver(), diff --git a/core/java/android/webkit/gears/UrlInterceptHandlerGears.java b/core/java/android/webkit/gears/UrlInterceptHandlerGears.java index 2a5cbe99e15c0..43104bf293e36 100644 --- a/core/java/android/webkit/gears/UrlInterceptHandlerGears.java +++ b/core/java/android/webkit/gears/UrlInterceptHandlerGears.java @@ -25,16 +25,14 @@ package android.webkit.gears; -import android.net.http.Headers; import android.util.Log; -import android.webkit.CacheManager; import android.webkit.CacheManager.CacheResult; import android.webkit.Plugin; +import android.webkit.PluginData; import android.webkit.UrlInterceptRegistry; import android.webkit.UrlInterceptHandler; import android.webkit.WebView; -import org.apache.http.impl.cookie.DateUtils; import org.apache.http.util.CharArrayBuffer; import java.io.*; @@ -53,12 +51,6 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { private static final String LOG_TAG = "Gears-J"; /** Buffer size for reading/writing streams. */ private static final int BUFFER_SIZE = 4096; - /** - * Number of milliseconds to expire LocalServer temporary entries in - * the browser's cache. Somewhat arbitrarily chosen as a compromise - * between being a) long enough not to expire during page load and - * b) short enough to evict entries during a session. */ - private static final int CACHE_EXPIRY_MS = 60000; // 1 minute. /** Enable/disable all logging in this class. */ private static boolean logEnabled = false; /** The unmodified (case-sensitive) key in the headers map is the @@ -140,6 +132,8 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { private String encoding; // The stream which contains the body when read(). private InputStream inputStream; + // The length of the content body. + private long contentLength; /** * Initialize members using an in-memory array to return the body. @@ -160,6 +154,7 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { this.mimeType = mimeType; this.encoding = encoding; // Setup a stream to read out of the byte array. + this.contentLength = body.length; this.inputStream = new ByteArrayInputStream(body); } @@ -185,7 +180,9 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { this.encoding = encoding; try { // Setup a stream to read out of a file on disk. - this.inputStream = new FileInputStream(new File(path)); + File file = new File(path); + this.contentLength = file.length(); + this.inputStream = new FileInputStream(file); return true; } catch (java.io.FileNotFoundException ex) { log("File not found: " + path); @@ -274,6 +271,13 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { public InputStream getInputStream() { return inputStream; } + + /** + * @return The length of the response body. + */ + public long getContentLength() { + return contentLength; + } } /** @@ -319,44 +323,32 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { UrlInterceptRegistry.unregisterHandler(this); } - /** - * Copy the entire InputStream to OutputStream. - * @param inputStream The stream to read from. - * @param outputStream The stream to write to. - * @return True if the entire stream copied successfully, false on error. - */ - private boolean copyStream(InputStream inputStream, - OutputStream outputStream) { - try { - // Temporary buffer to copy stream through. - byte[] buf = new byte[BUFFER_SIZE]; - for (;;) { - // Read up to BUFFER_SIZE bytes. - int bytes = inputStream.read(buf); - if (bytes < 0) { - break; - } - // Write the number of bytes we just read. - outputStream.write(buf, 0, bytes); - } - } catch (IOException ex) { - log("Got IOException copying stream: " + ex); - return false; + /** + * Given an URL, returns the CacheResult which contains the + * surrogate response for the request, or null if the handler is + * not interested. + * + * @param url URL string. + * @param headers The headers associated with the request. May be null. + * @return The CacheResult containing the surrogate response. + * @Deprecated Use PluginData getPluginData(String url, + * Map headers); instead + */ + @Deprecated + public CacheResult service(String url, Map headers) { + throw new UnsupportedOperationException("unimplemented"); } - return true; - } /** - * Given an URL, returns a CacheResult which contains the response - * for the request. This implements the UrlInterceptHandler interface. + * Given an URL, returns a PluginData instance which contains the + * response for the request. This implements the UrlInterceptHandler + * interface. * - * @param url The fully qualified URL being requested. + * @param url The fully qualified URL being requested. * @param requestHeaders The request headers for this URL. - * @return If a response can be crafted, a CacheResult initialized - * to return the surrogate response. If this URL cannot - * be serviced, returns null. + * @return a PluginData object. */ - public CacheResult service(String url, Map requestHeaders) { + public PluginData getPluginData(String url, Map requestHeaders) { // Thankfully the browser does call us with case-sensitive // headers. We just need to map it case-insensitive. Map lowercaseRequestHeaders = @@ -374,86 +366,10 @@ public class UrlInterceptHandlerGears implements UrlInterceptHandler { // No result for this URL. return null; } - // Translate the ServiceResponse to a CacheResult. - // Translate http -> gears, https -> gearss, so we don't overwrite - // existing entries. - String gearsUrl = "gears" + url.substring("http".length()); - // Set the result to expire, so that entries don't pollute the - // browser's cache for too long. - long now_ms = System.currentTimeMillis(); - String expires = DateUtils.formatDate(new Date(now_ms + CACHE_EXPIRY_MS)); - response.setResponseHeader(ApacheHttpRequestAndroid.KEY_EXPIRES, expires); - // The browser is only interested in a small subset of headers, - // contained in a Headers object. Iterate the map of all headers - // and add them to Headers. - Headers headers = new Headers(); - Iterator> responseHeadersIt = - response.getResponseHeaders().entrySet().iterator(); - while (responseHeadersIt.hasNext()) { - Map.Entry entry = responseHeadersIt.next(); - // Headers.parseHeader() expects lowercase keys. - String keyValue = entry.getKey() + ": " - + entry.getValue()[HEADERS_MAP_INDEX_VALUE]; - CharArrayBuffer buffer = new CharArrayBuffer(keyValue.length()); - buffer.append(keyValue); - // Parse it into the header container. - headers.parseHeader(buffer); - } - CacheResult cacheResult = CacheManager.createCacheFile( - gearsUrl, - response.getStatusCode(), - headers, - response.getMimeType(), - true); // forceCache - - if (cacheResult == null) { - // With the no-cache policy we could end up - // with a null result - return null; - } - - // Set encoding if specified. - String encoding = response.getEncoding(); - if (encoding != null) { - cacheResult.setEncoding(encoding); - } - // Copy the response body to the CacheResult. This handles all - // combinations of memory vs on-disk on both sides. - InputStream inputStream = response.getInputStream(); - OutputStream outputStream = cacheResult.getOutputStream(); - boolean copied = copyStream(inputStream, outputStream); - // Close the input and output streams to relinquish their - // resources earlier. - try { - inputStream.close(); - } catch (IOException ex) { - log("IOException closing InputStream: " + ex); - copied = false; - } - try { - outputStream.close(); - } catch (IOException ex) { - log("IOException closing OutputStream: " + ex); - copied = false; - } - if (!copied) { - log("copyStream of local result failed"); - return null; - } - // Save the entry into the browser's cache. - CacheManager.saveCacheFile(gearsUrl, cacheResult); - // Get it back from the cache, this time properly initialized to - // be used for input. - cacheResult = CacheManager.getCacheFile(gearsUrl, null); - if (cacheResult != null) { - log("Returning surrogate result"); - return cacheResult; - } else { - // Not an expected condition, but handle gracefully. Perhaps out - // of memory or disk? - Log.e(LOG_TAG, "Lost CacheResult between save and get. Can't serve.\n"); - return null; - } + return new PluginData(response.getInputStream(), + response.getContentLength(), + response.getResponseHeaders(), + response.getStatusCode()); } /** diff --git a/core/java/android/widget/AbsListView.java b/core/java/android/widget/AbsListView.java index 9da78d0d41990..d72570aca1c33 100644 --- a/core/java/android/widget/AbsListView.java +++ b/core/java/android/widget/AbsListView.java @@ -2766,6 +2766,7 @@ public abstract class AbsListView extends AdapterView implements Te private void showPopup() { // Make sure we have a window before showing the popup if (getWindowVisibility() == View.VISIBLE) { + createTextFilter(true); positionPopup(false); // Make sure we get focus if we are showing the popup checkFocus(); @@ -2913,8 +2914,8 @@ public abstract class AbsListView extends AdapterView implements Te if (mPopup == null) { Context c = getContext(); PopupWindow p = new PopupWindow(c); - LayoutInflater layoutInflater = (LayoutInflater) c - .getSystemService(Context.LAYOUT_INFLATER_SERVICE); + LayoutInflater layoutInflater = (LayoutInflater) + c.getSystemService(Context.LAYOUT_INFLATER_SERVICE); mTextFilter = (EditText) layoutInflater.inflate( com.android.internal.R.layout.typing_filter, null); mTextFilter.addTextChangedListener(this); @@ -3136,6 +3137,14 @@ public abstract class AbsListView extends AdapterView implements Te */ int viewType; + /** + * When this boolean is set, the view has been added to the AbsListView + * at least once. It is used to know whether headers/footers have already + * been added to the list view and whether they should be treated as + * recycled views or not. + */ + boolean recycledHeaderFooter; + public LayoutParams(Context c, AttributeSet attrs) { super(c, attrs); } @@ -3269,7 +3278,7 @@ public abstract class AbsListView extends AdapterView implements Te if (lp != null && lp.viewType != AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) { // Note: We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in active views. // However, we will NOT place them into scrap views. - activeViews[i] = getChildAt(i); + activeViews[i] = child; } } } diff --git a/core/java/android/widget/FastScroller.java b/core/java/android/widget/FastScroller.java index 57e21e4f7a41e..0a552e8cf2add 100644 --- a/core/java/android/widget/FastScroller.java +++ b/core/java/android/widget/FastScroller.java @@ -62,6 +62,8 @@ class FastScroller { private int mVisibleItem; private Paint mPaint; private int mListOffset; + private int mItemCount = -1; + private boolean mLongList; private Object [] mSections; private String mSectionText; @@ -219,8 +221,12 @@ class FastScroller { void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { - // Are there enough pages to require fast scroll? - if (visibleItemCount > 0 && totalItemCount / visibleItemCount < MIN_PAGES) { + // Are there enough pages to require fast scroll? Recompute only if total count changes + if (mItemCount != totalItemCount && visibleItemCount > 0) { + mItemCount = totalItemCount; + mLongList = mItemCount / visibleItemCount >= MIN_PAGES; + } + if (!mLongList) { if (mState != STATE_NONE) { setState(STATE_NONE); } diff --git a/core/java/android/widget/GridView.java b/core/java/android/widget/GridView.java index 6bbf062c3afec..11fab8f96a228 100644 --- a/core/java/android/widget/GridView.java +++ b/core/java/android/widget/GridView.java @@ -929,6 +929,7 @@ public class GridView extends AbsListView { if (p == null) { p = new AbsListView.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, 0); + child.setLayoutParams(p); } p.viewType = mAdapter.getItemViewType(0); @@ -1328,11 +1329,8 @@ public class GridView extends AbsListView { */ @Override void setSelectionInt(int position) { - mBlockLayoutRequests = true; setNextSelectedPositionInt(position); layoutChildren(); - - mBlockLayoutRequests = false; } @Override diff --git a/core/java/android/widget/ImageView.java b/core/java/android/widget/ImageView.java index a4523b92e1d92..480b0b8a135a2 100644 --- a/core/java/android/widget/ImageView.java +++ b/core/java/android/widget/ImageView.java @@ -333,6 +333,12 @@ public class ImageView extends View { resizeFromDrawable(); } + /** + * Sets the image level, when it is constructed from a + * {@link android.graphics.drawable.LevelListDrawable}. + * + * @param level The new level for the image. + */ @android.view.RemotableViewMethod public void setImageLevel(int level) { mLevel = level; diff --git a/core/java/android/widget/ListView.java b/core/java/android/widget/ListView.java index 404a4eef35398..c2f3a85c03577 100644 --- a/core/java/android/widget/ListView.java +++ b/core/java/android/widget/ListView.java @@ -26,7 +26,6 @@ import android.os.Parcel; import android.os.Parcelable; import android.util.AttributeSet; import android.util.SparseBooleanArray; -import android.util.SparseArray; import android.view.FocusFinder; import android.view.KeyEvent; import android.view.MotionEvent; @@ -1040,6 +1039,7 @@ public class ListView extends AbsListView { if (p == null) { p = new LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, 0); + child.setLayoutParams(p); } p.viewType = mAdapter.getItemViewType(position); @@ -1320,6 +1320,8 @@ public class ListView extends AbsListView { final boolean blockLayoutRequests = mBlockLayoutRequests; if (!blockLayoutRequests) { mBlockLayoutRequests = true; + } else { + return; } try { @@ -1429,15 +1431,12 @@ public class ListView extends AbsListView { // we can remember the focused view to restore after relayout if the // data hasn't changed, or if the focused position is a header or footer if (!dataChanged || isDirectChildHeaderOrFooter(focusedChild)) { - focusLayoutRestoreDirectChild = getFocusedChild(); - if (focusLayoutRestoreDirectChild != null) { - - // remember the specific view that had focus - focusLayoutRestoreView = findFocus(); - if (focusLayoutRestoreView != null) { - // tell it we are going to mess with it - focusLayoutRestoreView.onStartTemporaryDetach(); - } + focusLayoutRestoreDirectChild = focusedChild; + // remember the specific view that had focus + focusLayoutRestoreView = findFocus(); + if (focusLayoutRestoreView != null) { + // tell it we are going to mess with it + focusLayoutRestoreView.onStartTemporaryDetach(); } } requestFocus(); @@ -1657,9 +1656,12 @@ public class ListView extends AbsListView { } p.viewType = mAdapter.getItemViewType(position); - if (recycled) { + if (recycled || (p.recycledHeaderFooter && p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER)) { attachViewToParent(child, flowDown ? -1 : 0, p); } else { + if (p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) { + p.recycledHeaderFooter = true; + } addViewInLayout(child, flowDown ? -1 : 0, p, true); } @@ -1766,10 +1768,8 @@ public class ListView extends AbsListView { */ @Override void setSelectionInt(int position) { - mBlockLayoutRequests = true; setNextSelectedPositionInt(position); layoutChildren(); - mBlockLayoutRequests = false; } /** diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java index 080f3deb62941..3f4912f3c9fdf 100644 --- a/core/java/android/widget/TextView.java +++ b/core/java/android/widget/TextView.java @@ -33,6 +33,7 @@ import android.os.Bundle; import android.os.Handler; import android.os.Parcel; import android.os.Parcelable; +import android.os.ResultReceiver; import android.os.SystemClock; import android.os.Message; import android.text.BoringLayout; @@ -234,6 +235,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener private CharWrapper mCharWrapper = null; private boolean mSelectionMoved = false; + private boolean mTouchFocusSelectedAll = false; private Marquee mMarquee; private boolean mRestartMarquee; @@ -837,6 +839,11 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener if (password) { setTransformationMethod(PasswordTransformationMethod.getInstance()); typefaceIndex = MONOSPACE; + } else if ((mInputType&(EditorInfo.TYPE_MASK_CLASS + |EditorInfo.TYPE_MASK_VARIATION)) + == (EditorInfo.TYPE_CLASS_TEXT + |EditorInfo.TYPE_TEXT_VARIATION_PASSWORD)) { + typefaceIndex = MONOSPACE; } setTypefaceByIndex(typefaceIndex, styleIndex); @@ -2244,6 +2251,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener int selEnd; CharSequence text; boolean frozenWithFocus; + CharSequence error; SavedState(Parcelable superState) { super(superState); @@ -2256,6 +2264,13 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener out.writeInt(selEnd); out.writeInt(frozenWithFocus ? 1 : 0); TextUtils.writeToParcel(text, out, flags); + + if (error == null) { + out.writeInt(0); + } else { + out.writeInt(1); + TextUtils.writeToParcel(error, out, flags); + } } @Override @@ -2286,6 +2301,10 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener selEnd = in.readInt(); frozenWithFocus = (in.readInt() != 0); text = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in); + + if (in.readInt() != 0) { + error = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in); + } } } @@ -2338,6 +2357,8 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener ss.frozenWithFocus = true; } + ss.error = mError; + return ss; } @@ -2383,6 +2404,10 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener } } } + + if (ss.error != null) { + setError(ss.error); + } } /** @@ -2799,8 +2824,9 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener */ public void setInputType(int type) { setInputType(type, false); - final boolean isPassword = (type&(EditorInfo.TYPE_MASK_CLASS - |EditorInfo.TYPE_MASK_VARIATION)) + final int variation = type&(EditorInfo.TYPE_MASK_CLASS + |EditorInfo.TYPE_MASK_VARIATION); + final boolean isPassword = variation == (EditorInfo.TYPE_CLASS_TEXT |EditorInfo.TYPE_TEXT_VARIATION_PASSWORD); boolean forceUpdate = false; @@ -2809,8 +2835,14 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener setTypefaceByIndex(MONOSPACE, 0); } else if (mTransformation == PasswordTransformationMethod.getInstance()) { // We need to clean up if we were previously in password mode. - setTypefaceByIndex(-1, -1); + if (variation != (EditorInfo.TYPE_CLASS_TEXT + |EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD)) { + setTypefaceByIndex(-1, -1); + } forceUpdate = true; + } else if (variation == (EditorInfo.TYPE_CLASS_TEXT + |EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD)) { + setTypefaceByIndex(MONOSPACE, 0); } boolean multiLine = (type&(EditorInfo.TYPE_MASK_CLASS @@ -2999,23 +3031,28 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener } } } - - if (actionCode == EditorInfo.IME_ACTION_NEXT && - (ict != null || !shouldAdvanceFocusOnEnter())) { - // This is the default handling for the NEXT action, to advance - // focus. Note that for backwards compatibility we don't do this + if (ict != null || !shouldAdvanceFocusOnEnter()) { + // This is the handling for some default action. + // Note that for backwards compatibility we don't do this // default handling if explicit ime options have not been given, - // and we do not advance by default on an enter key -- in that - // case, we want to turn this into the normal enter key codes that - // an app may be expecting. - View v = focusSearch(FOCUS_DOWN); - if (v != null) { - if (!v.requestFocus(FOCUS_DOWN)) { - throw new IllegalStateException("focus search returned a view " + - "that wasn't able to take focus!"); + // to instead turn this into the normal enter key codes that an + // app may be expecting. + if (actionCode == EditorInfo.IME_ACTION_NEXT) { + View v = focusSearch(FOCUS_DOWN); + if (v != null) { + if (!v.requestFocus(FOCUS_DOWN)) { + throw new IllegalStateException("focus search returned a view " + + "that wasn't able to take focus!"); + } + } + return; + + } else if (actionCode == EditorInfo.IME_ACTION_DONE) { + InputMethodManager imm = InputMethodManager.peekInstance(); + if (imm != null) { + imm.hideSoftInputFromWindow(getWindowToken(), 0); } } - return; } Handler h = getHandler(); @@ -3998,7 +4035,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener * but also in mail addresses and subjects which will display on multiple * lines but where it doesn't make sense to insert newlines. */ - protected boolean shouldAdvanceFocusOnEnter() { + private boolean shouldAdvanceFocusOnEnter() { if (mInput == null) { return false; } @@ -4192,6 +4229,14 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener */ super.onKeyUp(keyCode, event); return true; + } else if ((event.getFlags() + & KeyEvent.FLAG_SOFT_KEYBOARD) != 0) { + // No target for next focus, but make sure the IME + // if this came from it. + InputMethodManager imm = InputMethodManager.peekInstance(); + if (imm != null) { + imm.hideSoftInputFromWindow(getWindowToken(), 0); + } } } @@ -4234,9 +4279,13 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener // An action has not been set, but the enter key will move to // the next focus, so set the action to that. outAttrs.imeOptions = EditorInfo.IME_ACTION_NEXT; - if (!shouldAdvanceFocusOnEnter()) { - outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_ENTER_ACTION; - } + } else { + // An action has not been set, and there is no focus to move + // to, so let's just supply a "done" action. + outAttrs.imeOptions = EditorInfo.IME_ACTION_DONE; + } + if (!shouldAdvanceFocusOnEnter()) { + outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_ENTER_ACTION; } } outAttrs.hintText = mHint; @@ -5977,6 +6026,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener if (mSelectAllOnFocus) { Selection.setSelection((Spannable) mText, 0, mText.length()); + mTouchFocusSelectedAll = true; } if (selMoved && selStart >= 0 && selEnd >= 0) { @@ -6078,12 +6128,32 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener } } + class CommitSelectionReceiver extends ResultReceiver { + int mNewStart; + int mNewEnd; + + CommitSelectionReceiver() { + super(getHandler()); + } + + protected void onReceiveResult(int resultCode, Bundle resultData) { + if (resultCode != InputMethodManager.RESULT_SHOWN) { + Selection.setSelection((Spannable)mText, mNewStart, mNewEnd); + } + } + } + @Override public boolean onTouchEvent(MotionEvent event) { + final int action = event.getAction(); + if (action == MotionEvent.ACTION_DOWN) { + // Reset this state; it will be re-set if super.onTouchEvent + // causes focus to move to the view. + mTouchFocusSelectedAll = false; + } + final boolean superResult = super.onTouchEvent(event); - final int action = event.getAction(); - /* * Don't handle the release after a long press, because it will * move the selection away from whatever the menu action was @@ -6100,17 +6170,44 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener mScrolled = false; } - boolean moved = mMovement.onTouchEvent(this, (Spannable) mText, event); + boolean handled = false; + + int oldSelStart = Selection.getSelectionStart(mText); + int oldSelEnd = Selection.getSelectionEnd(mText); + + handled |= mMovement.onTouchEvent(this, (Spannable) mText, event); if (mText instanceof Editable && onCheckIsTextEditor()) { if (action == MotionEvent.ACTION_UP && isFocused() && !mScrolled) { InputMethodManager imm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE); - imm.showSoftInput(this, 0); + + // This is going to be gross... if tapping on the text view + // causes the IME to be displayed, we don't want the selection + // to change. But the selection has already changed, and + // we won't know right away whether the IME is getting + // displayed, so... + + int newSelStart = Selection.getSelectionStart(mText); + int newSelEnd = Selection.getSelectionEnd(mText); + CommitSelectionReceiver csr = null; + if (newSelStart != oldSelStart || newSelEnd != oldSelEnd) { + csr = new CommitSelectionReceiver(); + csr.mNewStart = newSelStart; + csr.mNewEnd = newSelEnd; + } + + if (imm.showSoftInput(this, 0, csr) && csr != null) { + // The IME might get shown -- revert to the old + // selection, and change to the new when we finally + // find out of it is okay. + Selection.setSelection((Spannable)mText, oldSelStart, oldSelEnd); + handled = true; + } } } - if (moved) { + if (handled) { return true; } } @@ -6118,6 +6215,15 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener return superResult; } + /** + * Returns true, only while processing a touch gesture, if the initial + * touch down event caused focus to move to the text view and as a result + * it selected all of its text. + */ + public boolean didTouchFocusSelectAll() { + return mTouchFocusSelectedAll; + } + @Override public void cancelLongPress() { super.cancelLongPress(); diff --git a/core/java/android/widget/ZoomRing.java b/core/java/android/widget/ZoomRing.java index a5a867b4e91bf..83a1225aed456 100644 --- a/core/java/android/widget/ZoomRing.java +++ b/core/java/android/widget/ZoomRing.java @@ -1,9 +1,26 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package android.widget; import com.android.internal.R; import android.content.Context; import android.content.res.Resources; +import android.content.res.TypedArray; import android.graphics.Canvas; import android.graphics.drawable.Drawable; import android.graphics.drawable.RotateDrawable; @@ -18,36 +35,47 @@ import android.view.View; import android.view.ViewConfiguration; /** + * A view that has a draggable thumb on a circle. + * * @hide */ public class ZoomRing extends View { - - // TODO: move to ViewConfiguration? - static final int DOUBLE_TAP_DISMISS_TIMEOUT = ViewConfiguration.getDoubleTapTimeout(); - // TODO: get from theme private static final String TAG = "ZoomRing"; // TODO: Temporary until the trail is done private static final boolean DRAW_TRAIL = false; - // TODO: xml - private static final int THUMB_DISTANCE = 63; - - /** To avoid floating point calculations, we multiply radians by this value. */ + /** + * To avoid floating point calculations and int round-offs, we multiply + * radians by this value. + */ public static final int RADIAN_INT_MULTIPLIER = 10000; + /** The allowable margin of error when comparing two angles. */ public static final int RADIAN_INT_ERROR = 100; - /** PI using our multiplier. */ public static final int PI_INT_MULTIPLIED = (int) (Math.PI * RADIAN_INT_MULTIPLIER); public static final int TWO_PI_INT_MULTIPLIED = PI_INT_MULTIPLIED * 2; - /** PI/2 using our multiplier. */ private static final int HALF_PI_INT_MULTIPLIED = PI_INT_MULTIPLIED / 2; - private int mZeroAngle = HALF_PI_INT_MULTIPLIED * 3; - + private static final int DOUBLE_TAP_DISMISS_TIMEOUT = ViewConfiguration.getDoubleTapTimeout(); + private final int mTouchSlop; + + /** The slop when the user is grabbing the thumb. */ private static final int THUMB_GRAB_SLOP = PI_INT_MULTIPLIED / 8; + /** The slop until a user starts dragging the thumb. */ private static final int THUMB_DRAG_SLOP = PI_INT_MULTIPLIED / 12; + /** The distance (in px) from the center of the ring to the center of the thumb. */ + private int mThumbDistance; + + /** The angle on a unit circle that is considered to be the zoom ring's 0 degree. */ + private int mZeroAngle = HALF_PI_INT_MULTIPLIED * 3; + /** + * The maximum delta angle that the thumb can move. The primary use is to + * ensure that when a user taps on the ring, the movement to reach that + * target angle is not ambiguous (for example, if the thumb is at 0 and he + * taps 180, should the thumb go clockwise or counterclockwise? + *

* Includes error because we compare this to the result of * getDelta(getClosestTickeAngle(..), oldAngle) which ends up having some * rounding error. @@ -55,58 +83,93 @@ public class ZoomRing extends View { private static final int MAX_ABS_JUMP_DELTA_ANGLE = (2 * PI_INT_MULTIPLIED / 3) + RADIAN_INT_ERROR; - /** The cached X of our center. */ + /** The cached X of the zoom ring's center (in zoom ring coordinates). */ private int mCenterX; - /** The cached Y of our center. */ + /** The cached Y of the zoom ring's center (in zoom ring coordinates). */ private int mCenterY; /** The angle of the thumb (in int radians) */ private int mThumbAngle; + /** The cached width/2 of the zoom ring. */ private int mThumbHalfWidth; + /** The cached height/2 of the zoom ring. */ private int mThumbHalfHeight; + /** + * The bound for the thumb's movement when it is being dragged clockwise. + * Can be Integer.MIN_VALUE if there is no bound in this direction. + */ private int mThumbCwBound = Integer.MIN_VALUE; + /** + * The bound for the thumb's movement when it is being dragged + * counterclockwise. Can be Integer.MIN_VALUE if there is no bound in this + * direction. + */ private int mThumbCcwBound = Integer.MIN_VALUE; + + /** + * Whether to enforce the maximum absolute jump delta. See + * {@link #MAX_ABS_JUMP_DELTA_ANGLE}. + */ private boolean mEnforceMaxAbsJump = true; /** The inner radius of the track. */ - private int mBoundInnerRadiusSquared = 0; + private int mTrackInnerRadius; + /** Cached square of the inner radius of the track. */ + private int mTrackInnerRadiusSquared; /** The outer radius of the track. */ - private int mBoundOuterRadiusSquared = Integer.MAX_VALUE; + private int mTrackOuterRadius; + /** Cached square of the outer radius of the track. */ + private int mTrackOuterRadiusSquared; + /** The raw X of where the widget previously was located. */ private int mPreviousWidgetDragX; + /** The raw Y of where the widget previously was located. */ private int mPreviousWidgetDragY; + /** Whether the thumb should be visible. */ private boolean mThumbVisible = true; + + /** The drawable for the thumb. */ private Drawable mThumbDrawable; /** Shown beneath the thumb if we can still zoom in. */ - private Drawable mThumbPlusArrowDrawable; + private Drawable mZoomInArrowDrawable; /** Shown beneath the thumb if we can still zoom out. */ - private Drawable mThumbMinusArrowDrawable; + private Drawable mZoomOutArrowDrawable; + + /** @see #mThumbArrowsToDraw */ private static final int THUMB_ARROW_PLUS = 1 << 0; + /** @see #mThumbArrowsToDraw */ private static final int THUMB_ARROW_MINUS = 1 << 1; /** Bitwise-OR of {@link #THUMB_ARROW_MINUS} and {@link #THUMB_ARROW_PLUS} */ private int mThumbArrowsToDraw; + + /** The duration for the thumb arrows fading out */ private static final int THUMB_ARROWS_FADE_DURATION = 300; + /** The time when the fade out started. */ private long mThumbArrowsFadeStartTime; + /** The current alpha for the thumb arrows. */ private int mThumbArrowsAlpha = 255; - private static final int THUMB_PLUS_MINUS_DISTANCE = 69; - private static final int THUMB_PLUS_MINUS_OFFSET_ANGLE = TWO_PI_INT_MULTIPLIED / 11; + /** The distance from the center to the zoom arrow hints (usually plus and minus). */ + private int mZoomArrowHintDistance; + /** The offset angle from the thumb angle to draw the zoom arrow hints. */ + private int mZoomArrowHintOffsetAngle = TWO_PI_INT_MULTIPLIED / 11; /** Drawn (without rotation) on top of the arrow. */ - private Drawable mThumbPlusDrawable; + private Drawable mZoomInArrowHintDrawable; /** Drawn (without rotation) on top of the arrow. */ - private Drawable mThumbMinusDrawable; + private Drawable mZoomOutArrowHintDrawable; + /** Zoom ring is just chillin' */ private static final int MODE_IDLE = 0; - /** * User has his finger down somewhere on the ring (besides the thumb) and we * are waiting for him to move the slop amount before considering him in the * drag thumb state. */ private static final int MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP = 5; + /** User is dragging the thumb. */ private static final int MODE_DRAG_THUMB = 1; /** * User has his finger down, but we are waiting for him to pass the touch @@ -114,51 +177,65 @@ public class ZoomRing extends View { * show the movable hint. */ private static final int MODE_WAITING_FOR_MOVE_ZOOM_RING = 4; + /** User is moving the zoom ring. */ private static final int MODE_MOVE_ZOOM_RING = 2; + /** User is dragging the thumb via tap-drag. */ private static final int MODE_TAP_DRAG = 3; /** Ignore the touch interaction until the user touches the thumb again. */ private static final int MODE_IGNORE_UNTIL_TOUCHES_THUMB = 6; + /** The current mode of interaction. */ private int mMode; - /** Records the last mode the user was in. */ private int mPreviousMode; - + + /** The previous time of the up-touch on the center. */ private long mPreviousCenterUpTime; + /** The previous X of down-touch. */ private int mPreviousDownX; + /** The previous Y of down-touch. */ private int mPreviousDownY; - private int mWaitingForDragThumbDownAngle; + /** The angle where the user first grabbed the thumb. */ + private int mInitialGrabThumbAngle; + /** The callback. */ private OnZoomRingCallback mCallback; - private int mPreviousCallbackAngle; - private int mCallbackThreshold = Integer.MAX_VALUE; + /** The tick angle that we previously called back with. */ + private int mPreviousCallbackTickAngle; + /** The delta angle between ticks. A tick is a callback point. */ + private int mTickDelta = Integer.MAX_VALUE; /** If the user drags to within __% of a tick, snap to that tick. */ - private int mFuzzyCallbackThreshold = Integer.MAX_VALUE; + private int mFuzzyTickDelta = Integer.MAX_VALUE; - private boolean mResetThumbAutomatically = true; + /** The angle where the thumb is officially starting to be dragged. */ private int mThumbDragStartAngle; - private final int mTouchSlop; - + /** The drawable for the zoom trail. */ private Drawable mTrail; + /** The accumulated angle for the trail. */ private double mAcculumalatedTrailAngle; + /** The animation-step tracker for scrolling the thumb to a particular position. */ private Scroller mThumbScroller; + /** Whether to ever vibrate when passing a tick. */ private boolean mVibration = true; - private static final int MSG_THUMB_SCROLLER_TICK = 1; - private static final int MSG_THUMB_ARROWS_FADE_TICK = 2; + /** The drawable used to hint that this can pan its owner. */ + private Drawable mPanningArrowsDrawable; + + private static final int MSG_THUMB_SCROLLER_STEP = 1; + private static final int MSG_THUMB_ARROWS_FADE_STEP = 2; private Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { - case MSG_THUMB_SCROLLER_TICK: - onThumbScrollerTick(); + case MSG_THUMB_SCROLLER_STEP: + onThumbScrollerStep(); break; - case MSG_THUMB_ARROWS_FADE_TICK: - onThumbArrowsFadeTick(); + case MSG_THUMB_ARROWS_FADE_STEP: + onThumbArrowsFadeStep(); break; } } @@ -170,50 +247,64 @@ public class ZoomRing extends View { ViewConfiguration viewConfiguration = ViewConfiguration.get(context); mTouchSlop = viewConfiguration.getScaledTouchSlop(); - // TODO get drawables from style instead + TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ZoomRing, defStyle, 0); + mThumbDistance = (int) a.getDimension(R.styleable.ZoomRing_thumbDistance, 0); + setTrackRadii( + (int) a.getDimension(R.styleable.ZoomRing_trackInnerRadius, 0), + (int) a.getDimension(R.styleable.ZoomRing_trackOuterRadius, Integer.MAX_VALUE)); + mThumbDrawable = a.getDrawable(R.styleable.ZoomRing_thumbDrawable); + mZoomInArrowDrawable = a.getDrawable(R.styleable.ZoomRing_zoomInArrowDrawable); + mZoomOutArrowDrawable = a.getDrawable(R.styleable.ZoomRing_zoomOutArrowDrawable); + mZoomInArrowHintDrawable = a.getDrawable(R.styleable.ZoomRing_zoomInArrowHintDrawable); + mZoomOutArrowHintDrawable = a.getDrawable(R.styleable.ZoomRing_zoomOutArrowHintDrawable); + mZoomArrowHintDistance = + (int) a.getDimension(R.styleable.ZoomRing_zoomArrowHintDistance, 0); + mZoomArrowHintOffsetAngle = + (int) (a.getInteger(R.styleable.ZoomRing_zoomArrowHintOffsetAngle, 0) + * TWO_PI_INT_MULTIPLIED / 360); + mPanningArrowsDrawable = a.getDrawable(R.styleable.ZoomRing_panningArrowsDrawable); + a.recycle(); + Resources res = context.getResources(); - mThumbDrawable = res.getDrawable(R.drawable.zoom_ring_thumb); - mThumbPlusArrowDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_plus_arrow_rotatable). - mutate(); - mThumbMinusArrowDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_minus_arrow_rotatable). - mutate(); - mThumbPlusDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_plus); - mThumbMinusDrawable = res.getDrawable(R.drawable.zoom_ring_thumb_minus); if (DRAW_TRAIL) { + // TODO get drawables from style instead mTrail = res.getDrawable(R.drawable.zoom_ring_trail).mutate(); } - // TODO: add padding to drawable - setBackgroundResource(R.drawable.zoom_ring_track); - // TODO get from style - setRingBounds(43, Integer.MAX_VALUE); - mThumbHalfHeight = mThumbDrawable.getIntrinsicHeight() / 2; mThumbHalfWidth = mThumbDrawable.getIntrinsicWidth() / 2; - setCallbackThreshold(PI_INT_MULTIPLIED / 6); + setTickDelta(PI_INT_MULTIPLIED / 6); } public ZoomRing(Context context, AttributeSet attrs) { - this(context, attrs, 0); + this(context, attrs, com.android.internal.R.attr.zoomRingStyle); } public ZoomRing(Context context) { this(context, null); } + public void setTrackDrawable(Drawable drawable) { + setBackgroundDrawable(drawable); + } + public void setCallback(OnZoomRingCallback callback) { mCallback = callback; } - // TODO: rename - public void setCallbackThreshold(int callbackThreshold) { - mCallbackThreshold = callbackThreshold; - mFuzzyCallbackThreshold = (int) (callbackThreshold * 0.65f); + /** + * Sets the distance between ticks. This will be used as a callback threshold. + * + * @param angle The angle between ticks. + */ + public void setTickDelta(int angle) { + mTickDelta = angle; + mFuzzyTickDelta = (int) (angle * 0.65f); } - public void setVibration(boolean vibrate) { - mVibration = vibrate; + public void setVibration(boolean vibration) { + mVibration = vibration; } public void setThumbVisible(boolean thumbVisible) { @@ -223,28 +314,42 @@ public class ZoomRing extends View { } } - // TODO: from XML too - public void setRingBounds(int innerRadius, int outerRadius) { - mBoundInnerRadiusSquared = innerRadius * innerRadius; - if (mBoundInnerRadiusSquared < innerRadius) { + public Drawable getPanningArrowsDrawable() { + return mPanningArrowsDrawable; + } + + public void setTrackRadii(int innerRadius, int outerRadius) { + mTrackInnerRadius = innerRadius; + mTrackOuterRadius = outerRadius; + + mTrackInnerRadiusSquared = innerRadius * innerRadius; + if (mTrackInnerRadiusSquared < innerRadius) { // Prevent overflow - mBoundInnerRadiusSquared = Integer.MAX_VALUE; + mTrackInnerRadiusSquared = Integer.MAX_VALUE; } - mBoundOuterRadiusSquared = outerRadius * outerRadius; - if (mBoundOuterRadiusSquared < outerRadius) { + mTrackOuterRadiusSquared = outerRadius * outerRadius; + if (mTrackOuterRadiusSquared < outerRadius) { // Prevent overflow - mBoundOuterRadiusSquared = Integer.MAX_VALUE; + mTrackOuterRadiusSquared = Integer.MAX_VALUE; } } + public int getTrackInnerRadius() { + return mTrackInnerRadius; + } + + public int getTrackOuterRadius() { + return mTrackOuterRadius; + } + public void setThumbClockwiseBound(int angle) { if (angle < 0) { mThumbCwBound = Integer.MIN_VALUE; } else { mThumbCwBound = getClosestTickAngle(angle); } - setEnforceMaxAbsJump(); + updateEnforceMaxAbsJump(); } public void setThumbCounterclockwiseBound(int angle) { @@ -253,14 +358,14 @@ public class ZoomRing extends View { } else { mThumbCcwBound = getClosestTickAngle(angle); } - setEnforceMaxAbsJump(); + updateEnforceMaxAbsJump(); } - private void setEnforceMaxAbsJump() { + private void updateEnforceMaxAbsJump() { // If there are bounds in both direction, there is no reason to restrict // the amount that a user can absolute jump to mEnforceMaxAbsJump = - mThumbCcwBound == Integer.MIN_VALUE || mThumbCwBound == Integer.MIN_VALUE; + mThumbCcwBound == Integer.MIN_VALUE || mThumbCwBound == Integer.MIN_VALUE; } public int getThumbAngle() { @@ -269,7 +374,7 @@ public class ZoomRing extends View { public void setThumbAngle(int angle) { angle = getValidAngle(angle); - mPreviousCallbackAngle = getClosestTickAngle(angle); + mPreviousCallbackTickAngle = getClosestTickAngle(angle); setThumbAngleAuto(angle, false, false); } @@ -299,9 +404,9 @@ public class ZoomRing extends View { mThumbAngle = angle; int unoffsetAngle = angle + mZeroAngle; int thumbCenterX = (int) (Math.cos(1f * unoffsetAngle / RADIAN_INT_MULTIPLIER) * - THUMB_DISTANCE) + mCenterX; + mThumbDistance) + mCenterX; int thumbCenterY = (int) (Math.sin(1f * unoffsetAngle / RADIAN_INT_MULTIPLIER) * - THUMB_DISTANCE) * -1 + mCenterY; + mThumbDistance) * -1 + mCenterY; mThumbDrawable.setBounds(thumbCenterX - mThumbHalfWidth, thumbCenterY - mThumbHalfHeight, @@ -356,7 +461,7 @@ public class ZoomRing extends View { duration = getAnimationDuration(deltaAngle); } mThumbScroller.startScroll(startAngle, 0, deltaAngle, 0, duration); - onThumbScrollerTick(); + onThumbScrollerStep(); } private int getAnimationDuration(int deltaAngle) { @@ -364,10 +469,10 @@ public class ZoomRing extends View { return 300 + deltaAngle * 300 / RADIAN_INT_MULTIPLIER; } - private void onThumbScrollerTick() { + private void onThumbScrollerStep() { if (!mThumbScroller.computeScrollOffset()) return; setThumbAngleInt(getThumbScrollerAngle()); - mHandler.sendEmptyMessage(MSG_THUMB_SCROLLER_TICK); + mHandler.sendEmptyMessage(MSG_THUMB_SCROLLER_STEP); } private int getThumbScrollerAngle() { @@ -375,16 +480,10 @@ public class ZoomRing extends View { } public void resetThumbAngle() { - if (mResetThumbAutomatically) { - mPreviousCallbackAngle = 0; - setThumbAngleInt(0); - } + mPreviousCallbackTickAngle = 0; + setThumbAngleInt(0); } - public void setResetThumbAutomatically(boolean resetThumbAutomatically) { - mResetThumbAutomatically = resetThumbAutomatically; - } - @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { setMeasuredDimension(resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec), @@ -411,14 +510,12 @@ public class ZoomRing extends View { } // These drawables are the same size as the track - mThumbPlusArrowDrawable.setBounds(0, 0, right - left, bottom - top); - mThumbMinusArrowDrawable.setBounds(0, 0, right - left, bottom - top); + mZoomInArrowDrawable.setBounds(0, 0, right - left, bottom - top); + mZoomOutArrowDrawable.setBounds(0, 0, right - left, bottom - top); } @Override public boolean onTouchEvent(MotionEvent event) { -// Log.d(TAG, "History size: " + event.getHistorySize()); - return handleTouch(event.getAction(), event.getEventTime(), (int) event.getX(), (int) event.getY(), (int) event.getRawX(), (int) event.getRawY()); @@ -457,15 +554,10 @@ public class ZoomRing extends View { boolean isTouchingRing = mThumbVisible; int touchAngle = getAngle(localX, localY); -// printAngle("touchAngle", touchAngle); -// printAngle("mThumbAngle", mThumbAngle); -// printAngle("mPreviousCallbackAngle", mPreviousCallbackAngle); -// Log.d(TAG, ""); - int radiusSquared = localX * localX + localY * localY; - if (radiusSquared < mBoundInnerRadiusSquared || - radiusSquared > mBoundOuterRadiusSquared) { + if (radiusSquared < mTrackInnerRadiusSquared || + radiusSquared > mTrackOuterRadiusSquared) { // Out-of-bounds isTouchingThumb = false; isTouchingRing = false; @@ -486,7 +578,7 @@ public class ZoomRing extends View { if (!isTouchingRing && (time - mPreviousCenterUpTime <= DOUBLE_TAP_DISMISS_TIMEOUT)) { // Make sure the double-tap is in the center of the widget (and not on the ring) - mCallback.onZoomRingDismissed(true); + mCallback.onZoomRingDismissed(); onTouchUp(time, isTouchingRing); // Dismissing, so halt here @@ -557,7 +649,7 @@ public class ZoomRing extends View { } setMode(MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP); - mWaitingForDragThumbDownAngle = touchAngle; + mInitialGrabThumbAngle = touchAngle; boolean ccw = deltaThumbAndTick > 0; setThumbAngleAnimated(tickAngle, 0, ccw); @@ -577,9 +669,9 @@ public class ZoomRing extends View { } } else if (mMode == MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP) { - int deltaDownAngle = getDelta(mWaitingForDragThumbDownAngle, touchAngle); + int deltaDownAngle = getDelta(mInitialGrabThumbAngle, touchAngle); if ((deltaDownAngle < -THUMB_DRAG_SLOP || deltaDownAngle > THUMB_DRAG_SLOP) && - isDeltaInBounds(mWaitingForDragThumbDownAngle, deltaDownAngle)) { + isDeltaInBounds(mInitialGrabThumbAngle, deltaDownAngle)) { setMode(MODE_DRAG_THUMB); // No need to call onThumbDragStarted, since that was done when they tapped-to-jump @@ -591,6 +683,8 @@ public class ZoomRing extends View { /* Make sure the user has moved the slop amount before going into that mode. */ setMode(MODE_MOVE_ZOOM_RING); mCallback.onZoomRingMovingStarted(); + // Move the zoom ring so it is under the finger where the user first touched + mCallback.onZoomRingMoved(x - mPreviousDownX, y - mPreviousDownY, rawX, rawY); } } else if (mMode == MODE_IGNORE_UNTIL_TOUCHES_THUMB) { if (isTouchingThumb) { @@ -629,7 +723,7 @@ public class ZoomRing extends View { if (mode == MODE_DRAG_THUMB || mode == MODE_TAP_DRAG) { // Animate back to a tick - setThumbAngleAnimated(mPreviousCallbackAngle, 0); + setThumbAngleAnimated(mPreviousCallbackTickAngle, 0); } } mCallback.onUserInteractionStopped(); @@ -741,9 +835,9 @@ public class ZoomRing extends View { boolean animateThumbToNewAngle = false; int totalDeltaAngle; - totalDeltaAngle = getDelta(mPreviousCallbackAngle, touchAngle, useDirection, ccw); - if (totalDeltaAngle >= mFuzzyCallbackThreshold - || totalDeltaAngle <= -mFuzzyCallbackThreshold) { + totalDeltaAngle = getDelta(mPreviousCallbackTickAngle, touchAngle, useDirection, ccw); + if (totalDeltaAngle >= mFuzzyTickDelta + || totalDeltaAngle <= -mFuzzyTickDelta) { if (!useDirection) { // Set ccw to match the direction found by getDelta @@ -763,9 +857,9 @@ public class ZoomRing extends View { if (ccw && mThumbCcwBound != Integer.MIN_VALUE) { int deltaCcwBoundAndTouch = getDelta(mThumbCcwBound, touchAngle, useDirection, true); - if (deltaCcwBoundAndTouch >= mCallbackThreshold / 2) { + if (deltaCcwBoundAndTouch >= mTickDelta / 2) { // The touch has past a bound - int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackAngle, + int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackTickAngle, touchAngle, useDirection, true); if (deltaPreviousCbAndTouch >= deltaCcwBoundAndTouch) { // The bound is between the previous callback angle and the touch @@ -778,8 +872,8 @@ public class ZoomRing extends View { // See block above for general comments int deltaCwBoundAndTouch = getDelta(mThumbCwBound, touchAngle, useDirection, false); - if (deltaCwBoundAndTouch <= -mCallbackThreshold / 2) { - int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackAngle, + if (deltaCwBoundAndTouch <= -mTickDelta / 2) { + int deltaPreviousCbAndTouch = getDelta(mPreviousCallbackTickAngle, touchAngle, useDirection, false); /* * Both of these will be negative since we got delta in @@ -795,7 +889,7 @@ public class ZoomRing extends View { } if (touchAngle != oldTouchAngle) { // We bounded the touch angle - totalDeltaAngle = getDelta(mPreviousCallbackAngle, touchAngle, useDirection, ccw); + totalDeltaAngle = getDelta(mPreviousCallbackTickAngle, touchAngle, useDirection, ccw); animateThumbToNewAngle = true; setMode(MODE_IGNORE_UNTIL_TOUCHES_THUMB); } @@ -819,7 +913,7 @@ public class ZoomRing extends View { * hit. If we do int division, we'll end up with one level lower * than the one he was going for. */ - int deltaLevels = Math.round((float) totalDeltaAngle / mCallbackThreshold); + int deltaLevels = Math.round((float) totalDeltaAngle / mTickDelta); if (deltaLevels != 0) { boolean canStillZoom = mCallback.onZoomRingThumbDragged( deltaLevels, mThumbDragStartAngle, touchAngle); @@ -833,8 +927,8 @@ public class ZoomRing extends View { } // Set the callback angle to the actual angle based on how many delta levels we gave - mPreviousCallbackAngle = getValidAngle( - mPreviousCallbackAngle + (deltaLevels * mCallbackThreshold)); + mPreviousCallbackTickAngle = getValidAngle( + mPreviousCallbackTickAngle + (deltaLevels * mTickDelta)); } } @@ -993,14 +1087,14 @@ public class ZoomRing extends View { } private int getClosestTickAngle(int angle) { - int smallerAngleDistance = angle % mCallbackThreshold; + int smallerAngleDistance = angle % mTickDelta; int smallerAngle = angle - smallerAngleDistance; - if (smallerAngleDistance < mCallbackThreshold / 2) { + if (smallerAngleDistance < mTickDelta / 2) { // Closer to the smaller angle return smallerAngle; } else { // Closer to the bigger angle (premodding) - return (smallerAngle + mCallbackThreshold) % TWO_PI_INT_MULTIPLIED; + return (smallerAngle + mTickDelta) % TWO_PI_INT_MULTIPLIED; } } @@ -1025,7 +1119,7 @@ public class ZoomRing extends View { super.onWindowFocusChanged(hasWindowFocus); if (!hasWindowFocus) { - mCallback.onZoomRingDismissed(true); + mCallback.onZoomRingDismissed(); } } @@ -1054,12 +1148,12 @@ public class ZoomRing extends View { mTrail.draw(canvas); } if ((mThumbArrowsToDraw & THUMB_ARROW_PLUS) != 0) { - mThumbPlusArrowDrawable.draw(canvas); - mThumbPlusDrawable.draw(canvas); + mZoomInArrowDrawable.draw(canvas); + mZoomInArrowHintDrawable.draw(canvas); } if ((mThumbArrowsToDraw & THUMB_ARROW_MINUS) != 0) { - mThumbMinusArrowDrawable.draw(canvas); - mThumbMinusDrawable.draw(canvas); + mZoomOutArrowDrawable.draw(canvas); + mZoomOutArrowHintDrawable.draw(canvas); } mThumbDrawable.draw(canvas); } @@ -1067,48 +1161,48 @@ public class ZoomRing extends View { private void setThumbArrowsAngle(int angle) { int level = -angle * 10000 / ZoomRing.TWO_PI_INT_MULTIPLIED; - mThumbPlusArrowDrawable.setLevel(level); - mThumbMinusArrowDrawable.setLevel(level); + mZoomInArrowDrawable.setLevel(level); + mZoomOutArrowDrawable.setLevel(level); // Assume it is a square - int halfSideLength = mThumbPlusDrawable.getIntrinsicHeight() / 2; + int halfSideLength = mZoomInArrowHintDrawable.getIntrinsicHeight() / 2; int unoffsetAngle = angle + mZeroAngle; - int plusCenterX = (int) (Math.cos(1f * (unoffsetAngle - THUMB_PLUS_MINUS_OFFSET_ANGLE) - / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) + mCenterX; - int plusCenterY = (int) (Math.sin(1f * (unoffsetAngle - THUMB_PLUS_MINUS_OFFSET_ANGLE) - / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) * -1 + mCenterY; - mThumbPlusDrawable.setBounds(plusCenterX - halfSideLength, + int plusCenterX = (int) (Math.cos(1f * (unoffsetAngle - mZoomArrowHintOffsetAngle) + / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) + mCenterX; + int plusCenterY = (int) (Math.sin(1f * (unoffsetAngle - mZoomArrowHintOffsetAngle) + / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) * -1 + mCenterY; + mZoomInArrowHintDrawable.setBounds(plusCenterX - halfSideLength, plusCenterY - halfSideLength, plusCenterX + halfSideLength, plusCenterY + halfSideLength); - int minusCenterX = (int) (Math.cos(1f * (unoffsetAngle + THUMB_PLUS_MINUS_OFFSET_ANGLE) - / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) + mCenterX; - int minusCenterY = (int) (Math.sin(1f * (unoffsetAngle + THUMB_PLUS_MINUS_OFFSET_ANGLE) - / RADIAN_INT_MULTIPLIER) * THUMB_PLUS_MINUS_DISTANCE) * -1 + mCenterY; - mThumbMinusDrawable.setBounds(minusCenterX - halfSideLength, + int minusCenterX = (int) (Math.cos(1f * (unoffsetAngle + mZoomArrowHintOffsetAngle) + / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) + mCenterX; + int minusCenterY = (int) (Math.sin(1f * (unoffsetAngle + mZoomArrowHintOffsetAngle) + / RADIAN_INT_MULTIPLIER) * mZoomArrowHintDistance) * -1 + mCenterY; + mZoomOutArrowHintDrawable.setBounds(minusCenterX - halfSideLength, minusCenterY - halfSideLength, minusCenterX + halfSideLength, minusCenterY + halfSideLength); } - public void setThumbArrowsVisible(boolean visible) { + void setThumbArrowsVisible(boolean visible) { if (visible) { mThumbArrowsAlpha = 255; - int callbackAngle = mPreviousCallbackAngle; + int callbackAngle = mPreviousCallbackTickAngle; if (callbackAngle < mThumbCwBound - RADIAN_INT_ERROR || callbackAngle > mThumbCwBound + RADIAN_INT_ERROR) { - mThumbPlusArrowDrawable.setAlpha(255); - mThumbPlusDrawable.setAlpha(255); + mZoomInArrowDrawable.setAlpha(255); + mZoomInArrowHintDrawable.setAlpha(255); mThumbArrowsToDraw |= THUMB_ARROW_PLUS; } else { mThumbArrowsToDraw &= ~THUMB_ARROW_PLUS; } if (callbackAngle < mThumbCcwBound - RADIAN_INT_ERROR || callbackAngle > mThumbCcwBound + RADIAN_INT_ERROR) { - mThumbMinusArrowDrawable.setAlpha(255); - mThumbMinusDrawable.setAlpha(255); + mZoomOutArrowDrawable.setAlpha(255); + mZoomOutArrowHintDrawable.setAlpha(255); mThumbArrowsToDraw |= THUMB_ARROW_MINUS; } else { mThumbArrowsToDraw &= ~THUMB_ARROW_MINUS; @@ -1117,11 +1211,11 @@ public class ZoomRing extends View { } else if (mThumbArrowsAlpha == 255) { // Only start fade if we're fully visible (otherwise another fade is happening already) mThumbArrowsFadeStartTime = SystemClock.elapsedRealtime(); - onThumbArrowsFadeTick(); + onThumbArrowsFadeStep(); } } - private void onThumbArrowsFadeTick() { + private void onThumbArrowsFadeStep() { if (mThumbArrowsAlpha <= 0) { mThumbArrowsToDraw = 0; return; @@ -1132,20 +1226,20 @@ public class ZoomRing extends View { / THUMB_ARROWS_FADE_DURATION)); if (mThumbArrowsAlpha < 0) mThumbArrowsAlpha = 0; if ((mThumbArrowsToDraw & THUMB_ARROW_PLUS) != 0) { - mThumbPlusArrowDrawable.setAlpha(mThumbArrowsAlpha); - mThumbPlusDrawable.setAlpha(mThumbArrowsAlpha); - invalidateDrawable(mThumbPlusDrawable); - invalidateDrawable(mThumbPlusArrowDrawable); + mZoomInArrowDrawable.setAlpha(mThumbArrowsAlpha); + mZoomInArrowHintDrawable.setAlpha(mThumbArrowsAlpha); + invalidateDrawable(mZoomInArrowHintDrawable); + invalidateDrawable(mZoomInArrowDrawable); } if ((mThumbArrowsToDraw & THUMB_ARROW_MINUS) != 0) { - mThumbMinusArrowDrawable.setAlpha(mThumbArrowsAlpha); - mThumbMinusDrawable.setAlpha(mThumbArrowsAlpha); - invalidateDrawable(mThumbMinusDrawable); - invalidateDrawable(mThumbMinusArrowDrawable); + mZoomOutArrowDrawable.setAlpha(mThumbArrowsAlpha); + mZoomOutArrowHintDrawable.setAlpha(mThumbArrowsAlpha); + invalidateDrawable(mZoomOutArrowHintDrawable); + invalidateDrawable(mZoomOutArrowDrawable); } - if (!mHandler.hasMessages(MSG_THUMB_ARROWS_FADE_TICK)) { - mHandler.sendEmptyMessage(MSG_THUMB_ARROWS_FADE_TICK); + if (!mHandler.hasMessages(MSG_THUMB_ARROWS_FADE_STEP)) { + mHandler.sendEmptyMessage(MSG_THUMB_ARROWS_FADE_STEP); } } @@ -1168,7 +1262,7 @@ public class ZoomRing extends View { boolean onZoomRingThumbDragged(int numLevels, int startAngle, int curAngle); void onZoomRingThumbDraggingStopped(); - void onZoomRingDismissed(boolean dismissImmediately); + void onZoomRingDismissed(); void onUserInteractionStarted(); void onUserInteractionStopped(); diff --git a/core/java/android/widget/ZoomRingController.java b/core/java/android/widget/ZoomRingController.java index 19f66a0c873c9..3bf3b227dba04 100644 --- a/core/java/android/widget/ZoomRingController.java +++ b/core/java/android/widget/ZoomRingController.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 The Android Open Source Project + * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,7 +30,8 @@ import android.os.Handler; import android.os.Message; import android.os.SystemClock; import android.provider.Settings; -import android.util.Log; +import android.util.DisplayMetrics; +import android.view.GestureDetector; import android.view.Gravity; import android.view.KeyEvent; import android.view.LayoutInflater; @@ -44,11 +45,9 @@ import android.view.animation.Animation; import android.view.animation.AnimationUtils; import android.view.animation.DecelerateInterpolator; -// TODO: make sure no px values exist, only dip (scale if necessary from Viewconfiguration) - /** - * TODO: Docs - * + * A controller to simplify the use of the zoom ring widget. + *

* If you are using this with a custom View, please call * {@link #setVisible(boolean) setVisible(false)} from the * {@link View#onDetachedFromWindow}. @@ -58,13 +57,7 @@ import android.view.animation.DecelerateInterpolator; public class ZoomRingController implements ZoomRing.OnZoomRingCallback, View.OnTouchListener, View.OnKeyListener { - private static final int ZOOM_RING_RADIUS_INSET = 24; - - private static final int ZOOM_RING_RECENTERING_DURATION = 500; - - private static final String TAG = "ZoomRing"; - - public static final boolean USE_OLD_ZOOM = false; + // Temporary methods for different zoom types static int getZoomType(Context context) { return Settings.System.getInt(context.getContentResolver(), "zoom", 1); } @@ -75,19 +68,43 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return getZoomType(context) == 1; } - private static final int ZOOM_CONTROLS_TIMEOUT = - (int) ViewConfiguration.getZoomControlsTimeout(); + /** The duration for the animation to re-center the zoom ring. */ + private static final int RECENTERING_DURATION = 500; - // TODO: move these to ViewConfiguration or re-use existing ones - // TODO: scale px values based on latest from ViewConfiguration - private static final int SECOND_TAP_TIMEOUT = 500; - private static final int ZOOM_RING_DISMISS_DELAY = SECOND_TAP_TIMEOUT / 2; - // TODO: view config? at least scaled - private static final int MAX_PAN_GAP = 20; - private static final int MAX_INITIATE_PAN_GAP = 10; - // TODO view config + /** The inactivity timeout for the zoom ring. */ + private static final int INACTIVITY_TIMEOUT = + (int) ViewConfiguration.getZoomControlsTimeout(); + + /** + * The delay when the user taps outside to dismiss the zoom ring. This is + * because the user can do a second-tap to recenter the owner view instead + * of dismissing the zoom ring. + */ + private static final int OUTSIDE_TAP_DISMISS_DELAY = + ViewConfiguration.getDoubleTapTimeout() / 2; + + /** + * When the zoom ring is on the edge, this is the delay before we actually + * start panning the owner. + * @see #mInitiatePanGap + */ private static final int INITIATE_PAN_DELAY = 300; + /** + * While already panning, if the zoom ring remains this close to an edge, + * the owner will continue to be panned. + */ + private int mPanGap; + + /** To begin a pan, the zoom ring must be this close to an edge. */ + private int mInitiatePanGap; + + /** Initialized from ViewConfiguration. */ + private int mScaledTouchSlop; + + /** + * The setting name that tracks whether we've shown the zoom ring toast. + */ private static final String SETTING_NAME_SHOWN_TOAST = "shown_zoom_ring_toast"; private Context mContext; @@ -137,25 +154,37 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, * screen once (for the first tap down) instead of twice (for the first tap * down and then to grab the thumb). */ + /** The X where the tap-drag started. */ private int mTapDragStartX; + /** The Y where the tap-drag started. */ private int mTapDragStartY; + /** The controller is idle */ private static final int TOUCH_MODE_IDLE = 0; - private static final int TOUCH_MODE_WAITING_FOR_SECOND_TAP = 1; + /** + * In the middle of a second-tap interaction, waiting for either an up-touch + * or the user to start dragging to go into tap-drag mode. + */ private static final int TOUCH_MODE_WAITING_FOR_TAP_DRAG_MOVEMENT = 2; + /** In the middle of a tap-drag. */ private static final int TOUCH_MODE_FORWARDING_FOR_TAP_DRAG = 3; private int mTouchMode; + /** Whether the zoom ring is visible. */ private boolean mIsZoomRingVisible; private ZoomRing mZoomRing; + /** Cached width of the zoom ring. */ private int mZoomRingWidth; + /** Cached height of the zoom ring. */ private int mZoomRingHeight; /** Invokes panning of owner view if the zoom ring is touching an edge. */ private Panner mPanner; + /** The time when the zoom ring first touched the edge. */ private long mTouchingEdgeStartTime; - private boolean mPanningEnabledForThisInteraction; + /** Whether the user has already initiated the panning. */ + private boolean mPanningInitiated; /** * When the finger moves the zoom ring to an edge, this is the horizontal @@ -167,16 +196,21 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, /** Vertical accumulator, see {@link #mMovingZoomRingOobX} */ private int mMovingZoomRingOobY; + /** Arrows that hint that the zoom ring is movable. */ private ImageView mPanningArrows; + /** The animation shown when the panning arrows are being shown. */ private Animation mPanningArrowsEnterAnimation; + /** The animation shown when the panning arrows are being hidden. */ private Animation mPanningArrowsExitAnimation; + /** + * Temporary rectangle, only use from the UI thread (and ideally don't rely + * on it being unused across many method calls.) + */ private Rect mTempRect = new Rect(); private OnZoomListener mCallback; - private ViewConfiguration mViewConfig; - /** * When the zoom ring is centered on screen, this will be the x value used * for the container's layout params. @@ -217,6 +251,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, private IntentFilter mConfigurationChangedFilter = new IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED); + /** Listens for configuration changes so we can make sure we're still in a reasonable state. */ private BroadcastReceiver mConfigurationChangedReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { @@ -228,7 +263,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, }; /** Keeps the scroller going (or starts it). */ - private static final int MSG_SCROLLER_TICK = 1; + private static final int MSG_SCROLLER_STEP = 1; /** When configuration changes, this is called after the UI thread is idle. */ private static final int MSG_POST_CONFIGURATION_CHANGED = 2; /** Used to delay the zoom ring dismissal. */ @@ -244,8 +279,8 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, @Override public void handleMessage(Message msg) { switch (msg.what) { - case MSG_SCROLLER_TICK: - onScrollerTick(); + case MSG_SCROLLER_STEP: + onScrollerStep(); break; case MSG_POST_CONFIGURATION_CHANGED: @@ -296,8 +331,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, mContainerLayoutParams.width = LayoutParams.WRAP_CONTENT; mContainerLayoutParams.type = LayoutParams.TYPE_APPLICATION_PANEL; mContainerLayoutParams.format = PixelFormat.TRANSPARENT; - // TODO: make a new animation for this - mContainerLayoutParams.windowAnimations = com.android.internal.R.style.Animation_Dialog; + mContainerLayoutParams.windowAnimations = com.android.internal.R.style.Animation_ZoomRing; mContainer = new FrameLayout(context); mContainer.setLayoutParams(mContainerLayoutParams); @@ -308,13 +342,17 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, mScroller = new Scroller(context, new DecelerateInterpolator()); - mViewConfig = ViewConfiguration.get(context); + ViewConfiguration vc = ViewConfiguration.get(context); + mScaledTouchSlop = vc.getScaledTouchSlop(); + + float density = context.getResources().getDisplayMetrics().density; + mPanGap = (int) (20 * density); + mInitiatePanGap = (int) (10 * density); } private void createPanningArrows() { - // TODO: style mPanningArrows = new ImageView(mContext); - mPanningArrows.setImageResource(com.android.internal.R.drawable.zoom_ring_arrows); + mPanningArrows.setImageDrawable(mZoomRing.getPanningArrowsDrawable()); mPanningArrows.setLayoutParams(new FrameLayout.LayoutParams( FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT, @@ -328,15 +366,16 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } /** - * Sets the angle (in radians) a user must travel in order for the client to - * get a callback. Once there is a callback, the accumulator resets. For - * example, if you set this to PI/6, it will give a callback every time the - * user moves PI/6 amount on the ring. - * - * @param callbackThreshold The angle for the callback threshold, in radians + * Sets the angle (in radians) between ticks. This is also the angle a user + * must move the thumb in order for the client to get a callback. Once there + * is a callback, the accumulator resets. For example, if you set this to + * PI/6, it will give a callback every time the user moves PI/6 amount on + * the ring. + * + * @param angle The angle for the callback threshold, in radians */ - public void setZoomCallbackThreshold(float callbackThreshold) { - mZoomRing.setCallbackThreshold((int) (callbackThreshold * ZoomRing.RADIAN_INT_MULTIPLIER)); + public void setTickDelta(float angle) { + mZoomRing.setTickDelta((int) (angle * ZoomRing.RADIAN_INT_MULTIPLIER)); } /** @@ -346,14 +385,23 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, * @hide Need a better way of doing this, but this one-off for browser so it * can have its final look for the usability study */ - public void setZoomRingTrack(int drawable) { + public void setTrackDrawable(int drawable) { mZoomRing.setBackgroundResource(drawable); } - + + /** + * Sets the callback for the zoom ring controller. + * + * @param callback The callback. + */ public void setCallback(OnZoomListener callback) { mCallback = callback; } + public void setVibration(boolean vibrate) { + mZoomRing.setVibration(vibrate); + } + public void setThumbAngle(float angle) { mZoomRing.setThumbAngle((int) (angle * ZoomRing.RADIAN_INT_MULTIPLIER)); } @@ -362,14 +410,6 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, mZoomRing.setThumbAngleAnimated((int) (angle * ZoomRing.RADIAN_INT_MULTIPLIER), 0); } - public void setResetThumbAutomatically(boolean resetThumbAutomatically) { - mZoomRing.setResetThumbAutomatically(resetThumbAutomatically); - } - - public void setVibration(boolean vibrate) { - mZoomRing.setVibration(vibrate); - } - public void setThumbVisible(boolean thumbVisible) { mZoomRing.setThumbVisible(thumbVisible); } @@ -407,7 +447,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return; } - dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT); + dismissZoomRingDelayed(INACTIVITY_TIMEOUT); } else { mPanner.stop(); } @@ -429,12 +469,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, public void run() { refreshPositioningVariables(); resetZoomRing(); - - // TODO: remove this 'update' and just center zoom ring before the - // 'add', but need to make sure we have the width and height (which - // probably can only be retrieved after it's measured, which happens - // after it's added). - mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams); + refreshContainerLayout(); if (mCallback != null) { mCallback.onVisibilityChanged(true); @@ -479,19 +514,34 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } + private void refreshContainerLayout() { + if (mIsZoomRingVisible) { + mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams); + } + } + /** - * TODO: docs - * + * Returns the container of the zoom ring widget. The client can add views + * here to be shown alongside the zoom ring. See {@link #getZoomRingId()}. + *

* Notes: - * - Touch dispatching is different. Only direct children who are clickable are eligble for touch events. - * - Please ensure you set your View to INVISIBLE not GONE when hiding it. - * - * @return + *

    + *
  • The controller dispatches touch events differently than the regular view + * framework. + *
  • Please ensure you set your view to INVISIBLE not GONE when hiding it. + *
+ * + * @return The layout used by the container. */ public FrameLayout getContainer() { return mContainer; } + /** + * Returns the id of the zoom ring widget. + * + * @return The id of the zoom ring widget. + */ public int getZoomRingId() { return mZoomRing.getId(); } @@ -514,7 +564,10 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, /** * Should be called by the client for each event belonging to the second tap * (the down, move, up, and cancel events). - * + *

+ * In most cases, the client can use a {@link GestureDetector} and forward events from + * {@link GestureDetector.OnDoubleTapListener#onDoubleTapEvent(MotionEvent)}. + * * @param event The event belonging to the second tap. * @return Whether the event was consumed. */ @@ -550,9 +603,9 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, case MotionEvent.ACTION_MOVE: int x = (int) event.getX(); int y = (int) event.getY(); - if (Math.abs(x - mTapDragStartX) > mViewConfig.getScaledTouchSlop() || + if (Math.abs(x - mTapDragStartX) > mScaledTouchSlop || Math.abs(y - mTapDragStartY) > - mViewConfig.getScaledTouchSlop()) { + mScaledTouchSlop) { mZoomRing.setTapDragMode(true, x, y); mTouchMode = TOUCH_MODE_FORWARDING_FOR_TAP_DRAG; setTouchTargetView(mZoomRing); @@ -600,8 +653,8 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, int width = mContainer.getWidth(); int height = mContainer.getHeight(); mScroller.startScroll(lp.x, lp.y, mCenteredContainerX - lp.x, - mCenteredContainerY - lp.y, ZOOM_RING_RECENTERING_DURATION); - mHandler.sendEmptyMessage(MSG_SCROLLER_TICK); + mCenteredContainerY - lp.y, RECENTERING_DURATION); + mHandler.sendEmptyMessage(MSG_SCROLLER_STEP); } } @@ -636,18 +689,22 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, mZoomRing.handleTouch(event.getAction(), event.getEventTime(), x, y, rawX, rawY); } + /** @hide */ public void onZoomRingSetMovableHintVisible(boolean visible) { setPanningArrowsVisible(visible); } + /** @hide */ public void onUserInteractionStarted() { mHandler.removeMessages(MSG_DISMISS_ZOOM_RING); } + /** @hide */ public void onUserInteractionStopped() { - dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT); + dismissZoomRingDelayed(INACTIVITY_TIMEOUT); } + /** @hide */ public void onZoomRingMovingStarted() { mScroller.abortAnimation(); mTouchingEdgeStartTime = 0; @@ -664,6 +721,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, mPanningArrows.setVisibility(visible ? View.VISIBLE : View.INVISIBLE); } + /** @hide */ public boolean onZoomRingMoved(int deltaX, int deltaY, int rawX, int rawY) { if (mMovingZoomRingOobX != 0) { @@ -721,12 +779,12 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, ownerBounds.bottom - mZoomRingHeight : newZoomRingY; lp.y = newZoomRingY - zoomRingTop; - mWindowManager.updateViewLayout(mContainer, lp); - + refreshContainerLayout(); + // Check for pan boolean horizontalPanning = true; int leftGap = newZoomRingX - ownerBounds.left; - if (leftGap < MAX_PAN_GAP) { + if (leftGap < mPanGap) { if (leftGap == 0 && deltaX != 0 && mMovingZoomRingOobX == 0) { // Future moves in this direction should be accumulated in mMovingZoomRingOobX mMovingZoomRingOobX = deltaX / Math.abs(deltaX); @@ -736,7 +794,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } } else { int rightGap = ownerBounds.right - (lp.x + mZoomRingWidth + zoomRingLeft); - if (rightGap < MAX_PAN_GAP) { + if (rightGap < mPanGap) { if (rightGap == 0 && deltaX != 0 && mMovingZoomRingOobX == 0) { mMovingZoomRingOobX = deltaX / Math.abs(deltaX); } @@ -750,7 +808,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } int topGap = newZoomRingY - ownerBounds.top; - if (topGap < MAX_PAN_GAP) { + if (topGap < mPanGap) { if (topGap == 0 && deltaY != 0 && mMovingZoomRingOobY == 0) { mMovingZoomRingOobY = deltaY / Math.abs(deltaY); } @@ -759,7 +817,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } } else { int bottomGap = ownerBounds.bottom - (lp.y + mZoomRingHeight + zoomRingTop); - if (bottomGap < MAX_PAN_GAP) { + if (bottomGap < mPanGap) { if (bottomGap == 0 && deltaY != 0 && mMovingZoomRingOobY == 0) { mMovingZoomRingOobY = deltaY / Math.abs(deltaY); } @@ -771,7 +829,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, if (!horizontalPanning) { // Neither are panning, reset any timer to start pan mode mTouchingEdgeStartTime = 0; - mPanningEnabledForThisInteraction = false; + mPanningInitiated = false; mPanner.stop(); } } @@ -781,13 +839,13 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } private boolean shouldPan(int gap) { - if (mPanningEnabledForThisInteraction) return true; + if (mPanningInitiated) return true; - if (gap < MAX_INITIATE_PAN_GAP) { + if (gap < mInitiatePanGap) { long time = SystemClock.elapsedRealtime(); if (mTouchingEdgeStartTime != 0 && mTouchingEdgeStartTime + INITIATE_PAN_DELAY < time) { - mPanningEnabledForThisInteraction = true; + mPanningInitiated = true; return true; } else if (mTouchingEdgeStartTime == 0) { mTouchingEdgeStartTime = time; @@ -800,6 +858,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return false; } + /** @hide */ public void onZoomRingMovingStopped() { mPanner.stop(); setPanningArrowsVisible(false); @@ -809,27 +868,25 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } private int getStrengthFromGap(int gap) { - return gap > MAX_PAN_GAP ? 0 : - (MAX_PAN_GAP - gap) * 100 / MAX_PAN_GAP; + return gap > mPanGap ? 0 : + (mPanGap - gap) * 100 / mPanGap; } + /** @hide */ public void onZoomRingThumbDraggingStarted() { if (mCallback != null) { mCallback.onBeginDrag(); } } + /** @hide */ public boolean onZoomRingThumbDragged(int numLevels, int startAngle, int curAngle) { if (mCallback != null) { int deltaZoomLevel = -numLevels; - int globalZoomCenterX = mContainerLayoutParams.x + mZoomRing.getLeft() + - mZoomRingWidth / 2; - int globalZoomCenterY = mContainerLayoutParams.y + mZoomRing.getTop() + - mZoomRingHeight / 2; return mCallback.onDragZoom(deltaZoomLevel, - globalZoomCenterX - mOwnerViewBounds.left, - globalZoomCenterY - mOwnerViewBounds.top, + getZoomRingCenterXInOwnerCoordinates(), + getZoomRingCenterYInOwnerCoordinates(), (float) startAngle / ZoomRing.RADIAN_INT_MULTIPLIER, (float) curAngle / ZoomRing.RADIAN_INT_MULTIPLIER); } @@ -837,24 +894,36 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return false; } + private int getZoomRingCenterXInOwnerCoordinates() { + int globalZoomCenterX = mContainerLayoutParams.x + mZoomRing.getLeft() + + mZoomRingWidth / 2; + return globalZoomCenterX - mOwnerViewBounds.left; + } + + private int getZoomRingCenterYInOwnerCoordinates() { + int globalZoomCenterY = mContainerLayoutParams.y + mZoomRing.getTop() + + mZoomRingHeight / 2; + return globalZoomCenterY - mOwnerViewBounds.top; + } + + /** @hide */ public void onZoomRingThumbDraggingStopped() { if (mCallback != null) { mCallback.onEndDrag(); } } - public void onZoomRingDismissed(boolean dismissImmediately) { - if (dismissImmediately) { - mHandler.removeMessages(MSG_DISMISS_ZOOM_RING); - setVisible(false); - } else { - dismissZoomRingDelayed(ZOOM_RING_DISMISS_DELAY); - } + /** @hide */ + public void onZoomRingDismissed() { + mHandler.removeMessages(MSG_DISMISS_ZOOM_RING); + setVisible(false); } + /** @hide */ public void onRingDown(int tickAngle, int touchAngle) { } + /** @hide */ public boolean onTouch(View v, MotionEvent event) { if (sTutorialDialog != null && sTutorialDialog.isShowing() && SystemClock.elapsedRealtime() - sTutorialShowTime >= TUTORIAL_MIN_DISPLAY_TIME) { @@ -904,8 +973,9 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return retValue; } else { +// dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT); if (action == MotionEvent.ACTION_DOWN) { - dismissZoomRingDelayed(ZOOM_RING_DISMISS_DELAY); + dismissZoomRingDelayed(OUTSIDE_TAP_DISMISS_DELAY); } return false; @@ -932,7 +1002,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, int containerCenterY = mContainerLayoutParams.y + mContainer.getHeight() / 2; int distanceFromCenterX = rawX - containerCenterX; int distanceFromCenterY = rawY - containerCenterY; - int zoomRingRadius = mZoomRingWidth / 2 - ZOOM_RING_RADIUS_INSET; + int zoomRingRadius = mZoomRing.getTrackOuterRadius(); if (distanceFromCenterX * distanceFromCenterX + distanceFromCenterY * distanceFromCenterY <= zoomRingRadius * zoomRingRadius) { @@ -960,7 +1030,11 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return null; } - /** Steals key events from the owner view. */ + /** + * Steals key events from the owner view. + * + * @hide + */ public boolean onKey(View v, int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_DPAD_LEFT: @@ -971,12 +1045,14 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, case KeyEvent.KEYCODE_DPAD_UP: case KeyEvent.KEYCODE_DPAD_DOWN: // Keep the zoom alive a little longer - dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT); + dismissZoomRingDelayed(INACTIVITY_TIMEOUT); // They started zooming, hide the thumb arrows mZoomRing.setThumbArrowsVisible(false); if (mCallback != null && event.getAction() == KeyEvent.ACTION_DOWN) { - mCallback.onSimpleZoom(keyCode == KeyEvent.KEYCODE_DPAD_UP); + mCallback.onSimpleZoom(keyCode == KeyEvent.KEYCODE_DPAD_UP, + getZoomRingCenterXInOwnerCoordinates(), + getZoomRingCenterYInOwnerCoordinates()); } return true; @@ -985,18 +1061,18 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, return false; } - private void onScrollerTick() { + private void onScrollerStep() { if (!mScroller.computeScrollOffset() || !mIsZoomRingVisible) return; mContainerLayoutParams.x = mScroller.getCurrX(); mContainerLayoutParams.y = mScroller.getCurrY(); - mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams); + refreshContainerLayout(); - mHandler.sendEmptyMessage(MSG_SCROLLER_TICK); + mHandler.sendEmptyMessage(MSG_SCROLLER_STEP); } private void onPostConfigurationChanged() { - dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT); + dismissZoomRingDelayed(INACTIVITY_TIMEOUT); refreshPositioningVariables(); ensureZoomRingIsCentered(); } @@ -1056,6 +1132,7 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, sTutorialShowTime = SystemClock.elapsedRealtime(); } + /** @hide Should only be used by Android platform apps */ public static void finishZoomTutorial(Context context, boolean userNotified) { if (sTutorialDialog == null) return; @@ -1078,22 +1155,45 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } } + /** @hide Should only be used by Android platform apps */ public void finishZoomTutorial() { finishZoomTutorial(mContext, true); } + /** + * Sets the initial velocity of a pan. + * + * @param startVelocity The initial velocity to move the owner view, in + * pixels per second. + */ public void setPannerStartVelocity(float startVelocity) { mPanner.mStartVelocity = startVelocity; } + /** + * Sets the accelartion of the pan. + * + * @param acceleration The acceleration, in pixels per second squared. + */ public void setPannerAcceleration(float acceleration) { mPanner.mAcceleration = acceleration; } + /** + * Sets the maximum velocity of a pan. + * + * @param maxVelocity The max velocity to move the owner view, in pixels per + * second. + */ public void setPannerMaxVelocity(float maxVelocity) { mPanner.mMaxVelocity = maxVelocity; } + /** + * Sets the duration before acceleration will be applied. + * + * @param duration The duration, in milliseconds. + */ public void setPannerStartAcceleratingDuration(int duration) { mPanner.mStartAcceleratingDuration = duration; } @@ -1201,16 +1301,83 @@ public class ZoomRingController implements ZoomRing.OnZoomRingCallback, } + /** + * Interface used to inform the client of zoom events that the user + * triggers. + */ public interface OnZoomListener { + /** + * Called when the user begins dragging the thumb on the zoom ring. + */ void onBeginDrag(); + + /** + * Called when the user drags the thumb and passes a tick causing a + * zoom. + * + * @param deltaZoomLevel The number of levels to be zoomed. Positive to + * zoom in, negative to zoom out. + * @param centerX The point about which to zoom. The zoom should pin + * this point, leaving it at the same coordinate. This is + * relative to the owner view's upper-left. + * @param centerY The point about which to zoom. The zoom should pin + * this point, leaving it at the same coordinate. This is + * relative to the owner view's upper-left. + * @param startAngle The angle where the user started dragging the thumb. + * @param curAngle The current angle of the thumb. + * @return Whether the owner was zoomed. + */ boolean onDragZoom(int deltaZoomLevel, int centerX, int centerY, float startAngle, float curAngle); + + /** + * Called when the user releases the thumb. + */ void onEndDrag(); - void onSimpleZoom(boolean deltaZoomLevel); + + /** + * Called when the user zooms via some other mechanism, for example + * arrow keys or a trackball. + * + * @param zoomIn Whether to zoom in (true) or out (false). + * @param centerX See {@link #onDragZoom(int, int, int, float, float)}. + * @param centerY See {@link #onDragZoom(int, int, int, float, float)}. + */ + void onSimpleZoom(boolean zoomIn, int centerX, int centerY); + + /** + * Called when the user begins moving the zoom ring in order to pan the + * owner. + */ void onBeginPan(); + + /** + * Called when the owner should pan as a result of the user moving the zoom ring. + * + * @param deltaX The amount to pan horizontally. + * @param deltaY The amount to pan vertically. + * @return Whether the owner was panned. + */ boolean onPan(int deltaX, int deltaY); + + /** + * Called when the user releases the zoom ring. + */ void onEndPan(); + + /** + * Called when the client should center the owner on the given point. + * + * @param x The x to center on, relative to the owner view's upper-left. + * @param y The y to center on, relative to the owner view's upper-left. + */ void onCenter(int x, int y); + + /** + * Called when the zoom ring's visibility changes. + * + * @param visible Whether the zoom ring is visible (true) or not (false). + */ void onVisibilityChanged(boolean visible); } } diff --git a/core/java/com/android/internal/os/HandlerCaller.java b/core/java/com/android/internal/os/HandlerCaller.java index bab1e21812ae2..932555d15b9cb 100644 --- a/core/java/com/android/internal/os/HandlerCaller.java +++ b/core/java/com/android/internal/os/HandlerCaller.java @@ -120,6 +120,10 @@ public class HandlerCaller { return mH.obtainMessage(what, arg1, 0); } + public Message obtainMessageII(int what, int arg1, int arg2) { + return mH.obtainMessage(what, arg1, arg2); + } + public Message obtainMessageIO(int what, int arg1, Object arg2) { return mH.obtainMessage(what, arg1, 0, arg2); } diff --git a/core/java/com/android/internal/os/IResultReceiver.aidl b/core/java/com/android/internal/os/IResultReceiver.aidl new file mode 100644 index 0000000000000..2b70f95a5cf2a --- /dev/null +++ b/core/java/com/android/internal/os/IResultReceiver.aidl @@ -0,0 +1,25 @@ +/* //device/java/android/android/app/IActivityPendingResult.aidl +** +** Copyright 2009, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +package com.android.internal.os; + +import android.os.Bundle; + +/** @hide */ +oneway interface IResultReceiver { + void send(int resultCode, in Bundle resultData); +} diff --git a/core/java/com/android/internal/view/IInputMethod.aidl b/core/java/com/android/internal/view/IInputMethod.aidl index 9b004025ea9ae..8ff18ed69f846 100644 --- a/core/java/com/android/internal/view/IInputMethod.aidl +++ b/core/java/com/android/internal/view/IInputMethod.aidl @@ -18,6 +18,7 @@ package com.android.internal.view; import android.graphics.Rect; import android.os.IBinder; +import android.os.ResultReceiver; import android.view.KeyEvent; import android.view.MotionEvent; import android.view.inputmethod.EditorInfo; @@ -48,7 +49,7 @@ oneway interface IInputMethod { void revokeSession(IInputMethodSession session); - void showSoftInput(int flags); + void showSoftInput(int flags, in ResultReceiver resultReceiver); - void hideSoftInput(); + void hideSoftInput(int flags, in ResultReceiver resultReceiver); } diff --git a/core/java/com/android/internal/view/IInputMethodManager.aidl b/core/java/com/android/internal/view/IInputMethodManager.aidl index 1b1c7f78a7aff..9030a3e377c26 100644 --- a/core/java/com/android/internal/view/IInputMethodManager.aidl +++ b/core/java/com/android/internal/view/IInputMethodManager.aidl @@ -16,6 +16,7 @@ package com.android.internal.view; +import android.os.ResultReceiver; import android.view.inputmethod.InputMethodInfo; import android.view.inputmethod.EditorInfo; import com.android.internal.view.InputBindResult; @@ -38,8 +39,10 @@ interface IInputMethodManager { IInputContext inputContext, in EditorInfo attribute, boolean initial, boolean needResult); void finishInput(in IInputMethodClient client); - void showSoftInput(in IInputMethodClient client, int flags); - void hideSoftInput(in IInputMethodClient client, int flags); + boolean showSoftInput(in IInputMethodClient client, int flags, + in ResultReceiver resultReceiver); + boolean hideSoftInput(in IInputMethodClient client, int flags, + in ResultReceiver resultReceiver); void windowGainedFocus(in IInputMethodClient client, boolean viewHasFocus, boolean isTextEditor, int softInputMode, boolean first, int windowFlags); @@ -47,6 +50,7 @@ interface IInputMethodManager { void showInputMethodPickerFromClient(in IInputMethodClient client); void setInputMethod(in IBinder token, String id); void hideMySoftInput(in IBinder token, int flags); + void showMySoftInput(in IBinder token, int flags); void updateStatusIcon(in IBinder token, String packageName, int iconId); boolean setInputMethodEnabled(String id, boolean enabled); diff --git a/core/java/com/android/internal/view/IInputMethodSession.aidl b/core/java/com/android/internal/view/IInputMethodSession.aidl index 8a4497692d6e6..a05ff14bcccd6 100644 --- a/core/java/com/android/internal/view/IInputMethodSession.aidl +++ b/core/java/com/android/internal/view/IInputMethodSession.aidl @@ -46,4 +46,6 @@ oneway interface IInputMethodSession { void dispatchTrackballEvent(int seq, in MotionEvent event, IInputMethodCallback callback); void appPrivateCommand(String action, in Bundle data); + + void toggleSoftInput(int showFlags, int hideFlags); } diff --git a/core/java/com/android/internal/widget/EditStyledText.java b/core/java/com/android/internal/widget/EditStyledText.java new file mode 100644 index 0000000000000..48b47806a0bb7 --- /dev/null +++ b/core/java/com/android/internal/widget/EditStyledText.java @@ -0,0 +1,653 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.widget; + +import android.content.Context; +import android.text.Editable; +import android.text.Spannable; +import android.text.style.AbsoluteSizeSpan; +import android.text.style.ForegroundColorSpan; +import android.util.AttributeSet; +import android.util.Log; +import android.view.MotionEvent; +import android.widget.EditText; + +/** + * EditStyledText extends EditText for managing the flow and status + * to edit the styled text. This manages the states and flows of editing, + * supports inserting image, import/export HTML. + */ +public class EditStyledText extends EditText { + + private static final String LOG_TAG = "EditStyledText"; + private static final boolean DBG = true; + + /** + * The modes of editing actions. + */ + /** The mode that no editing action is done. */ + public static final int MODE_NOTHING = 0; + /** The mode of copy. */ + public static final int MODE_COPY = 1; + /** The mode of paste. */ + public static final int MODE_PASTE = 2; + /** The mode of changing size. */ + public static final int MODE_SIZE = 3; + /** The mode of changing color. */ + public static final int MODE_COLOR = 4; + /** The mode of selection. */ + public static final int MODE_SELECT = 5; + + /** + * The state of selection. + */ + /** The state that selection isn't started. */ + public static final int STATE_SELECT_OFF = 0; + /** The state that selection is started. */ + public static final int STATE_SELECT_ON = 1; + /** The state that selection is done, but not fixed. */ + public static final int STATE_SELECTED = 2; + /** The state that selection is done and not fixed.*/ + public static final int STATE_SELECT_FIX = 3; + + /** + * The help message strings. + */ + public static final int HINT_MSG_NULL = 0; + public static final int HINT_MSG_COPY_BUF_BLANK = 1; + public static final int HINT_MSG_SELECT_START = 2; + public static final int HINT_MSG_SELECT_END = 3; + public static final int HINT_MSG_PUSH_COMPETE = 4; + + + /** + * EditStyledTextInterface provides functions for notifying messages + * to calling class. + */ + public interface EditStyledTextInterface { + public void notifyHintMsg(int msg_id); + } + private EditStyledTextInterface mESTInterface; + + /** + * EditStyledTextEditorManager manages the flow and status of + * each function for editing styled text. + */ + private EditStyledTextEditorManager mManager; + + /** + * EditStyledText extends EditText for managing flow of each editing + * action. + */ + public EditStyledText(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + init(); + } + + public EditStyledText(Context context, AttributeSet attrs) { + super(context, attrs); + init(); + } + + public EditStyledText(Context context) { + super(context); + init(); + } + + /** + * Set View objects used in EditStyledText. + * @param helptext The view shows help messages. + */ + public void setParts(EditStyledTextInterface est_interface) { + mESTInterface = est_interface; + } + + @Override + public boolean onTouchEvent(MotionEvent event) { + final boolean superResult = super.onTouchEvent(event); + if (event.getAction() == MotionEvent.ACTION_UP) { + if (DBG) { + Log.d(LOG_TAG, "--- onTouchEvent"); + } + mManager.onTouchScreen(); + } + return superResult; + } + + /** + * Start editing. This function have to be called before other + * editing actions. + */ + public void onStartEdit() { + mManager.onStartEdit(); + } + + /** + * End editing. + */ + public void onEndEdit() { + mManager.onEndEdit(); + } + + /** + * Start "Copy" action. + */ + public void onStartCopy() { + mManager.onStartCopy(); + } + + /** + * Start "Paste" action. + */ + public void onStartPaste() { + mManager.onStartPaste(); + } + + /** + * Start changing "Size" action. + */ + public void onStartSize() { + mManager.onStartSize(); + } + + /** + * Start changing "Color" action. + */ + public void onStartColor() { + mManager.onStartColor(); + } + + /** + * Start "Select" action. + */ + public void onStartSelect() { + mManager.onStartSelect(); + } + + /** + * Start "SelectAll" action. + */ + public void onStartSelectAll() { + mManager.onStartSelectAll(); + } + + /** + * Fix Selected Item. + */ + public void fixSelectedItem() { + mManager.onFixSelectItem(); + } + + /** + * Set Size of the Item. + * @param size The size of the Item. + */ + public void setItemSize(int size) { + mManager.setItemSize(size); + } + + /** + * Set Color of the Item. + * @param color The color of the Item. + */ + public void setItemColor(int color) { + mManager.setItemColor(color); + } + + /** + * Check editing is started. + * @return Whether editing is started or not. + */ + public boolean isEditting() { + return mManager.isEditting(); + } + + /** + * Get the mode of the action. + * @return The mode of the action. + */ + public int getEditMode() { + return mManager.getEditMode(); + } + + /** + * Get the state of the selection. + * @return The state of the selection. + */ + public int getSelectState() { + return mManager.getSelectState(); + } + + /** + * Initialize members. + */ + private void init() { + if (DBG) { + Log.d(LOG_TAG, "--- init"); + requestFocus(); + } + mManager = new EditStyledTextEditorManager(this); + } + + /** + * Notify hint messages what action is expected to calling class. + * @param msg + */ + private void setHintMessage(int msg_id) { + if (mESTInterface != null) { + mESTInterface.notifyHintMsg(msg_id); + } + } + + /** + * Object which manages the flow and status of editing actions. + */ + private class EditStyledTextEditorManager { + private boolean mEditFlag = false; + private int mMode = 0; + private int mState = 0; + private int mCurStart = 0; + private int mCurEnd = 0; + private EditStyledText mEST; + private Editable mTextSelectBuffer; + private CharSequence mTextCopyBufer; + + EditStyledTextEditorManager(EditStyledText est) { + mEST = est; + } + + public void onStartEdit() { + if (DBG) { + Log.d(LOG_TAG, "--- onEdit"); + } + handleResetEdit(); + } + + public void onEndEdit() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickCancel"); + } + handleCancel(); + } + + public void onStartCopy() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickCopy"); + } + handleCopy(); + } + + public void onStartPaste() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickPaste"); + } + handlePaste(); + } + + public void onStartSize() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickSize"); + } + handleSize(); + } + + public void setItemSize(int size) { + if (DBG) { + Log.d(LOG_TAG, "--- onClickSizeItem"); + } + if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) { + changeSizeSelectedText(size); + handleResetEdit(); + } + } + + public void setItemColor(int color) { + if (DBG) { + Log.d(LOG_TAG, "--- onClickColorItem"); + } + if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) { + changeColorSelectedText(color); + handleResetEdit(); + } + } + + public void onStartColor() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickColor"); + } + handleColor(); + } + + public void onStartSelect() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickSelect"); + } + mMode = MODE_SELECT; + if (mState == STATE_SELECT_OFF) { + handleSelect(); + } else { + offSelect(); + handleSelect(); + } + } + + public void onStartSelectAll() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickSelectAll"); + } + handleSelectAll(); + } + + public void onTouchScreen() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickView"); + } + if (mState == STATE_SELECT_ON || mState == STATE_SELECTED) { + handleSelect(); + } + } + + public void onFixSelectItem() { + if (DBG) { + Log.d(LOG_TAG, "--- onClickComplete"); + } + handleComplete(); + } + + public boolean isEditting() { + return mEditFlag; + } + + public int getEditMode() { + return mMode; + } + + public int getSelectState() { + return mState; + } + + private void handleCancel() { + if (DBG) { + Log.d(LOG_TAG, "--- handleCancel"); + } + mMode = MODE_NOTHING; + mState = STATE_SELECT_OFF; + mEditFlag = false; + offSelect(); + } + + private void handleComplete() { + if (DBG) { + Log.d(LOG_TAG, "--- handleComplete"); + } + if (!mEditFlag) { + return; + } + if (mState == STATE_SELECTED) { + mState = STATE_SELECT_FIX; + } + switch (mMode) { + case MODE_COPY: + handleCopy(); + break; + default: + break; + } + } + + private void handleCopy() { + if (DBG) { + Log.d(LOG_TAG, "--- handleCopy: " + mMode + "," + mState); + } + if (!mEditFlag) { + return; + } + if (mMode == MODE_NOTHING || mMode == MODE_SELECT) { + mMode = MODE_COPY; + if (mState == STATE_SELECTED) { + mState = STATE_SELECT_FIX; + storeSelectedText(); + } else { + handleSelect(); + } + } else if (mMode != MODE_COPY) { + handleCancel(); + mMode = MODE_COPY; + handleCopy(); + } else if (mState == STATE_SELECT_FIX) { + mEST.setHintMessage(HINT_MSG_NULL); + storeSelectedText(); + handleResetEdit(); + } + } + + private void handlePaste() { + if (DBG) { + Log.d(LOG_TAG, "--- handlePaste"); + } + if (!mEditFlag) { + return; + } + if (mTextSelectBuffer != null && mTextCopyBufer.length() > 0) { + mTextSelectBuffer.insert(mEST.getSelectionStart(), + mTextCopyBufer); + } else { + mEST.setHintMessage(HINT_MSG_COPY_BUF_BLANK); + } + } + + private void handleSize() { + if (DBG) { + Log.d(LOG_TAG, "--- handleSize: " + mMode + "," + mState); + } + if (!mEditFlag) { + return; + } + if (mMode == MODE_NOTHING || mMode == MODE_SELECT) { + mMode = MODE_SIZE; + if (mState == STATE_SELECTED) { + mState = STATE_SELECT_FIX; + } else { + handleSelect(); + } + } else if (mMode != MODE_SIZE) { + handleCancel(); + mMode = MODE_SIZE; + handleSize(); + } else if (mState == STATE_SELECT_FIX) { + mEST.setHintMessage(HINT_MSG_NULL); + } + } + + private void handleColor() { + if (DBG) { + Log.d(LOG_TAG, "--- handleColor"); + } + if (!mEditFlag) { + return; + } + if (mMode == MODE_NOTHING || mMode == MODE_SELECT) { + mMode = MODE_COLOR; + if (mState == STATE_SELECTED) { + mState = STATE_SELECT_FIX; + } else { + handleSelect(); + } + } else if (mMode != MODE_COLOR) { + handleCancel(); + mMode = MODE_COLOR; + handleSize(); + } else if (mState == STATE_SELECT_FIX) { + mEST.setHintMessage(HINT_MSG_NULL); + } + } + + private void handleSelect() { + if (DBG) { + Log.d(LOG_TAG, "--- handleSelect" + mEditFlag + "," + mState); + } + if (!mEditFlag) { + return; + } + if (mState == STATE_SELECT_OFF) { + if (isTextSelected()) { + Log.e(LOG_TAG, "Selection state is off, but selected"); + } + setSelectStartPos(); + mEST.setHintMessage(HINT_MSG_SELECT_END); + } else if (mState == STATE_SELECT_ON) { + if (isTextSelected()) { + Log.e(LOG_TAG, "Selection state now start, but selected"); + } + setSelectEndPos(); + mEST.setHintMessage(HINT_MSG_PUSH_COMPETE); + doNextHandle(); + } else if (mState == STATE_SELECTED) { + if (!isTextSelected()) { + Log.e(LOG_TAG, + "Selection state is done, but not selected"); + } + setSelectEndPos(); + doNextHandle(); + } + } + + private void handleSelectAll() { + if (DBG) { + Log.d(LOG_TAG, "--- handleSelectAll"); + } + if (!mEditFlag) { + return; + } + mEST.selectAll(); + } + + private void doNextHandle() { + switch (mMode) { + case MODE_COPY: + handleCopy(); + break; + case MODE_PASTE: + handlePaste(); + break; + case MODE_SIZE: + handleSize(); + break; + case MODE_COLOR: + handleColor(); + break; + default: + break; + } + } + + private void handleResetEdit() { + handleCancel(); + mEditFlag = true; + mEST.setHintMessage(HINT_MSG_SELECT_START); + } + + // Methods of selection + private void onSelect() { + if (DBG) { + Log.d(LOG_TAG, "--- onSelect"); + } + if (mCurStart >= 0 && mCurStart <= mEST.getText().length() + && mCurEnd >= 0 && mCurEnd <= mEST.getText().length()) { + mEST.setSelection(mCurStart, mCurEnd); + mState = STATE_SELECTED; + } else { + Log.e(LOG_TAG, + "Select is on, but cursor positions are illigal.:" + + mEST.getText().length() + "," + mCurStart + + "," + mCurEnd); + } + } + + private void offSelect() { + if (DBG) { + Log.d(LOG_TAG, "--- offSelect"); + } + int currpos = mEST.getSelectionStart(); + mEST.setSelection(currpos, currpos); + mState = STATE_SELECT_OFF; + } + + private void setSelectStartPos() { + if (DBG) { + Log.d(LOG_TAG, "--- setSelectStartPos"); + } + mCurStart = mEST.getSelectionStart(); + mState = STATE_SELECT_ON; + } + + private void setSelectEndPos() { + if (DBG) { + Log.d(LOG_TAG, "--- setSelectEndPos:" + + mEST.getSelectionStart()); + } + int curpos = mEST.getSelectionStart(); + if (curpos < mCurStart) { + if (DBG) { + Log.d(LOG_TAG, "--- setSelectEndPos: swap is done."); + } + mCurEnd = mCurStart; + mCurStart = curpos; + } else { + mCurEnd = curpos; + } + onSelect(); + } + + private boolean isTextSelected() { + if (DBG) { + Log.d(LOG_TAG, "--- isTextSelected:" + mCurStart + "," + + mCurEnd); + } + return (mCurStart != mCurEnd) + && (mState == STATE_SELECTED || + mState == STATE_SELECT_FIX); + } + + private void storeSelectedText() { + if (DBG) { + Log.d(LOG_TAG, "--- storeSelectedText"); + } + mTextSelectBuffer = mEST.getText(); + mTextCopyBufer = mTextSelectBuffer.subSequence(mCurStart, mCurEnd); + } + + private void changeSizeSelectedText(int size) { + if (DBG) { + Log.d(LOG_TAG, "--- changeSizeSelectedText:" + size + "," + + mCurStart + "," + mCurEnd); + } + mEST.getText().setSpan(new AbsoluteSizeSpan(size), mCurStart, + mCurEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); + } + + private void changeColorSelectedText(int color) { + if (DBG) { + Log.d(LOG_TAG, "--- changeCollorSelectedText:" + color + "," + + mCurStart + "," + mCurEnd); + } + mEST.getText().setSpan(new ForegroundColorSpan(color), mCurStart, + mCurEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); + } + } + +} diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp index 32954cef63f13..e9514317b8f3c 100644 --- a/core/jni/android/graphics/Typeface.cpp +++ b/core/jni/android/graphics/Typeface.cpp @@ -32,11 +32,11 @@ static SkTypeface* Typeface_create(JNIEnv* env, jobject, jstring name, SkTypeface* face; if (NULL == name) { - face = SkTypeface::Create(NULL, (SkTypeface::Style)style); + face = SkTypeface::CreateFromName(NULL, (SkTypeface::Style)style); } else { AutoJavaStringToUTF8 str(env, name); - face = SkTypeface::Create(str.c_str(), style); + face = SkTypeface::CreateFromName(str.c_str(), style); } return face; } @@ -50,7 +50,7 @@ static void Typeface_unref(JNIEnv* env, jobject obj, SkTypeface* face) { } static int Typeface_getStyle(JNIEnv* env, jobject obj, SkTypeface* face) { - return face->getStyle(); + return face->style(); } class AssetStream : public SkStream { diff --git a/core/jni/android_text_format_Time.cpp b/core/jni/android_text_format_Time.cpp index 8e41ec76a8014..923e1aa05cc83 100644 --- a/core/jni/android_text_format_Time.cpp +++ b/core/jni/android_text_format_Time.cpp @@ -52,6 +52,9 @@ static jfieldID g_dateTimeFormatField = 0; static jfieldID g_amField = 0; static jfieldID g_pmField = 0; static jfieldID g_dateCommandField = 0; +static jfieldID g_localeField = 0; + +static jclass g_timeClass = NULL; static inline bool java2time(JNIEnv* env, Time* t, jobject o) { @@ -183,57 +186,102 @@ static jstring android_text_format_Time_format2445(JNIEnv* env, jobject This) static jstring android_text_format_Time_format(JNIEnv* env, jobject This, jstring formatObject) { - Time t; - struct strftime_locale locale; - jclass timeClass = env->FindClass("android/text/format/Time"); - jstring js_mon[12], js_month[12], js_wday[7], js_weekday[7]; - jstring js_X_fmt, js_x_fmt, js_c_fmt, js_am, js_pm, js_date_fmt; - jobjectArray ja; + // We only teardown and setup our 'locale' struct and other state + // when the Java-side locale changed. This is safe to do here + // without locking because we're always called from Java code + // synchronized on the class instance. + static jobject js_locale_previous = NULL; + static struct strftime_locale locale; + static jstring js_mon[12], js_month[12], js_wday[7], js_weekday[7]; + static jstring js_X_fmt, js_x_fmt, js_c_fmt, js_am, js_pm, js_date_fmt; + Time t; if (!java2time(env, &t, This)) return env->NewStringUTF(""); - ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortMonthsField); - for (int i = 0; i < 12; i++) { - js_mon[i] = (jstring) env->GetObjectArrayElement(ja, i); - locale.mon[i] = env->GetStringUTFChars(js_mon[i], NULL); + jclass timeClass = g_timeClass; + jobject js_locale = (jobject) env->GetStaticObjectField(timeClass, g_localeField); + if (js_locale_previous != js_locale) { + if (js_locale_previous != NULL) { + // Free the old one. + for (int i = 0; i < 12; i++) { + env->ReleaseStringUTFChars(js_mon[i], locale.mon[i]); + env->ReleaseStringUTFChars(js_month[i], locale.month[i]); + env->DeleteGlobalRef(js_mon[i]); + env->DeleteGlobalRef(js_month[i]); + } + + for (int i = 0; i < 7; i++) { + env->ReleaseStringUTFChars(js_wday[i], locale.wday[i]); + env->ReleaseStringUTFChars(js_weekday[i], locale.weekday[i]); + env->DeleteGlobalRef(js_wday[i]); + env->DeleteGlobalRef(js_weekday[i]); + } + + env->ReleaseStringUTFChars(js_X_fmt, locale.X_fmt); + env->ReleaseStringUTFChars(js_x_fmt, locale.x_fmt); + env->ReleaseStringUTFChars(js_c_fmt, locale.c_fmt); + env->ReleaseStringUTFChars(js_am, locale.am); + env->ReleaseStringUTFChars(js_pm, locale.pm); + env->ReleaseStringUTFChars(js_date_fmt, locale.date_fmt); + env->DeleteGlobalRef(js_X_fmt); + env->DeleteGlobalRef(js_x_fmt); + env->DeleteGlobalRef(js_c_fmt); + env->DeleteGlobalRef(js_am); + env->DeleteGlobalRef(js_pm); + env->DeleteGlobalRef(js_date_fmt); + } + js_locale_previous = js_locale; + + jobjectArray ja; + ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortMonthsField); + for (int i = 0; i < 12; i++) { + js_mon[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i)); + locale.mon[i] = env->GetStringUTFChars(js_mon[i], NULL); + } + + ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longMonthsField); + for (int i = 0; i < 12; i++) { + js_month[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i)); + locale.month[i] = env->GetStringUTFChars(js_month[i], NULL); + } + + ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortWeekdaysField); + for (int i = 0; i < 7; i++) { + js_wday[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i)); + locale.wday[i] = env->GetStringUTFChars(js_wday[i], NULL); + } + + ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longWeekdaysField); + for (int i = 0; i < 7; i++) { + js_weekday[i] = (jstring) env->NewGlobalRef(env->GetObjectArrayElement(ja, i)); + locale.weekday[i] = env->GetStringUTFChars(js_weekday[i], NULL); + } + + js_X_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField( + timeClass, g_timeOnlyFormatField)); + locale.X_fmt = env->GetStringUTFChars(js_X_fmt, NULL); + + js_x_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField( + timeClass, g_dateOnlyFormatField)); + locale.x_fmt = env->GetStringUTFChars(js_x_fmt, NULL); + + js_c_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField( + timeClass, g_dateTimeFormatField)); + locale.c_fmt = env->GetStringUTFChars(js_c_fmt, NULL); + + js_am = (jstring) env->NewGlobalRef(env->GetStaticObjectField( + timeClass, g_amField)); + locale.am = env->GetStringUTFChars(js_am, NULL); + + js_pm = (jstring) env->NewGlobalRef(env->GetStaticObjectField( + timeClass, g_pmField)); + locale.pm = env->GetStringUTFChars(js_pm, NULL); + + js_date_fmt = (jstring) env->NewGlobalRef(env->GetStaticObjectField( + timeClass, g_dateCommandField)); + locale.date_fmt = env->GetStringUTFChars(js_date_fmt, NULL); } - ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longMonthsField); - for (int i = 0; i < 12; i++) { - js_month[i] = (jstring) env->GetObjectArrayElement(ja, i); - locale.month[i] = env->GetStringUTFChars(js_month[i], NULL); - } - - ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_shortWeekdaysField); - for (int i = 0; i < 7; i++) { - js_wday[i] = (jstring) env->GetObjectArrayElement(ja, i); - locale.wday[i] = env->GetStringUTFChars(js_wday[i], NULL); - } - - ja = (jobjectArray) env->GetStaticObjectField(timeClass, g_longWeekdaysField); - for (int i = 0; i < 7; i++) { - js_weekday[i] = (jstring) env->GetObjectArrayElement(ja, i); - locale.weekday[i] = env->GetStringUTFChars(js_weekday[i], NULL); - } - - js_X_fmt = (jstring) env->GetStaticObjectField(timeClass, g_timeOnlyFormatField); - locale.X_fmt = env->GetStringUTFChars(js_X_fmt, NULL); - - js_x_fmt = (jstring) env->GetStaticObjectField(timeClass, g_dateOnlyFormatField); - locale.x_fmt = env->GetStringUTFChars(js_x_fmt, NULL); - - js_c_fmt = (jstring) env->GetStaticObjectField(timeClass, g_dateTimeFormatField); - locale.c_fmt = env->GetStringUTFChars(js_c_fmt, NULL); - - js_am = (jstring) env->GetStaticObjectField(timeClass, g_amField); - locale.am = env->GetStringUTFChars(js_am, NULL); - - js_pm = (jstring) env->GetStaticObjectField(timeClass, g_pmField); - locale.pm = env->GetStringUTFChars(js_pm, NULL); - - js_date_fmt = (jstring) env->GetStaticObjectField(timeClass, g_dateCommandField); - locale.date_fmt = env->GetStringUTFChars(js_date_fmt, NULL); - ACQUIRE_TIMEZONE(This, t) const char* format = env->GetStringUTFChars(formatObject, NULL); @@ -243,23 +291,6 @@ static jstring android_text_format_Time_format(JNIEnv* env, jobject This, env->ReleaseStringUTFChars(formatObject, format); RELEASE_TIMEZONE(This, t) - for (int i = 0; i < 12; i++) { - env->ReleaseStringUTFChars(js_mon[i], locale.mon[i]); - env->ReleaseStringUTFChars(js_month[i], locale.month[i]); - } - - for (int i = 0; i < 7; i++) { - env->ReleaseStringUTFChars(js_wday[i], locale.wday[i]); - env->ReleaseStringUTFChars(js_weekday[i], locale.weekday[i]); - } - - env->ReleaseStringUTFChars(js_X_fmt, locale.X_fmt); - env->ReleaseStringUTFChars(js_x_fmt, locale.x_fmt); - env->ReleaseStringUTFChars(js_c_fmt, locale.c_fmt); - env->ReleaseStringUTFChars(js_am, locale.am); - env->ReleaseStringUTFChars(js_pm, locale.pm); - env->ReleaseStringUTFChars(js_date_fmt, locale.date_fmt); - return env->NewStringUTF(r.string()); } @@ -307,7 +338,6 @@ static void android_text_format_Time_set(JNIEnv* env, jobject This, jlong millis { env->SetBooleanField(This, g_allDayField, JNI_FALSE); Time t; - if (!java2time(env, &t, This)) return; ACQUIRE_TIMEZONE(This, t) t.set(millis); @@ -592,6 +622,8 @@ int register_android_text_format_Time(JNIEnv* env) { jclass timeClass = env->FindClass("android/text/format/Time"); + g_timeClass = (jclass) env->NewGlobalRef(timeClass); + g_allDayField = env->GetFieldID(timeClass, "allDay", "Z"); g_secField = env->GetFieldID(timeClass, "second", "I"); g_minField = env->GetFieldID(timeClass, "minute", "I"); @@ -615,9 +647,9 @@ int register_android_text_format_Time(JNIEnv* env) g_amField = env->GetStaticFieldID(timeClass, "sAm", "Ljava/lang/String;"); g_pmField = env->GetStaticFieldID(timeClass, "sPm", "Ljava/lang/String;"); g_dateCommandField = env->GetStaticFieldID(timeClass, "sDateCommand", "Ljava/lang/String;"); + g_localeField = env->GetStaticFieldID(timeClass, "sLocale", "Ljava/util/Locale;"); return AndroidRuntime::registerNativeMethods(env, "android/text/format/Time", gMethods, NELEM(gMethods)); } }; // namespace android - diff --git a/core/res/assets/webkit/nullplugin.png b/core/res/assets/webkit/nullPlugin.png similarity index 100% rename from core/res/assets/webkit/nullplugin.png rename to core/res/assets/webkit/nullPlugin.png diff --git a/core/res/res/anim/zoom_ring_enter.xml b/core/res/res/anim/zoom_ring_enter.xml new file mode 100644 index 0000000000000..13d89b2f229b2 --- /dev/null +++ b/core/res/res/anim/zoom_ring_enter.xml @@ -0,0 +1,29 @@ + + + + + + + diff --git a/core/res/res/anim/zoom_ring_exit.xml b/core/res/res/anim/zoom_ring_exit.xml new file mode 100644 index 0000000000000..177a4c31697e3 --- /dev/null +++ b/core/res/res/anim/zoom_ring_exit.xml @@ -0,0 +1,28 @@ + + + + + + diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml index 44da1d5c06624..30b26fa09c3a4 100644 --- a/core/res/res/values/attrs.xml +++ b/core/res/res/values/attrs.xml @@ -371,6 +371,8 @@ + + @@ -529,10 +531,23 @@ {@link android.text.InputType#TYPE_CLASS_TEXT} | {@link android.text.InputType#TYPE_TEXT_VARIATION_PASSWORD}. --> + + - + + + + + @@ -1920,6 +1935,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + @@ -2183,7 +2226,9 @@ + + diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml index 346fa804958ea..d54bca322739e 100644 --- a/core/res/res/values/strings.xml +++ b/core/res/res/values/strings.xml @@ -1565,7 +1565,7 @@ want a 24-hour clock. You can remove the colon or make other punctuation changes appropriate for your locale. --> - H:mm + HH:mm "noon" @@ -2293,6 +2293,9 @@ Next + + Done + Execute diff --git a/core/res/res/values/styles.xml b/core/res/res/values/styles.xml index 54eba629a58a5..9f4d82e22372c 100644 --- a/core/res/res/values/styles.xml +++ b/core/res/res/values/styles.xml @@ -144,6 +144,11 @@ @anim/search_bar_exit + + + + diff --git a/core/res/res/values/themes.xml b/core/res/res/values/themes.xml index 01c46de1e5dc2..bde6b2acde55c 100644 --- a/core/res/res/values/themes.xml +++ b/core/res/res/values/themes.xml @@ -162,6 +162,7 @@ @android:style/Widget.TextView.SpinnerItem @android:style/TextAppearance.Widget.DropDownHint @android:style/Widget.KeyboardView + @android:style/Widget.ZoomRing @android:style/Preference.PreferenceScreen diff --git a/graphics/java/android/graphics/drawable/LevelListDrawable.java b/graphics/java/android/graphics/drawable/LevelListDrawable.java index cf94a3aebdf8f..7ae649f91cad2 100644 --- a/graphics/java/android/graphics/drawable/LevelListDrawable.java +++ b/graphics/java/android/graphics/drawable/LevelListDrawable.java @@ -34,9 +34,20 @@ import android.util.AttributeSet; * battery level. *

* It can be defined in an XML file with the <level-list> element. - * Each Drawable level is defined in a nested <item> + * Each Drawable level is defined in a nested <item>. For example: *

- * + * 
+ * <level-list xmlns:android="http://schemas.android.com/apk/res/android">
+ *  <item android:maxLevel="0" android:drawable="@drawable/ic_wifi_signal_1" />
+ *  <item android:maxLevel="1" android:drawable="@drawable/ic_wifi_signal_2" />
+ *  <item android:maxLevel="2" android:drawable="@drawable/ic_wifi_signal_3" />
+ *  <item android:maxLevel="3" android:drawable="@drawable/ic_wifi_signal_4" />
+ * </level-list>
+ *
+ *

With this XML saved into the res/drawable/ folder of the project, it can be referenced as + * the drawable for an {@link android.widget.ImageView}. The default image is the first in the list. + * It can then be changed to one of the other levels with + * {@link android.widget.ImageView#setImageLevel(int)}.

* @attr ref android.R.styleable#LevelListDrawableItem_minLevel * @attr ref android.R.styleable#LevelListDrawableItem_maxLevel * @attr ref android.R.styleable#LevelListDrawableItem_drawable diff --git a/include/ui/ICameraService.h b/include/ui/ICameraService.h index dfd89230017d5..c652c5169a0a4 100644 --- a/include/ui/ICameraService.h +++ b/include/ui/ICameraService.h @@ -28,7 +28,7 @@ namespace android { class ICameraService : public IInterface { -protected: +public: enum { CONNECT = IBinder::FIRST_CALL_TRANSACTION, }; diff --git a/include/utils/threads.h b/include/utils/threads.h index 7dca810043e98..8d8d46a054d8e 100644 --- a/include/utils/threads.h +++ b/include/utils/threads.h @@ -248,41 +248,6 @@ private: }; -/* - * Read/write lock. The resource can have multiple readers or one writer, - * but can't be read and written at the same time. - * - * The same thread should not call a lock function while it already has - * a lock. (Should be okay for multiple readers.) - */ -class ReadWriteLock { -public: - ReadWriteLock() - : mNumReaders(0), mNumWriters(0) - {} - ~ReadWriteLock() {} - - void lockForRead(); - bool tryLockForRead(); - void unlockForRead(); - - void lockForWrite(); - bool tryLockForWrite(); - void unlockForWrite(); - -private: - int mNumReaders; - int mNumWriters; - - Mutex mLock; - Condition mReadWaiter; - Condition mWriteWaiter; -#if defined(PRINT_RENDER_TIMES) - DurationTimer mDebugTimer; -#endif -}; - - /* * This is our spiffy thread object! */ diff --git a/libs/utils/CallStack.cpp b/libs/utils/CallStack.cpp index 26fb22abc01dc..2fdaa71186b38 100644 --- a/libs/utils/CallStack.cpp +++ b/libs/utils/CallStack.cpp @@ -120,13 +120,18 @@ class MapInfo { char name[]; }; - const char *map_to_name(uint64_t pc, const char* def) { + const char *map_to_name(uint64_t pc, const char* def, uint64_t* start) { mapinfo* mi = getMapInfoList(); while(mi) { - if ((pc >= mi->start) && (pc < mi->end)) + if ((pc >= mi->start) && (pc < mi->end)) { + if (start) + *start = mi->start; return mi->name; + } mi = mi->next; } + if (start) + *start = 0; return def; } @@ -183,8 +188,15 @@ public: } } - static const char *mapAddressToName(const void* pc, const char* def) { - return sMapInfo.map_to_name((uint64_t)pc, def); + static const char *mapAddressToName(const void* pc, const char* def, + void const** start) + { + uint64_t s; + char const* name = sMapInfo.map_to_name(uint64_t(uintptr_t(pc)), def, &s); + if (start) { + *start = (void*)s; + } + return name; } }; @@ -297,8 +309,9 @@ String8 CallStack::toStringSingleLevel(const char* prefix, int32_t level) const res.append(name); res.append(tmp2); } else { - name = MapInfo::mapAddressToName(ip, ""); - snprintf(tmp, 256, "pc %p %s", ip, name); + void const* start = 0; + name = MapInfo::mapAddressToName(ip, "", &start); + snprintf(tmp, 256, "pc %08lx %s", uintptr_t(ip)-uintptr_t(start), name); res.append(tmp); } res.append("\n"); diff --git a/libs/utils/ResourceTypes.cpp b/libs/utils/ResourceTypes.cpp index 71e7cd722bace..2ad3bfe8b8984 100644 --- a/libs/utils/ResourceTypes.cpp +++ b/libs/utils/ResourceTypes.cpp @@ -176,7 +176,9 @@ size_t Res_png_9patch::serializedSize() void* Res_png_9patch::serialize() { - void* newData = malloc(serializedSize()); + // Use calloc since we're going to leave a few holes in the data + // and want this to run cleanly under valgrind + void* newData = calloc(1, serializedSize()); serialize(newData); return newData; } @@ -3150,13 +3152,13 @@ bool ResTable::stringToValue(Res_value* outValue, String16* outString, const char16_t* pos = s; while (pos < end && !failed) { const char16_t* start = pos; - end++; + pos++; while (pos < end && *pos != '|') { pos++; } - //printf("Looking for: %s\n", String8(start, pos-start).string()); + //printf("Looking for: %s\n", String8(start, pos-start).string()); const bag_entry* bagi = bag; - ssize_t i; + ssize_t i; for (i=0; imap.name.ident)) { //printf("Trying attr #%08x\n", bagi->map.name.ident); @@ -3184,7 +3186,7 @@ bool ResTable::stringToValue(Res_value* outValue, String16* outString, } unlockBag(bag); if (!failed) { - //printf("Final flag value: 0x%lx\n", outValue->data); + //printf("Final flag value: 0x%lx\n", outValue->data); return true; } } @@ -3192,7 +3194,7 @@ bool ResTable::stringToValue(Res_value* outValue, String16* outString, if (fromAccessor) { if (accessor->getAttributeFlags(attrID, s, len, outValue)) { - //printf("Final flag value: 0x%lx\n", outValue->data); + //printf("Final flag value: 0x%lx\n", outValue->data); return true; } } diff --git a/libs/utils/String16.cpp b/libs/utils/String16.cpp index 1f81cadb7a4cb..ae0ae1e0909b8 100644 --- a/libs/utils/String16.cpp +++ b/libs/utils/String16.cpp @@ -388,7 +388,7 @@ status_t String16::setTo(const char16_t* other, size_t len) ->editResize((len+1)*sizeof(char16_t)); if (buf) { char16_t* str = (char16_t*)buf->data(); - memcpy(str, other, len*sizeof(char16_t)); + memmove(str, other, len*sizeof(char16_t)); str[len] = 0; mString = str; return NO_ERROR; diff --git a/libs/utils/Threads.cpp b/libs/utils/Threads.cpp index 5f407a99067cd..9287c0bbab3cd 100644 --- a/libs/utils/Threads.cpp +++ b/libs/utils/Threads.cpp @@ -14,6 +14,7 @@ * limitations under the License. */ +// #define LOG_NDEBUG 0 #define LOG_TAG "libutils.threads" #include @@ -838,148 +839,6 @@ void Condition::broadcast() #error "condition variables not supported on this platform" #endif - -/* - * =========================================================================== - * ReadWriteLock class - * =========================================================================== - */ - -#if 0 -#pragma mark - -#pragma mark ReadWriteLock -#endif - -/* - * Add a reader. Readers are nice. They share. - */ -void ReadWriteLock::lockForRead() -{ - mLock.lock(); - while (mNumWriters > 0) { - LOG(LOG_DEBUG, "thread", "+++ lockForRead: waiting\n"); - mReadWaiter.wait(mLock); - } - assert(mNumWriters == 0); - mNumReaders++; -#if defined(PRINT_RENDER_TIMES) - if (mNumReaders == 1) - mDebugTimer.start(); -#endif - mLock.unlock(); -} - -/* - * Try to add a reader. If it doesn't work right away, return "false". - */ -bool ReadWriteLock::tryLockForRead() -{ - mLock.lock(); - if (mNumWriters > 0) { - mLock.unlock(); - return false; - } - assert(mNumWriters == 0); - mNumReaders++; -#if defined(PRINT_RENDER_TIMES) - if (mNumReaders == 1) - mDebugTimer.start(); -#endif - mLock.unlock(); - return true; -} - -/* - * Remove a reader. - */ -void ReadWriteLock::unlockForRead() -{ - mLock.lock(); - if (mNumReaders == 0) { - mLock.unlock(); - LOG(LOG_WARN, "thread", - "WARNING: unlockForRead requested, but not locked\n"); - return; - } - assert(mNumReaders > 0); - assert(mNumWriters == 0); - mNumReaders--; - if (mNumReaders == 0) { // last reader? -#if defined(PRINT_RENDER_TIMES) - mDebugTimer.stop(); - printf(" rdlk held %.3f msec\n", - (double) mDebugTimer.durationUsecs() / 1000.0); -#endif - //printf("+++ signaling writers (if any)\n"); - mWriteWaiter.signal(); // wake one writer (if any) - } - mLock.unlock(); -} - -/* - * Add a writer. This requires exclusive access to the object. - */ -void ReadWriteLock::lockForWrite() -{ - mLock.lock(); - while (mNumReaders > 0 || mNumWriters > 0) { - LOG(LOG_DEBUG, "thread", "+++ lockForWrite: waiting\n"); - mWriteWaiter.wait(mLock); - } - assert(mNumReaders == 0); - assert(mNumWriters == 0); - mNumWriters++; -#if defined(PRINT_RENDER_TIMES) - mDebugTimer.start(); -#endif - mLock.unlock(); -} - -/* - * Try to add a writer. If it doesn't work right away, return "false". - */ -bool ReadWriteLock::tryLockForWrite() -{ - mLock.lock(); - if (mNumReaders > 0 || mNumWriters > 0) { - mLock.unlock(); - return false; - } - assert(mNumReaders == 0); - assert(mNumWriters == 0); - mNumWriters++; -#if defined(PRINT_RENDER_TIMES) - mDebugTimer.start(); -#endif - mLock.unlock(); - return true; -} - -/* - * Remove a writer. - */ -void ReadWriteLock::unlockForWrite() -{ - mLock.lock(); - if (mNumWriters == 0) { - mLock.unlock(); - LOG(LOG_WARN, "thread", - "WARNING: unlockForWrite requested, but not locked\n"); - return; - } - assert(mNumWriters == 1); - mNumWriters--; -#if defined(PRINT_RENDER_TIMES) - mDebugTimer.stop(); - //printf(" wrlk held %.3f msec\n", - // (double) mDebugTimer.durationUsecs() / 1000.0); -#endif - mWriteWaiter.signal(); // should other writers get first dibs? - //printf("+++ signaling readers (if any)\n"); - mReadWaiter.broadcast(); // wake all readers (if any) - mLock.unlock(); -} - // ---------------------------------------------------------------------------- #if 0 @@ -1027,6 +886,8 @@ status_t Thread::run(const char* name, int32_t priority, size_t stack) // hold a strong reference on ourself mHoldSelf = this; + mRunning = true; + bool res; if (mCanCallJava) { res = createThreadEtc(_threadLoop, @@ -1040,14 +901,16 @@ status_t Thread::run(const char* name, int32_t priority, size_t stack) mStatus = UNKNOWN_ERROR; // something happened! mRunning = false; mThread = thread_id_t(-1); + mHoldSelf.clear(); // "this" may have gone away after this. + + return UNKNOWN_ERROR; } - if (mStatus < 0) { - // something happened, don't leak - mHoldSelf.clear(); - } - - return mStatus; + // Do not refer to mStatus here: The thread is already running (may, in fact + // already have exited with a valid mStatus result). The NO_ERROR indication + // here merely indicates successfully starting the thread and does not + // imply successful termination/execution. + return NO_ERROR; } int Thread::_threadLoop(void* user) @@ -1057,20 +920,32 @@ int Thread::_threadLoop(void* user) wp weak(strong); self->mHoldSelf.clear(); - // we're about to run... - self->mStatus = self->readyToRun(); - if (self->mStatus!=NO_ERROR || self->mExitPending) { - // pretend the thread never started... - self->mExitPending = false; - self->mRunning = false; - return 0; - } - - // thread is running now - self->mRunning = true; + bool first = true; do { - bool result = self->threadLoop(); + bool result; + if (first) { + first = false; + self->mStatus = self->readyToRun(); + result = (self->mStatus == NO_ERROR); + + if (result && !self->mExitPending) { + // Binder threads (and maybe others) rely on threadLoop + // running at least once after a successful ::readyToRun() + // (unless, of course, the thread has already been asked to exit + // at that point). + // This is because threads are essentially used like this: + // (new ThreadSubclass())->run(); + // The caller therefore does not retain a strong reference to + // the thread and the thread would simply disappear after the + // successful ::readyToRun() call instead of entering the + // threadLoop at least once. + result = self->threadLoop(); + } + } else { + result = self->threadLoop(); + } + if (result == false || self->mExitPending) { self->mExitPending = true; self->mLock.lock(); @@ -1097,24 +972,23 @@ void Thread::requestExit() status_t Thread::requestExitAndWait() { - if (mStatus == OK) { + if (mThread == getThreadId()) { + LOGW( + "Thread (this=%p): don't call waitForExit() from this " + "Thread object's thread. It's a guaranteed deadlock!", + this); - if (mThread == getThreadId()) { - LOGW( - "Thread (this=%p): don't call waitForExit() from this " - "Thread object's thread. It's a guaranteed deadlock!", - this); - return WOULD_BLOCK; - } - - requestExit(); - - Mutex::Autolock _l(mLock); - while (mRunning == true) { - mThreadExitedCondition.wait(mLock); - } - mExitPending = false; + return WOULD_BLOCK; } + + requestExit(); + + Mutex::Autolock _l(mLock); + while (mRunning == true) { + mThreadExitedCondition.wait(mLock); + } + mExitPending = false; + return mStatus; } diff --git a/media/java/android/media/AudioTrack.java b/media/java/android/media/AudioTrack.java index 997cd44e930e4..316fa7a5f92ee 100644 --- a/media/java/android/media/AudioTrack.java +++ b/media/java/android/media/AudioTrack.java @@ -153,31 +153,23 @@ public class AudioTrack */ private final Object mPlayStateLock = new Object(); /** - * The listener the AudioTrack notifies previously set marker is reached. - * @see #setMarkerReachedListener(OnMarkerReachedListener) + * The listener the AudioTrack notifies when the playback position reaches a marker + * or for periodic updates during the progression of the playback head. + * @see #setPlaybackPositionUpdateListener(OnPlaybackPositionUpdateListener) */ - private OnMarkerReachedListener mMarkerListener = null; + private OnPlaybackPositionUpdateListener mPositionListener = null; /** - * Lock to protect marker listener updates against event notifications + * Lock to protect event listener updates against event notifications */ - private final Object mMarkerListenerLock = new Object(); - /** - * The listener the AudioTrack notifies periodically during playback. - * @see #setPeriodicNotificationListener(OnPeriodicNotificationListener) - */ - private OnPeriodicNotificationListener mPeriodicListener = null; - /** - * Lock to protect periodic listener updates against event notifications - */ - private final Object mPeriodicListenerLock = new Object(); + private final Object mPositionListenerLock = new Object(); /** * Size of the native audio buffer. */ private int mNativeBufferSizeInBytes = 0; /** - * Handler for events coming from the native code + * Handler for marker events coming from the native code */ - private NativeEventHandler mNativeEventHandler = null; + private NativeEventHandlerDelegate mEventHandlerDelegate = null; /** * The audio data sampling rate in Hz. */ @@ -373,22 +365,6 @@ public class AudioTrack } - // Convenience method for the creation of the native event handler - // It is called only when a non-null event listener is set. - // precondition: - // mNativeEventHandler is null - private void createNativeEventHandler() { - Looper looper; - if ((looper = Looper.myLooper()) != null) { - mNativeEventHandler = new NativeEventHandler(this, looper); - } else if ((looper = Looper.getMainLooper()) != null) { - mNativeEventHandler = new NativeEventHandler(this, looper); - } else { - mNativeEventHandler = null; - } - } - - /** * Releases the native AudioTrack resources. */ @@ -592,32 +568,27 @@ public class AudioTrack // Initialization / configuration //-------------------- /** - * Sets the listener the AudioTrack notifies when a previously set marker is reached. + * Sets the listener the AudioTrack notifies when a previously set marker is reached or + * for each periodic playback head position update. * @param listener */ - public void setMarkerReachedListener(OnMarkerReachedListener listener) { - synchronized (mMarkerListenerLock) { - mMarkerListener = listener; + public void setPlaybackPositionUpdateListener(OnPlaybackPositionUpdateListener listener) { + setPlaybackPositionUpdateListener(listener, null); + } + + + public void setPlaybackPositionUpdateListener(OnPlaybackPositionUpdateListener listener, + Handler handler) { + synchronized (mPositionListenerLock) { + mPositionListener = listener; } - if ((listener != null) && (mNativeEventHandler == null)) { - createNativeEventHandler(); + if (listener != null) { + mEventHandlerDelegate = new NativeEventHandlerDelegate(this, handler); } + } - /** - * Sets the listener the AudioTrack notifies periodically during playback. - * @param listener - */ - public void setPeriodicNotificationListener(OnPeriodicNotificationListener listener) { - synchronized (mPeriodicListenerLock) { - mPeriodicListener = listener; - } - if ((listener != null) && (mNativeEventHandler == null)) { - createNativeEventHandler(); - } - } - /** * Sets the specified left/right output volume values on the AudioTrack. Values are clamped @@ -895,23 +866,16 @@ public class AudioTrack // Interface definitions //-------------------- /** - * Interface definition for a callback to be invoked when an AudioTrack has - * reached a notification marker set by setNotificationMarkerPosition(). + * Interface definition for a callback to be invoked when the playback head position of + * an AudioTrack has reached a notification marker or has increased by a certain period. */ - public interface OnMarkerReachedListener { + public interface OnPlaybackPositionUpdateListener { /** * Called on the listener to notify it that the previously set marker has been reached * by the playback head. */ void onMarkerReached(AudioTrack track); - } - - - /** - * Interface definition for a callback to be invoked for each periodic AudioTrack - * update during playback. The update interval is set by setPositionNotificationPeriod(). - */ - public interface OnPeriodicNotificationListener { + /** * Called on the listener to periodically notify it that the playback head has reached * a multiple of the notification period. @@ -924,42 +888,63 @@ public class AudioTrack // Inner classes //-------------------- /** - * Helper class to handle the forwarding of native events to the appropriate listeners - */ - private class NativeEventHandler extends Handler - { - private AudioTrack mAudioTrack; - - public NativeEventHandler(AudioTrack mp, Looper looper) { - super(looper); - mAudioTrack = mp; + * Helper class to handle the forwarding of native events to the appropriate listener + * (potentially) handled in a different thread + */ + private class NativeEventHandlerDelegate { + private final AudioTrack mAudioTrack; + private final Handler mHandler; + + NativeEventHandlerDelegate(AudioTrack track, Handler handler) { + mAudioTrack = track; + // find the looper for our new event handler + Looper looper; + if (handler != null) { + looper = handler.getLooper(); + } else { + // no given handler, look for main looper + if ((looper = Looper.myLooper()) == null) { + looper = Looper.getMainLooper(); + } + } + // construct the event handler with this looper + if (looper != null) { + // implement the event handler delegate + mHandler = new Handler(looper) { + @Override + public void handleMessage(Message msg) { + if (mAudioTrack == null) { + return; + } + OnPlaybackPositionUpdateListener listener = null; + synchronized (mPositionListenerLock) { + listener = mAudioTrack.mPositionListener; + } + switch(msg.what) { + case NATIVE_EVENT_MARKER: + if (listener != null) { + listener.onMarkerReached(mAudioTrack); + } + break; + case NATIVE_EVENT_NEW_POS: + if (listener != null) { + listener.onPeriodicNotification(mAudioTrack); + } + break; + default: + Log.e(TAG, "[ android.media.AudioTrack.NativeEventHandler ] " + + "Unknown event type: " + msg.what); + break; + } + } + }; + } else { + mHandler = null; + } } - - @Override - public void handleMessage(Message msg) { - if (mAudioTrack == null) { - return; - } - switch(msg.what) { - case NATIVE_EVENT_MARKER: - synchronized (mMarkerListenerLock) { - if (mAudioTrack.mMarkerListener != null) { - mAudioTrack.mMarkerListener.onMarkerReached(mAudioTrack); - } - } - break; - case NATIVE_EVENT_NEW_POS: - synchronized (mPeriodicListenerLock) { - if (mAudioTrack.mPeriodicListener != null) { - mAudioTrack.mPeriodicListener.onPeriodicNotification(mAudioTrack); - } - } - break; - default: - Log.e(TAG, "[ android.media.AudioTrack.NativeEventHandler ] " + - "Unknown event type: " + msg.what); - break; - } + + Handler getHandler() { + return mHandler; } } @@ -976,9 +961,10 @@ public class AudioTrack return; } - if (track.mNativeEventHandler != null) { - Message m = track.mNativeEventHandler.obtainMessage(what, arg1, arg2, obj); - track.mNativeEventHandler.sendMessage(m); + if (track.mEventHandlerDelegate != null) { + Message m = + track.mEventHandlerDelegate.getHandler().obtainMessage(what, arg1, arg2, obj); + track.mEventHandlerDelegate.getHandler().sendMessage(m); } } diff --git a/media/jni/android_media_MediaPlayer.cpp b/media/jni/android_media_MediaPlayer.cpp index 5562254616bb6..707db02fd9488 100644 --- a/media/jni/android_media_MediaPlayer.cpp +++ b/media/jni/android_media_MediaPlayer.cpp @@ -29,6 +29,7 @@ #include "jni.h" #include "JNIHelp.h" #include "android_runtime/AndroidRuntime.h" +#include "utils/Errors.h" // for status_t // ---------------------------------------------------------------------------- @@ -171,6 +172,7 @@ android_media_MediaPlayer_setDataSource(JNIEnv *env, jobject thiz, jstring path) jniThrowException(env, "java/lang/RuntimeException", "Out of memory"); return; } + LOGV("setDataSource: path %s", pathStr); status_t opStatus = mp->setDataSource(pathStr); // Make sure that local ref is released before a potential exception @@ -192,6 +194,7 @@ android_media_MediaPlayer_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fil return; } int fd = getParcelFileDescriptorFD(env, fileDescriptor); + LOGV("setDataSourceFD: fd %d", fd); process_media_player_call( env, thiz, mp->setDataSource(fd, offset, length), "java/io/IOException", "setDataSourceFD failed." ); } @@ -207,8 +210,8 @@ android_media_MediaPlayer_prepare(JNIEnv *env, jobject thiz) jobject surface = env->GetObjectField(thiz, fields.surface); if (surface != NULL) { const sp& native_surface = get_surface(env, surface); - //LOGI("prepare: surface=%p (id=%d)", - // native_surface.get(), native_surface->ID()); + LOGV("prepare: surface=%p (id=%d)", + native_surface.get(), native_surface->ID()); mp->setVideoSurface(native_surface); } process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." ); @@ -225,8 +228,8 @@ android_media_MediaPlayer_prepareAsync(JNIEnv *env, jobject thiz) jobject surface = env->GetObjectField(thiz, fields.surface); if (surface != NULL) { const sp& native_surface = get_surface(env, surface); - LOGI("prepareAsync: surface=%p (id=%d)", - native_surface.get(), native_surface->ID()); + LOGV("prepareAsync: surface=%p (id=%d)", + native_surface.get(), native_surface->ID()); mp->setVideoSurface(native_surface); } process_media_player_call( env, thiz, mp->prepareAsync(), "java/io/IOException", "Prepare Async failed." ); @@ -235,6 +238,7 @@ android_media_MediaPlayer_prepareAsync(JNIEnv *env, jobject thiz) static void android_media_MediaPlayer_start(JNIEnv *env, jobject thiz) { + LOGV("start"); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -246,6 +250,7 @@ android_media_MediaPlayer_start(JNIEnv *env, jobject thiz) static void android_media_MediaPlayer_stop(JNIEnv *env, jobject thiz) { + LOGV("stop"); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -257,6 +262,7 @@ android_media_MediaPlayer_stop(JNIEnv *env, jobject thiz) static void android_media_MediaPlayer_pause(JNIEnv *env, jobject thiz) { + LOGV("pause"); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -273,7 +279,10 @@ android_media_MediaPlayer_isPlaying(JNIEnv *env, jobject thiz) jniThrowException(env, "java/lang/IllegalStateException", NULL); return false; } - return mp->isPlaying(); + const jboolean is_playing = mp->isPlaying(); + + LOGV("isPlaying: %d", is_playing); + return is_playing; } static void @@ -284,6 +293,7 @@ android_media_MediaPlayer_seekTo(JNIEnv *env, jobject thiz, int msec) jniThrowException(env, "java/lang/IllegalStateException", NULL); return; } + LOGV("seekTo: %d(msec)", msec); process_media_player_call( env, thiz, mp->seekTo(msec), NULL, NULL ); } @@ -296,9 +306,12 @@ android_media_MediaPlayer_getVideoWidth(JNIEnv *env, jobject thiz) return 0; } int w; - if (0 == mp->getVideoWidth(&w)) - return w; - return 0; + if (0 != mp->getVideoWidth(&w)) { + LOGE("getVideoWidth failed"); + w = 0; + } + LOGV("getVideoWidth: %d", w); + return w; } static int @@ -310,9 +323,12 @@ android_media_MediaPlayer_getVideoHeight(JNIEnv *env, jobject thiz) return 0; } int h; - if (0 == mp->getVideoHeight(&h)) - return h; - return 0; + if (0 != mp->getVideoHeight(&h)) { + LOGE("getVideoHeight failed"); + h = 0; + } + LOGV("getVideoHeight: %d", h); + return h; } @@ -326,6 +342,7 @@ android_media_MediaPlayer_getCurrentPosition(JNIEnv *env, jobject thiz) } int msec; process_media_player_call( env, thiz, mp->getCurrentPosition(&msec), NULL, NULL ); + LOGV("getCurrentPosition: %d (msec)", msec); return msec; } @@ -339,12 +356,14 @@ android_media_MediaPlayer_getDuration(JNIEnv *env, jobject thiz) } int msec; process_media_player_call( env, thiz, mp->getDuration(&msec), NULL, NULL ); + LOGV("getDuration: %d (msec)", msec); return msec; } static void android_media_MediaPlayer_reset(JNIEnv *env, jobject thiz) { + LOGV("reset"); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -356,6 +375,7 @@ android_media_MediaPlayer_reset(JNIEnv *env, jobject thiz) static void android_media_MediaPlayer_setAudioStreamType(JNIEnv *env, jobject thiz, int streamtype) { + LOGV("setAudioStreamType: %d", streamtype); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -367,6 +387,7 @@ android_media_MediaPlayer_setAudioStreamType(JNIEnv *env, jobject thiz, int stre static void android_media_MediaPlayer_setLooping(JNIEnv *env, jobject thiz, jboolean looping) { + LOGV("setLooping: %d", looping); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -378,6 +399,7 @@ android_media_MediaPlayer_setLooping(JNIEnv *env, jobject thiz, jboolean looping static jboolean android_media_MediaPlayer_isLooping(JNIEnv *env, jobject thiz) { + LOGV("isLooping"); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -389,6 +411,7 @@ android_media_MediaPlayer_isLooping(JNIEnv *env, jobject thiz) static void android_media_MediaPlayer_setVolume(JNIEnv *env, jobject thiz, float leftVolume, float rightVolume) { + LOGV("setVolume: left %f right %f", leftVolume, rightVolume); sp mp = getMediaPlayer(env, thiz); if (mp == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); @@ -570,4 +593,3 @@ bail: } // KTHXBYE - diff --git a/media/jni/android_media_MediaRecorder.cpp b/media/jni/android_media_MediaRecorder.cpp index 44f875c6eed16..5f6f754d69c8f 100644 --- a/media/jni/android_media_MediaRecorder.cpp +++ b/media/jni/android_media_MediaRecorder.cpp @@ -313,6 +313,7 @@ android_media_MediaRecorder_release(JNIEnv *env, jobject thiz) sp mr = setMediaRecorder(env, thiz, 0); if (mr != NULL) { mr->setListener(NULL); + mr->release(); } } diff --git a/media/libmedia/AudioTrack.cpp b/media/libmedia/AudioTrack.cpp index e79f336f8549e..d26b0c578052a 100644 --- a/media/libmedia/AudioTrack.cpp +++ b/media/libmedia/AudioTrack.cpp @@ -808,7 +808,14 @@ bool AudioTrack::processAudioBuffer(const sp& thread) writtenSize = audioBuffer.size; // Sanity check on returned size - if (ssize_t(writtenSize) <= 0) break; + if (ssize_t(writtenSize) <= 0) { + // The callback is done filling buffers + // Keep this thread going to handle timed events and + // still try to get more data in intervals of WAIT_PERIOD_MS + // but don't just loop and block the CPU, so wait + usleep(WAIT_PERIOD_MS*1000); + break; + } if (writtenSize > reqSize) writtenSize = reqSize; if (mFormat == AudioSystem::PCM_8_BIT) { diff --git a/media/libmedia/mediarecorder.cpp b/media/libmedia/mediarecorder.cpp index 98aac39184cb9..5eba0ef048f1b 100644 --- a/media/libmedia/mediarecorder.cpp +++ b/media/libmedia/mediarecorder.cpp @@ -42,7 +42,7 @@ status_t MediaRecorder::setCamera(const sp& camera) if (OK != ret) { LOGV("setCamera failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } return ret; } @@ -67,7 +67,7 @@ status_t MediaRecorder::setPreviewSurface(const sp& surface) if (OK != ret) { LOGV("setPreviewSurface failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } return ret; } @@ -88,14 +88,14 @@ status_t MediaRecorder::init() if (OK != ret) { LOGV("init failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } ret = mMediaRecorder->setListener(this); if (OK != ret) { LOGV("setListener failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mCurrentState = MEDIA_RECORDER_INITIALIZED; @@ -129,7 +129,7 @@ status_t MediaRecorder::setVideoSource(int vs) if (OK != ret) { LOGV("setVideoSource failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mIsVideoSourceSet = true; return ret; @@ -162,7 +162,7 @@ status_t MediaRecorder::setAudioSource(int as) if (OK != ret) { LOGV("setAudioSource failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mIsAudioSourceSet = true; return ret; @@ -188,7 +188,7 @@ status_t MediaRecorder::setOutputFormat(int of) if (OK != ret) { LOGE("setOutputFormat failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mCurrentState = MEDIA_RECORDER_DATASOURCE_CONFIGURED; return ret; @@ -218,7 +218,7 @@ status_t MediaRecorder::setVideoEncoder(int ve) if (OK != ret) { LOGV("setVideoEncoder failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mIsVideoEncoderSet = true; return ret; @@ -248,7 +248,7 @@ status_t MediaRecorder::setAudioEncoder(int ae) if (OK != ret) { LOGV("setAudioEncoder failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mIsAudioEncoderSet = true; return ret; @@ -274,7 +274,7 @@ status_t MediaRecorder::setOutputFile(const char* path) if (OK != ret) { LOGV("setOutputFile failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mIsOutputFileSet = true; return ret; @@ -300,7 +300,7 @@ status_t MediaRecorder::setOutputFile(int fd, int64_t offset, int64_t length) if (OK != ret) { LOGV("setOutputFile failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mIsOutputFileSet = true; return ret; @@ -326,7 +326,7 @@ status_t MediaRecorder::setVideoSize(int width, int height) if (OK != ret) { LOGE("setVideoSize failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } return ret; } @@ -351,7 +351,7 @@ status_t MediaRecorder::setVideoFrameRate(int frames_per_second) if (OK != ret) { LOGE("setVideoFrameRate failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } return ret; } @@ -389,7 +389,7 @@ status_t MediaRecorder::prepare() if (OK != ret) { LOGE("prepare failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mCurrentState = MEDIA_RECORDER_PREPARED; return ret; @@ -411,7 +411,7 @@ status_t MediaRecorder::getMaxAmplitude(int* max) if (OK != ret) { LOGE("getMaxAmplitude failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } return ret; } @@ -432,7 +432,7 @@ status_t MediaRecorder::start() if (OK != ret) { LOGE("start failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mCurrentState = MEDIA_RECORDER_RECORDING; return ret; @@ -454,7 +454,7 @@ status_t MediaRecorder::stop() if (OK != ret) { LOGE("stop failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } mCurrentState = MEDIA_RECORDER_IDLE; return ret; @@ -522,7 +522,7 @@ status_t MediaRecorder::doReset() if (OK != ret) { LOGE("doReset failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; - return UNKNOWN_ERROR; + return ret; } else { mCurrentState = MEDIA_RECORDER_INITIALIZED; } diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java index 73688cca90aa0..3c449c90530b5 100755 --- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java +++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java @@ -49,7 +49,7 @@ public class MediaFrameworkTestRunner extends InstrumentationTestRunner { suite.addTestSuite(MediaMetadataTest.class); suite.addTestSuite(CameraTest.class); suite.addTestSuite(MediaRecorderTest.class); - //suite.addTestSuite(MediaAudioTrackTest.class); + suite.addTestSuite(MediaAudioTrackTest.class); return suite; } diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java index 59803f7df42c6..c30db38317437 100644 --- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java +++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java @@ -100,6 +100,12 @@ public class CameraTest extends ActivityInstrumentationTestCase -