services/core/java/com/android/server/wm/AppTransition.java

   1 /*
   2  * Copyright (C) 2011 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.wm;
  18
  19 import static android.view.WindowManagerInternal.AppTransitionListener;
  20 import static com.android.internal.R.styleable.WindowAnimation_activityCloseEnterAnimation;
  21 import static com.android.internal.R.styleable.WindowAnimation_activityCloseExitAnimation;
  22 import static com.android.internal.R.styleable.WindowAnimation_activityOpenEnterAnimation;
  23 import static com.android.internal.R.styleable.WindowAnimation_activityOpenExitAnimation;
  24 import static com.android.internal.R.styleable.WindowAnimation_launchTaskBehindSourceAnimation;
  25 import static com.android.internal.R.styleable.WindowAnimation_launchTaskBehindTargetAnimation;
  26 import static com.android.internal.R.styleable.WindowAnimation_taskCloseEnterAnimation;
  27 import static com.android.internal.R.styleable.WindowAnimation_taskCloseExitAnimation;
  28 import static com.android.internal.R.styleable.WindowAnimation_taskOpenEnterAnimation;
  29 import static com.android.internal.R.styleable.WindowAnimation_taskOpenExitAnimation;
  30 import static com.android.internal.R.styleable.WindowAnimation_taskToBackEnterAnimation;
  31 import static com.android.internal.R.styleable.WindowAnimation_taskToBackExitAnimation;
  32 import static com.android.internal.R.styleable.WindowAnimation_taskToFrontEnterAnimation;
  33 import static com.android.internal.R.styleable.WindowAnimation_taskToFrontExitAnimation;
  34 import static com.android.internal.R.styleable.WindowAnimation_wallpaperCloseEnterAnimation;
  35 import static com.android.internal.R.styleable.WindowAnimation_wallpaperCloseExitAnimation;
  36 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseEnterAnimation;
  37 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseExitAnimation;
  38 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraOpenEnterAnimation;
  39 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraOpenExitAnimation;
  40 import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenEnterAnimation;
  41 import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenExitAnimation;
  42 import static com.android.server.wm.AppWindowAnimator.PROLONG_ANIMATION_AT_START;
  43 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ANIM;
  44 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_APP_TRANSITIONS;
  45 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
  46 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
  47 import static com.android.server.wm.WindowStateAnimator.STACK_CLIP_NONE;
  48 import static com.android.server.wm.WindowStateAnimator.STACK_CLIP_AFTER_ANIM;
  49
  50 import android.annotation.Nullable;
  51 import android.content.Context;
  52 import android.content.res.Configuration;
  53 import android.graphics.Bitmap;
  54 import android.graphics.Path;
  55 import android.graphics.Rect;
  56 import android.os.Debug;
  57 import android.os.IBinder;
  58 import android.os.IRemoteCallback;
  59 import android.os.RemoteException;
  60 import android.util.ArraySet;
  61 import android.util.Slog;
  62 import android.util.SparseArray;
  63 import android.view.AppTransitionAnimationSpec;
  64 import android.view.IAppTransitionAnimationSpecsFuture;
  65 import android.view.WindowManager;
  66 import android.view.animation.AlphaAnimation;
  67 import android.view.animation.Animation;
  68 import android.view.animation.AnimationSet;
  69 import android.view.animation.AnimationUtils;
  70 import android.view.animation.ClipRectAnimation;
  71 import android.view.animation.Interpolator;
  72 import android.view.animation.PathInterpolator;
  73 import android.view.animation.ScaleAnimation;
  74 import android.view.animation.TranslateAnimation;
  75
  76 import com.android.internal.util.DumpUtils.Dump;
  77 import com.android.server.AttributeCache;
  78 import com.android.server.wm.WindowManagerService.H;
  79 import com.android.server.wm.animation.ClipRectLRAnimation;
  80 import com.android.server.wm.animation.ClipRectTBAnimation;
  81 import com.android.server.wm.animation.CurvedTranslateAnimation;
  82
  83 import java.io.PrintWriter;
  84 import java.util.ArrayList;
  85 import java.util.concurrent.ExecutorService;
  86 import java.util.concurrent.Executors;
  87
  88 // State management of app transitions.  When we are preparing for a
  89 // transition, mNextAppTransition will be the kind of transition to
  90 // perform or TRANSIT_NONE if we are not waiting.  If we are waiting,
  91 // mOpeningApps and mClosingApps are the lists of tokens that will be
  92 // made visible or hidden at the next transition.
  93 public class AppTransition implements Dump {
  94     private static final String TAG = TAG_WITH_CLASS_NAME ? "AppTransition" : TAG_WM;
  95     private static final int CLIP_REVEAL_TRANSLATION_Y_DP = 8;
  96
  97     /** Not set up for a transition. */
  98     public static final int TRANSIT_UNSET = -1;
  99     /** No animation for transition. */
 100     public static final int TRANSIT_NONE = 0;
 101     /** A window in a new activity is being opened on top of an existing one in the same task. */
 102     public static final int TRANSIT_ACTIVITY_OPEN = 6;
 103     /** The window in the top-most activity is being closed to reveal the
 104      * previous activity in the same task. */
 105     public static final int TRANSIT_ACTIVITY_CLOSE = 7;
 106     /** A window in a new task is being opened on top of an existing one
 107      * in another activity's task. */
 108     public static final int TRANSIT_TASK_OPEN = 8;
 109     /** A window in the top-most activity is being closed to reveal the
 110      * previous activity in a different task. */
 111     public static final int TRANSIT_TASK_CLOSE = 9;
 112     /** A window in an existing task is being displayed on top of an existing one
 113      * in another activity's task. */
 114     public static final int TRANSIT_TASK_TO_FRONT = 10;
 115     /** A window in an existing task is being put below all other tasks. */
 116     public static final int TRANSIT_TASK_TO_BACK = 11;
 117     /** A window in a new activity that doesn't have a wallpaper is being opened on top of one that
 118      * does, effectively closing the wallpaper. */
 119     public static final int TRANSIT_WALLPAPER_CLOSE = 12;
 120     /** A window in a new activity that does have a wallpaper is being opened on one that didn't,
 121      * effectively opening the wallpaper. */
 122     public static final int TRANSIT_WALLPAPER_OPEN = 13;
 123     /** A window in a new activity is being opened on top of an existing one, and both are on top
 124      * of the wallpaper. */
 125     public static final int TRANSIT_WALLPAPER_INTRA_OPEN = 14;
 126     /** The window in the top-most activity is being closed to reveal the previous activity, and
 127      * both are on top of the wallpaper. */
 128     public static final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15;
 129     /** A window in a new task is being opened behind an existing one in another activity's task.
 130      * The new window will show briefly and then be gone. */
 131     public static final int TRANSIT_TASK_OPEN_BEHIND = 16;
 132     /** A window in a task is being animated in-place. */
 133     public static final int TRANSIT_TASK_IN_PLACE = 17;
 134     /** An activity is being relaunched (e.g. due to configuration change). */
 135     public static final int TRANSIT_ACTIVITY_RELAUNCH = 18;
 136     /** A task is being docked from recents. */
 137     public static final int TRANSIT_DOCK_TASK_FROM_RECENTS = 19;
 138
 139     /** Fraction of animation at which the recents thumbnail stays completely transparent */
 140     private static final float RECENTS_THUMBNAIL_FADEIN_FRACTION = 0.5f;
 141     /** Fraction of animation at which the recents thumbnail becomes completely transparent */
 142     private static final float RECENTS_THUMBNAIL_FADEOUT_FRACTION = 0.5f;
 143
 144     static final int DEFAULT_APP_TRANSITION_DURATION = 336;
 145
 146     /** Interpolator to be used for animations that respond directly to a touch */
 147     static final Interpolator TOUCH_RESPONSE_INTERPOLATOR =
 148             new PathInterpolator(0.3f, 0f, 0.1f, 1f);
 149
 150     private static final Interpolator THUMBNAIL_DOCK_INTERPOLATOR =
 151             new PathInterpolator(0.85f, 0f, 1f, 1f);
 152
 153     /**
 154      * Maximum duration for the clip reveal animation. This is used when there is a lot of movement
 155      * involved, to make it more understandable.
 156      */
 157     private static final int MAX_CLIP_REVEAL_TRANSITION_DURATION = 420;
 158     private static final int THUMBNAIL_APP_TRANSITION_DURATION = 336;
 159     private static final long APP_TRANSITION_TIMEOUT_MS = 5000;
 160
 161     private final Context mContext;
 162     private final WindowManagerService mService;
 163
 164     private int mNextAppTransition = TRANSIT_UNSET;
 165
 166     private static final int NEXT_TRANSIT_TYPE_NONE = 0;
 167     private static final int NEXT_TRANSIT_TYPE_CUSTOM = 1;
 168     private static final int NEXT_TRANSIT_TYPE_SCALE_UP = 2;
 169     private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP = 3;
 170     private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN = 4;
 171     private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP = 5;
 172     private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN = 6;
 173     private static final int NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE = 7;
 174     private static final int NEXT_TRANSIT_TYPE_CLIP_REVEAL = 8;
 175     private int mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE;
 176
 177     // These are the possible states for the enter/exit activities during a thumbnail transition
 178     private static final int THUMBNAIL_TRANSITION_ENTER_SCALE_UP = 0;
 179     private static final int THUMBNAIL_TRANSITION_EXIT_SCALE_UP = 1;
 180     private static final int THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN = 2;
 181     private static final int THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN = 3;
 182
 183     private String mNextAppTransitionPackage;
 184     // Used for thumbnail transitions. True if we're scaling up, false if scaling down
 185     private boolean mNextAppTransitionScaleUp;
 186     private IRemoteCallback mNextAppTransitionCallback;
 187     private IRemoteCallback mNextAppTransitionFutureCallback;
 188     private IRemoteCallback mAnimationFinishedCallback;
 189     private int mNextAppTransitionEnter;
 190     private int mNextAppTransitionExit;
 191     private int mNextAppTransitionInPlace;
 192
 193     // Keyed by task id.
 194     private final SparseArray<AppTransitionAnimationSpec> mNextAppTransitionAnimationsSpecs
 195             = new SparseArray<>();
 196     private IAppTransitionAnimationSpecsFuture mNextAppTransitionAnimationsSpecsFuture;
 197     private boolean mNextAppTransitionAnimationsSpecsPending;
 198     private AppTransitionAnimationSpec mDefaultNextAppTransitionAnimationSpec;
 199
 200     private Rect mNextAppTransitionInsets = new Rect();
 201
 202     private Rect mTmpFromClipRect = new Rect();
 203     private Rect mTmpToClipRect = new Rect();
 204
 205     private final Rect mTmpRect = new Rect();
 206
 207     private final static int APP_STATE_IDLE = 0;
 208     private final static int APP_STATE_READY = 1;
 209     private final static int APP_STATE_RUNNING = 2;
 210     private final static int APP_STATE_TIMEOUT = 3;
 211     private int mAppTransitionState = APP_STATE_IDLE;
 212
 213     private final int mConfigShortAnimTime;
 214     private final Interpolator mDecelerateInterpolator;
 215     private final Interpolator mThumbnailFadeInInterpolator;
 216     private final Interpolator mThumbnailFadeOutInterpolator;
 217     private final Interpolator mLinearOutSlowInInterpolator;
 218     private final Interpolator mFastOutLinearInInterpolator;
 219     private final Interpolator mFastOutSlowInInterpolator;
 220     private final Interpolator mClipHorizontalInterpolator = new PathInterpolator(0, 0, 0.4f, 1f);
 221
 222     private final int mClipRevealTranslationY;
 223
 224     private int mCurrentUserId = 0;
 225     private long mLastClipRevealTransitionDuration = DEFAULT_APP_TRANSITION_DURATION;
 226
 227     private final ArrayList<AppTransitionListener> mListeners = new ArrayList<>();
 228     private final ExecutorService mDefaultExecutor = Executors.newSingleThreadExecutor();
 229
 230     private int mLastClipRevealMaxTranslation;
 231     private boolean mLastHadClipReveal;
 232     private boolean mProlongedAnimationsEnded;
 233
 234     AppTransition(Context context, WindowManagerService service) {
 235         mContext = context;
 236         mService = service;
 237         mLinearOutSlowInInterpolator = AnimationUtils.loadInterpolator(context,
 238                 com.android.internal.R.interpolator.linear_out_slow_in);
 239         mFastOutLinearInInterpolator = AnimationUtils.loadInterpolator(context,
 240                 com.android.internal.R.interpolator.fast_out_linear_in);
 241         mFastOutSlowInInterpolator = AnimationUtils.loadInterpolator(context,
 242                 com.android.internal.R.interpolator.fast_out_slow_in);
 243         mConfigShortAnimTime = context.getResources().getInteger(
 244                 com.android.internal.R.integer.config_shortAnimTime);
 245         mDecelerateInterpolator = AnimationUtils.loadInterpolator(context,
 246                 com.android.internal.R.interpolator.decelerate_cubic);
 247         mThumbnailFadeInInterpolator = new Interpolator() {
 248             @Override
 249             public float getInterpolation(float input) {
 250                 // Linear response for first fraction, then complete after that.
 251                 if (input < RECENTS_THUMBNAIL_FADEIN_FRACTION) {
 252                     return 0f;
 253                 }
 254                 float t = (input - RECENTS_THUMBNAIL_FADEIN_FRACTION) /
 255                         (1f - RECENTS_THUMBNAIL_FADEIN_FRACTION);
 256                 return mFastOutLinearInInterpolator.getInterpolation(t);
 257             }
 258         };
 259         mThumbnailFadeOutInterpolator = new Interpolator() {
 260             @Override
 261             public float getInterpolation(float input) {
 262                 // Linear response for first fraction, then complete after that.
 263                 if (input < RECENTS_THUMBNAIL_FADEOUT_FRACTION) {
 264                     float t = input / RECENTS_THUMBNAIL_FADEOUT_FRACTION;
 265                     return mLinearOutSlowInInterpolator.getInterpolation(t);
 266                 }
 267                 return 1f;
 268             }
 269         };
 270         mClipRevealTranslationY = (int) (CLIP_REVEAL_TRANSLATION_Y_DP
 271                 * mContext.getResources().getDisplayMetrics().density);
 272     }
 273
 274     boolean isTransitionSet() {
 275         return mNextAppTransition != TRANSIT_UNSET;
 276     }
 277
 278     boolean isTransitionEqual(int transit) {
 279         return mNextAppTransition == transit;
 280     }
 281
 282     int getAppTransition() {
 283         return mNextAppTransition;
 284      }
 285
 286     private void setAppTransition(int transit) {
 287         mNextAppTransition = transit;
 288     }
 289
 290     boolean isReady() {
 291         return mAppTransitionState == APP_STATE_READY
 292                 || mAppTransitionState == APP_STATE_TIMEOUT;
 293     }
 294
 295     void setReady() {
 296         mAppTransitionState = APP_STATE_READY;
 297         fetchAppTransitionSpecsFromFuture();
 298     }
 299
 300     boolean isRunning() {
 301         return mAppTransitionState == APP_STATE_RUNNING;
 302     }
 303
 304     void setIdle() {
 305         mAppTransitionState = APP_STATE_IDLE;
 306     }
 307
 308     boolean isTimeout() {
 309         return mAppTransitionState == APP_STATE_TIMEOUT;
 310     }
 311
 312     void setTimeout() {
 313         mAppTransitionState = APP_STATE_TIMEOUT;
 314     }
 315
 316     Bitmap getAppTransitionThumbnailHeader(int taskId) {
 317         AppTransitionAnimationSpec spec = mNextAppTransitionAnimationsSpecs.get(taskId);
 318         if (spec == null) {
 319             spec = mDefaultNextAppTransitionAnimationSpec;
 320         }
 321         return spec != null ? spec.bitmap : null;
 322     }
 323
 324     /** Returns whether the next thumbnail transition is aspect scaled up. */
 325     boolean isNextThumbnailTransitionAspectScaled() {
 326         return mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP ||
 327                 mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN;
 328     }
 329
 330     /** Returns whether the next thumbnail transition is scaling up. */
 331     boolean isNextThumbnailTransitionScaleUp() {
 332         return mNextAppTransitionScaleUp;
 333     }
 334
 335     boolean isNextAppTransitionThumbnailUp() {
 336         return mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP ||
 337                 mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP;
 338     }
 339
 340     boolean isNextAppTransitionThumbnailDown() {
 341         return mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN ||
 342                 mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN;
 343     }
 344
 345     /**
 346      * @return true if and only if we are currently fetching app transition specs from the future
 347      *         passed into {@link #overridePendingAppTransitionMultiThumbFuture}
 348      */
 349     boolean isFetchingAppTransitionsSpecs() {
 350         return mNextAppTransitionAnimationsSpecsPending;
 351     }
 352
 353     private boolean prepare() {
 354         if (!isRunning()) {
 355             mAppTransitionState = APP_STATE_IDLE;
 356             notifyAppTransitionPendingLocked();
 357             mLastHadClipReveal = false;
 358             mLastClipRevealMaxTranslation = 0;
 359             mLastClipRevealTransitionDuration = DEFAULT_APP_TRANSITION_DURATION;
 360             return true;
 361         }
 362         return false;
 363     }
 364
 365     void goodToGo(AppWindowAnimator topOpeningAppAnimator, AppWindowAnimator topClosingAppAnimator,
 366             ArraySet<AppWindowToken> openingApps, ArraySet<AppWindowToken> closingApps) {
 367         mNextAppTransition = TRANSIT_UNSET;
 368         mAppTransitionState = APP_STATE_RUNNING;
 369         notifyAppTransitionStartingLocked(
 370                 topOpeningAppAnimator != null ? topOpeningAppAnimator.mAppToken.token : null,
 371                 topClosingAppAnimator != null ? topClosingAppAnimator.mAppToken.token : null,
 372                 topOpeningAppAnimator != null ? topOpeningAppAnimator.animation : null,
 373                 topClosingAppAnimator != null ? topClosingAppAnimator.animation : null);
 374         mService.getDefaultDisplayContentLocked().getDockedDividerController()
 375                 .notifyAppTransitionStarting();
 376
 377         // Prolong the start for the transition when docking a task from recents, unless recents
 378         // ended it already then we don't need to wait.
 379         if (mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS && !mProlongedAnimationsEnded) {
 380             for (int i = openingApps.size() - 1; i >= 0; i--) {
 381                 final AppWindowAnimator appAnimator = openingApps.valueAt(i).mAppAnimator;
 382                 appAnimator.startProlongAnimation(PROLONG_ANIMATION_AT_START);
 383             }
 384         }
 385     }
 386
 387     /**
 388      * Let the transitions manager know that the somebody wanted to end the prolonged animations.
 389      */
 390     void notifyProlongedAnimationsEnded() {
 391         mProlongedAnimationsEnded = true;
 392     }
 393
 394     void clear() {
 395         mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE;
 396         mNextAppTransitionPackage = null;
 397         mNextAppTransitionAnimationsSpecs.clear();
 398         mNextAppTransitionAnimationsSpecsFuture = null;
 399         mDefaultNextAppTransitionAnimationSpec = null;
 400         mAnimationFinishedCallback = null;
 401         mProlongedAnimationsEnded = false;
 402     }
 403
 404     void freeze() {
 405         setAppTransition(AppTransition.TRANSIT_UNSET);
 406         clear();
 407         setReady();
 408         notifyAppTransitionCancelledLocked();
 409     }
 410
 411     void registerListenerLocked(AppTransitionListener listener) {
 412         mListeners.add(listener);
 413     }
 414
 415     public void notifyAppTransitionFinishedLocked(IBinder token) {
 416         for (int i = 0; i < mListeners.size(); i++) {
 417             mListeners.get(i).onAppTransitionFinishedLocked(token);
 418         }
 419     }
 420
 421     private void notifyAppTransitionPendingLocked() {
 422         for (int i = 0; i < mListeners.size(); i++) {
 423             mListeners.get(i).onAppTransitionPendingLocked();
 424         }
 425     }
 426
 427     private void notifyAppTransitionCancelledLocked() {
 428         for (int i = 0; i < mListeners.size(); i++) {
 429             mListeners.get(i).onAppTransitionCancelledLocked();
 430         }
 431     }
 432
 433     private void notifyAppTransitionStartingLocked(IBinder openToken,
 434             IBinder closeToken, Animation openAnimation, Animation closeAnimation) {
 435         for (int i = 0; i < mListeners.size(); i++) {
 436             mListeners.get(i).onAppTransitionStartingLocked(openToken, closeToken, openAnimation,
 437                     closeAnimation);
 438         }
 439     }
 440
 441     private AttributeCache.Entry getCachedAnimations(WindowManager.LayoutParams lp) {
 442         if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: layout params pkg="
 443                 + (lp != null ? lp.packageName : null)
 444                 + " resId=0x" + (lp != null ? Integer.toHexString(lp.windowAnimations) : null));
 445         if (lp != null && lp.windowAnimations != 0) {
 446             // If this is a system resource, don't try to load it from the
 447             // application resources.  It is nice to avoid loading application
 448             // resources if we can.
 449             String packageName = lp.packageName != null ? lp.packageName : "android";
 450             int resId = lp.windowAnimations;
 451             if ((resId&0xFF000000) == 0x01000000) {
 452                 packageName = "android";
 453             }
 454             if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: picked package="
 455                     + packageName);
 456             return AttributeCache.instance().get(packageName, resId,
 457                     com.android.internal.R.styleable.WindowAnimation, mCurrentUserId);
 458         }
 459         return null;
 460     }
 461
 462     private AttributeCache.Entry getCachedAnimations(String packageName, int resId) {
 463         if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: package="
 464                 + packageName + " resId=0x" + Integer.toHexString(resId));
 465         if (packageName != null) {
 466             if ((resId&0xFF000000) == 0x01000000) {
 467                 packageName = "android";
 468             }
 469             if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: picked package="
 470                     + packageName);
 471             return AttributeCache.instance().get(packageName, resId,
 472                     com.android.internal.R.styleable.WindowAnimation, mCurrentUserId);
 473         }
 474         return null;
 475     }
 476
 477     Animation loadAnimationAttr(WindowManager.LayoutParams lp, int animAttr) {
 478         int anim = 0;
 479         Context context = mContext;
 480         if (animAttr >= 0) {
 481             AttributeCache.Entry ent = getCachedAnimations(lp);
 482             if (ent != null) {
 483                 context = ent.context;
 484                 anim = ent.array.getResourceId(animAttr, 0);
 485             }
 486         }
 487         if (anim != 0) {
 488             return AnimationUtils.loadAnimation(context, anim);
 489         }
 490         return null;
 491     }
 492
 493     Animation loadAnimationRes(WindowManager.LayoutParams lp, int resId) {
 494         Context context = mContext;
 495         if (resId >= 0) {
 496             AttributeCache.Entry ent = getCachedAnimations(lp);
 497             if (ent != null) {
 498                 context = ent.context;
 499             }
 500             return AnimationUtils.loadAnimation(context, resId);
 501         }
 502         return null;
 503     }
 504
 505     private Animation loadAnimationRes(String packageName, int resId) {
 506         int anim = 0;
 507         Context context = mContext;
 508         if (resId >= 0) {
 509             AttributeCache.Entry ent = getCachedAnimations(packageName, resId);
 510             if (ent != null) {
 511                 context = ent.context;
 512                 anim = resId;
 513             }
 514         }
 515         if (anim != 0) {
 516             return AnimationUtils.loadAnimation(context, anim);
 517         }
 518         return null;
 519     }
 520
 521     /**
 522      * Compute the pivot point for an animation that is scaling from a small
 523      * rect on screen to a larger rect.  The pivot point varies depending on
 524      * the distance between the inner and outer edges on both sides.  This
 525      * function computes the pivot point for one dimension.
 526      * @param startPos  Offset from left/top edge of outer rectangle to
 527      * left/top edge of inner rectangle.
 528      * @param finalScale The scaling factor between the size of the outer
 529      * and inner rectangles.
 530      */
 531     private static float computePivot(int startPos, float finalScale) {
 532
 533         /*
 534         Theorem of intercepting lines:
 535
 536           +      +   +-----------------------------------------------+
 537           |      |   |                                               |
 538           |      |   |                                               |
 539           |      |   |                                               |
 540           |      |   |                                               |
 541         x |    y |   |                                               |
 542           |      |   |                                               |
 543           |      |   |                                               |
 544           |      |   |                                               |
 545           |      |   |                                               |
 546           |      +   |             +--------------------+            |
 547           |          |             |                    |            |
 548           |          |             |                    |            |
 549           |          |             |                    |            |
 550           |          |             |                    |            |
 551           |          |             |                    |            |
 552           |          |             |                    |            |
 553           |          |             |                    |            |
 554           |          |             |                    |            |
 555           |          |             |                    |            |
 556           |          |             |                    |            |
 557           |          |             |                    |            |
 558           |          |             |                    |            |
 559           |          |             |                    |            |
 560           |          |             |                    |            |
 561           |          |             |                    |            |
 562           |          |             |                    |            |
 563           |          |             |                    |            |
 564           |          |             +--------------------+            |
 565           |          |                                               |
 566           |          |                                               |
 567           |          |                                               |
 568           |          |                                               |
 569           |          |                                               |
 570           |          |                                               |
 571           |          |                                               |
 572           |          +-----------------------------------------------+
 573           |
 574           |
 575           |
 576           |
 577           |
 578           |
 579           |
 580           |
 581           |
 582           +                                 ++
 583                                          p  ++
 584
 585         scale = (x - y) / x
 586         <=> x = -y / (scale - 1)
 587         */
 588         final float denom = finalScale-1;
 589         if (Math.abs(denom) < .0001f) {
 590             return startPos;
 591         }
 592         return -startPos / denom;
 593     }
 594
 595     private Animation createScaleUpAnimationLocked(int transit, boolean enter,
 596             Rect containingFrame) {
 597         Animation a;
 598         getDefaultNextAppTransitionStartRect(mTmpRect);
 599         final int appWidth = containingFrame.width();
 600         final int appHeight = containingFrame.height();
 601         if (enter) {
 602             // Entering app zooms out from the center of the initial rect.
 603             float scaleW = mTmpRect.width() / (float) appWidth;
 604             float scaleH = mTmpRect.height() / (float) appHeight;
 605             Animation scale = new ScaleAnimation(scaleW, 1, scaleH, 1,
 606                     computePivot(mTmpRect.left, scaleW),
 607                     computePivot(mTmpRect.right, scaleH));
 608             scale.setInterpolator(mDecelerateInterpolator);
 609
 610             Animation alpha = new AlphaAnimation(0, 1);
 611             alpha.setInterpolator(mThumbnailFadeOutInterpolator);
 612
 613             AnimationSet set = new AnimationSet(false);
 614             set.addAnimation(scale);
 615             set.addAnimation(alpha);
 616             set.setDetachWallpaper(true);
 617             a = set;
 618         } else  if (transit == TRANSIT_WALLPAPER_INTRA_OPEN ||
 619                     transit == TRANSIT_WALLPAPER_INTRA_CLOSE) {
 620             // If we are on top of the wallpaper, we need an animation that
 621             // correctly handles the wallpaper staying static behind all of
 622             // the animated elements.  To do this, will just have the existing
 623             // element fade out.
 624             a = new AlphaAnimation(1, 0);
 625             a.setDetachWallpaper(true);
 626         } else {
 627             // For normal animations, the exiting element just holds in place.
 628             a = new AlphaAnimation(1, 1);
 629         }
 630
 631         // Pick the desired duration.  If this is an inter-activity transition,
 632         // it  is the standard duration for that.  Otherwise we use the longer
 633         // task transition duration.
 634         final long duration;
 635         switch (transit) {
 636             case TRANSIT_ACTIVITY_OPEN:
 637             case TRANSIT_ACTIVITY_CLOSE:
 638                 duration = mConfigShortAnimTime;
 639                 break;
 640             default:
 641                 duration = DEFAULT_APP_TRANSITION_DURATION;
 642                 break;
 643         }
 644         a.setDuration(duration);
 645         a.setFillAfter(true);
 646         a.setInterpolator(mDecelerateInterpolator);
 647         a.initialize(appWidth, appHeight, appWidth, appHeight);
 648         return a;
 649     }
 650
 651     private void getDefaultNextAppTransitionStartRect(Rect rect) {
 652         if (mDefaultNextAppTransitionAnimationSpec == null ||
 653                 mDefaultNextAppTransitionAnimationSpec.rect == null) {
 654             Slog.wtf(TAG, "Starting rect for app requested, but none available", new Throwable());
 655             rect.setEmpty();
 656         } else {
 657             rect.set(mDefaultNextAppTransitionAnimationSpec.rect);
 658         }
 659     }
 660
 661     void getNextAppTransitionStartRect(int taskId, Rect rect) {
 662         AppTransitionAnimationSpec spec = mNextAppTransitionAnimationsSpecs.get(taskId);
 663         if (spec == null) {
 664             spec = mDefaultNextAppTransitionAnimationSpec;
 665         }
 666         if (spec == null || spec.rect == null) {
 667             Slog.wtf(TAG, "Starting rect for task: " + taskId + " requested, but not available",
 668                     new Throwable());
 669             rect.setEmpty();
 670         } else {
 671             rect.set(spec.rect);
 672         }
 673     }
 674
 675     private void putDefaultNextAppTransitionCoordinates(int left, int top, int width, int height,
 676             Bitmap bitmap) {
 677         mDefaultNextAppTransitionAnimationSpec = new AppTransitionAnimationSpec(-1 /* taskId */,
 678                 bitmap, new Rect(left, top, left + width, top + height));
 679     }
 680
 681     /**
 682      * @return the duration of the last clip reveal animation
 683      */
 684     long getLastClipRevealTransitionDuration() {
 685         return mLastClipRevealTransitionDuration;
 686     }
 687
 688     /**
 689      * @return the maximum distance the app surface is traveling of the last clip reveal animation
 690      */
 691     int getLastClipRevealMaxTranslation() {
 692         return mLastClipRevealMaxTranslation;
 693     }
 694
 695     /**
 696      * @return true if in the last app transition had a clip reveal animation, false otherwise
 697      */
 698     boolean hadClipRevealAnimation() {
 699         return mLastHadClipReveal;
 700     }
 701
 702     /**
 703      * Calculates the duration for the clip reveal animation. If the clip is "cut off", meaning that
 704      * the start rect is outside of the target rect, and there is a lot of movement going on.
 705      *
 706      * @param cutOff whether the start rect was not fully contained by the end rect
 707      * @param translationX the total translation the surface moves in x direction
 708      * @param translationY the total translation the surfaces moves in y direction
 709      * @param displayFrame our display frame
 710      *
 711      * @return the duration of the clip reveal animation, in milliseconds
 712      */
 713     private long calculateClipRevealTransitionDuration(boolean cutOff, float translationX,
 714             float translationY, Rect displayFrame) {
 715         if (!cutOff) {
 716             return DEFAULT_APP_TRANSITION_DURATION;
 717         }
 718         final float fraction = Math.max(Math.abs(translationX) / displayFrame.width(),
 719                 Math.abs(translationY) / displayFrame.height());
 720         return (long) (DEFAULT_APP_TRANSITION_DURATION + fraction *
 721                 (MAX_CLIP_REVEAL_TRANSITION_DURATION - DEFAULT_APP_TRANSITION_DURATION));
 722     }
 723
 724     private Animation createClipRevealAnimationLocked(int transit, boolean enter, Rect appFrame,
 725             Rect displayFrame) {
 726         final Animation anim;
 727         if (enter) {
 728             final int appWidth = appFrame.width();
 729             final int appHeight = appFrame.height();
 730
 731             // mTmpRect will contain an area around the launcher icon that was pressed. We will
 732             // clip reveal from that area in the final area of the app.
 733             getDefaultNextAppTransitionStartRect(mTmpRect);
 734
 735             float t = 0f;
 736             if (appHeight > 0) {
 737                 t = (float) mTmpRect.top / displayFrame.height();
 738             }
 739             int translationY = mClipRevealTranslationY + (int)(displayFrame.height() / 7f * t);
 740             int translationX = 0;
 741             int translationYCorrection = translationY;
 742             int centerX = mTmpRect.centerX();
 743             int centerY = mTmpRect.centerY();
 744             int halfWidth = mTmpRect.width() / 2;
 745             int halfHeight = mTmpRect.height() / 2;
 746             int clipStartX = centerX - halfWidth - appFrame.left;
 747             int clipStartY = centerY - halfHeight - appFrame.top;
 748             boolean cutOff = false;
 749
 750             // If the starting rectangle is fully or partially outside of the target rectangle, we
 751             // need to start the clipping at the edge and then achieve the rest with translation
 752             // and extending the clip rect from that edge.
 753             if (appFrame.top > centerY - halfHeight) {
 754                 translationY = (centerY - halfHeight) - appFrame.top;
 755                 translationYCorrection = 0;
 756                 clipStartY = 0;
 757                 cutOff = true;
 758             }
 759             if (appFrame.left > centerX - halfWidth) {
 760                 translationX = (centerX - halfWidth) - appFrame.left;
 761                 clipStartX = 0;
 762                 cutOff = true;
 763             }
 764             if (appFrame.right < centerX + halfWidth) {
 765                 translationX = (centerX + halfWidth) - appFrame.right;
 766                 clipStartX = appWidth - mTmpRect.width();
 767                 cutOff = true;
 768             }
 769             final long duration = calculateClipRevealTransitionDuration(cutOff, translationX,
 770                     translationY, displayFrame);
 771
 772             // Clip third of the from size of launch icon, expand to full width/height
 773             Animation clipAnimLR = new ClipRectLRAnimation(
 774                     clipStartX, clipStartX + mTmpRect.width(), 0, appWidth);
 775             clipAnimLR.setInterpolator(mClipHorizontalInterpolator);
 776             clipAnimLR.setDuration((long) (duration / 2.5f));
 777
 778             TranslateAnimation translate = new TranslateAnimation(translationX, 0, translationY, 0);
 779             translate.setInterpolator(cutOff ? TOUCH_RESPONSE_INTERPOLATOR
 780                     : mLinearOutSlowInInterpolator);
 781             translate.setDuration(duration);
 782
 783             Animation clipAnimTB = new ClipRectTBAnimation(
 784                     clipStartY, clipStartY + mTmpRect.height(),
 785                     0, appHeight,
 786                     translationYCorrection, 0,
 787                     mLinearOutSlowInInterpolator);
 788             clipAnimTB.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
 789             clipAnimTB.setDuration(duration);
 790
 791             // Quick fade-in from icon to app window
 792             final long alphaDuration = duration / 4;
 793             AlphaAnimation alpha = new AlphaAnimation(0.5f, 1);
 794             alpha.setDuration(alphaDuration);
 795             alpha.setInterpolator(mLinearOutSlowInInterpolator);
 796
 797             AnimationSet set = new AnimationSet(false);
 798             set.addAnimation(clipAnimLR);
 799             set.addAnimation(clipAnimTB);
 800             set.addAnimation(translate);
 801             set.addAnimation(alpha);
 802             set.setZAdjustment(Animation.ZORDER_TOP);
 803             set.initialize(appWidth, appHeight, appWidth, appHeight);
 804             anim = set;
 805             mLastHadClipReveal = true;
 806             mLastClipRevealTransitionDuration = duration;
 807
 808             // If the start rect was full inside the target rect (cutOff == false), we don't need
 809             // to store the translation, because it's only used if cutOff == true.
 810             mLastClipRevealMaxTranslation = cutOff
 811                     ? Math.max(Math.abs(translationY), Math.abs(translationX)) : 0;
 812         } else {
 813             final long duration;
 814             switch (transit) {
 815                 case TRANSIT_ACTIVITY_OPEN:
 816                 case TRANSIT_ACTIVITY_CLOSE:
 817                     duration = mConfigShortAnimTime;
 818                     break;
 819                 default:
 820                     duration = DEFAULT_APP_TRANSITION_DURATION;
 821                     break;
 822             }
 823             if (transit == TRANSIT_WALLPAPER_INTRA_OPEN ||
 824                     transit == TRANSIT_WALLPAPER_INTRA_CLOSE) {
 825                 // If we are on top of the wallpaper, we need an animation that
 826                 // correctly handles the wallpaper staying static behind all of
 827                 // the animated elements.  To do this, will just have the existing
 828                 // element fade out.
 829                 anim = new AlphaAnimation(1, 0);
 830                 anim.setDetachWallpaper(true);
 831             } else {
 832                 // For normal animations, the exiting element just holds in place.
 833                 anim = new AlphaAnimation(1, 1);
 834             }
 835             anim.setInterpolator(mDecelerateInterpolator);
 836             anim.setDuration(duration);
 837             anim.setFillAfter(true);
 838         }
 839         return anim;
 840     }
 841
 842     /**
 843      * Prepares the specified animation with a standard duration, interpolator, etc.
 844      */
 845     Animation prepareThumbnailAnimationWithDuration(Animation a, int appWidth, int appHeight,
 846             long duration, Interpolator interpolator) {
 847         if (duration > 0) {
 848             a.setDuration(duration);
 849         }
 850         a.setFillAfter(true);
 851         if (interpolator != null) {
 852             a.setInterpolator(interpolator);
 853         }
 854         a.initialize(appWidth, appHeight, appWidth, appHeight);
 855         return a;
 856     }
 857
 858     /**
 859      * Prepares the specified animation with a standard duration, interpolator, etc.
 860      */
 861     Animation prepareThumbnailAnimation(Animation a, int appWidth, int appHeight, int transit) {
 862         // Pick the desired duration.  If this is an inter-activity transition,
 863         // it  is the standard duration for that.  Otherwise we use the longer
 864         // task transition duration.
 865         final int duration;
 866         switch (transit) {
 867             case TRANSIT_ACTIVITY_OPEN:
 868             case TRANSIT_ACTIVITY_CLOSE:
 869                 duration = mConfigShortAnimTime;
 870                 break;
 871             default:
 872                 duration = DEFAULT_APP_TRANSITION_DURATION;
 873                 break;
 874         }
 875         return prepareThumbnailAnimationWithDuration(a, appWidth, appHeight, duration,
 876                 mDecelerateInterpolator);
 877     }
 878
 879     /**
 880      * Return the current thumbnail transition state.
 881      */
 882     int getThumbnailTransitionState(boolean enter) {
 883         if (enter) {
 884             if (mNextAppTransitionScaleUp) {
 885                 return THUMBNAIL_TRANSITION_ENTER_SCALE_UP;
 886             } else {
 887                 return THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN;
 888             }
 889         } else {
 890             if (mNextAppTransitionScaleUp) {
 891                 return THUMBNAIL_TRANSITION_EXIT_SCALE_UP;
 892             } else {
 893                 return THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN;
 894             }
 895         }
 896     }
 897
 898     /**
 899      * This animation runs for the thumbnail that gets cross faded with the enter/exit activity
 900      * when a thumbnail is specified with the pending animation override.
 901      */
 902     Animation createThumbnailAspectScaleAnimationLocked(Rect appRect, @Nullable Rect contentInsets,
 903             Bitmap thumbnailHeader, final int taskId, int uiMode, int orientation) {
 904         Animation a;
 905         final int thumbWidthI = thumbnailHeader.getWidth();
 906         final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
 907         final int thumbHeightI = thumbnailHeader.getHeight();
 908         final int appWidth = appRect.width();
 909
 910         float scaleW = appWidth / thumbWidth;
 911         getNextAppTransitionStartRect(taskId, mTmpRect);
 912         final float fromX;
 913         final float fromY;
 914         final float toX;
 915         final float toY;
 916         final float pivotX;
 917         final float pivotY;
 918         if (isTvUiMode(uiMode) || orientation == Configuration.ORIENTATION_PORTRAIT) {
 919             fromX = mTmpRect.left;
 920             fromY = mTmpRect.top;
 921
 922             // For the curved translate animation to work, the pivot points needs to be at the
 923             // same absolute position as the one from the real surface.
 924             toX = mTmpRect.width() / 2 * (scaleW - 1f) + appRect.left;
 925             toY = appRect.height() / 2 * (1 - 1 / scaleW) + appRect.top;
 926             pivotX = mTmpRect.width() / 2;
 927             pivotY = appRect.height() / 2 / scaleW;
 928         } else {
 929             pivotX = 0;
 930             pivotY = 0;
 931             fromX = mTmpRect.left;
 932             fromY = mTmpRect.top;
 933             toX = appRect.left;
 934             toY = appRect.top;
 935         }
 936         final long duration = getAspectScaleDuration();
 937         final Interpolator interpolator = getAspectScaleInterpolator();
 938         if (mNextAppTransitionScaleUp) {
 939             // Animation up from the thumbnail to the full screen
 940             Animation scale = new ScaleAnimation(1f, scaleW, 1f, scaleW, pivotX, pivotY);
 941             scale.setInterpolator(interpolator);
 942             scale.setDuration(duration);
 943             Animation alpha = new AlphaAnimation(1f, 0f);
 944             alpha.setInterpolator(mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS
 945                     ? THUMBNAIL_DOCK_INTERPOLATOR : mThumbnailFadeOutInterpolator);
 946             alpha.setDuration(mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS
 947                     ? duration / 2
 948                     : duration);
 949             Animation translate = createCurvedMotion(fromX, toX, fromY, toY);
 950             translate.setInterpolator(interpolator);
 951             translate.setDuration(duration);
 952
 953             mTmpFromClipRect.set(0, 0, thumbWidthI, thumbHeightI);
 954             mTmpToClipRect.set(appRect);
 955
 956             // Containing frame is in screen space, but we need the clip rect in the
 957             // app space.
 958             mTmpToClipRect.offsetTo(0, 0);
 959             mTmpToClipRect.right = (int) (mTmpToClipRect.right / scaleW);
 960             mTmpToClipRect.bottom = (int) (mTmpToClipRect.bottom / scaleW);
 961
 962             if (contentInsets != null) {
 963                 mTmpToClipRect.inset((int) (-contentInsets.left * scaleW),
 964                         (int) (-contentInsets.top * scaleW),
 965                         (int) (-contentInsets.right * scaleW),
 966                         (int) (-contentInsets.bottom * scaleW));
 967             }
 968
 969             Animation clipAnim = new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect);
 970             clipAnim.setInterpolator(interpolator);
 971             clipAnim.setDuration(duration);
 972
 973             // This AnimationSet uses the Interpolators assigned above.
 974             AnimationSet set = new AnimationSet(false);
 975             set.addAnimation(scale);
 976             set.addAnimation(alpha);
 977             set.addAnimation(translate);
 978             set.addAnimation(clipAnim);
 979             a = set;
 980         } else {
 981             // Animation down from the full screen to the thumbnail
 982             Animation scale = new ScaleAnimation(scaleW, 1f, scaleW, 1f, pivotX, pivotY);
 983             scale.setInterpolator(interpolator);
 984             scale.setDuration(duration);
 985             Animation alpha = new AlphaAnimation(0f, 1f);
 986             alpha.setInterpolator(mThumbnailFadeInInterpolator);
 987             alpha.setDuration(duration);
 988             Animation translate = createCurvedMotion(toX, fromX, toY, fromY);
 989             translate.setInterpolator(interpolator);
 990             translate.setDuration(duration);
 991
 992             // This AnimationSet uses the Interpolators assigned above.
 993             AnimationSet set = new AnimationSet(false);
 994             set.addAnimation(scale);
 995             set.addAnimation(alpha);
 996             set.addAnimation(translate);
 997             a = set;
 998
 999         }
