services/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 android.content.Context;
  20 import android.graphics.Bitmap;
  21 import android.graphics.Point;
  22 import android.os.Debug;
  23 import android.os.Handler;
  24 import android.os.IRemoteCallback;
  25 import android.util.Slog;
  26 import android.view.WindowManager;
  27 import android.view.animation.AlphaAnimation;
  28 import android.view.animation.Animation;
  29 import android.view.animation.AnimationSet;
  30 import android.view.animation.AnimationUtils;
  31 import android.view.animation.Interpolator;
  32 import android.view.animation.ScaleAnimation;
  33
  34 import com.android.internal.util.DumpUtils.Dump;
  35 import com.android.server.AttributeCache;
  36 import com.android.server.wm.WindowManagerService.H;
  37
  38 import java.io.PrintWriter;
  39
  40 import static com.android.internal.R.styleable.WindowAnimation_activityOpenEnterAnimation;
  41 import static com.android.internal.R.styleable.WindowAnimation_activityOpenExitAnimation;
  42 import static com.android.internal.R.styleable.WindowAnimation_activityCloseEnterAnimation;
  43 import static com.android.internal.R.styleable.WindowAnimation_activityCloseExitAnimation;
  44 import static com.android.internal.R.styleable.WindowAnimation_taskOpenEnterAnimation;
  45 import static com.android.internal.R.styleable.WindowAnimation_taskOpenExitAnimation;
  46 import static com.android.internal.R.styleable.WindowAnimation_taskCloseEnterAnimation;
  47 import static com.android.internal.R.styleable.WindowAnimation_taskCloseExitAnimation;
  48 import static com.android.internal.R.styleable.WindowAnimation_taskToFrontEnterAnimation;
  49 import static com.android.internal.R.styleable.WindowAnimation_taskToFrontExitAnimation;
  50 import static com.android.internal.R.styleable.WindowAnimation_taskToBackEnterAnimation;
  51 import static com.android.internal.R.styleable.WindowAnimation_taskToBackExitAnimation;
  52 import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenEnterAnimation;
  53 import static com.android.internal.R.styleable.WindowAnimation_wallpaperOpenExitAnimation;
  54 import static com.android.internal.R.styleable.WindowAnimation_wallpaperCloseEnterAnimation;
  55 import static com.android.internal.R.styleable.WindowAnimation_wallpaperCloseExitAnimation;
  56 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraOpenEnterAnimation;
  57 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraOpenExitAnimation;
  58 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseEnterAnimation;
  59 import static com.android.internal.R.styleable.WindowAnimation_wallpaperIntraCloseExitAnimation;
  60
  61 // State management of app transitions.  When we are preparing for a
  62 // transition, mNextAppTransition will be the kind of transition to
  63 // perform or TRANSIT_NONE if we are not waiting.  If we are waiting,
  64 // mOpeningApps and mClosingApps are the lists of tokens that will be
  65 // made visible or hidden at the next transition.
  66 public class AppTransition implements Dump {
  67     private static final String TAG = "AppTransition";
  68     private static final boolean DEBUG_APP_TRANSITIONS =
  69             WindowManagerService.DEBUG_APP_TRANSITIONS;
  70     private static final boolean DEBUG_ANIM = WindowManagerService.DEBUG_ANIM;
  71
  72     /** Bit mask that is set for all enter transition. */
  73     public static final int TRANSIT_ENTER_MASK = 0x1000;
  74
  75     /** Bit mask that is set for all exit transitions. */
  76     public static final int TRANSIT_EXIT_MASK = 0x2000;
  77
  78     /** Not set up for a transition. */
  79     public static final int TRANSIT_UNSET = -1;
  80     /** No animation for transition. */
  81     public static final int TRANSIT_NONE = 0;
  82     /** A window in a new activity is being opened on top of an existing one in the same task. */
  83     public static final int TRANSIT_ACTIVITY_OPEN = 6 | TRANSIT_ENTER_MASK;
  84     /** The window in the top-most activity is being closed to reveal the
  85      * previous activity in the same task. */
  86     public static final int TRANSIT_ACTIVITY_CLOSE = 7 | TRANSIT_EXIT_MASK;
  87     /** A window in a new task is being opened on top of an existing one
  88      * in another activity's task. */
  89     public static final int TRANSIT_TASK_OPEN = 8 | TRANSIT_ENTER_MASK;
  90     /** A window in the top-most activity is being closed to reveal the
  91      * previous activity in a different task. */
  92     public static final int TRANSIT_TASK_CLOSE = 9 | TRANSIT_EXIT_MASK;
  93     /** A window in an existing task is being displayed on top of an existing one
  94      * in another activity's task. */
  95     public static final int TRANSIT_TASK_TO_FRONT = 10 | TRANSIT_ENTER_MASK;
  96     /** A window in an existing task is being put below all other tasks. */
  97     public static final int TRANSIT_TASK_TO_BACK = 11 | TRANSIT_EXIT_MASK;
  98     /** A window in a new activity that doesn't have a wallpaper is being opened on top of one that
  99      * does, effectively closing the wallpaper. */
 100     public static final int TRANSIT_WALLPAPER_CLOSE = 12 | TRANSIT_EXIT_MASK;
 101     /** A window in a new activity that does have a wallpaper is being opened on one that didn't,
 102      * effectively opening the wallpaper. */
 103     public static final int TRANSIT_WALLPAPER_OPEN = 13 | TRANSIT_ENTER_MASK;
 104     /** A window in a new activity is being opened on top of an existing one, and both are on top
 105      * of the wallpaper. */
 106     public static final int TRANSIT_WALLPAPER_INTRA_OPEN = 14 | TRANSIT_ENTER_MASK;
 107     /** The window in the top-most activity is being closed to reveal the previous activity, and
 108      * both are on top of the wallpaper. */
 109     public static final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15 | TRANSIT_EXIT_MASK;
 110
 111     /** Fraction of animation at which the recents thumbnail becomes completely transparent */
 112     private static final float RECENTS_THUMBNAIL_FADEOUT_FRACTION = 0.25f;
 113
 114     private static final long DEFAULT_APP_TRANSITION_DURATION = 250;
 115
 116     private final Context mContext;
 117     private final Handler mH;
 118
 119     private int mNextAppTransition = TRANSIT_UNSET;
 120
 121     private static final int NEXT_TRANSIT_TYPE_NONE = 0;
 122     private static final int NEXT_TRANSIT_TYPE_CUSTOM = 1;
 123     private static final int NEXT_TRANSIT_TYPE_SCALE_UP = 2;
 124     private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP = 3;
 125     private static final int NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN = 4;
 126     private int mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE;
 127
 128     private String mNextAppTransitionPackage;
 129     private Bitmap mNextAppTransitionThumbnail;
 130     // Used for thumbnail transitions. True if we're scaling up, false if scaling down
 131     private boolean mNextAppTransitionScaleUp;
 132     private IRemoteCallback mNextAppTransitionCallback;
 133     private int mNextAppTransitionEnter;
 134     private int mNextAppTransitionExit;
 135     private int mNextAppTransitionStartX;
 136     private int mNextAppTransitionStartY;
 137     private int mNextAppTransitionStartWidth;
 138     private int mNextAppTransitionStartHeight;
 139
 140     private final static int APP_STATE_IDLE = 0;
 141     private final static int APP_STATE_READY = 1;
 142     private final static int APP_STATE_RUNNING = 2;
 143     private final static int APP_STATE_TIMEOUT = 3;
 144     private int mAppTransitionState = APP_STATE_IDLE;
 145
 146     private final int mConfigShortAnimTime;
 147     private final Interpolator mDecelerateInterpolator;
 148     private final Interpolator mThumbnailFadeoutInterpolator;
 149
 150     private int mCurrentUserId = 0;
 151
 152     AppTransition(Context context, Handler h) {
 153         mContext = context;
 154         mH = h;
 155         mConfigShortAnimTime = context.getResources().getInteger(
 156                 com.android.internal.R.integer.config_shortAnimTime);
 157         mDecelerateInterpolator = AnimationUtils.loadInterpolator(context,
 158                 com.android.internal.R.interpolator.decelerate_cubic);
 159         mThumbnailFadeoutInterpolator = new Interpolator() {
 160             @Override
 161             public float getInterpolation(float input) {
 162                 // Linear response for first fraction, then complete after that.
 163                 if (input < RECENTS_THUMBNAIL_FADEOUT_FRACTION) {
 164                     return input / RECENTS_THUMBNAIL_FADEOUT_FRACTION;
 165                 }
 166                 return 1.0f;
 167             }
 168         };
 169     }
 170
 171     boolean isTransitionSet() {
 172         return mNextAppTransition != TRANSIT_UNSET;
 173     }
 174
 175     boolean isTransitionNone() {
 176         return mNextAppTransition == TRANSIT_NONE;
 177     }
 178
 179     boolean isTransitionEqual(int transit) {
 180         return mNextAppTransition == transit;
 181     }
 182
 183     int getAppTransition() {
 184         return mNextAppTransition;
 185      }
 186
 187     void setAppTransition(int transit) {
 188         mNextAppTransition = transit;
 189     }
 190
 191     boolean isReady() {
 192         return mAppTransitionState == APP_STATE_READY
 193                 || mAppTransitionState == APP_STATE_TIMEOUT;
 194     }
 195
 196     void setReady() {
 197         mAppTransitionState = APP_STATE_READY;
 198     }
 199
 200     boolean isRunning() {
 201         return mAppTransitionState == APP_STATE_RUNNING;
 202     }
 203
 204     void setIdle() {
 205         mAppTransitionState = APP_STATE_IDLE;
 206     }
 207
 208     boolean isTimeout() {
 209         return mAppTransitionState == APP_STATE_TIMEOUT;
 210     }
 211
 212     void setTimeout() {
 213         mAppTransitionState = APP_STATE_TIMEOUT;
 214     }
 215
 216     Bitmap getNextAppTransitionThumbnail() {
 217         return mNextAppTransitionThumbnail;
 218     }
 219
 220     void getStartingPoint(Point outPoint) {
 221         outPoint.x = mNextAppTransitionStartX;
 222         outPoint.y = mNextAppTransitionStartY;
 223     }
 224
 225     void prepare() {
 226         if (!isRunning()) {
 227             mAppTransitionState = APP_STATE_IDLE;
 228         }
 229     }
 230
 231     void goodToGo() {
 232         mNextAppTransition = TRANSIT_UNSET;
 233         mAppTransitionState = APP_STATE_RUNNING;
 234     }
 235
 236     void clear() {
 237         mNextAppTransitionType = NEXT_TRANSIT_TYPE_NONE;
 238         mNextAppTransitionPackage = null;
 239         mNextAppTransitionThumbnail = null;
 240     }
 241
 242     void freeze() {
 243         setAppTransition(AppTransition.TRANSIT_UNSET);
 244         clear();
 245         setReady();
 246     }
 247
 248     private AttributeCache.Entry getCachedAnimations(WindowManager.LayoutParams lp) {
 249         if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: layout params pkg="
 250                 + (lp != null ? lp.packageName : null)
 251                 + " resId=0x" + (lp != null ? Integer.toHexString(lp.windowAnimations) : null));
 252         if (lp != null && lp.windowAnimations != 0) {
 253             // If this is a system resource, don't try to load it from the
 254             // application resources.  It is nice to avoid loading application
 255             // resources if we can.
 256             String packageName = lp.packageName != null ? lp.packageName : "android";
 257             int resId = lp.windowAnimations;
 258             if ((resId&0xFF000000) == 0x01000000) {
 259                 packageName = "android";
 260             }
 261             if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: picked package="
 262                     + packageName);
 263             return AttributeCache.instance().get(packageName, resId,
 264                     com.android.internal.R.styleable.WindowAnimation, mCurrentUserId);
 265         }
 266         return null;
 267     }
 268
 269     private AttributeCache.Entry getCachedAnimations(String packageName, int resId) {
 270         if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: package="
 271                 + packageName + " resId=0x" + Integer.toHexString(resId));
 272         if (packageName != null) {
 273             if ((resId&0xFF000000) == 0x01000000) {
 274                 packageName = "android";
 275             }
 276             if (DEBUG_ANIM) Slog.v(TAG, "Loading animations: picked package="
 277                     + packageName);
 278             return AttributeCache.instance().get(packageName, resId,
 279                     com.android.internal.R.styleable.WindowAnimation, mCurrentUserId);
 280         }
 281         return null;
 282     }
 283
 284     Animation loadAnimation(WindowManager.LayoutParams lp, int animAttr) {
 285         int anim = 0;
 286         Context context = mContext;
 287         if (animAttr >= 0) {
 288             AttributeCache.Entry ent = getCachedAnimations(lp);
 289             if (ent != null) {
 290                 context = ent.context;
 291                 anim = ent.array.getResourceId(animAttr, 0);
 292             }
 293         }
 294         if (anim != 0) {
 295             return AnimationUtils.loadAnimation(context, anim);
 296         }
 297         return null;
 298     }
 299
 300     private Animation loadAnimation(String packageName, int resId) {
 301         int anim = 0;
 302         Context context = mContext;
 303         if (resId >= 0) {
 304             AttributeCache.Entry ent = getCachedAnimations(packageName, resId);
 305             if (ent != null) {
 306                 context = ent.context;
 307                 anim = resId;
 308             }
 309         }
 310         if (anim != 0) {
 311             return AnimationUtils.loadAnimation(context, anim);
 312         }
 313         return null;
 314     }
 315
 316     /**
 317      * Compute the pivot point for an animation that is scaling from a small
 318      * rect on screen to a larger rect.  The pivot point varies depending on
 319      * the distance between the inner and outer edges on both sides.  This
 320      * function computes the pivot point for one dimension.
 321      * @param startPos  Offset from left/top edge of outer rectangle to
 322      * left/top edge of inner rectangle.
 323      * @param finalScale The scaling factor between the size of the outer
 324      * and inner rectangles.
 325      */
 326     private static float computePivot(int startPos, float finalScale) {
 327         final float denom = finalScale-1;
 328         if (Math.abs(denom) < .0001f) {
 329             return startPos;
 330         }
 331         return -startPos / denom;
 332     }
 333
 334     private Animation createScaleUpAnimationLocked(int transit, boolean enter,
 335                                                    int appWidth, int appHeight) {
 336         Animation a = null;
 337         if (enter) {
 338             // Entering app zooms out from the center of the initial rect.
 339             float scaleW = mNextAppTransitionStartWidth / (float) appWidth;
 340             float scaleH = mNextAppTransitionStartHeight / (float) appHeight;
 341             Animation scale = new ScaleAnimation(scaleW, 1, scaleH, 1,
 342                     computePivot(mNextAppTransitionStartX, scaleW),
 343                     computePivot(mNextAppTransitionStartY, scaleH));
 344             scale.setInterpolator(mDecelerateInterpolator);
 345
 346             Animation alpha = new AlphaAnimation(0, 1);
 347             alpha.setInterpolator(mThumbnailFadeoutInterpolator);
 348
 349             AnimationSet set = new AnimationSet(false);
 350             set.addAnimation(scale);
 351             set.addAnimation(alpha);
 352             set.setDetachWallpaper(true);
 353             a = set;
 354         } else  if (transit == TRANSIT_WALLPAPER_INTRA_OPEN ||
 355                     transit == TRANSIT_WALLPAPER_INTRA_CLOSE) {
 356             // If we are on top of the wallpaper, we need an animation that
 357             // correctly handles the wallpaper staying static behind all of
 358             // the animated elements.  To do this, will just have the existing
 359             // element fade out.
 360             a = new AlphaAnimation(1, 0);
 361             a.setDetachWallpaper(true);
 362         } else {
 363             // For normal animations, the exiting element just holds in place.
 364             a = new AlphaAnimation(1, 1);
 365         }
 366
 367         // Pick the desired duration.  If this is an inter-activity transition,
 368         // it  is the standard duration for that.  Otherwise we use the longer
 369         // task transition duration.
 370         final long duration;
 371         switch (transit) {
 372             case TRANSIT_ACTIVITY_OPEN:
 373             case TRANSIT_ACTIVITY_CLOSE:
 374                 duration = mConfigShortAnimTime;
 375                 break;
 376             default:
 377                 duration = DEFAULT_APP_TRANSITION_DURATION;
 378                 break;
 379         }
 380         a.setDuration(duration);
 381         a.setFillAfter(true);
 382         a.setInterpolator(mDecelerateInterpolator);
 383         a.initialize(appWidth, appHeight, appWidth, appHeight);
 384         return a;
 385     }
 386
 387     Animation createThumbnailAnimationLocked(int transit, boolean enter, boolean thumb,
 388                                     int appWidth, int appHeight) {
 389         Animation a;
 390         final int thumbWidthI = mNextAppTransitionThumbnail.getWidth();
 391         final float thumbWidth = thumbWidthI > 0 ? thumbWidthI : 1;
 392         final int thumbHeightI = mNextAppTransitionThumbnail.getHeight();
 393         final float thumbHeight = thumbHeightI > 0 ? thumbHeightI : 1;
 394         if (thumb) {
 395             // Animation for zooming thumbnail from its initial size to
 396             // filling the screen.
 397             if (mNextAppTransitionScaleUp) {
 398                 float scaleW = appWidth / thumbWidth;
 399                 float scaleH = appHeight / thumbHeight;
 400                 Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH,
 401                         computePivot(mNextAppTransitionStartX, 1 / scaleW),
 402                         computePivot(mNextAppTransitionStartY, 1 / scaleH));
 403                 scale.setInterpolator(mDecelerateInterpolator);
 404
 405                 Animation alpha = new AlphaAnimation(1, 0);
 406                 alpha.setInterpolator(mThumbnailFadeoutInterpolator);
 407
 408                 // This AnimationSet uses the Interpolators assigned above.
 409                 AnimationSet set = new AnimationSet(false);
 410                 set.addAnimation(scale);
 411                 set.addAnimation(alpha);
 412                 a = set;
 413             } else {
 414                 float scaleW = appWidth / thumbWidth;
 415                 float scaleH = appHeight / thumbHeight;
 416                 a = new ScaleAnimation(scaleW, 1, scaleH, 1,
 417                         computePivot(mNextAppTransitionStartX, 1 / scaleW),
 418                         computePivot(mNextAppTransitionStartY, 1 / scaleH));
 419             }
 420         } else if (enter) {
 421             // Entering app zooms out from the center of the thumbnail.
 422             if (mNextAppTransitionScaleUp) {
 423                 float scaleW = thumbWidth / appWidth;
 424                 float scaleH = thumbHeight / appHeight;
 425                 a = new ScaleAnimation(scaleW, 1, scaleH, 1,
 426                         computePivot(mNextAppTransitionStartX, scaleW),
 427                         computePivot(mNextAppTransitionStartY, scaleH));
 428             } else {
 429                 // noop animation
 430                 a = new AlphaAnimation(1, 1);
 431             }
 432         } else {
 433             // Exiting app
 434             if (mNextAppTransitionScaleUp) {
 435                 if (transit == TRANSIT_WALLPAPER_INTRA_OPEN) {
 436                     // Fade out while bringing up selected activity. This keeps the
 437                     // current activity from showing through a launching wallpaper
 438                     // activity.
 439                     a = new AlphaAnimation(1, 0);
 440                 } else {
 441                     // noop animation
 442                     a = new AlphaAnimation(1, 1);
 443                 }
 444             } else {
 445                 float scaleW = thumbWidth / appWidth;
 446                 float scaleH = thumbHeight / appHeight;
 447                 Animation scale = new ScaleAnimation(1, scaleW, 1, scaleH,
 448                         computePivot(mNextAppTransitionStartX, scaleW),
 449                         computePivot(mNextAppTransitionStartY, scaleH));
 450
 451                 Animation alpha = new AlphaAnimation(1, 0);
 452
 453                 AnimationSet set = new AnimationSet(true);
 454                 set.addAnimation(scale);
 455                 set.addAnimation(alpha);
 456                 set.setZAdjustment(Animation.ZORDER_TOP);
 457                 a = set;
 458             }
 459         }
 460
 461         // Pick the desired duration.  If this is an inter-activity transition,
 462         // it  is the standard duration for that.  Otherwise we use the longer
 463         // task transition duration.
 464         final long duration;
 465         switch (transit) {
 466             case TRANSIT_ACTIVITY_OPEN:
 467             case TRANSIT_ACTIVITY_CLOSE:
 468                 duration = mConfigShortAnimTime;
 469                 break;
 470             default:
 471                 duration = DEFAULT_APP_TRANSITION_DURATION;
 472                 break;
 473         }
 474         a.setDuration(duration);
 475         a.setFillAfter(true);
 476         a.setInterpolator(mDecelerateInterpolator);
 477         a.initialize(appWidth, appHeight, appWidth, appHeight);
 478         return a;
 479     }
 480
 481
 482     Animation loadAnimation(WindowManager.LayoutParams lp, int transit, boolean enter,
 483                             int appWidth, int appHeight) {
 484         Animation a;
 485         if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_CUSTOM) {
 486             a = loadAnimation(mNextAppTransitionPackage, enter ?
 487                     mNextAppTransitionEnter : mNextAppTransitionExit);
 488             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
 489                     "applyAnimation:"
 490                     + " anim=" + a + " nextAppTransition=ANIM_CUSTOM"
 491                     + " transit=" + transit + " isEntrance=" + enter
 492                     + " Callers=" + Debug.getCallers(3));
 493         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_SCALE_UP) {
 494             a = createScaleUpAnimationLocked(transit, enter, appWidth, appHeight);
 495             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
 496                     "applyAnimation:"
 497                     + " anim=" + a + " nextAppTransition=ANIM_SCALE_UP"
 498                     + " transit=" + transit + " isEntrance=" + enter
 499                     + " Callers=" + Debug.getCallers(3));
 500         } else if (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP ||
 501                 mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN) {
 502             mNextAppTransitionScaleUp =
 503                     (mNextAppTransitionType == NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP);
 504             a = createThumbnailAnimationLocked(transit, enter, false, appWidth, appHeight);
 505             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) {
 506                 String animName = mNextAppTransitionScaleUp ?
 507                         "ANIM_THUMBNAIL_SCALE_UP" : "ANIM_THUMBNAIL_SCALE_DOWN";
 508                 Slog.v(TAG, "applyAnimation:"
 509                         + " anim=" + a + " nextAppTransition=" + animName
 510                         + " transit=" + transit + " isEntrance=" + enter
 511                         + " Callers=" + Debug.getCallers(3));
 512             }
 513         } else {
 514             int animAttr = 0;
 515             switch (transit) {
 516                 case TRANSIT_ACTIVITY_OPEN:
 517                     animAttr = enter
 518                             ? WindowAnimation_activityOpenEnterAnimation
 519                             : WindowAnimation_activityOpenExitAnimation;
 520                     break;
 521                 case TRANSIT_ACTIVITY_CLOSE:
 522                     animAttr = enter
 523                             ? WindowAnimation_activityCloseEnterAnimation
 524                             : WindowAnimation_activityCloseExitAnimation;
 525                     break;
 526                 case TRANSIT_TASK_OPEN:
 527                     animAttr = enter
 528                             ? WindowAnimation_taskOpenEnterAnimation
 529                             : WindowAnimation_taskOpenExitAnimation;
 530                     break;
 531                 case TRANSIT_TASK_CLOSE:
 532                     animAttr = enter
 533                             ? WindowAnimation_taskCloseEnterAnimation
 534                             : WindowAnimation_taskCloseExitAnimation;
 535                     break;
 536                 case TRANSIT_TASK_TO_FRONT:
 537                     animAttr = enter
 538                             ? WindowAnimation_taskToFrontEnterAnimation
 539                             : WindowAnimation_taskToFrontExitAnimation;
 540                     break;
 541                 case TRANSIT_TASK_TO_BACK:
 542                     animAttr = enter
 543                             ? WindowAnimation_taskToBackEnterAnimation
 544                             : WindowAnimation_taskToBackExitAnimation;
 545                     break;
 546                 case TRANSIT_WALLPAPER_OPEN:
 547                     animAttr = enter
 548                             ? WindowAnimation_wallpaperOpenEnterAnimation
 549                             : WindowAnimation_wallpaperOpenExitAnimation;
 550                     break;
 551                 case TRANSIT_WALLPAPER_CLOSE:
 552                     animAttr = enter
 553                             ? WindowAnimation_wallpaperCloseEnterAnimation
 554                             : WindowAnimation_wallpaperCloseExitAnimation;
 555                     break;
 556                 case TRANSIT_WALLPAPER_INTRA_OPEN:
 557                     animAttr = enter
 558                             ? WindowAnimation_wallpaperIntraOpenEnterAnimation
 559                             : WindowAnimation_wallpaperIntraOpenExitAnimation;
 560                     break;
 561                 case TRANSIT_WALLPAPER_INTRA_CLOSE:
 562                     animAttr = enter
 563                             ? WindowAnimation_wallpaperIntraCloseEnterAnimation
 564                             : WindowAnimation_wallpaperIntraCloseExitAnimation;
 565                     break;
 566             }
 567             a = animAttr != 0 ? loadAnimation(lp, animAttr) : null;
 568             if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG,
 569                     "applyAnimation:"
 570                     + " anim=" + a
 571                     + " animAttr=0x" + Integer.toHexString(animAttr)
 572                     + " transit=" + transit + " isEntrance=" + enter
 573                     + " Callers=" + Debug.getCallers(3));
 574         }
 575         return a;
 576     }
 577
 578     void postAnimationCallback() {
 579         if (mNextAppTransitionCallback != null) {
 580             mH.sendMessage(mH.obtainMessage(H.DO_ANIMATION_CALLBACK, mNextAppTransitionCallback));
 581             mNextAppTransitionCallback = null;
 582         }
 583     }
 584
 585     void overridePendingAppTransition(String packageName, int enterAnim, int exitAnim,
 586                                              IRemoteCallback startedCallback) {
 587         if (isTransitionSet()) {
 588             mNextAppTransitionType = NEXT_TRANSIT_TYPE_CUSTOM;
 589             mNextAppTransitionPackage = packageName;
 590             mNextAppTransitionThumbnail = null;
 591             mNextAppTransitionEnter = enterAnim;
 592             mNextAppTransitionExit = exitAnim;
 593             postAnimationCallback();
 594             mNextAppTransitionCallback = startedCallback;
 595         } else {
 596             postAnimationCallback();
 597         }
 598     }
 599
 600     void overridePendingAppTransitionScaleUp(int startX, int startY, int startWidth,
 601                                                     int startHeight) {
 602         if (isTransitionSet()) {
 603             mNextAppTransitionType = NEXT_TRANSIT_TYPE_SCALE_UP;
 604             mNextAppTransitionPackage = null;
 605             mNextAppTransitionThumbnail = null;
 606             mNextAppTransitionStartX = startX;
 607             mNextAppTransitionStartY = startY;
 608             mNextAppTransitionStartWidth = startWidth;
 609             mNextAppTransitionStartHeight = startHeight;
 610             postAnimationCallback();
 611             mNextAppTransitionCallback = null;
 612         }
 613     }
 614
 615     void overridePendingAppTransitionThumb(Bitmap srcThumb, int startX, int startY,
 616                                            IRemoteCallback startedCallback, boolean scaleUp) {
 617         if (isTransitionSet()) {
 618             mNextAppTransitionType = scaleUp ? NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP
 619                     : NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN;
 620             mNextAppTransitionPackage = null;
 621             mNextAppTransitionThumbnail = srcThumb;
 622             mNextAppTransitionScaleUp = scaleUp;
 623             mNextAppTransitionStartX = startX;
 624             mNextAppTransitionStartY = startY;
 625             postAnimationCallback();
 626             mNextAppTransitionCallback = startedCallback;
 627         } else {
 628             postAnimationCallback();
 629         }
 630     }
 631
 632     @Override
 633     public String toString() {
 634         return "mNextAppTransition=0x" + Integer.toHexString(mNextAppTransition);
 635     }
 636
 637     /**
 638      * Returns the human readable name of a window transition.
 639      *
 640      * @param transition The window transition.
 641      * @return The transition symbolic name.
 642      */
 643     public static String appTransitionToString(int transition) {
 644         switch (transition) {
 645             case TRANSIT_UNSET: {
 646                 return "TRANSIT_UNSET";
 647             }
 648             case TRANSIT_NONE: {
 649                 return "TRANSIT_NONE";
 650             }
 651             case TRANSIT_EXIT_MASK: {
 652                 return "TRANSIT_EXIT_MASK";
 653             }
 654             case TRANSIT_ACTIVITY_OPEN: {
 655                 return "TRANSIT_ACTIVITY_OPEN";
 656             }
 657             case TRANSIT_ACTIVITY_CLOSE: {
 658                 return "TRANSIT_ACTIVITY_CLOSE";
 659             }
 660             case TRANSIT_TASK_OPEN: {
 661                 return "TRANSIT_TASK_OPEN";
 662             }
 663             case TRANSIT_TASK_CLOSE: {
 664                 return "TRANSIT_TASK_CLOSE";
 665             }
 666             case TRANSIT_TASK_TO_FRONT: {
 667                 return "TRANSIT_TASK_TO_FRONT";
 668             }
 669             case TRANSIT_TASK_TO_BACK: {
 670                 return "TRANSIT_TASK_TO_BACK";
 671             }
 672             case TRANSIT_WALLPAPER_CLOSE: {
 673                 return "TRANSIT_WALLPAPER_CLOSE";
 674             }
 675             case TRANSIT_WALLPAPER_OPEN: {
 676                 return "TRANSIT_WALLPAPER_OPEN";
 677             }
 678             case TRANSIT_WALLPAPER_INTRA_OPEN: {
 679                 return "TRANSIT_WALLPAPER_INTRA_OPEN";
 680             }
 681             case TRANSIT_WALLPAPER_INTRA_CLOSE: {
 682                 return "TRANSIT_WALLPAPER_INTRA_CLOSE";
 683             }
 684             default: {
 685                 return "<UNKNOWN>";
 686             }
 687         }
 688     }
 689
 690     private String appStateToString() {
 691         switch (mAppTransitionState) {
 692             case APP_STATE_IDLE:
 693                 return "APP_STATE_IDLE";
 694             case APP_STATE_READY:
 695                 return "APP_STATE_READY";
 696             case APP_STATE_RUNNING:
 697                 return "APP_STATE_RUNNING";
 698             case APP_STATE_TIMEOUT:
 699                 return "APP_STATE_TIMEOUT";
 700             default:
 701                 return "unknown state=" + mAppTransitionState;
 702         }
 703     }
 704
 705     private String transitTypeToString() {
 706         switch (mNextAppTransitionType) {
 707             case NEXT_TRANSIT_TYPE_NONE:
 708                 return "NEXT_TRANSIT_TYPE_NONE";
 709             case NEXT_TRANSIT_TYPE_CUSTOM:
 710                 return "NEXT_TRANSIT_TYPE_CUSTOM";
 711             case NEXT_TRANSIT_TYPE_SCALE_UP:
 712                 return "NEXT_TRANSIT_TYPE_SCALE_UP";
 713             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP:
 714                 return "NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP";
 715             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN:
 716                 return "NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN";
 717             default:
 718                 return "unknown type=" + mNextAppTransitionType;
 719         }
 720     }
 721
 722     @Override
 723     public void dump(PrintWriter pw) {
 724         pw.print(" " + this);
 725         pw.print(" mAppTransitionState="); pw.println(appStateToString());
 726         if (mNextAppTransitionType != NEXT_TRANSIT_TYPE_NONE) {
 727             pw.print("  mNextAppTransitionType="); pw.println(transitTypeToString());
 728         }
 729         switch (mNextAppTransitionType) {
 730             case NEXT_TRANSIT_TYPE_CUSTOM:
 731                 pw.print("  mNextAppTransitionPackage=");
 732                         pw.println(mNextAppTransitionPackage);
 733                 pw.print("  mNextAppTransitionEnter=0x");
 734                         pw.print(Integer.toHexString(mNextAppTransitionEnter));
 735                         pw.print(" mNextAppTransitionExit=0x");
 736                         pw.println(Integer.toHexString(mNextAppTransitionExit));
 737                 break;
 738             case NEXT_TRANSIT_TYPE_SCALE_UP:
 739                 pw.print("  mNextAppTransitionStartX="); pw.print(mNextAppTransitionStartX);
 740                         pw.print(" mNextAppTransitionStartY=");
 741                         pw.println(mNextAppTransitionStartY);
 742                 pw.print("  mNextAppTransitionStartWidth=");
 743                         pw.print(mNextAppTransitionStartWidth);
 744                         pw.print(" mNextAppTransitionStartHeight=");
 745                         pw.println(mNextAppTransitionStartHeight);
 746                 break;
 747             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_UP:
 748             case NEXT_TRANSIT_TYPE_THUMBNAIL_SCALE_DOWN:
 749                 pw.print("  mNextAppTransitionThumbnail=");
 750                         pw.print(mNextAppTransitionThumbnail);
 751                         pw.print(" mNextAppTransitionStartX=");
 752                         pw.print(mNextAppTransitionStartX);
 753                         pw.print(" mNextAppTransitionStartY=");
 754                         pw.println(mNextAppTransitionStartY);
 755                 pw.print("  mNextAppTransitionScaleUp="); pw.println(mNextAppTransitionScaleUp);
 756                 break;
 757         }
 758         if (mNextAppTransitionCallback != null) {
 759             pw.print("  mNextAppTransitionCallback=");
 760             pw.println(mNextAppTransitionCallback);
 761         }
 762     }
 763
 764     public void setCurrentUser(int newUserId) {
 765         mCurrentUserId = newUserId;
 766     }
 767 }