diff options
Diffstat (limited to 'core/java')
85 files changed, 5632 insertions, 1149 deletions
diff --git a/core/java/android/animation/ObjectAnimator.java b/core/java/android/animation/ObjectAnimator.java index 173ee73..9c88ccf 100644 --- a/core/java/android/animation/ObjectAnimator.java +++ b/core/java/android/animation/ObjectAnimator.java @@ -123,9 +123,37 @@ public final class ObjectAnimator extends ValueAnimator { * in a call to the function <code>setFoo()</code> on the target object. If either * <code>valueFrom</code> or <code>valueTo</code> is null, then a getter function will * also be derived and called. + * + * <p>If this animator was created with a {@link Property} object instead of the + * string name of a property, then this method will return the {@link + * Property#getName() name} of that Property object instead. If this animator was + * created with one or more {@link PropertyValuesHolder} objects, then this method + * will return the {@link PropertyValuesHolder#getPropertyName() name} of that + * object (if there was just one) or a comma-separated list of all of the + * names (if there are more than one).</p> */ public String getPropertyName() { - return mPropertyName; + String propertyName = null; + if (mPropertyName != null) { + propertyName = mPropertyName; + } else if (mProperty != null) { + propertyName = mProperty.getName(); + } else if (mValues != null && mValues.length > 0) { + for (int i = 0; i < mValues.length; ++i) { + if (i == 0) { + propertyName = ""; + } else { + propertyName += ","; + } + propertyName += mValues[i].getPropertyName(); + } + } + return propertyName; + } + + @Override + String getNameForTrace() { + return "animator:" + getPropertyName(); } /** diff --git a/core/java/android/animation/ValueAnimator.java b/core/java/android/animation/ValueAnimator.java index cb44264..f8ae616 100644 --- a/core/java/android/animation/ValueAnimator.java +++ b/core/java/android/animation/ValueAnimator.java @@ -869,7 +869,7 @@ public class ValueAnimator extends Animator { * * <p>If this ValueAnimator has only one set of values being animated between, this evaluator * will be used for that set. If there are several sets of values being animated, which is - * the case if PropertyValuesHOlder objects were set on the ValueAnimator, then the evaluator + * the case if PropertyValuesHolder objects were set on the ValueAnimator, then the evaluator * is assigned just to the first PropertyValuesHolder object.</p> * * @param value the evaluator to be used this animation @@ -1024,7 +1024,7 @@ public class ValueAnimator extends Animator { mStarted = false; mStartListenersCalled = false; mPlayingBackwards = false; - Trace.asyncTraceEnd(Trace.TRACE_TAG_VIEW, "animator", + Trace.asyncTraceEnd(Trace.TRACE_TAG_VIEW, getNameForTrace(), System.identityHashCode(this)); } @@ -1033,7 +1033,7 @@ public class ValueAnimator extends Animator { * called on the UI thread. */ private void startAnimation(AnimationHandler handler) { - Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, "animator", + Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, getNameForTrace(), System.identityHashCode(this)); initAnimation(); handler.mAnimations.add(this); @@ -1045,6 +1045,14 @@ public class ValueAnimator extends Animator { } /** + * Returns the name of this animator for debugging purposes. + */ + String getNameForTrace() { + return "animator"; + } + + + /** * Internal function called to process an animation frame on an animation that is currently * sleeping through its <code>startDelay</code> phase. The return value indicates whether it * should be woken up and put on the active animations queue. diff --git a/core/java/android/app/ActivityManager.java b/core/java/android/app/ActivityManager.java index bb9e19f..729ebd7 100644 --- a/core/java/android/app/ActivityManager.java +++ b/core/java/android/app/ActivityManager.java @@ -31,9 +31,8 @@ import android.content.pm.UserInfo; import android.content.res.Resources; import android.graphics.Bitmap; import android.graphics.Point; -import android.hardware.display.DisplayManager; +import android.graphics.Rect; import android.hardware.display.DisplayManagerGlobal; -import android.os.Binder; import android.os.Bundle; import android.os.Debug; import android.os.Handler; @@ -1229,7 +1228,74 @@ public class ActivityManager { } catch (RemoteException e) { } } - + + + /** + * Information you can retrieve about an ActivityStack in the system. + * @hide + */ + public static class StackInfo implements Parcelable { + public int stackId; + public Rect bounds; + public int[] taskIds; + public String[] taskNames; + + public StackInfo() { + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(stackId); + dest.writeInt(bounds.left); + dest.writeInt(bounds.top); + dest.writeInt(bounds.right); + dest.writeInt(bounds.bottom); + dest.writeIntArray(taskIds); + dest.writeStringArray(taskNames); + } + + public void readFromParcel(Parcel source) { + stackId = source.readInt(); + bounds = new Rect( + source.readInt(), source.readInt(), source.readInt(), source.readInt()); + taskIds = source.createIntArray(); + taskNames = source.createStringArray(); + } + + public static final Creator<StackInfo> CREATOR = new Creator<StackInfo>() { + @Override + public StackInfo createFromParcel(Parcel source) { + return new StackInfo(source); + } + @Override + public StackInfo[] newArray(int size) { + return new StackInfo[size]; + } + }; + + private StackInfo(Parcel source) { + readFromParcel(source); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(256); + sb.append("Stack id="); sb.append(stackId); + sb.append(" bounds="); sb.append(bounds.toShortString()); sb.append("\n"); + final String prefix = " "; + for (int i = 0; i < taskIds.length; ++i) { + sb.append(prefix); sb.append("taskId="); sb.append(taskIds[i]); + sb.append(": "); sb.append(taskNames[i]); sb.append("\n"); + } + return sb.toString(); + } + } + /** * @hide */ diff --git a/core/java/android/app/ActivityManagerNative.java b/core/java/android/app/ActivityManagerNative.java index 98baa0e..3dbb636 100644 --- a/core/java/android/app/ActivityManagerNative.java +++ b/core/java/android/app/ActivityManagerNative.java @@ -107,7 +107,8 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM public ActivityManagerNative() { attachInterface(this, descriptor); } - + + @Override public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { switch (code) { @@ -197,7 +198,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM Intent intent = Intent.CREATOR.createFromParcel(data); String resolvedType = data.readString(); IBinder resultTo = data.readStrongBinder(); - String resultWho = data.readString(); + String resultWho = data.readString(); int requestCode = data.readInt(); int startFlags = data.readInt(); Configuration config = Configuration.CREATOR.createFromParcel(data); @@ -223,7 +224,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM } String resolvedType = data.readString(); IBinder resultTo = data.readStrongBinder(); - String resultWho = data.readString(); + String resultWho = data.readString(); int requestCode = data.readInt(); int flagsMask = data.readInt(); int flagsValues = data.readInt(); @@ -236,7 +237,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeInt(result); return true; } - + case START_NEXT_MATCHING_ACTIVITY_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); @@ -267,7 +268,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM case FINISH_SUB_ACTIVITY_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); IBinder token = data.readStrongBinder(); - String resultWho = data.readString(); + String resultWho = data.readString(); int requestCode = data.readInt(); finishSubActivity(token, resultWho, requestCode); reply.writeNoException(); @@ -478,14 +479,13 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM IThumbnailReceiver receiver = receiverBinder != null ? IThumbnailReceiver.Stub.asInterface(receiverBinder) : null; - List list = getTasks(maxNum, fl, receiver); + List<ActivityManager.RunningTaskInfo> list = getTasks(maxNum, fl, receiver); reply.writeNoException(); int N = list != null ? list.size() : -1; reply.writeInt(N); int i; for (i=0; i<N; i++) { - ActivityManager.RunningTaskInfo info = - (ActivityManager.RunningTaskInfo)list.get(i); + ActivityManager.RunningTaskInfo info = list.get(i); info.writeToParcel(reply, 0); } return true; @@ -535,14 +535,13 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM data.enforceInterface(IActivityManager.descriptor); int maxNum = data.readInt(); int fl = data.readInt(); - List list = getServices(maxNum, fl); + List<ActivityManager.RunningServiceInfo> list = getServices(maxNum, fl); reply.writeNoException(); int N = list != null ? list.size() : -1; reply.writeInt(N); int i; for (i=0; i<N; i++) { - ActivityManager.RunningServiceInfo info = - (ActivityManager.RunningServiceInfo)list.get(i); + ActivityManager.RunningServiceInfo info = list.get(i); info.writeToParcel(reply, 0); } return true; @@ -555,7 +554,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeTypedList(list); return true; } - + case GET_RUNNING_APP_PROCESSES_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses(); @@ -609,6 +608,53 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM return true; } + case CREATE_STACK_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + int taskId = data.readInt(); + int relativeStackId = data.readInt(); + int position = data.readInt(); + float weight = data.readFloat(); + int res = createStack(taskId, relativeStackId, position, weight); + reply.writeNoException(); + reply.writeInt(res); + return true; + } + + case MOVE_TASK_TO_STACK_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + int taskId = data.readInt(); + int stackId = data.readInt(); + boolean toTop = data.readInt() != 0; + moveTaskToStack(taskId, stackId, toTop); + reply.writeNoException(); + return true; + } + + case RESIZE_STACK_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + int stackId = data.readInt(); + float weight = data.readFloat(); + resizeStack(stackId, weight); + reply.writeNoException(); + return true; + } + + case GET_STACKS_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + List<ActivityManager.StackInfo> list = getStacks(); + reply.writeNoException(); + reply.writeTypedList(list); + return true; + } + + case SET_FOCUSED_STACK_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + int stackId = data.readInt(); + setFocusedStack(stackId); + reply.writeNoException(); + return true; + } + case GET_TASK_FOR_ACTIVITY_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); IBinder token = data.readStrongBinder(); @@ -1033,9 +1079,9 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeInt(res); return true; } - + case CLEAR_APP_DATA_TRANSACTION: { - data.enforceInterface(IActivityManager.descriptor); + data.enforceInterface(IActivityManager.descriptor); String packageName = data.readString(); IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface( data.readStrongBinder()); @@ -1045,7 +1091,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeInt(res ? 1 : 0); return true; } - + case GRANT_URI_PERMISSION_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); IBinder b = data.readStrongBinder(); @@ -1057,7 +1103,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeNoException(); return true; } - + case REVOKE_URI_PERMISSION_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); IBinder b = data.readStrongBinder(); @@ -1068,7 +1114,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeNoException(); return true; } - + case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); IBinder b = data.readStrongBinder(); @@ -1257,7 +1303,7 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeNoException(); return true; } - + case FORCE_STOP_PACKAGE_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); String packageName = data.readString(); @@ -2556,6 +2602,77 @@ class ActivityManagerProxy implements IActivityManager data.recycle(); reply.recycle(); } + @Override + public int createStack(int taskId, int relativeStackId, int position, float weight) + throws RemoteException + { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeInt(taskId); + data.writeInt(relativeStackId); + data.writeInt(position); + data.writeFloat(weight); + mRemote.transact(CREATE_STACK_TRANSACTION, data, reply, 0); + reply.readException(); + int res = reply.readInt(); + data.recycle(); + reply.recycle(); + return res; + } + @Override + public void moveTaskToStack(int taskId, int stackId, boolean toTop) throws RemoteException + { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeInt(taskId); + data.writeInt(stackId); + data.writeInt(toTop ? 1 : 0); + mRemote.transact(MOVE_TASK_TO_STACK_TRANSACTION, data, reply, 0); + reply.readException(); + data.recycle(); + reply.recycle(); + } + @Override + public void resizeStack(int stackId, float weight) throws RemoteException + { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeInt(stackId); + data.writeFloat(weight); + mRemote.transact(RESIZE_STACK_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY); + reply.readException(); + data.recycle(); + reply.recycle(); + } + @Override + public List<ActivityManager.StackInfo> getStacks() throws RemoteException + { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + mRemote.transact(GET_STACKS_TRANSACTION, data, reply, 0); + reply.readException(); + ArrayList<ActivityManager.StackInfo> list + = reply.createTypedArrayList(ActivityManager.StackInfo.CREATOR); + data.recycle(); + reply.recycle(); + return list; + } + @Override + public void setFocusedStack(int stackId) throws RemoteException + { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeInt(stackId); + mRemote.transact(SET_FOCUSED_STACK_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY); + reply.readException(); + data.recycle(); + reply.recycle(); + } public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException { Parcel data = Parcel.obtain(); diff --git a/core/java/android/app/IActivityManager.java b/core/java/android/app/IActivityManager.java index 33a2770..5a798de 100644 --- a/core/java/android/app/IActivityManager.java +++ b/core/java/android/app/IActivityManager.java @@ -16,6 +16,9 @@ package android.app; +import android.app.ActivityManager.RunningTaskInfo; +import android.app.ActivityManager.RunningServiceInfo; +import android.app.ActivityManager.StackInfo; import android.content.ComponentName; import android.content.ContentProviderNative; import android.content.IContentProvider; @@ -99,19 +102,25 @@ public interface IActivityManager extends IInterface { public void activityDestroyed(IBinder token) throws RemoteException; public String getCallingPackage(IBinder token) throws RemoteException; public ComponentName getCallingActivity(IBinder token) throws RemoteException; - public List getTasks(int maxNum, int flags, + public List<RunningTaskInfo> getTasks(int maxNum, int flags, IThumbnailReceiver receiver) throws RemoteException; public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, int flags, int userId) throws RemoteException; public ActivityManager.TaskThumbnails getTaskThumbnails(int taskId) throws RemoteException; public Bitmap getTaskTopThumbnail(int taskId) throws RemoteException; - public List getServices(int maxNum, int flags) throws RemoteException; + public List<RunningServiceInfo> getServices(int maxNum, int flags) throws RemoteException; public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState() throws RemoteException; public void moveTaskToFront(int task, int flags, Bundle options) throws RemoteException; public void moveTaskToBack(int task) throws RemoteException; public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) throws RemoteException; public void moveTaskBackwards(int task) throws RemoteException; + public int createStack(int taskId, int relativeStackId, int position, float weight) + throws RemoteException; + public void moveTaskToStack(int taskId, int stackId, boolean toTop) throws RemoteException; + public void resizeStack(int stackId, float weight) throws RemoteException; + public List<StackInfo> getStacks() throws RemoteException; + public void setFocusedStack(int stackId) throws RemoteException; public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException; /* oneway */ public void reportThumbnail(IBinder token, @@ -149,14 +158,14 @@ public interface IActivityManager extends IInterface { public void serviceDoneExecuting(IBinder token, int type, int startId, int res) throws RemoteException; public IBinder peekService(Intent service, String resolvedType) throws RemoteException; - + public boolean bindBackupAgent(ApplicationInfo appInfo, int backupRestoreMode) throws RemoteException; public void clearPendingBackup() throws RemoteException; public void backupAgentCreated(String packageName, IBinder agent) throws RemoteException; public void unbindBackupAgent(ApplicationInfo appInfo) throws RemoteException; public void killApplicationProcess(String processName, int uid) throws RemoteException; - + public boolean startInstrumentation(ComponentName className, String profileFile, int flags, Bundle arguments, IInstrumentationWatcher watcher, IUiAutomationConnection connection, int userId) throws RemoteException; @@ -168,7 +177,7 @@ public interface IActivityManager extends IInterface { public void setRequestedOrientation(IBinder token, int requestedOrientation) throws RemoteException; public int getRequestedOrientation(IBinder token) throws RemoteException; - + public ComponentName getActivityClassForToken(IBinder token) throws RemoteException; public String getPackageForToken(IBinder token) throws RemoteException; @@ -181,16 +190,16 @@ public interface IActivityManager extends IInterface { final IPackageDataObserver observer, int userId) throws RemoteException; public String getPackageForIntentSender(IIntentSender sender) throws RemoteException; public int getUidForIntentSender(IIntentSender sender) throws RemoteException; - + public int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll, boolean requireFull, String name, String callerPackage) throws RemoteException; public void setProcessLimit(int max) throws RemoteException; public int getProcessLimit() throws RemoteException; - + public void setProcessForeground(IBinder token, int pid, boolean isForeground) throws RemoteException; - + public int checkPermission(String permission, int pid, int uid) throws RemoteException; @@ -393,10 +402,12 @@ public interface IActivityManager extends IInterface { info = _info; } + @Override public int describeContents() { return 0; } + @Override public void writeToParcel(Parcel dest, int flags) { info.writeToParcel(dest, 0); if (provider != null) { @@ -410,10 +421,12 @@ public interface IActivityManager extends IInterface { public static final Parcelable.Creator<ContentProviderHolder> CREATOR = new Parcelable.Creator<ContentProviderHolder>() { + @Override public ContentProviderHolder createFromParcel(Parcel source) { return new ContentProviderHolder(source); } + @Override public ContentProviderHolder[] newArray(int size) { return new ContentProviderHolder[size]; } @@ -439,10 +452,12 @@ public interface IActivityManager extends IInterface { public WaitResult() { } + @Override public int describeContents() { return 0; } + @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(result); dest.writeInt(timeout ? 1 : 0); @@ -453,10 +468,12 @@ public interface IActivityManager extends IInterface { public static final Parcelable.Creator<WaitResult> CREATOR = new Parcelable.Creator<WaitResult>() { + @Override public WaitResult createFromParcel(Parcel source) { return new WaitResult(source); } + @Override public WaitResult[] newArray(int size) { return new WaitResult[size]; } @@ -637,5 +654,10 @@ public interface IActivityManager extends IInterface { int REPORT_TOP_ACTIVITY_EXTRAS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+162; int GET_LAUNCHED_FROM_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+163; int KILL_UID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+164; - int SET_USER_IS_MONKEY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+165; + int CREATE_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+165; + int MOVE_TASK_TO_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+166; + int RESIZE_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+167; + int SET_USER_IS_MONKEY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+168; + int GET_STACKS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+169; + int SET_FOCUSED_STACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+170; } diff --git a/core/java/android/appwidget/AppWidgetHost.java b/core/java/android/appwidget/AppWidgetHost.java index c62bf32..3a355f9 100644 --- a/core/java/android/appwidget/AppWidgetHost.java +++ b/core/java/android/appwidget/AppWidgetHost.java @@ -198,7 +198,6 @@ public class AppWidgetHost { * @return a appWidgetId */ public int allocateAppWidgetId() { - try { if (mPackageName == null) { mPackageName = mContext.getPackageName(); @@ -211,20 +210,17 @@ public class AppWidgetHost { } /** - * Get a appWidgetId for a host in the calling process. + * Get a appWidgetId for a host in the given package. * * @return a appWidgetId * @hide */ - public static int allocateAppWidgetIdForSystem(int hostId, int userId) { + public static int allocateAppWidgetIdForPackage(int hostId, int userId, String packageName) { checkCallerIsSystem(); try { if (sService == null) { bindService(); } - Context systemContext = - (Context) ActivityThread.currentActivityThread().getSystemContext(); - String packageName = systemContext.getPackageName(); return sService.allocateAppWidgetId(packageName, hostId, userId); } catch (RemoteException e) { throw new RuntimeException("system server dead?", e); diff --git a/core/java/android/content/ContentResolver.java b/core/java/android/content/ContentResolver.java index fefd343..b3f0d96 100644 --- a/core/java/android/content/ContentResolver.java +++ b/core/java/android/content/ContentResolver.java @@ -220,6 +220,7 @@ public abstract class ContentResolver { // Always log queries which take 500ms+; shorter queries are // sampled accordingly. + private static final boolean ENABLE_CONTENT_SAMPLE = false; private static final int SLOW_THRESHOLD_MILLIS = 500; private final Random mRandom = new Random(); // guarded by itself @@ -1832,6 +1833,7 @@ public abstract class ContentResolver { private void maybeLogQueryToEventLog(long durationMillis, Uri uri, String[] projection, String selection, String sortOrder) { + if (!ENABLE_CONTENT_SAMPLE) return; int samplePercent = samplePercentForDuration(durationMillis); if (samplePercent < 100) { synchronized (mRandom) { @@ -1871,6 +1873,7 @@ public abstract class ContentResolver { private void maybeLogUpdateToEventLog( long durationMillis, Uri uri, String operation, String selection) { + if (!ENABLE_CONTENT_SAMPLE) return; int samplePercent = samplePercentForDuration(durationMillis); if (samplePercent < 100) { synchronized (mRandom) { diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java index 5bd28b9..81d6f0b 100644 --- a/core/java/android/content/Context.java +++ b/core/java/android/content/Context.java @@ -2434,7 +2434,7 @@ public abstract class Context { * Remove all permissions to access a particular content provider Uri * that were previously added with {@link #grantUriPermission}. The given * Uri will match all previously granted Uris that are the same or a - * sub-path of the given Uri. That is, revoking "content://foo/one" will + * sub-path of the given Uri. That is, revoking "content://foo/target" will * revoke both "content://foo/target" and "content://foo/target/sub", but not * "content://foo". * diff --git a/core/java/android/content/Intent.java b/core/java/android/content/Intent.java index 67bd952..8352635 100644 --- a/core/java/android/content/Intent.java +++ b/core/java/android/content/Intent.java @@ -1165,13 +1165,12 @@ public class Intent implements Parcelable, Cloneable { * additional optional contextual information about where the user was when they requested * the voice assist. * Output: nothing. - * @hide */ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_VOICE_ASSIST = "android.intent.action.VOICE_ASSIST"; /** - * An optional field on {@link #ACTION_ASSIST} + * An optional field on {@link #ACTION_ASSIST} and {@link #ACTION_VOICE_ASSIST} * containing the name of the current foreground application package at the time * the assist was invoked. */ @@ -1179,7 +1178,7 @@ public class Intent implements Parcelable, Cloneable { = "android.intent.extra.ASSIST_PACKAGE"; /** - * An optional field on {@link #ACTION_ASSIST} + * An optional field on {@link #ACTION_ASSIST} and {@link #ACTION_VOICE_ASSIST} * containing additional contextual information supplied by the current * foreground app at the time of the assist request. This is a {@link Bundle} of * additional data. @@ -2592,6 +2591,46 @@ public class Intent implements Parcelable, Cloneable { */ public static final String ACTION_GLOBAL_BUTTON = "android.intent.action.GLOBAL_BUTTON"; + /** + * Activity Action: Allow the user to select and open one or more existing + * documents. Both read and write access to the documents will be granted + * until explicitly revoked by the user. + * <p> + * Callers can restrict selection to a specific kind of data, such as + * photos, by setting one or more MIME types in {@link #EXTRA_MIME_TYPES}. + * <p> + * If the caller can handle multiple returned items (the user performing + * multiple selection), then it can specify {@link #EXTRA_ALLOW_MULTIPLE} to + * indicate this. + * <p> + * All returned URIs can be opened as a stream with + * {@link ContentResolver#openInputStream(Uri)}. + * <p> + * Output: The URI of the item that was picked. This must be a content: URI + * so that any receiver can access it. + */ + @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) + public static final String ACTION_OPEN_DOCUMENT = "android.intent.action.OPEN_DOCUMENT"; + + /** + * Activity Action: Allow the user to create a new document. Both read and + * write access to the document will be granted until explicitly revoked by + * the user. + * <p> + * Callers can provide a hint document name by setting {@link #EXTRA_TITLE}, + * but the user may change this value before creating the file. Callers can + * optionally hint at the MIME type being created by setting + * {@link #setType(String)}. + * <p> + * All returned URIs can be opened as a stream with + * {@link ContentResolver#openOutputStream(Uri)}. + * <p> + * Output: The URI of the item that was created. This must be a content: URI + * so that any receiver can access it. + */ + @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) + public static final String ACTION_CREATE_DOCUMENT = "android.intent.action.CREATE_DOCUMENT"; + // --------------------------------------------------------------------- // --------------------------------------------------------------------- // Standard intent categories (see addCategory()). @@ -3195,6 +3234,13 @@ public class Intent implements Parcelable, Cloneable { public static final String EXTRA_RESTRICTIONS_INTENT = "android.intent.extra.restrictions_intent"; + /** + * Extra used to communicate set of acceptable MIME types for + * {@link #ACTION_GET_CONTENT} or {@link #ACTION_OPEN_DOCUMENT}. The type of the + * extra is <code>ArrayList<String></code>. + */ + public static final String EXTRA_MIME_TYPES = "android.intent.extra.MIME_TYPES"; + // --------------------------------------------------------------------- // --------------------------------------------------------------------- // Intent flags (see mFlags variable). @@ -3244,6 +3290,15 @@ public class Intent implements Parcelable, Cloneable { public static final int FLAG_INCLUDE_STOPPED_PACKAGES = 0x00000020; /** + * When combined with {@link #FLAG_GRANT_READ_URI_PERMISSION} and/or + * {@link #FLAG_GRANT_WRITE_URI_PERMISSION}, the grant will be remembered + * until explicitly revoked with + * {@link Context#revokeUriPermission(Uri, int)}. These grants persist + * across device reboots. + */ + public static final int FLAG_PERSIST_GRANT_URI_PERMISSION = 0x00000040; + + /** * If set, the new activity is not kept in the history stack. As soon as * the user navigates away from it, the activity is finished. This may also * be set with the {@link android.R.styleable#AndroidManifestActivity_noHistory @@ -7032,7 +7087,8 @@ public class Intent implements Parcelable, Cloneable { // and flags to ourselves to grant. setClipData(target.getClipData()); addFlags(target.getFlags() - & (FLAG_GRANT_READ_URI_PERMISSION | FLAG_GRANT_WRITE_URI_PERMISSION)); + & (FLAG_GRANT_READ_URI_PERMISSION | FLAG_GRANT_WRITE_URI_PERMISSION + | FLAG_PERSIST_GRANT_URI_PERMISSION)); return true; } else { return false; diff --git a/core/java/android/content/pm/KeySet.java b/core/java/android/content/pm/KeySet.java new file mode 100644 index 0000000..0ef09a4 --- /dev/null +++ b/core/java/android/content/pm/KeySet.java @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2012 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.content.pm; + +import android.os.Binder; + +/** @hide */ +public class KeySet { + + private Binder token; + + /** @hide */ + public KeySet(Binder token) { + this.token = token; + } + + Binder getToken() { + return token; + } +}
\ No newline at end of file diff --git a/core/java/android/content/pm/PackageParser.java b/core/java/android/content/pm/PackageParser.java index 34e0c12..1b997f0 100644 --- a/core/java/android/content/pm/PackageParser.java +++ b/core/java/android/content/pm/PackageParser.java @@ -45,14 +45,20 @@ import java.security.NoSuchAlgorithmException; import java.security.PublicKey; import java.security.cert.Certificate; import java.security.cert.CertificateEncodingException; +import java.security.cert.CertificateFactory; +import java.security.cert.CertPath; +import java.security.cert.X509Certificate; import java.security.spec.EncodedKeySpec; import java.security.spec.InvalidKeySpecException; import java.security.spec.X509EncodedKeySpec; import java.util.ArrayList; import java.util.Enumeration; +import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.zip.ZipEntry; @@ -714,6 +720,13 @@ public class PackageParser { mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES; return false; } + + // Add the signing KeySet to the system + pkg.mSigningKeys = new HashSet<PublicKey>(); + for (int i=0; i < certs.length; i++) { + pkg.mSigningKeys.add(certs[i].getPublicKey()); + } + } catch (CertificateEncodingException e) { Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e); mParseError = PackageManager.INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING; @@ -1027,6 +1040,10 @@ public class PackageParser { if (!parseApplication(pkg, res, parser, attrs, flags, outError)) { return null; } + } else if (tagName.equals("keys")) { + if (!parseKeys(pkg, res, parser, attrs, outError)) { + return null; + } } else if (tagName.equals("permission-group")) { if (parsePermissionGroup(pkg, flags, res, parser, attrs, outError) == null) { return null; @@ -1519,7 +1536,71 @@ public class PackageParser { } return buildCompoundName(pkg, procSeq, "taskAffinity", outError); } - + + private boolean parseKeys(Package owner, Resources res, + XmlPullParser parser, AttributeSet attrs, String[] outError) + throws XmlPullParserException, IOException { + // we've encountered the 'keys' tag + // all the keys and keysets that we want must be defined here + // so we're going to iterate over the parser and pull out the things we want + int outerDepth = parser.getDepth(); + + int type; + PublicKey currentKey = null; + Map<PublicKey, Set<String>> definedKeySets = new HashMap<PublicKey, Set<String>>(); + while ((type = parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG) { + continue; + } + String tagname = parser.getName(); + if (tagname.equals("publicKey")) { + final TypedArray sa = res.obtainAttributes(attrs, + com.android.internal.R.styleable.PublicKey); + final String encodedKey = sa.getNonResourceString( + com.android.internal.R.styleable.PublicKey_value); + currentKey = parsePublicKey(encodedKey); + definedKeySets.put(currentKey, new HashSet<String>()); + sa.recycle(); + } else if (tagname.equals("keyset")) { + final TypedArray sa = res.obtainAttributes(attrs, + com.android.internal.R.styleable.KeySet); + final String name = sa.getNonResourceString( + com.android.internal.R.styleable.KeySet_name); + definedKeySets.get(currentKey).add(name); + sa.recycle(); + } else if (RIGID_PARSER) { + Slog.w(TAG, "Bad element under <keys>: " + parser.getName() + + " at " + mArchiveSourcePath + " " + + parser.getPositionDescription()); + return false; + } else { + Slog.w(TAG, "Unknown element under <keys>: " + parser.getName() + + " at " + mArchiveSourcePath + " " + + parser.getPositionDescription()); + XmlUtils.skipCurrentTag(parser); + continue; + } + } + + owner.mKeySetMapping = new HashMap<String, Set<PublicKey>>(); + for (Map.Entry<PublicKey, Set<String>> e : definedKeySets.entrySet()) { + PublicKey key = e.getKey(); + Set<String> keySetNames = e.getValue(); + for (String alias : keySetNames) { + if (owner.mKeySetMapping.containsKey(alias)) { + owner.mKeySetMapping.get(alias).add(key); + } else { + Set<PublicKey> keys = new HashSet<PublicKey>(); + keys.add(key); + owner.mKeySetMapping.put(alias, keys); + } + } + } + + return true; + } + private PermissionGroup parsePermissionGroup(Package owner, int flags, Resources res, XmlPullParser parser, AttributeSet attrs, String[] outError) throws XmlPullParserException, IOException { @@ -3083,20 +3164,28 @@ public class PackageParser { Slog.i(TAG, "verifier " + packageName + " public key was null; skipping"); } + PublicKey publicKey = parsePublicKey(encodedPublicKey); + if (publicKey != null) { + return new VerifierInfo(packageName, publicKey); + } + + return null; + } + + public static final PublicKey parsePublicKey(String encodedPublicKey) { EncodedKeySpec keySpec; try { final byte[] encoded = Base64.decode(encodedPublicKey, Base64.DEFAULT); keySpec = new X509EncodedKeySpec(encoded); } catch (IllegalArgumentException e) { - Slog.i(TAG, "Could not parse verifier " + packageName + " public key; invalid Base64"); + Slog.i(TAG, "Could not parse verifier public key; invalid Base64"); return null; } /* First try the key as an RSA key. */ try { final KeyFactory keyFactory = KeyFactory.getInstance("RSA"); - final PublicKey publicKey = keyFactory.generatePublic(keySpec); - return new VerifierInfo(packageName, publicKey); + return keyFactory.generatePublic(keySpec); } catch (NoSuchAlgorithmException e) { Log.wtf(TAG, "Could not parse public key because RSA isn't included in build"); return null; @@ -3107,8 +3196,7 @@ public class PackageParser { /* Now try it as a DSA key. */ try { final KeyFactory keyFactory = KeyFactory.getInstance("DSA"); - final PublicKey publicKey = keyFactory.generatePublic(keySpec); - return new VerifierInfo(packageName, publicKey); + return keyFactory.generatePublic(keySpec); } catch (NoSuchAlgorithmException e) { Log.wtf(TAG, "Could not parse public key because DSA isn't included in build"); return null; @@ -3360,6 +3448,12 @@ public class PackageParser { */ public ManifestDigest manifestDigest; + /** + * Data used to feed the KeySetManager + */ + public Set<PublicKey> mSigningKeys; + public Map<String, Set<PublicKey>> mKeySetMapping; + public Package(String _name) { packageName = _name; applicationInfo.packageName = _name; diff --git a/core/java/android/content/res/AssetFileDescriptor.java b/core/java/android/content/res/AssetFileDescriptor.java index 7d46710..e4cc77f 100644 --- a/core/java/android/content/res/AssetFileDescriptor.java +++ b/core/java/android/content/res/AssetFileDescriptor.java @@ -20,6 +20,7 @@ import android.os.Parcel; import android.os.ParcelFileDescriptor; import android.os.Parcelable; +import java.io.Closeable; import java.io.FileDescriptor; import java.io.FileInputStream; import java.io.FileOutputStream; @@ -30,7 +31,7 @@ import java.io.IOException; * opened FileDescriptor that can be used to read the data, as well as the * offset and length of that entry's data in the file. */ -public class AssetFileDescriptor implements Parcelable { +public class AssetFileDescriptor implements Parcelable, Closeable { /** * Length used with {@link #AssetFileDescriptor(ParcelFileDescriptor, long, long)} * and {@link #getDeclaredLength} when a length has not been declared. This means @@ -122,6 +123,7 @@ public class AssetFileDescriptor implements Parcelable { /** * Convenience for calling <code>getParcelFileDescriptor().close()</code>. */ + @Override public void close() throws IOException { mFd.close(); } diff --git a/core/java/android/content/res/Resources.java b/core/java/android/content/res/Resources.java index 42f4faf..c7976c3 100644 --- a/core/java/android/content/res/Resources.java +++ b/core/java/android/content/res/Resources.java @@ -16,8 +16,6 @@ package android.content.res; -import android.os.Trace; -import android.view.View; import com.android.internal.util.XmlUtils; import org.xmlpull.v1.XmlPullParser; @@ -30,6 +28,7 @@ import android.graphics.drawable.ColorDrawable; import android.graphics.drawable.Drawable.ConstantState; import android.os.Build; import android.os.Bundle; +import android.os.Trace; import android.util.AttributeSet; import android.util.DisplayMetrics; import android.util.Log; @@ -1985,6 +1984,13 @@ public class Resources { } } + /** + * @hide + */ + public LongSparseArray<Drawable.ConstantState> getPreloadedDrawables() { + return sPreloadedDrawables[0]; + } + private boolean verifyPreloadConfig(int changingConfigurations, int allowVarying, int resourceId, String name) { // We allow preloading of resources even if they vary by font scale (which diff --git a/core/java/android/hardware/Camera.java b/core/java/android/hardware/Camera.java index 4e51080..ac42b76 100644 --- a/core/java/android/hardware/Camera.java +++ b/core/java/android/hardware/Camera.java @@ -31,6 +31,11 @@ import android.os.Looper; import android.os.Message; import android.os.RemoteException; import android.os.ServiceManager; +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.RenderScript; +import android.renderscript.RSIllegalArgumentException; +import android.renderscript.Type; import android.util.Log; import android.text.TextUtils; import android.view.Surface; @@ -152,6 +157,7 @@ public class Camera { private PictureCallback mRawImageCallback; private PictureCallback mJpegCallback; private PreviewCallback mPreviewCallback; + private boolean mUsingPreviewAllocation; private PictureCallback mPostviewCallback; private AutoFocusCallback mAutoFocusCallback; private AutoFocusMoveCallback mAutoFocusMoveCallback; @@ -327,6 +333,7 @@ public class Camera { mJpegCallback = null; mPreviewCallback = null; mPostviewCallback = null; + mUsingPreviewAllocation = false; mZoomListener = null; Looper looper; @@ -587,6 +594,9 @@ public class Camera { mPreviewCallback = cb; mOneShot = false; mWithBuffer = false; + if (cb != null) { + mUsingPreviewAllocation = false; + } // Always use one-shot mode. We fake camera preview mode by // doing one-shot preview continuously. setHasPreviewCallback(cb != null, false); @@ -610,6 +620,9 @@ public class Camera { mPreviewCallback = cb; mOneShot = true; mWithBuffer = false; + if (cb != null) { + mUsingPreviewAllocation = false; + } setHasPreviewCallback(cb != null, false); } @@ -645,6 +658,9 @@ public class Camera { mPreviewCallback = cb; mOneShot = false; mWithBuffer = true; + if (cb != null) { + mUsingPreviewAllocation = false; + } setHasPreviewCallback(cb != null, true); } @@ -744,6 +760,134 @@ public class Camera { private native final void _addCallbackBuffer( byte[] callbackBuffer, int msgType); + /** + * <p>Create a {@link android.renderscript RenderScript} + * {@link android.renderscript.Allocation Allocation} to use as a + * destination of preview callback frames. Use + * {@link #setPreviewCallbackAllocation setPreviewCallbackAllocation} to use + * the created Allocation as a destination for camera preview frames.</p> + * + * <p>The Allocation will be created with a YUV type, and its contents must + * be accessed within Renderscript with the {@code rsGetElementAtYuv_*} + * accessor methods. Its size will be based on the current + * {@link Parameters#getPreviewSize preview size} configured for this + * camera.</p> + * + * @param rs the RenderScript context for this Allocation. + * @param usage additional usage flags to set for the Allocation. The usage + * flag {@link android.renderscript.Allocation#USAGE_IO_INPUT} will always + * be set on the created Allocation, but additional flags may be provided + * here. + * @return a new YUV-type Allocation with dimensions equal to the current + * preview size. + * @throws RSIllegalArgumentException if the usage flags are not compatible + * with an YUV Allocation. + * @see #setPreviewCallbackAllocation + * @hide + */ + public final Allocation createPreviewAllocation(RenderScript rs, int usage) + throws RSIllegalArgumentException { + Parameters p = getParameters(); + Size previewSize = p.getPreviewSize(); + Type.Builder yuvBuilder = new Type.Builder(rs, + Element.createPixel(rs, + Element.DataType.UNSIGNED_8, + Element.DataKind.PIXEL_YUV)); + // Use YV12 for wide compatibility. Changing this requires also + // adjusting camera service's format selection. + yuvBuilder.setYuvFormat(ImageFormat.YV12); + yuvBuilder.setX(previewSize.width); + yuvBuilder.setY(previewSize.height); + + Allocation a = Allocation.createTyped(rs, yuvBuilder.create(), + usage | Allocation.USAGE_IO_INPUT); + + return a; + } + + /** + * <p>Set an {@link android.renderscript.Allocation Allocation} as the + * target of preview callback data. Use this method for efficient processing + * of camera preview data with RenderScript. The Allocation must be created + * with the {@link #createPreviewAllocation createPreviewAllocation } + * method.</p> + * + * <p>Setting a preview allocation will disable any active preview callbacks + * set by {@link #setPreviewCallback setPreviewCallback} or + * {@link #setPreviewCallbackWithBuffer setPreviewCallbackWithBuffer}, and + * vice versa. Using a preview allocation still requires an active standard + * preview target to be set, either with + * {@link #setPreviewTexture setPreviewTexture} or + * {@link #setPreviewDisplay setPreviewDisplay}.</p> + * + * <p>To be notified when new frames are available to the Allocation, use + * {@link android.renderscript.Allocation#setIoInputNotificationHandler Allocation.setIoInputNotificationHandler}. To + * update the frame currently accessible from the Allocation to the latest + * preview frame, call + * {@link android.renderscript.Allocation#ioReceive Allocation.ioReceive}.</p> + * + * <p>To disable preview into the Allocation, call this method with a + * {@code null} parameter.</p> + * + * <p>Once a preview allocation is set, the preview size set by + * {@link Parameters#setPreviewSize setPreviewSize} cannot be changed. If + * you wish to change the preview size, first remove the preview allocation + * by calling {@code setPreviewCallbackAllocation(null)}, then change the + * preview size, create a new preview Allocation with + * {@link #createPreviewAllocation createPreviewAllocation}, and set it as + * the new preview callback allocation target.</p> + * + * <p>If you are using the preview data to create video or still images, + * strongly consider using {@link android.media.MediaActionSound} to + * properly indicate image capture or recording start/stop to the user.</p> + * + * @param previewAllocation the allocation to use as destination for preview + * @throws IOException if configuring the camera to use the Allocation for + * preview fails. + * @throws IllegalArgumentException if the Allocation's dimensions or other + * parameters don't meet the requirements. + * @see #createPreviewAllocation + * @see #setPreviewCallback + * @see #setPreviewCallbackWithBuffer + * @hide + */ + public final void setPreviewCallbackAllocation(Allocation previewAllocation) + throws IOException { + Surface previewSurface = null; + if (previewAllocation != null) { + Parameters p = getParameters(); + Size previewSize = p.getPreviewSize(); + if (previewSize.width != previewAllocation.getType().getX() || + previewSize.height != previewAllocation.getType().getY()) { + throw new IllegalArgumentException( + "Allocation dimensions don't match preview dimensions: " + + "Allocation is " + + previewAllocation.getType().getX() + + ", " + + previewAllocation.getType().getY() + + ". Preview is " + previewSize.width + ", " + + previewSize.height); + } + if ((previewAllocation.getUsage() & + Allocation.USAGE_IO_INPUT) == 0) { + throw new IllegalArgumentException( + "Allocation usage does not include USAGE_IO_INPUT"); + } + if (previewAllocation.getType().getElement().getDataKind() != + Element.DataKind.PIXEL_YUV) { + throw new IllegalArgumentException( + "Allocation is not of a YUV type"); + } + previewSurface = previewAllocation.getSurface(); + mUsingPreviewAllocation = true; + } else { + mUsingPreviewAllocation = false; + } + setPreviewCallbackSurface(previewSurface); + } + + private native final void setPreviewCallbackSurface(Surface s); + private class EventHandler extends Handler { private Camera mCamera; @@ -1492,6 +1636,17 @@ public class Camera { * @see #getParameters() */ public void setParameters(Parameters params) { + // If using preview allocations, don't allow preview size changes + if (mUsingPreviewAllocation) { + Size newPreviewSize = params.getPreviewSize(); + Size currentPreviewSize = getParameters().getPreviewSize(); + if (newPreviewSize.width != currentPreviewSize.width || + newPreviewSize.height != currentPreviewSize.height) { + throw new IllegalStateException("Cannot change preview size" + + " while a preview allocation is configured."); + } + } + native_setParameters(params.flatten()); } diff --git a/core/java/android/os/BatteryStats.java b/core/java/android/os/BatteryStats.java index 499ec77..d0f7511 100644 --- a/core/java/android/os/BatteryStats.java +++ b/core/java/android/os/BatteryStats.java @@ -98,6 +98,11 @@ public abstract class BatteryStats implements Parcelable { public static final int VIBRATOR_ON = 9; /** + * A constant indicating a foreground activity timer + */ + public static final int FOREGROUND_ACTIVITY = 10; + + /** * Include all of the data in the stats, including previously saved data. */ public static final int STATS_SINCE_CHARGED = 0; @@ -125,7 +130,7 @@ public abstract class BatteryStats implements Parcelable { /** * Bump the version on this if the checkin format changes. */ - private static final int BATTERY_STATS_CHECKIN_VERSION = 5; + private static final int BATTERY_STATS_CHECKIN_VERSION = 6; private static final long BYTES_PER_KB = 1024; private static final long BYTES_PER_MB = 1048576; // 1024^2 @@ -137,6 +142,7 @@ public abstract class BatteryStats implements Parcelable { private static final String PROCESS_DATA = "pr"; private static final String SENSOR_DATA = "sr"; private static final String VIBRATOR_DATA = "vib"; + private static final String FOREGROUND_DATA = "fg"; private static final String WAKELOCK_DATA = "wl"; private static final String KERNEL_WAKELOCK_DATA = "kwl"; private static final String NETWORK_DATA = "nt"; @@ -276,6 +282,8 @@ public abstract class BatteryStats implements Parcelable { public abstract void noteAudioTurnedOffLocked(); public abstract void noteVideoTurnedOnLocked(); public abstract void noteVideoTurnedOffLocked(); + public abstract void noteActivityResumedLocked(); + public abstract void noteActivityPausedLocked(); public abstract long getWifiRunningTime(long batteryRealtime, int which); public abstract long getFullWifiLockTime(long batteryRealtime, int which); public abstract long getWifiScanTime(long batteryRealtime, int which); @@ -283,6 +291,7 @@ public abstract class BatteryStats implements Parcelable { int which); public abstract long getAudioTurnedOnTime(long batteryRealtime, int which); public abstract long getVideoTurnedOnTime(long batteryRealtime, int which); + public abstract Timer getForegroundActivityTimer(); public abstract Timer getVibratorOnTimer(); /** @@ -1229,7 +1238,7 @@ public abstract class BatteryStats implements Parcelable { final int NU = uidStats.size(); String category = STAT_NAMES[which]; - + // Dump "battery" stat dumpLine(pw, 0 /* uid */, category, BATTERY_DATA, which == STATS_SINCE_CHARGED ? getStartCount() : "N/A", @@ -1417,22 +1426,31 @@ public abstract class BatteryStats implements Parcelable { } } + Timer fgTimer = u.getForegroundActivityTimer(); + if (fgTimer != null) { + // Convert from microseconds to milliseconds with rounding + long totalTime = (fgTimer.getTotalTimeLocked(batteryRealtime, which) + 500) / 1000; + int count = fgTimer.getCountLocked(which); + if (totalTime != 0) { + dumpLine(pw, uid, category, FOREGROUND_DATA, totalTime, count); + } + } + Map<String, ? extends BatteryStats.Uid.Proc> processStats = u.getProcessStats(); if (processStats.size() > 0) { for (Map.Entry<String, ? extends BatteryStats.Uid.Proc> ent : processStats.entrySet()) { Uid.Proc ps = ent.getValue(); - - long userTime = ps.getUserTime(which); - long systemTime = ps.getSystemTime(which); - int starts = ps.getStarts(which); - - if (userTime != 0 || systemTime != 0 || starts != 0) { - dumpLine(pw, uid, category, PROCESS_DATA, - ent.getKey(), // proc - userTime * 10, // cpu time in ms - systemTime * 10, // user time in ms - starts); // process starts + + final long userMillis = ps.getUserTime(which) * 10; + final long systemMillis = ps.getSystemTime(which) * 10; + final long foregroundMillis = ps.getForegroundTime(which) * 10; + final long starts = ps.getStarts(which); + + if (userMillis != 0 || systemMillis != 0 || foregroundMillis != 0 + || starts != 0) { + dumpLine(pw, uid, category, PROCESS_DATA, ent.getKey(), userMillis, + systemMillis, foregroundMillis, starts); } } } @@ -1961,6 +1979,24 @@ public abstract class BatteryStats implements Parcelable { } } + Timer fgTimer = u.getForegroundActivityTimer(); + if (fgTimer != null) { + // Convert from microseconds to milliseconds with rounding + long totalTime = (fgTimer.getTotalTimeLocked(batteryRealtime, which) + 500) / 1000; + int count = fgTimer.getCountLocked(which); + if (totalTime != 0) { + sb.setLength(0); + sb.append(prefix); + sb.append(" Foreground activities: "); + formatTimeMs(sb, totalTime); + sb.append("realtime ("); + sb.append(count); + sb.append(" times)"); + pw.println(sb.toString()); + uidActivity = true; + } + } + Map<String, ? extends BatteryStats.Uid.Proc> processStats = u.getProcessStats(); if (processStats.size() > 0) { for (Map.Entry<String, ? extends BatteryStats.Uid.Proc> ent @@ -1968,23 +2004,26 @@ public abstract class BatteryStats implements Parcelable { Uid.Proc ps = ent.getValue(); long userTime; long systemTime; + long foregroundTime; int starts; int numExcessive; userTime = ps.getUserTime(which); systemTime = ps.getSystemTime(which); + foregroundTime = ps.getForegroundTime(which); starts = ps.getStarts(which); numExcessive = which == STATS_SINCE_CHARGED ? ps.countExcessivePowers() : 0; - if (userTime != 0 || systemTime != 0 || starts != 0 + if (userTime != 0 || systemTime != 0 || foregroundTime != 0 || starts != 0 || numExcessive != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Proc "); sb.append(ent.getKey()); sb.append(":\n"); sb.append(prefix); sb.append(" CPU: "); formatTime(sb, userTime); sb.append("usr + "); - formatTime(sb, systemTime); sb.append("krn"); + formatTime(sb, systemTime); sb.append("krn ; "); + formatTime(sb, foregroundTime); sb.append("fg"); if (starts != 0) { sb.append("\n"); sb.append(prefix); sb.append(" "); sb.append(starts); sb.append(" proc starts"); @@ -2042,7 +2081,7 @@ public abstract class BatteryStats implements Parcelable { sb.append(sent.getKey()); sb.append(":\n"); sb.append(prefix); sb.append(" Created for: "); formatTimeMs(sb, startTime / 1000); - sb.append(" uptime\n"); + sb.append("uptime\n"); sb.append(prefix); sb.append(" Starts: "); sb.append(starts); sb.append(", launches: "); sb.append(launches); @@ -2215,7 +2254,7 @@ public abstract class BatteryStats implements Parcelable { * @param pw a Printer to receive the dump output. */ @SuppressWarnings("unused") - public void dumpLocked(PrintWriter pw) { + public void dumpLocked(PrintWriter pw, boolean isUnpluggedOnly) { prepareForDumpLocked(); long now = getHistoryBaseTime() + SystemClock.elapsedRealtime(); @@ -2267,28 +2306,22 @@ public abstract class BatteryStats implements Parcelable { if (didPid) { pw.println(""); } - - pw.println("Statistics since last charge:"); - pw.println(" System starts: " + getStartCount() - + ", currently on battery: " + getIsOnBattery()); - dumpLocked(pw, "", STATS_SINCE_CHARGED, -1); - pw.println(""); + + if (!isUnpluggedOnly) { + pw.println("Statistics since last charge:"); + pw.println(" System starts: " + getStartCount() + + ", currently on battery: " + getIsOnBattery()); + dumpLocked(pw, "", STATS_SINCE_CHARGED, -1); + pw.println(""); + } pw.println("Statistics since last unplugged:"); dumpLocked(pw, "", STATS_SINCE_UNPLUGGED, -1); } @SuppressWarnings("unused") - public void dumpCheckinLocked(PrintWriter pw, String[] args, List<ApplicationInfo> apps) { + public void dumpCheckinLocked( + PrintWriter pw, List<ApplicationInfo> apps, boolean isUnpluggedOnly) { prepareForDumpLocked(); - - boolean isUnpluggedOnly = false; - - for (String arg : args) { - if ("-u".equals(arg)) { - if (LOCAL_LOGV) Log.v("BatteryStats", "Dumping unplugged data"); - isUnpluggedOnly = true; - } - } if (apps != null) { SparseArray<ArrayList<String>> uids = new SparseArray<ArrayList<String>>(); diff --git a/core/java/android/os/Build.java b/core/java/android/os/Build.java index 6c9f2d1..71c3e4a 100644 --- a/core/java/android/os/Build.java +++ b/core/java/android/os/Build.java @@ -436,6 +436,11 @@ public class Build { * Android 4.3: Jelly Bean MR2, the revenge of the beans. */ public static final int JELLY_BEAN_MR2 = 18; + + /** + * Android X.X: Key Lime Pie, another tasty treat. + */ + public static final int KEY_LIME_PIE = CUR_DEVELOPMENT; } /** The type of build, like "user" or "eng". */ diff --git a/core/java/android/os/Environment.java b/core/java/android/os/Environment.java index 61eef1f..70a1edc 100644 --- a/core/java/android/os/Environment.java +++ b/core/java/android/os/Environment.java @@ -19,6 +19,7 @@ package android.os; import android.os.storage.IMountService; import android.os.storage.StorageManager; import android.os.storage.StorageVolume; +import android.os.SystemProperties; import android.text.TextUtils; import android.util.Log; @@ -59,6 +60,10 @@ public class Environment { private static volatile StorageVolume sPrimaryVolume; private static StorageVolume getPrimaryVolume() { + if (SystemProperties.getBoolean("config.disable_storage", false)) { + return null; + } + if (sPrimaryVolume == null) { synchronized (sLock) { if (sPrimaryVolume == null) { diff --git a/core/java/android/os/RecoverySystem.java b/core/java/android/os/RecoverySystem.java index 480fe7d..5e20dec 100644 --- a/core/java/android/os/RecoverySystem.java +++ b/core/java/android/os/RecoverySystem.java @@ -244,12 +244,17 @@ public class RecoverySystem { // The signature cert matches a trusted key. Now verify that // the digest in the cert matches the actual file data. - // The verifier in recovery *only* handles SHA1withRSA - // signatures. SignApk.java always uses SHA1withRSA, no - // matter what the cert says to use. Ignore - // cert.getSigAlgName(), and instead use whatever - // algorithm is used by the signature (which should be - // SHA1withRSA). + // The verifier in recovery only handles SHA1withRSA and + // SHA256withRSA signatures. SignApk chooses which to use + // based on the signature algorithm of the cert: + // + // "SHA256withRSA" cert -> "SHA256withRSA" signature + // "SHA1withRSA" cert -> "SHA1withRSA" signature + // "MD5withRSA" cert -> "SHA1withRSA" signature (for backwards compatibility) + // any other cert -> SignApk fails + // + // Here we ignore whatever the cert says, and instead use + // whatever algorithm is used by the signature. String da = sigInfo.getDigestAlgorithm(); String dea = sigInfo.getDigestEncryptionAlgorithm(); diff --git a/core/java/android/provider/DocumentsContract.java b/core/java/android/provider/DocumentsContract.java new file mode 100644 index 0000000..c26f6d4 --- /dev/null +++ b/core/java/android/provider/DocumentsContract.java @@ -0,0 +1,209 @@ +/* + * Copyright (C) 2013 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.provider; + +import android.content.ContentResolver; +import android.content.ContentValues; +import android.content.Intent; +import android.content.res.AssetFileDescriptor; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Point; +import android.net.Uri; +import android.os.Bundle; +import android.util.Log; + +import libcore.io.IoUtils; + +import java.io.IOException; +import java.io.InputStream; + +/** + * The contract between a storage backend and the platform. Contains definitions + * for the supported URIs and columns. + */ +public final class DocumentsContract { + private static final String TAG = "Documents"; + + // content://com.example/docs/0/ + // content://com.example/docs/0/contents/ + // content://com.example/search/?query=pony + + /** + * MIME type of a document which is a directory that may contain additional + * documents. + * + * @see #buildContentsUri(Uri) + */ + public static final String MIME_TYPE_DIRECTORY = "vnd.android.cursor.dir/doc"; + + /** {@hide} */ + public static final String META_DATA_DOCUMENT_PROVIDER = "android.content.DOCUMENT_PROVIDER"; + + /** + * {@link DocumentColumns#GUID} value representing the root directory of a + * storage backend. + */ + public static final String ROOT_GUID = "0"; + + /** + * Flag indicating that a document is a directory that supports creation of + * new files within it. + * + * @see DocumentColumns#FLAGS + * @see #buildContentsUri(Uri) + */ + public static final int FLAG_SUPPORTS_CREATE = 1; + + /** + * Flag indicating that a document is renamable. + * + * @see DocumentColumns#FLAGS + * @see #renameDocument(ContentResolver, Uri, String) + */ + public static final int FLAG_SUPPORTS_RENAME = 1 << 1; + + /** + * Flag indicating that a document can be represented as a thumbnail. + * + * @see DocumentColumns#FLAGS + * @see #getThumbnail(ContentResolver, Uri, Point) + */ + public static final int FLAG_SUPPORTS_THUMBNAIL = 1 << 2; + + /** + * Optimal dimensions for a document thumbnail request, stored as a + * {@link Point} object. This is only a hint, and the returned thumbnail may + * have different dimensions. + */ + public static final String EXTRA_THUMBNAIL_SIZE = "thumbnail_size"; + + private static final String PATH_DOCS = "docs"; + private static final String PATH_CONTENTS = "contents"; + private static final String PATH_SEARCH = "search"; + + private static final String PARAM_QUERY = "query"; + + /** + * Build URI representing the given {@link DocumentColumns#GUID} in a + * storage backend. + */ + public static Uri buildDocumentUri(String authority, String guid) { + return new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT) + .authority(authority).appendPath(PATH_DOCS).appendPath(guid).build(); + } + + /** + * Build URI representing a search for matching documents in a storage + * backend. + */ + public static Uri buildSearchUri(String authority, String query) { + return new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).authority(authority) + .appendPath(PATH_SEARCH).appendQueryParameter(PARAM_QUERY, query).build(); + } + + /** + * Build URI representing the contents of the given directory in a storage + * backend. The given document must be {@link #MIME_TYPE_DIRECTORY}. + */ + public static Uri buildContentsUri(Uri documentUri) { + return documentUri.buildUpon().appendPath(PATH_CONTENTS).build(); + } + + /** + * These are standard columns for document URIs. Storage backend providers + * <em>must</em> support at least these columns when queried. + * + * @see Intent#ACTION_OPEN_DOCUMENT + * @see Intent#ACTION_CREATE_DOCUMENT + */ + public interface DocumentColumns extends OpenableColumns { + /** + * The globally unique ID for a document within a storage backend. + * Values <em>must</em> never change once returned. + * <p> + * Type: STRING + * + * @see DocumentsContract#ROOT_GUID + */ + public static final String GUID = "guid"; + + /** + * MIME type of a document, matching the value returned by + * {@link ContentResolver#getType(android.net.Uri)}. + * <p> + * Type: STRING + * + * @see DocumentsContract#MIME_TYPE_DIRECTORY + */ + public static final String MIME_TYPE = "mime_type"; + + /** + * Timestamp when a document was last modified, in milliseconds since + * January 1, 1970 00:00:00.0 UTC. + * <p> + * Type: INTEGER (long) + * + * @see System#currentTimeMillis() + */ + public static final String LAST_MODIFIED = "last_modified"; + + /** + * Flags that apply to a specific document. + * <p> + * Type: INTEGER (int) + */ + public static final String FLAGS = "flags"; + } + + /** + * Return thumbnail representing the document at the given URI. Callers are + * responsible for their own caching. Given document must have + * {@link #FLAG_SUPPORTS_THUMBNAIL} set. + * + * @return decoded thumbnail, or {@code null} if problem was encountered. + */ + public static Bitmap getThumbnail(ContentResolver resolver, Uri documentUri, Point size) { + final Bundle opts = new Bundle(); + opts.putParcelable(EXTRA_THUMBNAIL_SIZE, size); + + InputStream is = null; + try { + is = new AssetFileDescriptor.AutoCloseInputStream( + resolver.openTypedAssetFileDescriptor(documentUri, "image/*", opts)); + return BitmapFactory.decodeStream(is); + } catch (IOException e) { + Log.w(TAG, "Failed to load thumbnail for " + documentUri + ": " + e); + return null; + } finally { + IoUtils.closeQuietly(is); + } + } + + /** + * Rename the document at the given URI. Given document must have + * {@link #FLAG_SUPPORTS_RENAME} set. + * + * @return if rename was successful. + */ + public static boolean renameDocument( + ContentResolver resolver, Uri documentUri, String displayName) { + final ContentValues values = new ContentValues(); + values.put(DocumentColumns.DISPLAY_NAME, displayName); + return (resolver.update(documentUri, values, null, null) == 1); + } +} diff --git a/core/java/android/provider/DrmStore.java b/core/java/android/provider/DrmStore.java deleted file mode 100644 index 34f2f0d..0000000 --- a/core/java/android/provider/DrmStore.java +++ /dev/null @@ -1,211 +0,0 @@ -/* - * Copyright (C) 2008 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.provider; - -import android.content.ContentResolver; -import android.content.ContentValues; -import android.content.Context; -import android.drm.mobile1.DrmRawContent; -import android.drm.mobile1.DrmRights; -import android.drm.mobile1.DrmRightsManager; -import android.content.Intent; -import android.content.pm.PackageManager; -import android.net.Uri; -import android.util.Log; - -import java.io.File; -import java.io.FileInputStream; -import java.io.InputStream; -import java.io.IOException; -import java.io.OutputStream; - -/** - * The DRM provider contains forward locked DRM content. - * - * @hide - */ -public final class DrmStore -{ - private static final String TAG = "DrmStore"; - - public static final String AUTHORITY = "drm"; - - /** - * This is in the Manifest class of the drm provider, but that isn't visible - * in the framework. - */ - private static final String ACCESS_DRM_PERMISSION = "android.permission.ACCESS_DRM"; - - /** - * Fields for DRM database - */ - - public interface Columns extends BaseColumns { - /** - * The data stream for the file - * <P>Type: DATA STREAM</P> - */ - public static final String DATA = "_data"; - - /** - * The size of the file in bytes - * <P>Type: INTEGER (long)</P> - */ - public static final String SIZE = "_size"; - - /** - * The title of the file content - * <P>Type: TEXT</P> - */ - public static final String TITLE = "title"; - - /** - * The MIME type of the file - * <P>Type: TEXT</P> - */ - public static final String MIME_TYPE = "mime_type"; - - } - - public interface Images extends Columns { - - public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/images"); - } - - public interface Audio extends Columns { - - public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/audio"); - } - - /** - * Utility function for inserting a file into the DRM content provider. - * - * @param cr The content resolver to use - * @param file The file to insert - * @param title The title for the content (or null) - * @return uri to the DRM record or null - */ - public static final Intent addDrmFile(ContentResolver cr, File file, String title) { - FileInputStream fis = null; - Intent result = null; - - try { - fis = new FileInputStream(file); - if (title == null) { - title = file.getName(); - int lastDot = title.lastIndexOf('.'); - if (lastDot > 0) { - title = title.substring(0, lastDot); - } - } - result = addDrmFile(cr, fis, title); - } catch (Exception e) { - Log.e(TAG, "pushing file failed", e); - } finally { - try { - if (fis != null) - fis.close(); - } catch (IOException e) { - Log.e(TAG, "IOException in DrmStore.addDrmFile()", e); - } - } - - return result; - } - - /** - * Utility function for inserting a file stream into the DRM content provider. - * - * @param cr The content resolver to use - * @param fis The FileInputStream to insert - * @param title The title for the content (or null) - * @return uri to the DRM record or null - */ - public static final Intent addDrmFile(ContentResolver cr, FileInputStream fis, String title) { - OutputStream os = null; - Intent result = null; - - try { - DrmRawContent content = new DrmRawContent(fis, (int) fis.available(), - DrmRawContent.DRM_MIMETYPE_MESSAGE_STRING); - String mimeType = content.getContentType(); - long size = fis.getChannel().size(); - - DrmRightsManager manager = manager = DrmRightsManager.getInstance(); - DrmRights rights = manager.queryRights(content); - InputStream stream = content.getContentInputStream(rights); - - Uri contentUri = null; - if (mimeType.startsWith("audio/")) { - contentUri = DrmStore.Audio.CONTENT_URI; - } else if (mimeType.startsWith("image/")) { - contentUri = DrmStore.Images.CONTENT_URI; - } else { - Log.w(TAG, "unsupported mime type " + mimeType); - } - - if (contentUri != null) { - ContentValues values = new ContentValues(3); - values.put(DrmStore.Columns.TITLE, title); - values.put(DrmStore.Columns.SIZE, size); - values.put(DrmStore.Columns.MIME_TYPE, mimeType); - - Uri uri = cr.insert(contentUri, values); - if (uri != null) { - os = cr.openOutputStream(uri); - - byte[] buffer = new byte[1000]; - int count; - - while ((count = stream.read(buffer)) != -1) { - os.write(buffer, 0, count); - } - result = new Intent(); - result.setDataAndType(uri, mimeType); - - } - } - } catch (Exception e) { - Log.e(TAG, "pushing file failed", e); - } finally { - try { - if (fis != null) - fis.close(); - if (os != null) - os.close(); - } catch (IOException e) { - Log.e(TAG, "IOException in DrmStore.addDrmFile()", e); - } - } - - return result; - } - - /** - * Utility function to enforce any permissions required to access DRM - * content. - * - * @param context A context used for checking calling permission. - */ - public static void enforceAccessDrmPermission(Context context) { - if (context.checkCallingOrSelfPermission(ACCESS_DRM_PERMISSION) != - PackageManager.PERMISSION_GRANTED) { - throw new SecurityException("Requires DRM permission"); - } - } - -} diff --git a/core/java/android/provider/OpenableColumns.java b/core/java/android/provider/OpenableColumns.java index f548bae..faf96b7 100644 --- a/core/java/android/provider/OpenableColumns.java +++ b/core/java/android/provider/OpenableColumns.java @@ -16,11 +16,17 @@ package android.provider; +import android.content.ContentResolver; +import android.content.Intent; + /** - * These are standard columns for openable URIs. (See - * {@link android.content.Intent#CATEGORY_OPENABLE}.) If possible providers that have openable URIs - * should support these columns. To find the content type of a URI use - * {@link android.content.ContentResolver#getType(android.net.Uri)} as normal. + * These are standard columns for openable URIs. Providers that serve openable + * URIs <em>must</em> support at least these columns when queried. + * <p> + * To find the content type of a URI, use + * {@link ContentResolver#getType(android.net.Uri)}. + * + * @see Intent#CATEGORY_OPENABLE */ public interface OpenableColumns { diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java index 4de5933..9164aa6 100644 --- a/core/java/android/provider/Settings.java +++ b/core/java/android/provider/Settings.java @@ -1011,6 +1011,14 @@ public final class Settings { MOVED_TO_GLOBAL.add(Settings.Global.WAIT_FOR_DEBUGGER); MOVED_TO_GLOBAL.add(Settings.Global.SHOW_PROCESSES); MOVED_TO_GLOBAL.add(Settings.Global.ALWAYS_FINISH_ACTIVITIES); + MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_CONTENT_URL); + MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_METADATA_URL); + MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_CONTENT_URL); + MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_METADATA_URL); + MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_CONTENT_URL); + MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_METADATA_URL); + MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_CONTENT_URL); + MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_METADATA_URL); } /** @hide */ diff --git a/core/java/android/text/method/ArrowKeyMovementMethod.java b/core/java/android/text/method/ArrowKeyMovementMethod.java index 30bb447..ba6f1d4 100644 --- a/core/java/android/text/method/ArrowKeyMovementMethod.java +++ b/core/java/android/text/method/ArrowKeyMovementMethod.java @@ -56,7 +56,7 @@ public class ArrowKeyMovementMethod extends BaseMovementMethod implements Moveme if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0 && MetaKeyKeyListener.getMetaState(buffer, - MetaKeyKeyListener.META_SELECTING) != 0) { + MetaKeyKeyListener.META_SELECTING, event) != 0) { return widget.showContextMenu(); } } diff --git a/core/java/android/text/method/BaseKeyListener.java b/core/java/android/text/method/BaseKeyListener.java index 4fede32..63607fa 100644 --- a/core/java/android/text/method/BaseKeyListener.java +++ b/core/java/android/text/method/BaseKeyListener.java @@ -75,7 +75,7 @@ public abstract class BaseKeyListener extends MetaKeyKeyListener } // Alt+Backspace or Alt+ForwardDelete deletes the current line, if possible. - if (event.isAltPressed() || getMetaState(content, META_ALT_ON) == 1) { + if (getMetaState(content, META_ALT_ON, event) == 1) { if (deleteLine(view, content)) { return true; } diff --git a/core/java/android/text/method/BaseMovementMethod.java b/core/java/android/text/method/BaseMovementMethod.java index 113a4be..155a2c4 100644 --- a/core/java/android/text/method/BaseMovementMethod.java +++ b/core/java/android/text/method/BaseMovementMethod.java @@ -135,7 +135,7 @@ public class BaseMovementMethod implements MovementMethod { */ protected int getMovementMetaState(Spannable buffer, KeyEvent event) { // We ignore locked modifiers and SHIFT. - int metaState = (event.getMetaState() | MetaKeyKeyListener.getMetaState(buffer)) + int metaState = MetaKeyKeyListener.getMetaState(buffer, event) & ~(MetaKeyKeyListener.META_ALT_LOCKED | MetaKeyKeyListener.META_SYM_LOCKED); return KeyEvent.normalizeMetaState(metaState) & ~KeyEvent.META_SHIFT_MASK; } diff --git a/core/java/android/text/method/DialerKeyListener.java b/core/java/android/text/method/DialerKeyListener.java index ce51fae..bb8b0de 100644 --- a/core/java/android/text/method/DialerKeyListener.java +++ b/core/java/android/text/method/DialerKeyListener.java @@ -53,7 +53,7 @@ public class DialerKeyListener extends NumberKeyListener * from the KeyEvent. */ protected int lookup(KeyEvent event, Spannable content) { - int meta = event.getMetaState() | getMetaState(content); + int meta = getMetaState(content, event); int number = event.getNumber(); /* diff --git a/core/java/android/text/method/MetaKeyKeyListener.java b/core/java/android/text/method/MetaKeyKeyListener.java index 0a097f9..e9db5fd 100644 --- a/core/java/android/text/method/MetaKeyKeyListener.java +++ b/core/java/android/text/method/MetaKeyKeyListener.java @@ -135,6 +135,9 @@ public abstract class MetaKeyKeyListener { private static final Object SYM = new NoCopySpan.Concrete(); private static final Object SELECTING = new NoCopySpan.Concrete(); + private static final int PRESSED_RETURN_VALUE = 1; + private static final int LOCKED_RETURN_VALUE = 2; + /** * Resets all meta state to inactive. */ @@ -161,9 +164,34 @@ public abstract class MetaKeyKeyListener { } /** + * Gets the state of the meta keys for a specific key event. + * + * For input devices that use toggled key modifiers, the `toggled' state + * is stored into the text buffer. This method retrieves the meta state + * for this event, accounting for the stored state. If the event has been + * created by a device that does not support toggled key modifiers, like + * a virtual device for example, the stored state is ignored. + * + * @param text the buffer in which the meta key would have been pressed. + * @param event the event for which to evaluate the meta state. + * @return an integer in which each bit set to one represents a pressed + * or locked meta key. + */ + public static final int getMetaState(final CharSequence text, final KeyEvent event) { + int metaState = event.getMetaState(); + if (event.getKeyCharacterMap().getModifierBehavior() + == KeyCharacterMap.MODIFIER_BEHAVIOR_CHORDED_OR_TOGGLED) { + metaState |= getMetaState(text); + } + return metaState; + } + + // As META_SELECTING is @hide we should not mention it in public comments, hence the + // omission in @param meta + /** * Gets the state of a particular meta key. * - * @param meta META_SHIFT_ON, META_ALT_ON, META_SYM_ON, or META_SELECTING + * @param meta META_SHIFT_ON, META_ALT_ON, META_SYM_ON * @param text the buffer in which the meta key would have been pressed. * * @return 0 if inactive, 1 if active, 2 if locked. @@ -171,22 +199,53 @@ public abstract class MetaKeyKeyListener { public static final int getMetaState(CharSequence text, int meta) { switch (meta) { case META_SHIFT_ON: - return getActive(text, CAP, 1, 2); + return getActive(text, CAP, PRESSED_RETURN_VALUE, LOCKED_RETURN_VALUE); case META_ALT_ON: - return getActive(text, ALT, 1, 2); + return getActive(text, ALT, PRESSED_RETURN_VALUE, LOCKED_RETURN_VALUE); case META_SYM_ON: - return getActive(text, SYM, 1, 2); + return getActive(text, SYM, PRESSED_RETURN_VALUE, LOCKED_RETURN_VALUE); case META_SELECTING: - return getActive(text, SELECTING, 1, 2); + return getActive(text, SELECTING, PRESSED_RETURN_VALUE, LOCKED_RETURN_VALUE); default: return 0; } } + /** + * Gets the state of a particular meta key to use with a particular key event. + * + * If the key event has been created by a device that does not support toggled + * key modifiers, like a virtual keyboard for example, only the meta state in + * the key event is considered. + * + * @param meta META_SHIFT_ON, META_ALT_ON, META_SYM_ON + * @param text the buffer in which the meta key would have been pressed. + * @param event the event for which to evaluate the meta state. + * @return 0 if inactive, 1 if active, 2 if locked. + */ + public static final int getMetaState(final CharSequence text, final int meta, + final KeyEvent event) { + int metaState = event.getMetaState(); + if (event.getKeyCharacterMap().getModifierBehavior() + == KeyCharacterMap.MODIFIER_BEHAVIOR_CHORDED_OR_TOGGLED) { + metaState |= getMetaState(text); + } + if (META_SELECTING == meta) { + // #getMetaState(long, int) does not support META_SELECTING, but we want the same + // behavior as #getMetaState(CharSequence, int) so we need to do it here + if ((metaState & META_SELECTING) != 0) { + // META_SELECTING is only ever set to PRESSED and can't be LOCKED, so return 1 + return 1; + } + return 0; + } + return getMetaState(metaState, meta); + } + private static int getActive(CharSequence text, Object meta, int on, int lock) { if (!(text instanceof Spanned)) { @@ -430,18 +489,18 @@ public abstract class MetaKeyKeyListener { public static final int getMetaState(long state, int meta) { switch (meta) { case META_SHIFT_ON: - if ((state & META_CAP_LOCKED) != 0) return 2; - if ((state & META_SHIFT_ON) != 0) return 1; + if ((state & META_CAP_LOCKED) != 0) return LOCKED_RETURN_VALUE; + if ((state & META_SHIFT_ON) != 0) return PRESSED_RETURN_VALUE; return 0; case META_ALT_ON: - if ((state & META_ALT_LOCKED) != 0) return 2; - if ((state & META_ALT_ON) != 0) return 1; + if ((state & META_ALT_LOCKED) != 0) return LOCKED_RETURN_VALUE; + if ((state & META_ALT_ON) != 0) return PRESSED_RETURN_VALUE; return 0; case META_SYM_ON: - if ((state & META_SYM_LOCKED) != 0) return 2; - if ((state & META_SYM_ON) != 0) return 1; + if ((state & META_SYM_LOCKED) != 0) return LOCKED_RETURN_VALUE; + if ((state & META_SYM_ON) != 0) return PRESSED_RETURN_VALUE; return 0; default: @@ -599,4 +658,3 @@ public abstract class MetaKeyKeyListener { private static final int LOCKED = Spannable.SPAN_MARK_MARK | (4 << Spannable.SPAN_USER_SHIFT); } - diff --git a/core/java/android/text/method/NumberKeyListener.java b/core/java/android/text/method/NumberKeyListener.java index 5d4c732..988d566 100644 --- a/core/java/android/text/method/NumberKeyListener.java +++ b/core/java/android/text/method/NumberKeyListener.java @@ -41,7 +41,7 @@ public abstract class NumberKeyListener extends BaseKeyListener protected abstract char[] getAcceptedChars(); protected int lookup(KeyEvent event, Spannable content) { - return event.getMatch(getAcceptedChars(), event.getMetaState() | getMetaState(content)); + return event.getMatch(getAcceptedChars(), getMetaState(content, event)); } public CharSequence filter(CharSequence source, int start, int end, diff --git a/core/java/android/text/method/QwertyKeyListener.java b/core/java/android/text/method/QwertyKeyListener.java index 98316ae..0bd46bc 100644 --- a/core/java/android/text/method/QwertyKeyListener.java +++ b/core/java/android/text/method/QwertyKeyListener.java @@ -108,7 +108,7 @@ public class QwertyKeyListener extends BaseKeyListener { // QWERTY keyboard normal case - int i = event.getUnicodeChar(event.getMetaState() | getMetaState(content)); + int i = event.getUnicodeChar(getMetaState(content, event)); if (!mFullKeyboard) { int count = event.getRepeatCount(); diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java index 2ec9a7d..cc7d948 100644 --- a/core/java/android/view/GLES20Canvas.java +++ b/core/java/android/view/GLES20Canvas.java @@ -21,6 +21,7 @@ import android.graphics.Canvas; import android.graphics.ColorFilter; import android.graphics.DrawFilter; import android.graphics.Matrix; +import android.graphics.NinePatch; import android.graphics.Paint; import android.graphics.PaintFlagsDrawFilter; import android.graphics.Path; @@ -273,6 +274,18 @@ class GLES20Canvas extends HardwareCanvas { private static native int nGetStencilSize(); + void setCountOverdrawEnabled(boolean enabled) { + nSetCountOverdrawEnabled(mRenderer, enabled); + } + + static native void nSetCountOverdrawEnabled(int renderer, boolean enabled); + + float getOverdraw() { + return nGetOverdraw(mRenderer); + } + + static native float nGetOverdraw(int renderer); + /////////////////////////////////////////////////////////////////////////// // Functor /////////////////////////////////////////////////////////////////////////// @@ -314,21 +327,21 @@ class GLES20Canvas extends HardwareCanvas { * * @see #flushCaches(int) */ - public static final int FLUSH_CACHES_LAYERS = 0; + static final int FLUSH_CACHES_LAYERS = 0; /** * Must match Caches::FlushMode values * * @see #flushCaches(int) */ - public static final int FLUSH_CACHES_MODERATE = 1; + static final int FLUSH_CACHES_MODERATE = 1; /** * Must match Caches::FlushMode values * * @see #flushCaches(int) */ - public static final int FLUSH_CACHES_FULL = 2; + static final int FLUSH_CACHES_FULL = 2; /** * Flush caches to reclaim as much memory as possible. The amount of memory @@ -338,10 +351,8 @@ class GLES20Canvas extends HardwareCanvas { * {@link #FLUSH_CACHES_FULL}. * * @param level Hint about the amount of memory to reclaim - * - * @hide */ - public static void flushCaches(int level) { + static void flushCaches(int level) { nFlushCaches(level); } @@ -353,21 +364,28 @@ class GLES20Canvas extends HardwareCanvas { * * @hide */ - public static void terminateCaches() { + static void terminateCaches() { nTerminateCaches(); } private static native void nTerminateCaches(); - /** - * @hide - */ - public static void initCaches() { - nInitCaches(); + static boolean initCaches() { + return nInitCaches(); } - private static native void nInitCaches(); - + private static native boolean nInitCaches(); + + /////////////////////////////////////////////////////////////////////////// + // Atlas + /////////////////////////////////////////////////////////////////////////// + + static void initAtlas(GraphicBuffer buffer, int[] map) { + nInitAtlas(buffer, map, map.length); + } + + private static native void nInitAtlas(GraphicBuffer buffer, int[] map, int count); + /////////////////////////////////////////////////////////////////////////// // Display list /////////////////////////////////////////////////////////////////////////// @@ -718,20 +736,21 @@ class GLES20Canvas extends HardwareCanvas { } @Override - public void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint) { + public void drawPatch(NinePatch patch, RectF dst, Paint paint) { + Bitmap bitmap = patch.getBitmap(); if (bitmap.isRecycled()) throw new IllegalArgumentException("Cannot draw recycled bitmaps"); // Shaders are ignored when drawing patches int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE; try { final int nativePaint = paint == null ? 0 : paint.mNativePaint; - nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, chunks, + nDrawPatch(mRenderer, bitmap.mNativeBitmap, patch.mChunk, dst.left, dst.top, dst.right, dst.bottom, nativePaint); } finally { if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier); } } - private static native void nDrawPatch(int renderer, int bitmap, byte[] buffer, byte[] chunks, + private static native void nDrawPatch(int renderer, int bitmap, byte[] chunks, float left, float top, float right, float bottom, int paint); @Override @@ -741,14 +760,14 @@ class GLES20Canvas extends HardwareCanvas { int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE; try { final int nativePaint = paint == null ? 0 : paint.mNativePaint; - nDrawBitmap(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, left, top, nativePaint); + nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, nativePaint); } finally { if (modifiers != MODIFIER_NONE) nResetModifiers(mRenderer, modifiers); } } - private static native void nDrawBitmap( - int renderer, int bitmap, byte[] buffer, float left, float top, int paint); + private static native void nDrawBitmap(int renderer, int bitmap, + float left, float top, int paint); @Override public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) { @@ -757,15 +776,13 @@ class GLES20Canvas extends HardwareCanvas { int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE; try { final int nativePaint = paint == null ? 0 : paint.mNativePaint; - nDrawBitmap(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, - matrix.native_instance, nativePaint); + nDrawBitmap(mRenderer, bitmap.mNativeBitmap, matrix.native_instance, nativePaint); } finally { if (modifiers != MODIFIER_NONE) nResetModifiers(mRenderer, modifiers); } } - private static native void nDrawBitmap(int renderer, int bitmap, byte[] buff, - int matrix, int paint); + private static native void nDrawBitmap(int renderer, int bitmap, int matrix, int paint); @Override public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) { @@ -787,7 +804,7 @@ class GLES20Canvas extends HardwareCanvas { bottom = src.bottom; } - nDrawBitmap(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, left, top, right, bottom, + nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, right, bottom, dst.left, dst.top, dst.right, dst.bottom, nativePaint); } finally { if (modifiers != MODIFIER_NONE) nResetModifiers(mRenderer, modifiers); @@ -814,14 +831,14 @@ class GLES20Canvas extends HardwareCanvas { bottom = src.bottom; } - nDrawBitmap(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, left, top, right, bottom, + nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, right, bottom, dst.left, dst.top, dst.right, dst.bottom, nativePaint); } finally { if (modifiers != MODIFIER_NONE) nResetModifiers(mRenderer, modifiers); } } - private static native void nDrawBitmap(int renderer, int bitmap, byte[] buffer, + private static native void nDrawBitmap(int renderer, int bitmap, float srcLeft, float srcTop, float srcRight, float srcBottom, float left, float top, float right, float bottom, int paint); @@ -891,14 +908,14 @@ class GLES20Canvas extends HardwareCanvas { int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE; try { final int nativePaint = paint == null ? 0 : paint.mNativePaint; - nDrawBitmapMesh(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, meshWidth, meshHeight, + nDrawBitmapMesh(mRenderer, bitmap.mNativeBitmap, meshWidth, meshHeight, verts, vertOffset, colors, colorOffset, nativePaint); } finally { if (modifiers != MODIFIER_NONE) nResetModifiers(mRenderer, modifiers); } } - private static native void nDrawBitmapMesh(int renderer, int bitmap, byte[] buffer, + private static native void nDrawBitmapMesh(int renderer, int bitmap, int meshWidth, int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset, int paint); diff --git a/core/java/android/view/GLES20DisplayList.java b/core/java/android/view/GLES20DisplayList.java index 3272504..d367267 100644 --- a/core/java/android/view/GLES20DisplayList.java +++ b/core/java/android/view/GLES20DisplayList.java @@ -18,6 +18,7 @@ package android.view; import android.graphics.Bitmap; import android.graphics.Matrix; +import android.graphics.NinePatch; import java.util.ArrayList; @@ -29,7 +30,8 @@ class GLES20DisplayList extends DisplayList { // alive as long as the DisplayList is alive. The Bitmap and DisplayList lists // are populated by the GLES20RecordingCanvas during appropriate drawing calls and are // cleared at the start of a new drawing frame or when the view is detached from the window. - final ArrayList<Bitmap> mBitmaps = new ArrayList<Bitmap>(5); + final ArrayList<Bitmap> mBitmaps = new ArrayList<Bitmap>(10); + final ArrayList<NinePatch> mNinePatches = new ArrayList<NinePatch>(10); final ArrayList<DisplayList> mChildDisplayLists = new ArrayList<DisplayList>(); private GLES20RecordingCanvas mCanvas; @@ -83,7 +85,12 @@ class GLES20DisplayList extends DisplayList { } mValid = false; + clearReferences(); + } + + void clearReferences() { mBitmaps.clear(); + mNinePatches.clear(); mChildDisplayLists.clear(); } diff --git a/core/java/android/view/GLES20RecordingCanvas.java b/core/java/android/view/GLES20RecordingCanvas.java index 7da2451..ec059d5 100644 --- a/core/java/android/view/GLES20RecordingCanvas.java +++ b/core/java/android/view/GLES20RecordingCanvas.java @@ -19,6 +19,7 @@ package android.view; import android.graphics.Bitmap; import android.graphics.BitmapShader; import android.graphics.Matrix; +import android.graphics.NinePatch; import android.graphics.Paint; import android.graphics.Path; import android.graphics.Rect; @@ -62,8 +63,7 @@ class GLES20RecordingCanvas extends GLES20Canvas { } void start() { - mDisplayList.mBitmaps.clear(); - mDisplayList.mChildDisplayLists.clear(); + mDisplayList.clearReferences(); } int end(int nativeDisplayList) { @@ -80,9 +80,10 @@ class GLES20RecordingCanvas extends GLES20Canvas { } @Override - public void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint) { - super.drawPatch(bitmap, chunks, dst, paint); - mDisplayList.mBitmaps.add(bitmap); + public void drawPatch(NinePatch patch, RectF dst, Paint paint) { + super.drawPatch(patch, dst, paint); + mDisplayList.mBitmaps.add(patch.getBitmap()); + mDisplayList.mNinePatches.add(patch); // Shaders in the Paint are ignored when drawing a Bitmap } diff --git a/core/java/android/view/GLES20RenderLayer.java b/core/java/android/view/GLES20RenderLayer.java index 685dc70..68ba77c 100644 --- a/core/java/android/view/GLES20RenderLayer.java +++ b/core/java/android/view/GLES20RenderLayer.java @@ -100,12 +100,17 @@ class GLES20RenderLayer extends GLES20Layer { @Override HardwareCanvas start(Canvas currentCanvas) { + return start(currentCanvas, null); + } + + @Override + HardwareCanvas start(Canvas currentCanvas, Rect dirty) { if (currentCanvas instanceof GLES20Canvas) { ((GLES20Canvas) currentCanvas).interrupt(); } HardwareCanvas canvas = getCanvas(); canvas.setViewport(mWidth, mHeight); - canvas.onPreDraw(null); + canvas.onPreDraw(dirty); return canvas; } diff --git a/core/java/android/view/GLES20TextureLayer.java b/core/java/android/view/GLES20TextureLayer.java index e863e49..a4cc630 100644 --- a/core/java/android/view/GLES20TextureLayer.java +++ b/core/java/android/view/GLES20TextureLayer.java @@ -63,6 +63,11 @@ class GLES20TextureLayer extends GLES20Layer { } @Override + HardwareCanvas start(Canvas currentCanvas, Rect dirty) { + return null; + } + + @Override void end(Canvas currentCanvas) { } diff --git a/core/java/android/view/GraphicBuffer.aidl b/core/java/android/view/GraphicBuffer.aidl new file mode 100644 index 0000000..6dc6bed --- /dev/null +++ b/core/java/android/view/GraphicBuffer.aidl @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2013 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.view; + +parcelable GraphicBuffer; diff --git a/core/java/android/view/GraphicBuffer.java b/core/java/android/view/GraphicBuffer.java new file mode 100644 index 0000000..b4576f3 --- /dev/null +++ b/core/java/android/view/GraphicBuffer.java @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2013 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.view; + +import android.graphics.Canvas; +import android.graphics.PixelFormat; +import android.graphics.Rect; +import android.os.Parcel; +import android.os.Parcelable; + +/** + * Simple wrapper for the native GraphicBuffer class. + * + * @hide + */ +@SuppressWarnings("UnusedDeclaration") +public class GraphicBuffer implements Parcelable { + // Note: keep usage flags in sync with GraphicBuffer.h and gralloc.h + public static final int USAGE_SW_READ_NEVER = 0x0; + public static final int USAGE_SW_READ_RARELY = 0x2; + public static final int USAGE_SW_READ_OFTEN = 0x3; + public static final int USAGE_SW_READ_MASK = 0xF; + + public static final int USAGE_SW_WRITE_NEVER = 0x0; + public static final int USAGE_SW_WRITE_RARELY = 0x20; + public static final int USAGE_SW_WRITE_OFTEN = 0x30; + public static final int USAGE_SW_WRITE_MASK = 0xF0; + + public static final int USAGE_SOFTWARE_MASK = USAGE_SW_READ_MASK | USAGE_SW_WRITE_MASK; + + public static final int USAGE_PROTECTED = 0x4000; + + public static final int USAGE_HW_TEXTURE = 0x100; + public static final int USAGE_HW_RENDER = 0x200; + public static final int USAGE_HW_2D = 0x400; + public static final int USAGE_HW_COMPOSER = 0x800; + public static final int USAGE_HW_VIDEO_ENCODER = 0x10000; + public static final int USAGE_HW_MASK = 0x71F00; + + private final int mWidth; + private final int mHeight; + private final int mFormat; + private final int mUsage; + // Note: do not rename, this field is used by native code + private final int mNativeObject; + + // These two fields are only used by lock/unlockCanvas() + private Canvas mCanvas; + private int mSaveCount; + + /** + * Creates new <code>GraphicBuffer</code> instance. This method will return null + * if the buffer cannot be created. + * + * @param width The width in pixels of the buffer + * @param height The height in pixels of the buffer + * @param format The format of each pixel as specified in {@link PixelFormat} + * @param usage Hint indicating how the buffer will be used + * + * @return A <code>GraphicBuffer</code> instance or null + */ + public static GraphicBuffer create(int width, int height, int format, int usage) { + int nativeObject = nCreateGraphicBuffer(width, height, format, usage); + if (nativeObject != 0) { + return new GraphicBuffer(width, height, format, usage, nativeObject); + } + return null; + } + + /** + * Private use only. See {@link #create(int, int, int, int)}. + */ + private GraphicBuffer(int width, int height, int format, int usage, int nativeObject) { + mWidth = width; + mHeight = height; + mFormat = format; + mUsage = usage; + mNativeObject = nativeObject; + } + + /** + * Returns the width of this buffer in pixels. + */ + public int getWidth() { + return mWidth; + } + + /** + * Returns the height of this buffer in pixels. + */ + public int getHeight() { + return mHeight; + } + + /** + * Returns the pixel format of this buffer. The pixel format must be one of + * the formats defined in {@link PixelFormat}. + */ + public int getFormat() { + return mFormat; + } + + /** + * Returns the usage hint set on this buffer. + */ + public int getUsage() { + return mUsage; + } + + /** + * <p>Start editing the pixels in the buffer. A null is returned if the buffer + * cannot be locked for editing.</p> + * + * <p>The content of the buffer is preserved between unlockCanvas() + * and lockCanvas().</p> + * + * @return A Canvas used to draw into the buffer, or null. + * + * @see #lockCanvas(android.graphics.Rect) + * @see #unlockCanvasAndPost(android.graphics.Canvas) + */ + public Canvas lockCanvas() { + return lockCanvas(null); + } + + /** + * Just like {@link #lockCanvas()} but allows specification of a dirty + * rectangle. + * + * @param dirty Area of the buffer that may be modified. + + * @return A Canvas used to draw into the surface or null + * + * @see #lockCanvas() + * @see #unlockCanvasAndPost(android.graphics.Canvas) + */ + public Canvas lockCanvas(Rect dirty) { + if (mCanvas == null) { + mCanvas = new Canvas(); + } + + if (nLockCanvas(mNativeObject, mCanvas, dirty)) { + mSaveCount = mCanvas.save(); + return mCanvas; + } + + return null; + } + + /** + * Finish editing pixels in the buffer. + * + * @param canvas The Canvas previously returned by lockCanvas() + * + * @see #lockCanvas() + * @see #lockCanvas(android.graphics.Rect) + */ + public void unlockCanvasAndPost(Canvas canvas) { + if (mCanvas != null && canvas == mCanvas) { + canvas.restoreToCount(mSaveCount); + mSaveCount = 0; + + nUnlockCanvasAndPost(mNativeObject, mCanvas); + } + } + + @Override + protected void finalize() throws Throwable { + try { + nDestroyGraphicBuffer(mNativeObject); + } finally { + super.finalize(); + } + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(mWidth); + dest.writeInt(mHeight); + dest.writeInt(mFormat); + dest.writeInt(mUsage); + nWriteGraphicBufferToParcel(mNativeObject, dest); + } + + public static final Parcelable.Creator<GraphicBuffer> CREATOR = + new Parcelable.Creator<GraphicBuffer>() { + public GraphicBuffer createFromParcel(Parcel in) { + int width = in.readInt(); + int height = in.readInt(); + int format = in.readInt(); + int usage = in.readInt(); + int nativeObject = nReadGraphicBufferFromParcel(in); + if (nativeObject != 0) { + return new GraphicBuffer(width, height, format, usage, nativeObject); + } + return null; + } + + public GraphicBuffer[] newArray(int size) { + return new GraphicBuffer[size]; + } + }; + + private static native int nCreateGraphicBuffer(int width, int height, int format, int usage); + private static native void nDestroyGraphicBuffer(int nativeObject); + private static native void nWriteGraphicBufferToParcel(int nativeObject, Parcel dest); + private static native int nReadGraphicBufferFromParcel(Parcel in); + private static native boolean nLockCanvas(int nativeObject, Canvas canvas, Rect dirty); + private static native boolean nUnlockCanvasAndPost(int nativeObject, Canvas canvas); +} diff --git a/core/java/android/view/HardwareLayer.java b/core/java/android/view/HardwareLayer.java index 18b838b..23383d9 100644 --- a/core/java/android/view/HardwareLayer.java +++ b/core/java/android/view/HardwareLayer.java @@ -158,14 +158,22 @@ abstract class HardwareLayer { /** * This must be invoked before drawing onto this layer. * - * @param currentCanvas + * @param currentCanvas The canvas whose rendering needs to be interrupted */ abstract HardwareCanvas start(Canvas currentCanvas); /** + * This must be invoked before drawing onto this layer. + * + * @param dirty The dirty area to repaint + * @param currentCanvas The canvas whose rendering needs to be interrupted + */ + abstract HardwareCanvas start(Canvas currentCanvas, Rect dirty); + + /** * This must be invoked after drawing onto this layer. * - * @param currentCanvas + * @param currentCanvas The canvas whose rendering needs to be resumed */ abstract void end(Canvas currentCanvas); diff --git a/core/java/android/view/HardwareRenderer.java b/core/java/android/view/HardwareRenderer.java index 8308459..e8c1653 100644 --- a/core/java/android/view/HardwareRenderer.java +++ b/core/java/android/view/HardwareRenderer.java @@ -17,6 +17,7 @@ package android.view; import android.content.ComponentCallbacks2; +import android.graphics.Color; import android.graphics.Paint; import android.graphics.Rect; import android.graphics.SurfaceTexture; @@ -24,7 +25,10 @@ import android.opengl.EGL14; import android.opengl.GLUtils; import android.opengl.ManagedEGLContext; import android.os.Handler; +import android.os.IBinder; import android.os.Looper; +import android.os.RemoteException; +import android.os.ServiceManager; import android.os.SystemClock; import android.os.SystemProperties; import android.os.Trace; @@ -42,7 +46,6 @@ import javax.microedition.khronos.opengles.GL; import java.io.File; import java.io.PrintWriter; -import java.util.Arrays; import java.util.concurrent.locks.ReentrantLock; import static javax.microedition.khronos.egl.EGL10.*; @@ -162,15 +165,32 @@ public abstract class HardwareRenderer { "debug.hwui.show_layers_updates"; /** - * Turn on to show overdraw level. + * Controls overdraw debugging. * * Possible values: - * "true", to enable overdraw debugging * "false", to disable overdraw debugging + * "show", to show overdraw areas on screen + * "count", to display an overdraw counter * * @hide */ - public static final String DEBUG_SHOW_OVERDRAW_PROPERTY = "debug.hwui.show_overdraw"; + public static final String DEBUG_OVERDRAW_PROPERTY = "debug.hwui.overdraw"; + + /** + * Value for {@link #DEBUG_OVERDRAW_PROPERTY}. When the property is set to this + * value, overdraw will be shown on screen by coloring pixels. + * + * @hide + */ + public static final String OVERDRAW_PROPERTY_SHOW = "show"; + + /** + * Value for {@link #DEBUG_OVERDRAW_PROPERTY}. When the property is set to this + * value, an overdraw counter will be shown on screen. + * + * @hide + */ + public static final String OVERDRAW_PROPERTY_COUNT = "count"; /** * Turn on to debug non-rectangular clip operations. @@ -762,6 +782,17 @@ public abstract class HardwareRenderer { private static final int PROFILE_DRAW_THRESHOLD_STROKE_WIDTH = 2; private static final int PROFILE_DRAW_DP_PER_MS = 7; + private static final String[] VISUALIZERS = { + PROFILE_PROPERTY_VISUALIZE_BARS, + PROFILE_PROPERTY_VISUALIZE_LINES + }; + + private static final String[] OVERDRAW = { + OVERDRAW_PROPERTY_SHOW, + OVERDRAW_PROPERTY_COUNT + }; + private static final int OVERDRAW_TYPE_COUNT = 1; + static EGL10 sEgl; static EGLDisplay sEglDisplay; static EGLConfig sEglConfig; @@ -807,7 +838,9 @@ public abstract class HardwareRenderer { Paint mProfilePaint; boolean mDebugDirtyRegions; - boolean mShowOverdraw; + int mDebugOverdraw = -1; + HardwareLayer mDebugOverdrawLayer; + Paint mDebugOverdrawPaint; final int mGlVersion; final boolean mTranslucent; @@ -826,18 +859,13 @@ public abstract class HardwareRenderer { loadSystemProperties(null); } - private static final String[] VISUALIZERS = { - PROFILE_PROPERTY_VISUALIZE_BARS, - PROFILE_PROPERTY_VISUALIZE_LINES - }; - @Override boolean loadSystemProperties(Surface surface) { boolean value; boolean changed = false; String profiling = SystemProperties.get(PROFILE_PROPERTY); - int graphType = Arrays.binarySearch(VISUALIZERS, profiling); + int graphType = search(VISUALIZERS, profiling); value = graphType >= 0; if (graphType != mProfileVisualizerType) { @@ -894,11 +922,19 @@ public abstract class HardwareRenderer { } } - value = SystemProperties.getBoolean( - HardwareRenderer.DEBUG_SHOW_OVERDRAW_PROPERTY, false); - if (value != mShowOverdraw) { + String overdraw = SystemProperties.get(HardwareRenderer.DEBUG_OVERDRAW_PROPERTY); + int debugOverdraw = search(OVERDRAW, overdraw); + if (debugOverdraw != mDebugOverdraw) { changed = true; - mShowOverdraw = value; + mDebugOverdraw = debugOverdraw; + + if (mDebugOverdraw != OVERDRAW_TYPE_COUNT) { + if (mDebugOverdrawLayer != null) { + mDebugOverdrawLayer.destroy(); + mDebugOverdrawLayer = null; + mDebugOverdrawPaint = null; + } + } } if (nLoadProperties()) { @@ -908,6 +944,13 @@ public abstract class HardwareRenderer { return changed; } + private static int search(String[] values, String value) { + for (int i = 0; i < values.length; i++) { + if (values[i].equals(value)) return i; + } + return -1; + } + @Override void dumpGfxInfo(PrintWriter pw) { if (mProfileEnabled) { @@ -968,7 +1011,7 @@ public abstract class HardwareRenderer { if (fallback) { // we'll try again if it was context lost setRequested(false); - Log.w(LOG_TAG, "Mountain View, we've had a problem here. " + Log.w(LOG_TAG, "Mountain View, we've had a problem here. " + "Switching back to software rendering."); } } @@ -976,7 +1019,7 @@ public abstract class HardwareRenderer { @Override boolean initialize(Surface surface) throws Surface.OutOfResourcesException { if (isRequested() && !isEnabled()) { - initializeEgl(); + boolean contextCreated = initializeEgl(); mGl = createEglSurface(surface); mDestroyed = false; @@ -991,6 +1034,10 @@ public abstract class HardwareRenderer { mCanvas.setName(mName); } setEnabled(true); + + if (contextCreated) { + initAtlas(); + } } return mCanvas != null; @@ -1010,7 +1057,7 @@ public abstract class HardwareRenderer { abstract int[] getConfig(boolean dirtyRegions); - void initializeEgl() { + boolean initializeEgl() { synchronized (sEglLock) { if (sEgl == null && sEglConfig == null) { sEgl = (EGL10) EGLContext.getEGL(); @@ -1043,7 +1090,10 @@ public abstract class HardwareRenderer { if (mEglContext == null) { mEglContext = createContext(sEgl, sEglDisplay, sEglConfig); sEglContextStorage.set(createManagedContext(mEglContext)); + return true; } + + return false; } private EGLConfig loadEglConfig() { @@ -1181,6 +1231,7 @@ public abstract class HardwareRenderer { } abstract void initCaches(); + abstract void initAtlas(); EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) { int[] attribs = { EGL14.EGL_CONTEXT_CLIENT_VERSION, mGlVersion, EGL_NONE }; @@ -1193,6 +1244,7 @@ public abstract class HardwareRenderer { "Could not create an EGL context. eglCreateContext failed with error: " + GLUtils.getEGLErrorString(sEgl.eglGetError())); } + return context; } @@ -1380,6 +1432,8 @@ public abstract class HardwareRenderer { canvas.restoreToCount(saveCount); view.mRecreateDisplayList = false; + debugOverdraw(attachInfo, dirty, canvas, displayList); + mFrameCount++; debugDirtyRegions(dirty, canvas); @@ -1399,6 +1453,61 @@ public abstract class HardwareRenderer { } } + abstract void countOverdraw(HardwareCanvas canvas); + abstract float getOverdraw(HardwareCanvas canvas); + + private void debugOverdraw(View.AttachInfo attachInfo, Rect dirty, + HardwareCanvas canvas, DisplayList displayList) { + + if (mDebugOverdraw == OVERDRAW_TYPE_COUNT) { + // TODO: Use an alpha layer allocated from a GraphicBuffer + // The alpha format will help with rendering performance and + // the GraphicBuffer will let us skip the read pixels step + if (mDebugOverdrawLayer == null) { + mDebugOverdrawLayer = createHardwareLayer(mWidth, mHeight, true); + } else if (mDebugOverdrawLayer.getWidth() != mWidth || + mDebugOverdrawLayer.getHeight() != mHeight) { + mDebugOverdrawLayer.resize(mWidth, mHeight); + } + + if (!mDebugOverdrawLayer.isValid()) { + mDebugOverdraw = -1; + return; + } + + HardwareCanvas layerCanvas = mDebugOverdrawLayer.start(canvas, dirty); + countOverdraw(layerCanvas); + final int restoreCount = layerCanvas.save(); + layerCanvas.drawDisplayList(displayList, null, DisplayList.FLAG_CLIP_CHILDREN); + layerCanvas.restoreToCount(restoreCount); + mDebugOverdrawLayer.end(canvas); + + float overdraw = getOverdraw(layerCanvas); + DisplayMetrics metrics = attachInfo.mRootView.getResources().getDisplayMetrics(); + + drawOverdrawCounter(canvas, overdraw, metrics.density); + } + } + + private void drawOverdrawCounter(HardwareCanvas canvas, float overdraw, float density) { + final String text = String.format("%.2fx", overdraw); + final Paint paint = setupPaint(density); + // HSBtoColor will clamp the values in the 0..1 range + paint.setColor(Color.HSBtoColor(0.28f - 0.28f * overdraw / 3.5f, 0.8f, 1.0f)); + + canvas.drawText(text, density * 4.0f, mHeight - paint.getFontMetrics().bottom, paint); + } + + private Paint setupPaint(float density) { + if (mDebugOverdrawPaint == null) { + mDebugOverdrawPaint = new Paint(); + mDebugOverdrawPaint.setAntiAlias(true); + mDebugOverdrawPaint.setShadowLayer(density * 3.0f, 0.0f, 0.0f, 0xff000000); + mDebugOverdrawPaint.setTextSize(density * 20.0f); + } + return mDebugOverdrawPaint; + } + private DisplayList buildDisplayList(View view, HardwareCanvas canvas) { view.mRecreateDisplayList = (view.mPrivateFlags & View.PFLAG_INVALIDATED) == View.PFLAG_INVALIDATED; @@ -1788,7 +1897,29 @@ public abstract class HardwareRenderer { @Override void initCaches() { - GLES20Canvas.initCaches(); + if (GLES20Canvas.initCaches()) { + // Caches were (re)initialized, rebind atlas + initAtlas(); + } + } + + @Override + void initAtlas() { + IBinder binder = ServiceManager.getService("assetatlas"); + if (binder == null) return; + + IAssetAtlas atlas = IAssetAtlas.Stub.asInterface(binder); + try { + GraphicBuffer buffer = atlas.getBuffer(); + if (buffer != null) { + int[] map = atlas.getMap(); + if (map != null) { + GLES20Canvas.initAtlas(buffer, map); + } + } + } catch (RemoteException e) { + Log.w(LOG_TAG, "Could not acquire atlas", e); + } } @Override @@ -1985,6 +2116,16 @@ public abstract class HardwareRenderer { } @Override + void countOverdraw(HardwareCanvas canvas) { + ((GLES20Canvas) canvas).setCountOverdrawEnabled(true); + } + + @Override + float getOverdraw(HardwareCanvas canvas) { + return ((GLES20Canvas) canvas).getOverdraw(); + } + + @Override public SurfaceTexture createSurfaceTexture(HardwareLayer layer) { return ((GLES20TextureLayer) layer).getSurfaceTexture(); } diff --git a/core/java/android/view/IAssetAtlas.aidl b/core/java/android/view/IAssetAtlas.aidl new file mode 100644 index 0000000..2595179 --- /dev/null +++ b/core/java/android/view/IAssetAtlas.aidl @@ -0,0 +1,47 @@ +/** + * Copyright (c) 2013, 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.view; + +import android.view.GraphicBuffer; + +/** + * Programming interface to the system assets atlas. This atlas, when + * present, holds preloaded drawable in a single, shareable graphics + * buffer. This allows multiple processes to share the same data to + * save up on memory. + * + * @hide + */ +interface IAssetAtlas { + /** + * Returns the atlas buffer (texture) or null if the atlas is + * not available yet. + */ + GraphicBuffer getBuffer(); + + /** + * Returns the map of the bitmaps stored in the atlas or null + * if the atlas is not available yet. + * + * Each bitmap is represented by several entries in the array: + * int0: SkBitmap*, the native bitmap object + * int1: x position + * int2: y position + * int3: rotated, 1 if the bitmap must be rotated, 0 otherwise + */ + int[] getMap(); +} diff --git a/core/java/android/view/IWindowManager.aidl b/core/java/android/view/IWindowManager.aidl index 8ed4a86..8007d9a 100644 --- a/core/java/android/view/IWindowManager.aidl +++ b/core/java/android/view/IWindowManager.aidl @@ -80,8 +80,8 @@ interface IWindowManager void setEventDispatching(boolean enabled); void addWindowToken(IBinder token, int type); void removeWindowToken(IBinder token); - void addAppToken(int addPos, IApplicationToken token, - int groupId, int requestedOrientation, boolean fullscreen, boolean showWhenLocked); + void addAppToken(int addPos, IApplicationToken token, int groupId, int stackId, + int requestedOrientation, boolean fullscreen, boolean showWhenLocked); void setAppGroupId(IBinder token, int groupId); void setAppOrientation(IApplicationToken token, int requestedOrientation); int getAppOrientation(IApplicationToken token); @@ -103,9 +103,6 @@ interface IWindowManager void startAppFreezingScreen(IBinder token, int configChanges); void stopAppFreezingScreen(IBinder token, boolean force); void removeAppToken(IBinder token); - void moveAppToken(int index, IBinder token); - void moveAppTokensToTop(in List<IBinder> tokens); - void moveAppTokensToBottom(in List<IBinder> tokens); // Re-evaluate the current orientation from the caller's state. // If there is a change, the new Configuration is returned and the diff --git a/core/java/android/view/InputEvent.java b/core/java/android/view/InputEvent.java index 07a937c..1ecdf30 100644 --- a/core/java/android/view/InputEvent.java +++ b/core/java/android/view/InputEvent.java @@ -70,6 +70,7 @@ public abstract class InputEvent implements Parcelable { * Gets the source of the event. * * @return The event source or {@link InputDevice#SOURCE_UNKNOWN} if unknown. + * @see InputDevice#getSources */ public abstract int getSource(); diff --git a/core/java/android/view/InputFilter.java b/core/java/android/view/InputFilter.java index c25b87b..4aba30c 100644 --- a/core/java/android/view/InputFilter.java +++ b/core/java/android/view/InputFilter.java @@ -40,7 +40,7 @@ import android.view.WindowManagerPolicy; * <li>Input events are then asynchronously delivered to the input filter's * {@link #onInputEvent(InputEvent)} method instead of being enqueued for dispatch to * applications as usual. The input filter only receives input events that were - * generated by input device; the input filter will not receive input events that were + * generated by an input device; the input filter will not receive input events that were * injected into the system by other means, such as by instrumentation.</li> * <li>The input filter processes and optionally transforms the stream of events. For example, * it may transform a sequence of motion events representing an accessibility gesture into @@ -68,7 +68,7 @@ import android.view.WindowManagerPolicy; * The input filter must take into account the fact that the input events coming from different * devices or even different sources all consist of distinct streams of input. * Use {@link InputEvent#getDeviceId()} and {@link InputEvent#getSource()} to identify - * the source of the event and its semantics. There are be multiple sources of keys, + * the source of the event and its semantics. There may be multiple sources of keys, * touches and other input: they must be kept separate. * </p> * <h3>Policy flags</h3> @@ -88,7 +88,7 @@ import android.view.WindowManagerPolicy; * The input filter should clear its internal state about the gesture and then send key or * motion events to the dispatcher to cancel any keys or pointers that are down. * </p><p> - * Corollary: Events that set sent to the dispatcher should usually include the + * Corollary: Events that get sent to the dispatcher should usually include the * {@link WindowManagerPolicy#FLAG_PASS_TO_USER} flag. Otherwise, they will be dropped! * </p><p> * It may be prudent to disable automatic key repeating for synthetic key events diff --git a/core/java/android/view/SurfaceView.java b/core/java/android/view/SurfaceView.java index 793fb5e..8b2b556 100644 --- a/core/java/android/view/SurfaceView.java +++ b/core/java/android/view/SurfaceView.java @@ -160,7 +160,6 @@ public class SurfaceView extends View { int mHeight = -1; int mFormat = -1; final Rect mSurfaceFrame = new Rect(); - Rect mTmpDirty; int mLastSurfaceWidth = -1, mLastSurfaceHeight = -1; boolean mUpdateWindowNeeded; boolean mReportDrawNeeded; @@ -795,14 +794,6 @@ public class SurfaceView extends View { Canvas c = null; if (!mDrawingStopped && mWindow != null) { - if (dirty == null) { - if (mTmpDirty == null) { - mTmpDirty = new Rect(); - } - mTmpDirty.set(mSurfaceFrame); - dirty = mTmpDirty; - } - try { c = mSurface.lockCanvas(dirty); } catch (Exception e) { diff --git a/core/java/android/view/TextureView.java b/core/java/android/view/TextureView.java index 5c3934d..f0acba1 100644 --- a/core/java/android/view/TextureView.java +++ b/core/java/android/view/TextureView.java @@ -648,13 +648,19 @@ public class TextureView extends View { * rectangle. Every pixel within that rectangle must be written; however * pixels outside the dirty rectangle will be preserved by the next call * to lockCanvas(). + * + * This method can return null if the underlying surface texture is not + * available (see {@link #isAvailable()} or if the surface texture is + * already connected to an image producer (for instance: the camera, + * OpenGL, a media player, etc.) * * @param dirty Area of the surface that will be modified. * @return A Canvas used to draw into the surface. * * @see #lockCanvas() - * @see #unlockCanvasAndPost(android.graphics.Canvas) + * @see #unlockCanvasAndPost(android.graphics.Canvas) + * @see #isAvailable() */ public Canvas lockCanvas(Rect dirty) { if (!isAvailable()) return null; @@ -664,7 +670,9 @@ public class TextureView extends View { } synchronized (mNativeWindowLock) { - nLockCanvas(mNativeWindow, mCanvas, dirty); + if (!nLockCanvas(mNativeWindow, mCanvas, dirty)) { + return null; + } } mSaveCount = mCanvas.save(); @@ -803,6 +811,6 @@ public class TextureView extends View { private static native void nSetDefaultBufferSize(SurfaceTexture surfaceTexture, int width, int height); - private static native void nLockCanvas(int nativeWindow, Canvas canvas, Rect dirty); + private static native boolean nLockCanvas(int nativeWindow, Canvas canvas, Rect dirty); private static native void nUnlockCanvasAndPost(int nativeWindow, Canvas canvas); } diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java index 0938bb3..ed6dc6c 100644 --- a/core/java/android/view/View.java +++ b/core/java/android/view/View.java @@ -73,6 +73,7 @@ import android.view.animation.Transformation; import android.view.inputmethod.EditorInfo; import android.view.inputmethod.InputConnection; import android.view.inputmethod.InputMethodManager; +import android.view.transition.Scene; import android.widget.ScrollBarDrawable; import static android.os.Build.VERSION_CODES.*; @@ -1572,6 +1573,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback, */ protected Object mTag; + private Scene mCurrentScene = null; + // for mPrivateFlags: /** {@hide} */ static final int PFLAG_WANTS_FOCUS = 0x00000001; @@ -2341,7 +2344,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * allows it to avoid artifacts when switching in and out of that mode, at * the expense that some of its user interface may be covered by screen * decorations when they are shown. You can perform layout of your inner - * UI elements to account for the navagation system UI through the + * UI elements to account for the navigation system UI through the * {@link #fitSystemWindows(Rect)} method. */ public static final int SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION = 0x00000200; @@ -2479,6 +2482,18 @@ public class View implements Drawable.Callback, KeyEvent.Callback, /** * @hide + * + * NOTE: This flag may only be used in subtreeSystemUiVisibility. It is masked + * out of the public fields to keep the undefined bits out of the developer's way. + * + * Flag to specify that the status bar should temporarily overlay underlying content + * that is otherwise assuming the status bar is hidden. The status bar will typically + * have some degree of transparency while in this temporary overlay mode. + */ + public static final int STATUS_BAR_OVERLAY = 0x04000000; + + /** + * @hide */ public static final int PUBLIC_STATUS_BAR_VISIBILITY_MASK = 0x0000FFFF; @@ -12036,9 +12051,14 @@ public class View implements Drawable.Callback, KeyEvent.Callback, mCurrentAnimation = null; + mCurrentScene = null; + resetAccessibilityStateChanged(); } + void invalidateInheritedLayoutMode(int layoutModeOfRoot) { + } + /** * @return The number of times this view has been attached to a window */ @@ -17754,6 +17774,31 @@ public class View implements Drawable.Callback, KeyEvent.Callback, } /** + * Set the current Scene that this view is in. The current scene is set only + * on the root view of a scene, not for every view in that hierarchy. This + * information is used by Scene to determine whether there is a previous + * scene which should be exited before the new scene is entered. + * + * @param scene The new scene being set on the view + * + * @hide + */ + public void setCurrentScene(Scene scene) { + mCurrentScene = scene; + } + + /** + * Gets the current {@link Scene} set on this view. A scene is set on a view + * only if that view is the scene root. + * + * @return The current Scene set on this view. A value of null indicates that + * no Scene is current set. + */ + public Scene getCurrentScene() { + return mCurrentScene; + } + + /** * Interface definition for a callback to be invoked when a hardware key event is * dispatched to this view. The callback will be invoked before the key event is * given to the view. This is only useful for hardware keyboards; a software input diff --git a/core/java/android/view/ViewGroup.java b/core/java/android/view/ViewGroup.java index c7ce999..dfe5f88 100644 --- a/core/java/android/view/ViewGroup.java +++ b/core/java/android/view/ViewGroup.java @@ -204,7 +204,7 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager /** * Either {@link #LAYOUT_MODE_CLIP_BOUNDS} or {@link #LAYOUT_MODE_OPTICAL_BOUNDS}. */ - private int mLayoutMode = DEFAULT_LAYOUT_MODE; + private int mLayoutMode = LAYOUT_MODE_UNDEFINED; /** * NOTE: If you change the flags below make sure to reflect the changes @@ -345,6 +345,14 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager private static final int FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW = 0x400000; /** + * When true, indicates that a layoutMode has been explicitly set, either with + * an explicit call to {@link #setLayoutMode(int)} in code or from an XML resource. + * This distinguishes the situation in which a layout mode was inherited from + * one of the ViewGroup's ancestors and cached locally. + */ + private static final int FLAG_LAYOUT_MODE_WAS_EXPLICITLY_SET = 0x800000; + + /** * Indicates which types of drawing caches are to be kept in memory. * This field should be made private, so it is hidden from the SDK. * {@hide} @@ -373,6 +381,8 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager // Layout Modes + private static final int LAYOUT_MODE_UNDEFINED = -1; + /** * This constant is a {@link #setLayoutMode(int) layoutMode}. * Clip bounds are the raw values of {@link #getLeft() left}, {@link #getTop() top}, @@ -389,7 +399,7 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager public static final int LAYOUT_MODE_OPTICAL_BOUNDS = 1; /** @hide */ - public static int DEFAULT_LAYOUT_MODE = LAYOUT_MODE_CLIP_BOUNDS; + public static int LAYOUT_MODE_DEFAULT = LAYOUT_MODE_CLIP_BOUNDS; /** * We clip to padding when FLAG_CLIP_TO_PADDING and FLAG_PADDING_NOT_NULL @@ -531,7 +541,7 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager } break; case R.styleable.ViewGroup_layoutMode: - setLayoutMode(a.getInt(attr, DEFAULT_LAYOUT_MODE)); + setLayoutMode(a.getInt(attr, LAYOUT_MODE_UNDEFINED)); break; } } @@ -3447,6 +3457,24 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager } } + private void clearCachedLayoutMode() { + if (!getBooleanFlag(FLAG_LAYOUT_MODE_WAS_EXPLICITLY_SET)) { + mLayoutMode = LAYOUT_MODE_UNDEFINED; + } + } + + @Override + protected void onAttachedToWindow() { + super.onAttachedToWindow(); + clearCachedLayoutMode(); + } + + @Override + protected void onDetachedFromWindow() { + super.onDetachedFromWindow(); + clearCachedLayoutMode(); + } + /** * Adds a view during layout. This is useful if in your onLayout() method, * you need to add more views (as does the list view for example). @@ -4745,6 +4773,10 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager setBooleanFlag(FLAG_USE_CHILD_DRAWING_ORDER, enabled); } + private boolean getBooleanFlag(int flag) { + return (mGroupFlags & flag) == flag; + } + private void setBooleanFlag(int flag, boolean value) { if (value) { mGroupFlags |= flag; @@ -4788,24 +4820,63 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager mPersistentDrawingCache = drawingCacheToKeep & PERSISTENT_ALL_CACHES; } + private void setLayoutMode(int layoutMode, boolean explicitly) { + mLayoutMode = layoutMode; + setBooleanFlag(FLAG_LAYOUT_MODE_WAS_EXPLICITLY_SET, explicitly); + } + /** - * Returns the basis of alignment during layout operations on this view group: + * Recursively traverse the view hierarchy, resetting the layoutMode of any + * descendants that had inherited a different layoutMode from a previous parent. + * Recursion terminates when a descendant's mode is: + * <ul> + * <li>Undefined</li> + * <li>The same as the root node's</li> + * <li>A mode that had been explicitly set</li> + * <ul/> + * The first two clauses are optimizations. + * @param layoutModeOfRoot + */ + @Override + void invalidateInheritedLayoutMode(int layoutModeOfRoot) { + if (mLayoutMode == LAYOUT_MODE_UNDEFINED || + mLayoutMode == layoutModeOfRoot || + getBooleanFlag(FLAG_LAYOUT_MODE_WAS_EXPLICITLY_SET)) { + return; + } + setLayoutMode(LAYOUT_MODE_UNDEFINED, false); + + // apply recursively + for (int i = 0, N = getChildCount(); i < N; i++) { + getChildAt(i).invalidateInheritedLayoutMode(layoutModeOfRoot); + } + } + + /** + * Returns the basis of alignment during layout operations on this ViewGroup: * either {@link #LAYOUT_MODE_CLIP_BOUNDS} or {@link #LAYOUT_MODE_OPTICAL_BOUNDS}. + * <p> + * If no layoutMode was explicitly set, either programmatically or in an XML resource, + * the method returns the layoutMode of the view's parent ViewGroup if such a parent exists, + * otherwise the method returns a default value of {@link #LAYOUT_MODE_CLIP_BOUNDS}. * * @return the layout mode to use during layout operations * * @see #setLayoutMode(int) */ public int getLayoutMode() { + if (mLayoutMode == LAYOUT_MODE_UNDEFINED) { + int inheritedLayoutMode = (mParent instanceof ViewGroup) ? + ((ViewGroup) mParent).getLayoutMode() : LAYOUT_MODE_DEFAULT; + setLayoutMode(inheritedLayoutMode, false); + } return mLayoutMode; } /** - * Sets the basis of alignment during the layout of this view group. + * Sets the basis of alignment during the layout of this ViewGroup. * Valid values are either {@link #LAYOUT_MODE_CLIP_BOUNDS} or * {@link #LAYOUT_MODE_OPTICAL_BOUNDS}. - * <p> - * The default is {@link #LAYOUT_MODE_CLIP_BOUNDS}. * * @param layoutMode the layout mode to use during layout operations * @@ -4813,7 +4884,8 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager */ public void setLayoutMode(int layoutMode) { if (mLayoutMode != layoutMode) { - mLayoutMode = layoutMode; + invalidateInheritedLayoutMode(layoutMode); + setLayoutMode(layoutMode, layoutMode != LAYOUT_MODE_UNDEFINED); requestLayout(); } } diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java index 7ecb52e..47c40d2 100644 --- a/core/java/android/view/ViewRootImpl.java +++ b/core/java/android/view/ViewRootImpl.java @@ -23,7 +23,6 @@ import android.content.ClipDescription; import android.content.ComponentCallbacks; import android.content.ComponentCallbacks2; import android.content.Context; -import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.res.CompatibilityInfo; import android.content.res.Configuration; @@ -108,13 +107,12 @@ public final class ViewRootImpl implements ViewParent, private static final boolean DEBUG_FPS = false; private static final boolean DEBUG_INPUT_PROCESSING = false || LOCAL_LOGV; - private static final boolean USE_RENDER_THREAD = false; - /** * Set this system property to true to force the view hierarchy to render * at 60 Hz. This can be used to measure the potential framerate. */ private static final String PROPERTY_PROFILE_RENDERING = "viewancestor.profile_rendering"; + private static final String PROPERTY_MEDIA_DISABLED = "config.disable_media"; /** * Maximum time we allow the user to roll the trackball enough to generate @@ -130,10 +128,6 @@ public final class ViewRootImpl implements ViewParent, static final ArrayList<ComponentCallbacks> sConfigCallbacks = new ArrayList<ComponentCallbacks>(); - private static boolean sUseRenderThread = false; - private static boolean sRenderThreadQueried = false; - private static final Object[] sRenderThreadQueryLock = new Object[0]; - final Context mContext; final IWindowSession mWindowSession; final Display mDisplay; @@ -285,6 +279,8 @@ public final class ViewRootImpl implements ViewParent, private Choreographer.FrameCallback mRenderProfiler; private boolean mRenderProfilingEnabled; + private boolean mMediaDisabled; + // Variables to track frames per second, enabled via DEBUG_FPS flag private long mFpsStartTime = -1; private long mFpsPrevTime = -1; @@ -372,35 +368,6 @@ public final class ViewRootImpl implements ViewParent, loadSystemProperties(); } - /** - * @return True if the application requests the use of a separate render thread, - * false otherwise - */ - private static boolean isRenderThreadRequested(Context context) { - if (USE_RENDER_THREAD) { - synchronized (sRenderThreadQueryLock) { - if (!sRenderThreadQueried) { - final PackageManager packageManager = context.getPackageManager(); - final String packageName = context.getApplicationInfo().packageName; - try { - ApplicationInfo applicationInfo = packageManager.getApplicationInfo(packageName, - PackageManager.GET_META_DATA); - if (applicationInfo.metaData != null) { - sUseRenderThread = applicationInfo.metaData.getBoolean( - "android.graphics.renderThread", false); - } - } catch (PackageManager.NameNotFoundException e) { - } finally { - sRenderThreadQueried = true; - } - } - return sUseRenderThread; - } - } else { - return false; - } - } - public static void addFirstDrawHandler(Runnable callback) { synchronized (sFirstDrawHandlers) { if (!sFirstDrawComplete) { @@ -478,7 +445,7 @@ public final class ViewRootImpl implements ViewParent, // If the application owns the surface, don't enable hardware acceleration if (mSurfaceHolder == null) { - enableHardwareAcceleration(mView.getContext(), attrs); + enableHardwareAcceleration(attrs); } boolean restore = false; @@ -686,7 +653,7 @@ public final class ViewRootImpl implements ViewParent, } } - private void enableHardwareAcceleration(Context context, WindowManager.LayoutParams attrs) { + private void enableHardwareAcceleration(WindowManager.LayoutParams attrs) { mAttachInfo.mHardwareAccelerated = false; mAttachInfo.mHardwareAccelerationRequested = false; @@ -726,11 +693,6 @@ public final class ViewRootImpl implements ViewParent, return; } - final boolean renderThread = isRenderThreadRequested(context); - if (renderThread) { - Log.i(HardwareRenderer.LOG_TAG, "Render threat initiated"); - } - if (mAttachInfo.mHardwareRenderer != null) { mAttachInfo.mHardwareRenderer.destroy(true); } @@ -5041,6 +5003,10 @@ public final class ViewRootImpl implements ViewParent, public void playSoundEffect(int effectId) { checkThread(); + if (mMediaDisabled) { + return; + } + try { final AudioManager audioManager = getAudioManager(); @@ -5186,6 +5152,9 @@ public final class ViewRootImpl implements ViewParent, mProfileRendering = SystemProperties.getBoolean(PROPERTY_PROFILE_RENDERING, false); profileRendering(mAttachInfo.mHasWindowFocus); + // Media (used by sound effects) + mMediaDisabled = SystemProperties.getBoolean(PROPERTY_MEDIA_DISABLED, false); + // Hardware rendering if (mAttachInfo.mHardwareRenderer != null) { if (mAttachInfo.mHardwareRenderer.loadSystemProperties(mHolder.getSurface())) { diff --git a/core/java/android/view/WindowManager.java b/core/java/android/view/WindowManager.java index 541c503..5144889 100644 --- a/core/java/android/view/WindowManager.java +++ b/core/java/android/view/WindowManager.java @@ -527,6 +527,14 @@ public interface WindowManager extends ViewManager { */ public static final int TYPE_RECENTS_OVERLAY = FIRST_SYSTEM_WINDOW+28; + + /** + * Window type: keyguard scrim window. Shows if keyguard needs to be restarted. + * In multiuser systems shows on all users' windows. + * @hide + */ + public static final int TYPE_KEYGUARD_SCRIM = FIRST_SYSTEM_WINDOW+29; + /** * End of types of system windows. */ diff --git a/core/java/android/view/WindowManagerPolicy.java b/core/java/android/view/WindowManagerPolicy.java index c0044b6..b9f9e80 100644 --- a/core/java/android/view/WindowManagerPolicy.java +++ b/core/java/android/view/WindowManagerPolicy.java @@ -816,6 +816,14 @@ public interface WindowManagerPolicy { public int getSystemDecorRectLw(Rect systemRect); /** + * Return the rectangle of the screen that is available for applications to run in. + * This will be called immediately after {@link #beginLayoutLw}. + * + * @param r The rectangle to be filled with the boundaries available to applications. + */ + public void getContentRectLw(Rect r); + + /** * Called for each window attached to the window manager as layout is * proceeding. The implementation of this function must take care of * setting the window's frame, either here or in finishLayout(). diff --git a/core/java/android/view/accessibility/AccessibilityManager.java b/core/java/android/view/accessibility/AccessibilityManager.java index 732699b..04ce7e2 100644 --- a/core/java/android/view/accessibility/AccessibilityManager.java +++ b/core/java/android/view/accessibility/AccessibilityManager.java @@ -16,14 +16,17 @@ package android.view.accessibility; +import android.Manifest; import android.accessibilityservice.AccessibilityServiceInfo; import android.content.Context; +import android.content.pm.PackageManager; import android.content.pm.ServiceInfo; import android.os.Binder; import android.os.Handler; import android.os.IBinder; import android.os.Looper; import android.os.Message; +import android.os.Process; import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemClock; @@ -132,29 +135,6 @@ public final class AccessibilityManager { } /** - * Creates the singleton AccessibilityManager to be shared across users. This - * has to be called before the local AccessibilityManager is created to ensure - * it registers itself in the system correctly. - * <p> - * Note: Calling this method requires INTERACT_ACROSS_USERS_FULL or - * INTERACT_ACROSS_USERS permission. - * </p> - * @param context Context in which this manager operates. - * @throws IllegalStateException if not called before the local - * AccessibilityManager is instantiated. - * - * @hide - */ - public static void createAsSharedAcrossUsers(Context context) { - synchronized (sInstanceSync) { - if (sInstance != null) { - throw new IllegalStateException("AccessibilityManager already created."); - } - createSingletonInstance(context, UserHandle.USER_CURRENT); - } - } - - /** * Get an AccessibilityManager instance (create one if necessary). * * @param context Context in which this manager operates. @@ -164,25 +144,27 @@ public final class AccessibilityManager { public static AccessibilityManager getInstance(Context context) { synchronized (sInstanceSync) { if (sInstance == null) { - createSingletonInstance(context, UserHandle.myUserId()); + final int userId; + if (Binder.getCallingUid() == Process.SYSTEM_UID + || context.checkCallingOrSelfPermission( + Manifest.permission.INTERACT_ACROSS_USERS) + == PackageManager.PERMISSION_GRANTED + || context.checkCallingOrSelfPermission( + Manifest.permission.INTERACT_ACROSS_USERS_FULL) + == PackageManager.PERMISSION_GRANTED) { + userId = UserHandle.USER_CURRENT; + } else { + userId = UserHandle.myUserId(); + } + IBinder iBinder = ServiceManager.getService(Context.ACCESSIBILITY_SERVICE); + IAccessibilityManager service = IAccessibilityManager.Stub.asInterface(iBinder); + sInstance = new AccessibilityManager(context, service, userId); } } return sInstance; } /** - * Creates the singleton instance. - * - * @param context Context in which this manager operates. - * @param userId The user id under which to operate. - */ - private static void createSingletonInstance(Context context, int userId) { - IBinder iBinder = ServiceManager.getService(Context.ACCESSIBILITY_SERVICE); - IAccessibilityManager service = IAccessibilityManager.Stub.asInterface(iBinder); - sInstance = new AccessibilityManager(context, service, userId); - } - - /** * Create an instance. * * @param context A {@link Context}. diff --git a/core/java/android/view/inputmethod/BaseInputConnection.java b/core/java/android/view/inputmethod/BaseInputConnection.java index 7ec5398..b3ff54d 100644 --- a/core/java/android/view/inputmethod/BaseInputConnection.java +++ b/core/java/android/view/inputmethod/BaseInputConnection.java @@ -268,8 +268,9 @@ public class BaseInputConnection implements InputConnection { if (content != null) { beginBatchEdit(); removeComposingSpans(content); - endBatchEdit(); + // Note: sendCurrentText does nothing unless mDummyMode is set sendCurrentText(); + endBatchEdit(); } return true; } @@ -466,8 +467,9 @@ public class BaseInputConnection implements InputConnection { content.setSpan(COMPOSING, a, b, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_COMPOSING); - endBatchEdit(); + // Note: sendCurrentText does nothing unless mDummyMode is set sendCurrentText(); + endBatchEdit(); } return true; } diff --git a/core/java/android/view/transition/AutoTransition.java b/core/java/android/view/transition/AutoTransition.java new file mode 100644 index 0000000..d94cf2c --- /dev/null +++ b/core/java/android/view/transition/AutoTransition.java @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2013 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.view.transition; + +/** + * Utility class for creating a default transition that automatically fades, + * moves, and resizes views during a scene change. + */ +public class AutoTransition extends TransitionGroup { + + /** + * Constructs an AutoTransition object, which is a TransitionGroup which + * first fades out disappearing targets, then moves and resizes existing + * targets, and finally fades in appearing targets. + * + */ + public AutoTransition() { + setOrdering(SEQUENTIALLY); + addTransitions(new Fade(Fade.OUT), new Move(), new Fade(Fade.IN)); + } +} diff --git a/core/java/android/view/transition/Crossfade.java b/core/java/android/view/transition/Crossfade.java new file mode 100644 index 0000000..babf58f --- /dev/null +++ b/core/java/android/view/transition/Crossfade.java @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.animation.AnimatorSet; +import android.animation.ObjectAnimator; +import android.animation.RectEvaluator; +import android.animation.ValueAnimator; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Rect; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.util.Log; +import android.view.SurfaceView; +import android.view.TextureView; +import android.view.View; +import android.view.ViewGroup; + +import java.util.HashMap; + +/** + * This transition captures bitmap representations of target views before and + * after the scene change and fades between them. + * + * <p>Note: This transition is not compatible with {@link TextureView} + * or {@link SurfaceView}.</p> + */ +public class Crossfade extends Transition { + // TODO: Add a hook that lets a Transition call user code to query whether it should run on + // a given target view. This would save bitmap comparisons in this transition, for example. + + private static final String LOG_TAG = "Crossfade"; + + private static final String PROPNAME_BITMAP = "android:crossfade:bitmap"; + private static final String PROPNAME_DRAWABLE = "android:crossfade:drawable"; + private static final String PROPNAME_BOUNDS = "android:crossfade:bounds"; + + private static RectEvaluator sRectEvaluator = new RectEvaluator(); + + @Override + protected boolean prePlay(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return false; + } + final View view = startValues.view; + HashMap<String, Object> startVals = startValues.values; + HashMap<String, Object> endVals = endValues.values; + Bitmap startBitmap = (Bitmap) startVals.get(PROPNAME_BITMAP); + Bitmap endBitmap = (Bitmap) endVals.get(PROPNAME_BITMAP); + Drawable startDrawable = (Drawable) startVals.get(PROPNAME_DRAWABLE); + Drawable endDrawable = (Drawable) endVals.get(PROPNAME_DRAWABLE); + if (Transition.DBG) { + Log.d(LOG_TAG, "StartBitmap.sameAs(endBitmap) = " + startBitmap.sameAs(endBitmap) + + " for start, end: " + startBitmap + ", " + endBitmap); + } + if (startDrawable != null && endDrawable != null && !startBitmap.sameAs(endBitmap)) { + view.getOverlay().add(endDrawable); + view.getOverlay().add(startDrawable); + return true; + } else { + return false; + } + } + + @Override + protected Animator play(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return null; + } + HashMap<String, Object> startVals = startValues.values; + HashMap<String, Object> endVals = endValues.values; + + final View view = endValues.view; + Rect startBounds = (Rect) startVals.get(PROPNAME_BOUNDS); + Rect endBounds = (Rect) endVals.get(PROPNAME_BOUNDS); + final BitmapDrawable startDrawable = (BitmapDrawable) startVals.get(PROPNAME_DRAWABLE); + final BitmapDrawable endDrawable = (BitmapDrawable) endVals.get(PROPNAME_DRAWABLE); + + // The transition works by placing the end drawable under the start drawable and + // gradually fading out the start drawable. So it's not really a cross-fade, but rather + // a reveal of the end scene over time. Also, animate the bounds of both drawables + // to mimic the change in the size of the view itself between scenes. + ObjectAnimator anim = ObjectAnimator.ofInt(startDrawable, "alpha", 0); + anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + // TODO: some way to auto-invalidate views based on drawable changes? callbacks? + view.invalidate(startDrawable.getBounds()); + } + }); + if (Transition.DBG) { + Log.d(LOG_TAG, "Crossfade: created anim " + anim + " for start, end values " + + startValues + ", " + endValues); + } + anim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + view.getOverlay().remove(startDrawable); + view.getOverlay().remove(endDrawable); + } + }); + AnimatorSet set = new AnimatorSet(); + set.playTogether(anim); + if (!startBounds.equals(endBounds)) { + if (Transition.DBG) { + Log.d(LOG_TAG, "animating from startBounds to endBounds: " + + startBounds + ", " + endBounds); + } + Animator anim2 = ObjectAnimator.ofObject(startDrawable, "bounds", + sRectEvaluator, startBounds, endBounds); + Animator anim3 = ObjectAnimator.ofObject(endDrawable, "bounds", + sRectEvaluator, startBounds, endBounds); + set.playTogether(anim2); + set.playTogether(anim3); + } + return set; + } + + @Override + protected void captureValues(TransitionValues values, boolean start) { + View view = values.view; + values.values.put(PROPNAME_BOUNDS, new Rect(0, 0, + view.getWidth(), view.getHeight())); + + if (Transition.DBG) { + Log.d(LOG_TAG, "Captured bounds " + values.values.get(PROPNAME_BOUNDS) + ": start = " + + start); + } + Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), + Bitmap.Config.ARGB_8888); + if (view instanceof TextureView) { + bitmap = ((TextureView) view).getBitmap(); + } else { + Canvas c = new Canvas(bitmap); + view.draw(c); + } + values.values.put(PROPNAME_BITMAP, bitmap); + // TODO: I don't have resources, can't call the non-deprecated method? + BitmapDrawable drawable = new BitmapDrawable(bitmap); + // TODO: lrtb will be wrong if the view has transXY set + drawable.setBounds(view.getLeft(), view.getTop(), view.getRight(), view.getBottom()); + values.values.put(PROPNAME_DRAWABLE, drawable); + } + +} diff --git a/core/java/android/view/transition/Fade.java b/core/java/android/view/transition/Fade.java new file mode 100644 index 0000000..8e4909d --- /dev/null +++ b/core/java/android/view/transition/Fade.java @@ -0,0 +1,209 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.animation.ObjectAnimator; +import android.util.Log; +import android.view.View; +import android.view.ViewGroup; + +/** + * This transition tracks changes to the visibility of target views in the + * start and end scenes and fades views in or out when they become visible + * or non-visible. Visibility is determined by both the + * {@link View#setVisibility(int)} state of the view as well as whether it + * is parented in the current view hierarchy. + */ +public class Fade extends Visibility { + + private static final String LOG_TAG = "Fade"; + + /** + * Fading mode used in {@link #Fade(int)} to make the transition + * operate on targets that are appearing. Maybe be combined with + * {@link #OUT} to fade both in and out. + */ + public static final int IN = 0x1; + /** + * Fading mode used in {@link #Fade(int)} to make the transition + * operate on targets that are disappearing. Maybe be combined with + * {@link #IN} to fade both in and out. + */ + public static final int OUT = 0x2; + + private int mFadingMode; + + /** + * Constructs a Fade transition that will fade targets in and out. + */ + public Fade() { + this(IN | OUT); + } + + /** + * Constructs a Fade transition that will fade targets in + * and/or out, according to the value of fadingMode. + * + * @param fadingMode The behavior of this transition, a combination of + * {@link #IN} and {@link #OUT}. + */ + public Fade(int fadingMode) { + mFadingMode = fadingMode; + } + + /** + * Utility method to handle creating and running the Animator. + */ + private Animator runAnimation(View view, float startAlpha, float endAlpha, + Animator.AnimatorListener listener) { + final ObjectAnimator anim = ObjectAnimator.ofFloat(view, "alpha", startAlpha, endAlpha); + if (listener != null) { + anim.addListener(listener); + } + // TODO: Maybe extract a method into Transition to run an animation that handles the + // duration/startDelay stuff for all subclasses. + return anim; + } + + @Override + protected boolean preAppear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + if ((mFadingMode & IN) != IN) { + return false; + } + endView.setAlpha(0); + return true; + } + + @Override + protected Animator appear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + if ((mFadingMode & IN) != IN) { + return null; + } + // TODO: hack - retain original value from before preAppear + return runAnimation(endView, 0, 1, null); + // TODO: end listener to make sure we end at 1 no matter what + } + + @Override + protected boolean preDisappear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + if ((mFadingMode & OUT) != OUT) { + return false; + } + if (Transition.DBG) { + Log.d(LOG_TAG, "Fade.predisappear: startView, startVis, endView, endVis = " + + startView + ", " + startVisibility + ", " + endView + ", " + endVisibility); + } + View view; + View overlayView = null; + View viewToKeep = null; + if (endView == null) { + // view was removed: add the start view to the Overlay + view = startView; + overlayView = view; + } else { + // visibility change + if (endVisibility == View.INVISIBLE) { + view = endView; + viewToKeep = view; + } else { + // Becoming GONE + if (startView == endView) { + view = endView; + viewToKeep = view; + } else { + view = startView; + overlayView = view; + } + } + } + // TODO: add automatic facility to Visibility superclass for keeping views around + if (overlayView != null) { + // TODO: Need to do this for general case of adding to overlay + sceneRoot.getOverlay().add(overlayView); + return true; + } + if (viewToKeep != null) { + // TODO: find a different way to do this, like just changing the view to be + // VISIBLE for the duration of the transition + viewToKeep.setVisibility((View.VISIBLE)); + return true; + } + return false; + } + + @Override + protected Animator disappear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + if ((mFadingMode & OUT) != OUT) { + return null; + } + if (Transition.DBG) { + Log.d(LOG_TAG, "Fade.disappear: startView, startVis, endView, endVis = " + + startView + ", " + startVisibility + ", " + endView + ", " + endVisibility); + } + View view; + View overlayView = null; + View viewToKeep = null; + final int finalVisibility = endVisibility; + if (endView == null) { + // view was removed: add the start view to the Overlay + view = startView; + overlayView = view; + } else { + // visibility change + if (endVisibility == View.INVISIBLE) { + view = endView; + viewToKeep = view; + } else { + // Becoming GONE + if (startView == endView) { + view = endView; + viewToKeep = view; + } else { + view = startView; + overlayView = view; + } + } + } + // TODO: add automatic facility to Visibility superclass for keeping views around + final float startAlpha = view.getAlpha(); + float endAlpha = 0; + final View finalView = view; + final View finalOverlayView = overlayView; + final View finalViewToKeep = viewToKeep; + final ViewGroup finalSceneRoot = sceneRoot; + final Animator.AnimatorListener endListener = new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + finalView.setAlpha(startAlpha); + // TODO: restore view offset from overlay repositioning + if (finalViewToKeep != null) { + finalViewToKeep.setVisibility(finalVisibility); + } + if (finalOverlayView != null) { + finalSceneRoot.getOverlay().remove(finalOverlayView); + } + } + }; + return runAnimation(view, startAlpha, endAlpha, endListener); + } + +}
\ No newline at end of file diff --git a/core/java/android/view/transition/Move.java b/core/java/android/view/transition/Move.java new file mode 100644 index 0000000..3bd57bd --- /dev/null +++ b/core/java/android/view/transition/Move.java @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.animation.ObjectAnimator; +import android.animation.PropertyValuesHolder; +import android.animation.RectEvaluator; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Rect; +import android.graphics.drawable.BitmapDrawable; +import android.view.View; +import android.view.ViewGroup; + +import java.util.HashMap; + +/** + * This transition captures the layout bounds of target views before and after + * the scene change and animates those changes during the transition. + */ +public class Move extends Transition { + + private static final String PROPNAME_BOUNDS = "android:move:bounds"; + private static final String PROPNAME_PARENT = "android:move:parent"; + private static final String PROPNAME_WINDOW_X = "android:move:windowX"; + private static final String PROPNAME_WINDOW_Y = "android:move:windowY"; + int[] tempLocation = new int[2]; + boolean mResizeClip = false; + boolean mReparent = false; + + private static RectEvaluator sRectEvaluator = new RectEvaluator(); + + public void setResizeClip(boolean resizeClip) { + mResizeClip = resizeClip; + } + + /** + * Setting this flag tells Move to track the before/after parent + * of every view using this transition. The flag is not enabled by + * default because it requires the parent instances to be the same + * in the two scenes or else all parents must use ids to allow + * the transition to determine which parents are the same. + * + * @param reparent true if the transition should track the parent + * container of target views and animate parent changes. + */ + public void setReparent(boolean reparent) { + mReparent = reparent; + } + + @Override + protected void captureValues(TransitionValues values, boolean start) { + View view = values.view; + values.values.put(PROPNAME_BOUNDS, new Rect(view.getLeft(), view.getTop(), + view.getRight(), view.getBottom())); + values.values.put(PROPNAME_PARENT, values.view.getParent()); + values.view.getLocationInWindow(tempLocation); + values.values.put(PROPNAME_WINDOW_X, tempLocation[0]); + values.values.put(PROPNAME_WINDOW_Y, tempLocation[1]); + } + + @Override + protected Animator play(final ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return null; + } + final View view = endValues.view; + if (view.getParent() == null) { + // TODO: Might want to make it possible to Move an disappearing view. + // This workaround is here because if a parallel Fade is not running on the view + // Then it won't get added to the hierarchy and the animator below will not fire, + // causing the transition to not end + return null; + } + // TODO: need to handle non-VG case? + ViewGroup startParent = (ViewGroup) startValues.values.get(PROPNAME_PARENT); + ViewGroup endParent = (ViewGroup) endValues.values.get(PROPNAME_PARENT); + if (startParent == null || endParent == null) { + return null; + } + boolean parentsEqual = (startParent == endParent) || + (startParent.getId() == endParent.getId()); + if (!mReparent || parentsEqual) { + // Common case - view belongs to the same layout before/after. Just animate its bounds + Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS); + Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS); + int startLeft = startBounds.left; + int endLeft = endBounds.left; + int startTop = startBounds.top; + int endTop = endBounds.top; + int startRight = startBounds.right; + int endRight = endBounds.right; + int startBottom = startBounds.bottom; + int endBottom = endBounds.bottom; + int startWidth = startRight - startLeft; + int startHeight = startBottom - startTop; + int endWidth = endRight - endLeft; + int endHeight = endBottom - endTop; + int numChanges = 0; + if (startWidth != 0 && startHeight != 0 && endWidth != 0 && endHeight != 0) { + if (startLeft != endLeft) ++numChanges; + if (startTop != endTop) ++numChanges; + if (startRight != endRight) ++numChanges; + if (startBottom != endBottom) ++numChanges; + } + if (numChanges > 0) { + if (!mResizeClip) { + PropertyValuesHolder pvh[] = new PropertyValuesHolder[numChanges]; + int pvhIndex = 0; + if (startLeft != endLeft) { + pvh[pvhIndex++] = PropertyValuesHolder.ofInt("left", startLeft, endLeft); + } + if (startTop != endTop) { + pvh[pvhIndex++] = PropertyValuesHolder.ofInt("top", startTop, endTop); + } + if (startRight != endRight) { + pvh[pvhIndex++] = PropertyValuesHolder.ofInt("right", + startRight, endRight); + } + if (startBottom != endBottom) { + pvh[pvhIndex++] = PropertyValuesHolder.ofInt("bottom", + startBottom, endBottom); + } + ObjectAnimator anim = ObjectAnimator.ofPropertyValuesHolder(view, pvh); + if (view.getParent() instanceof ViewGroup) { + final ViewGroup parent = (ViewGroup) view.getParent(); + parent.suppressLayout(true); + anim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + parent.suppressLayout(false); + } + }); + } + return anim; + } else { + // Animate location with translationX/Y and size with clip bounds + float transXDelta = endLeft - startLeft; + float transYDelta = endTop - startTop; + int widthDelta = endWidth - startWidth; + int heightDelta = endHeight - startHeight; + numChanges = 0; + if (transXDelta != 0) numChanges++; + if (transYDelta != 0) numChanges++; + if (widthDelta != 0 || heightDelta != 0) numChanges++; + PropertyValuesHolder pvh[] = new PropertyValuesHolder[numChanges]; + int pvhIndex = 0; + if (transXDelta != 0) { + pvh[pvhIndex++] = PropertyValuesHolder.ofFloat("translationX", + view.getTranslationX(), 0); + } + if (transYDelta != 0) { + pvh[pvhIndex++] = PropertyValuesHolder.ofFloat("translationY", + view.getTranslationY(), 0); + } + if (widthDelta != 0 || heightDelta != 0) { + Rect tempStartBounds = new Rect(0, 0, startWidth, startHeight); + Rect tempEndBounds = new Rect(0, 0, endWidth, endHeight); + pvh[pvhIndex++] = PropertyValuesHolder.ofObject("clipBounds", + sRectEvaluator, tempStartBounds, tempEndBounds); + } + ObjectAnimator anim = ObjectAnimator.ofPropertyValuesHolder(view, pvh); + if (view.getParent() instanceof ViewGroup) { + final ViewGroup parent = (ViewGroup) view.getParent(); + parent.suppressLayout(true); + anim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + parent.suppressLayout(false); + } + }); + } + anim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + view.setClipBounds(null); + } + }); + return anim; + } + } + } else { + return (ObjectAnimator) endValues.values.get("drawableAnim"); + } + return null; + } + + @Override + protected boolean prePlay(final ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return false; + } + HashMap<String, Object> startParentVals = startValues.values; + HashMap<String, Object> endParentVals = endValues.values; + ViewGroup startParent = (ViewGroup) startParentVals.get(PROPNAME_PARENT); + ViewGroup endParent = (ViewGroup) endParentVals.get(PROPNAME_PARENT); + if (startParent == null || endParent == null) { + return false; + } + final View view = endValues.view; + boolean parentsEqual = (startParent == endParent) || + (startParent.getId() == endParent.getId()); + // TODO: Might want reparenting to be separate/subclass transition, or at least + // triggered by a property on Move. Otherwise, we're forcing the requirement that + // all parents in layouts have IDs to avoid layout-inflation resulting in a side-effect + // of reparenting the views. + if (!mReparent || parentsEqual) { + Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS); + Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS); + int startLeft = startBounds.left; + int endLeft = endBounds.left; + int startTop = startBounds.top; + int endTop = endBounds.top; + int startRight = startBounds.right; + int endRight = endBounds.right; + int startBottom = startBounds.bottom; + int endBottom = endBounds.bottom; + int startWidth = startRight - startLeft; + int startHeight = startBottom - startTop; + int endWidth = endRight - endLeft; + int endHeight = endBottom - endTop; + int numChanges = 0; + if (startWidth != 0 && startHeight != 0 && endWidth != 0 && endHeight != 0) { + if (startLeft != endLeft) ++numChanges; + if (startTop != endTop) ++numChanges; + if (startRight != endRight) ++numChanges; + if (startBottom != endBottom) ++numChanges; + } + if (numChanges > 0) { + if (!mResizeClip) { + if (startLeft != endLeft) view.setLeft(startLeft); + if (startTop != endTop) view.setTop(startTop); + if (startRight != endRight) view.setRight(startRight); + if (startBottom != endBottom) view.setBottom(startBottom); + } else { + if (startWidth != endWidth) view.setRight(endLeft + + Math.max(startWidth, endWidth)); + if (startHeight != endHeight) view.setBottom(endTop + + Math.max(startHeight, endHeight)); + // TODO: don't clobber TX/TY + if (startLeft != endLeft) view.setTranslationX(startLeft - endLeft); + if (startTop != endTop) view.setTranslationY(startTop - endTop); + } + return true; + } + } else { + int startX = (Integer) startValues.values.get(PROPNAME_WINDOW_X); + int startY = (Integer) startValues.values.get(PROPNAME_WINDOW_Y); + int endX = (Integer) endValues.values.get(PROPNAME_WINDOW_X); + int endY = (Integer) endValues.values.get(PROPNAME_WINDOW_Y); + // TODO: also handle size changes: check bounds and animate size changes + if (startX != endX || startY != endY) { + sceneRoot.getLocationInWindow(tempLocation); + Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), + Bitmap.Config.ARGB_8888); + Canvas canvas = new Canvas(bitmap); + view.draw(canvas); + final BitmapDrawable drawable = new BitmapDrawable(bitmap); + view.setVisibility(View.INVISIBLE); + sceneRoot.getOverlay().add(drawable); + Rect startBounds = new Rect(startX - tempLocation[0], startY - tempLocation[1], + startX - tempLocation[0] + view.getWidth(), + startY - tempLocation[1] + view.getHeight()); + Rect endBounds = new Rect(endX - tempLocation[0], endY - tempLocation[1], + endX - tempLocation[0] + view.getWidth(), + endY - tempLocation[1] + view.getHeight()); + ObjectAnimator anim = ObjectAnimator.ofObject(drawable, "bounds", + sRectEvaluator, startBounds, endBounds); + anim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + sceneRoot.getOverlay().remove(drawable); + view.setVisibility(View.VISIBLE); + } + }); + endParentVals.put("drawableAnim", anim); + return true; + } + } + return false; + } +} diff --git a/core/java/android/view/transition/Recolor.java b/core/java/android/view/transition/Recolor.java new file mode 100644 index 0000000..7048be9 --- /dev/null +++ b/core/java/android/view/transition/Recolor.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.ArgbEvaluator; +import android.animation.ObjectAnimator; +import android.graphics.drawable.ColorDrawable; +import android.graphics.drawable.Drawable; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import java.util.HashMap; + +/** + * This transition tracks changes during scene changes to the + * {@link View#setBackground(android.graphics.drawable.Drawable) background} + * property of its target views (when the background is a + * {@link ColorDrawable}, as well as the + * {@link TextView#setTextColor(android.content.res.ColorStateList) + * color} of the text for target TextViews. If the color changes between + * scenes, the color change is animated. + */ +public class Recolor extends Transition { + + private static final String PROPNAME_BACKGROUND = "android:recolor:background"; + private static final String PROPNAME_TEXT_COLOR = "android:recolor:textColor"; + + @Override + protected void captureValues(TransitionValues values, boolean start) { + values.values.put(PROPNAME_BACKGROUND, values.view.getBackground()); + if (values.view instanceof TextView) { + values.values.put(PROPNAME_TEXT_COLOR, ((TextView)values.view).getCurrentTextColor()); + } + } + + @Override + protected boolean prePlay(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return false; + } + final View view = endValues.view; + Drawable startBackground = (Drawable) startValues.values.get(PROPNAME_BACKGROUND); + Drawable endBackground = (Drawable) endValues.values.get(PROPNAME_BACKGROUND); + boolean changed = false; + if (startBackground instanceof ColorDrawable && endBackground instanceof ColorDrawable) { + ColorDrawable startColor = (ColorDrawable) startBackground; + ColorDrawable endColor = (ColorDrawable) endBackground; + if (startColor.getColor() != endColor.getColor()) { + endColor.setColor(startColor.getColor()); + changed = true; + } + } + if (view instanceof TextView) { + TextView textView = (TextView) view; + int start = (Integer) startValues.values.get(PROPNAME_TEXT_COLOR); + int end = (Integer) endValues.values.get(PROPNAME_TEXT_COLOR); + if (start != end) { + textView.setTextColor(end); + changed = true; + } + } + return changed; + } + + @Override + protected Animator play(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return null; + } + ObjectAnimator anim = null; + final View view = endValues.view; + HashMap<String, Object> startVals = startValues.values; + HashMap<String, Object> endVals = endValues.values; + Drawable startBackground = (Drawable) startVals.get(PROPNAME_BACKGROUND); + Drawable endBackground = (Drawable) endVals.get(PROPNAME_BACKGROUND); + if (startBackground instanceof ColorDrawable && endBackground instanceof ColorDrawable) { + ColorDrawable startColor = (ColorDrawable) startBackground; + ColorDrawable endColor = (ColorDrawable) endBackground; + if (startColor.getColor() != endColor.getColor()) { + anim = ObjectAnimator.ofObject(endBackground, "color", + new ArgbEvaluator(), startColor.getColor(), endColor.getColor()); + if (getStartDelay() > 0) { + endColor.setColor(startColor.getColor()); + } + } + } + if (view instanceof TextView) { + TextView textView = (TextView) view; + int start = (Integer) startValues.values.get(PROPNAME_TEXT_COLOR); + int end = (Integer) endValues.values.get(PROPNAME_TEXT_COLOR); + if (start != end) { + anim = ObjectAnimator.ofObject(textView, "textColor", + new ArgbEvaluator(), start, end); + if (getStartDelay() > 0) { + textView.setTextColor(end); + } + } + } + return anim; + } +} diff --git a/core/java/android/view/transition/Rotate.java b/core/java/android/view/transition/Rotate.java new file mode 100644 index 0000000..b42fbe5 --- /dev/null +++ b/core/java/android/view/transition/Rotate.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.ObjectAnimator; +import android.view.View; +import android.view.ViewGroup; + +/** + * This transition captures the rotation property of targets before and after + * the scene change and animates any changes. + */ +public class Rotate extends Transition { + + private static final String PROPNAME_ROTATION = "android:rotate:rotation"; + + @Override + protected void captureValues(TransitionValues values, boolean start) { + values.values.put(PROPNAME_ROTATION, values.view.getRotation()); + } + + @Override + protected boolean prePlay(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return false; + } + final View view = endValues.view; + float startRotation = (Float) startValues.values.get(PROPNAME_ROTATION); + float endRotation = (Float) endValues.values.get(PROPNAME_ROTATION); + if (startRotation != endRotation) { + view.setRotation(startRotation); + return true; + } + return false; + } + + @Override + protected Animator play(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null) { + return null; + } + final View view = endValues.view; + float startRotation = (Float) startValues.values.get(PROPNAME_ROTATION); + float endRotation = (Float) endValues.values.get(PROPNAME_ROTATION); + if (startRotation != endRotation) { + return ObjectAnimator.ofFloat(view, View.ROTATION, + startRotation, endRotation); + } + return null; + } +} diff --git a/core/java/android/view/transition/Scene.java b/core/java/android/view/transition/Scene.java new file mode 100644 index 0000000..62cb9d3 --- /dev/null +++ b/core/java/android/view/transition/Scene.java @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.ViewGroup; + +/** + * A scene represents the collection of values that various properties in the + * View hierarchy will have when the scene is applied. A Scene can be + * configured to automatically run a Transition when it is applied, which will + * animate the various property changes that take place during the + * scene change. + */ +public final class Scene { + + private Context mContext; + private int mLayoutId = -1; + private ViewGroup mSceneRoot; + private ViewGroup mLayout; // alternative to layoutId + Runnable mEnterAction, mExitAction; + + /** + * Constructs a Scene with no information about how values will change + * when this scene is applied. This constructor might be used when + * a Scene is created with the intention of being dynamically configured, + * through setting {@link #setEnterAction(Runnable)} and possibly + * {@link #setExitAction(Runnable)}. + * + * @param sceneRoot The root of the hierarchy in which scene changes + * and transitions will take place. + */ + public Scene(ViewGroup sceneRoot) { + mSceneRoot = sceneRoot; + } + + /** + * Constructs a Scene which, when entered, will remove any + * children from the sceneRoot container and will inflate and add + * the hierarchy specified by the layoutId resource file. + * + * @param sceneRoot The root of the hierarchy in which scene changes + * and transitions will take place. + * @param layoutId The id of a resource file that defines the view + * hierarchy of this scene. + * @param context The context used in the process of inflating + * the layout resource. + */ + public Scene(ViewGroup sceneRoot, int layoutId, Context context) { + mContext = context; + mSceneRoot = sceneRoot; + mLayoutId = layoutId; + } + + /** + * Constructs a Scene which, when entered, will remove any + * children from the sceneRoot container and add the layout + * object as a new child of that container. + * + * @param sceneRoot The root of the hierarchy in which scene changes + * and transitions will take place. + * @param layout The view hiearrchy of this scene, added as a child + * of sceneRoot when this scene is entered. + */ + public Scene(ViewGroup sceneRoot, ViewGroup layout) { + mSceneRoot = sceneRoot; + mLayout = layout; + } + + /** + * Gets the root of the scene, which is the root of the view hierarchy + * affected by changes due to this scene, and which will be animated + * when this scene is entered. + * + * @return The root of the view hierarchy affected by this scene. + */ + public ViewGroup getSceneRoot() { + return mSceneRoot; + } + + /** + * Exits this scene, if it is the {@link ViewGroup#getCurrentScene() + * currentScene} on the scene's {@link #getSceneRoot() scene root}. + * Exiting a scene involves removing the layout added if the scene + * has either a layoutId or layout view group (set at construction + * time) and running the {@link #setExitAction(Runnable) exit action} + * if there is one. + */ + public void exit() { + if (mSceneRoot.getCurrentScene() == this) { + if (mLayoutId >= 0 || mLayout != null) { + // Undo layout change caused by entering this scene + getSceneRoot().removeAllViews(); + } + if (mExitAction != null) { + mExitAction.run(); + } + } + } + + /** + * Enters this scene, which entails changing all values that + * are specified by this scene. These may be values associated + * with a layout view group or layout resource file which will + * now be added to the scene root, or it may be values changed by + * an {@link #setEnterAction(Runnable)} enter action}, or a + * combination of the these. No transition will be run when the + * scene is entered. To get transition behavior in scene changes, + * use one of the methods in {@link TransitionManager} instead. + */ + public void enter() { + + // Apply layout change, if any + if (mLayoutId >= 0 || mLayout != null) { + // redundant with exit() action of previous scene, but must + // empty out that parent container before adding to it + getSceneRoot().removeAllViews(); + + if (mLayoutId >= 0) { + LayoutInflater.from(mContext).inflate(mLayoutId, mSceneRoot); + } else { + mSceneRoot.addView(mLayout); + } + } + + // Notify next scene that it is entering. Subclasses may override to configure scene. + if (mEnterAction != null) { + mEnterAction.run(); + } + + mSceneRoot.setCurrentScene(this ); + } + + /** + * Scenes that are not defined with layout resources or + * hierarchies, or which need to perform additional steps + * after those hierarchies are changed to, should set an enter + * action, and possibly an exit action as well. An enter action + * will cause Scene to call back into application code to do + * anything else the application needs after transitions have + * captured pre-change values and after any other scene changes + * have been applied, such as the layout (if any) being added to + * the view hierarchy. After this method is called, Transitions will + * be played. + * + * @param action The runnable whose {@link Runnable#run() run()} method will + * be called when this scene is entered + * @see #setExitAction(Runnable) + * @see Scene#Scene(ViewGroup, int, Context) + * @see Scene#Scene(ViewGroup, ViewGroup) + */ + public void setEnterAction(Runnable action) { + mEnterAction = action; + } + + /** + * Scenes that are not defined with layout resources or + * hierarchies, or which need to perform additional steps + * after those hierarchies are changed to, should set an enter + * action, and possibly an exit action as well. An exit action + * will cause Scene to call back into application code to do + * anything the application needs to do after applicable transitions have + * captured pre-change values, but before any other scene changes + * have been applied, such as the new layout (if any) being added to + * the view hierarchy. After this method is called, the next scene + * will be entered, including a call to {@link #setEnterAction(Runnable)} + * if an enter action is set. + * + * @see #setEnterAction(Runnable) + * @see Scene#Scene(ViewGroup, int, Context) + * @see Scene#Scene(ViewGroup, ViewGroup) + */ + public void setExitAction(Runnable action) { + mExitAction = action; + } + +}
\ No newline at end of file diff --git a/core/java/android/view/transition/Slide.java b/core/java/android/view/transition/Slide.java new file mode 100644 index 0000000..8630ee2 --- /dev/null +++ b/core/java/android/view/transition/Slide.java @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.ObjectAnimator; +import android.animation.TimeInterpolator; +import android.view.View; +import android.view.ViewGroup; +import android.view.animation.AccelerateInterpolator; +import android.view.animation.DecelerateInterpolator; + +/** + * This transition captures the visibility of target objects before and + * after a scene change and animates any changes by sliding the target + * objects into or out of place. + */ +public class Slide extends Visibility { + + // TODO: Add parameter for sliding factor - it's hard-coded below + + private static final TimeInterpolator sAccelerator = new AccelerateInterpolator(); + private static final TimeInterpolator sDecelerator = new DecelerateInterpolator(); + + @Override + protected Animator appear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + ObjectAnimator anim = ObjectAnimator.ofFloat(endView, View.TRANSLATION_Y, + -2 * endView.getHeight(), 0); + anim.setInterpolator(sDecelerator); + return anim; + } + + @Override + protected boolean preAppear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + endView.setTranslationY(-2 * endView.getHeight()); + return true; + } + + @Override + protected boolean preDisappear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + startView.setTranslationY(0); + return true; + } + + @Override + protected Animator disappear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + ObjectAnimator anim = ObjectAnimator.ofFloat(startView, View.TRANSLATION_Y, 0, + -2 * startView.getHeight()); + anim.setInterpolator(sAccelerator); + return anim; + } + +} diff --git a/core/java/android/view/transition/TextChange.java b/core/java/android/view/transition/TextChange.java new file mode 100644 index 0000000..0ba2412 --- /dev/null +++ b/core/java/android/view/transition/TextChange.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.animation.ValueAnimator; +import android.view.ViewGroup; +import android.widget.TextView; + +import java.util.HashMap; + +/** + * This transition tracks changes to the text in TextView targets. If the text + * changes between the start and end scenes, the transition ensures that the + * starting text stays until the transition ends, at which point it changes + * to the end text. This is useful in situations where you want to resize a + * text view to its new size before displaying the text that goes there. + */ +public class TextChange extends Transition { + private static final String PROPNAME_TEXT = "android:textchange:text"; + + // TODO: think about other options we could have here, like cross-fading the text, or fading + // it out/in. These could be parameters to supply to the constructors (and xml attributes). + + @Override + protected void captureValues(TransitionValues values, boolean start) { + if (values.view instanceof TextView) { + TextView textview = (TextView) values.view; + values.values.put(PROPNAME_TEXT, textview.getText()); + } + } + + @Override + protected boolean prePlay(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null || !(endValues.view instanceof TextView)) { + return false; + } + final TextView view = (TextView) endValues.view; + HashMap<String, Object> startVals = startValues.values; + HashMap<String, Object> endVals = endValues.values; + String startText = (String) startVals.get(PROPNAME_TEXT); + String endText = (String) endVals.get(PROPNAME_TEXT); + if (!startText.equals(endText)) { + view.setText(startText); + return true; + } + return false; + } + + @Override + protected Animator play(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + if (startValues == null || endValues == null || !(endValues.view instanceof TextView)) { + return null; + } + final TextView view = (TextView) endValues.view; + HashMap<String, Object> startVals = startValues.values; + HashMap<String, Object> endVals = endValues.values; + final String startText = (String) startVals.get(PROPNAME_TEXT); + final String endText = (String) endVals.get(PROPNAME_TEXT); + if (!startText.equals(endText)) { + // This noop animation is just used to keep the text in its start state + // until the transition ends + ValueAnimator anim = ValueAnimator.ofFloat(0, 1); + anim.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + view.setText(endText); + } + }); + return anim; + } + return null; + } +} diff --git a/core/java/android/view/transition/Transition.java b/core/java/android/view/transition/Transition.java new file mode 100644 index 0000000..150c218 --- /dev/null +++ b/core/java/android/view/transition/Transition.java @@ -0,0 +1,911 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.animation.TimeInterpolator; +import android.util.LongSparseArray; +import android.util.SparseArray; +import android.view.SurfaceView; +import android.view.TextureView; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewOverlay; +import android.widget.ListView; + +import java.util.ArrayList; +import java.util.HashMap; + +/** + * A Transition holds information about animations that will be run on its + * targets during a scene change. Subclasses of this abstract class may + * choreograph several child transitions ({@link TransitionGroup} or they may + * perform custom animations themselves. Any Transition has two main jobs: + * (1) capture property values, and (2) play animations based on changes to + * captured property values. A custom transition knows what property values + * on View objects are of interest to it, and also knows how to animate + * changes to those values. For example, the {@link Fade} transition tracks + * changes to visibility-related properties and is able to construct and run + * animations that fade items in or out based on changes to those properties. + * + * <p>Note: Transitions may not work correctly with either {@link SurfaceView} + * or {@link TextureView}, due to the way that these views are displayed + * on the screen. For SurfaceView, the problem is that the view is updated from + * a non-UI thread, so changes to the view due to transitions (such as moving + * and resizing the view) may be out of sync with the display inside those bounds. + * TextureView is more compatible with transitions in general, but some + * specific transitions (such as {@link Crossfade}) may not be compatible + * with TextureView because they rely on {@link ViewOverlay} functionality, + * which does not currently work with TextureView.</p> + */ +public abstract class Transition { + + private static final String LOG_TAG = "Transition"; + static final boolean DBG = false; + + long mStartDelay = -1; + long mDuration = -1; + TimeInterpolator mInterpolator = null; + int[] mTargetIds; + View[] mTargets; + // TODO: sparse arrays instead of hashmaps? + private HashMap<View, TransitionValues> mStartValues = + new HashMap<View, TransitionValues>(); + private SparseArray<TransitionValues> mStartIdValues = new SparseArray<TransitionValues>(); + private LongSparseArray<TransitionValues> mStartItemIdValues = + new LongSparseArray<TransitionValues>(); + private HashMap<View, TransitionValues> mEndValues = + new HashMap<View, TransitionValues>(); + private SparseArray<TransitionValues> mEndIdValues = new SparseArray<TransitionValues>(); + private LongSparseArray<TransitionValues> mEndItemIdValues = + new LongSparseArray<TransitionValues>(); + + // Used to carry data between preplay() and play(), cleared before every scene transition + private ArrayList<TransitionValues> mPlayStartValuesList = new ArrayList<TransitionValues>(); + private ArrayList<TransitionValues> mPlayEndValuesList = new ArrayList<TransitionValues>(); + + // Number of per-target instances of this Transition currently running. This count is + // determined by calls to startTransition() and endTransition() + int mNumInstances = 0; + + + /** + * The set of listeners to be sent transition lifecycle events. + */ + ArrayList<TransitionListener> mListeners = null; + + /** + * Constructs a Transition object with no target objects. A transition with + * no targets defaults to running on all target objects in the scene hierarchy + * (if the transition is not contained in a TransitionGroup), or all target + * objects passed down from its parent (if it is in a TransitionGroup). + */ + public Transition() {} + + /** + * Sets the duration of this transition. By default, there is no duration + * (indicated by a negative number), which means that the Animator created by + * the transition will have its own specified duration. If the duration of a + * Transition is set, that duration will override the Animator duration. + * + * @param duration The length of the animation, in milliseconds. + * @return This transition object. + */ + public Transition setDuration(long duration) { + mDuration = duration; + return this; + } + + public long getDuration() { + return mDuration; + } + + /** + * Sets the startDelay of this transition. By default, there is no delay + * (indicated by a negative number), which means that the Animator created by + * the transition will have its own specified startDelay. If the delay of a + * Transition is set, that delay will override the Animator delay. + * + * @param startDelay The length of the delay, in milliseconds. + */ + public void setStartDelay(long startDelay) { + mStartDelay = startDelay; + } + + public long getStartDelay() { + return mStartDelay; + } + + /** + * Sets the interpolator of this transition. By default, the interpolator + * is null, which means that the Animator created by the transition + * will have its own specified interpolator. If the interpolator of a + * Transition is set, that interpolator will override the Animator interpolator. + * + * @param interpolator The time interpolator used by the transition + */ + public void setInterpolator(TimeInterpolator interpolator) { + mInterpolator = interpolator; + } + + public TimeInterpolator getInterpolator() { + return mInterpolator; + } + + /** + * This method is called by the transition's parent (all the way up to the + * topmost Transition in the hierarchy) with the sceneRoot and start/end + * values that the transition may need to run animations on its target + * views. The method is called for every applicable target object, which + * is stored in the {@link TransitionValues#view} field. When the method + * results in an animation needing to be run, the transition will construct + * the appropriate {@link Animator} object and return it. The transition + * mechanism will apply any applicable duration, startDelay, and interpolator + * to that animation and start it. Returning null from the method tells the + * transition engine that there is no animation to be played (TransitionGroup + * will return null because any applicable animations were started on its child + * transitions already and there is no animation to be run on the group itself). + * + * @param sceneRoot + * @param startValues + * @param endValues + * @return Animator The animation to run. + */ + protected abstract Animator play(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues); + + /** + * This method is called by the transition's parent (all the way up to the + * topmost Transition in the hierarchy) with the sceneRoot and start/end + * values that the transition may need to set things up at the start of a + * Transition. For example, if an overall Transition consists of several + * child transitions in sequence, then some of the child transitions may + * want to set initial values on target views prior to the overall + * Transition commencing, to put them in an appropriate scene for the + * delay between that start and the child Transition start time. For + * example, a transition that fades an item in may wish to set the starting + * alpha value to 0, to avoid it blinking in prior to the transition + * actually starting the animation. This is necessary because the scene + * change that triggers the Transition will automatically set the end-scene + * on all target views, so a Transition that wants to animate from a + * different value should set that value in the preplay() method. + * + * <p>Additionally, a Transition can perform logic to determine whether + * the transition needs to run on the given target and start/end values. + * For example, a transition that resizes objects on the screen may wish + * to avoid running for views which are not present in either the start + * or end scenes. A return value of <code>false</code> indicates that + * the transition should not run, and there will be no ensuing call to the + * {@link #play(ViewGroup, TransitionValues, TransitionValues)} method during + * this scene change. The default implementation returns true.</p> + * + * <p>The method is called for every applicable target object, which is + * stored in the {@link TransitionValues#view} field.</p> + * + * @param sceneRoot + * @param startValues + * @param endValues + * @return True if the Transition's {@link #play(ViewGroup, + * TransitionValues, TransitionValues) play()} method should be called + * during this scene change, false otherwise. + */ + protected boolean prePlay(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + return true; + } + + /** + * This version of prePlay() is called with the entire set of start/end + * values. The implementation in Transition iterates through these lists + * and calls {@link #prePlay(ViewGroup, TransitionValues, TransitionValues)} + * with each set of start/end values on this transition. The + * TransitionGroup subclass overrides this method and delegates it to + * each of its children in succession. The intention in splitting + * preplay() out from play() is to allow all Transitions in the tree to + * set up the appropriate start scene for their target objects prior to + * any calls to play(), which is necessary when there is a sequential + * Transition, where a child transition which is not the first may want to + * set up a target's scene prior to the overall Transition start. + * + * @hide + */ + protected void prePlay(ViewGroup sceneRoot, HashMap<View, TransitionValues> startValues, + SparseArray<TransitionValues> startIdValues, + LongSparseArray<TransitionValues> startItemIdValues, + HashMap<View, TransitionValues> endValues, + SparseArray<TransitionValues> endIdValues, + LongSparseArray<TransitionValues> endItemIdValues) { + mPlayStartValuesList.clear(); + mPlayEndValuesList.clear(); + HashMap<View, TransitionValues> endCopy = new HashMap<View, TransitionValues>(endValues); + SparseArray<TransitionValues> endIdCopy = + new SparseArray<TransitionValues>(endIdValues.size()); + for (int i = 0; i < endIdValues.size(); ++i) { + int id = endIdValues.keyAt(i); + endIdCopy.put(id, endIdValues.valueAt(i)); + } + LongSparseArray<TransitionValues> endItemIdCopy = + new LongSparseArray<TransitionValues>(endItemIdValues.size()); + for (int i = 0; i < endItemIdValues.size(); ++i) { + long id = endItemIdValues.keyAt(i); + endItemIdCopy.put(id, endItemIdValues.valueAt(i)); + } + // Walk through the start values, playing everything we find + // Remove from the end set as we go + ArrayList<TransitionValues> startValuesList = new ArrayList<TransitionValues>(); + ArrayList<TransitionValues> endValuesList = new ArrayList<TransitionValues>(); + for (View view : startValues.keySet()) { + TransitionValues start = null; + TransitionValues end = null; + boolean isInListView = false; + if (view.getParent() instanceof ListView) { + isInListView = true; + } + if (!isInListView) { + int id = view.getId(); + start = startValues.get(view) != null ? + startValues.get(view) : startIdValues.get(id); + if (endValues.get(view) != null) { + end = endValues.get(view); + endCopy.remove(view); + } else { + end = endIdValues.get(id); + View removeView = null; + for (View viewToRemove : endCopy.keySet()) { + if (viewToRemove.getId() == id) { + removeView = viewToRemove; + } + } + if (removeView != null) { + endCopy.remove(removeView); + } + } + endIdCopy.remove(id); + if (isValidTarget(view, id)) { + startValuesList.add(start); + endValuesList.add(end); + } + } else { + ListView parent = (ListView) view.getParent(); + if (parent.getAdapter().hasStableIds()) { + int position = parent.getPositionForView(view); + long itemId = parent.getItemIdAtPosition(position); + start = startItemIdValues.get(itemId); + endItemIdCopy.remove(itemId); + // TODO: deal with targetIDs for itemIDs for ListView items + startValuesList.add(start); + endValuesList.add(end); + } + } + } + int startItemIdCopySize = startItemIdValues.size(); + for (int i = 0; i < startItemIdCopySize; ++i) { + long id = startItemIdValues.keyAt(i); + if (isValidTarget(null, id)) { + TransitionValues start = startItemIdValues.get(id); + TransitionValues end = endItemIdValues.get(id); + endItemIdCopy.remove(id); + startValuesList.add(start); + endValuesList.add(end); + } + } + // Now walk through the remains of the end set + for (View view : endCopy.keySet()) { + int id = view.getId(); + if (isValidTarget(view, id)) { + TransitionValues start = startValues.get(view) != null ? + startValues.get(view) : startIdValues.get(id); + TransitionValues end = endCopy.get(view); + endIdCopy.remove(id); + startValuesList.add(start); + endValuesList.add(end); + } + } + int endIdCopySize = endIdCopy.size(); + for (int i = 0; i < endIdCopySize; ++i) { + int id = endIdCopy.keyAt(i); + if (isValidTarget(null, id)) { + TransitionValues start = startIdValues.get(id); + TransitionValues end = endIdCopy.get(id); + startValuesList.add(start); + endValuesList.add(end); + } + } + int endItemIdCopySize = endItemIdCopy.size(); + for (int i = 0; i < endItemIdCopySize; ++i) { + long id = endItemIdCopy.keyAt(i); + // TODO: Deal with targetIDs and itemIDs + TransitionValues start = startItemIdValues.get(id); + TransitionValues end = endItemIdCopy.get(id); + startValuesList.add(start); + endValuesList.add(end); + } + for (int i = 0; i < startValuesList.size(); ++i) { + TransitionValues start = startValuesList.get(i); + TransitionValues end = endValuesList.get(i); + // TODO: what to do about targetIds and itemIds? + if (prePlay(sceneRoot, start, end)) { + // Note: we've already done the check against targetIDs in these lists + mPlayStartValuesList.add(start); + mPlayEndValuesList.add(end); + } + } + } + + /** + * Internal utility method for checking whether a given view/id + * is valid for this transition, where "valid" means that either + * the Transition has no target/targetId list (the default, in which + * cause the transition should act on all views in the hiearchy), or + * the given view is in the target list or the view id is in the + * targetId list. If the target parameter is null, then the target list + * is not checked (this is in the case of ListView items, where the + * views are ignored and only the ids are used). + */ + boolean isValidTarget(View target, long targetId) { + if (mTargetIds == null && mTargets == null) { + return true; + } + if (mTargetIds != null) { + for (int i = 0; i < mTargetIds.length; ++i) { + if (mTargetIds[i] == targetId) { + return true; + } + } + } + if (target != null && mTargets != null) { + for (int i = 0; i < mTargets.length; ++i) { + if (mTargets[i] == target) { + return true; + } + } + } + return false; + } + + /** + * This version of play() is called with the entire set of start/end + * values. The implementation in Transition iterates through these lists + * and calls {@link #play(ViewGroup, TransitionValues, TransitionValues)} + * with each set of start/end values on this transition. The + * TransitionGroup subclass overrides this method and delegates it to + * each of its children in succession. + * + * @hide + */ + protected void play(ViewGroup sceneRoot, + final HashMap<View, TransitionValues> startValues, + final SparseArray<TransitionValues> startIdValues, + final LongSparseArray<TransitionValues> startItemIdValues, + final HashMap<View, TransitionValues> endValues, + final SparseArray<TransitionValues> endIdValues, + final LongSparseArray<TransitionValues> endItemIdValues) { + + startTransition(); + // Now walk the list of TransitionValues, calling play for each pair + for (int i = 0; i < mPlayStartValuesList.size(); ++i) { + TransitionValues start = mPlayStartValuesList.get(i); + TransitionValues end = mPlayEndValuesList.get(i); + startTransition(); + animate(play(sceneRoot, start, end)); + } + mPlayStartValuesList.clear(); + mPlayEndValuesList.clear(); + endTransition(); + } + + /** + * Captures the current scene of values for the properties that this + * transition monitors. These values can be either the start or end + * values used in a subsequent call to + * {@link #play(ViewGroup, TransitionValues, TransitionValues)}, as indicated by + * <code>start</code>. The main concern for an implementation is what the + * properties are that the transition cares about and what the values are + * for all of those properties. The start and end values will be compared + * later during the preplay and play() methods to determine what, if any, + * animations, should be run. + * + * @param transitionValues The holder any values that the Transition + * wishes to store. Values are stored in the fields of this + * TransitionValues object, according to their type, and are keyed from + * a String value. For example, to start a view's rotation value, + * a Transition might call + * <code>transitionValues.floatValues.put("rotation", view.getRotation()) + * </code>. The target <code>View</code> will already be stored in + * the transitionValues structure when this method is called. The other + * fields in TransitionValues, e.g. <code>floatValues</code>, + * may need to be instantiated if they have not yet been created. + */ + protected abstract void captureValues(TransitionValues transitionValues, boolean start); + + /** + * Sets the ids of target views that this Transition is interested in + * animating. By default, there are no targetIds, and a Transition will + * listen for changes on every view in the hierarchy below the sceneRoot + * of the Scene being transitioned into. Setting targetIDs constrains + * the Transition to only listen for, and act on, views with these IDs. + * Views with different IDs, or no IDs whatsoever, will be ignored. + * + * @see View#getId() + * @param targetIds A list of IDs which specify the set of Views on which + * the Transition will act. + * @return Transition The Transition on which the targetIds have been set. + * Returning the same object makes it easier to chain calls during + * construction, such as + * <code>transitionGroup.addTransitions(new Fade()).setTargetIds(someId);</code> + */ + public Transition setTargetIds(int... targetIds) { + int numTargets = targetIds.length; + mTargetIds = new int[numTargets]; + System.arraycopy(targetIds, 0, mTargetIds, 0, numTargets); + return this; + } + + /** + * Sets the target view instances that this Transition is interested in + * animating. By default, there are no targets, and a Transition will + * listen for changes on every view in the hierarchy below the sceneRoot + * of the Scene being transitioned into. Setting targets constrains + * the Transition to only listen for, and act on, these views. + * All other views will be ignored. + * + * <p>The target list is like the {@link #setTargetIds(int...) targetId} + * list except this list specifies the actual View instances, not the ids + * of the views. This is an important distinction when scene changes involve + * view hierarchies which have been inflated separately; different views may + * share the same id but not actually be the same instance. If the transition + * should treat those views as the same, then seTargetIds() should be used + * instead of setTargets(). If, on the other hand, scene changes involve + * changes all within the same view hierarchy, among views which do not + * necessary have ids set on them, then the target list may be more + * convenient.</p> + * + * @see #setTargetIds(int...) + * @param targets A list of Views on which the Transition will act. + * @return Transition The Transition on which the targets have been set. + * Returning the same object makes it easier to chain calls during + * construction, such as + * <code>transitionGroup.addTransitions(new Fade()).setTargets(someView);</code> + */ + public Transition setTargets(View... targets) { + int numTargets = targets.length; + mTargets = new View[numTargets]; + System.arraycopy(targets, 0, mTargets, 0, numTargets); + return this; + } + + /** + * Returns the array of target IDs that this transition limits itself to + * tracking and animating. If the array is null for both this method and + * {@link #getTargets()}, then this transition is + * not limited to specific views, and will handle changes to any views + * in the hierarchy of a scene change. + * + * @return the list of target IDs + */ + public int[] getTargetIds() { + return mTargetIds; + } + + /** + * Returns the array of target views that this transition limits itself to + * tracking and animating. If the array is null for both this method and + * {@link #getTargetIds()}, then this transition is + * not limited to specific views, and will handle changes to any views + * in the hierarchy of a scene change. + * + * @return the list of target views + */ + public View[] getTargets() { + return mTargets; + } + + /** + * Recursive method that captures values for the given view and the + * hierarchy underneath it. + * @param sceneRoot The root of the view hierarchy being captured + * @param start true if this capture is happening before the scene change, + * false otherwise + */ + void captureValues(ViewGroup sceneRoot, boolean start) { + if (mTargetIds != null && mTargetIds.length > 0 || + mTargets != null && mTargets.length > 0) { + if (mTargetIds != null) { + for (int i = 0; i < mTargetIds.length; ++i) { + int id = mTargetIds[i]; + View view = sceneRoot.findViewById(id); + if (view != null) { + TransitionValues values = new TransitionValues(); + values.view = view; + captureValues(values, start); + if (start) { + mStartValues.put(view, values); + mStartIdValues.put(id, values); + } else { + mEndValues.put(view, values); + mEndIdValues.put(id, values); + } + } + } + } + if (mTargets != null) { + for (int i = 0; i < mTargets.length; ++i) { + View view = mTargets[i]; + if (view != null) { + TransitionValues values = new TransitionValues(); + values.view = view; + captureValues(values, start); + if (start) { + mStartValues.put(view, values); + } else { + mEndValues.put(view, values); + } + } + } + } + } else { + captureHierarchy(sceneRoot, start); + } + } + + /** + * Recursive method which captures values for an entire view hierarchy, + * starting at some root view. Transitions without targetIDs will use this + * method to capture values for all possible views. + * + * @param view The view for which to capture values. Children of this View + * will also be captured, recursively down to the leaf nodes. + * @param start true if values are being captured in the start scene, false + * otherwise. + */ + private void captureHierarchy(View view, boolean start) { + if (view == null) { + return; + } + boolean isListViewItem = false; + if (view.getParent() instanceof ListView) { + isListViewItem = true; + } + if (isListViewItem && !((ListView) view.getParent()).getAdapter().hasStableIds()) { + // ignore listview children unless we can track them with stable IDs + return; + } + long id; + if (!isListViewItem) { + id = view.getId(); + } else { + ListView listview = (ListView) view.getParent(); + int position = listview.getPositionForView(view); + id = listview.getItemIdAtPosition(position); + view.setHasTransientState(true); + } + TransitionValues values = new TransitionValues(); + values.view = view; + captureValues(values, start); + if (start) { + if (!isListViewItem) { + mStartValues.put(view, values); + mStartIdValues.put((int) id, values); + } else { + mStartItemIdValues.put(id, values); + } + } else { + if (!isListViewItem) { + mEndValues.put(view, values); + mEndIdValues.put((int) id, values); + } else { + mEndItemIdValues.put(id, values); + } + } + if (view instanceof ViewGroup) { + ViewGroup parent = (ViewGroup) view; + for (int i = 0; i < parent.getChildCount(); ++i) { + captureHierarchy(parent.getChildAt(i), start); + } + } + } + + /** + * Called by TransitionManager to play the transition. This calls + * prePlay() and then play() with the full set of per-view + * transitionValues objects + */ + void play(ViewGroup sceneRoot) { + // prePlay() must be called on entire transition hierarchy and set of views + // before calling play() on anything; every transition needs a chance to set up + // target views appropriately before transitions begin running + prePlay(sceneRoot, mStartValues, mStartIdValues, mStartItemIdValues, + mEndValues, mEndIdValues, mEndItemIdValues); + play(sceneRoot, mStartValues, mStartIdValues, mStartItemIdValues, + mEndValues, mEndIdValues, mEndItemIdValues); + } + + /** + * This is a utility method used by subclasses to handle standard parts of + * setting up and running an Animator: it sets the {@link #getDuration() + * duration} and the {@link #getStartDelay() startDelay}, starts the + * animation, and, when the animator ends, calls {@link #endTransition()}. + * + * @param animator The Animator to be run during this transition. + * + * @hide + */ + protected void animate(Animator animator) { + // TODO: maybe pass auto-end as a boolean parameter? + if (animator == null) { + endTransition(); + } else { + if (getDuration() >= 0) { + animator.setDuration(getDuration()); + } + if (getStartDelay() >= 0) { + animator.setStartDelay(getStartDelay()); + } + if (getInterpolator() != null) { + animator.setInterpolator(getInterpolator()); + } + animator.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationCancel(Animator animation) { + cancelTransition(); + } + + @Override + public void onAnimationEnd(Animator animation) { + endTransition(); + animation.removeListener(this); + } + }); + animator.start(); + } + } + + /** + * Subclasses may override to receive notice of when the transition starts. + * This is equivalent to listening for the + * {@link TransitionListener#onTransitionStart(Transition)} callback. + */ + protected void onTransitionStart() { + } + + /** + * Subclasses may override to receive notice of when the transition is + * canceled. This is equivalent to listening for the + * {@link TransitionListener#onTransitionCancel(Transition)} callback. + */ + protected void onTransitionCancel() { + } + + /** + * Subclasses may override to receive notice of when the transition ends. + * This is equivalent to listening for the + * {@link TransitionListener#onTransitionEnd(Transition)} callback. + */ + protected void onTransitionEnd() { + } + + /** + * This method is called automatically by the transition and + * TransitionGroup classes prior to a Transition subclass starting; + * subclasses should not need to call it directly. + * + * @hide + */ + protected void startTransition() { + if (mNumInstances == 0) { + onTransitionStart(); + if (mListeners != null && mListeners.size() > 0) { + ArrayList<TransitionListener> tmpListeners = + (ArrayList<TransitionListener>) mListeners.clone(); + int numListeners = tmpListeners.size(); + for (int i = 0; i < numListeners; ++i) { + tmpListeners.get(i).onTransitionStart(this); + } + } + } + mNumInstances++; + } + + /** + * This method is called automatically by the Transition and + * TransitionGroup classes when a transition finishes, either because + * a transition did nothing (returned a null Animator from + * {@link Transition#play(ViewGroup, TransitionValues, + * TransitionValues)}) or because the transition returned a valid + * Animator and endTransition() was called in the onAnimationEnd() + * callback of the AnimatorListener. + * + * @hide + */ + protected void endTransition() { + --mNumInstances; + if (mNumInstances == 0) { + onTransitionEnd(); + if (mListeners != null && mListeners.size() > 0) { + ArrayList<TransitionListener> tmpListeners = + (ArrayList<TransitionListener>) mListeners.clone(); + int numListeners = tmpListeners.size(); + for (int i = 0; i < numListeners; ++i) { + tmpListeners.get(i).onTransitionEnd(this); + } + } + for (int i = 0; i < mStartItemIdValues.size(); ++i) { + TransitionValues tv = mStartItemIdValues.valueAt(i); + View v = tv.view; + if (v.hasTransientState()) { + v.setHasTransientState(false); + } + } + for (int i = 0; i < mEndItemIdValues.size(); ++i) { + TransitionValues tv = mEndItemIdValues.valueAt(i); + View v = tv.view; + if (v.hasTransientState()) { + v.setHasTransientState(false); + } + } + mStartValues.clear(); + mStartIdValues.clear(); + mStartItemIdValues.clear(); + mEndValues.clear(); + mEndIdValues.clear(); + mEndItemIdValues.clear(); + } + } + + /** + * This method cancels a transition that is currently running. + * Implementation TBD. + */ + protected void cancelTransition() { + // TODO: how does this work with instances? + // TODO: this doesn't actually do *anything* yet + onTransitionCancel(); + if (mListeners != null && mListeners.size() > 0) { + ArrayList<TransitionListener> tmpListeners = + (ArrayList<TransitionListener>) mListeners.clone(); + int numListeners = tmpListeners.size(); + for (int i = 0; i < numListeners; ++i) { + tmpListeners.get(i).onTransitionCancel(this); + } + } + } + + /** + * Adds a listener to the set of listeners that are sent events through the + * life of an animation, such as start, repeat, and end. + * + * @param listener the listener to be added to the current set of listeners + * for this animation. + */ + public void addListener(TransitionListener listener) { + if (mListeners == null) { + mListeners = new ArrayList<TransitionListener>(); + } + mListeners.add(listener); + } + + /** + * Removes a listener from the set listening to this animation. + * + * @param listener the listener to be removed from the current set of + * listeners for this transition. + */ + public void removeListener(TransitionListener listener) { + if (mListeners == null) { + return; + } + mListeners.remove(listener); + if (mListeners.size() == 0) { + mListeners = null; + } + } + + /** + * Gets the set of {@link TransitionListener} objects that are currently + * listening for events on this <code>Transition</code> object. + * + * @return ArrayList<TransitionListener> The set of listeners. + */ + public ArrayList<TransitionListener> getListeners() { + return mListeners; + } + + @Override + public String toString() { + return toString(""); + } + + String toString(String indent) { + String result = indent + getClass().getSimpleName() + "@" + + Integer.toHexString(hashCode()) + ": "; + result += "dur(" + mDuration + ") "; + result += "dly(" + mStartDelay + ") "; + result += "interp(" + mInterpolator + ") "; + result += "tgts("; + if (mTargetIds != null) { + for (int i = 0; i < mTargetIds.length; ++i) { + if (i > 0) { + result += ", "; + } + result += mTargetIds[i]; + } + } + if (mTargets != null) { + for (int i = 0; i < mTargets.length; ++i) { + if (i > 0) { + result += ", "; + } + result += mTargets[i]; + } + } + result += ")"; + return result; + } + + /** + * A transition listener receives notifications from a transition. + * Notifications indicate transition lifecycle events: when the transition + * begins, ends, or is canceled. + */ + public static interface TransitionListener { + /** + * Notification about the start of the transition. + * + * @param transition The started transition. + */ + void onTransitionStart(Transition transition); + + /** + * Notification about the end of the transition. Canceled transitions + * will always notify listeners of both the cancellation and end + * events. That is, {@link #onTransitionEnd()} is always called, + * regardless of whether the transition was canceled or played + * through to completion. + * + * @param transition The transition which reached its end. + */ + void onTransitionEnd(Transition transition); + + /** + * Notification about the cancellation of the transition. + * + * @param transition The transition which was canceled. + */ + void onTransitionCancel(Transition transition); + } + + /** + * Utility adapter class to avoid having to override all three methods + * whenever someone just wants to listen for a single event. + * + * @hide + * */ + public static class TransitionListenerAdapter implements TransitionListener { + @Override + public void onTransitionStart(Transition transition) { + } + + @Override + public void onTransitionEnd(Transition transition) { + } + + @Override + public void onTransitionCancel(Transition transition) { + } + } + +} diff --git a/core/java/android/view/transition/TransitionGroup.java b/core/java/android/view/transition/TransitionGroup.java new file mode 100644 index 0000000..363872a --- /dev/null +++ b/core/java/android/view/transition/TransitionGroup.java @@ -0,0 +1,292 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.util.AndroidRuntimeException; +import android.util.LongSparseArray; +import android.util.SparseArray; +import android.view.View; +import android.view.ViewGroup; + +import java.util.ArrayList; +import java.util.HashMap; + +/** + * A TransitionGroup is a parent of child transitions (including other + * TransitionGroups). Using TransitionGroups enables more complex + * choreography of transitions, where some groups play {@link #TOGETHER} and + * others play {@link #SEQUENTIALLY}. For example, {@link AutoTransition} + * uses a TransitionGroup to sequentially play a Fade(Fade.OUT), followed by + * a {@link Move}, followed by a Fade(Fade.OUT) transition. + */ +public class TransitionGroup extends Transition { + + ArrayList<Transition> mTransitions = new ArrayList<Transition>(); + private boolean mPlayTogether = true; + int mCurrentListeners; + boolean mStarted = false; + + /** + * A flag used to indicate that the child transitions of this group + * should all start at the same time. + */ + public static final int TOGETHER = 0; + /** + * A flag used to indicate that the child transitions of this group should + * play in sequence; when one child transition ends, the next child + * transition begins. Note that a transition does not end until all + * instances of it (which are playing on all applicable targets of the + * transition) end. + */ + public static final int SEQUENTIALLY = 1; + + /** + * Constructs an empty transition group. Add child transitions to the + * group by calling to {@link #addTransitions(Transition...)} )}. By default, + * child transitions will play {@link #TOGETHER}. + */ + public TransitionGroup() { + } + + /** + * Constructs an empty transition group with the specified ordering. + * + * @param ordering {@link #TOGETHER} to start this group's child + * transitions together, {@link #SEQUENTIALLY} to play the child + * transitions in sequence. + * @see #setOrdering(int) + */ + public TransitionGroup(int ordering) { + setOrdering(ordering); + } + + /** + * Sets the play order of this group's child transitions. + * + * @param ordering {@link #TOGETHER} to start this group's child + * transitions together, {@link #SEQUENTIALLY} to play the child + * transitions in sequence. + */ + public void setOrdering(int ordering) { + switch (ordering) { + case SEQUENTIALLY: + mPlayTogether = false; + break; + case TOGETHER: + mPlayTogether = true; + break; + default: + throw new AndroidRuntimeException("Invalid parameter for TransitionGroup " + + "ordering: " + ordering); + } + } + + /** + * Adds child transitions to this group. The order of the child transitions + * passed in determines the order in which they are started. + * + * @param transitions A list of child transition to be added to this group. + */ + public void addTransitions(Transition... transitions) { + if (transitions != null) { + int numTransitions = transitions.length; + for (int i = 0; i < numTransitions; ++i) { + mTransitions.add(transitions[i]); + } + } + } + + /** + * Removes the specified child transition from this group. + * + * @param transition The transition to be removed. + */ + public void removeTransition(Transition transition) { + mTransitions.remove(transition); + } + + /** + * Sets up listeners for each of the child transitions. This is used to + * determine when this transition group is finished (all child transitions + * must finish first). + */ + private void setupStartEndListeners() { + for (Transition childTransition : mTransitions) { + childTransition.addListener(mListener); + } + mCurrentListeners = mTransitions.size(); + } + + /** + * This listener is used to detect when all child transitions are done, at + * which point this transition group is also done. + */ + private TransitionListener mListener = new TransitionListenerAdapter() { + @Override + public void onTransitionStart(Transition transition) { + if (!mStarted) { + startTransition(); + mStarted = true; + } + } + + @Override + public void onTransitionEnd(Transition transition) { + --mCurrentListeners; + if (mCurrentListeners == 0) { + // All child trans + mStarted = false; + endTransition(); + } + transition.removeListener(this); + } + }; + + /** + * @hide + */ + @Override + protected void prePlay(ViewGroup sceneRoot, + HashMap<View, TransitionValues> startValues, + SparseArray<TransitionValues> startIdValues, + LongSparseArray<TransitionValues> startItemIdValues, + HashMap<View, TransitionValues> endValues, + SparseArray<TransitionValues> endIdValues, + LongSparseArray<TransitionValues> endItemIdValues) { + for (Transition childTransition : mTransitions) { + childTransition.prePlay(sceneRoot, startValues, startIdValues, startItemIdValues, + endValues, endIdValues, endItemIdValues); + } + } + + /** + * @hide + */ + @Override + protected void play(ViewGroup sceneRoot, + final HashMap<View, TransitionValues> startValues, + final SparseArray<TransitionValues> startIdValues, + final LongSparseArray<TransitionValues> startItemIdValues, + final HashMap<View, TransitionValues> endValues, + final SparseArray<TransitionValues> endIdValues, + final LongSparseArray<TransitionValues> endItemIdValues) { + setupStartEndListeners(); + final ViewGroup finalSceneRoot = sceneRoot; + if (!mPlayTogether) { + // Setup sequence with listeners + // TODO: Need to add listeners in such a way that we can remove them later if canceled + for (int i = 1; i < mTransitions.size(); ++i) { + Transition previousTransition = mTransitions.get(i - 1); + final Transition nextTransition = mTransitions.get(i); + previousTransition.addListener(new TransitionListenerAdapter() { + @Override + public void onTransitionEnd(Transition transition) { + nextTransition.play(finalSceneRoot, + startValues, startIdValues, startItemIdValues, + endValues, endIdValues, endItemIdValues); + transition.removeListener(this); + } + }); + } + Transition firstTransition = mTransitions.get(0); + if (firstTransition != null) { + firstTransition.play(finalSceneRoot, startValues, startIdValues, startItemIdValues, + endValues, endIdValues, endItemIdValues); + } + } else { + for (Transition childTransition : mTransitions) { + childTransition.play(finalSceneRoot, startValues, startIdValues, startItemIdValues, + endValues, endIdValues, endItemIdValues); + } + } + } + + @Override + protected Animator play(ViewGroup sceneRoot, + TransitionValues startValues, TransitionValues endValues) { + final View view = (endValues != null) ? endValues.view : + (startValues != null) ? startValues.view : null; + final int targetId = (view != null) ? view.getId() : -1; + // TODO: not sure this is a valid check - what about auto-targets? No need for ids. + if (targetId < 0) { + return null; + } + setupStartEndListeners(); + if (!mPlayTogether) { + final ViewGroup finalSceneRoot = sceneRoot; + final TransitionValues finalStartValues = startValues; + final TransitionValues finalEndValues = endValues; + // Setup sequence with listeners + // TODO: Need to add listeners in such a way that we can remove them later if canceled + for (int i = 1; i < mTransitions.size(); ++i) { + Transition previousTransition = mTransitions.get(i - 1); + final Transition nextTransition = mTransitions.get(i); + previousTransition.addListener(new TransitionListenerAdapter() { + @Override + public void onTransitionEnd(Transition transition) { + nextTransition.startTransition(); + if (nextTransition.isValidTarget(view, targetId)) { + animate(nextTransition.play(finalSceneRoot, finalStartValues, + finalEndValues)); + } else { + nextTransition.endTransition(); + } + } + }); + } + Transition firstTransition = mTransitions.get(0); + if (firstTransition != null) { + firstTransition.startTransition(); + if (firstTransition.isValidTarget(view, targetId)) { + animate(firstTransition.play(finalSceneRoot, finalStartValues, finalEndValues)); + } else { + firstTransition.endTransition(); + } + } + } else { + for (Transition childTransition : mTransitions) { + childTransition.startTransition(); + if (childTransition.isValidTarget(view, targetId)) { + animate(childTransition.play(sceneRoot, startValues, endValues)); + } else { + childTransition.endTransition(); + } + } + } + return null; + } + + @Override + protected void captureValues(TransitionValues transitionValues, boolean start) { + int targetId = transitionValues.view.getId(); + for (Transition childTransition : mTransitions) { + if (childTransition.isValidTarget(transitionValues.view, targetId)) { + childTransition.captureValues(transitionValues, start); + } + } + } + + @Override + String toString(String indent) { + String result = super.toString(indent); + for (int i = 0; i < mTransitions.size(); ++i) { + result += "\n" + mTransitions.get(i).toString(indent + " "); + } + return result; + } + +} diff --git a/core/java/android/view/transition/TransitionInflater.java b/core/java/android/view/transition/TransitionInflater.java new file mode 100644 index 0000000..a5f5836 --- /dev/null +++ b/core/java/android/view/transition/TransitionInflater.java @@ -0,0 +1,392 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.content.Context; +import android.content.res.Resources; +import android.content.res.TypedArray; +import android.content.res.XmlResourceParser; +import android.util.AttributeSet; +import android.util.SparseArray; +import android.util.Xml; +import android.view.InflateException; +import android.view.ViewGroup; +import android.view.animation.AnimationUtils; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; + +/** + * This class inflates scenes and transitions from resource files. + */ +public class TransitionInflater { + + // We only need one inflater for any given context. Also, this allows us to associate + // ids with unique instances per-Context, used to avoid re-inflating + // already-inflated resources into new/different instances + private static final HashMap<Context, TransitionInflater> sInflaterMap = + new HashMap<Context, TransitionInflater>(); + + private Context mContext; + // TODO: do we need id maps for transitions and transitionMgrs as well? + SparseArray<Scene> mScenes = new SparseArray<Scene>(); + + private TransitionInflater(Context context) { + mContext = context; + } + + /** + * Obtains the TransitionInflater from the given context. + */ + public static TransitionInflater from(Context context) { + TransitionInflater inflater = sInflaterMap.get(context); + if (inflater != null) { + return inflater; + } + inflater = new TransitionInflater(context); + sInflaterMap.put(context, inflater); + return inflater; + } + + /** + * Loads a {@link Transition} object from a resource + * + * @param resource The resource id of the transition to load + * @return The loaded Transition object + * @throws android.content.res.Resources.NotFoundException when the + * transition cannot be loaded + */ + public Transition inflateTransition(int resource) { + XmlResourceParser parser = mContext.getResources().getXml(resource); + try { + return createTransitionFromXml(parser, Xml.asAttributeSet(parser), null); + } catch (XmlPullParserException e) { + InflateException ex = new InflateException(e.getMessage()); + ex.initCause(e); + throw ex; + } catch (IOException e) { + InflateException ex = new InflateException( + parser.getPositionDescription() + + ": " + e.getMessage()); + ex.initCause(e); + throw ex; + } finally { + parser.close(); + } + } + + /** + * Loads a {@link TransitionManager} object from a resource + * + * + * + * @param resource The resource id of the transition manager to load + * @return The loaded TransitionManager object + * @throws android.content.res.Resources.NotFoundException when the + * transition manager cannot be loaded + */ + public TransitionManager inflateTransitionManager(int resource, ViewGroup sceneRoot) { + XmlResourceParser parser = mContext.getResources().getXml(resource); + try { + return createTransitionManagerFromXml(parser, Xml.asAttributeSet(parser), sceneRoot); + } catch (XmlPullParserException e) { + InflateException ex = new InflateException(e.getMessage()); + ex.initCause(e); + throw ex; + } catch (IOException e) { + InflateException ex = new InflateException( + parser.getPositionDescription() + + ": " + e.getMessage()); + ex.initCause(e); + throw ex; + } finally { + parser.close(); + } + } + + /** + * Loads a {@link Scene} object from a resource + * + * @param resource The resource id of the scene to load + * @return The loaded Scene object + * @throws android.content.res.Resources.NotFoundException when the scene + * cannot be loaded + */ + public Scene inflateScene(int resource, ViewGroup parent) { + Scene scene = mScenes.get(resource); + if (scene != null) { + return scene; + } + XmlResourceParser parser = mContext.getResources().getXml(resource); + try { + scene = createSceneFromXml(parser, Xml.asAttributeSet(parser), parent); + mScenes.put(resource, scene); + return scene; + } catch (XmlPullParserException e) { + InflateException ex = new InflateException(e.getMessage()); + ex.initCause(e); + throw ex; + } catch (IOException e) { + InflateException ex = new InflateException( + parser.getPositionDescription() + + ": " + e.getMessage()); + ex.initCause(e); + throw ex; + } finally { + parser.close(); + } + } + + + // + // Transition loading + // + + private Transition createTransitionFromXml(XmlPullParser parser, + AttributeSet attrs, TransitionGroup transitionGroup) + throws XmlPullParserException, IOException { + + Transition transition = null; + + // Make sure we are on a start tag. + int type; + int depth = parser.getDepth(); + + while (((type=parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth) + && type != XmlPullParser.END_DOCUMENT) { + + boolean newTransition = false; + + if (type != XmlPullParser.START_TAG) { + continue; + } + + String name = parser.getName(); + if ("fade".equals(name)) { + transition = new Fade(); + newTransition = true; + } else if ("move".equals(name)) { + transition = new Move(); + newTransition = true; + } else if ("slide".equals(name)) { + transition = new Slide(); + newTransition = true; + } else if ("autoTransition".equals(name)) { + transition = new AutoTransition(); + newTransition = true; + } else if ("recolor".equals(name)) { + transition = new Recolor(); + newTransition = true; + } else if ("transitionGroup".equals(name)) { + transition = new TransitionGroup(); + createTransitionFromXml(parser, attrs, ((TransitionGroup) transition)); + newTransition = true; + } else if ("targets".equals(name)) { + if (parser.getDepth() - 1 > depth && transition != null) { + // We're inside the child tag - add targets to the child + getTargetIDs(parser, attrs, transition); + } else if (parser.getDepth() - 1 == depth && transitionGroup != null) { + // add targets to the group + getTargetIDs(parser, attrs, transitionGroup); + } + } + if (transition != null || "targets".equals(name)) { + if (newTransition) { + loadTransition(transition, attrs); + if (transitionGroup != null) { + transitionGroup.addTransitions(transition); + } + } + } else { + throw new RuntimeException("Unknown scene name: " + parser.getName()); + } + } + + return transition; + } + + private void getTargetIDs(XmlPullParser parser, + AttributeSet attrs, Transition transition) throws XmlPullParserException, IOException { + + // Make sure we are on a start tag. + int type; + int depth = parser.getDepth(); + + ArrayList<Integer> targetIds = new ArrayList<Integer>(); + while (((type=parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth) + && type != XmlPullParser.END_DOCUMENT) { + + if (type != XmlPullParser.START_TAG) { + continue; + } + + String name = parser.getName(); + if (name.equals("target")) { + TypedArray a = mContext.obtainStyledAttributes(attrs, + com.android.internal.R.styleable.Transition); + int id = a.getResourceId(com.android.internal.R.styleable.Transition_targetID, -1); + if (id >= 0) { + targetIds.add(id); + } + } else { + throw new RuntimeException("Unknown scene name: " + parser.getName()); + } + } + int numTargets = targetIds.size(); + if (numTargets > 0) { + int[] targetsArray = new int[numTargets]; + for (int i = 0; i < targetIds.size(); ++i) { + targetsArray[i] = targetIds.get(i); + } + transition.setTargetIds(targetsArray); + } + } + + private Transition loadTransition(Transition transition, AttributeSet attrs) + throws Resources.NotFoundException { + + TypedArray a = + mContext.obtainStyledAttributes(attrs, com.android.internal.R.styleable.Transition); + long duration = a.getInt(com.android.internal.R.styleable.Transition_duration, -1); + if (duration >= 0) { + transition.setDuration(duration); + } + long startOffset = a.getInt(com.android.internal.R.styleable.Transition_startOffset, -1); + if (startOffset > 0) { + transition.setStartDelay(startOffset); + } + final int resID = + a.getResourceId(com.android.internal.R.styleable.Animator_interpolator, 0); + if (resID > 0) { + transition.setInterpolator(AnimationUtils.loadInterpolator(mContext, resID)); + } + a.recycle(); + return transition; + } + + // + // TransitionManager loading + // + + private TransitionManager createTransitionManagerFromXml(XmlPullParser parser, + AttributeSet attrs, ViewGroup sceneRoot) throws XmlPullParserException, IOException { + + // Make sure we are on a start tag. + int type; + int depth = parser.getDepth(); + TransitionManager transitionManager = null; + + while (((type=parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth) + && type != XmlPullParser.END_DOCUMENT) { + + if (type != XmlPullParser.START_TAG) { + continue; + } + + String name = parser.getName(); + if (name.equals("transitionManager")) { + transitionManager = new TransitionManager(); + } else if (name.equals("transition") && (transitionManager != null)) { + loadTransition(attrs, sceneRoot, transitionManager); + } else { + throw new RuntimeException("Unknown scene name: " + parser.getName()); + } + } + return transitionManager; + } + + private void loadTransition(AttributeSet attrs, ViewGroup sceneRoot, + TransitionManager transitionManager) + throws Resources.NotFoundException { + + TypedArray a = mContext.obtainStyledAttributes(attrs, + com.android.internal.R.styleable.TransitionManager); + int transitionId = attrs.getAttributeResourceValue( + com.android.internal.R.styleable.TransitionManager_transition, -1); + Scene fromScene = null, toScene = null; + int fromId = attrs.getAttributeResourceValue( + com.android.internal.R.styleable.TransitionManager_fromScene, -1); + if (fromId >= 0) fromScene = inflateScene(fromId, sceneRoot); + int toId = attrs.getAttributeResourceValue( + com.android.internal.R.styleable.TransitionManager_toScene, -1); + if (toId >= 0) toScene = inflateScene(toId, sceneRoot); + if (transitionId >= 0) { + Transition transition = inflateTransition(transitionId); + if (transition != null) { + if (fromScene != null) { + if (toScene == null){ + throw new RuntimeException("No matching toScene for given fromScene " + + "for transition ID " + transitionId); + } else { + transitionManager.setTransition(fromScene, toScene, transition); + } + } else if (toId >= 0) { + transitionManager.setTransition(toScene, transition); + } + } + } + a.recycle(); + } + + // + // Scene loading + // + + private Scene createSceneFromXml(XmlPullParser parser, AttributeSet attrs, ViewGroup parent) + throws XmlPullParserException, IOException { + Scene scene = null; + + // Make sure we are on a start tag. + int type; + int depth = parser.getDepth(); + + while (((type=parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth) + && type != XmlPullParser.END_DOCUMENT) { + + if (type != XmlPullParser.START_TAG) { + continue; + } + + String name = parser.getName(); + if (name.equals("scene")) { + scene = loadScene(attrs, parent); + } else { + throw new RuntimeException("Unknown scene name: " + parser.getName()); + } + } + + return scene; + } + + private Scene loadScene(AttributeSet attrs, ViewGroup parent) + throws Resources.NotFoundException { + + Scene scene; + TypedArray a = mContext.obtainStyledAttributes(attrs, + com.android.internal.R.styleable.Scene); + int layoutId = a.getResourceId(com.android.internal.R.styleable.Scene_layout, -1); + if (layoutId >= 0) { + scene = new Scene(parent, layoutId, mContext); + } else { + scene = new Scene(parent); + } + a.recycle(); + return scene; + } +} diff --git a/core/java/android/view/transition/TransitionManager.java b/core/java/android/view/transition/TransitionManager.java new file mode 100644 index 0000000..5a1991c --- /dev/null +++ b/core/java/android/view/transition/TransitionManager.java @@ -0,0 +1,261 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.view.ViewGroup; +import android.view.ViewTreeObserver; + +import java.util.HashMap; + +/** + * This class manages the set of transitions that fire when there is a + * change of {@link Scene}. To use the manager, add scenes along with + * transition objects with calls to {@link #setTransition(Scene, Transition)} + * or {@link #setTransition(Scene, Scene, Transition)}. Setting specific + * transitions for scene changes is not required; by default, a Scene change + * will use {@link AutoTransition} to do something reasonable for most + * situations. Specifying other transitions for particular scene changes is + * only necessary if the application wants different transition behavior + * in these situations. + */ +public class TransitionManager { + // TODO: how to handle enter/exit? + + private static final Transition sDefaultTransition = new AutoTransition(); + private Transition mDefaultTransition = new AutoTransition(); + + HashMap<Scene, Transition> mSceneTransitions = new HashMap<Scene, Transition>(); + HashMap<Scene, HashMap<Scene, Transition>> mScenePairTransitions = + new HashMap<Scene, HashMap<Scene, Transition>>(); + + /** + * Sets the transition to be used for any scene change for which no + * other transition is explicitly set. The initial value is + * an {@link AutoTransition} instance. + * + * @param transition The default transition to be used for scene changes. + */ + public void setDefaultTransition(Transition transition) { + mDefaultTransition = transition; + } + + /** + * Gets the current default transition. The initial value is an {@link + * AutoTransition} instance. + * + * @return The current default transition. + * @see #setDefaultTransition(Transition) + */ + public Transition getDefaultTransition() { + return mDefaultTransition; + } + + /** + * Sets a specific transition to occur when the given scene is entered. + * + * @param scene The scene which, when applied, will cause the given + * transition to run. + * @param transition The transition that will play when the given scene is + * entered. A value of null will result in the default behavior of + * using {@link AutoTransition}. + */ + public void setTransition(Scene scene, Transition transition) { + mSceneTransitions.put(scene, transition); + } + + /** + * Sets a specific transition to occur when the given pair of scenes is + * exited/entered. + * + * @param fromScene The scene being exited when the given transition will + * be run + * @param toScene The scene being entered when the given transition will + * be run + * @param transition The transition that will play when the given scene is + * entered. A value of null will result in the default behavior of + * using {@link AutoTransition}. + */ + public void setTransition(Scene fromScene, Scene toScene, Transition transition) { + HashMap<Scene, Transition> sceneTransitionMap = mScenePairTransitions.get(toScene); + if (sceneTransitionMap == null) { + sceneTransitionMap = new HashMap<Scene, Transition>(); + mScenePairTransitions.put(toScene, sceneTransitionMap); + } + sceneTransitionMap.put(fromScene, transition); + } + + /** + * Returns the Transition for the given scene being entered. The result + * depends not only on the given scene, but also the scene which the + * {@link Scene#getSceneRoot() sceneRoot} of the Scene is currently in. + * + * @param scene The scene being entered + * @return The Transition to be used for the given scene change. If no + * Transition was specified for this scene change, {@link AutoTransition} + * will be used instead. + */ + private Transition getTransition(Scene scene) { + Transition transition = null; + ViewGroup sceneRoot = scene.getSceneRoot(); + if (sceneRoot != null) { + // TODO: cached in Scene instead? long-term, cache in View itself + Scene currScene = sceneRoot.getCurrentScene(); + if (currScene != null) { + HashMap<Scene, Transition> sceneTransitionMap = mScenePairTransitions.get(scene); + if (sceneTransitionMap != null) { + transition = sceneTransitionMap.get(currScene); + if (transition != null) { + return transition; + } + } + } + } + transition = mSceneTransitions.get(scene); + return (transition != null) ? transition : new AutoTransition(); + } + + /** + * This is where all of the work of a transition/scene-change is + * orchestrated. This method captures the start values for the given + * transition, exits the current Scene, enters the new scene, captures + * the end values for the transition, and finally plays the + * resulting values-populated transition. + * + * @param scene The scene being entered + * @param transition The transition to play for this scene change + */ + private static void changeScene(Scene scene, final Transition transition) { + + final ViewGroup sceneRoot = scene.getSceneRoot(); + + // Capture current values + if (transition != null) { + transition.captureValues(sceneRoot, true); + } + + // Notify previous scene that it is being exited + Scene previousScene = sceneRoot.getCurrentScene(); + if (previousScene != null) { + previousScene.exit(); + } + + scene.enter(); + + if (transition != null) { + final ViewTreeObserver observer = sceneRoot.getViewTreeObserver(); + observer.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() { + public boolean onPreDraw() { + sceneRoot.getViewTreeObserver().removeOnPreDrawListener(this); + transition.captureValues(sceneRoot, false); + transition.play(sceneRoot); + return true; + } + }); + } + } + + /** + * Change to the given scene, using the + * appropriate transition for this particular scene change + * (as specified to the TransitionManager, or the default + * if no such transition exists). + * + * @param scene The Scene to change to + */ + public void transitionTo(Scene scene) { + // Auto transition if there is no transition declared for the Scene, but there is + // a root or parent view + changeScene(scene, getTransition(scene)); + + } + + /** + * Static utility method to simply change to the given scene using + * the default transition for TransitionManager. + * + * @param scene The Scene to change to + */ + public static void go(Scene scene) { + changeScene(scene, sDefaultTransition); + } + + /** + * Static utility method to simply change to the given scene using + * the given transition. + * + * <p>Passing in <code>null</code> for the transition parameter will + * result in the scene changing without any transition running, and is + * equivalent to calling {@link Scene#exit()} on the scene root's + * {@link ViewGroup#getCurrentScene() current scene}, followed by + * {@link Scene#enter()} on the scene specified by the <code>scene</code> + * parameter.</p> + * + * @param scene The Scene to change to + * @param transition The transition to use for this scene change. A + * value of null causes the scene change to happen with no transition. + */ + public static void go(Scene scene, Transition transition) { + changeScene(scene, transition); + } + + /** + * Static utility method to simply change to a scene defined by the + * code in the given runnable, which will be executed after + * the current values have been captured for the transition. + * This is equivalent to creating a Scene and calling {@link + * Scene#setEnterAction(Runnable)} with the runnable, then calling + * {@link #go(Scene, Transition)}. The transition used will be the + * default provided by TransitionManager. + * + * @param sceneRoot The root of the View hierarchy used when this scene + * runs a transition automatically. + * @param action The runnable whose {@link Runnable#run() run()} method will + * be called. + */ + public static void go(ViewGroup sceneRoot, Runnable action) { + Scene scene = new Scene(sceneRoot); + scene.setEnterAction(action); + changeScene(scene, sDefaultTransition); + } + + /** + * Static utility method to simply change to a scene defined by the + * code in the given runnable, which will be executed after + * the current values have been captured for the transition. + * This is equivalent to creating a Scene and calling {@link + * Scene#setEnterAction(Runnable)} with the runnable, then calling + * {@link #go(Scene, Transition)}. The given transition will be + * used to animate the changes. + * + * <p>Passing in <code>null</code> for the transition parameter will + * result in the scene changing without any transition running, and is + * equivalent to calling {@link Scene#exit()} on the scene root's + * {@link ViewGroup#getCurrentScene() current scene}, followed by + * {@link Scene#enter()} on a new scene specified by the + * <code>action</code> parameter.</p> + * + * @param sceneRoot The root of the View hierarchy to run the transition on. + * @param action The runnable whose {@link Runnable#run() run()} method will + * be called. + * @param transition The transition to use for this change. A + * value of null causes the change to happen with no transition. + */ + public static void go(ViewGroup sceneRoot, Runnable action, Transition transition) { + Scene scene = new Scene(sceneRoot); + scene.setEnterAction(action); + changeScene(scene, transition); + } +} diff --git a/core/java/android/view/transition/TransitionValues.java b/core/java/android/view/transition/TransitionValues.java new file mode 100644 index 0000000..120ace8 --- /dev/null +++ b/core/java/android/view/transition/TransitionValues.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.view.View; +import android.view.ViewGroup; + +import java.util.HashMap; + +/** + * Data structure which holds cached values for the transition. + * The view field is the target which all of the values pertain to. + * The values field is a hashmap which holds information for fields + * according to names selected by the transitions. These names should + * be unique to avoid clobbering values stored by other transitions, + * such as the convention project:transition_name:property_name. For + * example, the platform might store a property "alpha" in a transition + * "Fader" as "android:fader:alpha". + * + * <p>These values are cached during the + * {@link Transition#captureValues(TransitionValues, boolean)} + * capture} phases of a scene change, once when the start values are captured + * and again when the end values are captured. These start/end values are then + * passed into the transitions during the play phase of the scene change, + * for {@link Transition#prePlay(ViewGroup, TransitionValues, TransitionValues)} and + * for {@link Transition#play(ViewGroup, TransitionValues, TransitionValues)}.</p> + */ +public class TransitionValues { + + /** + * The View with these values + */ + public View view; + + /** + * The set of values tracked by transitions for this scene + */ + public final HashMap<String, Object> values = new HashMap<String, Object>(); + + @Override + public String toString() { + String returnValue = "TransitionValues@" + Integer.toHexString(hashCode()) + ":\n"; + returnValue += " view = " + view + "\n"; + returnValue += " values = " + values + "\n"; + return returnValue; + } +}
\ No newline at end of file diff --git a/core/java/android/view/transition/Visibility.java b/core/java/android/view/transition/Visibility.java new file mode 100644 index 0000000..a3e6e77 --- /dev/null +++ b/core/java/android/view/transition/Visibility.java @@ -0,0 +1,243 @@ +/* + * Copyright (C) 2013 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.view.transition; + +import android.animation.Animator; +import android.view.View; +import android.view.ViewGroup; + +/** + * This transition tracks changes to the visibility of target views in the + * start and end scenes. Visibility is determined not just by the + * {@link View#setVisibility(int)} state of views, but also whether + * views exist in the current view hierarchy. The class is intended to be a + * utility for subclasses such as {@link Fade}, which use this visibility + * information to determine the specific animations to run when visibility + * changes occur. Subclasses should implement one or more of the methods + * {@link #preAppear(ViewGroup, View, int, View, int)}, + * {@link #preDisappear(ViewGroup, View, int, View, int)}, + * {@link #appear(ViewGroup, View, int, View, int)}, and + * {@link #disappear(ViewGroup, View, int, View, int)}. + */ +public abstract class Visibility extends Transition { + + private static final String PROPNAME_VISIBILITY = "android:visibility:visibility"; + private static final String PROPNAME_PARENT = "android:visibility:parent"; + + @Override + protected void captureValues(TransitionValues values, boolean start) { + int visibility = values.view.getVisibility(); + values.values.put(PROPNAME_VISIBILITY, visibility); + values.values.put(PROPNAME_PARENT, values.view.getParent()); + } + + @Override + protected boolean prePlay(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + boolean visibilityChange = false; + boolean fadeIn = false; + int startVisibility, endVisibility; + View startParent, endParent; + if (startValues != null) { + startVisibility = (Integer) startValues.values.get(PROPNAME_VISIBILITY); + startParent = (View) startValues.values.get(PROPNAME_PARENT); + } else { + startVisibility = -1; + startParent = null; + } + if (endValues != null) { + endVisibility = (Integer) endValues.values.get(PROPNAME_VISIBILITY); + endParent = (View) endValues.values.get(PROPNAME_PARENT); + } else { + endVisibility = -1; + endParent = null; + } + boolean existenceChange = false; + if (startValues != null && endValues != null) { + if (startVisibility == endVisibility && startParent == endParent) { + return false; + } else { + if (startVisibility != endVisibility) { + if (startVisibility == View.VISIBLE) { + fadeIn = false; + visibilityChange = true; + } else if (endVisibility == View.VISIBLE) { + fadeIn = true; + visibilityChange = true; + } + // no visibilityChange if going between INVISIBLE and GONE + } else if (startParent != endParent) { + existenceChange = true; + if (endParent == null) { + fadeIn = false; + visibilityChange = true; + } else if (startParent == null) { + fadeIn = true; + visibilityChange = true; + } + } + } + } + if (startValues == null) { + existenceChange = true; + fadeIn = true; + visibilityChange = true; + } else if (endValues == null) { + existenceChange = true; + fadeIn = false; + visibilityChange = true; + } + if (visibilityChange) { + if (fadeIn) { + return preAppear(sceneRoot, existenceChange ? null : startValues.view, + startVisibility, endValues.view, endVisibility); + } else { + return preDisappear(sceneRoot, startValues.view, startVisibility, + existenceChange ? null : endValues.view, endVisibility); + } + } else { + return false; + } + } + + @Override + protected Animator play(ViewGroup sceneRoot, TransitionValues startValues, + TransitionValues endValues) { + boolean visibilityChange = false; + boolean fadeIn = false; + int startVisibility, endVisibility; + View startParent, endParent; + if (startValues != null) { + startVisibility = (Integer) startValues.values.get(PROPNAME_VISIBILITY); + startParent = (View) startValues.values.get(PROPNAME_PARENT); + } else { + startVisibility = -1; + startParent = null; + } + if (endValues != null) { + endVisibility = (Integer) endValues.values.get(PROPNAME_VISIBILITY); + endParent = (View) endValues.values.get(PROPNAME_PARENT); + } else { + endVisibility = -1; + endParent = null; + } + boolean existenceChange = false; + if (startValues != null && endValues != null) { + if (startVisibility == endVisibility && startParent == endParent) { + return null; + } else { + if (startVisibility != endVisibility) { + if (startVisibility == View.VISIBLE) { + fadeIn = false; + visibilityChange = true; + } else if (endVisibility == View.VISIBLE) { + fadeIn = true; + visibilityChange = true; + } + // no visibilityChange if going between INVISIBLE and GONE + } else if (startParent != endParent) { + existenceChange = true; + if (endParent == null) { + fadeIn = false; + visibilityChange = true; + } else if (startParent == null) { + fadeIn = true; + visibilityChange = true; + } + } + } + } + if (startValues == null) { + existenceChange = true; + fadeIn = true; + visibilityChange = true; + } else if (endValues == null) { + existenceChange = true; + fadeIn = false; + visibilityChange = true; + } + if (visibilityChange) { + if (fadeIn) { + return appear(sceneRoot, existenceChange ? null : startValues.view, startVisibility, + endValues.view, endVisibility); + } else { + return disappear(sceneRoot, startValues.view, startVisibility, + existenceChange ? null : endValues.view, endVisibility); + } + } + return null; + } + + /** + * The default implementation of this method does nothing. Subclasses + * should override if they need to set up anything prior to the + * transition starting. + * + * @param sceneRoot + * @param startView + * @param startVisibility + * @param endView + * @param endVisibility + * @return + */ + protected boolean preAppear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + return true; + } + + /** + * The default implementation of this method does nothing. Subclasses + * should override if they need to set up anything prior to the + * transition starting. + * @param sceneRoot + * @param startView + * @param startVisibility + * @param endView + * @param endVisibility + * @return + */ + protected boolean preDisappear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { + return true; + } + + /** + * The default implementation of this method does nothing. Subclasses + * should override if they need to do anything when target objects + * appear during the scene change. + * @param sceneRoot + * @param startView + * @param startVisibility + * @param endView + * @param endVisibility + */ + protected Animator appear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { return null; } + + /** + * The default implementation of this method does nothing. Subclasses + * should override if they need to do anything when target objects + * disappear during the scene change. + * @param sceneRoot + * @param startView + * @param startVisibility + * @param endView + * @param endVisibility + */ + protected Animator disappear(ViewGroup sceneRoot, View startView, int startVisibility, + View endView, int endVisibility) { return null; } + +} diff --git a/core/java/android/view/transition/package.html b/core/java/android/view/transition/package.html new file mode 100644 index 0000000..37dc0ec --- /dev/null +++ b/core/java/android/view/transition/package.html @@ -0,0 +1,25 @@ +<html> +<body> +<p>The classes in this package enable "scenes & transitions" functionality for +view hiearchies.</p> + +<p>A <b>Scene</b> is an encapsulation of the state of a view hiearchy, +including the views in that hierarchy and the various values (layout-related +and otherwise) that those views have. A scene be defined by a layout hierarchy +directly or some code which sets up the scene dynamically as it is entered.</p> + +<p>A <b>Transition</b> is a mechanism to automatically animate changes that occur +when a new scene is entered. Some transition capabilities are automatic. That +is, entering a scene may cause animations to run which fade out views that +go away, move and resize existing views that change, and fade in views that +become visible. There are additional transitions that can animate other +attributes, such as color changes, and which can optionally be specified +to take place during particular scene changes. Finally, developers can +define their own Transition subclasses which monitor particular property +changes and which run custom animations when those properties change values.</p> + +<p><b>TransitionManager</b> is used to specify custom transitions for particular +scene changes, and to cause scene changes with transitions to take place.</p> + +</body> +</html> diff --git a/core/java/android/widget/AbsListView.java b/core/java/android/widget/AbsListView.java index c72853f..2012988 100644 --- a/core/java/android/widget/AbsListView.java +++ b/core/java/android/widget/AbsListView.java @@ -2398,7 +2398,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te * @return True if the selector should be shown */ boolean shouldShowSelector() { - return (hasFocus() && !isInTouchMode()) || touchModeDrawsInPressedState(); + return (!isInTouchMode()) || touchModeDrawsInPressedState(); } private void drawSelector(Canvas canvas) { @@ -2736,7 +2736,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te } public boolean sameWindow() { - return hasWindowFocus() && getWindowAttachCount() == mOriginalAttachCount; + return getWindowAttachCount() == mOriginalAttachCount; } } diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java index f57f333..4312dee 100644 --- a/core/java/android/widget/Editor.java +++ b/core/java/android/widget/Editor.java @@ -181,7 +181,10 @@ public class Editor { // Set when this TextView gained focus with some text selected. Will start selection mode. boolean mCreatedWithASelection; - private EasyEditSpanController mEasyEditSpanController; + // The span controller helps monitoring the changes to which the Editor needs to react: + // - EasyEditSpans, for which we have some UI to display on attach and on hide + // - SelectionSpans, for which we need to call updateSelection if an IME is attached + private SpanController mSpanController; WordIterator mWordIterator; SpellChecker mSpellChecker; @@ -466,8 +469,8 @@ public class Editor { } private void hideSpanControllers() { - if (mEasyEditSpanController != null) { - mEasyEditSpanController.hide(); + if (mSpanController != null) { + mSpanController.hide(); } } @@ -1082,9 +1085,12 @@ public class Editor { mTextView.updateAfterEdit(); reportExtractedText(); } else if (ims.mCursorChanged) { - // Cheezy way to get us to report the current cursor location. + // Cheesy way to get us to report the current cursor location. mTextView.invalidateCursor(); } + // sendUpdateSelection knows to avoid sending if the selection did + // not actually change. + sendUpdateSelection(); } static final int EXTRACT_NOTHING = -2; @@ -1205,6 +1211,27 @@ public class Editor { return false; } + private void sendUpdateSelection() { + if (null != mInputMethodState && mInputMethodState.mBatchEditNesting <= 0) { + final InputMethodManager imm = InputMethodManager.peekInstance(); + if (null != imm) { + final int selectionStart = mTextView.getSelectionStart(); + final int selectionEnd = mTextView.getSelectionEnd(); + int candStart = -1; + int candEnd = -1; + if (mTextView.getText() instanceof Spannable) { + final Spannable sp = (Spannable) mTextView.getText(); + candStart = EditableInputConnection.getComposingSpanStart(sp); + candEnd = EditableInputConnection.getComposingSpanEnd(sp); + } + // InputMethodManager#updateSelection skips sending the message if + // none of the parameters have changed since the last time we called it. + imm.updateSelection(mTextView, + selectionStart, selectionEnd, candStart, candEnd); + } + } + } + void onDraw(Canvas canvas, Layout layout, Path highlight, Paint highlightPaint, int cursorOffsetVertical) { final int selectionStart = mTextView.getSelectionStart(); @@ -1222,17 +1249,6 @@ public class Editor { // input method. reported = reportExtractedText(); } - if (!reported && highlight != null) { - int candStart = -1; - int candEnd = -1; - if (mTextView.getText() instanceof Spannable) { - Spannable sp = (Spannable) mTextView.getText(); - candStart = EditableInputConnection.getComposingSpanStart(sp); - candEnd = EditableInputConnection.getComposingSpanEnd(sp); - } - imm.updateSelection(mTextView, - selectionStart, selectionEnd, candStart, candEnd); - } } if (imm.isWatchingCursor(mTextView) && highlight != null) { @@ -1859,17 +1875,18 @@ public class Editor { text.setSpan(mKeyListener, 0, textLength, Spanned.SPAN_INCLUSIVE_INCLUSIVE); } - if (mEasyEditSpanController == null) { - mEasyEditSpanController = new EasyEditSpanController(); + if (mSpanController == null) { + mSpanController = new SpanController(); } - text.setSpan(mEasyEditSpanController, 0, textLength, Spanned.SPAN_INCLUSIVE_INCLUSIVE); + text.setSpan(mSpanController, 0, textLength, Spanned.SPAN_INCLUSIVE_INCLUSIVE); } /** * Controls the {@link EasyEditSpan} monitoring when it is added, and when the related * pop-up should be displayed. + * Also monitors {@link SelectionSpan} to call back to the attached input method. */ - class EasyEditSpanController implements SpanWatcher { + class SpanController implements SpanWatcher { private static final int DISPLAY_TIMEOUT_MS = 3000; // 3 secs @@ -1877,9 +1894,18 @@ public class Editor { private Runnable mHidePopup; + // This function is pure but inner classes can't have static functions + private boolean isNonIntermediateSelectionSpan(final Spannable text, + final Object span) { + return (Selection.SELECTION_START == span || Selection.SELECTION_END == span) + && (text.getSpanFlags(span) & Spanned.SPAN_INTERMEDIATE) == 0; + } + @Override public void onSpanAdded(Spannable text, Object span, int start, int end) { - if (span instanceof EasyEditSpan) { + if (isNonIntermediateSelectionSpan(text, span)) { + sendUpdateSelection(); + } else if (span instanceof EasyEditSpan) { if (mPopupWindow == null) { mPopupWindow = new EasyEditPopupWindow(); mHidePopup = new Runnable() { @@ -1903,7 +1929,7 @@ public class Editor { int start = editable.getSpanStart(span); int end = editable.getSpanEnd(span); if (start >= 0 && end >= 0) { - sendNotification(EasyEditSpan.TEXT_DELETED, span); + sendEasySpanNotification(EasyEditSpan.TEXT_DELETED, span); mTextView.deleteText_internal(start, end); } editable.removeSpan(span); @@ -1934,7 +1960,9 @@ public class Editor { @Override public void onSpanRemoved(Spannable text, Object span, int start, int end) { - if (mPopupWindow != null && span == mPopupWindow.mEasyEditSpan) { + if (isNonIntermediateSelectionSpan(text, span)) { + sendUpdateSelection(); + } else if (mPopupWindow != null && span == mPopupWindow.mEasyEditSpan) { hide(); } } @@ -1942,9 +1970,11 @@ public class Editor { @Override public void onSpanChanged(Spannable text, Object span, int previousStart, int previousEnd, int newStart, int newEnd) { - if (mPopupWindow != null && span instanceof EasyEditSpan) { + if (isNonIntermediateSelectionSpan(text, span)) { + sendUpdateSelection(); + } else if (mPopupWindow != null && span instanceof EasyEditSpan) { EasyEditSpan easyEditSpan = (EasyEditSpan) span; - sendNotification(EasyEditSpan.TEXT_MODIFIED, easyEditSpan); + sendEasySpanNotification(EasyEditSpan.TEXT_MODIFIED, easyEditSpan); text.removeSpan(easyEditSpan); } } @@ -1956,7 +1986,7 @@ public class Editor { } } - private void sendNotification(int textChangedType, EasyEditSpan span) { + private void sendEasySpanNotification(int textChangedType, EasyEditSpan span) { try { PendingIntent pendingIntent = span.getPendingIntent(); if (pendingIntent != null) { diff --git a/core/java/android/widget/GridLayout.java b/core/java/android/widget/GridLayout.java index 2309001..b0ab70d 100644 --- a/core/java/android/widget/GridLayout.java +++ b/core/java/android/widget/GridLayout.java @@ -24,7 +24,9 @@ import android.graphics.Insets; import android.graphics.Paint; import android.util.AttributeSet; import android.util.Log; +import android.util.LogPrinter; import android.util.Pair; +import android.util.Printer; import android.view.Gravity; import android.view.View; import android.view.ViewGroup; @@ -124,6 +126,17 @@ import static java.lang.Math.min; * GridLayout's algorithms favour rows and columns that are closer to its <em>right</em> * and <em>bottom</em> edges. * + * <h4>Interpretation of GONE</h4> + * + * For layout purposes, GridLayout treats views whose visibility status is + * {@link View#GONE GONE}, as having zero width and height. This is subtly different from + * the policy of ignoring views that are marked as GONE outright. If, for example, a gone-marked + * view was alone in a column, that column would itself collapse to zero width if and only if + * no gravity was defined on the view. If gravity was defined, then the gone-marked + * view has no effect on the layout and the container should be laid out as if the view + * had never been added to it. + * These statements apply equally to rows as well as columns, and to groups of rows or columns. + * * <h5>Limitations</h5> * * GridLayout does not provide support for the principle of <em>weight</em>, as defined in @@ -208,10 +221,15 @@ public class GridLayout extends ViewGroup { // Misc constants - static final String TAG = GridLayout.class.getName(); static final int MAX_SIZE = 100000; static final int DEFAULT_CONTAINER_MARGIN = 0; static final int UNINITIALIZED_HASH = 0; + static final Printer LOG_PRINTER = new LogPrinter(Log.DEBUG, GridLayout.class.getName()); + static final Printer NO_PRINTER = new Printer() { + @Override + public void println(String x) { + } + }; // Defaults @@ -240,6 +258,7 @@ public class GridLayout extends ViewGroup { int alignmentMode = DEFAULT_ALIGNMENT_MODE; int defaultGap; int lastLayoutParamsHashCode = UNINITIALIZED_HASH; + Printer printer = LOG_PRINTER; // Constructors @@ -556,6 +575,29 @@ public class GridLayout extends ViewGroup { requestLayout(); } + /** + * Return the printer that will log diagnostics from this layout. + * + * @see #setPrinter(android.util.Printer) + * + * @return the printer associated with this view + */ + public Printer getPrinter() { + return printer; + } + + /** + * Set the printer that will log diagnostics from this layout. + * The default value is created by {@link android.util.LogPrinter}. + * + * @param printer the printer associated with this layout + * + * @see #getPrinter() + */ + public void setPrinter(Printer printer) { + this.printer = (printer == null) ? NO_PRINTER : printer; + } + // Static utility methods static int max2(int[] a, int valueIfEmpty) { @@ -915,7 +957,7 @@ public class GridLayout extends ViewGroup { protected void onChildVisibilityChanged(View child, int oldVisibility, int newVisibility) { super.onChildVisibilityChanged(child, oldVisibility, newVisibility); if (oldVisibility == GONE || newVisibility == GONE) { - invalidateStructure(); + invalidateStructure(); } } @@ -935,8 +977,8 @@ public class GridLayout extends ViewGroup { validateLayoutParams(); lastLayoutParamsHashCode = computeLayoutParamsHashCode(); } else if (lastLayoutParamsHashCode != computeLayoutParamsHashCode()) { - Log.w(TAG, "The fields of some layout parameters were modified in between layout " + - "operations. Check the javadoc for GridLayout.LayoutParams#rowSpec."); + printer.println("The fields of some layout parameters were modified in between " + + "layout operations. Check the javadoc for GridLayout.LayoutParams#rowSpec."); invalidateStructure(); consistencyCheck(); } @@ -1246,6 +1288,7 @@ public class GridLayout extends ViewGroup { Assoc<Spec, Bounds> assoc = Assoc.of(Spec.class, Bounds.class); for (int i = 0, N = getChildCount(); i < N; i++) { View c = getChildAt(i); + // we must include views that are GONE here, see introductory javadoc LayoutParams lp = getLayoutParams(c); Spec spec = horizontal ? lp.columnSpec : lp.rowSpec; Bounds bounds = getAlignment(spec.alignment, horizontal).getBounds(); @@ -1261,6 +1304,7 @@ public class GridLayout extends ViewGroup { } for (int i = 0, N = getChildCount(); i < N; i++) { View c = getChildAt(i); + // we must include views that are GONE here, see introductory javadoc LayoutParams lp = getLayoutParams(c); Spec spec = horizontal ? lp.columnSpec : lp.rowSpec; groupBounds.getValue(i).include(GridLayout.this, c, spec, this); @@ -1527,8 +1571,8 @@ public class GridLayout extends ViewGroup { removed.add(arc); } } - Log.d(TAG, axisName + " constraints: " + arcsToString(culprits) + " are inconsistent; " - + "permanently removing: " + arcsToString(removed) + ". "); + printer.println(axisName + " constraints: " + arcsToString(culprits) + + " are inconsistent; permanently removing: " + arcsToString(removed) + ". "); } /* @@ -2666,6 +2710,9 @@ public class GridLayout extends ViewGroup { @Override public int getAlignmentValue(View view, int viewSize, int mode) { + if (view.getVisibility() == GONE) { + return 0; + } int baseline = view.getBaseline(); return baseline == -1 ? UNDEFINED : baseline; } diff --git a/core/java/android/widget/RemoteViewsAdapter.java b/core/java/android/widget/RemoteViewsAdapter.java index aeee111..3ff0cee 100644 --- a/core/java/android/widget/RemoteViewsAdapter.java +++ b/core/java/android/widget/RemoteViewsAdapter.java @@ -22,9 +22,11 @@ import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; +import android.Manifest; import android.appwidget.AppWidgetManager; import android.content.Context; import android.content.Intent; +import android.content.pm.PackageManager; import android.os.Handler; import android.os.HandlerThread; import android.os.IBinder; @@ -34,6 +36,7 @@ import android.os.Process; import android.os.RemoteException; import android.os.UserHandle; import android.util.Log; +import android.util.Slog; import android.view.LayoutInflater; import android.view.View; import android.view.View.MeasureSpec; @@ -50,9 +53,11 @@ import com.android.internal.widget.LockPatternUtils; */ /** @hide */ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback { + private static final String MULTI_USER_PERM = Manifest.permission.INTERACT_ACROSS_USERS_FULL; + private static final String TAG = "RemoteViewsAdapter"; - // The max number of items in the cache + // The max number of items in the cache private static final int sDefaultCacheSize = 40; // The delay (in millis) to wait until attempting to unbind from a service after a request. // This ensures that we don't stay continually bound to the service and that it can be destroyed @@ -63,7 +68,7 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback private static final int sDefaultLoadingViewHeight = 50; // Type defs for controlling different messages across the main and worker message queues - private static final int sDefaultMessageType = 0; + private static final int sDefaultMessageType = 0; private static final int sUnbindServiceMessageType = 1; private final Context mContext; @@ -90,7 +95,7 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback private Handler mMainQueue; // We cache the FixedSizeRemoteViewsCaches across orientation. These are the related data - // structures; + // structures; private static final HashMap<RemoteViewsCacheKey, FixedSizeRemoteViewsCache> sCachedRemoteViewsCaches = new HashMap<RemoteViewsCacheKey, @@ -155,13 +160,12 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback try { RemoteViewsAdapter adapter; final AppWidgetManager mgr = AppWidgetManager.getInstance(context); - if (Process.myUid() == Process.SYSTEM_UID - && (adapter = mAdapter.get()) != null) { + if ((adapter = mAdapter.get()) != null) { + checkInteractAcrossUsersPermission(context, adapter.mUserId); mgr.bindRemoteViewsService(appWidgetId, intent, asBinder(), new UserHandle(adapter.mUserId)); } else { - mgr.bindRemoteViewsService(appWidgetId, intent, asBinder(), - Process.myUserHandle()); + Slog.w(TAG, "bind: adapter was null"); } mIsConnecting = true; } catch (Exception e) { @@ -176,12 +180,12 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback try { RemoteViewsAdapter adapter; final AppWidgetManager mgr = AppWidgetManager.getInstance(context); - if (Process.myUid() == Process.SYSTEM_UID - && (adapter = mAdapter.get()) != null) { + if ((adapter = mAdapter.get()) != null) { + checkInteractAcrossUsersPermission(context, adapter.mUserId); mgr.unbindRemoteViewsService(appWidgetId, intent, new UserHandle(adapter.mUserId)); } else { - mgr.unbindRemoteViewsService(appWidgetId, intent, Process.myUserHandle()); + Slog.w(TAG, "unbind: adapter was null"); } mIsConnecting = false; } catch (Exception e) { @@ -263,7 +267,7 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback // Clear the main/worker queues final RemoteViewsAdapter adapter = mAdapter.get(); if (adapter == null) return; - + adapter.mMainQueue.post(new Runnable() { @Override public void run() { @@ -828,11 +832,9 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback } mRequestedViews = new RemoteViewsFrameLayoutRefSet(); - if (Process.myUid() == Process.SYSTEM_UID) { - mUserId = new LockPatternUtils(context).getCurrentUser(); - } else { - mUserId = UserHandle.myUserId(); - } + checkInteractAcrossUsersPermission(context, UserHandle.myUserId()); + mUserId = context.getUserId(); + // Strip the previously injected app widget id from service intent if (intent.hasExtra(RemoteViews.EXTRA_REMOTEADAPTER_APPWIDGET_ID)) { intent.removeExtra(RemoteViews.EXTRA_REMOTEADAPTER_APPWIDGET_ID); @@ -876,6 +878,15 @@ public class RemoteViewsAdapter extends BaseAdapter implements Handler.Callback } } + private static void checkInteractAcrossUsersPermission(Context context, int userId) { + if (context.getUserId() != userId + && context.checkCallingOrSelfPermission(MULTI_USER_PERM) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Must have permission " + MULTI_USER_PERM + + " to inflate another user's widget"); + } + } + @Override protected void finalize() throws Throwable { try { diff --git a/core/java/android/widget/ScrollBarDrawable.java b/core/java/android/widget/ScrollBarDrawable.java index 93a1179..9886bc3 100644 --- a/core/java/android/widget/ScrollBarDrawable.java +++ b/core/java/android/widget/ScrollBarDrawable.java @@ -226,6 +226,12 @@ public class ScrollBarDrawable extends Drawable { } @Override + public int getAlpha() { + // All elements should have same alpha, just return one of them + return mVerticalThumb.getAlpha(); + } + + @Override public void setColorFilter(ColorFilter cf) { if (mVerticalTrack != null) { mVerticalTrack.setColorFilter(cf); diff --git a/core/java/android/widget/TextClock.java b/core/java/android/widget/TextClock.java index a564c96..b3b95d9 100644 --- a/core/java/android/widget/TextClock.java +++ b/core/java/android/widget/TextClock.java @@ -95,6 +95,7 @@ public class TextClock extends TextView { * * @see #setFormat12Hour(CharSequence) * @see #getFormat12Hour() + * * @deprecated Let the system use locale-appropriate defaults instead. */ public static final CharSequence DEFAULT_FORMAT_12_HOUR = "h:mm a"; @@ -108,6 +109,7 @@ public class TextClock extends TextView { * * @see #setFormat24Hour(CharSequence) * @see #getFormat24Hour() + * * @deprecated Let the system use locale-appropriate defaults instead. */ public static final CharSequence DEFAULT_FORMAT_24_HOUR = "H:mm"; @@ -162,9 +164,7 @@ public class TextClock extends TextView { }; /** - * Creates a new clock using the default patterns - * {@link #DEFAULT_FORMAT_24_HOUR} and {@link #DEFAULT_FORMAT_12_HOUR} - * respectively for the 24-hour and 12-hour modes. + * Creates a new clock using the default patterns for the current locale. * * @param context The Context the view is running in, through which it can * access the current theme, resources, etc. @@ -258,20 +258,26 @@ public class TextClock extends TextView { } /** - * Specifies the formatting pattern used to display the date and/or time + * <p>Specifies the formatting pattern used to display the date and/or time * in 12-hour mode. The formatting pattern syntax is described in - * {@link DateFormat}. + * {@link DateFormat}.</p> * - * If this pattern is set to null, {@link #getFormat24Hour()} will be used + * <p>If this pattern is set to null, {@link #getFormat24Hour()} will be used * even in 12-hour mode. If both 24-hour and 12-hour formatting patterns - * are set to null, {@link #DEFAULT_FORMAT_24_HOUR} and - * {@link #DEFAULT_FORMAT_12_HOUR} will be used instead. + * are set to null, the default pattern for the current locale will be used + * instead.</p> + * + * <p><strong>Note:</strong> if styling is not needed, it is highly recommended + * you supply a format string generated by + * {@link DateFormat#getBestDateTimePattern(java.util.Locale, String)}. This method + * takes care of generating a format string adapted to the desired locale.</p> + * * * @param format A date/time formatting pattern as described in {@link DateFormat} * * @see #getFormat12Hour() * @see #is24HourModeEnabled() - * @see #DEFAULT_FORMAT_12_HOUR + * @see DateFormat#getBestDateTimePattern(java.util.Locale, String) * @see DateFormat * * @attr ref android.R.styleable#TextClock_format12Hour @@ -300,20 +306,25 @@ public class TextClock extends TextView { } /** - * Specifies the formatting pattern used to display the date and/or time + * <p>Specifies the formatting pattern used to display the date and/or time * in 24-hour mode. The formatting pattern syntax is described in - * {@link DateFormat}. + * {@link DateFormat}.</p> + * + * <p>If this pattern is set to null, {@link #getFormat24Hour()} will be used + * even in 12-hour mode. If both 24-hour and 12-hour formatting patterns + * are set to null, the default pattern for the current locale will be used + * instead.</p> * - * If this pattern is set to null, {@link #getFormat12Hour()} will be used - * even in 24-hour mode. If both 24-hour and 12-hour formatting patterns - * are set to null, {@link #DEFAULT_FORMAT_24_HOUR} and - * {@link #DEFAULT_FORMAT_12_HOUR} will be used instead. + * <p><strong>Note:</strong> if styling is not needed, it is highly recommended + * you supply a format string generated by + * {@link DateFormat#getBestDateTimePattern(java.util.Locale, String)}. This method + * takes care of generating a format string adapted to the desired locale.</p> * * @param format A date/time formatting pattern as described in {@link DateFormat} * * @see #getFormat24Hour() * @see #is24HourModeEnabled() - * @see #DEFAULT_FORMAT_24_HOUR + * @see DateFormat#getBestDateTimePattern(java.util.Locale, String) * @see DateFormat * * @attr ref android.R.styleable#TextClock_format24Hour @@ -334,8 +345,7 @@ public class TextClock extends TextView { * returned by {@link #getFormat12Hour()} is used instead. * * If either one of the formats is null, the other format is used. If - * both formats are null, the default values {@link #DEFAULT_FORMAT_12_HOUR} - * and {@link #DEFAULT_FORMAT_24_HOUR} are used instead. + * both formats are null, the default formats for the current locale are used. * * @return true if time should be displayed in 24-hour format, false if it * should be displayed in 12-hour format. diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java index 9e3f87f..698f101 100644 --- a/core/java/android/widget/TextView.java +++ b/core/java/android/widget/TextView.java @@ -284,6 +284,13 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener private boolean mPreDrawRegistered; + // A flag to prevent repeated movements from escaping the enclosing text view. The idea here is + // that if a user is holding down a movement key to traverse text, we shouldn't also traverse + // the view hierarchy. On the other hand, if the user is using the movement key to traverse views + // (i.e. the first movement was to traverse out of this view, or this view was traversed into by + // the user holding the movement key down) then we shouldn't prevent the focus from changing. + private boolean mPreventDefaultMovement; + private TextUtils.TruncateAt mEllipsize; static class Drawables { @@ -5268,7 +5275,6 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener public boolean onKeyDown(int keyCode, KeyEvent event) { int which = doKeyDown(keyCode, event, null); if (which == 0) { - // Go through default dispatching. return super.onKeyDown(keyCode, event); } @@ -5366,6 +5372,15 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener return 0; } + // If this is the initial keydown, we don't want to prevent a movement away from this view. + // While this shouldn't be necessary because any time we're preventing default movement we + // should be restricting the focus to remain within this view, thus we'll also receive + // the key up event, occasionally key up events will get dropped and we don't want to + // prevent the user from traversing out of this on the next key down. + if (event.getRepeatCount() == 0 && !KeyEvent.isModifierKey(keyCode)) { + mPreventDefaultMovement = false; + } + switch (keyCode) { case KeyEvent.KEYCODE_ENTER: if (event.hasNoModifiers()) { @@ -5474,12 +5489,16 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener } } if (doDown) { - if (mMovement.onKeyDown(this, (Spannable)mText, keyCode, event)) + if (mMovement.onKeyDown(this, (Spannable)mText, keyCode, event)) { + if (event.getRepeatCount() == 0 && !KeyEvent.isModifierKey(keyCode)) { + mPreventDefaultMovement = true; + } return 2; + } } } - return 0; + return mPreventDefaultMovement && !KeyEvent.isModifierKey(keyCode) ? -1 : 0; } /** @@ -5512,6 +5531,10 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener return super.onKeyUp(keyCode, event); } + if (!KeyEvent.isModifierKey(keyCode)) { + mPreventDefaultMovement = false; + } + switch (keyCode) { case KeyEvent.KEYCODE_DPAD_CENTER: if (event.hasNoModifiers()) { diff --git a/core/java/com/android/internal/content/PackageMonitor.java b/core/java/com/android/internal/content/PackageMonitor.java index 424c19b..ab871fb 100644 --- a/core/java/com/android/internal/content/PackageMonitor.java +++ b/core/java/com/android/internal/content/PackageMonitor.java @@ -25,6 +25,7 @@ import android.os.Handler; import android.os.HandlerThread; import android.os.Looper; import android.os.UserHandle; +import com.android.internal.os.BackgroundThread; import java.util.HashSet; @@ -37,10 +38,6 @@ public abstract class PackageMonitor extends android.content.BroadcastReceiver { static final IntentFilter sNonDataFilt = new IntentFilter(); static final IntentFilter sExternalFilt = new IntentFilter(); - static final Object sLock = new Object(); - static HandlerThread sBackgroundThread; - static Handler sBackgroundHandler; - static { sPackageFilt.addAction(Intent.ACTION_PACKAGE_ADDED); sPackageFilt.addAction(Intent.ACTION_PACKAGE_REMOVED); @@ -79,15 +76,7 @@ public abstract class PackageMonitor extends android.content.BroadcastReceiver { } mRegisteredContext = context; if (thread == null) { - synchronized (sLock) { - if (sBackgroundThread == null) { - sBackgroundThread = new HandlerThread("PackageMonitor", - android.os.Process.THREAD_PRIORITY_BACKGROUND); - sBackgroundThread.start(); - sBackgroundHandler = new Handler(sBackgroundThread.getLooper()); - } - mRegisteredHandler = sBackgroundHandler; - } + mRegisteredHandler = BackgroundThread.getHandler(); } else { mRegisteredHandler = new Handler(thread); } diff --git a/core/java/com/android/internal/os/BackgroundThread.java b/core/java/com/android/internal/os/BackgroundThread.java new file mode 100644 index 0000000..d6f7b20 --- /dev/null +++ b/core/java/com/android/internal/os/BackgroundThread.java @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2013 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.Handler; +import android.os.HandlerThread; + +/** + * Shared singleton background thread for each process. + */ +public final class BackgroundThread extends HandlerThread { + private static BackgroundThread sInstance; + private static Handler sHandler; + + private BackgroundThread() { + super("android.bg", android.os.Process.THREAD_PRIORITY_BACKGROUND); + } + + private static void ensureThreadLocked() { + if (sInstance == null) { + sInstance = new BackgroundThread(); + sInstance.start(); + sHandler = new Handler(sInstance.getLooper()); + } + } + + public static BackgroundThread get() { + synchronized (BackgroundThread.class) { + ensureThreadLocked(); + return sInstance; + } + } + + public static Handler getHandler() { + synchronized (BackgroundThread.class) { + ensureThreadLocked(); + return sHandler; + } + } +} diff --git a/core/java/com/android/internal/os/BatteryStatsImpl.java b/core/java/com/android/internal/os/BatteryStatsImpl.java index 04b9884..33ce573 100644 --- a/core/java/com/android/internal/os/BatteryStatsImpl.java +++ b/core/java/com/android/internal/os/BatteryStatsImpl.java @@ -83,7 +83,7 @@ public final class BatteryStatsImpl extends BatteryStats { private static final int MAGIC = 0xBA757475; // 'BATSTATS' // Current on-disk Parcel version - private static final int VERSION = 64 + (USE_OLD_HISTORY ? 1000 : 0); + private static final int VERSION = 65 + (USE_OLD_HISTORY ? 1000 : 0); // Maximum number of items we will record in the history. private static final int MAX_HISTORY_ITEMS = 2000; @@ -663,7 +663,7 @@ public final class BatteryStatsImpl extends BatteryStats { } public void logState(Printer pw, String prefix) { - pw.println(prefix + " mCount=" + mCount + pw.println(prefix + "mCount=" + mCount + " mLoadedCount=" + mLoadedCount + " mLastCount=" + mLastCount + " mUnpluggedCount=" + mUnpluggedCount); pw.println(prefix + "mTotalTime=" + mTotalTime @@ -1048,7 +1048,7 @@ public final class BatteryStatsImpl extends BatteryStats { public void logState(Printer pw, String prefix) { super.logState(pw, prefix); - pw.println(prefix + "mNesting=" + mNesting + "mUpdateTime=" + mUpdateTime + pw.println(prefix + "mNesting=" + mNesting + " mUpdateTime=" + mUpdateTime + " mAcquireTime=" + mAcquireTime); } @@ -2240,6 +2240,14 @@ public final class BatteryStatsImpl extends BatteryStats { getUidStatsLocked(uid).noteVideoTurnedOffLocked(); } + public void noteActivityResumedLocked(int uid) { + getUidStatsLocked(uid).noteActivityResumedLocked(); + } + + public void noteActivityPausedLocked(int uid) { + getUidStatsLocked(uid).noteActivityPausedLocked(); + } + public void noteVibratorOnLocked(int uid, long durationMillis) { getUidStatsLocked(uid).noteVibratorOnLocked(durationMillis); } @@ -2541,6 +2549,8 @@ public final class BatteryStatsImpl extends BatteryStats { boolean mVideoTurnedOn; StopwatchTimer mVideoTurnedOnTimer; + StopwatchTimer mForegroundActivityTimer; + BatchTimer mVibratorOnTimer; Counter[] mUserActivityCounters; @@ -2776,6 +2786,27 @@ public final class BatteryStatsImpl extends BatteryStats { } } + public StopwatchTimer createForegroundActivityTimerLocked() { + if (mForegroundActivityTimer == null) { + mForegroundActivityTimer = new StopwatchTimer( + Uid.this, FOREGROUND_ACTIVITY, null, mUnpluggables); + } + return mForegroundActivityTimer; + } + + @Override + public void noteActivityResumedLocked() { + // We always start, since we want multiple foreground PIDs to nest + createForegroundActivityTimerLocked().startRunningLocked(BatteryStatsImpl.this); + } + + @Override + public void noteActivityPausedLocked() { + if (mForegroundActivityTimer != null) { + mForegroundActivityTimer.stopRunningLocked(BatteryStatsImpl.this); + } + } + public BatchTimer createVibratorOnTimerLocked() { if (mVibratorOnTimer == null) { mVibratorOnTimer = new BatchTimer(Uid.this, VIBRATOR_ON, @@ -2844,6 +2875,11 @@ public final class BatteryStatsImpl extends BatteryStats { } @Override + public Timer getForegroundActivityTimer() { + return mForegroundActivityTimer; + } + + @Override public Timer getVibratorOnTimer() { return mVibratorOnTimer; } @@ -2919,6 +2955,9 @@ public final class BatteryStatsImpl extends BatteryStats { active |= !mVideoTurnedOnTimer.reset(BatteryStatsImpl.this, false); active |= mVideoTurnedOn; } + if (mForegroundActivityTimer != null) { + active |= !mForegroundActivityTimer.reset(BatteryStatsImpl.this, false); + } if (mVibratorOnTimer != null) { if (mVibratorOnTimer.reset(BatteryStatsImpl.this, false)) { mVibratorOnTimer.detach(); @@ -3018,6 +3057,10 @@ public final class BatteryStatsImpl extends BatteryStats { mVideoTurnedOnTimer.detach(); mVideoTurnedOnTimer = null; } + if (mForegroundActivityTimer != null) { + mForegroundActivityTimer.detach(); + mForegroundActivityTimer = null; + } if (mUserActivityCounters != null) { for (int i=0; i<NUM_USER_ACTIVITY_TYPES; i++) { mUserActivityCounters[i].detach(); @@ -3099,6 +3142,12 @@ public final class BatteryStatsImpl extends BatteryStats { } else { out.writeInt(0); } + if (mForegroundActivityTimer != null) { + out.writeInt(1); + mForegroundActivityTimer.writeToParcel(out, batteryRealtime); + } else { + out.writeInt(0); + } if (mVibratorOnTimer != null) { out.writeInt(1); mVibratorOnTimer.writeToParcel(out, batteryRealtime); @@ -3204,6 +3253,12 @@ public final class BatteryStatsImpl extends BatteryStats { mVideoTurnedOnTimer = null; } if (in.readInt() != 0) { + mForegroundActivityTimer = new StopwatchTimer( + Uid.this, FOREGROUND_ACTIVITY, null, mUnpluggables, in); + } else { + mForegroundActivityTimer = null; + } + if (in.readInt() != 0) { mVibratorOnTimer = new BatchTimer(Uid.this, VIBRATOR_ON, mUnpluggables, BatteryStatsImpl.this.mOnBatteryInternal, in); } else { @@ -3372,14 +3427,14 @@ public final class BatteryStatsImpl extends BatteryStats { long mSystemTime; /** - * Number of times the process has been started. + * Amount of time the process was running in the foreground. */ - int mStarts; + long mForegroundTime; /** - * Amount of time the process was running in the foreground. + * Number of times the process has been started. */ - long mForegroundTime; + int mStarts; /** * The amount of user time loaded from a previous save. @@ -3392,14 +3447,14 @@ public final class BatteryStatsImpl extends BatteryStats { long mLoadedSystemTime; /** - * The number of times the process has started from a previous save. + * The amount of foreground time loaded from a previous save. */ - int mLoadedStarts; + long mLoadedForegroundTime; /** - * The amount of foreground time loaded from a previous save. + * The number of times the process has started from a previous save. */ - long mLoadedForegroundTime; + int mLoadedStarts; /** * The amount of user time loaded from the previous run. @@ -3412,14 +3467,14 @@ public final class BatteryStatsImpl extends BatteryStats { long mLastSystemTime; /** - * The number of times the process has started from the previous run. + * The amount of foreground time loaded from the previous run */ - int mLastStarts; + long mLastForegroundTime; /** - * The amount of foreground time loaded from the previous run + * The number of times the process has started from the previous run. */ - long mLastForegroundTime; + int mLastStarts; /** * The amount of user time when last unplugged. @@ -3432,14 +3487,14 @@ public final class BatteryStatsImpl extends BatteryStats { long mUnpluggedSystemTime; /** - * The number of times the process has started before unplugged. + * The amount of foreground time since unplugged. */ - int mUnpluggedStarts; + long mUnpluggedForegroundTime; /** - * The amount of foreground time since unplugged. + * The number of times the process has started before unplugged. */ - long mUnpluggedForegroundTime; + int mUnpluggedStarts; SamplingCounter[] mSpeedBins; @@ -3453,8 +3508,8 @@ public final class BatteryStatsImpl extends BatteryStats { public void unplug(long elapsedRealtime, long batteryUptime, long batteryRealtime) { mUnpluggedUserTime = mUserTime; mUnpluggedSystemTime = mSystemTime; - mUnpluggedStarts = mStarts; mUnpluggedForegroundTime = mForegroundTime; + mUnpluggedStarts = mStarts; } public void plug(long elapsedRealtime, long batteryUptime, long batteryRealtime) { @@ -5362,6 +5417,9 @@ public final class BatteryStatsImpl extends BatteryStats { u.createVideoTurnedOnTimerLocked().readSummaryFromParcelLocked(in); } if (in.readInt() != 0) { + u.createForegroundActivityTimerLocked().readSummaryFromParcelLocked(in); + } + if (in.readInt() != 0) { u.createVibratorOnTimerLocked().readSummaryFromParcelLocked(in); } @@ -5415,6 +5473,7 @@ public final class BatteryStatsImpl extends BatteryStats { Uid.Proc p = u.getProcessStatsLocked(procName); p.mUserTime = p.mLoadedUserTime = in.readLong(); p.mSystemTime = p.mLoadedSystemTime = in.readLong(); + p.mForegroundTime = p.mLoadedForegroundTime = in.readLong(); p.mStarts = p.mLoadedStarts = in.readInt(); int NSB = in.readInt(); if (NSB > 100) { @@ -5564,6 +5623,12 @@ public final class BatteryStatsImpl extends BatteryStats { } else { out.writeInt(0); } + if (u.mForegroundActivityTimer != null) { + out.writeInt(1); + u.mForegroundActivityTimer.writeSummaryFromParcelLocked(out, NOWREAL); + } else { + out.writeInt(0); + } if (u.mVibratorOnTimer != null) { out.writeInt(1); u.mVibratorOnTimer.writeSummaryFromParcelLocked(out, NOWREAL); @@ -5633,6 +5698,7 @@ public final class BatteryStatsImpl extends BatteryStats { Uid.Proc ps = ent.getValue(); out.writeLong(ps.mUserTime); out.writeLong(ps.mSystemTime); + out.writeLong(ps.mForegroundTime); out.writeInt(ps.mStarts); final int N = ps.mSpeedBins.length; out.writeInt(N); @@ -5908,7 +5974,7 @@ public final class BatteryStatsImpl extends BatteryStats { updateKernelWakelocksLocked(); } - public void dumpLocked(PrintWriter pw) { + public void dumpLocked(PrintWriter pw, boolean isUnpluggedOnly) { if (DEBUG) { Printer pr = new PrintWriterPrinter(pw); pr.println("*** Screen timer:"); @@ -5940,7 +6006,7 @@ public final class BatteryStatsImpl extends BatteryStats { pr.println("*** Mobile ifaces:"); pr.println(mMobileIfaces.toString()); } - super.dumpLocked(pw); + super.dumpLocked(pw, isUnpluggedOnly); } private NetworkStats mNetworkSummaryCache; diff --git a/core/java/com/android/internal/os/ProcessStats.java b/core/java/com/android/internal/os/ProcessStats.java index b1bb8c1..bd0914d 100644 --- a/core/java/com/android/internal/os/ProcessStats.java +++ b/core/java/com/android/internal/os/ProcessStats.java @@ -518,6 +518,10 @@ public class ProcessStats { return pids; } + /** + * Returns the total time (in clock ticks, or 1/100 sec) spent executing in + * both user and system code. + */ public long getCpuTimeForPid(int pid) { final String statFile = "/proc/" + pid + "/stat"; final long[] statsData = mSinglePidStatsData; @@ -531,9 +535,9 @@ public class ProcessStats { } /** - * Returns the times spent at each CPU speed, since the last call to this method. If this - * is the first time, it will return 1 for each value. - * @return relative times spent at different speed steps. + * Returns the delta time (in clock ticks, or 1/100 sec) spent at each CPU + * speed, since the last call to this method. If this is the first call, it + * will return 1 for each value. */ public long[] getLastCpuSpeedTimes() { if (mCpuSpeedTimes == null) { diff --git a/core/java/com/android/internal/policy/IKeyguardExitCallback.aidl b/core/java/com/android/internal/policy/IKeyguardExitCallback.aidl new file mode 100644 index 0000000..3702712 --- /dev/null +++ b/core/java/com/android/internal/policy/IKeyguardExitCallback.aidl @@ -0,0 +1,20 @@ +/* + * Copyright (C) 2013 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.policy; + +oneway interface IKeyguardExitCallback { + void onKeyguardExitResult(boolean success); +} diff --git a/core/java/com/android/internal/policy/IKeyguardService.aidl b/core/java/com/android/internal/policy/IKeyguardService.aidl new file mode 100644 index 0000000..880464d --- /dev/null +++ b/core/java/com/android/internal/policy/IKeyguardService.aidl @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2013 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.policy; + +import com.android.internal.policy.IKeyguardShowCallback; +import com.android.internal.policy.IKeyguardExitCallback; + +import android.os.Bundle; + +interface IKeyguardService { + boolean isShowing(); + boolean isSecure(); + boolean isShowingAndNotHidden(); + boolean isInputRestricted(); + boolean isDismissable(); + oneway void verifyUnlock(IKeyguardExitCallback callback); + oneway void keyguardDone(boolean authenticated, boolean wakeup); + oneway void setHidden(boolean isHidden); + oneway void dismiss(); + oneway void onWakeKeyWhenKeyguardShowing(int keyCode); + oneway void onWakeMotionWhenKeyguardShowing(); + oneway void onDreamingStarted(); + oneway void onDreamingStopped(); + oneway void onScreenTurnedOff(int reason); + oneway void onScreenTurnedOn(IKeyguardShowCallback callback); + oneway void setKeyguardEnabled(boolean enabled); + oneway void onSystemReady(); + oneway void doKeyguardTimeout(in Bundle options); + oneway void setCurrentUser(int userId); + oneway void showAssistant(); +} diff --git a/core/java/com/android/internal/policy/IKeyguardShowCallback.aidl b/core/java/com/android/internal/policy/IKeyguardShowCallback.aidl new file mode 100644 index 0000000..a2784d9 --- /dev/null +++ b/core/java/com/android/internal/policy/IKeyguardShowCallback.aidl @@ -0,0 +1,20 @@ +/* + * Copyright (C) 2013 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.policy; + +oneway interface IKeyguardShowCallback { + void onShown(IBinder windowToken); +} diff --git a/core/java/com/android/internal/util/IndentingPrintWriter.java b/core/java/com/android/internal/util/IndentingPrintWriter.java index d01a817..6fddd09 100644 --- a/core/java/com/android/internal/util/IndentingPrintWriter.java +++ b/core/java/com/android/internal/util/IndentingPrintWriter.java @@ -68,6 +68,10 @@ public class IndentingPrintWriter extends PrintWriter { print(key + "=" + String.valueOf(value) + " "); } + public void printHexPair(String key, int value) { + print(key + "=0x" + Integer.toHexString(value) + " "); + } + @Override public void write(char[] buf, int offset, int count) { final int indentLength = mIndentBuilder.length(); diff --git a/core/java/com/android/internal/widget/LockPatternUtils.java b/core/java/com/android/internal/widget/LockPatternUtils.java index d3ead26..521ba81 100644 --- a/core/java/com/android/internal/widget/LockPatternUtils.java +++ b/core/java/com/android/internal/widget/LockPatternUtils.java @@ -16,6 +16,7 @@ package com.android.internal.widget; +import android.Manifest; import android.app.ActivityManagerNative; import android.app.admin.DevicePolicyManager; import android.appwidget.AppWidgetManager; @@ -149,6 +150,8 @@ public class LockPatternUtils { private DevicePolicyManager mDevicePolicyManager; private ILockSettings mLockSettingsService; + private final boolean mMultiUserMode; + // The current user is set by KeyguardViewMediator and shared by all LockPatternUtils. private static volatile int sCurrentUserId = UserHandle.USER_NULL; @@ -170,6 +173,12 @@ public class LockPatternUtils { public LockPatternUtils(Context context) { mContext = context; mContentResolver = context.getContentResolver(); + + // If this is being called by the system or by an application like keyguard that + // has permision INTERACT_ACROSS_USERS, then LockPatternUtils will operate in multi-user + // mode where calls are for the current user rather than the user of the calling process. + mMultiUserMode = context.checkCallingOrSelfPermission( + Manifest.permission.INTERACT_ACROSS_USERS_FULL) == PackageManager.PERMISSION_GRANTED; } private ILockSettings getLockSettings() { @@ -264,13 +273,12 @@ public class LockPatternUtils { } private int getCurrentOrCallingUserId() { - int callingUid = Binder.getCallingUid(); - if (callingUid == android.os.Process.SYSTEM_UID) { + if (mMultiUserMode) { // TODO: This is a little inefficient. See if all users of this are able to // handle USER_CURRENT and pass that instead. return getCurrentUser(); } else { - return UserHandle.getUserId(callingUid); + return UserHandle.getCallingUserId(); } } diff --git a/core/java/com/android/internal/widget/TransportControlView.java b/core/java/com/android/internal/widget/TransportControlView.java deleted file mode 100644 index ca797eb..0000000 --- a/core/java/com/android/internal/widget/TransportControlView.java +++ /dev/null @@ -1,515 +0,0 @@ -/* - * Copyright (C) 2011 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 java.lang.ref.WeakReference; - -import com.android.internal.widget.LockScreenWidgetCallback; -import com.android.internal.widget.LockScreenWidgetInterface; - -import android.app.PendingIntent; -import android.app.PendingIntent.CanceledException; -import android.content.Context; -import android.content.Intent; -import android.graphics.Bitmap; -import android.media.AudioManager; -import android.media.MediaMetadataRetriever; -import android.media.RemoteControlClient; -import android.media.IRemoteControlDisplay; -import android.os.Bundle; -import android.os.Handler; -import android.os.Message; -import android.os.Parcel; -import android.os.Parcelable; -import android.os.RemoteException; -import android.os.SystemClock; -import android.text.Spannable; -import android.text.TextUtils; -import android.text.style.ForegroundColorSpan; -import android.util.AttributeSet; -import android.util.Log; -import android.view.KeyEvent; -import android.view.View; -import android.view.View.OnClickListener; -import android.widget.FrameLayout; -import android.widget.ImageView; -import android.widget.TextView; - - -import com.android.internal.R; - -public class TransportControlView extends FrameLayout implements OnClickListener, - LockScreenWidgetInterface { - - private static final int MSG_UPDATE_STATE = 100; - private static final int MSG_SET_METADATA = 101; - private static final int MSG_SET_TRANSPORT_CONTROLS = 102; - private static final int MSG_SET_ARTWORK = 103; - private static final int MSG_SET_GENERATION_ID = 104; - private static final int MAXDIM = 512; - private static final int DISPLAY_TIMEOUT_MS = 5000; // 5s - protected static final boolean DEBUG = false; - protected static final String TAG = "TransportControlView"; - - private ImageView mAlbumArt; - private TextView mTrackTitle; - private ImageView mBtnPrev; - private ImageView mBtnPlay; - private ImageView mBtnNext; - private int mClientGeneration; - private Metadata mMetadata = new Metadata(); - private boolean mAttached; - private PendingIntent mClientIntent; - private int mTransportControlFlags; - private int mCurrentPlayState; - private AudioManager mAudioManager; - private LockScreenWidgetCallback mWidgetCallbacks; - private IRemoteControlDisplayWeak mIRCD; - - /** - * The metadata which should be populated into the view once we've been attached - */ - private Bundle mPopulateMetadataWhenAttached = null; - - // This handler is required to ensure messages from IRCD are handled in sequence and on - // the UI thread. - private Handler mHandler = new Handler() { - @Override - public void handleMessage(Message msg) { - switch (msg.what) { - case MSG_UPDATE_STATE: - if (mClientGeneration == msg.arg1) updatePlayPauseState(msg.arg2); - break; - - case MSG_SET_METADATA: - if (mClientGeneration == msg.arg1) updateMetadata((Bundle) msg.obj); - break; - - case MSG_SET_TRANSPORT_CONTROLS: - if (mClientGeneration == msg.arg1) updateTransportControls(msg.arg2); - break; - - case MSG_SET_ARTWORK: - if (mClientGeneration == msg.arg1) { - if (mMetadata.bitmap != null) { - mMetadata.bitmap.recycle(); - } - mMetadata.bitmap = (Bitmap) msg.obj; - mAlbumArt.setImageBitmap(mMetadata.bitmap); - } - break; - - case MSG_SET_GENERATION_ID: - if (msg.arg2 != 0) { - // This means nobody is currently registered. Hide the view. - if (mWidgetCallbacks != null) { - mWidgetCallbacks.requestHide(TransportControlView.this); - } - } - if (DEBUG) Log.v(TAG, "New genId = " + msg.arg1 + ", clearing = " + msg.arg2); - mClientGeneration = msg.arg1; - mClientIntent = (PendingIntent) msg.obj; - break; - - } - } - }; - - /** - * This class is required to have weak linkage to the current TransportControlView - * because the remote process can hold a strong reference to this binder object and - * we can't predict when it will be GC'd in the remote process. Without this code, it - * would allow a heavyweight object to be held on this side of the binder when there's - * no requirement to run a GC on the other side. - */ - private static class IRemoteControlDisplayWeak extends IRemoteControlDisplay.Stub { - private WeakReference<Handler> mLocalHandler; - - IRemoteControlDisplayWeak(Handler handler) { - mLocalHandler = new WeakReference<Handler>(handler); - } - - public void setPlaybackState(int generationId, int state, long stateChangeTimeMs, - long currentPosMs, float speed) { - Handler handler = mLocalHandler.get(); - if (handler != null) { - handler.obtainMessage(MSG_UPDATE_STATE, generationId, state).sendToTarget(); - } - } - - public void setMetadata(int generationId, Bundle metadata) { - Handler handler = mLocalHandler.get(); - if (handler != null) { - handler.obtainMessage(MSG_SET_METADATA, generationId, 0, metadata).sendToTarget(); - } - } - - public void setTransportControlInfo(int generationId, int flags, int posCapabilities) { - Handler handler = mLocalHandler.get(); - if (handler != null) { - handler.obtainMessage(MSG_SET_TRANSPORT_CONTROLS, generationId, flags) - .sendToTarget(); - } - } - - public void setArtwork(int generationId, Bitmap bitmap) { - Handler handler = mLocalHandler.get(); - if (handler != null) { - handler.obtainMessage(MSG_SET_ARTWORK, generationId, 0, bitmap).sendToTarget(); - } - } - - public void setAllMetadata(int generationId, Bundle metadata, Bitmap bitmap) { - Handler handler = mLocalHandler.get(); - if (handler != null) { - handler.obtainMessage(MSG_SET_METADATA, generationId, 0, metadata).sendToTarget(); - handler.obtainMessage(MSG_SET_ARTWORK, generationId, 0, bitmap).sendToTarget(); - } - } - - public void setCurrentClientId(int clientGeneration, PendingIntent mediaIntent, - boolean clearing) throws RemoteException { - Handler handler = mLocalHandler.get(); - if (handler != null) { - handler.obtainMessage(MSG_SET_GENERATION_ID, - clientGeneration, (clearing ? 1 : 0), mediaIntent).sendToTarget(); - } - } - }; - - public TransportControlView(Context context, AttributeSet attrs) { - super(context, attrs); - if (DEBUG) Log.v(TAG, "Create TCV " + this); - mAudioManager = new AudioManager(mContext); - mCurrentPlayState = RemoteControlClient.PLAYSTATE_NONE; // until we get a callback - mIRCD = new IRemoteControlDisplayWeak(mHandler); - } - - private void updateTransportControls(int transportControlFlags) { - mTransportControlFlags = transportControlFlags; - } - - @Override - public void onFinishInflate() { - super.onFinishInflate(); - mTrackTitle = (TextView) findViewById(R.id.title); - mTrackTitle.setSelected(true); // enable marquee - mAlbumArt = (ImageView) findViewById(R.id.albumart); - mBtnPrev = (ImageView) findViewById(R.id.btn_prev); - mBtnPlay = (ImageView) findViewById(R.id.btn_play); - mBtnNext = (ImageView) findViewById(R.id.btn_next); - final View buttons[] = { mBtnPrev, mBtnPlay, mBtnNext }; - for (View view : buttons) { - view.setOnClickListener(this); - } - } - - @Override - public void onAttachedToWindow() { - super.onAttachedToWindow(); - if (mPopulateMetadataWhenAttached != null) { - updateMetadata(mPopulateMetadataWhenAttached); - mPopulateMetadataWhenAttached = null; - } - if (!mAttached) { - if (DEBUG) Log.v(TAG, "Registering TCV " + this); - mAudioManager.registerRemoteControlDisplay(mIRCD); - } - mAttached = true; - } - - @Override - public void onDetachedFromWindow() { - super.onDetachedFromWindow(); - if (mAttached) { - if (DEBUG) Log.v(TAG, "Unregistering TCV " + this); - mAudioManager.unregisterRemoteControlDisplay(mIRCD); - } - mAttached = false; - } - - @Override - protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { - super.onMeasure(widthMeasureSpec, heightMeasureSpec); - int dim = Math.min(MAXDIM, Math.max(getWidth(), getHeight())); -// Log.v(TAG, "setting max bitmap size: " + dim + "x" + dim); -// mAudioManager.remoteControlDisplayUsesBitmapSize(mIRCD, dim, dim); - } - - class Metadata { - private String artist; - private String trackTitle; - private String albumTitle; - private Bitmap bitmap; - - public String toString() { - return "Metadata[artist=" + artist + " trackTitle=" + trackTitle + " albumTitle=" + albumTitle + "]"; - } - } - - private String getMdString(Bundle data, int id) { - return data.getString(Integer.toString(id)); - } - - private void updateMetadata(Bundle data) { - if (mAttached) { - mMetadata.artist = getMdString(data, MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST); - mMetadata.trackTitle = getMdString(data, MediaMetadataRetriever.METADATA_KEY_TITLE); - mMetadata.albumTitle = getMdString(data, MediaMetadataRetriever.METADATA_KEY_ALBUM); - populateMetadata(); - } else { - mPopulateMetadataWhenAttached = data; - } - } - - /** - * Populates the given metadata into the view - */ - private void populateMetadata() { - StringBuilder sb = new StringBuilder(); - int trackTitleLength = 0; - if (!TextUtils.isEmpty(mMetadata.trackTitle)) { - sb.append(mMetadata.trackTitle); - trackTitleLength = mMetadata.trackTitle.length(); - } - if (!TextUtils.isEmpty(mMetadata.artist)) { - if (sb.length() != 0) { - sb.append(" - "); - } - sb.append(mMetadata.artist); - } - if (!TextUtils.isEmpty(mMetadata.albumTitle)) { - if (sb.length() != 0) { - sb.append(" - "); - } - sb.append(mMetadata.albumTitle); - } - mTrackTitle.setText(sb.toString(), TextView.BufferType.SPANNABLE); - Spannable str = (Spannable) mTrackTitle.getText(); - if (trackTitleLength != 0) { - str.setSpan(new ForegroundColorSpan(0xffffffff), 0, trackTitleLength, - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); - trackTitleLength++; - } - if (sb.length() > trackTitleLength) { - str.setSpan(new ForegroundColorSpan(0x7fffffff), trackTitleLength, sb.length(), - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); - } - - mAlbumArt.setImageBitmap(mMetadata.bitmap); - final int flags = mTransportControlFlags; - setVisibilityBasedOnFlag(mBtnPrev, flags, RemoteControlClient.FLAG_KEY_MEDIA_PREVIOUS); - setVisibilityBasedOnFlag(mBtnNext, flags, RemoteControlClient.FLAG_KEY_MEDIA_NEXT); - setVisibilityBasedOnFlag(mBtnPlay, flags, - RemoteControlClient.FLAG_KEY_MEDIA_PLAY - | RemoteControlClient.FLAG_KEY_MEDIA_PAUSE - | RemoteControlClient.FLAG_KEY_MEDIA_PLAY_PAUSE - | RemoteControlClient.FLAG_KEY_MEDIA_STOP); - - updatePlayPauseState(mCurrentPlayState); - } - - private static void setVisibilityBasedOnFlag(View view, int flags, int flag) { - if ((flags & flag) != 0) { - view.setVisibility(View.VISIBLE); - } else { - view.setVisibility(View.GONE); - } - } - - private void updatePlayPauseState(int state) { - if (DEBUG) Log.v(TAG, - "updatePlayPauseState(), old=" + mCurrentPlayState + ", state=" + state); - if (state == mCurrentPlayState) { - return; - } - final int imageResId; - final int imageDescId; - boolean showIfHidden = false; - switch (state) { - case RemoteControlClient.PLAYSTATE_ERROR: - imageResId = com.android.internal.R.drawable.stat_sys_warning; - // TODO use more specific image description string for warning, but here the "play" - // message is still valid because this button triggers a play command. - imageDescId = com.android.internal.R.string.lockscreen_transport_play_description; - break; - - case RemoteControlClient.PLAYSTATE_PLAYING: - imageResId = com.android.internal.R.drawable.ic_media_pause; - imageDescId = com.android.internal.R.string.lockscreen_transport_pause_description; - showIfHidden = true; - break; - - case RemoteControlClient.PLAYSTATE_BUFFERING: - imageResId = com.android.internal.R.drawable.ic_media_stop; - imageDescId = com.android.internal.R.string.lockscreen_transport_stop_description; - showIfHidden = true; - break; - - case RemoteControlClient.PLAYSTATE_PAUSED: - default: - imageResId = com.android.internal.R.drawable.ic_media_play; - imageDescId = com.android.internal.R.string.lockscreen_transport_play_description; - showIfHidden = false; - break; - } - mBtnPlay.setImageResource(imageResId); - mBtnPlay.setContentDescription(getResources().getString(imageDescId)); - if (showIfHidden && mWidgetCallbacks != null && !mWidgetCallbacks.isVisible(this)) { - mWidgetCallbacks.requestShow(this); - } - mCurrentPlayState = state; - } - - static class SavedState extends BaseSavedState { - boolean wasShowing; - - SavedState(Parcelable superState) { - super(superState); - } - - private SavedState(Parcel in) { - super(in); - this.wasShowing = in.readInt() != 0; - } - - @Override - public void writeToParcel(Parcel out, int flags) { - super.writeToParcel(out, flags); - out.writeInt(this.wasShowing ? 1 : 0); - } - - public static final Parcelable.Creator<SavedState> CREATOR - = new Parcelable.Creator<SavedState>() { - public SavedState createFromParcel(Parcel in) { - return new SavedState(in); - } - - public SavedState[] newArray(int size) { - return new SavedState[size]; - } - }; - } - - @Override - public Parcelable onSaveInstanceState() { - if (DEBUG) Log.v(TAG, "onSaveInstanceState()"); - Parcelable superState = super.onSaveInstanceState(); - SavedState ss = new SavedState(superState); - ss.wasShowing = mWidgetCallbacks != null && mWidgetCallbacks.isVisible(this); - return ss; - } - - @Override - public void onRestoreInstanceState(Parcelable state) { - if (DEBUG) Log.v(TAG, "onRestoreInstanceState()"); - if (!(state instanceof SavedState)) { - super.onRestoreInstanceState(state); - return; - } - SavedState ss = (SavedState) state; - super.onRestoreInstanceState(ss.getSuperState()); - if (ss.wasShowing && mWidgetCallbacks != null) { - mWidgetCallbacks.requestShow(this); - } - } - - public void onClick(View v) { - int keyCode = -1; - if (v == mBtnPrev) { - keyCode = KeyEvent.KEYCODE_MEDIA_PREVIOUS; - } else if (v == mBtnNext) { - keyCode = KeyEvent.KEYCODE_MEDIA_NEXT; - } else if (v == mBtnPlay) { - keyCode = KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE; - - } - if (keyCode != -1) { - sendMediaButtonClick(keyCode); - if (mWidgetCallbacks != null) { - mWidgetCallbacks.userActivity(this); - } - } - } - - private void sendMediaButtonClick(int keyCode) { - if (mClientIntent == null) { - // Shouldn't be possible because this view should be hidden in this case. - Log.e(TAG, "sendMediaButtonClick(): No client is currently registered"); - return; - } - // use the registered PendingIntent that will be processed by the registered - // media button event receiver, which is the component of mClientIntent - KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode); - Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON); - intent.putExtra(Intent.EXTRA_KEY_EVENT, keyEvent); - try { - mClientIntent.send(getContext(), 0, intent); - } catch (CanceledException e) { - Log.e(TAG, "Error sending intent for media button down: "+e); - e.printStackTrace(); - } - - keyEvent = new KeyEvent(KeyEvent.ACTION_UP, keyCode); - intent = new Intent(Intent.ACTION_MEDIA_BUTTON); - intent.putExtra(Intent.EXTRA_KEY_EVENT, keyEvent); - try { - mClientIntent.send(getContext(), 0, intent); - } catch (CanceledException e) { - Log.e(TAG, "Error sending intent for media button up: "+e); - e.printStackTrace(); - } - } - - public void setCallback(LockScreenWidgetCallback callback) { - mWidgetCallbacks = callback; - } - - public boolean providesClock() { - return false; - } - - private boolean wasPlayingRecently(int state, long stateChangeTimeMs) { - switch (state) { - case RemoteControlClient.PLAYSTATE_PLAYING: - case RemoteControlClient.PLAYSTATE_FAST_FORWARDING: - case RemoteControlClient.PLAYSTATE_REWINDING: - case RemoteControlClient.PLAYSTATE_SKIPPING_FORWARDS: - case RemoteControlClient.PLAYSTATE_SKIPPING_BACKWARDS: - case RemoteControlClient.PLAYSTATE_BUFFERING: - // actively playing or about to play - return true; - case RemoteControlClient.PLAYSTATE_NONE: - return false; - case RemoteControlClient.PLAYSTATE_STOPPED: - case RemoteControlClient.PLAYSTATE_PAUSED: - case RemoteControlClient.PLAYSTATE_ERROR: - // we have stopped playing, check how long ago - if (DEBUG) { - if ((SystemClock.elapsedRealtime() - stateChangeTimeMs) < DISPLAY_TIMEOUT_MS) { - Log.v(TAG, "wasPlayingRecently: time < TIMEOUT was playing recently"); - } else { - Log.v(TAG, "wasPlayingRecently: time > TIMEOUT"); - } - } - return ((SystemClock.elapsedRealtime() - stateChangeTimeMs) < DISPLAY_TIMEOUT_MS); - default: - Log.e(TAG, "Unknown playback state " + state + " in wasPlayingRecently()"); - return false; - } - } -} diff --git a/core/java/com/android/internal/widget/multiwaveview/TargetDrawable.java b/core/java/com/android/internal/widget/multiwaveview/TargetDrawable.java index 30f5f2f..16bec16 100644 --- a/core/java/com/android/internal/widget/multiwaveview/TargetDrawable.java +++ b/core/java/com/android/internal/widget/multiwaveview/TargetDrawable.java @@ -46,36 +46,6 @@ public class TargetDrawable { private boolean mEnabled = true; private final int mResourceId; - /* package */ static class DrawableWithAlpha extends Drawable { - private float mAlpha = 1.0f; - private Drawable mRealDrawable; - public DrawableWithAlpha(Drawable realDrawable) { - mRealDrawable = realDrawable; - } - public void setAlpha(float alpha) { - mAlpha = alpha; - } - public float getAlpha() { - return mAlpha; - } - public void draw(Canvas canvas) { - mRealDrawable.setAlpha((int) Math.round(mAlpha * 255f)); - mRealDrawable.draw(canvas); - } - @Override - public void setAlpha(int alpha) { - mRealDrawable.setAlpha(alpha); - } - @Override - public void setColorFilter(ColorFilter cf) { - mRealDrawable.setColorFilter(cf); - } - @Override - public int getOpacity() { - return mRealDrawable.getOpacity(); - } - } - public TargetDrawable(Resources res, int resId) { mResourceId = resId; setDrawable(res, resId); |