/* * 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 static android.view.WindowManagerInternal.AppTransitionListener; 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_activityOpenEnterAnimation; import static com.android.internal.R.styleable.WindowAnimation_activityOpenExitAnimation; import static com.android.internal.R.styleable.WindowAnimation_launchTaskBehindSourceAnimation; import static com.android.internal.R.styleable.WindowAnimation_launchTaskBehindTargetAnimation; 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_taskOpenEnterAnimation; import static com.android.internal.R.styleable.WindowAnimation_taskOpenExitAnimation; 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_taskToFrontEnterAnimation; import static com.android.internal.R.styleable.WindowAnimation_taskToFrontExitAnimation; 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_wallpaperIntraCloseEnterAnimation; import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseExitAnimation; 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_wallpaperOpenEnterAnimation; import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenExitAnimation; import static com.android.server.wm.AppWindowAnimator.PROLONG_ANIMATION_AT_START; import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ANIM; import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_APP_TRANSITIONS; import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME; import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM; import static com.android.server.wm.WindowStateAnimator.STACK_CLIP_NONE; import static com.android.server.wm.WindowStateAnimator.STACK_CLIP_AFTER_ANIM; import android.annotation.Nullable; import android.content.Context; import android.content.res.Configuration; import android.graphics.Bitmap; import android.graphics.Path; import android.graphics.Rect; import android.os.Debug; import android.os.IBinder; import android.os.IRemoteCallback; import android.os.RemoteException; import android.util.ArraySet; import android.util.Slog; import android.util.SparseArray; import android.view.AppTransitionAnimationSpec; import android.view.IAppTransitionAnimationSpecsFuture; 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.ClipRectAnimation; import android.view.animation.Interpolator; import android.view.animation.PathInterpolator; import android.view.animation.ScaleAnimation; import android.view.animation.TranslateAnimation; import com.android.internal.util.DumpUtils.Dump; import com.android.server.AttributeCache; import com.android.server.wm.WindowManagerService.H; import com.android.server.wm.animation.ClipRectLRAnimation; import com.android.server.wm.animation.ClipRectTBAnimation; import com.android.server.wm.animation.CurvedTranslateAnimation; import java.io.PrintWriter; import java.util.ArrayList; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; // 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 = TAG_WITH_CLASS_NAME ? "AppTransition" : TAG_WM; private static final int CLIP_REVEAL_TRANSLATION_Y_DP = 8; /** 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; /** 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; /** 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; /** 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; /** 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; /** A window in an existing task is being put below all other tasks. */ public static final int TRANSIT_TASK_TO_BACK = 11; /** 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; /** 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; /** 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; /** 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; /** A window in a new task is being opened behind an existing one in another activity's task. * The new window will show briefly and then be gone. */ public static final int TRANSIT_TASK_OPEN_BEHIND = 16; /** A window in a task is being animated in-place. */ public static final int TRANSIT_TASK_IN_PLACE = 17; /** An activity is being relaunched (e.g. due to configuration change). */ public static final int TRANSIT_ACTIVITY_RELAUNCH = 18; /** A task is being docked from recents. */ public static final int TRANSIT_DOCK_TASK_FROM_RECENTS = 19; /** Fraction of animation at which the recents thumbnail stays completely transparent */ private static final float RECENTS_THUMBNAIL_FADEIN_FRACTION = 0.5f; /** Fraction of animation at which the recents thumbnail becomes completely transparent */ private static final float RECENTS_THUMBNAIL_FADEOUT_FRACTION = 0.5f; static final int DEFAULT_APP_TRANSITION_DURATION = 336; /** Interpolator to be used for animations that respond directly to a touch */ static final Interpolator TOUCH_RESPONSE_INTERPOLATOR = new PathInterpolator(0.3f, 0f, 0.1f, 1f); private static final Interpolator THUMBNAIL_DOCK_INTERPOLATOR = new PathInterpolator(0.85f, 0f, 1f, 1f); /** * Maximum duration for the clip reveal animation. This is used when there is a lot of movement * involved, to make it more understandable. */ private static final int MAX_CLIP_REVEAL_TRANSITION_DURATION = 420; private static final int THUMBNAIL_APP_TRANSITION_DURATION = 336; private static final long APP_TRANSITION_TIMEOUT_MS = 5000; private final Context mContext; private final WindowManagerService mService; private int mNextAppTransition = TRANSIT_UNSET; private int mLastUsedAppTransition = TRANSIT_UNSET; private String mLastOpeningApp; private String mLastClosingApp; 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 static final int NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP = 5; private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN = 6; private static final int NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE = 7; private static final int NEXT_TRANSIT_TYPE_CLIP_REVEAL = 8; private int mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE; // These are the possible states for the enter/exit activities during a thumbnail transition private static final int THUMBNAIL_TRANSITION_ENTER_SCALE_UP = 0; private static final int THUMBNAIL_TRANSITION_EXIT_SCALE_UP = 1; private static final int THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN = 2; private static final int THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN = 3; private String mNextAppTransitionPackage; // Used for thumbnail transitions. True if we're scaling up, false if scaling down private boolean mNextAppTransitionScaleUp; private IRemoteCallback mNextAppTransitionCallback; private IRemoteCallback mNextAppTransitionFutureCallback; private IRemoteCallback mAnimationFinishedCallback; private int mNextAppTransitionEnter; private int mNextAppTransitionExit; private int mNextAppTransitionInPlace; // Keyed by task id. private final SparseArray mNextAppTransitionAnimationsSpecs = new SparseArray<>(); private IAppTransitionAnimationSpecsFuture mNextAppTransitionAnimationsSpecsFuture; private boolean mNextAppTransitionAnimationsSpecsPending; private AppTransitionAnimationSpec mDefaultNextAppTransitionAnimationSpec; private Rect mNextAppTransitionInsets = new Rect(); private Rect mTmpFromClipRect = new Rect(); private Rect mTmpToClipRect = new Rect(); private final Rect mTmpRect = new Rect(); 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 mThumbnailFadeInInterpolator; private final Interpolator mThumbnailFadeOutInterpolator; private final Interpolator mLinearOutSlowInInterpolator; private final Interpolator mFastOutLinearInInterpolator; private final Interpolator mFastOutSlowInInterpolator; private final Interpolator mClipHorizontalInterpolator = new PathInterpolator(0, 0, 0.4f, 1f); private final int mClipRevealTranslationY; private int mCurrentUserId = 0; private long mLastClipRevealTransitionDuration = DEFAULT_APP_TRANSITION_DURATION; private final ArrayList mListeners = new ArrayList<>(); private final ExecutorService mDefaultExecutor = Executors.newSingleThreadExecutor(); private int mLastClipRevealMaxTranslation; private boolean mLastHadClipReveal; private boolean mProlongedAnimationsEnded; AppTransition(Context context, WindowManagerService service) { mContext = context; mService = service; mLinearOutSlowInInterpolator = AnimationUtils.loadInterpolator(context, com.android.internal.R.interpolator.linear_out_slow_in); mFastOutLinearInInterpolator = AnimationUtils.loadInterpolator(context, com.android.internal.R.interpolator.fast_out_linear_in); mFastOutSlowInInterpolator = AnimationUtils.loadInterpolator(context, com.android.internal.R.interpolator.fast_out_slow_in); mConfigShortAnimTime = context.getResources().getInteger( com.android.internal.R.integer.config_shortAnimTime); mDecelerateInterpolator = AnimationUtils.loadInterpolator(context, com.android.internal.R.interpolator.decelerate_cubic); mThumbnailFadeInInterpolator = new Interpolator() { @Override public float getInterpolation(float input) { // Linear response for first fraction, then complete after that. if (input < RECENTS_THUMBNAIL_FADEIN_FRACTION) { return 0f; } float t = (input - RECENTS_THUMBNAIL_FADEIN_FRACTION) / (1f - RECENTS_THUMBNAIL_FADEIN_FRACTION); return mFastOutLinearInInterpolator.getInterpolation(t); } }; mThumbnailFadeOutInterpolator = new Interpolator() { @Override public float getInterpolation(float input) { // Linear response for first fraction, then complete after that. if (input < RECENTS_THUMBNAIL_FADEOUT_FRACTION) { float t = input / RECENTS_THUMBNAIL_FADEOUT_FRACTION; return mLinearOutSlowInInterpolator.getInterpolation(t); } return 1f; } }; mClipRevealTranslationY = (int) (CLIP_REVEAL_TRANSLATION_Y_DP * mContext.getResources().getDisplayMetrics().density); } boolean isTransitionSet() { return mNextAppTransition != TRANSIT_UNSET; } boolean isTransitionEqual(int transit) { return mNextAppTransition == transit; } int getAppTransition() { return mNextAppTransition; } private void setAppTransition(int transit) { mNextAppTransition = transit; setLastAppTransition(TRANSIT_UNSET, null, null); } void setLastAppTransition(int transit, AppWindowToken openingApp, AppWindowToken closingApp) { mLastUsedAppTransition = transit; mLastOpeningApp = "" + openingApp; mLastClosingApp = "" + closingApp; } boolean isReady() { return mAppTransitionState == APP_STATE_READY || mAppTransitionState == APP_STATE_TIMEOUT; } void setReady() { mAppTransitionState = APP_STATE_READY; fetchAppTransitionSpecsFromFuture(); } 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 getAppTransitionThumbnailHeader(int taskId) { AppTransitionAnimationSpec spec = mNextAppTransitionAnimationsSpecs.get(taskId); if (spec == null) { spec = mDefaultNextAppTransitionAnimationSpec; } return spec != null ? spec.bitmap : null; } /** Returns whether the next thumbnail transition is aspect scaled up. */ boolean isNextThumbnailTransitionAspectScaled() { return mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP || mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN; } /** Returns whether the next thumbnail transition is scaling up. */ boolean isNextThumbnailTransitionScaleUp() { return mNextAppTransitionScaleUp; } boolean isNextAppTransitionThumbnailUp() { return mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP || mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP; } boolean isNextAppTransitionThumbnailDown() { return mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN || mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN; } /** * @return true if and only if we are currently fetching app transition specs from the future * passed into {@link #overridePendingAppTransitionMultiThumbFuture} */ boolean isFetchingAppTransitionsSpecs() { return mNextAppTransitionAnimationsSpecsPending; } private boolean prepare() { if (!isRunning()) { mAppTransitionState = APP_STATE_IDLE; notifyAppTransitionPendingLocked(); mLastHadClipReveal = false; mLastClipRevealMaxTranslation = 0; mLastClipRevealTransitionDuration = DEFAULT_APP_TRANSITION_DURATION; return true; } return false; } void goodToGo(AppWindowAnimator topOpeningAppAnimator, AppWindowAnimator topClosingAppAnimator, ArraySet openingApps, ArraySet closingApps) { int appTransition = mNextAppTransition; mNextAppTransition = TRANSIT_UNSET; mAppTransitionState = APP_STATE_RUNNING; notifyAppTransitionStartingLocked( topOpeningAppAnimator != null ? topOpeningAppAnimator.mAppToken.token : null, topClosingAppAnimator != null ? topClosingAppAnimator.mAppToken.token : null, topOpeningAppAnimator != null ? topOpeningAppAnimator.animation : null, topClosingAppAnimator != null ? topClosingAppAnimator.animation : null); mService.getDefaultDisplayContentLocked().getDockedDividerController() .notifyAppTransitionStarting(openingApps, appTransition); // Prolong the start for the transition when docking a task from recents, unless recents // ended it already then we don't need to wait. if (mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS && !mProlongedAnimationsEnded) { for (int i = openingApps.size() - 1; i >= 0; i--) { final AppWindowAnimator appAnimator = openingApps.valueAt(i).mAppAnimator; appAnimator.startProlongAnimation(PROLONG_ANIMATION_AT_START); } } } /** * Let the transitions manager know that the somebody wanted to end the prolonged animations. */ void notifyProlongedAnimationsEnded() { mProlongedAnimationsEnded = true; } void clear() { mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE; mNextAppTransitionPackage = null; mNextAppTransitionAnimationsSpecs.clear(); mNextAppTransitionAnimationsSpecsFuture = null; mDefaultNextAppTransitionAnimationSpec = null; mAnimationFinishedCallback = null; mProlongedAnimationsEnded = false; } void freeze() { setAppTransition(AppTransition.TRANSIT_UNSET); clear(); setReady(); notifyAppTransitionCancelledLocked(); } void registerListenerLocked(AppTransitionListener listener) { mListeners.add(listener); } public void notifyAppTransitionFinishedLocked(IBinder token) { for (int i = 0; i < mListeners.size(); i++) { mListeners.get(i).onAppTransitionFinishedLocked(token); } } private void notifyAppTransitionPendingLocked() { for (int i = 0; i < mListeners.size(); i++) { mListeners.get(i).onAppTransitionPendingLocked(); } } private void notifyAppTransitionCancelledLocked() { for (int i = 0; i < mListeners.size(); i++) { mListeners.get(i).onAppTransitionCancelledLocked(); } } private void notifyAppTransitionStartingLocked(IBinder openToken, IBinder closeToken, Animation openAnimation, Animation closeAnimation) { for (int i = 0; i < mListeners.size(); i++) { mListeners.get(i).onAppTransitionStartingLocked(openToken, closeToken, openAnimation, closeAnimation); } } 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 loadAnimationAttr(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; } Animation loadAnimationRes(WindowManager.LayoutParams lp, int resId) { Context context = mContext; if (resId >= 0) { AttributeCache.Entry ent = getCachedAnimations(lp); if (ent != null) { context = ent.context; } return AnimationUtils.loadAnimation(context, resId); } return null; } private Animation loadAnimationRes(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) { /* Theorem of intercepting lines: + + +-----------------------------------------------+ | | | | | | | | | | | | | | | | x | y | | | | | | | | | | | | | | | | | | | | + | +--------------------+ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | +--------------------+ | | | | | | | | | | | | | | | | | | | | | | | +-----------------------------------------------+ | | | | | | | | | + ++ p ++ scale = (x - y) / x <=> x = -y / (scale - 1) */ final float denom = finalScale-1; if (Math.abs(denom) < .0001f) { return startPos; } return -startPos / denom; } private Animation createScaleUpAnimationLocked(int transit, boolean enter, Rect containingFrame) { Animation a; getDefaultNextAppTransitionStartRect(mTmpRect); final int appWidth = containingFrame.width(); final int appHeight = containingFrame.height(); if (enter) { // Entering app zooms out from the center of the initial rect. float scaleW = mTmpRect.width() / (float) appWidth; float scaleH = mTmpRect.height() / (float) appHeight; Animation scale = new ScaleAnimation(scaleW, 1, scaleH, 1, computePivot(mTmpRect.left, scaleW), computePivot(mTmpRect.top, 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; } private void getDefaultNextAppTransitionStartRect(Rect rect) { if (mDefaultNextAppTransitionAnimationSpec == null || mDefaultNextAppTransitionAnimationSpec.rect == null) { Slog.wtf(TAG, "Starting rect for app requested, but none available", new Throwable()); rect.setEmpty(); } else { rect.set(mDefaultNextAppTransitionAnimationSpec.rect); } } void getNextAppTransitionStartRect(int taskId, Rect rect) { AppTransitionAnimationSpec spec = mNextAppTransitionAnimationsSpecs.get(taskId); if (spec == null) { spec = mDefaultNextAppTransitionAnimationSpec; } if (spec == null || spec.rect == null) { Slog.wtf(TAG, "Starting rect for task: " + taskId + " requested, but not available", new Throwable()); rect.setEmpty(); } else { rect.set(spec.rect); } } private void putDefaultNextAppTransitionCoordinates(int left, int top, int width, int height, Bitmap bitmap) { mDefaultNextAppTransitionAnimationSpec = new AppTransitionAnimationSpec(-1 /* taskId */, bitmap, new Rect(left, top, left + width, top + height)); } /** * @return the duration of the last clip reveal animation */ long getLastClipRevealTransitionDuration() { return mLastClipRevealTransitionDuration; } /** * @return the maximum distance the app surface is traveling of the last clip reveal animation */ int getLastClipRevealMaxTranslation() { return mLastClipRevealMaxTranslation; } /** * @return true if in the last app transition had a clip reveal animation, false otherwise */ boolean hadClipRevealAnimation() { return mLastHadClipReveal; } /** * Calculates the duration for the clip reveal animation. If the clip is "cut off", meaning that * the start rect is outside of the target rect, and there is a lot of movement going on. * * @param cutOff whether the start rect was not fully contained by the end rect * @param translationX the total translation the surface moves in x direction * @param translationY the total translation the surfaces moves in y direction * @param displayFrame our display frame * * @return the duration of the clip reveal animation, in milliseconds */ private long calculateClipRevealTransitionDuration(boolean cutOff, float translationX, float translationY, Rect displayFrame) { if (!cutOff) { return DEFAULT_APP_TRANSITION_DURATION; } final float fraction = Math.max(Math.abs(translationX) / displayFrame.width(), Math.abs(translationY) / displayFrame.height()); return (long) (DEFAULT_APP_TRANSITION_DURATION + fraction * (MAX_CLIP_REVEAL_TRANSITION_DURATION - DEFAULT_APP_TRANSITION_DURATION)); } private Animation createClipRevealAnimationLocked(int transit, boolean enter, Rect appFrame, Rect displayFrame) { final Animation anim; if (enter) { final int appWidth = appFrame.width(); final int appHeight = appFrame.height(); // mTmpRect will contain an area around the launcher icon that was pressed. We will // clip reveal from that area in the final area of the app. getDefaultNextAppTransitionStartRect(mTmpRect); float t = 0f; if (appHeight > 0) { t = (float) mTmpRect.top / displayFrame.height(); } int translationY = mClipRevealTranslationY + (int)(displayFrame.height() / 7f * t); int translationX = 0; int translationYCorrection = translationY; int centerX = mTmpRect.centerX(); int centerY = mTmpRect.centerY(); int halfWidth = mTmpRect.width() / 2; int halfHeight = mTmpRect.height() / 2; int clipStartX = centerX - halfWidth - appFrame.left; int clipStartY = centerY - halfHeight - appFrame.top; boolean cutOff = false; // If the starting rectangle is fully or partially outside of the target rectangle, we // need to start the clipping at the edge and then achieve the rest with translation // and extending the clip rect from that edge. if (appFrame.top > centerY - halfHeight) { translationY = (centerY - halfHeight) - appFrame.top; translationYCorrection = 0; clipStartY = 0; cutOff = true; } if (appFrame.left > centerX - halfWidth) { translationX = (centerX - halfWidth) - appFrame.left; clipStartX = 0; cutOff = true; } if (appFrame.right < centerX + halfWidth) { translationX = (centerX + halfWidth) - appFrame.right; clipStartX = appWidth - mTmpRect.width(); cutOff = true; } final long duration = calculateClipRevealTransitionDuration(cutOff, translationX, translationY, displayFrame); // Clip third of the from size of launch icon, expand to full width/height Animation clipAnimLR = new ClipRectLRAnimation( clipStartX, clipStartX + mTmpRect.width(), 0, appWidth); clipAnimLR.setInterpolator(mClipHorizontalInterpolator); clipAnimLR.setDuration((long) (duration / 2.5f)); TranslateAnimation translate = new TranslateAnimation(translationX, 0, translationY, 0); translate.setInterpolator(cutOff ? TOUCH_RESPONSE_INTERPOLATOR : mLinearOutSlowInInterpolator); translate.setDuration(duration); Animation clipAnimTB = new ClipRectTBAnimation( clipStartY, clipStartY + mTmpRect.height(), 0, appHeight, translationYCorrection, 0, mLinearOutSlowInInterpolator); clipAnimTB.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR); clipAnimTB.setDuration(duration); // Quick fade-in from icon to app window final long alphaDuration = duration / 4; AlphaAnimation alpha = new AlphaAnimation(0.5f, 1); alpha.setDuration(alphaDuration); alpha.setInterpolator(mLinearOutSlowInInterpolator); AnimationSet set = new AnimationSet(false); set.addAnimation(clipAnimLR); set.addAnimation(clipAnimTB); set.addAnimation(translate); set.addAnimation(alpha); set.setZAdjustment(Animation.ZORDER_TOP); set.initialize(appWidth, appHeight, appWidth, appHeight); anim = set; mLastHadClipReveal = true; mLastClipRevealTransitionDuration = duration; // If the start rect was full inside the target rect (cutOff == false), we don't need // to store the translation, because it's only used if cutOff == true. mLastClipRevealMaxTranslation = cutOff ? Math.max(Math.abs(translationY), Math.abs(translationX)) : 0; } else { final long duration; switch (transit) { case TRANSIT_ACTIVITY_OPEN: case TRANSIT_ACTIVITY_CLOSE: duration = mConfigShortAnimTime; break; default: duration = DEFAULT_APP_TRANSITION_DURATION; break; } 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. anim = new AlphaAnimation(1, 0); anim.setDetachWallpaper(true); } else { // For normal animations, the exiting element just holds in place. anim = new AlphaAnimation(1, 1); } anim.setInterpolator(mDecelerateInterpolator); anim.setDuration(duration); anim.setFillAfter(true); } return anim; } /** * Prepares the specified animation with a standard duration, interpolator, etc. */ Animation prepareThumbnailAnimationWithDuration(Animation a, int appWidth, int appHeight, long duration, Interpolator interpolator) { if (duration > 0) { a.setDuration(duration); } a.setFillAfter(true); if (interpolator != null) { a.setInterpolator(interpolator); } a.initialize(appWidth, appHeight, appWidth, appHeight); return a; } /** * Prepares the specified animation with a standard duration, interpolator, etc. */ Animation prepareThumbnailAnimation(Animation a, int appWidth, int appHeight, int transit) { // 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 int duration; switch (transit) { case TRANSIT_ACTIVITY_OPEN: case TRANSIT_ACTIVITY_CLOSE: duration = mConfigShortAnimTime; break; default: duration = DEFAULT_APP_TRANSITION_DURATION; break; } return prepareThumbnailAnimationWithDuration(a, appWidth, appHeight, duration, mDecelerateInterpolator); } /** * Return the current thumbnail transition state. */ int getThumbnailTransitionState(boolean enter) { if (enter) { if (mNextAppTransitionScaleUp) { return THUMBNAIL_TRANSITION_ENTER_SCALE_UP; } else { return THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN; } } else { if (mNextAppTransitionScaleUp) { return THUMBNAIL_TRANSITION_EXIT_SCALE_UP; } else { return THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN; } } } /** * This animation runs for the thumbnail that gets cross faded with the enter/exit activity * when a thumbnail is specified with the pending animation override. */ Animation createThumbnailAspectScaleAnimationLocked(Rect appRect, @Nullable Rect contentInsets, Bitmap thumbnailHeader, final int taskId, int uiMode, int orientation) { Animation a; final int thumbWidthI = thumbnailHeader.getWidth(); final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1; final int thumbHeightI = thumbnailHeader.getHeight(); final int appWidth = appRect.width(); float scaleW = appWidth / thumbWidth; getNextAppTransitionStartRect(taskId, mTmpRect); final float fromX; final float fromY; final float toX; final float toY; final float pivotX; final float pivotY; if (isTvUiMode(uiMode) || orientation == Configuration.ORIENTATION_PORTRAIT) { fromX = mTmpRect.left; fromY = mTmpRect.top; // For the curved translate animation to work, the pivot points needs to be at the // same absolute position as the one from the real surface. toX = mTmpRect.width() / 2 * (scaleW - 1f) + appRect.left; toY = appRect.height() / 2 * (1 - 1 / scaleW) + appRect.top; pivotX = mTmpRect.width() / 2; pivotY = appRect.height() / 2 / scaleW; } else { pivotX = 0; pivotY = 0; fromX = mTmpRect.left; fromY = mTmpRect.top; toX = appRect.left; toY = appRect.top; } final long duration = getAspectScaleDuration(); final Interpolator interpolator = getAspectScaleInterpolator(); if (mNextAppTransitionScaleUp) { // Animation up from the thumbnail to the full screen Animation scale = new ScaleAnimation(1f, scaleW, 1f, scaleW, pivotX, pivotY); scale.setInterpolator(interpolator); scale.setDuration(duration); Animation alpha = new AlphaAnimation(1f, 0f); alpha.setInterpolator(mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS ? THUMBNAIL_DOCK_INTERPOLATOR : mThumbnailFadeOutInterpolator); alpha.setDuration(mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS ? duration / 2 : duration); Animation translate = createCurvedMotion(fromX, toX, fromY, toY); translate.setInterpolator(interpolator); translate.setDuration(duration); mTmpFromClipRect.set(0, 0, thumbWidthI, thumbHeightI); mTmpToClipRect.set(appRect); // Containing frame is in screen space, but we need the clip rect in the // app space. mTmpToClipRect.offsetTo(0, 0); mTmpToClipRect.right = (int) (mTmpToClipRect.right / scaleW); mTmpToClipRect.bottom = (int) (mTmpToClipRect.bottom / scaleW); if (contentInsets != null) { mTmpToClipRect.inset((int) (-contentInsets.left * scaleW), (int) (-contentInsets.top * scaleW), (int) (-contentInsets.right * scaleW), (int) (-contentInsets.bottom * scaleW)); } Animation clipAnim = new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect); clipAnim.setInterpolator(interpolator); clipAnim.setDuration(duration); // This AnimationSet uses the Interpolators assigned above. AnimationSet set = new AnimationSet(false); set.addAnimation(scale); set.addAnimation(alpha); set.addAnimation(translate); set.addAnimation(clipAnim); a = set; } else { // Animation down from the full screen to the thumbnail Animation scale = new ScaleAnimation(scaleW, 1f, scaleW, 1f, pivotX, pivotY); scale.setInterpolator(interpolator); scale.setDuration(duration); Animation alpha = new AlphaAnimation(0f, 1f); alpha.setInterpolator(mThumbnailFadeInInterpolator); alpha.setDuration(duration); Animation translate = createCurvedMotion(toX, fromX, toY, fromY); translate.setInterpolator(interpolator); translate.setDuration(duration); // This AnimationSet uses the Interpolators assigned above. AnimationSet set = new AnimationSet(false); set.addAnimation(scale); set.addAnimation(alpha); set.addAnimation(translate); a = set; } return prepareThumbnailAnimationWithDuration(a, appWidth, appRect.height(), 0, null); } private Animation createCurvedMotion(float fromX, float toX, float fromY, float toY) { // Almost no x-change - use linear animation if (Math.abs(toX - fromX) < 1f || mNextAppTransition != TRANSIT_DOCK_TASK_FROM_RECENTS) { return new TranslateAnimation(fromX, toX, fromY, toY); } else { final Path path = createCurvedPath(fromX, toX, fromY, toY); return new CurvedTranslateAnimation(path); } } private Path createCurvedPath(float fromX, float toX, float fromY, float toY) { final Path path = new Path(); path.moveTo(fromX, fromY); if (fromY > toY) { // If the object needs to go up, move it in horizontal direction first, then vertical. path.cubicTo(fromX, fromY, toX, 0.9f * fromY + 0.1f * toY, toX, toY); } else { // If the object needs to go down, move it in vertical direction first, then horizontal. path.cubicTo(fromX, fromY, fromX, 0.1f * fromY + 0.9f * toY, toX, toY); } return path; } private long getAspectScaleDuration() { if (mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS) { return (long) (THUMBNAIL_APP_TRANSITION_DURATION * 1.35f); } else { return THUMBNAIL_APP_TRANSITION_DURATION; } } private Interpolator getAspectScaleInterpolator() { if (mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS) { return mFastOutSlowInInterpolator; } else { return TOUCH_RESPONSE_INTERPOLATOR; } } /** * This alternate animation is created when we are doing a thumbnail transition, for the * activity that is leaving, and the activity that is entering. */ Animation createAspectScaledThumbnailEnterExitAnimationLocked(int thumbTransitState, int uiMode, int orientation, int transit, Rect containingFrame, Rect contentInsets, @Nullable Rect surfaceInsets, boolean freeform, int taskId) { Animation a; final int appWidth = containingFrame.width(); final int appHeight = containingFrame.height(); getDefaultNextAppTransitionStartRect(mTmpRect); final int thumbWidthI = mTmpRect.width(); final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1; final int thumbHeightI = mTmpRect.height(); final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1; final int thumbStartX = mTmpRect.left - containingFrame.left - contentInsets.left; final int thumbStartY = mTmpRect.top - containingFrame.top; switch (thumbTransitState) { case THUMBNAIL_TRANSITION_ENTER_SCALE_UP: case THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN: { final boolean scaleUp = thumbTransitState == THUMBNAIL_TRANSITION_ENTER_SCALE_UP; if (freeform && scaleUp) { a = createAspectScaledThumbnailEnterFreeformAnimationLocked( containingFrame, surfaceInsets, taskId); } else if (freeform) { a = createAspectScaledThumbnailExitFreeformAnimationLocked( containingFrame, surfaceInsets, taskId); } else { AnimationSet set = new AnimationSet(true); // In portrait, we scale to fit the width mTmpFromClipRect.set(containingFrame); mTmpToClipRect.set(containingFrame); // Containing frame is in screen space, but we need the clip rect in the // app space. mTmpFromClipRect.offsetTo(0, 0); mTmpToClipRect.offsetTo(0, 0); // Exclude insets region from the source clip. mTmpFromClipRect.inset(contentInsets); mNextAppTransitionInsets.set(contentInsets); if (isTvUiMode(uiMode) || orientation == Configuration.ORIENTATION_PORTRAIT) { // We scale the width and clip to the top/left square float scale = thumbWidth / (appWidth - contentInsets.left - contentInsets.right); int unscaledThumbHeight = (int) (thumbHeight / scale); mTmpFromClipRect.bottom = mTmpFromClipRect.top + unscaledThumbHeight; mNextAppTransitionInsets.set(contentInsets); Animation scaleAnim = new ScaleAnimation( scaleUp ? scale : 1, scaleUp ? 1 : scale, scaleUp ? scale : 1, scaleUp ? 1 : scale, containingFrame.width() / 2f, containingFrame.height() / 2f + contentInsets.top); final float targetX = (mTmpRect.left - containingFrame.left); final float x = containingFrame.width() / 2f - containingFrame.width() / 2f * scale; final float targetY = (mTmpRect.top - containingFrame.top); final float y = containingFrame.height() / 2f - containingFrame.height() / 2f * scale; final float startX = targetX - x; final float startY = targetY - y; Animation clipAnim = scaleUp ? new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect) : new ClipRectAnimation(mTmpToClipRect, mTmpFromClipRect); Animation translateAnim = scaleUp ? createCurvedMotion(startX, 0, startY - contentInsets.top, 0) : createCurvedMotion(0, startX, 0, startY - contentInsets.top); set.addAnimation(clipAnim); set.addAnimation(scaleAnim); set.addAnimation(translateAnim); } else { // In landscape, we don't scale at all and only crop mTmpFromClipRect.bottom = mTmpFromClipRect.top + thumbHeightI; mTmpFromClipRect.right = mTmpFromClipRect.left + thumbWidthI; Animation clipAnim = scaleUp ? new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect) : new ClipRectAnimation(mTmpToClipRect, mTmpFromClipRect); Animation translateAnim = scaleUp ? createCurvedMotion(thumbStartX, 0, thumbStartY - contentInsets.top, 0) : createCurvedMotion(0, thumbStartX, 0, thumbStartY - contentInsets.top); set.addAnimation(clipAnim); set.addAnimation(translateAnim); } a = set; a.setZAdjustment(Animation.ZORDER_TOP); } break; } case THUMBNAIL_TRANSITION_EXIT_SCALE_UP: { // Previous app window during the scale up if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) { // Fade out the source activity if we are animating to a wallpaper // activity. a = new AlphaAnimation(1, 0); } else { a = new AlphaAnimation(1, 1); } break; } case THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN: { // Target app window during the scale down if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) { // Fade in the destination activity if we are animating from a wallpaper // activity. a = new AlphaAnimation(0, 1); } else { a = new AlphaAnimation(1, 1); } break; } default: throw new RuntimeException("Invalid thumbnail transition state"); } return prepareThumbnailAnimationWithDuration(a, appWidth, appHeight, getAspectScaleDuration(), getAspectScaleInterpolator()); } private Animation createAspectScaledThumbnailEnterFreeformAnimationLocked(Rect frame, @Nullable Rect surfaceInsets, int taskId) { getNextAppTransitionStartRect(taskId, mTmpRect); return createAspectScaledThumbnailFreeformAnimationLocked(mTmpRect, frame, surfaceInsets, true); } private Animation createAspectScaledThumbnailExitFreeformAnimationLocked(Rect frame, @Nullable Rect surfaceInsets, int taskId) { getNextAppTransitionStartRect(taskId, mTmpRect); return createAspectScaledThumbnailFreeformAnimationLocked(frame, mTmpRect, surfaceInsets, false); } private AnimationSet createAspectScaledThumbnailFreeformAnimationLocked(Rect sourceFrame, Rect destFrame, @Nullable Rect surfaceInsets, boolean enter) { final float sourceWidth = sourceFrame.width(); final float sourceHeight = sourceFrame.height(); final float destWidth = destFrame.width(); final float destHeight = destFrame.height(); final float scaleH = enter ? sourceWidth / destWidth : destWidth / sourceWidth; final float scaleV = enter ? sourceHeight / destHeight : destHeight / sourceHeight; AnimationSet set = new AnimationSet(true); final int surfaceInsetsH = surfaceInsets == null ? 0 : surfaceInsets.left + surfaceInsets.right; final int surfaceInsetsV = surfaceInsets == null ? 0 : surfaceInsets.top + surfaceInsets.bottom; // We want the scaling to happen from the center of the surface. In order to achieve that, // we need to account for surface insets that will be used to enlarge the surface. final float scaleHCenter = ((enter ? destWidth : sourceWidth) + surfaceInsetsH) / 2; final float scaleVCenter = ((enter ? destHeight : sourceHeight) + surfaceInsetsV) / 2; final ScaleAnimation scale = enter ? new ScaleAnimation(scaleH, 1, scaleV, 1, scaleHCenter, scaleVCenter) : new ScaleAnimation(1, scaleH, 1, scaleV, scaleHCenter, scaleVCenter); final int sourceHCenter = sourceFrame.left + sourceFrame.width() / 2; final int sourceVCenter = sourceFrame.top + sourceFrame.height() / 2; final int destHCenter = destFrame.left + destFrame.width() / 2; final int destVCenter = destFrame.top + destFrame.height() / 2; final int fromX = enter ? sourceHCenter - destHCenter : destHCenter - sourceHCenter; final int fromY = enter ? sourceVCenter - destVCenter : destVCenter - sourceVCenter; final TranslateAnimation translation = enter ? new TranslateAnimation(fromX, 0, fromY, 0) : new TranslateAnimation(0, fromX, 0, fromY); set.addAnimation(scale); set.addAnimation(translation); final IRemoteCallback callback = mAnimationFinishedCallback; if (callback != null) { set.setAnimationListener(new Animation.AnimationListener() { @Override public void onAnimationStart(Animation animation) { } @Override public void onAnimationEnd(Animation animation) { mService.mH.obtainMessage(H.DO_ANIMATION_CALLBACK, callback).sendToTarget(); } @Override public void onAnimationRepeat(Animation animation) { } }); } return set; } /** * This animation runs for the thumbnail that gets cross faded with the enter/exit activity * when a thumbnail is specified with the pending animation override. */ Animation createThumbnailScaleAnimationLocked(int appWidth, int appHeight, int transit, Bitmap thumbnailHeader) { Animation a; getDefaultNextAppTransitionStartRect(mTmpRect); final int thumbWidthI = thumbnailHeader.getWidth(); final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1; final int thumbHeightI = thumbnailHeader.getHeight(); final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1; if (mNextAppTransitionScaleUp) { // Animation for the thumbnail zooming from its initial size to the full screen float scaleW = appWidth / thumbWidth; float scaleH = appHeight / thumbHeight; Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH, computePivot(mTmpRect.left, 1 / scaleW), computePivot(mTmpRect.top, 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 { // Animation for the thumbnail zooming down from the full screen to its final size float scaleW = appWidth / thumbWidth; float scaleH = appHeight / thumbHeight; a = new ScaleAnimation(scaleW, 1, scaleH, 1, computePivot(mTmpRect.left, 1 / scaleW), computePivot(mTmpRect.top, 1 / scaleH)); } return prepareThumbnailAnimation(a, appWidth, appHeight, transit); } /** * This animation is created when we are doing a thumbnail transition, for the activity that is * leaving, and the activity that is entering. */ Animation createThumbnailEnterExitAnimationLocked(int thumbTransitState, Rect containingFrame, int transit, int taskId) { final int appWidth = containingFrame.width(); final int appHeight = containingFrame.height(); Bitmap thumbnailHeader = getAppTransitionThumbnailHeader(taskId); Animation a; getDefaultNextAppTransitionStartRect(mTmpRect); final int thumbWidthI = thumbnailHeader != null ? thumbnailHeader.getWidth() : appWidth; final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1; final int thumbHeightI = thumbnailHeader != null ? thumbnailHeader.getHeight() : appHeight; final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1; switch (thumbTransitState) { case THUMBNAIL_TRANSITION_ENTER_SCALE_UP: { // Entering app scales up with the thumbnail float scaleW = thumbWidth / appWidth; float scaleH = thumbHeight / appHeight; a = new ScaleAnimation(scaleW, 1, scaleH, 1, computePivot(mTmpRect.left, scaleW), computePivot(mTmpRect.top, scaleH)); break; } case THUMBNAIL_TRANSITION_EXIT_SCALE_UP: { // Exiting app while the thumbnail is scaling up should fade or stay in place 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); } break; } case THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN: { // Entering the other app, it should just be visible while we scale the thumbnail // down above it a = new AlphaAnimation(1, 1); break; } case THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN: { // Exiting the current app, the app should scale down with the thumbnail float scaleW = thumbWidth / appWidth; float scaleH = thumbHeight / appHeight; Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH, computePivot(mTmpRect.left, scaleW), computePivot(mTmpRect.top, 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; break; } default: throw new RuntimeException("Invalid thumbnail transition state"); } return prepareThumbnailAnimation(a, appWidth, appHeight, transit); } private Animation createRelaunchAnimation(Rect containingFrame, Rect contentInsets) { getDefaultNextAppTransitionStartRect(mTmpFromClipRect); final int left = mTmpFromClipRect.left; final int top = mTmpFromClipRect.top; mTmpFromClipRect.offset(-left, -top); // TODO: Isn't that strange that we ignore exact position of the containingFrame? mTmpToClipRect.set(0, 0, containingFrame.width(), containingFrame.height()); AnimationSet set = new AnimationSet(true); float fromWidth = mTmpFromClipRect.width(); float toWidth = mTmpToClipRect.width(); float fromHeight = mTmpFromClipRect.height(); // While the window might span the whole display, the actual content will be cropped to the // system decoration frame, for example when the window is docked. We need to take into // account the visible height when constructing the animation. float toHeight = mTmpToClipRect.height() - contentInsets.top - contentInsets.bottom; int translateAdjustment = 0; if (fromWidth <= toWidth && fromHeight <= toHeight) { // The final window is larger in both dimensions than current window (e.g. we are // maximizing), so we can simply unclip the new window and there will be no disappearing // frame. set.addAnimation(new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect)); } else { // The disappearing window has one larger dimension. We need to apply scaling, so the // first frame of the entry animation matches the old window. set.addAnimation(new ScaleAnimation(fromWidth / toWidth, 1, fromHeight / toHeight, 1)); // We might not be going exactly full screen, but instead be aligned under the status // bar using cropping. We still need to account for the cropped part, which will also // be scaled. translateAdjustment = (int) (contentInsets.top * fromHeight / toHeight); } // We animate the translation from the old position of the removed window, to the new // position of the added window. The latter might not be full screen, for example docked for // docked windows. TranslateAnimation translate = new TranslateAnimation(left - containingFrame.left, 0, top - containingFrame.top - translateAdjustment, 0); set.addAnimation(translate); set.setDuration(DEFAULT_APP_TRANSITION_DURATION); set.setZAdjustment(Animation.ZORDER_TOP); return set; } /** * @return true if and only if the first frame of the transition can be skipped, i.e. the first * frame of the transition doesn't change the visuals on screen, so we can start * directly with the second one */ boolean canSkipFirstFrame() { return mNextAppTransitionType != NEXT_TRANSIT_TYPE_CUSTOM && mNextAppTransitionType != NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE && mNextAppTransitionType != NEXT_TRANSIT_TYPE_CLIP_REVEAL; } /** * * @param frame These are the bounds of the window when it finishes the animation. This is where * the animation must usually finish in entrance animation, as the next frame will * display the window at these coordinates. In case of exit animation, this is * where the animation must start, as the frame before the animation is displaying * the window at these bounds. * @param insets Knowing where the window will be positioned is not enough. Some parts of the * window might be obscured, usually by the system windows (status bar and * navigation bar) and we use content insets to convey that information. This * usually affects the animation aspects vertically, as the system decoration is * at the top and the bottom. For example when we animate from full screen to * recents, we want to exclude the covered parts, because they won't match the * thumbnail after the last frame is executed. * @param surfaceInsets In rare situation the surface is larger than the content and we need to * know about this to make the animation frames match. We currently use * this for freeform windows, which have larger surfaces to display * shadows. When we animate them from recents, we want to match the content * to the recents thumbnail and hence need to account for the surface being * bigger. */ Animation loadAnimation(WindowManager.LayoutParams lp, int transit, boolean enter, int uiMode, int orientation, Rect frame, Rect displayFrame, Rect insets, @Nullable Rect surfaceInsets, boolean isVoiceInteraction, boolean freeform, int taskId) { Animation a; if (isVoiceInteraction && (transit == TRANSIT_ACTIVITY_OPEN || transit == TRANSIT_TASK_OPEN || transit == TRANSIT_TASK_TO_FRONT)) { a = loadAnimationRes(lp, enter ? com.android.internal.R.anim.voice_activity_open_enter : com.android.internal.R.anim.voice_activity_open_exit); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation voice:" + " anim=" + a + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3)); } else if (isVoiceInteraction && (transit == TRANSIT_ACTIVITY_CLOSE || transit == TRANSIT_TASK_CLOSE || transit == TRANSIT_TASK_TO_BACK)) { a = loadAnimationRes(lp, enter ? com.android.internal.R.anim.voice_activity_close_enter : com.android.internal.R.anim.voice_activity_close_exit); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation voice:" + " anim=" + a + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3)); } else if (transit == TRANSIT_ACTIVITY_RELAUNCH) { a = createRelaunchAnimation(frame, insets); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation:" + " anim=" + a + " nextAppTransition=" + mNextAppTransition + " transit=" + appTransitionToString(transit) + " Callers=" + Debug.getCallers(3)); } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM) { a = loadAnimationRes(mNextAppTransitionPackage, enter ? mNextAppTransitionEnter : mNextAppTransitionExit); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation:" + " anim=" + a + " nextAppTransition=ANIM_CUSTOM" + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3)); } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE) { a = loadAnimationRes(mNextAppTransitionPackage, mNextAppTransitionInPlace); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation:" + " anim=" + a + " nextAppTransition=ANIM_CUSTOM_IN_PLACE" + " transit=" + appTransitionToString(transit) + " Callers=" + Debug.getCallers(3)); } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CLIP_REVEAL) { a = createClipRevealAnimationLocked(transit, enter, frame, displayFrame); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation:" + " anim=" + a + " nextAppTransition=ANIM_CLIP_REVEAL" + " transit=" + appTransitionToString(transit) + " Callers=" + Debug.getCallers(3)); } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_SCALE_UP) { a = createScaleUpAnimationLocked(transit, enter, frame); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation:" + " anim=" + a + " nextAppTransition=ANIM_SCALE_UP" + " transit=" + appTransitionToString(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 = createThumbnailEnterExitAnimationLocked(getThumbnailTransitionState(enter), frame, transit, taskId); 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=" + appTransitionToString(transit) + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3)); } } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP || mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN) { mNextAppTransitionScaleUp = (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP); a = createAspectScaledThumbnailEnterExitAnimationLocked( getThumbnailTransitionState(enter), uiMode, orientation, transit, frame, insets, surfaceInsets, freeform, taskId); if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) { String animName = mNextAppTransitionScaleUp ? "ANIM_THUMBNAIL_ASPECT_SCALE_UP" : "ANIM_THUMBNAIL_ASPECT_SCALE_DOWN"; Slog.v(TAG, "applyAnimation:" + " anim=" + a + " nextAppTransition=" + animName + " transit=" + appTransitionToString(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_DOCK_TASK_FROM_RECENTS: 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; case TRANSIT_TASK_OPEN_BEHIND: animAttr = enter ? WindowAnimation_launchTaskBehindSourceAnimation : WindowAnimation_launchTaskBehindTargetAnimation; } a = animAttr != 0 ? loadAnimationAttr(lp, animAttr) : null; if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation:" + " anim=" + a + " animAttr=0x" + Integer.toHexString(animAttr) + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3)); } return a; } int getAppStackClipMode() { return mNextAppTransition == TRANSIT_ACTIVITY_RELAUNCH || mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS || mNextAppTransitionType == NEXT_TRANSIT_TYPE_CLIP_REVEAL ? STACK_CLIP_NONE : STACK_CLIP_AFTER_ANIM; } void postAnimationCallback() { if (mNextAppTransitionCallback != null) { mService.mH.sendMessage(mService.mH.obtainMessage(H.DO_ANIMATION_CALLBACK, mNextAppTransitionCallback)); mNextAppTransitionCallback = null; } } void overridePendingAppTransition(String packageName, int enterAnim, int exitAnim, IRemoteCallback startedCallback) { if (isTransitionSet()) { clear(); mNextAppTransitionType = NEXT_TRANSIT_TYPE_CUSTOM; mNextAppTransitionPackage = packageName; mNextAppTransitionEnter = enterAnim; mNextAppTransitionExit = exitAnim; postAnimationCallback(); mNextAppTransitionCallback = startedCallback; } else { postAnimationCallback(); } } void overridePendingAppTransitionScaleUp(int startX, int startY, int startWidth, int startHeight) { if (isTransitionSet()) { clear(); mNextAppTransitionType = NEXT_TRANSIT_TYPE_SCALE_UP; putDefaultNextAppTransitionCoordinates(startX, startY, startWidth, startHeight, null); postAnimationCallback(); } } void overridePendingAppTransitionClipReveal(int startX, int startY, int startWidth, int startHeight) { if (isTransitionSet()) { clear(); mNextAppTransitionType = NEXT_TRANSIT_TYPE_CLIP_REVEAL; putDefaultNextAppTransitionCoordinates(startX, startY, startWidth, startHeight, null); postAnimationCallback(); } } void overridePendingAppTransitionThumb(Bitmap srcThumb, int startX, int startY, IRemoteCallback startedCallback, boolean scaleUp) { if (isTransitionSet()) { clear(); mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP : NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN; mNextAppTransitionScaleUp = scaleUp; putDefaultNextAppTransitionCoordinates(startX, startY, 0, 0, srcThumb); postAnimationCallback(); mNextAppTransitionCallback = startedCallback; } else { postAnimationCallback(); } } void overridePendingAppTransitionAspectScaledThumb(Bitmap srcThumb, int startX, int startY, int targetWidth, int targetHeight, IRemoteCallback startedCallback, boolean scaleUp) { if (isTransitionSet()) { clear(); mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP : NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN; mNextAppTransitionScaleUp = scaleUp; putDefaultNextAppTransitionCoordinates(startX, startY, targetWidth, targetHeight, srcThumb); postAnimationCallback(); mNextAppTransitionCallback = startedCallback; } else { postAnimationCallback(); } } public void overridePendingAppTransitionMultiThumb(AppTransitionAnimationSpec[] specs, IRemoteCallback onAnimationStartedCallback, IRemoteCallback onAnimationFinishedCallback, boolean scaleUp) { if (isTransitionSet()) { clear(); mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP : NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN; mNextAppTransitionScaleUp = scaleUp; if (specs != null) { for (int i = 0; i < specs.length; i++) { AppTransitionAnimationSpec spec = specs[i]; if (spec != null) { mNextAppTransitionAnimationsSpecs.put(spec.taskId, spec); if (i == 0) { // In full screen mode, the transition code depends on the default spec // to be set. Rect rect = spec.rect; putDefaultNextAppTransitionCoordinates(rect.left, rect.top, rect.width(), rect.height(), spec.bitmap); } } } } postAnimationCallback(); mNextAppTransitionCallback = onAnimationStartedCallback; mAnimationFinishedCallback = onAnimationFinishedCallback; } else { postAnimationCallback(); } } void overridePendingAppTransitionMultiThumbFuture( IAppTransitionAnimationSpecsFuture specsFuture, IRemoteCallback callback, boolean scaleUp) { if (isTransitionSet()) { clear(); mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP : NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN; mNextAppTransitionAnimationsSpecsFuture = specsFuture; mNextAppTransitionScaleUp = scaleUp; mNextAppTransitionFutureCallback = callback; } } void overrideInPlaceAppTransition(String packageName, int anim) { if (isTransitionSet()) { clear(); mNextAppTransitionType = NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE; mNextAppTransitionPackage = packageName; mNextAppTransitionInPlace = anim; } else { postAnimationCallback(); } } /** * If a future is set for the app transition specs, fetch it in another thread. */ private void fetchAppTransitionSpecsFromFuture() { if (mNextAppTransitionAnimationsSpecsFuture != null) { mNextAppTransitionAnimationsSpecsPending = true; final IAppTransitionAnimationSpecsFuture future = mNextAppTransitionAnimationsSpecsFuture; mNextAppTransitionAnimationsSpecsFuture = null; mDefaultExecutor.execute(new Runnable() { @Override public void run() { AppTransitionAnimationSpec[] specs = null; try { specs = future.get(); } catch (RemoteException e) { Slog.w(TAG, "Failed to fetch app transition specs: " + e); } synchronized (mService.mWindowMap) { mNextAppTransitionAnimationsSpecsPending = false; overridePendingAppTransitionMultiThumb(specs, mNextAppTransitionFutureCallback, null /* finishedCallback */, mNextAppTransitionScaleUp); mNextAppTransitionFutureCallback = null; if (specs != null) { mService.prolongAnimationsFromSpecs(specs, mNextAppTransitionScaleUp); } } mService.requestTraversal(); } }); } } @Override public String toString() { return "mNextAppTransition=" + appTransitionToString(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_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"; } case TRANSIT_TASK_OPEN_BEHIND: { return "TRANSIT_TASK_OPEN_BEHIND"; } case TRANSIT_ACTIVITY_RELAUNCH: { return "TRANSIT_ACTIVITY_RELAUNCH"; } case TRANSIT_DOCK_TASK_FROM_RECENTS: { return "TRANSIT_DOCK_TASK_FROM_RECENTS"; } default: { return ""; } } } 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_CUSTOM_IN_PLACE: return "NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE"; 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"; case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP: return "NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP"; case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN: return "NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN"; default: return "unknown type=" + mNextAppTransitionType; } } @Override public void dump(PrintWriter pw, String prefix) { pw.print(prefix); pw.println(this); pw.print(prefix); pw.print("mAppTransitionState="); pw.println(appStateToString()); if (mNextAppTransitionType != NEXT_TRANSIT_TYPE_NONE) { pw.print(prefix); pw.print("mNextAppTransitionType="); pw.println(transitTypeToString()); } switch (mNextAppTransitionType) { case NEXT_TRANSIT_TYPE_CUSTOM: pw.print(prefix); pw.print("mNextAppTransitionPackage="); pw.println(mNextAppTransitionPackage); pw.print(prefix); pw.print("mNextAppTransitionEnter=0x"); pw.print(Integer.toHexString(mNextAppTransitionEnter)); pw.print(" mNextAppTransitionExit=0x"); pw.println(Integer.toHexString(mNextAppTransitionExit)); break; case NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE: pw.print(prefix); pw.print("mNextAppTransitionPackage="); pw.println(mNextAppTransitionPackage); pw.print(prefix); pw.print("mNextAppTransitionInPlace=0x"); pw.print(Integer.toHexString(mNextAppTransitionInPlace)); break; case NEXT_TRANSIT_TYPE_SCALE_UP: { getDefaultNextAppTransitionStartRect(mTmpRect); pw.print(prefix); pw.print("mNextAppTransitionStartX="); pw.print(mTmpRect.left); pw.print(" mNextAppTransitionStartY="); pw.println(mTmpRect.top); pw.print(prefix); pw.print("mNextAppTransitionStartWidth="); pw.print(mTmpRect.width()); pw.print(" mNextAppTransitionStartHeight="); pw.println(mTmpRect.height()); break; } case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP: case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN: case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP: case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN: { pw.print(prefix); pw.print("mDefaultNextAppTransitionAnimationSpec="); pw.println(mDefaultNextAppTransitionAnimationSpec); pw.print(prefix); pw.print("mNextAppTransitionAnimationsSpecs="); pw.println(mNextAppTransitionAnimationsSpecs); pw.print(prefix); pw.print("mNextAppTransitionScaleUp="); pw.println(mNextAppTransitionScaleUp); break; } } if (mNextAppTransitionCallback != null) { pw.print(prefix); pw.print("mNextAppTransitionCallback="); pw.println(mNextAppTransitionCallback); } if (mLastUsedAppTransition != TRANSIT_NONE) { pw.print(prefix); pw.print("mLastUsedAppTransition="); pw.println(appTransitionToString(mLastUsedAppTransition)); pw.print(prefix); pw.print("mLastOpeningApp="); pw.println(mLastOpeningApp); pw.print(prefix); pw.print("mLastClosingApp="); pw.println(mLastClosingApp); } } public void setCurrentUser(int newUserId) { mCurrentUserId = newUserId; } /** * @return true if transition is not running and should not be skipped, false if transition is * already running */ boolean prepareAppTransitionLocked(int transit, boolean alwaysKeepCurrent) { if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Prepare app transition:" + " transit=" + appTransitionToString(transit) + " " + this + " alwaysKeepCurrent=" + alwaysKeepCurrent + " Callers=" + Debug.getCallers(3)); if (!isTransitionSet() || mNextAppTransition == TRANSIT_NONE) { setAppTransition(transit); } else if (!alwaysKeepCurrent) { if (transit == TRANSIT_TASK_OPEN && isTransitionEqual(TRANSIT_TASK_CLOSE)) { // Opening a new task always supersedes a close for the anim. setAppTransition(transit); } else if (transit == TRANSIT_ACTIVITY_OPEN && isTransitionEqual(TRANSIT_ACTIVITY_CLOSE)) { // Opening a new activity always supersedes a close for the anim. setAppTransition(transit); } } boolean prepared = prepare(); if (isTransitionSet()) { mService.mH.removeMessages(H.APP_TRANSITION_TIMEOUT); mService.mH.sendEmptyMessageDelayed(H.APP_TRANSITION_TIMEOUT, APP_TRANSITION_TIMEOUT_MS); } return prepared; } /** * @return whether the specified {@param uiMode} is the TV mode. */ private boolean isTvUiMode(int uiMode) { return (uiMode & Configuration.UI_MODE_TYPE_TELEVISION) > 0; } }