1 /* 2 * Copyright (C) 2012 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 android.app; 18 19 import static android.app.ActivityManager.DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT; 20 import static android.app.ActivityManager.StackId.INVALID_STACK_ID; 21 22 import android.annotation.Nullable; 23 import android.annotation.TestApi; 24 import android.content.Context; 25 import android.content.Intent; 26 import android.graphics.Bitmap; 27 import android.graphics.Rect; 28 import android.os.Bundle; 29 import android.os.Handler; 30 import android.os.IRemoteCallback; 31 import android.os.Parcelable; 32 import android.os.RemoteException; 33 import android.os.ResultReceiver; 34 import android.transition.Transition; 35 import android.transition.TransitionManager; 36 import android.util.Pair; 37 import android.util.Slog; 38 import android.view.AppTransitionAnimationSpec; 39 import android.view.View; 40 import android.view.ViewGroup; 41 import android.view.Window; 42 43 import java.util.ArrayList; 44 45 /** 46 * Helper class for building an options Bundle that can be used with 47 * {@link android.content.Context#startActivity(android.content.Intent, android.os.Bundle) 48 * Context.startActivity(Intent, Bundle)} and related methods. 49 */ 50 public class ActivityOptions { 51 private static final String TAG = "ActivityOptions"; 52 53 /** 54 * A long in the extras delivered by {@link #requestUsageTimeReport} that contains 55 * the total time (in ms) the user spent in the app flow. 56 */ 57 public static final String EXTRA_USAGE_TIME_REPORT = "android.activity.usage_time"; 58 59 /** 60 * A Bundle in the extras delivered by {@link #requestUsageTimeReport} that contains 61 * detailed information about the time spent in each package associated with the app; 62 * each key is a package name, whose value is a long containing the time (in ms). 63 */ 64 public static final String EXTRA_USAGE_TIME_REPORT_PACKAGES = "android.usage_time_packages"; 65 66 /** 67 * The package name that created the options. 68 * @hide 69 */ 70 public static final String KEY_PACKAGE_NAME = "android:activity.packageName"; 71 72 /** 73 * The bounds (window size) that the activity should be launched in. Set to null explicitly for 74 * full screen. If the key is not found, previous bounds will be preserved. 75 * NOTE: This value is ignored on devices that don't have 76 * {@link android.content.pm.PackageManager#FEATURE_FREEFORM_WINDOW_MANAGEMENT} or 77 * {@link android.content.pm.PackageManager#FEATURE_PICTURE_IN_PICTURE} enabled. 78 * @hide 79 */ 80 public static final String KEY_LAUNCH_BOUNDS = "android:activity.launchBounds"; 81 82 /** 83 * Type of animation that arguments specify. 84 * @hide 85 */ 86 public static final String KEY_ANIM_TYPE = "android:activity.animType"; 87 88 /** 89 * Custom enter animation resource ID. 90 * @hide 91 */ 92 public static final String KEY_ANIM_ENTER_RES_ID = "android:activity.animEnterRes"; 93 94 /** 95 * Custom exit animation resource ID. 96 * @hide 97 */ 98 public static final String KEY_ANIM_EXIT_RES_ID = "android:activity.animExitRes"; 99 100 /** 101 * Custom in-place animation resource ID. 102 * @hide 103 */ 104 public static final String KEY_ANIM_IN_PLACE_RES_ID = "android:activity.animInPlaceRes"; 105 106 /** 107 * Bitmap for thumbnail animation. 108 * @hide 109 */ 110 public static final String KEY_ANIM_THUMBNAIL = "android:activity.animThumbnail"; 111 112 /** 113 * Start X position of thumbnail animation. 114 * @hide 115 */ 116 public static final String KEY_ANIM_START_X = "android:activity.animStartX"; 117 118 /** 119 * Start Y position of thumbnail animation. 120 * @hide 121 */ 122 public static final String KEY_ANIM_START_Y = "android:activity.animStartY"; 123 124 /** 125 * Initial width of the animation. 126 * @hide 127 */ 128 public static final String KEY_ANIM_WIDTH = "android:activity.animWidth"; 129 130 /** 131 * Initial height of the animation. 132 * @hide 133 */ 134 public static final String KEY_ANIM_HEIGHT = "android:activity.animHeight"; 135 136 /** 137 * Callback for when animation is started. 138 * @hide 139 */ 140 public static final String KEY_ANIM_START_LISTENER = "android:activity.animStartListener"; 141 142 /** 143 * Callback for when the last frame of the animation is played. 144 * @hide 145 */ 146 private static final String KEY_ANIMATION_FINISHED_LISTENER = 147 "android:activity.animationFinishedListener"; 148 149 /** 150 * Descriptions of app transition animations to be played during the activity launch. 151 */ 152 private static final String KEY_ANIM_SPECS = "android:activity.animSpecs"; 153 154 /** 155 * The stack id the activity should be launched into. 156 * @hide 157 */ 158 private static final String KEY_LAUNCH_STACK_ID = "android.activity.launchStackId"; 159 160 /** 161 * The task id the activity should be launched into. 162 * @hide 163 */ 164 private static final String KEY_LAUNCH_TASK_ID = "android.activity.launchTaskId"; 165 166 /** 167 * See {@link #setTaskOverlay}. 168 * @hide 169 */ 170 private static final String KEY_TASK_OVERLAY = "android.activity.taskOverlay"; 171 172 /** 173 * Where the docked stack should be positioned. 174 * @hide 175 */ 176 private static final String KEY_DOCK_CREATE_MODE = "android:activity.dockCreateMode"; 177 178 /** 179 * For Activity transitions, the calling Activity's TransitionListener used to 180 * notify the called Activity when the shared element and the exit transitions 181 * complete. 182 */ 183 private static final String KEY_TRANSITION_COMPLETE_LISTENER 184 = "android:activity.transitionCompleteListener"; 185 186 private static final String KEY_TRANSITION_IS_RETURNING 187 = "android:activity.transitionIsReturning"; 188 private static final String KEY_TRANSITION_SHARED_ELEMENTS 189 = "android:activity.sharedElementNames"; 190 private static final String KEY_RESULT_DATA = "android:activity.resultData"; 191 private static final String KEY_RESULT_CODE = "android:activity.resultCode"; 192 private static final String KEY_EXIT_COORDINATOR_INDEX 193 = "android:activity.exitCoordinatorIndex"; 194 195 private static final String KEY_USAGE_TIME_REPORT = "android:activity.usageTimeReport"; 196 private static final String KEY_ROTATION_ANIMATION_HINT = "android:activity.rotationAnimationHint"; 197 198 /** @hide */ 199 public static final int ANIM_NONE = 0; 200 /** @hide */ 201 public static final int ANIM_CUSTOM = 1; 202 /** @hide */ 203 public static final int ANIM_SCALE_UP = 2; 204 /** @hide */ 205 public static final int ANIM_THUMBNAIL_SCALE_UP = 3; 206 /** @hide */ 207 public static final int ANIM_THUMBNAIL_SCALE_DOWN = 4; 208 /** @hide */ 209 public static final int ANIM_SCENE_TRANSITION = 5; 210 /** @hide */ 211 public static final int ANIM_DEFAULT = 6; 212 /** @hide */ 213 public static final int ANIM_LAUNCH_TASK_BEHIND = 7; 214 /** @hide */ 215 public static final int ANIM_THUMBNAIL_ASPECT_SCALE_UP = 8; 216 /** @hide */ 217 public static final int ANIM_THUMBNAIL_ASPECT_SCALE_DOWN = 9; 218 /** @hide */ 219 public static final int ANIM_CUSTOM_IN_PLACE = 10; 220 /** @hide */ 221 public static final int ANIM_CLIP_REVEAL = 11; 222 223 private String mPackageName; 224 private Rect mLaunchBounds; 225 private int mAnimationType = ANIM_NONE; 226 private int mCustomEnterResId; 227 private int mCustomExitResId; 228 private int mCustomInPlaceResId; 229 private Bitmap mThumbnail; 230 private int mStartX; 231 private int mStartY; 232 private int mWidth; 233 private int mHeight; 234 private IRemoteCallback mAnimationStartedListener; 235 private IRemoteCallback mAnimationFinishedListener; 236 private ResultReceiver mTransitionReceiver; 237 private boolean mIsReturning; 238 private ArrayList<String> mSharedElementNames; 239 private Intent mResultData; 240 private int mResultCode; 241 private int mExitCoordinatorIndex; 242 private PendingIntent mUsageTimeReport; 243 private int mLaunchStackId = INVALID_STACK_ID; 244 private int mLaunchTaskId = -1; 245 private int mDockCreateMode = DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT; 246 private boolean mTaskOverlay; 247 private AppTransitionAnimationSpec mAnimSpecs[]; 248 private int mRotationAnimationHint = -1; 249 250 /** 251 * Create an ActivityOptions specifying a custom animation to run when 252 * the activity is displayed. 253 * 254 * @param context Who is defining this. This is the application that the 255 * animation resources will be loaded from. 256 * @param enterResId A resource ID of the animation resource to use for 257 * the incoming activity. Use 0 for no animation. 258 * @param exitResId A resource ID of the animation resource to use for 259 * the outgoing activity. Use 0 for no animation. 260 * @return Returns a new ActivityOptions object that you can use to 261 * supply these options as the options Bundle when starting an activity. 262 */ 263 public static ActivityOptions makeCustomAnimation(Context context, 264 int enterResId, int exitResId) { 265 return makeCustomAnimation(context, enterResId, exitResId, null, null); 266 } 267 268 /** 269 * Create an ActivityOptions specifying a custom animation to run when 270 * the activity is displayed. 271 * 272 * @param context Who is defining this. This is the application that the 273 * animation resources will be loaded from. 274 * @param enterResId A resource ID of the animation resource to use for 275 * the incoming activity. Use 0 for no animation. 276 * @param exitResId A resource ID of the animation resource to use for 277 * the outgoing activity. Use 0 for no animation. 278 * @param handler If <var>listener</var> is non-null this must be a valid 279 * Handler on which to dispatch the callback; otherwise it should be null. 280 * @param listener Optional OnAnimationStartedListener to find out when the 281 * requested animation has started running. If for some reason the animation 282 * is not executed, the callback will happen immediately. 283 * @return Returns a new ActivityOptions object that you can use to 284 * supply these options as the options Bundle when starting an activity. 285 * @hide 286 */ 287 public static ActivityOptions makeCustomAnimation(Context context, 288 int enterResId, int exitResId, Handler handler, OnAnimationStartedListener listener) { 289 ActivityOptions opts = new ActivityOptions(); 290 opts.mPackageName = context.getPackageName(); 291 opts.mAnimationType = ANIM_CUSTOM; 292 opts.mCustomEnterResId = enterResId; 293 opts.mCustomExitResId = exitResId; 294 opts.setOnAnimationStartedListener(handler, listener); 295 return opts; 296 } 297 298 /** 299 * Creates an ActivityOptions specifying a custom animation to run in place on an existing 300 * activity. 301 * 302 * @param context Who is defining this. This is the application that the 303 * animation resources will be loaded from. 304 * @param animId A resource ID of the animation resource to use for 305 * the incoming activity. 306 * @return Returns a new ActivityOptions object that you can use to 307 * supply these options as the options Bundle when running an in-place animation. 308 * @hide 309 */ 310 public static ActivityOptions makeCustomInPlaceAnimation(Context context, int animId) { 311 if (animId == 0) { 312 throw new RuntimeException("You must specify a valid animation."); 313 } 314 315 ActivityOptions opts = new ActivityOptions(); 316 opts.mPackageName = context.getPackageName(); 317 opts.mAnimationType = ANIM_CUSTOM_IN_PLACE; 318 opts.mCustomInPlaceResId = animId; 319 return opts; 320 } 321 322 private void setOnAnimationStartedListener(final Handler handler, 323 final OnAnimationStartedListener listener) { 324 if (listener != null) { 325 mAnimationStartedListener = new IRemoteCallback.Stub() { 326 @Override 327 public void sendResult(Bundle data) throws RemoteException { 328 handler.post(new Runnable() { 329 @Override public void run() { 330 listener.onAnimationStarted(); 331 } 332 }); 333 } 334 }; 335 } 336 } 337 338 /** 339 * Callback for use with {@link ActivityOptions#makeThumbnailScaleUpAnimation} 340 * to find out when the given animation has started running. 341 * @hide 342 */ 343 public interface OnAnimationStartedListener { 344 void onAnimationStarted(); 345 } 346 347 private void setOnAnimationFinishedListener(final Handler handler, 348 final OnAnimationFinishedListener listener) { 349 if (listener != null) { 350 mAnimationFinishedListener = new IRemoteCallback.Stub() { 351 @Override 352 public void sendResult(Bundle data) throws RemoteException { 353 handler.post(new Runnable() { 354 @Override 355 public void run() { 356 listener.onAnimationFinished(); 357 } 358 }); 359 } 360 }; 361 } 362 } 363 364 /** 365 * Callback for use with {@link ActivityOptions#makeThumbnailAspectScaleDownAnimation} 366 * to find out when the given animation has drawn its last frame. 367 * @hide 368 */ 369 public interface OnAnimationFinishedListener { 370 void onAnimationFinished(); 371 } 372 373 /** 374 * Create an ActivityOptions specifying an animation where the new 375 * activity is scaled from a small originating area of the screen to 376 * its final full representation. 377 * 378 * <p>If the Intent this is being used with has not set its 379 * {@link android.content.Intent#setSourceBounds Intent.setSourceBounds}, 380 * those bounds will be filled in for you based on the initial 381 * bounds passed in here. 382 * 383 * @param source The View that the new activity is animating from. This 384 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 385 * @param startX The x starting location of the new activity, relative to <var>source</var>. 386 * @param startY The y starting location of the activity, relative to <var>source</var>. 387 * @param width The initial width of the new activity. 388 * @param height The initial height of the new activity. 389 * @return Returns a new ActivityOptions object that you can use to 390 * supply these options as the options Bundle when starting an activity. 391 */ 392 public static ActivityOptions makeScaleUpAnimation(View source, 393 int startX, int startY, int width, int height) { 394 ActivityOptions opts = new ActivityOptions(); 395 opts.mPackageName = source.getContext().getPackageName(); 396 opts.mAnimationType = ANIM_SCALE_UP; 397 int[] pts = new int[2]; 398 source.getLocationOnScreen(pts); 399 opts.mStartX = pts[0] + startX; 400 opts.mStartY = pts[1] + startY; 401 opts.mWidth = width; 402 opts.mHeight = height; 403 return opts; 404 } 405 406 /** 407 * Create an ActivityOptions specifying an animation where the new 408 * activity is revealed from a small originating area of the screen to 409 * its final full representation. 410 * 411 * @param source The View that the new activity is animating from. This 412 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 413 * @param startX The x starting location of the new activity, relative to <var>source</var>. 414 * @param startY The y starting location of the activity, relative to <var>source</var>. 415 * @param width The initial width of the new activity. 416 * @param height The initial height of the new activity. 417 * @return Returns a new ActivityOptions object that you can use to 418 * supply these options as the options Bundle when starting an activity. 419 */ 420 public static ActivityOptions makeClipRevealAnimation(View source, 421 int startX, int startY, int width, int height) { 422 ActivityOptions opts = new ActivityOptions(); 423 opts.mAnimationType = ANIM_CLIP_REVEAL; 424 int[] pts = new int[2]; 425 source.getLocationOnScreen(pts); 426 opts.mStartX = pts[0] + startX; 427 opts.mStartY = pts[1] + startY; 428 opts.mWidth = width; 429 opts.mHeight = height; 430 return opts; 431 } 432 433 /** 434 * Create an ActivityOptions specifying an animation where a thumbnail 435 * is scaled from a given position to the new activity window that is 436 * being started. 437 * 438 * <p>If the Intent this is being used with has not set its 439 * {@link android.content.Intent#setSourceBounds Intent.setSourceBounds}, 440 * those bounds will be filled in for you based on the initial 441 * thumbnail location and size provided here. 442 * 443 * @param source The View that this thumbnail is animating from. This 444 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 445 * @param thumbnail The bitmap that will be shown as the initial thumbnail 446 * of the animation. 447 * @param startX The x starting location of the bitmap, relative to <var>source</var>. 448 * @param startY The y starting location of the bitmap, relative to <var>source</var>. 449 * @return Returns a new ActivityOptions object that you can use to 450 * supply these options as the options Bundle when starting an activity. 451 */ 452 public static ActivityOptions makeThumbnailScaleUpAnimation(View source, 453 Bitmap thumbnail, int startX, int startY) { 454 return makeThumbnailScaleUpAnimation(source, thumbnail, startX, startY, null); 455 } 456 457 /** 458 * Create an ActivityOptions specifying an animation where a thumbnail 459 * is scaled from a given position to the new activity window that is 460 * being started. 461 * 462 * @param source The View that this thumbnail is animating from. This 463 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 464 * @param thumbnail The bitmap that will be shown as the initial thumbnail 465 * of the animation. 466 * @param startX The x starting location of the bitmap, relative to <var>source</var>. 467 * @param startY The y starting location of the bitmap, relative to <var>source</var>. 468 * @param listener Optional OnAnimationStartedListener to find out when the 469 * requested animation has started running. If for some reason the animation 470 * is not executed, the callback will happen immediately. 471 * @return Returns a new ActivityOptions object that you can use to 472 * supply these options as the options Bundle when starting an activity. 473 * @hide 474 */ 475 public static ActivityOptions makeThumbnailScaleUpAnimation(View source, 476 Bitmap thumbnail, int startX, int startY, OnAnimationStartedListener listener) { 477 return makeThumbnailAnimation(source, thumbnail, startX, startY, listener, true); 478 } 479 480 /** 481 * Create an ActivityOptions specifying an animation where an activity window 482 * is scaled from a given position to a thumbnail at a specified location. 483 * 484 * @param source The View that this thumbnail is animating to. This 485 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 486 * @param thumbnail The bitmap that will be shown as the final thumbnail 487 * of the animation. 488 * @param startX The x end location of the bitmap, relative to <var>source</var>. 489 * @param startY The y end location of the bitmap, relative to <var>source</var>. 490 * @param listener Optional OnAnimationStartedListener to find out when the 491 * requested animation has started running. If for some reason the animation 492 * is not executed, the callback will happen immediately. 493 * @return Returns a new ActivityOptions object that you can use to 494 * supply these options as the options Bundle when starting an activity. 495 * @hide 496 */ 497 public static ActivityOptions makeThumbnailScaleDownAnimation(View source, 498 Bitmap thumbnail, int startX, int startY, OnAnimationStartedListener listener) { 499 return makeThumbnailAnimation(source, thumbnail, startX, startY, listener, false); 500 } 501 502 private static ActivityOptions makeThumbnailAnimation(View source, 503 Bitmap thumbnail, int startX, int startY, OnAnimationStartedListener listener, 504 boolean scaleUp) { 505 ActivityOptions opts = new ActivityOptions(); 506 opts.mPackageName = source.getContext().getPackageName(); 507 opts.mAnimationType = scaleUp ? ANIM_THUMBNAIL_SCALE_UP : ANIM_THUMBNAIL_SCALE_DOWN; 508 opts.mThumbnail = thumbnail; 509 int[] pts = new int[2]; 510 source.getLocationOnScreen(pts); 511 opts.mStartX = pts[0] + startX; 512 opts.mStartY = pts[1] + startY; 513 opts.setOnAnimationStartedListener(source.getHandler(), listener); 514 return opts; 515 } 516 517 /** 518 * Create an ActivityOptions specifying an animation where the new activity 519 * window and a thumbnail is aspect-scaled to a new location. 520 * 521 * @param source The View that this thumbnail is animating from. This 522 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 523 * @param thumbnail The bitmap that will be shown as the initial thumbnail 524 * of the animation. 525 * @param startX The x starting location of the bitmap, relative to <var>source</var>. 526 * @param startY The y starting location of the bitmap, relative to <var>source</var>. 527 * @param handler If <var>listener</var> is non-null this must be a valid 528 * Handler on which to dispatch the callback; otherwise it should be null. 529 * @param listener Optional OnAnimationStartedListener to find out when the 530 * requested animation has started running. If for some reason the animation 531 * is not executed, the callback will happen immediately. 532 * @return Returns a new ActivityOptions object that you can use to 533 * supply these options as the options Bundle when starting an activity. 534 * @hide 535 */ 536 public static ActivityOptions makeThumbnailAspectScaleUpAnimation(View source, 537 Bitmap thumbnail, int startX, int startY, int targetWidth, int targetHeight, 538 Handler handler, OnAnimationStartedListener listener) { 539 return makeAspectScaledThumbnailAnimation(source, thumbnail, startX, startY, 540 targetWidth, targetHeight, handler, listener, true); 541 } 542 543 /** 544 * Create an ActivityOptions specifying an animation where the new activity 545 * window and a thumbnail is aspect-scaled to a new location. 546 * 547 * @param source The View that this thumbnail is animating to. This 548 * defines the coordinate space for <var>startX</var> and <var>startY</var>. 549 * @param thumbnail The bitmap that will be shown as the final thumbnail 550 * of the animation. 551 * @param startX The x end location of the bitmap, relative to <var>source</var>. 552 * @param startY The y end location of the bitmap, relative to <var>source</var>. 553 * @param handler If <var>listener</var> is non-null this must be a valid 554 * Handler on which to dispatch the callback; otherwise it should be null. 555 * @param listener Optional OnAnimationStartedListener to find out when the 556 * requested animation has started running. If for some reason the animation 557 * is not executed, the callback will happen immediately. 558 * @return Returns a new ActivityOptions object that you can use to 559 * supply these options as the options Bundle when starting an activity. 560 * @hide 561 */ 562 public static ActivityOptions makeThumbnailAspectScaleDownAnimation(View source, 563 Bitmap thumbnail, int startX, int startY, int targetWidth, int targetHeight, 564 Handler handler, OnAnimationStartedListener listener) { 565 return makeAspectScaledThumbnailAnimation(source, thumbnail, startX, startY, 566 targetWidth, targetHeight, handler, listener, false); 567 } 568 569 private static ActivityOptions makeAspectScaledThumbnailAnimation(View source, Bitmap thumbnail, 570 int startX, int startY, int targetWidth, int targetHeight, 571 Handler handler, OnAnimationStartedListener listener, boolean scaleUp) { 572 ActivityOptions opts = new ActivityOptions(); 573 opts.mPackageName = source.getContext().getPackageName(); 574 opts.mAnimationType = scaleUp ? ANIM_THUMBNAIL_ASPECT_SCALE_UP : 575 ANIM_THUMBNAIL_ASPECT_SCALE_DOWN; 576 opts.mThumbnail = thumbnail; 577 int[] pts = new int[2]; 578 source.getLocationOnScreen(pts); 579 opts.mStartX = pts[0] + startX; 580 opts.mStartY = pts[1] + startY; 581 opts.mWidth = targetWidth; 582 opts.mHeight = targetHeight; 583 opts.setOnAnimationStartedListener(handler, listener); 584 return opts; 585 } 586 587 /** @hide */ 588 public static ActivityOptions makeThumbnailAspectScaleDownAnimation(View source, 589 AppTransitionAnimationSpec[] specs, Handler handler, 590 OnAnimationStartedListener onAnimationStartedListener, 591 OnAnimationFinishedListener onAnimationFinishedListener) { 592 ActivityOptions opts = new ActivityOptions(); 593 opts.mPackageName = source.getContext().getPackageName(); 594 opts.mAnimationType = ANIM_THUMBNAIL_ASPECT_SCALE_DOWN; 595 opts.mAnimSpecs = specs; 596 opts.setOnAnimationStartedListener(handler, onAnimationStartedListener); 597 opts.setOnAnimationFinishedListener(handler, onAnimationFinishedListener); 598 return opts; 599 } 600 601 /** 602 * Create an ActivityOptions to transition between Activities using cross-Activity scene 603 * animations. This method carries the position of one shared element to the started Activity. 604 * The position of <code>sharedElement</code> will be used as the epicenter for the 605 * exit Transition. The position of the shared element in the launched Activity will be the 606 * epicenter of its entering Transition. 607 * 608 * <p>This requires {@link android.view.Window#FEATURE_ACTIVITY_TRANSITIONS} to be 609 * enabled on the calling Activity to cause an exit transition. The same must be in 610 * the called Activity to get an entering transition.</p> 611 * @param activity The Activity whose window contains the shared elements. 612 * @param sharedElement The View to transition to the started Activity. 613 * @param sharedElementName The shared element name as used in the target Activity. This 614 * must not be null. 615 * @return Returns a new ActivityOptions object that you can use to 616 * supply these options as the options Bundle when starting an activity. 617 * @see android.transition.Transition#setEpicenterCallback( 618 * android.transition.Transition.EpicenterCallback) 619 */ 620 public static ActivityOptions makeSceneTransitionAnimation(Activity activity, 621 View sharedElement, String sharedElementName) { 622 return makeSceneTransitionAnimation(activity, Pair.create(sharedElement, sharedElementName)); 623 } 624 625 /** 626 * Create an ActivityOptions to transition between Activities using cross-Activity scene 627 * animations. This method carries the position of multiple shared elements to the started 628 * Activity. The position of the first element in sharedElements 629 * will be used as the epicenter for the exit Transition. The position of the associated 630 * shared element in the launched Activity will be the epicenter of its entering Transition. 631 * 632 * <p>This requires {@link android.view.Window#FEATURE_ACTIVITY_TRANSITIONS} to be 633 * enabled on the calling Activity to cause an exit transition. The same must be in 634 * the called Activity to get an entering transition.</p> 635 * @param activity The Activity whose window contains the shared elements. 636 * @param sharedElements The names of the shared elements to transfer to the called 637 * Activity and their associated Views. The Views must each have 638 * a unique shared element name. 639 * @return Returns a new ActivityOptions object that you can use to 640 * supply these options as the options Bundle when starting an activity. 641 * @see android.transition.Transition#setEpicenterCallback( 642 * android.transition.Transition.EpicenterCallback) 643 */ 644 @SafeVarargs 645 public static ActivityOptions makeSceneTransitionAnimation(Activity activity, 646 Pair<View, String>... sharedElements) { 647 ActivityOptions opts = new ActivityOptions(); 648 makeSceneTransitionAnimation(activity, activity.getWindow(), opts, 649 activity.mExitTransitionListener, sharedElements); 650 return opts; 651 } 652 653 /** 654 * Call this immediately prior to startActivity to begin a shared element transition 655 * from a non-Activity. The window must support Window.FEATURE_ACTIVITY_TRANSITIONS. 656 * The exit transition will start immediately and the shared element transition will 657 * start once the launched Activity's shared element is ready. 658 * <p> 659 * When all transitions have completed and the shared element has been transfered, 660 * the window's decor View will have its visibility set to View.GONE. 661 * 662 * @hide 663 */ 664 @SafeVarargs 665 public static ActivityOptions startSharedElementAnimation(Window window, 666 Pair<View, String>... sharedElements) { 667 ActivityOptions opts = new ActivityOptions(); 668 final View decorView = window.getDecorView(); 669 if (decorView == null) { 670 return opts; 671 } 672 final ExitTransitionCoordinator exit = 673 makeSceneTransitionAnimation(null, window, opts, null, sharedElements); 674 if (exit != null) { 675 HideWindowListener listener = new HideWindowListener(window, exit); 676 exit.setHideSharedElementsCallback(listener); 677 exit.startExit(); 678 } 679 return opts; 680 } 681 682 /** 683 * This method should be called when the {@link #startSharedElementAnimation(Window, Pair[])} 684 * animation must be stopped and the Views reset. This can happen if there was an error 685 * from startActivity or a springboard activity and the animation should stop and reset. 686 * 687 * @hide 688 */ 689 public static void stopSharedElementAnimation(Window window) { 690 final View decorView = window.getDecorView(); 691 if (decorView == null) { 692 return; 693 } 694 final ExitTransitionCoordinator exit = (ExitTransitionCoordinator) 695 decorView.getTag(com.android.internal.R.id.cross_task_transition); 696 if (exit != null) { 697 exit.cancelPendingTransitions(); 698 decorView.setTagInternal(com.android.internal.R.id.cross_task_transition, null); 699 TransitionManager.endTransitions((ViewGroup) decorView); 700 exit.resetViews(); 701 exit.clearState(); 702 decorView.setVisibility(View.VISIBLE); 703 } 704 } 705 706 static ExitTransitionCoordinator makeSceneTransitionAnimation(Activity activity, Window window, 707 ActivityOptions opts, SharedElementCallback callback, 708 Pair<View, String>[] sharedElements) { 709 if (!window.hasFeature(Window.FEATURE_ACTIVITY_TRANSITIONS)) { 710 opts.mAnimationType = ANIM_DEFAULT; 711 return null; 712 } 713 opts.mAnimationType = ANIM_SCENE_TRANSITION; 714 715 ArrayList<String> names = new ArrayList<String>(); 716 ArrayList<View> views = new ArrayList<View>(); 717 718 if (sharedElements != null) { 719 for (int i = 0; i < sharedElements.length; i++) { 720 Pair<View, String> sharedElement = sharedElements[i]; 721 String sharedElementName = sharedElement.second; 722 if (sharedElementName == null) { 723 throw new IllegalArgumentException("Shared element name must not be null"); 724 } 725 names.add(sharedElementName); 726 View view = sharedElement.first; 727 if (view == null) { 728 throw new IllegalArgumentException("Shared element must not be null"); 729 } 730 views.add(sharedElement.first); 731 } 732 } 733 734 ExitTransitionCoordinator exit = new ExitTransitionCoordinator(activity, window, 735 callback, names, names, views, false); 736 opts.mTransitionReceiver = exit; 737 opts.mSharedElementNames = names; 738 opts.mIsReturning = (activity == null); 739 if (activity == null) { 740 opts.mExitCoordinatorIndex = -1; 741 } else { 742 opts.mExitCoordinatorIndex = 743 activity.mActivityTransitionState.addExitTransitionCoordinator(exit); 744 } 745 return exit; 746 } 747 748 /** @hide */ 749 static ActivityOptions makeSceneTransitionAnimation(Activity activity, 750 ExitTransitionCoordinator exitCoordinator, ArrayList<String> sharedElementNames, 751 int resultCode, Intent resultData) { 752 ActivityOptions opts = new ActivityOptions(); 753 opts.mAnimationType = ANIM_SCENE_TRANSITION; 754 opts.mSharedElementNames = sharedElementNames; 755 opts.mTransitionReceiver = exitCoordinator; 756 opts.mIsReturning = true; 757 opts.mResultCode = resultCode; 758 opts.mResultData = resultData; 759 opts.mExitCoordinatorIndex = 760 activity.mActivityTransitionState.addExitTransitionCoordinator(exitCoordinator); 761 return opts; 762 } 763 764 /** 765 * If set along with Intent.FLAG_ACTIVITY_NEW_DOCUMENT then the task being launched will not be 766 * presented to the user but will instead be only available through the recents task list. 767 * In addition, the new task wil be affiliated with the launching activity's task. 768 * Affiliated tasks are grouped together in the recents task list. 769 * 770 * <p>This behavior is not supported for activities with {@link 771 * android.R.styleable#AndroidManifestActivity_launchMode launchMode} values of 772 * <code>singleInstance</code> or <code>singleTask</code>. 773 */ 774 public static ActivityOptions makeTaskLaunchBehind() { 775 final ActivityOptions opts = new ActivityOptions(); 776 opts.mAnimationType = ANIM_LAUNCH_TASK_BEHIND; 777 return opts; 778 } 779 780 /** 781 * Create a basic ActivityOptions that has no special animation associated with it. 782 * Other options can still be set. 783 */ 784 public static ActivityOptions makeBasic() { 785 final ActivityOptions opts = new ActivityOptions(); 786 return opts; 787 } 788 789 /** @hide */ 790 public boolean getLaunchTaskBehind() { 791 return mAnimationType == ANIM_LAUNCH_TASK_BEHIND; 792 } 793 794 private ActivityOptions() { 795 } 796 797 /** @hide */ 798 public ActivityOptions(Bundle opts) { 799 // If the remote side sent us bad parcelables, they won't get the 800 // results they want, which is their loss. 801 opts.setDefusable(true); 802 803 mPackageName = opts.getString(KEY_PACKAGE_NAME); 804 try { 805 mUsageTimeReport = opts.getParcelable(KEY_USAGE_TIME_REPORT); 806 } catch (RuntimeException e) { 807 Slog.w(TAG, e); 808 } 809 mLaunchBounds = opts.getParcelable(KEY_LAUNCH_BOUNDS); 810 mAnimationType = opts.getInt(KEY_ANIM_TYPE); 811 switch (mAnimationType) { 812 case ANIM_CUSTOM: 813 mCustomEnterResId = opts.getInt(KEY_ANIM_ENTER_RES_ID, 0); 814 mCustomExitResId = opts.getInt(KEY_ANIM_EXIT_RES_ID, 0); 815 mAnimationStartedListener = IRemoteCallback.Stub.asInterface( 816 opts.getBinder(KEY_ANIM_START_LISTENER)); 817 break; 818 819 case ANIM_CUSTOM_IN_PLACE: 820 mCustomInPlaceResId = opts.getInt(KEY_ANIM_IN_PLACE_RES_ID, 0); 821 break; 822 823 case ANIM_SCALE_UP: 824 case ANIM_CLIP_REVEAL: 825 mStartX = opts.getInt(KEY_ANIM_START_X, 0); 826 mStartY = opts.getInt(KEY_ANIM_START_Y, 0); 827 mWidth = opts.getInt(KEY_ANIM_WIDTH, 0); 828 mHeight = opts.getInt(KEY_ANIM_HEIGHT, 0); 829 break; 830 831 case ANIM_THUMBNAIL_SCALE_UP: 832 case ANIM_THUMBNAIL_SCALE_DOWN: 833 case ANIM_THUMBNAIL_ASPECT_SCALE_UP: 834 case ANIM_THUMBNAIL_ASPECT_SCALE_DOWN: 835 mThumbnail = (Bitmap) opts.getParcelable(KEY_ANIM_THUMBNAIL); 836 mStartX = opts.getInt(KEY_ANIM_START_X, 0); 837 mStartY = opts.getInt(KEY_ANIM_START_Y, 0); 838 mWidth = opts.getInt(KEY_ANIM_WIDTH, 0); 839 mHeight = opts.getInt(KEY_ANIM_HEIGHT, 0); 840 mAnimationStartedListener = IRemoteCallback.Stub.asInterface( 841 opts.getBinder(KEY_ANIM_START_LISTENER)); 842 break; 843 844 case ANIM_SCENE_TRANSITION: 845 mTransitionReceiver = opts.getParcelable(KEY_TRANSITION_COMPLETE_LISTENER); 846 mIsReturning = opts.getBoolean(KEY_TRANSITION_IS_RETURNING, false); 847 mSharedElementNames = opts.getStringArrayList(KEY_TRANSITION_SHARED_ELEMENTS); 848 mResultData = opts.getParcelable(KEY_RESULT_DATA); 849 mResultCode = opts.getInt(KEY_RESULT_CODE); 850 mExitCoordinatorIndex = opts.getInt(KEY_EXIT_COORDINATOR_INDEX); 851 break; 852 } 853 mLaunchStackId = opts.getInt(KEY_LAUNCH_STACK_ID, INVALID_STACK_ID); 854 mLaunchTaskId = opts.getInt(KEY_LAUNCH_TASK_ID, -1); 855 mTaskOverlay = opts.getBoolean(KEY_TASK_OVERLAY, false); 856 mDockCreateMode = opts.getInt(KEY_DOCK_CREATE_MODE, DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT); 857 if (opts.containsKey(KEY_ANIM_SPECS)) { 858 Parcelable[] specs = opts.getParcelableArray(KEY_ANIM_SPECS); 859 mAnimSpecs = new AppTransitionAnimationSpec[specs.length]; 860 for (int i = specs.length - 1; i >= 0; i--) { 861 mAnimSpecs[i] = (AppTransitionAnimationSpec) specs[i]; 862 } 863 } 864 if (opts.containsKey(KEY_ANIMATION_FINISHED_LISTENER)) { 865 mAnimationFinishedListener = IRemoteCallback.Stub.asInterface( 866 opts.getBinder(KEY_ANIMATION_FINISHED_LISTENER)); 867 } 868 mRotationAnimationHint = opts.getInt(KEY_ROTATION_ANIMATION_HINT); 869 } 870 871 /** 872 * Sets the bounds (window size) that the activity should be launched in. 873 * Rect position should be provided in pixels and in screen coordinates. 874 * Set to null explicitly for fullscreen. 875 * <p> 876 * <strong>NOTE:<strong/> This value is ignored on devices that don't have 877 * {@link android.content.pm.PackageManager#FEATURE_FREEFORM_WINDOW_MANAGEMENT} or 878 * {@link android.content.pm.PackageManager#FEATURE_PICTURE_IN_PICTURE} enabled. 879 * @param screenSpacePixelRect Launch bounds to use for the activity or null for fullscreen. 880 */ 881 public ActivityOptions setLaunchBounds(@Nullable Rect screenSpacePixelRect) { 882 mLaunchBounds = screenSpacePixelRect != null ? new Rect(screenSpacePixelRect) : null; 883 return this; 884 } 885 886 /** @hide */ 887 public String getPackageName() { 888 return mPackageName; 889 } 890 891 /** 892 * Returns the bounds that should be used to launch the activity. 893 * @see #setLaunchBounds(Rect) 894 * @return Bounds used to launch the activity. 895 */ 896 @Nullable 897 public Rect getLaunchBounds() { 898 return mLaunchBounds; 899 } 900 901 /** @hide */ 902 public int getAnimationType() { 903 return mAnimationType; 904 } 905 906 /** @hide */ 907 public int getCustomEnterResId() { 908 return mCustomEnterResId; 909 } 910 911 /** @hide */ 912 public int getCustomExitResId() { 913 return mCustomExitResId; 914 } 915 916 /** @hide */ 917 public int getCustomInPlaceResId() { 918 return mCustomInPlaceResId; 919 } 920 921 /** @hide */ 922 public Bitmap getThumbnail() { 923 return mThumbnail; 924 } 925 926 /** @hide */ 927 public int getStartX() { 928 return mStartX; 929 } 930 931 /** @hide */ 932 public int getStartY() { 933 return mStartY; 934 } 935 936 /** @hide */ 937 public int getWidth() { 938 return mWidth; 939 } 940 941 /** @hide */ 942 public int getHeight() { 943 return mHeight; 944 } 945 946 /** @hide */ 947 public IRemoteCallback getOnAnimationStartListener() { 948 return mAnimationStartedListener; 949 } 950 951 /** @hide */ 952 public IRemoteCallback getAnimationFinishedListener() { 953 return mAnimationFinishedListener; 954 } 955 956 /** @hide */ 957 public int getExitCoordinatorKey() { return mExitCoordinatorIndex; } 958 959 /** @hide */ 960 public void abort() { 961 if (mAnimationStartedListener != null) { 962 try { 963 mAnimationStartedListener.sendResult(null); 964 } catch (RemoteException e) { 965 } 966 } 967 } 968 969 /** @hide */ 970 public boolean isReturning() { 971 return mIsReturning; 972 } 973 974 /** 975 * Returns whether or not the ActivityOptions was created with 976 * {@link #startSharedElementAnimation(Window, Pair[])}. 977 * 978 * @hide 979 */ 980 boolean isCrossTask() { 981 return mExitCoordinatorIndex < 0; 982 } 983 984 /** @hide */ 985 public ArrayList<String> getSharedElementNames() { 986 return mSharedElementNames; 987 } 988 989 /** @hide */ 990 public ResultReceiver getResultReceiver() { return mTransitionReceiver; } 991 992 /** @hide */ 993 public int getResultCode() { return mResultCode; } 994 995 /** @hide */ 996 public Intent getResultData() { return mResultData; } 997 998 /** @hide */ 999 public PendingIntent getUsageTimeReport() { 1000 return mUsageTimeReport; 1001 } 1002 1003 /** @hide */ 1004 public AppTransitionAnimationSpec[] getAnimSpecs() { return mAnimSpecs; } 1005 1006 /** @hide */ 1007 public static ActivityOptions fromBundle(Bundle bOptions) { 1008 return bOptions != null ? new ActivityOptions(bOptions) : null; 1009 } 1010 1011 /** @hide */ 1012 public static void abort(ActivityOptions options) { 1013 if (options != null) { 1014 options.abort(); 1015 } 1016 } 1017 1018 /** @hide */ 1019 public int getLaunchStackId() { 1020 return mLaunchStackId; 1021 } 1022 1023 /** @hide */ 1024 @TestApi 1025 public void setLaunchStackId(int launchStackId) { 1026 mLaunchStackId = launchStackId; 1027 } 1028 1029 /** 1030 * Sets the task the activity will be launched in. 1031 * @hide 1032 */ 1033 public void setLaunchTaskId(int taskId) { 1034 mLaunchTaskId = taskId; 1035 } 1036 1037 /** 1038 * @hide 1039 */ 1040 public int getLaunchTaskId() { 1041 return mLaunchTaskId; 1042 } 1043 1044 /** 1045 * Set's whether the activity launched with this option should be a task overlay. That is the 1046 * activity will always be the top activity of the task and doesn't cause the task to be moved 1047 * to the front when it is added. 1048 * @hide 1049 */ 1050 public void setTaskOverlay(boolean taskOverlay) { 1051 mTaskOverlay = taskOverlay; 1052 } 1053 1054 /** 1055 * @hide 1056 */ 1057 public boolean getTaskOverlay() { 1058 return mTaskOverlay; 1059 } 1060 1061 /** @hide */ 1062 public int getDockCreateMode() { 1063 return mDockCreateMode; 1064 } 1065 1066 /** @hide */ 1067 public void setDockCreateMode(int dockCreateMode) { 1068 mDockCreateMode = dockCreateMode; 1069 } 1070 1071 /** 1072 * Update the current values in this ActivityOptions from those supplied 1073 * in <var>otherOptions</var>. Any values 1074 * defined in <var>otherOptions</var> replace those in the base options. 1075 */ 1076 public void update(ActivityOptions otherOptions) { 1077 if (otherOptions.mPackageName != null) { 1078 mPackageName = otherOptions.mPackageName; 1079 } 1080 mUsageTimeReport = otherOptions.mUsageTimeReport; 1081 mTransitionReceiver = null; 1082 mSharedElementNames = null; 1083 mIsReturning = false; 1084 mResultData = null; 1085 mResultCode = 0; 1086 mExitCoordinatorIndex = 0; 1087 mAnimationType = otherOptions.mAnimationType; 1088 switch (otherOptions.mAnimationType) { 1089 case ANIM_CUSTOM: 1090 mCustomEnterResId = otherOptions.mCustomEnterResId; 1091 mCustomExitResId = otherOptions.mCustomExitResId; 1092 mThumbnail = null; 1093 if (mAnimationStartedListener != null) { 1094 try { 1095 mAnimationStartedListener.sendResult(null); 1096 } catch (RemoteException e) { 1097 } 1098 } 1099 mAnimationStartedListener = otherOptions.mAnimationStartedListener; 1100 break; 1101 case ANIM_CUSTOM_IN_PLACE: 1102 mCustomInPlaceResId = otherOptions.mCustomInPlaceResId; 1103 break; 1104 case ANIM_SCALE_UP: 1105 mStartX = otherOptions.mStartX; 1106 mStartY = otherOptions.mStartY; 1107 mWidth = otherOptions.mWidth; 1108 mHeight = otherOptions.mHeight; 1109 if (mAnimationStartedListener != null) { 1110 try { 1111 mAnimationStartedListener.sendResult(null); 1112 } catch (RemoteException e) { 1113 } 1114 } 1115 mAnimationStartedListener = null; 1116 break; 1117 case ANIM_THUMBNAIL_SCALE_UP: 1118 case ANIM_THUMBNAIL_SCALE_DOWN: 1119 case ANIM_THUMBNAIL_ASPECT_SCALE_UP: 1120 case ANIM_THUMBNAIL_ASPECT_SCALE_DOWN: 1121 mThumbnail = otherOptions.mThumbnail; 1122 mStartX = otherOptions.mStartX; 1123 mStartY = otherOptions.mStartY; 1124 mWidth = otherOptions.mWidth; 1125 mHeight = otherOptions.mHeight; 1126 if (mAnimationStartedListener != null) { 1127 try { 1128 mAnimationStartedListener.sendResult(null); 1129 } catch (RemoteException e) { 1130 } 1131 } 1132 mAnimationStartedListener = otherOptions.mAnimationStartedListener; 1133 break; 1134 case ANIM_SCENE_TRANSITION: 1135 mTransitionReceiver = otherOptions.mTransitionReceiver; 1136 mSharedElementNames = otherOptions.mSharedElementNames; 1137 mIsReturning = otherOptions.mIsReturning; 1138 mThumbnail = null; 1139 mAnimationStartedListener = null; 1140 mResultData = otherOptions.mResultData; 1141 mResultCode = otherOptions.mResultCode; 1142 mExitCoordinatorIndex = otherOptions.mExitCoordinatorIndex; 1143 break; 1144 } 1145 mAnimSpecs = otherOptions.mAnimSpecs; 1146 mAnimationFinishedListener = otherOptions.mAnimationFinishedListener; 1147 } 1148 1149 /** 1150 * Returns the created options as a Bundle, which can be passed to 1151 * {@link android.content.Context#startActivity(android.content.Intent, android.os.Bundle) 1152 * Context.startActivity(Intent, Bundle)} and related methods. 1153 * Note that the returned Bundle is still owned by the ActivityOptions 1154 * object; you must not modify it, but can supply it to the startActivity 1155 * methods that take an options Bundle. 1156 */ 1157 public Bundle toBundle() { 1158 if (mAnimationType == ANIM_DEFAULT) { 1159 return null; 1160 } 1161 Bundle b = new Bundle(); 1162 if (mPackageName != null) { 1163 b.putString(KEY_PACKAGE_NAME, mPackageName); 1164 } 1165 if (mLaunchBounds != null) { 1166 b.putParcelable(KEY_LAUNCH_BOUNDS, mLaunchBounds); 1167 } 1168 b.putInt(KEY_ANIM_TYPE, mAnimationType); 1169 if (mUsageTimeReport != null) { 1170 b.putParcelable(KEY_USAGE_TIME_REPORT, mUsageTimeReport); 1171 } 1172 switch (mAnimationType) { 1173 case ANIM_CUSTOM: 1174 b.putInt(KEY_ANIM_ENTER_RES_ID, mCustomEnterResId); 1175 b.putInt(KEY_ANIM_EXIT_RES_ID, mCustomExitResId); 1176 b.putBinder(KEY_ANIM_START_LISTENER, mAnimationStartedListener 1177 != null ? mAnimationStartedListener.asBinder() : null); 1178 break; 1179 case ANIM_CUSTOM_IN_PLACE: 1180 b.putInt(KEY_ANIM_IN_PLACE_RES_ID, mCustomInPlaceResId); 1181 break; 1182 case ANIM_SCALE_UP: 1183 case ANIM_CLIP_REVEAL: 1184 b.putInt(KEY_ANIM_START_X, mStartX); 1185 b.putInt(KEY_ANIM_START_Y, mStartY); 1186 b.putInt(KEY_ANIM_WIDTH, mWidth); 1187 b.putInt(KEY_ANIM_HEIGHT, mHeight); 1188 break; 1189 case ANIM_THUMBNAIL_SCALE_UP: 1190 case ANIM_THUMBNAIL_SCALE_DOWN: 1191 case ANIM_THUMBNAIL_ASPECT_SCALE_UP: 1192 case ANIM_THUMBNAIL_ASPECT_SCALE_DOWN: 1193 b.putParcelable(KEY_ANIM_THUMBNAIL, mThumbnail); 1194 b.putInt(KEY_ANIM_START_X, mStartX); 1195 b.putInt(KEY_ANIM_START_Y, mStartY); 1196 b.putInt(KEY_ANIM_WIDTH, mWidth); 1197 b.putInt(KEY_ANIM_HEIGHT, mHeight); 1198 b.putBinder(KEY_ANIM_START_LISTENER, mAnimationStartedListener 1199 != null ? mAnimationStartedListener.asBinder() : null); 1200 break; 1201 case ANIM_SCENE_TRANSITION: 1202 if (mTransitionReceiver != null) { 1203 b.putParcelable(KEY_TRANSITION_COMPLETE_LISTENER, mTransitionReceiver); 1204 } 1205 b.putBoolean(KEY_TRANSITION_IS_RETURNING, mIsReturning); 1206 b.putStringArrayList(KEY_TRANSITION_SHARED_ELEMENTS, mSharedElementNames); 1207 b.putParcelable(KEY_RESULT_DATA, mResultData); 1208 b.putInt(KEY_RESULT_CODE, mResultCode); 1209 b.putInt(KEY_EXIT_COORDINATOR_INDEX, mExitCoordinatorIndex); 1210 break; 1211 } 1212 b.putInt(KEY_LAUNCH_STACK_ID, mLaunchStackId); 1213 b.putInt(KEY_LAUNCH_TASK_ID, mLaunchTaskId); 1214 b.putBoolean(KEY_TASK_OVERLAY, mTaskOverlay); 1215 b.putInt(KEY_DOCK_CREATE_MODE, mDockCreateMode); 1216 if (mAnimSpecs != null) { 1217 b.putParcelableArray(KEY_ANIM_SPECS, mAnimSpecs); 1218 } 1219 if (mAnimationFinishedListener != null) { 1220 b.putBinder(KEY_ANIMATION_FINISHED_LISTENER, mAnimationFinishedListener.asBinder()); 1221 } 1222 b.putInt(KEY_ROTATION_ANIMATION_HINT, mRotationAnimationHint); 1223 1224 return b; 1225 } 1226 1227 /** 1228 * Ask the the system track that time the user spends in the app being launched, and 1229 * report it back once done. The report will be sent to the given receiver, with 1230 * the extras {@link #EXTRA_USAGE_TIME_REPORT} and {@link #EXTRA_USAGE_TIME_REPORT_PACKAGES} 1231 * filled in. 1232 * 1233 * <p>The time interval tracked is from launching this activity until the user leaves 1234 * that activity's flow. They are considered to stay in the flow as long as 1235 * new activities are being launched or returned to from the original flow, 1236 * even if this crosses package or task boundaries. For example, if the originator 1237 * starts an activity to view an image, and while there the user selects to share, 1238 * which launches their email app in a new task, and they complete the share, the 1239 * time during that entire operation will be included until they finally hit back from 1240 * the original image viewer activity.</p> 1241 * 1242 * <p>The user is considered to complete a flow once they switch to another 1243 * activity that is not part of the tracked flow. This may happen, for example, by 1244 * using the notification shade, launcher, or recents to launch or switch to another 1245 * app. Simply going in to these navigation elements does not break the flow (although 1246 * the launcher and recents stops time tracking of the session); it is the act of 1247 * going somewhere else that completes the tracking.</p> 1248 * 1249 * @param receiver A broadcast receiver that willl receive the report. 1250 */ 1251 public void requestUsageTimeReport(PendingIntent receiver) { 1252 mUsageTimeReport = receiver; 1253 } 1254 1255 /** 1256 * Return the filtered options only meant to be seen by the target activity itself 1257 * @hide 1258 */ 1259 public ActivityOptions forTargetActivity() { 1260 if (mAnimationType == ANIM_SCENE_TRANSITION) { 1261 final ActivityOptions result = new ActivityOptions(); 1262 result.update(this); 1263 return result; 1264 } 1265 1266 return null; 1267 } 1268 1269 /** 1270 * Returns the rotation animation set by {@link setRotationAnimationHint} or -1 1271 * if unspecified. 1272 * @hide 1273 */ 1274 public int getRotationAnimationHint() { 1275 return mRotationAnimationHint; 1276 } 1277 1278 1279 /** 1280 * Set a rotation animation to be used if launching the activity 1281 * triggers an orientation change, or -1 to clear. See 1282 * {@link android.view.WindowManager.LayoutParams} for rotation 1283 * animation values. 1284 * @hide 1285 */ 1286 public void setRotationAnimationHint(int hint) { 1287 mRotationAnimationHint = hint; 1288 } 1289 1290 /** @hide */ 1291 @Override 1292 public String toString() { 1293 return "ActivityOptions(" + hashCode() + "), mPackageName=" + mPackageName 1294 + ", mAnimationType=" + mAnimationType + ", mStartX=" + mStartX + ", mStartY=" 1295 + mStartY + ", mWidth=" + mWidth + ", mHeight=" + mHeight; 1296 } 1297 1298 private static class HideWindowListener extends Transition.TransitionListenerAdapter 1299 implements ExitTransitionCoordinator.HideSharedElementsCallback { 1300 private final Window mWindow; 1301 private final ExitTransitionCoordinator mExit; 1302 private final boolean mWaitingForTransition; 1303 private boolean mTransitionEnded; 1304 private boolean mSharedElementHidden; 1305 private ArrayList<View> mSharedElements; 1306 1307 public HideWindowListener(Window window, ExitTransitionCoordinator exit) { 1308 mWindow = window; 1309 mExit = exit; 1310 mSharedElements = new ArrayList<>(exit.mSharedElements); 1311 Transition transition = mWindow.getExitTransition(); 1312 if (transition != null) { 1313 transition.addListener(this); 1314 mWaitingForTransition = true; 1315 } else { 1316 mWaitingForTransition = false; 1317 } 1318 View decorView = mWindow.getDecorView(); 1319 if (decorView != null) { 1320 if (decorView.getTag(com.android.internal.R.id.cross_task_transition) != null) { 1321 throw new IllegalStateException( 1322 "Cannot start a transition while one is running"); 1323 } 1324 decorView.setTagInternal(com.android.internal.R.id.cross_task_transition, exit); 1325 } 1326 } 1327 1328 @Override 1329 public void onTransitionEnd(Transition transition) { 1330 mTransitionEnded = true; 1331 hideWhenDone(); 1332 transition.removeListener(this); 1333 } 1334 1335 @Override 1336 public void hideSharedElements() { 1337 mSharedElementHidden = true; 1338 hideWhenDone(); 1339 } 1340 1341 private void hideWhenDone() { 1342 if (mSharedElementHidden && (!mWaitingForTransition || mTransitionEnded)) { 1343 mExit.resetViews(); 1344 int numSharedElements = mSharedElements.size(); 1345 for (int i = 0; i < numSharedElements; i++) { 1346 View view = mSharedElements.get(i); 1347 view.requestLayout(); 1348 } 1349 View decorView = mWindow.getDecorView(); 1350 if (decorView != null) { 1351 decorView.setTagInternal( 1352 com.android.internal.R.id.cross_task_transition, null); 1353 decorView.setVisibility(View.GONE); 1354 } 1355 } 1356 } 1357 } 1358 } 1359
