auto import from //depot/cupcake/@136594
diff --git a/core/java/android/database/sqlite/SQLiteProgram.java b/core/java/android/database/sqlite/SQLiteProgram.java
index f89c87d..9e85452 100644
--- a/core/java/android/database/sqlite/SQLiteProgram.java
+++ b/core/java/android/database/sqlite/SQLiteProgram.java
@@ -22,7 +22,7 @@
* A base class for compiled SQLite programs.
*/
public abstract class SQLiteProgram extends SQLiteClosable {
- static final String TAG = "SQLiteProgram";
+ private static final String TAG = "SQLiteProgram";
/** The database this program is compiled against. */
protected SQLiteDatabase mDatabase;
diff --git a/core/java/android/database/sqlite/SQLiteQuery.java b/core/java/android/database/sqlite/SQLiteQuery.java
index 5bfa0e8..1386a0d 100644
--- a/core/java/android/database/sqlite/SQLiteQuery.java
+++ b/core/java/android/database/sqlite/SQLiteQuery.java
@@ -18,13 +18,14 @@
import android.database.CursorWindow;
import android.os.SystemClock;
+import android.util.Log;
/**
* A SQLite program that represents a query that reads the resulting rows into a CursorWindow.
* This class is used by SQLiteCursor and isn't useful itself.
*/
public class SQLiteQuery extends SQLiteProgram {
- //private static final String TAG = "Cursor";
+ private static final String TAG = "Cursor";
/** The index of the unbound OFFSET parameter */
private int mOffsetIndex;
@@ -73,6 +74,11 @@
// is not safe in this situation. the native code will ignore maxRead
int numRows = native_fill_window(window, window.getStartPosition(), mOffsetIndex,
maxRead, lastPos);
+
+ // Logging
+ if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {
+ Log.d(TAG, "fillWindow(): " + mQuery);
+ }
if (logStats) {
mDatabase.logTimeStat(true /* read */, startTime,
SystemClock.elapsedRealtime());
diff --git a/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java b/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java
index 5a85c66..6cf90d6 100644
--- a/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java
+++ b/core/java/android/inputmethodservice/IInputMethodSessionWrapper.java
@@ -30,6 +30,7 @@
private static final int DO_UPDATE_SELECTION = 90;
private static final int DO_UPDATE_CURSOR = 95;
private static final int DO_APP_PRIVATE_COMMAND = 100;
+ private static final int DO_TOGGLE_SOFT_INPUT = 105;
final HandlerCaller mCaller;
final InputMethodSession mInputMethodSession;
@@ -106,6 +107,10 @@
mCaller.recycleArgs(args);
return;
}
+ case DO_TOGGLE_SOFT_INPUT: {
+ mInputMethodSession.toggleSoftInput(msg.arg1, msg.arg2);
+ return;
+ }
}
Log.w(TAG, "Unhandled message code: " + msg.what);
}
@@ -149,4 +154,8 @@
public void appPrivateCommand(String action, Bundle data) {
mCaller.executeOrSendMessage(mCaller.obtainMessageOO(DO_APP_PRIVATE_COMMAND, action, data));
}
+
+ public void toggleSoftInput(int showFlags, int hideFlags) {
+ mCaller.executeOrSendMessage(mCaller.obtainMessageII(DO_TOGGLE_SOFT_INPUT, showFlags, hideFlags));
+ }
}
diff --git a/core/java/android/inputmethodservice/IInputMethodWrapper.java b/core/java/android/inputmethodservice/IInputMethodWrapper.java
index a2c75b5..20a05a5 100644
--- a/core/java/android/inputmethodservice/IInputMethodWrapper.java
+++ b/core/java/android/inputmethodservice/IInputMethodWrapper.java
@@ -13,6 +13,7 @@
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
+import android.os.ResultReceiver;
import android.util.Log;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputBinding;
@@ -144,10 +145,10 @@
mInputMethod.revokeSession((InputMethodSession)msg.obj);
return;
case DO_SHOW_SOFT_INPUT:
- mInputMethod.showSoftInput(msg.arg1);
+ mInputMethod.showSoftInput(msg.arg1, (ResultReceiver)msg.obj);
return;
case DO_HIDE_SOFT_INPUT:
- mInputMethod.hideSoftInput();
+ mInputMethod.hideSoftInput(msg.arg1, (ResultReceiver)msg.obj);
return;
}
Log.w(TAG, "Unhandled message code: " + msg.what);
@@ -225,12 +226,13 @@
}
}
- public void showSoftInput(int flags) {
- mCaller.executeOrSendMessage(mCaller.obtainMessageI(DO_SHOW_SOFT_INPUT,
- flags));
+ public void showSoftInput(int flags, ResultReceiver resultReceiver) {
+ mCaller.executeOrSendMessage(mCaller.obtainMessageIO(DO_SHOW_SOFT_INPUT,
+ flags, resultReceiver));
}
- public void hideSoftInput() {
- mCaller.executeOrSendMessage(mCaller.obtainMessage(DO_HIDE_SOFT_INPUT));
+ public void hideSoftInput(int flags, ResultReceiver resultReceiver) {
+ mCaller.executeOrSendMessage(mCaller.obtainMessageIO(DO_HIDE_SOFT_INPUT,
+ flags, resultReceiver));
}
}
diff --git a/core/java/android/inputmethodservice/InputMethodService.java b/core/java/android/inputmethodservice/InputMethodService.java
index 1e2e2f3..f1e613e 100644
--- a/core/java/android/inputmethodservice/InputMethodService.java
+++ b/core/java/android/inputmethodservice/InputMethodService.java
@@ -26,6 +26,7 @@
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.IBinder;
+import android.os.ResultReceiver;
import android.os.SystemClock;
import android.provider.Settings;
import android.text.InputType;
@@ -53,7 +54,6 @@
import android.view.inputmethod.EditorInfo;
import android.widget.Button;
import android.widget.FrameLayout;
-
import java.io.FileDescriptor;
import java.io.PrintWriter;
@@ -348,23 +348,37 @@
/**
* Handle a request by the system to hide the soft input area.
*/
- public void hideSoftInput() {
+ public void hideSoftInput(int flags, ResultReceiver resultReceiver) {
if (DEBUG) Log.v(TAG, "hideSoftInput()");
+ boolean wasVis = isInputViewShown();
mShowInputFlags = 0;
mShowInputRequested = false;
mShowInputForced = false;
hideWindow();
+ if (resultReceiver != null) {
+ resultReceiver.send(wasVis != isInputViewShown()
+ ? InputMethodManager.RESULT_HIDDEN
+ : (wasVis ? InputMethodManager.RESULT_UNCHANGED_SHOWN
+ : InputMethodManager.RESULT_UNCHANGED_HIDDEN), null);
+ }
}
/**
* Handle a request by the system to show the soft input area.
*/
- public void showSoftInput(int flags) {
+ public void showSoftInput(int flags, ResultReceiver resultReceiver) {
if (DEBUG) Log.v(TAG, "showSoftInput()");
+ boolean wasVis = isInputViewShown();
mShowInputFlags = 0;
if (onShowInputRequested(flags, false)) {
showWindow(true);
}
+ if (resultReceiver != null) {
+ resultReceiver.send(wasVis != isInputViewShown()
+ ? InputMethodManager.RESULT_SHOWN
+ : (wasVis ? InputMethodManager.RESULT_UNCHANGED_SHOWN
+ : InputMethodManager.RESULT_UNCHANGED_HIDDEN), null);
+ }
}
}
@@ -440,6 +454,13 @@
}
InputMethodService.this.onAppPrivateCommand(action, data);
}
+
+ /**
+ *
+ */
+ public void toggleSoftInput(int showFlags, int hideFlags) {
+ InputMethodService.this.onToggleSoftInput(showFlags, hideFlags);
+ }
}
/**
@@ -1048,7 +1069,7 @@
* text; you can override this (not calling the base class implementation)
* to perform whatever behavior you would like.
*
- * @boolean finishingInput If true, {@link #onFinishInput} will be
+ * @param finishingInput If true, {@link #onFinishInput} will be
* called immediately after.
*/
public void onFinishInputView(boolean finishingInput) {
@@ -1092,7 +1113,7 @@
* text; you can override this (not calling the base class implementation)
* to perform whatever behavior you would like.
*
- * @boolean finishingInput If true, {@link #onFinishInput} will be
+ * @param finishingInput If true, {@link #onFinishInput} will be
* called immediately after.
*/
public void onFinishCandidatesView(boolean finishingInput) {
@@ -1107,14 +1128,14 @@
/**
* The system has decided that it may be time to show your input method.
* This is called due to a corresponding call to your
- * {@link InputMethod#showSoftInput(int) InputMethod.showSoftInput(int)}
+ * {@link InputMethod#showSoftInput InputMethod.showSoftInput()}
* method. The default implementation uses
* {@link #onEvaluateInputViewShown()}, {@link #onEvaluateFullscreenMode()},
* and the current configuration to decide whether the input view should
* be shown at this point.
*
* @param flags Provides additional information about the show request,
- * as per {@link InputMethod#showSoftInput(int) InputMethod.showSoftInput(int)}.
+ * as per {@link InputMethod#showSoftInput InputMethod.showSoftInput()}.
* @param configChange This is true if we are re-showing due to a
* configuration change.
* @return Returns true to indicate that the window should be shown.
@@ -1290,7 +1311,7 @@
mStartedInputConnection = null;
mCurCompletions = null;
}
-
+
void doStartInput(InputConnection ic, EditorInfo attribute, boolean restarting) {
if (!restarting) {
doFinishInput();
@@ -1399,11 +1420,25 @@
* 0 or have the {@link InputMethodManager#HIDE_IMPLICIT_ONLY
* InputMethodManager.HIDE_IMPLICIT_ONLY} bit set.
*/
- public void dismissSoftInput(int flags) {
+ public void requestHideSelf(int flags) {
mImm.hideSoftInputFromInputMethod(mToken, flags);
}
/**
+ * Show the input method. This is a call back to the
+ * IMF to handle showing the input method.
+ * Close this input method's soft input area, removing it from the display.
+ * The input method will continue running, but the user can no longer use
+ * it to generate input by touching the screen.
+ * @param flags Provides additional operating flags. Currently may be
+ * 0 or have the {@link InputMethodManager#SHOW_FORCED
+ * InputMethodManager.} bit set.
+ */
+ private void requestShowSelf(int flags) {
+ mImm.showSoftInputFromInputMethod(mToken, flags);
+ }
+
+ /**
* Override this to intercept key down events before they are processed by the
* application. If you return true, the application will not itself
* process the event. If you return true, the normal application processing
@@ -1421,7 +1456,7 @@
if (mShowInputRequested) {
// If the soft input area is shown, back closes it and we
// consume the back key.
- dismissSoftInput(0);
+ requestHideSelf(0);
return true;
} else if (mWindowVisible) {
if (mCandidatesVisibility == View.VISIBLE) {
@@ -1438,7 +1473,6 @@
}
}
}
-
return doMovementKey(keyCode, event, MOVEMENT_DOWN);
}
@@ -1480,6 +1514,18 @@
public void onAppPrivateCommand(String action, Bundle data) {
}
+ /**
+ * Handle a request by the system to toggle the soft input area.
+ */
+ private void onToggleSoftInput(int showFlags, int hideFlags) {
+ if (DEBUG) Log.v(TAG, "toggleSoftInput()");
+ if (isInputViewShown()) {
+ requestHideSelf(hideFlags);
+ } else {
+ requestShowSelf(showFlags);
+ }
+ }
+
static final int MOVEMENT_DOWN = -1;
static final int MOVEMENT_UP = -2;
@@ -1737,6 +1783,8 @@
return getText(com.android.internal.R.string.ime_action_send);
case EditorInfo.IME_ACTION_NEXT:
return getText(com.android.internal.R.string.ime_action_next);
+ case EditorInfo.IME_ACTION_DONE:
+ return getText(com.android.internal.R.string.ime_action_done);
default:
return getText(com.android.internal.R.string.ime_action_default);
}
@@ -1777,7 +1825,7 @@
*/
public void onExtractingInputChanged(EditorInfo ei) {
if (ei.inputType == InputType.TYPE_NULL) {
- dismissSoftInput(InputMethodManager.HIDE_NOT_ALWAYS);
+ requestHideSelf(InputMethodManager.HIDE_NOT_ALWAYS);
}
}
diff --git a/core/java/android/inputmethodservice/KeyboardView.java b/core/java/android/inputmethodservice/KeyboardView.java
index c838779..f58b7ef 100755
--- a/core/java/android/inputmethodservice/KeyboardView.java
+++ b/core/java/android/inputmethodservice/KeyboardView.java
@@ -502,7 +502,7 @@
}
private CharSequence adjustCase(CharSequence label) {
- if (mKeyboard.isShifted() && label != null && label.length() == 1
+ if (mKeyboard.isShifted() && label != null && label.length() < 3
&& Character.isLowerCase(label.charAt(0))) {
label = label.toString().toUpperCase();
}
diff --git a/core/java/android/net/http/AndroidHttpClient.java b/core/java/android/net/http/AndroidHttpClient.java
index 0c4fcda..c2013d5 100644
--- a/core/java/android/net/http/AndroidHttpClient.java
+++ b/core/java/android/net/http/AndroidHttpClient.java
@@ -63,6 +63,7 @@
import android.content.ContentResolver;
import android.provider.Settings;
import android.text.TextUtils;
+import android.os.SystemProperties;
/**
* Subclass of the Apache {@link DefaultHttpClient} that is configured with
@@ -387,10 +388,12 @@
}
/**
- * Returns true if auth logging is turned on for this configuration.
+ * Returns true if auth logging is turned on for this configuration. Can only be set on
+ * insecure devices.
*/
private boolean isAuthLoggable() {
- return Log.isLoggable(tag + "-auth", level);
+ String secure = SystemProperties.get("ro.secure");
+ return "0".equals(secure) && Log.isLoggable(tag + "-auth", level);
}
/**
diff --git a/core/java/android/os/ResultReceiver.aidl b/core/java/android/os/ResultReceiver.aidl
new file mode 100644
index 0000000..28ce6d5
--- /dev/null
+++ b/core/java/android/os/ResultReceiver.aidl
@@ -0,0 +1,20 @@
+/* //device/java/android/android/os/ParcelFileDescriptor.aidl
+**
+** Copyright 2007, 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.os;
+
+parcelable ResultReceiver;
diff --git a/core/java/android/os/ResultReceiver.java b/core/java/android/os/ResultReceiver.java
new file mode 100644
index 0000000..711d4d9e
--- /dev/null
+++ b/core/java/android/os/ResultReceiver.java
@@ -0,0 +1,130 @@
+/*
+ * 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.os;
+
+import com.android.internal.os.IResultReceiver;
+
+/**
+ * Generic interface for receiving a callback result from someone. Use this
+ * by creating a subclass and implement {@link #onReceiveResult}, which you can
+ * then pass to others and send through IPC, and receive results they
+ * supply with {@link #send}.
+ */
+public class ResultReceiver implements Parcelable {
+ final boolean mLocal;
+ final Handler mHandler;
+
+ IResultReceiver mReceiver;
+
+ class MyRunnable implements Runnable {
+ final int mResultCode;
+ final Bundle mResultData;
+
+ MyRunnable(int resultCode, Bundle resultData) {
+ mResultCode = resultCode;
+ mResultData = resultData;
+ }
+
+ public void run() {
+ onReceiveResult(mResultCode, mResultData);
+ }
+ }
+
+ class MyResultReceiver extends IResultReceiver.Stub {
+ public void send(int resultCode, Bundle resultData) {
+ if (mHandler != null) {
+ mHandler.post(new MyRunnable(resultCode, resultData));
+ } else {
+ onReceiveResult(resultCode, resultData);
+ }
+ }
+ }
+
+ /**
+ * Create a new ResultReceive to receive results. Your
+ * {@link #onReceiveResult} method will be called from the thread running
+ * <var>handler</var> 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<ResultReceiver> CREATOR
+ = new Parcelable.Creator<ResultReceiver>() {
+ 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 b536b0d..b0ee479 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -2825,6 +2825,11 @@
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 18c64ed..d802c14 100644
--- a/core/java/android/provider/Telephony.java
+++ b/core/java/android/provider/Telephony.java
@@ -1023,6 +1023,11 @@
* <P>Type: INTEGER</P>
*/
public static final String ERROR = "error";
+ /**
+ * Indicates whether this thread contains any attachments.
+ * <P>Type: INTEGER</P>
+ */
+ 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 f643f92..d50684a 100644
--- a/core/java/android/text/InputType.java
+++ b/core/java/android/text/InputType.java
@@ -179,9 +179,27 @@
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 6df0b35..8aa49af 100644
--- a/core/java/android/text/method/ArrowKeyMovementMethod.java
+++ b/core/java/android/text/method/ArrowKeyMovementMethod.java
@@ -204,7 +204,7 @@
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 0b39517..3f8288c 100644
--- a/core/java/android/text/method/QwertyKeyListener.java
+++ b/core/java/android/text/method/QwertyKeyListener.java
@@ -296,20 +296,27 @@
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 70cc2a9..dc7b299 100644
--- a/core/java/android/view/ViewGroup.java
+++ b/core/java/android/view/ViewGroup.java
@@ -1387,14 +1387,10 @@
// 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 b9c8ec3..a662760 100644
--- a/core/java/android/view/animation/Animation.java
+++ b/core/java/android/view/animation/Animation.java
@@ -340,6 +340,7 @@
* 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 @@
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 @@
* 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 @@
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 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 590ce06..98b2594 100644
--- a/core/java/android/view/animation/AnimationSet.java
+++ b/core/java/android/view/animation/AnimationSet.java
@@ -266,32 +266,10 @@
/**
* @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 @@
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 @@
final ArrayList<Animation> 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 0405371..1c0d42a 100644
--- a/core/java/android/view/inputmethod/EditorInfo.java
+++ b/core/java/android/view/inputmethod/EditorInfo.java
@@ -66,6 +66,12 @@
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
* be available in-line as the same as a "enter" key. Typically this is
diff --git a/core/java/android/view/inputmethod/InputMethod.java b/core/java/android/view/inputmethod/InputMethod.java
index 740dca8..a5e0e94 100644
--- a/core/java/android/view/inputmethod/InputMethod.java
+++ b/core/java/android/view/inputmethod/InputMethod.java
@@ -18,6 +18,7 @@
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 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 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 @@
/**
* 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 0aa1d6c..916ffea 100644
--- a/core/java/android/view/inputmethod/InputMethodManager.java
+++ b/core/java/android/view/inputmethod/InputMethodManager.java
@@ -24,6 +24,7 @@
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 @@
// -----------------------------------------------------------
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 @@
}
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 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));
}
};
@@ -646,6 +665,52 @@
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
* your view in such a way that they have expressed they would like to
@@ -655,25 +720,33 @@
* 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) {
}
}
@@ -693,6 +766,20 @@
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
* of the user doing some actually than fairly explicitly requests to
@@ -702,21 +789,77 @@
* 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 @@
void closeCurrentInput() {
try {
- mService.hideSoftInput(mClient, HIDE_NOT_ALWAYS);
+ mService.hideSoftInput(mClient, HIDE_NOT_ALWAYS, null);
} catch (RemoteException e) {
}
}
@@ -1118,7 +1261,8 @@
* 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 {
@@ -1129,6 +1273,27 @@
}
/**
+ * 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
*/
public void dispatchKeyEvent(Context context, int seq, KeyEvent key,
@@ -1204,7 +1369,7 @@
}
}
}
-
+
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 b5bbaff..bb03afa 100644
--- a/core/java/android/view/inputmethod/InputMethodSession.java
+++ b/core/java/android/view/inputmethod/InputMethodSession.java
@@ -139,4 +139,16 @@
* @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 451af6d..5401a6e 100644
--- a/core/java/android/webkit/BrowserFrame.java
+++ b/core/java/android/webkit/BrowserFrame.java
@@ -201,10 +201,14 @@
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 @@
if (isMainFrame || loadType == FRAME_LOADTYPE_STANDARD) {
if (isMainFrame) {
+ resetLoadingStates();
mCallbackProxy.switchOutDrawHistory();
mCallbackProxy.onPageFinished(url);
}
@@ -555,8 +560,11 @@
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 @@
/**
* 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 5e323eb..42d03f0 100644
--- a/core/java/android/webkit/FrameLoader.java
+++ b/core/java/android/webkit/FrameLoader.java
@@ -21,7 +21,6 @@
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 @@
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 dfae17d..8d4b220 100644
--- a/core/java/android/webkit/LoadListener.java
+++ b/core/java/android/webkit/LoadListener.java
@@ -1126,6 +1126,7 @@
mCacheResult = null;
}
+ // This will strip the anchor
setUrl(redirectTo);
// Redirect may be in the cache
@@ -1143,7 +1144,7 @@
// 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 @@
*/
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 0000000..2069599
--- /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<Map.Entry<String, String[]>> responseHeadersIt =
+ mData.getHeaders().entrySet().iterator();
+ while (responseHeadersIt.hasNext()) {
+ Map.Entry<String, String[]> 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 0000000..2b539fe
--- /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<String, String[]> 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<String, String[]> 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<String, String[]> containing all headers. The
+ * mapping is 'lowercase header name' to ['unmodified header
+ * name', header value].
+ */
+ public Map<String, String[]> 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 8a82411..39806dc 100644
--- a/core/java/android/webkit/TextDialog.java
+++ b/core/java/android/webkit/TextDialog.java
@@ -113,13 +113,7 @@
// 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 e1c9d61..9216413 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 @@
* @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<String, String> headers); instead
*/
+ @Deprecated
public CacheResult service(String url, Map<String, String> 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<String, String> headers);
}
diff --git a/core/java/android/webkit/UrlInterceptRegistry.java b/core/java/android/webkit/UrlInterceptRegistry.java
index a218191..6051f29 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 @@
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<String, String> headers) instead.
*/
+ @Deprecated
public static synchronized CacheResult getSurrogate(
String url, Map<String, String> headers) {
- if (urlInterceptDisabled())
+ if (urlInterceptDisabled()) {
return null;
+ }
Iterator iter = getHandlers().listIterator();
while (iter.hasNext()) {
UrlInterceptHandler handler = (UrlInterceptHandler) iter.next();
@@ -103,4 +108,27 @@
}
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<String, String> 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 5126ef0..91795a3 100644
--- a/core/java/android/webkit/WebView.java
+++ b/core/java/android/webkit/WebView.java
@@ -689,7 +689,10 @@
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 @@
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 void onZoom(boolean zoomIn) {
- mZoomListener.onSimpleZoom(zoomIn);
+ mZoomListener.onSimpleZoom(zoomIn, getWidth() / 2, getHeight() / 2);
}
});
}
@@ -4491,6 +4494,14 @@
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 @@
// 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 @@
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 @@
// 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 2a5cbe9..43104bf 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 @@
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 @@
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 @@
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 @@
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 InputStream getInputStream() {
return inputStream;
}
+
+ /**
+ * @return The length of the response body.
+ */
+ public long getContentLength() {
+ return contentLength;
+ }
}
/**
@@ -319,44 +323,32 @@
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<String, String> headers); instead
+ */
+ @Deprecated
+ public CacheResult service(String url, Map<String, String> 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<String, String> requestHeaders) {
+ public PluginData getPluginData(String url, Map<String, String> requestHeaders) {
// Thankfully the browser does call us with case-sensitive
// headers. We just need to map it case-insensitive.
Map<String, String[]> lowercaseRequestHeaders =
@@ -374,86 +366,10 @@
// 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<Map.Entry<String, String[]>> responseHeadersIt =
- response.getResponseHeaders().entrySet().iterator();
- while (responseHeadersIt.hasNext()) {
- Map.Entry<String, String[]> 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 9da78d0..d72570a 100644
--- a/core/java/android/widget/AbsListView.java
+++ b/core/java/android/widget/AbsListView.java
@@ -2766,6 +2766,7 @@
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 @@
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 @@
*/
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 @@
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 57e21e4..0a552e8 100644
--- a/core/java/android/widget/FastScroller.java
+++ b/core/java/android/widget/FastScroller.java
@@ -62,6 +62,8 @@
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 @@
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 6bbf062..11fab8f 100644
--- a/core/java/android/widget/GridView.java
+++ b/core/java/android/widget/GridView.java
@@ -929,6 +929,7 @@
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 @@
*/
@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 a4523b92..480b0b8 100644
--- a/core/java/android/widget/ImageView.java
+++ b/core/java/android/widget/ImageView.java
@@ -333,6 +333,12 @@
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 404a4ee..c2f3a85 100644
--- a/core/java/android/widget/ListView.java
+++ b/core/java/android/widget/ListView.java
@@ -26,7 +26,6 @@
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 @@
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 @@
final boolean blockLayoutRequests = mBlockLayoutRequests;
if (!blockLayoutRequests) {
mBlockLayoutRequests = true;
+ } else {
+ return;
}
try {
@@ -1429,15 +1431,12 @@
// 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 @@
}
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 @@
*/
@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 080f3de..3f4912f 100644
--- a/core/java/android/widget/TextView.java
+++ b/core/java/android/widget/TextView.java
@@ -33,6 +33,7 @@
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 @@
private CharWrapper mCharWrapper = null;
private boolean mSelectionMoved = false;
+ private boolean mTouchFocusSelectedAll = false;
private Marquee mMarquee;
private boolean mRestartMarquee;
@@ -837,6 +839,11 @@
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 @@
int selEnd;
CharSequence text;
boolean frozenWithFocus;
+ CharSequence error;
SavedState(Parcelable superState) {
super(superState);
@@ -2256,6 +2264,13 @@
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 @@
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 @@
ss.frozenWithFocus = true;
}
+ ss.error = mError;
+
return ss;
}
@@ -2383,6 +2404,10 @@
}
}
}
+
+ if (ss.error != null) {
+ setError(ss.error);
+ }
}
/**
@@ -2799,8 +2824,9 @@
*/
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 @@
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 @@
}
}
}
-
- 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 @@
* 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 @@
*/
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 @@
// 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 @@
if (mSelectAllOnFocus) {
Selection.setSelection((Spannable) mText, 0, mText.length());
+ mTouchFocusSelectedAll = true;
}
if (selMoved && selStart >= 0 && selEnd >= 0) {
@@ -6078,12 +6128,32 @@
}
}
+ 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 @@
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 @@
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 a5a867b..83a1225 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.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?
+ * <p>
* Includes error because we compare this to the result of
* getDelta(getClosestTickeAngle(..), oldAngle) which ends up having some
* rounding error.
@@ -55,58 +83,93 @@
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 @@
* 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 @@
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 @@
}
}
- // 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 @@
} 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 void setThumbAngle(int angle) {
angle = getValidAngle(angle);
- mPreviousCallbackAngle = getClosestTickAngle(angle);
+ mPreviousCallbackTickAngle = getClosestTickAngle(angle);
setThumbAngleAuto(angle, false, false);
}
@@ -299,9 +404,9 @@
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 @@
duration = getAnimationDuration(deltaAngle);
}
mThumbScroller.startScroll(startAngle, 0, deltaAngle, 0, duration);
- onThumbScrollerTick();
+ onThumbScrollerStep();
}
private int getAnimationDuration(int deltaAngle) {
@@ -364,10 +469,10 @@
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 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 @@
}
// 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 @@
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 @@
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 @@
}
setMode(MODE_WAITING_FOR_DRAG_THUMB_AFTER_JUMP);
- mWaitingForDragThumbDownAngle = touchAngle;
+ mInitialGrabThumbAngle = touchAngle;
boolean ccw = deltaThumbAndTick > 0;
setThumbAngleAnimated(tickAngle, 0, ccw);
@@ -577,9 +669,9 @@
}
} 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 @@
/* 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 @@
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 @@
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 @@
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 @@
// 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 @@
}
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 @@
* 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 @@
}
// 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 @@
}
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 @@
super.onWindowFocusChanged(hasWindowFocus);
if (!hasWindowFocus) {
- mCallback.onZoomRingDismissed(true);
+ mCallback.onZoomRingDismissed();
}
}
@@ -1054,12 +1148,12 @@
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 @@
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 @@
} 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 @@
/ 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 @@
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 19f66a0..3bf3b22 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.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.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.
+ * <p>
* 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 @@
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 @@
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 @@
* 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 @@
/** 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 @@
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 @@
};
/** 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 @@
@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 @@
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 @@
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 @@
}
/**
- * 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 @@
* @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 @@
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 @@
return;
}
- dismissZoomRingDelayed(ZOOM_CONTROLS_TIMEOUT);
+ dismissZoomRingDelayed(INACTIVITY_TIMEOUT);
} else {
mPanner.stop();
}
@@ -429,12 +469,7 @@
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 @@
}
+ 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()}.
+ * <p>
* 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
+ * <ul>
+ * <li> The controller dispatches touch events differently than the regular view
+ * framework.
+ * <li> Please ensure you set your view to INVISIBLE not GONE when hiding it.
+ * </ul>
+ *
+ * @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 @@
/**
* Should be called by the client for each event belonging to the second tap
* (the down, move, up, and cancel events).
- *
+ * <p>
+ * 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
} 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 @@
}
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 @@
}
} 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 @@
if (!horizontalPanning) {
// Neither are panning, reset any timer to start pan mode
mTouchingEdgeStartTime = 0;
- mPanningEnabledForThisInteraction = false;
+ mPanningInitiated = false;
mPanner.stop();
}
}
@@ -781,13 +839,13 @@
}
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 @@
return false;
}
+ /** @hide */
public void onZoomRingMovingStopped() {
mPanner.stop();
setPanningArrowsVisible(false);
@@ -809,27 +868,25 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
}
+ /** @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 @@
}
+ /**
+ * 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 bab1e21..932555d 100644
--- a/core/java/com/android/internal/os/HandlerCaller.java
+++ b/core/java/com/android/internal/os/HandlerCaller.java
@@ -120,6 +120,10 @@
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 0000000..2b70f95
--- /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 9b00402..8ff18ed 100644
--- a/core/java/com/android/internal/view/IInputMethod.aidl
+++ b/core/java/com/android/internal/view/IInputMethod.aidl
@@ -18,6 +18,7 @@
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 @@
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 1b1c7f7..9030a3e 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 @@
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 @@
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 8a44976..a05ff14 100644
--- a/core/java/com/android/internal/view/IInputMethodSession.aidl
+++ b/core/java/com/android/internal/view/IInputMethodSession.aidl
@@ -46,4 +46,6 @@
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 0000000..48b4780
--- /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 32954ce..e951431 100644
--- a/core/jni/android/graphics/Typeface.cpp
+++ b/core/jni/android/graphics/Typeface.cpp
@@ -32,11 +32,11 @@
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 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 8e41ec7..923e1aa 100644
--- a/core/jni/android_text_format_Time.cpp
+++ b/core/jni/android_text_format_Time.cpp
@@ -52,6 +52,9 @@
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_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 @@
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 @@
{
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 @@
{
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 @@
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
Binary files differ
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 0000000..13d89b2
--- /dev/null
+++ b/core/res/res/anim/zoom_ring_enter.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/* //device/apps/common/res/anim/fade_in.xml
+**
+** Copyright 2007, 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.
+*/
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+ android:interpolator="@anim/decelerate_interpolator">
+ <scale android:fromXScale="0.75" android:toXScale="1.0"
+ android:fromYScale="0.75" android:toYScale="1.0"
+ android:pivotX="50%" android:pivotY="50%"
+ android:duration="75" />
+ <alpha android:fromAlpha="0.0" android:toAlpha="1.0"
+ android:duration="75" />
+</set>
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 0000000..177a4c3
--- /dev/null
+++ b/core/res/res/anim/zoom_ring_exit.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/* //device/apps/common/res/anim/fade_out.xml
+**
+** Copyright 2007, 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.
+*/
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+ android:interpolator="@anim/accelerate_interpolator">
+ <scale android:fromXScale="1.0" android:toXScale="0.75"
+ android:fromYScale="1.0" android:toYScale="0.75"
+ android:pivotX="50%" android:pivotY="50%"
+ android:duration="75" />
+ <alpha android:fromAlpha="1.0" android:toAlpha="0.0"
+ android:duration="75"/>
+</set>
diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml
index 44da1d5..30b26fa 100644
--- a/core/res/res/values/attrs.xml
+++ b/core/res/res/values/attrs.xml
@@ -371,6 +371,8 @@
<attr name="spinnerItemStyle" format="reference" />
<!-- Default MapView style. -->
<attr name="mapViewStyle" format="reference" />
+ <!-- Default ZoomRing style. -->
+ <attr name="zoomRingStyle" format="reference" />
<!-- =================== -->
<!-- Preference styles -->
@@ -529,10 +531,23 @@
{@link android.text.InputType#TYPE_CLASS_TEXT} |
{@link android.text.InputType#TYPE_TEXT_VARIATION_PASSWORD}. -->
<flag name="textPassword" value="0x00000081" />
+ <!-- Text that is a password that should be visible. Corresponds to
+ {@link android.text.InputType#TYPE_CLASS_TEXT} |
+ {@link android.text.InputType#TYPE_TEXT_VARIATION_VISIBLE_PASSWORD}. -->
+ <flag name="textVisiblePassword" value="0x00000091" />
<!-- Text that is being supplied as text in a web form. Corresponds to
{@link android.text.InputType#TYPE_CLASS_TEXT} |
{@link android.text.InputType#TYPE_TEXT_VARIATION_WEB_EDIT_TEXT}. -->
- <flag name="textWebEditText" value="0x00000091" />
+ <flag name="textWebEditText" value="0x000000a1" />
+ <!-- Text that is filtering some other data. Corresponds to
+ {@link android.text.InputType#TYPE_CLASS_TEXT} |
+ {@link android.text.InputType#TYPE_TEXT_VARIATION_FILTER}. -->
+ <flag name="textFilter" value="0x000000b1" />
+ <!-- Text that is for phonetic pronunciation, such as a phonetic name
+ field in a contact entry. Corresponds to
+ {@link android.text.InputType#TYPE_CLASS_TEXT} |
+ {@link android.text.InputType#TYPE_TEXT_VARIATION_PHONETIC}. -->
+ <flag name="textPhonetic" value="0x000000c1" />
<!-- A numeric only field. Corresponds to
{@link android.text.InputType#TYPE_CLASS_NUMBER}. -->
<flag name="number" value="0x00000002" />
@@ -1920,6 +1935,34 @@
</attr>
<attr name="inputType" />
</declare-styleable>
+ <declare-styleable name="ZoomRing">
+ <!-- Defines the drawable used as the thumb. -->
+ <attr name="thumbDrawable" format="reference" />
+ <!-- Defines the distance of the thumb from the center of the ring. -->
+ <attr name="thumbDistance" format="dimension" />
+ <!-- Defines the distance from the center of the ring to the beginning of the track. -->
+ <attr name="trackInnerRadius" format="dimension" />
+ <!-- Defines the distance from the center of the ring to the end of the track. -->
+ <attr name="trackOuterRadius" format="dimension" />
+ <!-- Defines the drawable used as a hint to show which direction is zoom in. This should be
+ the same size as the zoom ring's asset. It will be rotated programmatically. -->
+ <attr name="zoomInArrowDrawable" format="reference" />
+ <!-- Defines the drawable used as a hint to show which direction is zoom out. This should be
+ the same size as the zoom ring's asset. It will be rotated programmatically. -->
+ <attr name="zoomOutArrowDrawable" format="reference" />
+ <!-- Defines the drawable that is laid on top of the zoom in arrow.
+ For example, this could be a +. -->
+ <attr name="zoomInArrowHintDrawable" format="reference" />
+ <!-- Defines the drawable that is laid on top of the zoom out arrow.
+ For example, this could be a -. -->
+ <attr name="zoomOutArrowHintDrawable" format="reference" />
+ <!-- Defines the distance of the zoom arrow hint from the center of the ring. -->
+ <attr name="zoomArrowHintDistance" format="dimension" />
+ <!-- Defines the offset of the zoom arrow hints from the thumb. Valid ranges are [0, 359] -->
+ <attr name="zoomArrowHintOffsetAngle" format="integer" />
+ <!-- Defines the drawable used to hint that the zoom ring can pan its owner. -->
+ <attr name="panningArrowsDrawable" format="reference" />
+ </declare-styleable>
<declare-styleable name="PopupWindow">
<attr name="popupBackground" format="reference|color" />
</declare-styleable>
@@ -2183,7 +2226,9 @@
</declare-styleable>
<declare-styleable name="LevelListDrawableItem">
+ <!-- The minimum level allowed for this item. -->
<attr name="minLevel" format="integer" />
+ <!-- The maximum level allowed for this item. -->
<attr name="maxLevel" format="integer" />
<attr name="drawable" />
</declare-styleable>
diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml
index 346fa80..d54bca3 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. -->
- <string name="twenty_four_hour_time_format" format="date"><xliff:g id="hour" example="23">H</xliff:g>:<xliff:g id="minute" example="59">mm</xliff:g></string>
+ <string name="twenty_four_hour_time_format" format="date"><xliff:g id="hour" example="23">HH</xliff:g>:<xliff:g id="minute" example="59">mm</xliff:g></string>
<!-- Quoted name for 12pm, lowercase -->
<string name="noon">"noon"</string>
@@ -2293,6 +2293,9 @@
<!-- Long label for a button on a full-screen input method for the "Next" action. -->
<string name="ime_action_next">Next</string>
+ <!-- Long label for a button on a full-screen input method for the "Done" action. -->
+ <string name="ime_action_done">Done</string>
+
<!-- Long label for a button on a full-screen input method for an unknown action. -->
<string name="ime_action_default">Execute</string>
diff --git a/core/res/res/values/styles.xml b/core/res/res/values/styles.xml
index 54eba62..9f4d82e 100644
--- a/core/res/res/values/styles.xml
+++ b/core/res/res/values/styles.xml
@@ -144,6 +144,11 @@
<item name="windowExitAnimation">@anim/search_bar_exit</item>
</style>
+ <!-- Standard animations for the zoom ring. -->
+ <style name="Animation.ZoomRing">
+ <item name="windowEnterAnimation">@anim/zoom_ring_enter</item>
+ <item name="windowExitAnimation">@anim/zoom_ring_exit</item>
+ </style>
<!-- Status Bar Styles -->
<style name="TextAppearance.StatusBarTitle">
@@ -456,6 +461,21 @@
<item name="android:shadowRadius">2.75</item>
</style>
+ <style name="Widget.ZoomRing">
+ <item name="android:background">@android:drawable/zoom_ring_track</item>
+ <item name="android:thumbDrawable">@android:drawable/zoom_ring_thumb</item>
+ <item name="android:thumbDistance">63dip</item>
+ <item name="android:trackInnerRadius">43dip</item>
+ <item name="android:trackOuterRadius">91dip</item>
+ <item name="android:zoomInArrowDrawable">@android:drawable/zoom_ring_thumb_plus_arrow_rotatable</item>
+ <item name="android:zoomOutArrowDrawable">@android:drawable/zoom_ring_thumb_minus_arrow_rotatable</item>
+ <item name="android:zoomInArrowHintDrawable">@android:drawable/zoom_ring_thumb_plus</item>
+ <item name="android:zoomOutArrowHintDrawable">@android:drawable/zoom_ring_thumb_minus</item>
+ <item name="android:zoomArrowHintDistance">69dip</item>
+ <item name="android:zoomArrowHintOffsetAngle">33</item>
+ <item name="android:panningArrowsDrawable">@android:drawable/zoom_ring_arrows</item>
+ </style>
+
<!-- Text Appearances -->
<eat-comment />
diff --git a/core/res/res/values/themes.xml b/core/res/res/values/themes.xml
index 01c46de..bde6b2a 100644
--- a/core/res/res/values/themes.xml
+++ b/core/res/res/values/themes.xml
@@ -162,6 +162,7 @@
<item name="spinnerItemStyle">@android:style/Widget.TextView.SpinnerItem</item>
<item name="dropDownHintAppearance">@android:style/TextAppearance.Widget.DropDownHint</item>
<item name="keyboardViewStyle">@android:style/Widget.KeyboardView</item>
+ <item name="zoomRingStyle">@android:style/Widget.ZoomRing</item>
<!-- Preference styles -->
<item name="preferenceScreenStyle">@android:style/Preference.PreferenceScreen</item>