1000         return prepareThumbnailAnimationWithDuration(a, appWidth, appRect.height(), 0,
1001                 null);
1002     }
1003
1004     private Animation createCurvedMotion(float fromX, float toX, float fromY, float toY) {
1005
1006         // Almost no x-change - use linear animation
1007         if (Math.abs(toX - fromX) < 1f || mNextAppTransition != TRANSIT_DOCK_TASK_FROM_RECENTS) {
1008             return new TranslateAnimation(fromX, toX, fromY, toY);
1009         } else {
1010             final Path path = createCurvedPath(fromX, toX, fromY, toY);
1011             return new CurvedTranslateAnimation(path);
1012         }
1013     }
1014
1015     private Path createCurvedPath(float fromX, float toX, float fromY, float toY) {
1016         final Path path = new Path();
1017         path.moveTo(fromX, fromY);
1018
1019         if (fromY > toY) {
1020             // If the object needs to go up, move it in horizontal direction first, then vertical.
1021             path.cubicTo(fromX, fromY, toX, 0.9f * fromY + 0.1f * toY, toX, toY);
1022         } else {
1023             // If the object needs to go down, move it in vertical direction first, then horizontal.
1024             path.cubicTo(fromX, fromY, fromX, 0.1f * fromY + 0.9f * toY, toX, toY);
1025         }
1026         return path;
1027     }
1028
1029     private long getAspectScaleDuration() {
1030         if (mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS) {
1031             return (long) (THUMBNAIL_APP_TRANSITION_DURATION * 1.35f);
1032         } else {
1033             return THUMBNAIL_APP_TRANSITION_DURATION;
1034         }
1035     }
1036
1037     private Interpolator getAspectScaleInterpolator() {
1038         if (mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS) {
1039             return mFastOutSlowInInterpolator;
1040         } else {
1041             return TOUCH_RESPONSE_INTERPOLATOR;
1042         }
1043     }
1044
1045     /**
1046      * This alternate animation is created when we are doing a thumbnail transition, for the
1047      * activity that is leaving, and the activity that is entering.
1048      */
1049     Animation createAspectScaledThumbnailEnterExitAnimationLocked(int thumbTransitState,
1050             int uiMode, int orientation, int transit, Rect containingFrame, Rect contentInsets,
1051             @Nullable Rect surfaceInsets, boolean freeform, int taskId) {
1052         Animation a;
1053         final int appWidth = containingFrame.width();
1054         final int appHeight = containingFrame.height();
1055         getDefaultNextAppTransitionStartRect(mTmpRect);
1056         final int thumbWidthI = mTmpRect.width();
1057         final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
1058         final int thumbHeightI = mTmpRect.height();
1059         final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1;
1060         final int thumbStartX = mTmpRect.left - containingFrame.left;
1061         final int thumbStartY = mTmpRect.top - containingFrame.top;
1062
1063         switch (thumbTransitState) {
1064             case THUMBNAIL_TRANSITION_ENTER_SCALE_UP:
1065             case THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN: {
1066                 final boolean scaleUp = thumbTransitState == THUMBNAIL_TRANSITION_ENTER_SCALE_UP;
1067                 if (freeform && scaleUp) {
1068                     a = createAspectScaledThumbnailEnterFreeformAnimationLocked(
1069                             containingFrame, surfaceInsets, taskId);
1070                 } else if (freeform) {
1071                     a = createAspectScaledThumbnailExitFreeformAnimationLocked(
1072                             containingFrame, surfaceInsets, taskId);
1073                 } else {
1074                     AnimationSet set = new AnimationSet(true);
1075
1076                     // In portrait, we scale to fit the width
1077                     mTmpFromClipRect.set(containingFrame);
1078                     mTmpToClipRect.set(containingFrame);
1079
1080                     // Containing frame is in screen space, but we need the clip rect in the
1081                     // app space.
1082                     mTmpFromClipRect.offsetTo(0, 0);
1083                     mTmpToClipRect.offsetTo(0, 0);
1084
1085                     // Exclude insets region from the source clip.
1086                     mTmpFromClipRect.inset(contentInsets);
1087                     mNextAppTransitionInsets.set(contentInsets);
1088
1089                     if (isTvUiMode(uiMode) || orientation == Configuration.ORIENTATION_PORTRAIT) {
1090                         // We scale the width and clip to the top/left square
1091                         float scale = thumbWidth /
1092                                 (appWidth - contentInsets.left - contentInsets.right);
1093                         int unscaledThumbHeight = (int) (thumbHeight / scale);
1094                         mTmpFromClipRect.bottom = mTmpFromClipRect.top + unscaledThumbHeight;
1095
1096                         mNextAppTransitionInsets.set(contentInsets);
1097
1098                         Animation scaleAnim = new ScaleAnimation(
1099                                 scaleUp ? scale : 1, scaleUp ? 1 : scale,
1100                                 scaleUp ? scale : 1, scaleUp ? 1 : scale,
1101                                 containingFrame.width() / 2f,
1102                                 containingFrame.height() / 2f + contentInsets.top);
1103                         final float targetX = (mTmpRect.left - containingFrame.left);
1104                         final float x = containingFrame.width() / 2f
1105                                 - containingFrame.width() / 2f * scale;
1106                         final float targetY = (mTmpRect.top - containingFrame.top);
1107                         final float y = containingFrame.height() / 2f
1108                                 - containingFrame.height() / 2f * scale;
1109                         final float startX = targetX - x;
1110                         final float startY = targetY - y;
1111                         Animation clipAnim = scaleUp
1112                                 ? new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect)
1113                                 : new ClipRectAnimation(mTmpToClipRect, mTmpFromClipRect);
1114                         Animation translateAnim = scaleUp
1115                                 ? createCurvedMotion(startX, 0, startY - contentInsets.top, 0)
1116                                 : createCurvedMotion(0, startX, 0, startY - contentInsets.top);
1117
1118                         set.addAnimation(clipAnim);
1119                         set.addAnimation(scaleAnim);
1120                         set.addAnimation(translateAnim);
1121
1122                     } else {
1123                         // In landscape, we don't scale at all and only crop
1124                         mTmpFromClipRect.bottom = mTmpFromClipRect.top + thumbHeightI;
1125                         mTmpFromClipRect.right = mTmpFromClipRect.left + thumbWidthI;
1126
1127                         Animation clipAnim = scaleUp
1128                                 ? new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect)
1129                                 : new ClipRectAnimation(mTmpToClipRect, mTmpFromClipRect);
1130                         Animation translateAnim = scaleUp
1131                                 ? createCurvedMotion(thumbStartX, 0,
1132                                 thumbStartY - contentInsets.top, 0)
1133                                 : createCurvedMotion(0, thumbStartX, 0,
1134                                         thumbStartY - contentInsets.top);
1135
1136                         set.addAnimation(clipAnim);
1137                         set.addAnimation(translateAnim);
1138                     }
1139                     a = set;
1140                     a.setZAdjustment(Animation.ZORDER_TOP);
1141                 }
1142                 break;
1143             }
1144             case THUMBNAIL_TRANSITION_EXIT_SCALE_UP: {
1145                 // Previous app window during the scale up
1146                 if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) {
1147                     // Fade out the source activity if we are animating to a wallpaper
1148                     // activity.
1149                     a = new AlphaAnimation(1, 0);
1150                 } else {
1151                     a = new AlphaAnimation(1, 1);
1152                 }
1153                 break;
1154             }
1155             case THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN: {
1156                 // Target app window during the scale down
1157                 if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) {
1158                     // Fade in the destination activity if we are animating from a wallpaper
1159                     // activity.
1160                     a = new AlphaAnimation(0, 1);
1161                 } else {
1162                     a = new AlphaAnimation(1, 1);
1163                 }
1164                 break;
1165             }
1166             default:
1167                 throw new RuntimeException("Invalid thumbnail transition state");
1168         }
1169
1170         return prepareThumbnailAnimationWithDuration(a, appWidth, appHeight,
1171                 getAspectScaleDuration(), getAspectScaleInterpolator());
1172     }
1173
1174     private Animation createAspectScaledThumbnailEnterFreeformAnimationLocked(Rect frame,
1175             @Nullable Rect surfaceInsets, int taskId) {
1176         getNextAppTransitionStartRect(taskId, mTmpRect);
1177         return createAspectScaledThumbnailFreeformAnimationLocked(mTmpRect, frame, surfaceInsets,
1178                 true);
1179     }
1180
1181     private Animation createAspectScaledThumbnailExitFreeformAnimationLocked(Rect frame,
1182             @Nullable Rect surfaceInsets, int taskId) {
1183         getNextAppTransitionStartRect(taskId, mTmpRect);
1184         return createAspectScaledThumbnailFreeformAnimationLocked(frame, mTmpRect, surfaceInsets,
1185                 false);
1186     }
1187
1188     private AnimationSet createAspectScaledThumbnailFreeformAnimationLocked(Rect sourceFrame,
1189             Rect destFrame, @Nullable Rect surfaceInsets, boolean enter) {
1190         final float sourceWidth = sourceFrame.width();
1191         final float sourceHeight = sourceFrame.height();
1192         final float destWidth = destFrame.width();
1193         final float destHeight = destFrame.height();
1194         final float scaleH = enter ? sourceWidth / destWidth : destWidth / sourceWidth;
1195         final float scaleV = enter ? sourceHeight / destHeight : destHeight / sourceHeight;
1196         AnimationSet set = new AnimationSet(true);
1197         final int surfaceInsetsH = surfaceInsets == null
1198                 ? 0 : surfaceInsets.left + surfaceInsets.right;
1199         final int surfaceInsetsV = surfaceInsets == null
1200                 ? 0 : surfaceInsets.top + surfaceInsets.bottom;
1201         // We want the scaling to happen from the center of the surface. In order to achieve that,
1202         // we need to account for surface insets that will be used to enlarge the surface.
1203         final float scaleHCenter = ((enter ? destWidth : sourceWidth) + surfaceInsetsH) / 2;
1204         final float scaleVCenter = ((enter ? destHeight : sourceHeight) + surfaceInsetsV) / 2;
1205         final ScaleAnimation scale = enter ?
1206                 new ScaleAnimation(scaleH, 1, scaleV, 1, scaleHCenter, scaleVCenter)
1207                 : new ScaleAnimation(1, scaleH, 1, scaleV, scaleHCenter, scaleVCenter);
1208         final int sourceHCenter = sourceFrame.left + sourceFrame.width() / 2;
1209         final int sourceVCenter = sourceFrame.top + sourceFrame.height() / 2;
1210         final int destHCenter = destFrame.left + destFrame.width() / 2;
1211         final int destVCenter = destFrame.top + destFrame.height() / 2;
1212         final int fromX = enter ? sourceHCenter - destHCenter : destHCenter - sourceHCenter;
1213         final int fromY = enter ? sourceVCenter - destVCenter : destVCenter - sourceVCenter;
1214         final TranslateAnimation translation = enter ? new TranslateAnimation(fromX, 0, fromY, 0)
1215                 : new TranslateAnimation(0, fromX, 0, fromY);
1216         set.addAnimation(scale);
1217         set.addAnimation(translation);
1218
1219         final IRemoteCallback callback = mAnimationFinishedCallback;
1220         if (callback != null) {
1221             set.setAnimationListener(new Animation.AnimationListener() {
1222                 @Override
1223                 public void onAnimationStart(Animation animation) { }
1224
1225                 @Override
1226                 public void onAnimationEnd(Animation animation) {
1227                     mService.mH.obtainMessage(H.DO_ANIMATION_CALLBACK, callback).sendToTarget();
1228                 }
1229
1230                 @Override
1231                 public void onAnimationRepeat(Animation animation) { }
1232             });
1233         }
1234         return set;
1235     }
1236
1237     /**
1238      * This animation runs for the thumbnail that gets cross faded with the enter/exit activity
1239      * when a thumbnail is specified with the pending animation override.
1240      */
1241     Animation createThumbnailScaleAnimationLocked(int appWidth, int appHeight, int transit,
1242             Bitmap thumbnailHeader) {
1243         Animation a;
1244         getDefaultNextAppTransitionStartRect(mTmpRect);
1245         final int thumbWidthI = thumbnailHeader.getWidth();
1246         final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
1247         final int thumbHeightI = thumbnailHeader.getHeight();
1248         final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1;
1249
1250         if (mNextAppTransitionScaleUp) {
1251             // Animation for the thumbnail zooming from its initial size to the full screen
1252             float scaleW = appWidth / thumbWidth;
1253             float scaleH = appHeight / thumbHeight;
1254             Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH,
1255                     computePivot(mTmpRect.left, 1 / scaleW),
1256                     computePivot(mTmpRect.top, 1 / scaleH));
1257             scale.setInterpolator(mDecelerateInterpolator);
1258
1259             Animation alpha = new AlphaAnimation(1, 0);
1260             alpha.setInterpolator(mThumbnailFadeOutInterpolator);
1261
1262             // This AnimationSet uses the Interpolators assigned above.
1263             AnimationSet set = new AnimationSet(false);
1264             set.addAnimation(scale);
1265             set.addAnimation(alpha);
1266             a = set;
1267         } else {
1268             // Animation for the thumbnail zooming down from the full screen to its final size
1269             float scaleW = appWidth / thumbWidth;
1270             float scaleH = appHeight / thumbHeight;
1271             a = new ScaleAnimation(scaleW, 1, scaleH, 1,
1272                     computePivot(mTmpRect.left, 1 / scaleW),
1273                     computePivot(mTmpRect.top, 1 / scaleH));
1274         }
1275
1276         return prepareThumbnailAnimation(a, appWidth, appHeight, transit);
1277     }
1278
1279     /**
1280      * This animation is created when we are doing a thumbnail transition, for the activity that is
1281      * leaving, and the activity that is entering.
1282      */
1283     Animation createThumbnailEnterExitAnimationLocked(int thumbTransitState, Rect containingFrame,
1284             int transit, int taskId) {
1285         final int appWidth = containingFrame.width();
1286         final int appHeight = containingFrame.height();
1287         Bitmap thumbnailHeader = getAppTransitionThumbnailHeader(taskId);
1288         Animation a;
1289         getDefaultNextAppTransitionStartRect(mTmpRect);
1290         final int thumbWidthI = thumbnailHeader != null ? thumbnailHeader.getWidth() : appWidth;
1291         final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
1292         final int thumbHeightI = thumbnailHeader != null ? thumbnailHeader.getHeight() : appHeight;
1293         final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1;
1294
1295         switch (thumbTransitState) {
1296             case THUMBNAIL_TRANSITION_ENTER_SCALE_UP: {
1297                 // Entering app scales up with the thumbnail
1298                 float scaleW = thumbWidth / appWidth;
1299                 float scaleH = thumbHeight / appHeight;
1300                 a = new ScaleAnimation(scaleW, 1, scaleH, 1,
1301                         computePivot(mTmpRect.left, scaleW),
1302                         computePivot(mTmpRect.top, scaleH));
1303                 break;
1304             }
1305             case THUMBNAIL_TRANSITION_EXIT_SCALE_UP: {
1306                 // Exiting app while the thumbnail is scaling up should fade or stay in place
1307                 if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) {
1308                     // Fade out while bringing up selected activity. This keeps the
1309                     // current activity from showing through a launching wallpaper
1310                     // activity.
1311                     a = new AlphaAnimation(1, 0);
1312                 } else {
1313                     // noop animation
1314                     a = new AlphaAnimation(1, 1);
1315                 }
1316                 break;
1317             }
1318             case THUMBNAIL_TRANSITION_ENTER_SCALE_DOWN: {
1319                 // Entering the other app, it should just be visible while we scale the thumbnail
1320                 // down above it
1321                 a = new AlphaAnimation(1, 1);
1322                 break;
1323             }
1324             case THUMBNAIL_TRANSITION_EXIT_SCALE_DOWN: {
1325                 // Exiting the current app, the app should scale down with the thumbnail
1326                 float scaleW = thumbWidth / appWidth;
1327                 float scaleH = thumbHeight / appHeight;
1328                 Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH,
1329                         computePivot(mTmpRect.left, scaleW),
1330                         computePivot(mTmpRect.top, scaleH));
1331
1332                 Animation alpha = new AlphaAnimation(1, 0);
1333
1334                 AnimationSet set = new AnimationSet(true);
1335                 set.addAnimation(scale);
1336                 set.addAnimation(alpha);
1337                 set.setZAdjustment(Animation.ZORDER_TOP);
1338                 a = set;
1339                 break;
1340             }
1341             default:
1342                 throw new RuntimeException("Invalid thumbnail transition state");
1343         }
1344
1345         return prepareThumbnailAnimation(a, appWidth, appHeight, transit);
1346     }
1347
1348     private Animation createRelaunchAnimation(Rect containingFrame, Rect contentInsets) {
1349         getDefaultNextAppTransitionStartRect(mTmpFromClipRect);
1350         final int left = mTmpFromClipRect.left;
1351         final int top = mTmpFromClipRect.top;
1352         mTmpFromClipRect.offset(-left, -top);
1353         // TODO: Isn't that strange that we ignore exact position of the containingFrame?
1354         mTmpToClipRect.set(0, 0, containingFrame.width(), containingFrame.height());
1355         AnimationSet set = new AnimationSet(true);
1356         float fromWidth = mTmpFromClipRect.width();
1357         float toWidth = mTmpToClipRect.width();
1358         float fromHeight = mTmpFromClipRect.height();
1359         // While the window might span the whole display, the actual content will be cropped to the
1360         // system decoration frame, for example when the window is docked. We need to take into
1361         // account the visible height when constructing the animation.
1362         float toHeight = mTmpToClipRect.height() - contentInsets.top - contentInsets.bottom;
1363         int translateAdjustment = 0;
1364         if (fromWidth <= toWidth && fromHeight <= toHeight) {
1365             // The final window is larger in both dimensions than current window (e.g. we are
1366             // maximizing), so we can simply unclip the new window and there will be no disappearing
1367             // frame.
1368             set.addAnimation(new ClipRectAnimation(mTmpFromClipRect, mTmpToClipRect));
1369         } else {
1370             // The disappearing window has one larger dimension. We need to apply scaling, so the
1371             // first frame of the entry animation matches the old window.
1372             set.addAnimation(new ScaleAnimation(fromWidth / toWidth, 1, fromHeight / toHeight, 1));
1373             // We might not be going exactly full screen, but instead be aligned under the status
1374             // bar using cropping. We still need to account for the cropped part, which will also
1375             // be scaled.
1376             translateAdjustment = (int) (contentInsets.top * fromHeight / toHeight);
1377         }
1378
1379         // We animate the translation from the old position of the removed window, to the new
1380         // position of the added window. The latter might not be full screen, for example docked for
1381         // docked windows.
1382         TranslateAnimation translate = new TranslateAnimation(left - containingFrame.left,
1383                 0, top - containingFrame.top - translateAdjustment, 0);
1384         set.addAnimation(translate);
1385         set.setDuration(DEFAULT_APP_TRANSITION_DURATION);
1386         set.setZAdjustment(Animation.ZORDER_TOP);
1387         return set;
1388     }
1389
1390     /**
1391      * @return true if and only if the first frame of the transition can be skipped, i.e. the first
1392      *         frame of the transition doesn't change the visuals on screen, so we can start
1393      *         directly with the second one
1394      */
1395     boolean canSkipFirstFrame() {
1396         return mNextAppTransitionType != NEXT_TRANSIT_TYPE_CUSTOM
1397                 && mNextAppTransitionType != NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE
1398                 && mNextAppTransitionType != NEXT_TRANSIT_TYPE_CLIP_REVEAL;
1399     }
1400
1401     /**
1402      *
1403      * @param frame These are the bounds of the window when it finishes the animation. This is where
1404      *              the animation must usually finish in entrance animation, as the next frame will
1405      *              display the window at these coordinates. In case of exit animation, this is
1406      *              where the animation must start, as the frame before the animation is displaying
1407      *              the window at these bounds.
1408      * @param insets Knowing where the window will be positioned is not enough. Some parts of the
1409      *               window might be obscured, usually by the system windows (status bar and
1410      *               navigation bar) and we use content insets to convey that information. This
1411      *               usually affects the animation aspects vertically, as the system decoration is
1412      *               at the top and the bottom. For example when we animate from full screen to
1413      *               recents, we want to exclude the covered parts, because they won't match the
1414      *               thumbnail after the last frame is executed.
1415      * @param surfaceInsets In rare situation the surface is larger than the content and we need to
1416      *                      know about this to make the animation frames match. We currently use
1417      *                      this for freeform windows, which have larger surfaces to display
1418      *                      shadows. When we animate them from recents, we want to match the content
1419      *                      to the recents thumbnail and hence need to account for the surface being
1420      *                      bigger.
1421      */
1422     Animation loadAnimation(WindowManager.LayoutParams lp, int transit, boolean enter, int uiMode,
1423             int orientation, Rect frame, Rect displayFrame, Rect insets,
1424             @Nullable Rect surfaceInsets, boolean isVoiceInteraction, boolean freeform,
1425             int taskId) {
1426         Animation a;
1427         if (isVoiceInteraction && (transit == TRANSIT_ACTIVITY_OPEN
1428                 || transit == TRANSIT_TASK_OPEN
1429                 || transit == TRANSIT_TASK_TO_FRONT)) {
1430             a = loadAnimationRes(lp, enter
1431                     ? com.android.internal.R.anim.voice_activity_open_enter
1432                     : com.android.internal.R.anim.voice_activity_open_exit);
1433             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1434                     "applyAnimation voice:"
1435                     + " anim=" + a + " transit=" + appTransitionToString(transit)
1436                     + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3));
1437         } else if (isVoiceInteraction && (transit == TRANSIT_ACTIVITY_CLOSE
1438                 || transit == TRANSIT_TASK_CLOSE
1439                 || transit == TRANSIT_TASK_TO_BACK)) {
1440             a = loadAnimationRes(lp, enter
1441                     ? com.android.internal.R.anim.voice_activity_close_enter
1442                     : com.android.internal.R.anim.voice_activity_close_exit);
1443             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1444                     "applyAnimation voice:"
1445                     + " anim=" + a + " transit=" + appTransitionToString(transit)
1446                     + " isEntrance=" + enter + " Callers=" + Debug.getCallers(3));
1447         } else if (transit == TRANSIT_ACTIVITY_RELAUNCH) {
1448             a = createRelaunchAnimation(frame, insets);
1449             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1450                     "applyAnimation:"
1451                     + " anim=" + a + " nextAppTransition=" + mNextAppTransition
1452                     + " transit=" + appTransitionToString(transit)
1453                     + " Callers=" + Debug.getCallers(3));
1454         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM) {
1455             a = loadAnimationRes(mNextAppTransitionPackage, enter ?
1456                     mNextAppTransitionEnter : mNextAppTransitionExit);
1457             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1458                     "applyAnimation:"
1459                     + " anim=" + a + " nextAppTransition=ANIM_CUSTOM"
1460                     + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
1461                     + " Callers=" + Debug.getCallers(3));
1462         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE) {
1463             a = loadAnimationRes(mNextAppTransitionPackage, mNextAppTransitionInPlace);
1464             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1465                     "applyAnimation:"
1466                     + " anim=" + a + " nextAppTransition=ANIM_CUSTOM_IN_PLACE"
1467                     + " transit=" + appTransitionToString(transit)
1468                     + " Callers=" + Debug.getCallers(3));
1469         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CLIP_REVEAL) {
1470             a = createClipRevealAnimationLocked(transit, enter, frame, displayFrame);
1471             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1472                     "applyAnimation:"
1473                             + " anim=" + a + " nextAppTransition=ANIM_CLIP_REVEAL"
1474                             + " transit=" + appTransitionToString(transit)
1475                             + " Callers=" + Debug.getCallers(3));
1476         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_SCALE_UP) {
1477             a = createScaleUpAnimationLocked(transit, enter, frame);
1478             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1479                     "applyAnimation:"
1480                     + " anim=" + a + " nextAppTransition=ANIM_SCALE_UP"
1481                     + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
1482                     + " Callers=" + Debug.getCallers(3));
1483         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP ||
1484                 mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN) {
1485             mNextAppTransitionScaleUp =
1486                     (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP);
1487             a = createThumbnailEnterExitAnimationLocked(getThumbnailTransitionState(enter),
1488                     frame, transit, taskId);
1489             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) {
1490                 String animName = mNextAppTransitionScaleUp ?
1491                         "ANIM_THUMBNAIL_SCALE_UP" : "ANIM_THUMBNAIL_SCALE_DOWN";
1492                 Slog.v(TAG, "applyAnimation:"
1493                         + " anim=" + a + " nextAppTransition=" + animName
1494                         + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
1495                         + " Callers=" + Debug.getCallers(3));
1496             }
1497         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP ||
1498                 mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN) {
1499             mNextAppTransitionScaleUp =
1500                     (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP);
1501             a = createAspectScaledThumbnailEnterExitAnimationLocked(
1502                     getThumbnailTransitionState(enter), uiMode, orientation, transit, frame,
1503                     insets, surfaceInsets, freeform, taskId);
1504             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) {
1505                 String animName = mNextAppTransitionScaleUp ?
1506                         "ANIM_THUMBNAIL_ASPECT_SCALE_UP" : "ANIM_THUMBNAIL_ASPECT_SCALE_DOWN";
1507                 Slog.v(TAG, "applyAnimation:"
1508                         + " anim=" + a + " nextAppTransition=" + animName
1509                         + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
1510                         + " Callers=" + Debug.getCallers(3));
1511             }
1512         } else {
1513             int animAttr = 0;
1514             switch (transit) {
1515                 case TRANSIT_ACTIVITY_OPEN:
1516                     animAttr = enter
1517                             ? WindowAnimation_activityOpenEnterAnimation
1518                             : WindowAnimation_activityOpenExitAnimation;
1519                     break;
1520                 case TRANSIT_ACTIVITY_CLOSE:
1521                     animAttr = enter
1522                             ? WindowAnimation_activityCloseEnterAnimation
1523                             : WindowAnimation_activityCloseExitAnimation;
1524                     break;
1525                 case TRANSIT_DOCK_TASK_FROM_RECENTS:
1526                 case TRANSIT_TASK_OPEN:
1527                     animAttr = enter
1528                             ? WindowAnimation_taskOpenEnterAnimation
1529                             : WindowAnimation_taskOpenExitAnimation;
1530                     break;
1531                 case TRANSIT_TASK_CLOSE:
1532                     animAttr = enter
1533                             ? WindowAnimation_taskCloseEnterAnimation
1534                             : WindowAnimation_taskCloseExitAnimation;
1535                     break;
1536                 case TRANSIT_TASK_TO_FRONT:
1537                     animAttr = enter
1538                             ? WindowAnimation_taskToFrontEnterAnimation
1539                             : WindowAnimation_taskToFrontExitAnimation;
1540                     break;
1541                 case TRANSIT_TASK_TO_BACK:
1542                     animAttr = enter
1543                             ? WindowAnimation_taskToBackEnterAnimation
1544                             : WindowAnimation_taskToBackExitAnimation;
1545                     break;
1546                 case TRANSIT_WALLPAPER_OPEN:
1547                     animAttr = enter
1548                             ? WindowAnimation_wallpaperOpenEnterAnimation
1549                             : WindowAnimation_wallpaperOpenExitAnimation;
1550                     break;
1551                 case TRANSIT_WALLPAPER_CLOSE:
1552                     animAttr = enter
1553                             ? WindowAnimation_wallpaperCloseEnterAnimation
1554                             : WindowAnimation_wallpaperCloseExitAnimation;
1555                     break;
1556                 case TRANSIT_WALLPAPER_INTRA_OPEN:
1557                     animAttr = enter
1558                             ? WindowAnimation_wallpaperIntraOpenEnterAnimation
1559                             : WindowAnimation_wallpaperIntraOpenExitAnimation;
1560                     break;
1561                 case TRANSIT_WALLPAPER_INTRA_CLOSE:
1562                     animAttr = enter
1563                             ? WindowAnimation_wallpaperIntraCloseEnterAnimation
1564                             : WindowAnimation_wallpaperIntraCloseExitAnimation;
1565                     break;
1566                 case TRANSIT_TASK_OPEN_BEHIND:
1567                     animAttr = enter
1568                             ? WindowAnimation_launchTaskBehindSourceAnimation
1569                             : WindowAnimation_launchTaskBehindTargetAnimation;
1570             }
1571             a = animAttr != 0 ? loadAnimationAttr(lp, animAttr) : null;
1572             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
1573                     "applyAnimation:"
1574                     + " anim=" + a
1575                     + " animAttr=0x" + Integer.toHexString(animAttr)
1576                     + " transit=" + appTransitionToString(transit) + " isEntrance=" + enter
1577                     + " Callers=" + Debug.getCallers(3));
1578         }
1579         return a;
1580     }
1581
1582     int getAppStackClipMode() {
1583         return mNextAppTransition == TRANSIT_ACTIVITY_RELAUNCH
1584                 || mNextAppTransition == TRANSIT_DOCK_TASK_FROM_RECENTS
1585                 || mNextAppTransitionType == NEXT_TRANSIT_TYPE_CLIP_REVEAL
1586                 ? STACK_CLIP_NONE
1587                 : STACK_CLIP_AFTER_ANIM;
1588     }
1589
1590     void postAnimationCallback() {
1591         if (mNextAppTransitionCallback != null) {
1592             mService.mH.sendMessage(mService.mH.obtainMessage(H.DO_ANIMATION_CALLBACK,
1593                     mNextAppTransitionCallback));
1594             mNextAppTransitionCallback = null;
1595         }
1596     }
1597
1598     void overridePendingAppTransition(String packageName, int enterAnim, int exitAnim,
1599             IRemoteCallback startedCallback) {
1600         if (isTransitionSet()) {
1601             clear();
1602             mNextAppTransitionType = NEXT_TRANSIT_TYPE_CUSTOM;
1603             mNextAppTransitionPackage = packageName;
1604             mNextAppTransitionEnter = enterAnim;
1605             mNextAppTransitionExit = exitAnim;
1606             postAnimationCallback();
1607             mNextAppTransitionCallback = startedCallback;
1608         } else {
1609             postAnimationCallback();
1610         }
1611     }
1612
1613     void overridePendingAppTransitionScaleUp(int startX, int startY, int startWidth,
1614             int startHeight) {
1615         if (isTransitionSet()) {
1616             clear();
1617             mNextAppTransitionType = NEXT_TRANSIT_TYPE_SCALE_UP;
1618             putDefaultNextAppTransitionCoordinates(startX, startY, startX + startWidth,
1619                     startY + startHeight, null);
1620             postAnimationCallback();
1621         }
1622     }
1623
1624     void overridePendingAppTransitionClipReveal(int startX, int startY,
1625                                                 int startWidth, int startHeight) {
1626         if (isTransitionSet()) {
1627             clear();
1628             mNextAppTransitionType = NEXT_TRANSIT_TYPE_CLIP_REVEAL;
1629             putDefaultNextAppTransitionCoordinates(startX, startY, startWidth, startHeight, null);
1630             postAnimationCallback();
1631         }
1632     }
1633
1634     void overridePendingAppTransitionThumb(Bitmap srcThumb, int startX, int startY,
1635                                            IRemoteCallback startedCallback, boolean scaleUp) {
1636         if (isTransitionSet()) {
1637             clear();
1638             mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP
1639                     : NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN;
1640             mNextAppTransitionScaleUp = scaleUp;
1641             putDefaultNextAppTransitionCoordinates(startX, startY, 0, 0, srcThumb);
1642             postAnimationCallback();
1643             mNextAppTransitionCallback = startedCallback;
1644         } else {
1645             postAnimationCallback();
1646         }
1647     }
1648
1649     void overridePendingAppTransitionAspectScaledThumb(Bitmap srcThumb, int startX, int startY,
1650             int targetWidth, int targetHeight, IRemoteCallback startedCallback, boolean scaleUp) {
1651         if (isTransitionSet()) {
1652             clear();
1653             mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP
1654                     : NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN;
1655             mNextAppTransitionScaleUp = scaleUp;
1656             putDefaultNextAppTransitionCoordinates(startX, startY, targetWidth, targetHeight,
1657                     srcThumb);
1658             postAnimationCallback();
1659             mNextAppTransitionCallback = startedCallback;
1660         } else {
1661             postAnimationCallback();
1662         }
1663     }
1664
1665     public void overridePendingAppTransitionMultiThumb(AppTransitionAnimationSpec[] specs,
1666             IRemoteCallback onAnimationStartedCallback, IRemoteCallback onAnimationFinishedCallback,
1667             boolean scaleUp) {
1668         if (isTransitionSet()) {
1669             clear();
1670             mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP
1671                     : NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN;
1672             mNextAppTransitionScaleUp = scaleUp;
1673             if (specs != null) {
1674                 for (int i = 0; i < specs.length; i++) {
1675                     AppTransitionAnimationSpec spec = specs[i];
1676                     if (spec != null) {
1677                         mNextAppTransitionAnimationsSpecs.put(spec.taskId, spec);
1678                         if (i == 0) {
1679                             // In full screen mode, the transition code depends on the default spec
1680                             // to be set.
1681                             Rect rect = spec.rect;
1682                             putDefaultNextAppTransitionCoordinates(rect.left, rect.top,
1683                                     rect.width(), rect.height(), spec.bitmap);
1684                         }
1685                     }
1686                 }
1687             }
1688             postAnimationCallback();
1689             mNextAppTransitionCallback = onAnimationStartedCallback;
1690             mAnimationFinishedCallback = onAnimationFinishedCallback;
1691         } else {
1692             postAnimationCallback();
1693         }
1694     }
1695
1696     void overridePendingAppTransitionMultiThumbFuture(
1697             IAppTransitionAnimationSpecsFuture specsFuture, IRemoteCallback callback,
1698             boolean scaleUp) {
1699         if (isTransitionSet()) {
1700             clear();
1701             mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP
1702                     : NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN;
1703             mNextAppTransitionAnimationsSpecsFuture = specsFuture;
1704             mNextAppTransitionScaleUp = scaleUp;
1705             mNextAppTransitionFutureCallback = callback;
1706         }
1707     }
1708
1709     void overrideInPlaceAppTransition(String packageName, int anim) {
1710         if (isTransitionSet()) {
1711             clear();
1712             mNextAppTransitionType = NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE;
1713             mNextAppTransitionPackage = packageName;
1714             mNextAppTransitionInPlace = anim;
1715         } else {
1716             postAnimationCallback();
1717         }
1718     }
1719
1720     /**
1721      * If a future is set for the app transition specs, fetch it in another thread.
1722      */
1723     private void fetchAppTransitionSpecsFromFuture() {
1724         if (mNextAppTransitionAnimationsSpecsFuture != null) {
1725             mNextAppTransitionAnimationsSpecsPending = true;
1726             final IAppTransitionAnimationSpecsFuture future
1727                     = mNextAppTransitionAnimationsSpecsFuture;
1728             mNextAppTransitionAnimationsSpecsFuture = null;
1729             mDefaultExecutor.execute(new Runnable() {
1730                 @Override
1731                 public void run() {
1732                     AppTransitionAnimationSpec[] specs = null;
1733                     try {
1734                         specs = future.get();
1735                     } catch (RemoteException e) {
1736                         Slog.w(TAG, "Failed to fetch app transition specs: " + e);
1737                     }
1738                     synchronized (mService.mWindowMap) {
1739                         mNextAppTransitionAnimationsSpecsPending = false;
1740                         overridePendingAppTransitionMultiThumb(specs,
1741                                 mNextAppTransitionFutureCallback, null /* finishedCallback */,
1742                                 mNextAppTransitionScaleUp);
1743                         mNextAppTransitionFutureCallback = null;
1744                         if (specs != null) {
1745                             mService.prolongAnimationsFromSpecs(specs, mNextAppTransitionScaleUp);
1746                         }
1747                     }
1748                     mService.requestTraversal();
1749                 }
1750             });
1751         }
1752     }
1753
1754     @Override
1755     public String toString() {
1756         return "mNextAppTransition=" + appTransitionToString(mNextAppTransition);
1757     }
1758
1759     /**
1760      * Returns the human readable name of a window transition.
1761      *
1762      * @param transition The window transition.
1763      * @return The transition symbolic name.
1764      */
1765     public static String appTransitionToString(int transition) {
1766         switch (transition) {
1767             case TRANSIT_UNSET: {
1768                 return "TRANSIT_UNSET";
1769             }
1770             case TRANSIT_NONE: {
1771                 return "TRANSIT_NONE";
1772             }
1773             case TRANSIT_ACTIVITY_OPEN: {
1774                 return "TRANSIT_ACTIVITY_OPEN";
1775             }
1776             case TRANSIT_ACTIVITY_CLOSE: {
1777                 return "TRANSIT_ACTIVITY_CLOSE";
1778             }
1779             case TRANSIT_TASK_OPEN: {
1780                 return "TRANSIT_TASK_OPEN";
1781             }
1782             case TRANSIT_TASK_CLOSE: {
1783                 return "TRANSIT_TASK_CLOSE";
1784             }
1785             case TRANSIT_TASK_TO_FRONT: {
1786                 return "TRANSIT_TASK_TO_FRONT";
1787             }
1788             case TRANSIT_TASK_TO_BACK: {
1789                 return "TRANSIT_TASK_TO_BACK";
1790             }
1791             case TRANSIT_WALLPAPER_CLOSE: {
1792                 return "TRANSIT_WALLPAPER_CLOSE";
1793             }
1794             case TRANSIT_WALLPAPER_OPEN: {
1795                 return "TRANSIT_WALLPAPER_OPEN";
1796             }
1797             case TRANSIT_WALLPAPER_INTRA_OPEN: {
1798                 return "TRANSIT_WALLPAPER_INTRA_OPEN";
1799             }
1800             case TRANSIT_WALLPAPER_INTRA_CLOSE: {
1801                 return "TRANSIT_WALLPAPER_INTRA_CLOSE";
1802             }
1803             case TRANSIT_TASK_OPEN_BEHIND: {
1804                 return "TRANSIT_TASK_OPEN_BEHIND";
1805             }
1806             case TRANSIT_ACTIVITY_RELAUNCH: {
1807                 return "TRANSIT_ACTIVITY_RELAUNCH";
1808             }
1809             case TRANSIT_DOCK_TASK_FROM_RECENTS: {
1810                 return "TRANSIT_DOCK_TASK_FROM_RECENTS";
1811             }
1812             default: {
1813                 return "<UNKNOWN>";
1814             }
1815         }
1816     }
1817
1818     private String appStateToString() {
1819         switch (mAppTransitionState) {
1820             case APP_STATE_IDLE:
1821                 return "APP_STATE_IDLE";
1822             case APP_STATE_READY:
1823                 return "APP_STATE_READY";
1824             case APP_STATE_RUNNING:
1825                 return "APP_STATE_RUNNING";
1826             case APP_STATE_TIMEOUT:
1827                 return "APP_STATE_TIMEOUT";
1828             default:
1829                 return "unknown state=" + mAppTransitionState;
1830         }
1831     }
1832
1833     private String transitTypeToString() {
1834         switch (mNextAppTransitionType) {
1835             case NEXT_TRANSIT_TYPE_NONE:
1836                 return "NEXT_TRANSIT_TYPE_NONE";
1837             case NEXT_TRANSIT_TYPE_CUSTOM:
1838                 return "NEXT_TRANSIT_TYPE_CUSTOM";
1839             case NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE:
1840                 return "NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE";
1841             case NEXT_TRANSIT_TYPE_SCALE_UP:
1842                 return "NEXT_TRANSIT_TYPE_SCALE_UP";
1843             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP:
1844                 return "NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP";
1845             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN:
1846                 return "NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN";
1847             case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP:
1848                 return "NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP";
1849             case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN:
1850                 return "NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN";
1851             default:
1852                 return "unknown type=" + mNextAppTransitionType;
1853         }
1854     }
1855
1856     @Override
1857     public void dump(PrintWriter pw, String prefix) {
1858         pw.print(prefix); pw.println(this);
1859         pw.print(prefix); pw.print("mAppTransitionState="); pw.println(appStateToString());
1860         if (mNextAppTransitionType != NEXT_TRANSIT_TYPE_NONE) {
1861             pw.print(prefix); pw.print("mNextAppTransitionType=");
1862                     pw.println(transitTypeToString());
1863         }
1864         switch (mNextAppTransitionType) {
1865             case NEXT_TRANSIT_TYPE_CUSTOM:
1866                 pw.print(prefix); pw.print("mNextAppTransitionPackage=");
1867                         pw.println(mNextAppTransitionPackage);
1868                 pw.print(prefix); pw.print("mNextAppTransitionEnter=0x");
1869                         pw.print(Integer.toHexString(mNextAppTransitionEnter));
1870                         pw.print(" mNextAppTransitionExit=0x");
1871                         pw.println(Integer.toHexString(mNextAppTransitionExit));
1872                 break;
1873             case NEXT_TRANSIT_TYPE_CUSTOM_IN_PLACE:
1874                 pw.print(prefix); pw.print("mNextAppTransitionPackage=");
1875                         pw.println(mNextAppTransitionPackage);
1876                 pw.print(prefix); pw.print("mNextAppTransitionInPlace=0x");
1877                         pw.print(Integer.toHexString(mNextAppTransitionInPlace));
1878                 break;
1879             case NEXT_TRANSIT_TYPE_SCALE_UP: {
1880                 getDefaultNextAppTransitionStartRect(mTmpRect);
1881                 pw.print(prefix); pw.print("mNextAppTransitionStartX=");
1882                         pw.print(mTmpRect.left);
1883                         pw.print(" mNextAppTransitionStartY=");
1884                         pw.println(mTmpRect.top);
1885                 pw.print(prefix); pw.print("mNextAppTransitionStartWidth=");
1886                         pw.print(mTmpRect.width());
1887                         pw.print(" mNextAppTransitionStartHeight=");
1888                         pw.println(mTmpRect.height());
1889                 break;
1890             }
1891             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP:
1892             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN:
1893             case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_UP:
1894             case NEXT_TRANSIT_TYPE_THUMBNAIL_ASPECT_SCALE_DOWN: {
1895                 pw.print(prefix); pw.print("mDefaultNextAppTransitionAnimationSpec=");
1896                         pw.println(mDefaultNextAppTransitionAnimationSpec);
1897                 pw.print(prefix); pw.print("mNextAppTransitionAnimationsSpecs=");
1898                         pw.println(mNextAppTransitionAnimationsSpecs);
1899                 pw.print(prefix); pw.print("mNextAppTransitionScaleUp=");
1900                         pw.println(mNextAppTransitionScaleUp);
1901                 break;
1902             }
1903         }
1904         if (mNextAppTransitionCallback != null) {
1905             pw.print(prefix); pw.print("mNextAppTransitionCallback=");
1906                     pw.println(mNextAppTransitionCallback);
1907         }
1908     }
1909
1910     public void setCurrentUser(int newUserId) {
1911         mCurrentUserId = newUserId;
1912     }
1913
1914     /**
1915      * @return true if transition is not running and should not be skipped, false if transition is
1916      *         already running
1917      */
1918     boolean prepareAppTransitionLocked(int transit, boolean alwaysKeepCurrent) {
1919         if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Prepare app transition:"
1920                 + " transit=" + appTransitionToString(transit)
1921                 + " " + this
1922                 + " alwaysKeepCurrent=" + alwaysKeepCurrent
1923                 + " Callers=" + Debug.getCallers(3));
1924         if (!isTransitionSet() || mNextAppTransition == TRANSIT_NONE) {
1925             setAppTransition(transit);
1926         } else if (!alwaysKeepCurrent) {
1927             if (transit == TRANSIT_TASK_OPEN && isTransitionEqual(TRANSIT_TASK_CLOSE)) {
1928                 // Opening a new task always supersedes a close for the anim.
1929                 setAppTransition(transit);
1930             } else if (transit == TRANSIT_ACTIVITY_OPEN
1931                     && isTransitionEqual(TRANSIT_ACTIVITY_CLOSE)) {
1932                 // Opening a new activity always supersedes a close for the anim.
1933                 setAppTransition(transit);
1934             }
1935         }
1936         boolean prepared = prepare();
1937         if (isTransitionSet()) {
1938             mService.mH.removeMessages(H.APP_TRANSITION_TIMEOUT);
1939             mService.mH.sendEmptyMessageDelayed(H.APP_TRANSITION_TIMEOUT, APP_TRANSITION_TIMEOUT_MS);
1940         }
1941         return prepared;
1942     }
1943
1944     /**
1945      * @return whether the specified {@param uiMode} is the TV mode.
1946      */
1947     private boolean isTvUiMode(int uiMode) {
1948         return (uiMode & Configuration.UI_MODE_TYPE_TELEVISION) > 0;
1949     }
1950 }