Merge "Sending SceneTransitionInfo for scene transition to client" into main (6e4e56f1) · Commits · e / os / android_frameworks_base

core/java/android/app/Activity.java

+24 −20

Original line number	Diff line number	Diff line
		@@ -24,7 +24,9 @@ import static android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
		import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
		import static android.app.WindowConfiguration.inMultiWindowMode;
		import static android.os.Process.myUid;

		import static com.android.sdksandbox.flags.Flags.sandboxActivitySdkBasedContext;

		import static java.lang.Character.MIN_VALUE;

		import android.annotation.AnimRes;
		@@ -45,6 +47,7 @@ import android.annotation.SuppressLint;
		import android.annotation.SystemApi;
		import android.annotation.TestApi;
		import android.annotation.UiContext;
		import android.app.ActivityOptions.SceneTransitionInfo;
		import android.app.VoiceInteractor.Request;
		import android.app.admin.DevicePolicyManager;
		import android.app.assist.AssistContent;
		@@ -930,8 +933,8 @@ public class Activity extends ContextThemeWrapper
		@UnsupportedAppUsage
		final FragmentController mFragments = FragmentController.createController(new HostCallbacks());

		/** The options for scene transition. */
		ActivityOptions mPendingOptions;
		/** The scene transition info. */
		SceneTransitionInfo mSceneTransitionInfo;

		/ Whether this activity was launched from a bubble. /
		boolean mLaunchedFromBubble;
		@@ -5807,10 +5810,9 @@ public class Activity extends ContextThemeWrapper

		private Bundle transferSpringboardActivityOptions(@Nullable Bundle options) {
		if (options == null && (mWindow != null && !mWindow.isActive())) {
		final ActivityOptions activityOptions = getActivityOptions();
		if (activityOptions != null &&
		activityOptions.getAnimationType() == ActivityOptions.ANIM_SCENE_TRANSITION) {
		return activityOptions.toBundle();
		final SceneTransitionInfo info = getSceneTransitionInfo();
		if (info != null) {
		return ActivityOptions.makeBasic().setSceneTransitionInfo(info).toBundle();
		}
		}
		return options;
		@@ -8079,8 +8081,10 @@ public class Activity extends ContextThemeWrapper
		*
		* @param callback the method to call when all visible activities behind this one have been
		* drawn and it is safe to make this activity translucent again.
		* @param options activity options delivered to the activity below this one. The options
		* are retrieved using {@link #getActivityOptions}.
		* @param options activity options that created from
		* {@link ActivityOptions#makeSceneTransitionAnimation} which will be converted to
		* {@link SceneTransitionInfo} and delivered to the activity below this one. The
		* options are retrieved using {@link #getSceneTransitionInfo}.
		* @return <code>true</code> if Window was opaque and will become translucent or
		* <code>false</code> if window was translucent and no change needed to be made.
		*
		@@ -8116,27 +8120,27 @@ public class Activity extends ContextThemeWrapper
		}

		/** @hide */
		public void onNewActivityOptions(ActivityOptions options) {
		mActivityTransitionState.setEnterActivityOptions(this, options);
		public void onNewSceneTransitionInfo(ActivityOptions.SceneTransitionInfo info) {
		mActivityTransitionState.setEnterSceneTransitionInfo(this, info);
		if (!mStopped) {
		mActivityTransitionState.enterReady(this);
		}
		}

		/**
		* Takes the ActivityOptions passed in from the launching activity or passed back
		* Takes the {@link SceneTransitionInfo} passed in from the launching activity or passed back
		* from an activity launched by this activity in its call to {@link
		* #convertToTranslucent(TranslucentConversionListener, ActivityOptions)}
		*
		* @return The ActivityOptions passed to {@link #convertToTranslucent}.
		* @return The {@link SceneTransitionInfo} which based on the ActivityOptions that originally
		* passed to {@link #convertToTranslucent}.
		* @hide
		*/
		@UnsupportedAppUsage
		ActivityOptions getActivityOptions() {
		final ActivityOptions options = mPendingOptions;
		// The option only applies once.
		mPendingOptions = null;
		return options;
		SceneTransitionInfo getSceneTransitionInfo() {
		final SceneTransitionInfo sceneTransitionInfo = mSceneTransitionInfo;
		// The info only applies once.
		mSceneTransitionInfo = null;
		return sceneTransitionInfo;
		}

		/**
		@@ -8780,7 +8784,7 @@ public class Activity extends ContextThemeWrapper
		mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
		com.android.internal.R.styleable.Window_windowNoDisplay, false);
		mFragments.dispatchActivityCreated();
		mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
		mActivityTransitionState.setEnterSceneTransitionInfo(this, getSceneTransitionInfo());
		dispatchActivityPostCreated(icicle);
		Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
		}
		@@ -8798,7 +8802,7 @@ public class Activity extends ContextThemeWrapper
		+ mComponent.getClassName());
		}
		dispatchActivityPreStarted();
		mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
		mActivityTransitionState.setEnterSceneTransitionInfo(this, getSceneTransitionInfo());
		mFragments.noteStateNotSaved();
		mCalled = false;
		mFragments.execPendingActions();

core/java/android/app/ActivityOptions.aidl

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		/**
		* Copyright (c) 2024, The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package android.app;

		/** @hide */
		parcelable ActivityOptions.SceneTransitionInfo;
		No newline at end of file

core/java/android/app/ActivityOptions.java

+160 −89

Original line number	Diff line number	Diff line
		@@ -357,22 +357,7 @@ public class ActivityOptions extends ComponentOptions {
		private static final String KEY_APPLY_NO_USER_ACTION_FLAG_FOR_SHORTCUT =
		"android:activity.applyNoUserActionFlagForShortcut";

		/**
		* For Activity transitions, the calling Activity's TransitionListener used to
		* notify the called Activity when the shared element and the exit transitions
		* complete.
		*/
		private static final String KEY_TRANSITION_COMPLETE_LISTENER
		= "android:activity.transitionCompleteListener";

		private static final String KEY_TRANSITION_IS_RETURNING
		= "android:activity.transitionIsReturning";
		private static final String KEY_TRANSITION_SHARED_ELEMENTS
		= "android:activity.sharedElementNames";
		private static final String KEY_RESULT_DATA = "android:activity.resultData";
		private static final String KEY_RESULT_CODE = "android:activity.resultCode";
		private static final String KEY_EXIT_COORDINATOR_INDEX
		= "android:activity.exitCoordinatorIndex";
		private static final String KEY_SCENE_TRANSITION_INFO = "android:activity.sceneTransitionInfo";

		/** See {@link SourceInfo}. */
		private static final String KEY_SOURCE_INFO = "android.activity.sourceInfo";
		@@ -472,12 +457,7 @@ public class ActivityOptions extends ComponentOptions {
		private int mHeight;
		private IRemoteCallback mAnimationStartedListener;
		private IRemoteCallback mAnimationFinishedListener;
		private ResultReceiver mTransitionReceiver;
		private boolean mIsReturning;
		private ArrayList<String> mSharedElementNames;
		private Intent mResultData;
		private int mResultCode;
		private int mExitCoordinatorIndex;
		private SceneTransitionInfo mSceneTransitionInfo;
		private PendingIntent mUsageTimeReport;
		private int mLaunchDisplayId = INVALID_DISPLAY;
		private int mCallerDisplayId = INVALID_DISPLAY;
		@@ -1006,8 +986,11 @@ public class ActivityOptions extends ComponentOptions {
		ExitTransitionCoordinator exit = makeSceneTransitionAnimation(
		new ActivityExitTransitionCallbacks(activity), activity.mExitTransitionListener,
		activity.getWindow(), opts, sharedElements);
		opts.mExitCoordinatorIndex =
		activity.mActivityTransitionState.addExitTransitionCoordinator(exit);
		final SceneTransitionInfo info = opts.getSceneTransitionInfo();
		if (info != null) {
		info.setExitCoordinatorKey(
		activity.mActivityTransitionState.addExitTransitionCoordinator(exit));
		}
		return opts;
		}

		@@ -1029,13 +1012,16 @@ public class ActivityOptions extends ComponentOptions {
		ActivityOptions opts = new ActivityOptions();
		ExitTransitionCoordinator exit = makeSceneTransitionAnimation(
		exitCallbacks, callback, window, opts, sharedElements);
		opts.mExitCoordinatorIndex = -1;
		final SceneTransitionInfo info = opts.getSceneTransitionInfo();
		if (info != null) {
		info.setExitCoordinatorKey(-1);
		}
		return Pair.create(opts, exit);
		}

		/**
		* This method should be called when the
		* {@link #startSharedElementAnimation(Window, ExitTransitionCallbacks, Pair[])}
		* This method should be called when the {@link #startSharedElementAnimation(Window,
		* ExitTransitionCallbacks, SharedElementCallback, Pair[])}
		* animation must be stopped and the Views reset. This can happen if there was an error
		* from startActivity or a springboard activity and the animation should stop and reset.
		*
		@@ -1088,9 +1074,11 @@ public class ActivityOptions extends ComponentOptions {

		ExitTransitionCoordinator exit = new ExitTransitionCoordinator(exitCallbacks, window,
		callback, names, names, views, false);
		opts.mTransitionReceiver = exit;
		opts.mSharedElementNames = names;
		opts.mIsReturning = false;
		final SceneTransitionInfo info = new SceneTransitionInfo();
		info.setResultReceiver(exit);
		info.setSharedElementNames(names);
		info.setReturning(false);
		opts.setSceneTransitionInfo(info);
		return exit;
		}

		@@ -1111,17 +1099,20 @@ public class ActivityOptions extends ComponentOptions {
		int resultCode, Intent resultData) {
		ActivityOptions opts = new ActivityOptions();
		opts.mAnimationType = ANIM_SCENE_TRANSITION;
		opts.mSharedElementNames = sharedElementNames;
		opts.mTransitionReceiver = exitCoordinator;
		opts.mIsReturning = true;
		opts.mResultCode = resultCode;
		opts.mResultData = resultData;
		final SceneTransitionInfo info = new SceneTransitionInfo();
		info.setSharedElementNames(sharedElementNames);
		info.setResultReceiver(exitCoordinator);
		info.setReturning(true);
		info.setResultCode(resultCode);
		info.setResultData(resultData);
		if (activity == null) {
		opts.mExitCoordinatorIndex = -1;
		info.setExitCoordinatorKey(-1);
		} else {
		opts.mExitCoordinatorIndex =
		activity.mActivityTransitionState.addExitTransitionCoordinator(exitCoordinator);
		info.setExitCoordinatorKey(
		activity.mActivityTransitionState.addExitTransitionCoordinator(
		exitCoordinator));
		}
		opts.setSceneTransitionInfo(info);
		return opts;
		}

		@@ -1269,12 +1260,8 @@ public class ActivityOptions extends ComponentOptions {
		break;

		case ANIM_SCENE_TRANSITION:
		mTransitionReceiver = opts.getParcelable(KEY_TRANSITION_COMPLETE_LISTENER, android.os.ResultReceiver.class);
		mIsReturning = opts.getBoolean(KEY_TRANSITION_IS_RETURNING, false);
		mSharedElementNames = opts.getStringArrayList(KEY_TRANSITION_SHARED_ELEMENTS);
		mResultData = opts.getParcelable(KEY_RESULT_DATA, android.content.Intent.class);
		mResultCode = opts.getInt(KEY_RESULT_CODE);
		mExitCoordinatorIndex = opts.getInt(KEY_EXIT_COORDINATOR_INDEX);
		mSceneTransitionInfo = opts.getParcelable(KEY_SCENE_TRANSITION_INFO,
		SceneTransitionInfo.class);
		break;
		}
		mLockTaskMode = opts.getBoolean(KEY_LOCK_TASK_MODE, false);
		@@ -1436,9 +1423,6 @@ public class ActivityOptions extends ComponentOptions {
		return mAnimationFinishedListener;
		}

		/** @hide */
		public int getExitCoordinatorKey() { return mExitCoordinatorIndex; }

		/** @hide */
		public void abort() {
		if (mAnimationStartedListener != null) {
		@@ -1450,34 +1434,16 @@ public class ActivityOptions extends ComponentOptions {
		}

		/** @hide */
		public boolean isReturning() {
		return mIsReturning;
		}

		/**
		* Returns whether or not the ActivityOptions was created with
		* {@link #startSharedElementAnimation(Window, Pair[])}.
		*
		* @hide
		*/
		boolean isCrossTask() {
		return mExitCoordinatorIndex < 0;
		public ActivityOptions setSceneTransitionInfo(SceneTransitionInfo info) {
		mSceneTransitionInfo = info;
		return this;
		}

		/** @hide */
		public ArrayList<String> getSharedElementNames() {
		return mSharedElementNames;
		public SceneTransitionInfo getSceneTransitionInfo() {
		return mSceneTransitionInfo;
		}

		/** @hide */
		public ResultReceiver getResultReceiver() { return mTransitionReceiver; }

		/** @hide */
		public int getResultCode() { return mResultCode; }

		/** @hide */
		public Intent getResultData() { return mResultData; }

		/** @hide */
		public PendingIntent getUsageTimeReport() {
		return mUsageTimeReport;
		@@ -2102,12 +2068,7 @@ public class ActivityOptions extends ComponentOptions {
		mPackageName = otherOptions.mPackageName;
		}
		mUsageTimeReport = otherOptions.mUsageTimeReport;
		mTransitionReceiver = null;
		mSharedElementNames = null;
		mIsReturning = false;
		mResultData = null;
		mResultCode = 0;
		mExitCoordinatorIndex = 0;
		mSceneTransitionInfo = null;
		mAnimationType = otherOptions.mAnimationType;
		switch (otherOptions.mAnimationType) {
		case ANIM_CUSTOM:
		@@ -2157,14 +2118,9 @@ public class ActivityOptions extends ComponentOptions {
		mAnimationStartedListener = otherOptions.mAnimationStartedListener;
		break;
		case ANIM_SCENE_TRANSITION:
		mTransitionReceiver = otherOptions.mTransitionReceiver;
		mSharedElementNames = otherOptions.mSharedElementNames;
		mIsReturning = otherOptions.mIsReturning;
		mSceneTransitionInfo = otherOptions.mSceneTransitionInfo;
		mThumbnail = null;
		mAnimationStartedListener = null;
		mResultData = otherOptions.mResultData;
		mResultCode = otherOptions.mResultCode;
		mExitCoordinatorIndex = otherOptions.mExitCoordinatorIndex;
		break;
		}
		mLockTaskMode = otherOptions.mLockTaskMode;
		@@ -2240,14 +2196,9 @@ public class ActivityOptions extends ComponentOptions {
		!= null ? mAnimationStartedListener.asBinder() : null);
		break;
		case ANIM_SCENE_TRANSITION:
		if (mTransitionReceiver != null) {
		b.putParcelable(KEY_TRANSITION_COMPLETE_LISTENER, mTransitionReceiver);
		}
		b.putBoolean(KEY_TRANSITION_IS_RETURNING, mIsReturning);
		b.putStringArrayList(KEY_TRANSITION_SHARED_ELEMENTS, mSharedElementNames);
		b.putParcelable(KEY_RESULT_DATA, mResultData);
		b.putInt(KEY_RESULT_CODE, mResultCode);
		b.putInt(KEY_EXIT_COORDINATOR_INDEX, mExitCoordinatorIndex);
		if (mSceneTransitionInfo != null) {
		b.putParcelable(KEY_SCENE_TRANSITION_INFO, mSceneTransitionInfo);
		}
		break;
		}
		if (mLockTaskMode) {
		@@ -2607,4 +2558,124 @@ public class ActivityOptions extends ComponentOptions {
		}
		};
		}

		/**
		* This class contains necessary information for Activity Scene Transition.
		*
		* @hide
		*/
		public static class SceneTransitionInfo implements Parcelable {
		private boolean mIsReturning;
		private int mResultCode;
		@Nullable
		private Intent mResultData;
		@Nullable
		private ArrayList<String> mSharedElementNames;
		@Nullable
		private ResultReceiver mResultReceiver;
		private int mExitCoordinatorIndex;

		public SceneTransitionInfo() {
		}

		SceneTransitionInfo(Parcel in) {
		mIsReturning = in.readBoolean();
		mResultCode = in.readInt();
		mResultData = in.readTypedObject(Intent.CREATOR);
		mSharedElementNames = in.createStringArrayList();
		mResultReceiver = in.readTypedObject(ResultReceiver.CREATOR);
		mExitCoordinatorIndex = in.readInt();
		}

		public static final Creator<SceneTransitionInfo> CREATOR = new Creator<>() {
		@Override
		public SceneTransitionInfo createFromParcel(Parcel in) {
		return new SceneTransitionInfo(in);
		}

		@Override
		public SceneTransitionInfo[] newArray(int size) {
		return new SceneTransitionInfo[size];
		}
		};

		@Override
		public int describeContents() {
		return 0;
		}

		@Override
		public void writeToParcel(Parcel dest, int flags) {
		dest.writeBoolean(mIsReturning);
		dest.writeInt(mResultCode);
		dest.writeTypedObject(mResultData, flags);
		dest.writeStringList(mSharedElementNames);
		dest.writeTypedObject(mResultReceiver, flags);
		dest.writeInt(mExitCoordinatorIndex);
		}

		public void setReturning(boolean isReturning) {
		mIsReturning = isReturning;
		}

		public boolean isReturning() {
		return mIsReturning;
		}

		public void setResultCode(int resultCode) {
		mResultCode = resultCode;
		}

		public int getResultCode() {
		return mResultCode;
		}

		public void setResultData(Intent resultData) {
		mResultData = resultData;
		}

		@Nullable
		public Intent getResultData() {
		return mResultData;
		}

		public void setSharedElementNames(ArrayList<String> sharedElementNames) {
		mSharedElementNames = sharedElementNames;
		}

		@Nullable
		public ArrayList<String> getSharedElementNames() {
		return mSharedElementNames;
		}

		public void setResultReceiver(ResultReceiver resultReceiver) {
		mResultReceiver = resultReceiver;
		}

		@Nullable
		public ResultReceiver getResultReceiver() {
		return mResultReceiver;
		}

		public void setExitCoordinatorKey(int exitCoordinatorKey) {
		mExitCoordinatorIndex = exitCoordinatorKey;
		}

		public int getExitCoordinatorKey() {
		return mExitCoordinatorIndex;
		}

		boolean isCrossTask() {
		return mExitCoordinatorIndex < 0;
		}

		@Override
		public String toString() {
		return "SceneTransitionInfo, mIsReturning=" + mIsReturning
		+ ", mResultCode=" + mResultCode + ", mResultData=" + mResultData
		+ ", mSharedElementNames=" + mSharedElementNames
		+ ", mTransitionReceiver=" + mResultReceiver
		+ ", mExitCoordinatorIndex=" + mExitCoordinatorIndex;
		}
		}
		}

core/java/android/app/ActivityThread.java

+22 −20

Original line number	Diff line number	Diff line
		@@ -43,6 +43,7 @@ import static com.android.sdksandbox.flags.Flags.sandboxActivitySdkBasedContext;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.ActivityOptions.SceneTransitionInfo;
		import android.app.RemoteServiceException.BadForegroundServiceNotificationException;
		import android.app.RemoteServiceException.BadUserInitiatedJobNotificationException;
		import android.app.RemoteServiceException.CannotPostForegroundServiceNotificationException;
		@@ -632,8 +633,8 @@ public final class ActivityThread extends ClientTransactionHandler
		@UnsupportedAppUsage
		boolean mPreserveWindow;

		/** The options for scene transition. */
		ActivityOptions mActivityOptions;
		/** The scene transition info. */
		SceneTransitionInfo mSceneTransitionInfo;

		/** Whether this activiy was launched from a bubble. */
		boolean mLaunchedFromBubble;
		@@ -660,7 +661,7 @@ public final class ActivityThread extends ClientTransactionHandler
		ActivityInfo info, Configuration overrideConfig,
		String referrer, IVoiceInteractor voiceInteractor, Bundle state,
		PersistableBundle persistentState, List<ResultInfo> pendingResults,
		List<ReferrerIntent> pendingNewIntents, ActivityOptions activityOptions,
		List<ReferrerIntent> pendingNewIntents, SceneTransitionInfo sceneTransitionInfo,
		boolean isForward, ProfilerInfo profilerInfo, ClientTransactionHandler client,
		IBinder assistToken, IBinder shareableActivityToken, boolean launchedFromBubble,
		IBinder taskFragmentToken) {
		@@ -680,7 +681,7 @@ public final class ActivityThread extends ClientTransactionHandler
		this.profilerInfo = profilerInfo;
		this.overrideConfig = overrideConfig;
		this.packageInfo = client.getPackageInfoNoCheck(activityInfo.applicationInfo);
		mActivityOptions = activityOptions;
		mSceneTransitionInfo = sceneTransitionInfo;
		mLaunchedFromBubble = launchedFromBubble;
		mTaskFragmentToken = taskFragmentToken;
		init();
		@@ -1960,9 +1961,9 @@ public final class ActivityThread extends ClientTransactionHandler
		sendMessage(H.TRANSLUCENT_CONVERSION_COMPLETE, token, drawComplete ? 1 : 0);
		}

		public void scheduleOnNewActivityOptions(IBinder token, Bundle options) {
		sendMessage(H.ON_NEW_ACTIVITY_OPTIONS,
		new Pair<IBinder, ActivityOptions>(token, ActivityOptions.fromBundle(options)));
		public void scheduleOnNewSceneTransitionInfo(IBinder token, SceneTransitionInfo info) {
		sendMessage(H.ON_NEW_SCENE_TRANSITION_INFO,
		new Pair<IBinder, SceneTransitionInfo>(token, info));
		}

		public void setProcessState(int state) {
		@@ -2258,7 +2259,7 @@ public final class ActivityThread extends ClientTransactionHandler
		public static final int TRANSLUCENT_CONVERSION_COMPLETE = 144;
		@UnsupportedAppUsage
		public static final int INSTALL_PROVIDER = 145;
		public static final int ON_NEW_ACTIVITY_OPTIONS = 146;
		public static final int ON_NEW_SCENE_TRANSITION_INFO = 146;
		@UnsupportedAppUsage
		public static final int ENTER_ANIMATION_COMPLETE = 149;
		public static final int START_BINDER_TRACKING = 150;
		@@ -2314,7 +2315,7 @@ public final class ActivityThread extends ClientTransactionHandler
		case REQUEST_ASSIST_CONTEXT_EXTRAS: return "REQUEST_ASSIST_CONTEXT_EXTRAS";
		case TRANSLUCENT_CONVERSION_COMPLETE: return "TRANSLUCENT_CONVERSION_COMPLETE";
		case INSTALL_PROVIDER: return "INSTALL_PROVIDER";
		case ON_NEW_ACTIVITY_OPTIONS: return "ON_NEW_ACTIVITY_OPTIONS";
		case ON_NEW_SCENE_TRANSITION_INFO: return "ON_NEW_SCENE_TRANSITION_INFO";
		case ENTER_ANIMATION_COMPLETE: return "ENTER_ANIMATION_COMPLETE";
		case LOCAL_VOICE_INTERACTION_STARTED: return "LOCAL_VOICE_INTERACTION_STARTED";
		case ATTACH_AGENT: return "ATTACH_AGENT";
		@@ -2520,9 +2521,10 @@ public final class ActivityThread extends ClientTransactionHandler
		Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
		}
		break;
		case ON_NEW_ACTIVITY_OPTIONS:
		Pair<IBinder, ActivityOptions> pair = (Pair<IBinder, ActivityOptions>) msg.obj;
		onNewActivityOptions(pair.first, pair.second);
		case ON_NEW_SCENE_TRANSITION_INFO:
		Pair<IBinder, SceneTransitionInfo> pair =
		(Pair<IBinder, SceneTransitionInfo>) msg.obj;
		onNewSceneTransitionInfo(pair.first, pair.second);
		break;
		case ENTER_ANIMATION_COMPLETE:
		handleEnterAnimationComplete((IBinder) msg.obj);
		@@ -3921,9 +3923,9 @@ public final class ActivityThread extends ClientTransactionHandler
		activity.setTheme(theme);
		}

		if (r.mActivityOptions != null) {
		activity.mPendingOptions = r.mActivityOptions;
		r.mActivityOptions = null;
		if (r.mSceneTransitionInfo != null) {
		activity.mSceneTransitionInfo = r.mSceneTransitionInfo;
		r.mSceneTransitionInfo = null;
		}
		activity.mLaunchedFromBubble = r.mLaunchedFromBubble;
		activity.mCalled = false;
		@@ -3962,7 +3964,7 @@ public final class ActivityThread extends ClientTransactionHandler

		@Override
		public void handleStartActivity(ActivityClientRecord r,
		PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
		PendingTransactionActions pendingActions, SceneTransitionInfo sceneTransitionInfo) {
		final Activity activity = r.activity;
		if (!r.stopped) {
		throw new IllegalStateException("Can't start activity that is not stopped.");
		@@ -3973,8 +3975,8 @@ public final class ActivityThread extends ClientTransactionHandler
		}

		unscheduleGcIdler();
		if (activityOptions != null) {
		activity.mPendingOptions = activityOptions;
		if (sceneTransitionInfo != null) {
		activity.mSceneTransitionInfo = sceneTransitionInfo;
		}

		// Start
		@@ -4349,10 +4351,10 @@ public final class ActivityThread extends ClientTransactionHandler
		}
		}

		public void onNewActivityOptions(IBinder token, ActivityOptions options) {
		public void onNewSceneTransitionInfo(IBinder token, SceneTransitionInfo info) {
		ActivityClientRecord r = mActivities.get(token);
		if (r != null) {
		r.activity.onNewActivityOptions(options);
		r.activity.onNewSceneTransitionInfo(info);
		}
		}

core/java/android/app/ActivityTransitionState.java

+26 −24

File changed.

Preview size limit exceeded, changes collapsed.