| /* |
| * 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.server.wm; |
| |
| import android.content.Context; |
| import android.graphics.Bitmap; |
| import android.graphics.Point; |
| import android.os.Debug; |
| import android.os.Handler; |
| import android.os.IRemoteCallback; |
| import android.util.Slog; |
| import android.view.WindowManager; |
| import android.view.animation.AlphaAnimation; |
| import android.view.animation.Animation; |
| import android.view.animation.AnimationSet; |
| import android.view.animation.AnimationUtils; |
| import android.view.animation.Interpolator; |
| import android.view.animation.ScaleAnimation; |
| |
| import com.android.internal.util.DumpUtils.Dump; |
| import com.android.server.AttributeCache; |
| import com.android.server.wm.WindowManagerService.H; |
| |
| import java.io.PrintWriter; |
| |
| import static com.android.internal.R.styleable.WindowAnimation_activityOpenEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_activityOpenExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_activityCloseEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_activityCloseExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskOpenEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskOpenExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskCloseEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskCloseExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskToFrontEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskToFrontExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskToBackEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_taskToBackExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperCloseEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperCloseExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraOpenEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraOpenExitAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseEnterAnimation; |
| import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseExitAnimation; |
| |
| // State management of app transitions. When we are preparing for a |
| // transition, mNextAppTransition will be the kind of transition to |
| // perform or TRANSIT_NONE if we are not waiting. If we are waiting, |
| // mOpeningApps and mClosingApps are the lists of tokens that will be |
| // made visible or hidden at the next transition. |
| public class AppTransition implements Dump { |
| private static final String TAG = "AppTransition"; |
| private static final boolean DEBUG_APP_TRANSITIONS = |
| WindowManagerService.DEBUG_APP_TRANSITIONS; |
| private static final boolean DEBUG_ANIM = WindowManagerService.DEBUG_ANIM; |
| |
| /** Bit mask that is set for all enter transition. */ |
| public static final int TRANSIT_ENTER_MASK = 0x1000; |
| |
| /** Bit mask that is set for all exit transitions. */ |
| public static final int TRANSIT_EXIT_MASK = 0x2000; |
| |
| /** Not set up for a transition. */ |
| public static final int TRANSIT_UNSET = -1; |
| /** No animation for transition. */ |
| public static final int TRANSIT_NONE = 0; |
| /** A window in a new activity is being opened on top of an existing one in the same task. */ |
| public static final int TRANSIT_ACTIVITY_OPEN = 6 | TRANSIT_ENTER_MASK; |
| /** The window in the top-most activity is being closed to reveal the |
| * previous activity in the same task. */ |
| public static final int TRANSIT_ACTIVITY_CLOSE = 7 | TRANSIT_EXIT_MASK; |
| /** A window in a new task is being opened on top of an existing one |
| * in another activity's task. */ |
| public static final int TRANSIT_TASK_OPEN = 8 | TRANSIT_ENTER_MASK; |
| /** A window in the top-most activity is being closed to reveal the |
| * previous activity in a different task. */ |
| public static final int TRANSIT_TASK_CLOSE = 9 | TRANSIT_EXIT_MASK; |
| /** A window in an existing task is being displayed on top of an existing one |
| * in another activity's task. */ |
| public static final int TRANSIT_TASK_TO_FRONT = 10 | TRANSIT_ENTER_MASK; |
| /** A window in an existing task is being put below all other tasks. */ |
| public static final int TRANSIT_TASK_TO_BACK = 11 | TRANSIT_EXIT_MASK; |
| /** A window in a new activity that doesn't have a wallpaper is being opened on top of one that |
| * does, effectively closing the wallpaper. */ |
| public static final int TRANSIT_WALLPAPER_CLOSE = 12 | TRANSIT_EXIT_MASK; |
| /** A window in a new activity that does have a wallpaper is being opened on one that didn't, |
| * effectively opening the wallpaper. */ |
| public static final int TRANSIT_WALLPAPER_OPEN = 13 | TRANSIT_ENTER_MASK; |
| /** A window in a new activity is being opened on top of an existing one, and both are on top |
| * of the wallpaper. */ |
| public static final int TRANSIT_WALLPAPER_INTRA_OPEN = 14 | TRANSIT_ENTER_MASK; |
| /** The window in the top-most activity is being closed to reveal the previous activity, and |
| * both are on top of the wallpaper. */ |
| public static final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15 | TRANSIT_EXIT_MASK; |
| |
| /** Fraction of animation at which the recents thumbnail becomes completely transparent */ |
| private static final float RECENTS_THUMBNAIL_FADEOUT_FRACTION = 0.25f; |
| |
| private static final long DEFAULT_APP_TRANSITION_DURATION = 250; |
| |
| private final Context mContext; |
| private final Handler mH; |
| |
| private int mNextAppTransition = TRANSIT_UNSET; |
| |
| private static final int NEXT_TRANSIT_TYPE_NONE = 0; |
| private static final int NEXT_TRANSIT_TYPE_CUSTOM = 1; |
| private static final int NEXT_TRANSIT_TYPE_SCALE_UP = 2; |
| private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP = 3; |
| private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN = 4; |
| private int mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE; |
| |
| private String mNextAppTransitionPackage; |
| private Bitmap mNextAppTransitionThumbnail; |
| // Used for thumbnail transitions. True if we're scaling up, false if scaling down |
| private boolean mNextAppTransitionScaleUp; |
| private IRemoteCallback mNextAppTransitionCallback; |
| private int mNextAppTransitionEnter; |
| private int mNextAppTransitionExit; |
| private int mNextAppTransitionStartX; |
| private int mNextAppTransitionStartY; |
| private int mNextAppTransitionStartWidth; |
| private int mNextAppTransitionStartHeight; |
| |
| private final static int APP_STATE_IDLE = 0; |
| private final static int APP_STATE_READY = 1; |
| private final static int APP_STATE_RUNNING = 2; |
| private final static int APP_STATE_TIMEOUT = 3; |
| private int mAppTransitionState = APP_STATE_IDLE; |
| |
| private final int mConfigShortAnimTime; |
| private final Interpolator mDecelerateInterpolator; |
| private final Interpolator mThumbnailFadeoutInterpolator; |
| |
| private int mCurrentUserId = 0; |
| |
| AppTransition(Context context, Handler h) { |
| mContext = context; |
| mH = h; |
| mConfigShortAnimTime = context.getResources().getInteger( |
| com.android.internal.R.integer.config_shortAnimTime); |
| mDecelerateInterpolator = AnimationUtils.loadInterpolator(context, |
| com.android.internal.R.interpolator.decelerate_cubic); |
| mThumbnailFadeoutInterpolator = new Interpolator() { |
| @Override |
| public float getInterpolation(float input) { |
| // Linear response for first fraction, then complete after that. |
| if (input < RECENTS_THUMBNAIL_FADEOUT_FRACTION) { |
| return input / RECENTS_THUMBNAIL_FADEOUT_FRACTION; |
| } |
| return 1.0f; |
| } |
| }; |
| } |
| |
| boolean isTransitionSet() { |
| return mNextAppTransition != TRANSIT_UNSET; |
| } |
| |
| boolean isTransitionNone() { |
| return mNextAppTransition == TRANSIT_NONE; |
| } |
| |
| boolean isTransitionEqual(int transit) { |
| return mNextAppTransition == transit; |
| } |
| |
| int getAppTransition() { |
| return mNextAppTransition; |
| } |
| |
| void setAppTransition(int transit) { |
| mNextAppTransition = transit; |
| } |
| |
| boolean isReady() { |
| return mAppTransitionState == APP_STATE_READY |
| || mAppTransitionState == APP_STATE_TIMEOUT; |
| } |
| |
| void setReady() { |
| mAppTransitionState = APP_STATE_READY; |
| } |
| |
| boolean isRunning() { |
| return mAppTransitionState == APP_STATE_RUNNING; |
| } |
| |
| void setIdle() { |
| mAppTransitionState = APP_STATE_IDLE; |
| } |
| |
| boolean isTimeout() { |
| return mAppTransitionState == APP_STATE_TIMEOUT; |
| } |
| |
| void setTimeout() { |
| mAppTransitionState = APP_STATE_TIMEOUT; |
| } |
| |
| Bitmap getNextAppTransitionThumbnail() { |
| return mNextAppTransitionThumbnail; |
| } |
| |
| void getStartingPoint(Point outPoint) { |
| outPoint.x = mNextAppTransitionStartX; |
| outPoint.y = mNextAppTransitionStartY; |
| } |
| |
| void prepare() { |
| if (!isRunning()) { |
| mAppTransitionState = APP_STATE_IDLE; |
| } |
| } |
| |
| void goodToGo() { |
| mNextAppTransition = TRANSIT_UNSET; |
| mAppTransitionState = APP_STATE_RUNNING; |
| } |
| |
| void clear() { |
| mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE; |
| mNextAppTransitionPackage = null; |
| mNextAppTransitionThumbnail = null; |
| } |
| |
| void freeze() { |
| setAppTransition(AppTransition.TRANSIT_UNSET); |
| clear(); |
| setReady(); |
| } |
| |
| private AttributeCache.Entry getCachedAnimations(WindowManager.LayoutParams lp) { |
| if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: layout params pkg=" |
| + (lp != null ? lp.packageName : null) |
| + " resId=0x" + (lp != null ? Integer.toHexString(lp.windowAnimations) : null)); |
| if (lp != null && lp.windowAnimations != 0) { |
| // If this is a system resource, don't try to load it from the |
| // application resources. It is nice to avoid loading application |
| // resources if we can. |
| String packageName = lp.packageName != null ? lp.packageName : "android"; |
| int resId = lp.windowAnimations; |
| if ((resId&0xFF000000) == 0x01000000) { |
| packageName = "android"; |
| } |
| if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: picked package=" |
| + packageName); |
| return AttributeCache.instance().get(packageName, resId, |
| com.android.internal.R.styleable.WindowAnimation, mCurrentUserId); |
| } |
| return null; |
| } |
| |
| private AttributeCache.Entry getCachedAnimations(String packageName, int resId) { |
| if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: package=" |
| + packageName + " resId=0x" + Integer.toHexString(resId)); |
| if (packageName != null) { |
| if ((resId&0xFF000000) == 0x01000000) { |
| packageName = "android"; |
| } |
| if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: picked package=" |
| + packageName); |
| return AttributeCache.instance().get(packageName, resId, |
| com.android.internal.R.styleable.WindowAnimation, mCurrentUserId); |
| } |
| return null; |
| } |
| |
| Animation loadAnimation(WindowManager.LayoutParams lp, int animAttr) { |
| int anim = 0; |
| Context context = mContext; |
| if (animAttr >= 0) { |
| AttributeCache.Entry ent = getCachedAnimations(lp); |
| if (ent != null) { |
| context = ent.context; |
| anim = ent.array.getResourceId(animAttr, 0); |
| } |
| } |
| if (anim != 0) { |
| return AnimationUtils.loadAnimation(context, anim); |
| } |
| return null; |
| } |
| |
| private Animation loadAnimation(String packageName, int resId) { |
| int anim = 0; |
| Context context = mContext; |
| if (resId >= 0) { |
| AttributeCache.Entry ent = getCachedAnimations(packageName, resId); |
| if (ent != null) { |
| context = ent.context; |
| anim = resId; |
| } |
| } |
| if (anim != 0) { |
| return AnimationUtils.loadAnimation(context, anim); |
| } |
| return null; |
| } |
| |
| /** |
| * Compute the pivot point for an animation that is scaling from a small |
| * rect on screen to a larger rect. The pivot point varies depending on |
| * the distance between the inner and outer edges on both sides. This |
| * function computes the pivot point for one dimension. |
| * @param startPos Offset from left/top edge of outer rectangle to |
| * left/top edge of inner rectangle. |
| * @param finalScale The scaling factor between the size of the outer |
| * and inner rectangles. |
| */ |
| private static float computePivot(int startPos, float finalScale) { |
| final float denom = finalScale-1; |
| if (Math.abs(denom) < .0001f) { |
| return startPos; |
| } |
| return -startPos / denom; |
| } |
| |
| private Animation createScaleUpAnimationLocked(int transit, boolean enter, |
| int appWidth, int appHeight) { |
| Animation a = null; |
| if (enter) { |
| // Entering app zooms out from the center of the initial rect. |
| float scaleW = mNextAppTransitionStartWidth / (float) appWidth; |
| float scaleH = mNextAppTransitionStartHeight / (float) appHeight; |
| Animation scale = new ScaleAnimation(scaleW, 1, scaleH, 1, |
| computePivot(mNextAppTransitionStartX, scaleW), |
| computePivot(mNextAppTransitionStartY, scaleH)); |
| scale.setInterpolator(mDecelerateInterpolator); |
| |
| Animation alpha = new AlphaAnimation(0, 1); |
| alpha.setInterpolator(mThumbnailFadeoutInterpolator); |
| |
| AnimationSet set = new AnimationSet(false); |
| set.addAnimation(scale); |
| set.addAnimation(alpha); |
| set.setDetachWallpaper(true); |
| a = set; |
| } else if (transit == TRANSIT_WALLPAPER_INTRA_OPEN || |
| transit == TRANSIT_WALLPAPER_INTRA_CLOSE) { |
| // If we are on top of the wallpaper, we need an animation that |
| // correctly handles the wallpaper staying static behind all of |
| // the animated elements. To do this, will just have the existing |
| // element fade out. |
| a = new AlphaAnimation(1, 0); |
| a.setDetachWallpaper(true); |
| } else { |
| // For normal animations, the exiting element just holds in place. |
| a = new AlphaAnimation(1, 1); |
| } |
| |
| // Pick the desired duration. If this is an inter-activity transition, |
| // it is the standard duration for that. Otherwise we use the longer |
| // task transition duration. |
| final long duration; |
| switch (transit) { |
| case TRANSIT_ACTIVITY_OPEN: |
| case TRANSIT_ACTIVITY_CLOSE: |
| duration = mConfigShortAnimTime; |
| break; |
| default: |
| duration = DEFAULT_APP_TRANSITION_DURATION; |
| break; |
| } |
| a.setDuration(duration); |
| a.setFillAfter(true); |
| a.setInterpolator(mDecelerateInterpolator); |
| a.initialize(appWidth, appHeight, appWidth, appHeight); |
| return a; |
| } |
| |
| Animation createThumbnailAnimationLocked(int transit, boolean enter, boolean thumb, |
| int appWidth, int appHeight) { |
| Animation a; |
| final int thumbWidthI = mNextAppTransitionThumbnail.getWidth(); |
| final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1; |
| final int thumbHeightI = mNextAppTransitionThumbnail.getHeight(); |
| final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1; |
| if (thumb) { |
| // Animation for zooming thumbnail from its initial size to |
| // filling the screen. |
| if (mNextAppTransitionScaleUp) { |
| float scaleW = appWidth / thumbWidth; |
| float scaleH = appHeight / thumbHeight; |
| Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH, |
| computePivot(mNextAppTransitionStartX, 1 / scaleW), |
| computePivot(mNextAppTransitionStartY, 1 / scaleH)); |
| scale.setInterpolator(mDecelerateInterpolator); |
| |
| Animation alpha = new AlphaAnimation(1, 0); |
| alpha.setInterpolator(mThumbnailFadeoutInterpolator); |
| |
| // This AnimationSet uses the Interpolators assigned above. |
| AnimationSet set = new AnimationSet(false); |
| set.addAnimation(scale); |
| set.addAnimation(alpha); |
| a = set; |
| } else { |
| float scaleW = appWidth / thumbWidth; |
| float scaleH = appHeight / thumbHeight; |
| a = new ScaleAnimation(scaleW, 1, scaleH, 1, |
| computePivot(mNextAppTransitionStartX, 1 / scaleW), |
| computePivot(mNextAppTransitionStartY, 1 / scaleH)); |
| } |
| } else if (enter) { |
| // Entering app zooms out from the center of the thumbnail. |
| if (mNextAppTransitionScaleUp) { |
| float scaleW = thumbWidth / appWidth; |
| float scaleH = thumbHeight / appHeight; |
| a = new ScaleAnimation(scaleW, 1, scaleH, 1, |
| computePivot(mNextAppTransitionStartX, scaleW), |
| computePivot(mNextAppTransitionStartY, scaleH)); |
| } else { |
| // noop animation |
| a = new AlphaAnimation(1, 1); |
| } |
| } else { |
| // Exiting app |
| if (mNextAppTransitionScaleUp) { |
| if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) { |
| // Fade out while bringing up selected activity. This keeps the |
| // current activity from showing through a launching wallpaper |
| // activity. |
| a = new AlphaAnimation(1, 0); |
| } else { |
| // noop animation |
| a = new AlphaAnimation(1, 1); |
| } |
| } else { |
| float scaleW = thumbWidth / appWidth; |
| float scaleH = thumbHeight / appHeight; |
| Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH, |
| computePivot(mNextAppTransitionStartX, scaleW), |
| computePivot(mNextAppTransitionStartY, scaleH)); |
| |
| Animation alpha = new AlphaAnimation(1, 0); |
| |
| AnimationSet set = new AnimationSet(true); |
| set.addAnimation(scale); |
| set.addAnimation(alpha); |
| set.setZAdjustment(Animation.ZORDER_TOP); |
| a = set; |
| } |
| } |
| |
| // Pick the desired duration. If this is an inter-activity transition, |
| // it is the standard duration for that. Otherwise we use the longer |
| // task transition duration. |
| final long duration; |
| switch (transit) { |
| case TRANSIT_ACTIVITY_OPEN: |
| case TRANSIT_ACTIVITY_CLOSE: |
| duration = mConfigShortAnimTime; |
| break; |
| default: |
| duration = DEFAULT_APP_TRANSITION_DURATION; |
| break; |
| } |
| a.setDuration(duration); |
| a.setFillAfter(true); |
| a.setInterpolator(mDecelerateInterpolator); |
| a.initialize(appWidth, appHeight, appWidth, appHeight); |
| return a; |
| } |
| |
| |
| Animation loadAnimation(WindowManager.LayoutParams lp, int transit, boolean enter, |
| int appWidth, int appHeight) { |
| Animation a; |
| if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM) { |
| a = loadAnimation(mNextAppTransitionPackage, enter ? |
| mNextAppTransitionEnter : mNextAppTransitionExit); |
| if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, |
| "applyAnimation:" |
| + " anim=" + a + " nextAppTransition=ANIM_CUSTOM" |
| + " transit=" + transit + " isEntrance=" + enter |
| + " Callers=" + Debug.getCallers(3)); |
| } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_SCALE_UP) { |
| a = createScaleUpAnimationLocked(transit, enter, appWidth, appHeight); |
| if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, |
| "applyAnimation:" |
| + " anim=" + a + " nextAppTransition=ANIM_SCALE_UP" |
| + " transit=" + transit + " isEntrance=" + enter |
| + " Callers=" + Debug.getCallers(3)); |
| } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP || |
| mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN) { |
| mNextAppTransitionScaleUp = |
| (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP); |
| a = createThumbnailAnimationLocked(transit, enter, false, appWidth, appHeight); |
| if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) { |
| String animName = mNextAppTransitionScaleUp ? |
| "ANIM_THUMBNAIL_SCALE_UP" : "ANIM_THUMBNAIL_SCALE_DOWN"; |
| Slog.v(TAG, "applyAnimation:" |
| + " anim=" + a + " nextAppTransition=" + animName |
| + " transit=" + transit + " isEntrance=" + enter |
| + " Callers=" + Debug.getCallers(3)); |
| } |
| } else { |
| int animAttr = 0; |
| switch (transit) { |
| case TRANSIT_ACTIVITY_OPEN: |
| animAttr = enter |
| ? WindowAnimation_activityOpenEnterAnimation |
| : WindowAnimation_activityOpenExitAnimation; |
| break; |
| case TRANSIT_ACTIVITY_CLOSE: |
| animAttr = enter |
| ? WindowAnimation_activityCloseEnterAnimation |
| : WindowAnimation_activityCloseExitAnimation; |
| break; |
| case TRANSIT_TASK_OPEN: |
| animAttr = enter |
| ? WindowAnimation_taskOpenEnterAnimation |
| : WindowAnimation_taskOpenExitAnimation; |
| break; |
| case TRANSIT_TASK_CLOSE: |
| animAttr = enter |
| ? WindowAnimation_taskCloseEnterAnimation |
| : WindowAnimation_taskCloseExitAnimation; |
| break; |
| case TRANSIT_TASK_TO_FRONT: |
| animAttr = enter |
| ? WindowAnimation_taskToFrontEnterAnimation |
| : WindowAnimation_taskToFrontExitAnimation; |
| break; |
| case TRANSIT_TASK_TO_BACK: |
| animAttr = enter |
| ? WindowAnimation_taskToBackEnterAnimation |
| : WindowAnimation_taskToBackExitAnimation; |
| break; |
| case TRANSIT_WALLPAPER_OPEN: |
| animAttr = enter |
| ? WindowAnimation_wallpaperOpenEnterAnimation |
| : WindowAnimation_wallpaperOpenExitAnimation; |
| break; |
| case TRANSIT_WALLPAPER_CLOSE: |
| animAttr = enter |
| ? WindowAnimation_wallpaperCloseEnterAnimation |
| : WindowAnimation_wallpaperCloseExitAnimation; |
| break; |
| case TRANSIT_WALLPAPER_INTRA_OPEN: |
| animAttr = enter |
| ? WindowAnimation_wallpaperIntraOpenEnterAnimation |
| : WindowAnimation_wallpaperIntraOpenExitAnimation; |
| break; |
| case TRANSIT_WALLPAPER_INTRA_CLOSE: |
| animAttr = enter |
| ? WindowAnimation_wallpaperIntraCloseEnterAnimation |
| : WindowAnimation_wallpaperIntraCloseExitAnimation; |
| break; |
| } |
| a = animAttr != 0 ? loadAnimation(lp, animAttr) : null; |
| if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, |
| "applyAnimation:" |
| + " anim=" + a |
| + " animAttr=0x" + Integer.toHexString(animAttr) |
| + " transit=" + transit + " isEntrance=" + enter |
| + " Callers=" + Debug.getCallers(3)); |
| } |
| return a; |
| } |
| |
| void postAnimationCallback() { |
| if (mNextAppTransitionCallback != null) { |
| mH.sendMessage(mH.obtainMessage(H.DO_ANIMATION_CALLBACK, mNextAppTransitionCallback)); |
| mNextAppTransitionCallback = null; |
| } |
| } |
| |
| void overridePendingAppTransition(String packageName, int enterAnim, int exitAnim, |
| IRemoteCallback startedCallback) { |
| if (isTransitionSet()) { |
| mNextAppTransitionType = NEXT_TRANSIT_TYPE_CUSTOM; |
| mNextAppTransitionPackage = packageName; |
| mNextAppTransitionThumbnail = null; |
| mNextAppTransitionEnter = enterAnim; |
| mNextAppTransitionExit = exitAnim; |
| postAnimationCallback(); |
| mNextAppTransitionCallback = startedCallback; |
| } else { |
| postAnimationCallback(); |
| } |
| } |
| |
| void overridePendingAppTransitionScaleUp(int startX, int startY, int startWidth, |
| int startHeight) { |
| if (isTransitionSet()) { |
| mNextAppTransitionType = NEXT_TRANSIT_TYPE_SCALE_UP; |
| mNextAppTransitionPackage = null; |
| mNextAppTransitionThumbnail = null; |
| mNextAppTransitionStartX = startX; |
| mNextAppTransitionStartY = startY; |
| mNextAppTransitionStartWidth = startWidth; |
| mNextAppTransitionStartHeight = startHeight; |
| postAnimationCallback(); |
| mNextAppTransitionCallback = null; |
| } |
| } |
| |
| void overridePendingAppTransitionThumb(Bitmap srcThumb, int startX, int startY, |
| IRemoteCallback startedCallback, boolean scaleUp) { |
| if (isTransitionSet()) { |
| mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP |
| : NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN; |
| mNextAppTransitionPackage = null; |
| mNextAppTransitionThumbnail = srcThumb; |
| mNextAppTransitionScaleUp = scaleUp; |
| mNextAppTransitionStartX = startX; |
| mNextAppTransitionStartY = startY; |
| postAnimationCallback(); |
| mNextAppTransitionCallback = startedCallback; |
| } else { |
| postAnimationCallback(); |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return "mNextAppTransition=0x" + Integer.toHexString(mNextAppTransition); |
| } |
| |
| /** |
| * Returns the human readable name of a window transition. |
| * |
| * @param transition The window transition. |
| * @return The transition symbolic name. |
| */ |
| public static String appTransitionToString(int transition) { |
| switch (transition) { |
| case TRANSIT_UNSET: { |
| return "TRANSIT_UNSET"; |
| } |
| case TRANSIT_NONE: { |
| return "TRANSIT_NONE"; |
| } |
| case TRANSIT_EXIT_MASK: { |
| return "TRANSIT_EXIT_MASK"; |
| } |
| case TRANSIT_ACTIVITY_OPEN: { |
| return "TRANSIT_ACTIVITY_OPEN"; |
| } |
| case TRANSIT_ACTIVITY_CLOSE: { |
| return "TRANSIT_ACTIVITY_CLOSE"; |
| } |
| case TRANSIT_TASK_OPEN: { |
| return "TRANSIT_TASK_OPEN"; |
| } |
| case TRANSIT_TASK_CLOSE: { |
| return "TRANSIT_TASK_CLOSE"; |
| } |
| case TRANSIT_TASK_TO_FRONT: { |
| return "TRANSIT_TASK_TO_FRONT"; |
| } |
| case TRANSIT_TASK_TO_BACK: { |
| return "TRANSIT_TASK_TO_BACK"; |
| } |
| case TRANSIT_WALLPAPER_CLOSE: { |
| return "TRANSIT_WALLPAPER_CLOSE"; |
| } |
| case TRANSIT_WALLPAPER_OPEN: { |
| return "TRANSIT_WALLPAPER_OPEN"; |
| } |
| case TRANSIT_WALLPAPER_INTRA_OPEN: { |
| return "TRANSIT_WALLPAPER_INTRA_OPEN"; |
| } |
| case TRANSIT_WALLPAPER_INTRA_CLOSE: { |
| return "TRANSIT_WALLPAPER_INTRA_CLOSE"; |
| } |
| default: { |
| return "<UNKNOWN>"; |
| } |
| } |
| } |
| |
| private String appStateToString() { |
| switch (mAppTransitionState) { |
| case APP_STATE_IDLE: |
| return "APP_STATE_IDLE"; |
| case APP_STATE_READY: |
| return "APP_STATE_READY"; |
| case APP_STATE_RUNNING: |
| return "APP_STATE_RUNNING"; |
| case APP_STATE_TIMEOUT: |
| return "APP_STATE_TIMEOUT"; |
| default: |
| return "unknown state=" + mAppTransitionState; |
| } |
| } |
| |
| private String transitTypeToString() { |
| switch (mNextAppTransitionType) { |
| case NEXT_TRANSIT_TYPE_NONE: |
| return "NEXT_TRANSIT_TYPE_NONE"; |
| case NEXT_TRANSIT_TYPE_CUSTOM: |
| return "NEXT_TRANSIT_TYPE_CUSTOM"; |
| case NEXT_TRANSIT_TYPE_SCALE_UP: |
| return "NEXT_TRANSIT_TYPE_SCALE_UP"; |
| case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP: |
| return "NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP"; |
| case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN: |
| return "NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN"; |
| default: |
| return "unknown type=" + mNextAppTransitionType; |
| } |
| } |
| |
| @Override |
| public void dump(PrintWriter pw) { |
| pw.print(" " + this); |
| pw.print(" mAppTransitionState="); pw.println(appStateToString()); |
| if (mNextAppTransitionType != NEXT_TRANSIT_TYPE_NONE) { |
| pw.print(" mNextAppTransitionType="); pw.println(transitTypeToString()); |
| } |
| switch (mNextAppTransitionType) { |
| case NEXT_TRANSIT_TYPE_CUSTOM: |
| pw.print(" mNextAppTransitionPackage="); |
| pw.println(mNextAppTransitionPackage); |
| pw.print(" mNextAppTransitionEnter=0x"); |
| pw.print(Integer.toHexString(mNextAppTransitionEnter)); |
| pw.print(" mNextAppTransitionExit=0x"); |
| pw.println(Integer.toHexString(mNextAppTransitionExit)); |
| break; |
| case NEXT_TRANSIT_TYPE_SCALE_UP: |
| pw.print(" mNextAppTransitionStartX="); pw.print(mNextAppTransitionStartX); |
| pw.print(" mNextAppTransitionStartY="); |
| pw.println(mNextAppTransitionStartY); |
| pw.print(" mNextAppTransitionStartWidth="); |
| pw.print(mNextAppTransitionStartWidth); |
| pw.print(" mNextAppTransitionStartHeight="); |
| pw.println(mNextAppTransitionStartHeight); |
| break; |
| case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP: |
| case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN: |
| pw.print(" mNextAppTransitionThumbnail="); |
| pw.print(mNextAppTransitionThumbnail); |
| pw.print(" mNextAppTransitionStartX="); |
| pw.print(mNextAppTransitionStartX); |
| pw.print(" mNextAppTransitionStartY="); |
| pw.println(mNextAppTransitionStartY); |
| pw.print(" mNextAppTransitionScaleUp="); pw.println(mNextAppTransitionScaleUp); |
| break; |
| } |
| if (mNextAppTransitionCallback != null) { |
| pw.print(" mNextAppTransitionCallback="); |
| pw.println(mNextAppTransitionCallback); |
| } |
| } |
| |
| public void setCurrentUser(int newUserId) { |
| mCurrentUserId = newUserId; |
| } |
| } |