Synchronize window config updates (4/n)

Before, ClientTransaction can only contain one ActivityTransactionItem,
and store the activity token in ClientTransaction.

Now, each ActivityTransactionItem stores its own activity token, so that
it unblocks to have multiple ActivityTransactionItems in one
ClientTransaction.

Bug: 260873529
Test: atest FrameworksCoreTests:ObjectPoolTests
Test: atest FrameworksCoreTests:TransactionExecutorTests
Change-Id: Ida1bfd63fe5b58280fd66c09e3cdecc62be2d990

34 files changed, 857 insertions, 510 deletions

diff --git a/core/java/android/app/ActivityThread.java b/core/java/android/app/ActivityThread.java
index 39589fa93149..618dfd2a40f7 100644
--- a/core/java/android/app/ActivityThread.java
+++ b/core/java/android/app/ActivityThread.java
@@ -3651,15 +3651,16 @@ public final class ActivityThread extends ClientTransactionHandler
     }
 
     @UnsupportedAppUsage
-    public final void sendActivityResult(
-            IBinder token, String id, int requestCode,
+    public void sendActivityResult(
+            IBinder activityToken, String id, int requestCode,
             int resultCode, Intent data) {
         if (DEBUG_RESULTS) Slog.v(TAG, "sendActivityResult: id=" + id
                 + " req=" + requestCode + " res=" + resultCode + " data=" + data);
         ArrayList<ResultInfo> list = new ArrayList<ResultInfo>();
         list.add(new ResultInfo(id, requestCode, resultCode, data));
-        final ClientTransaction clientTransaction = ClientTransaction.obtain(mAppThread, token);
-        clientTransaction.addCallback(ActivityResultItem.obtain(list));
+        final ClientTransaction clientTransaction = ClientTransaction.obtain(mAppThread,
+                activityToken);
+        clientTransaction.addCallback(ActivityResultItem.obtain(activityToken, list));
         try {
             mAppThread.scheduleTransaction(clientTransaction);
         } catch (RemoteException e) {
@@ -4361,16 +4362,16 @@ public final class ActivityThread extends ClientTransactionHandler
 
     private void schedulePauseWithUserLeavingHint(ActivityClientRecord r) {
         final ClientTransaction transaction = ClientTransaction.obtain(this.mAppThread, r.token);
-        transaction.setLifecycleStateRequest(PauseActivityItem.obtain(r.activity.isFinishing(),
-                /* userLeaving */ true, r.activity.mConfigChangeFlags, /* dontReport */ false,
-                /* autoEnteringPip */ false));
+        transaction.setLifecycleStateRequest(PauseActivityItem.obtain(r.token,
+                r.activity.isFinishing(), /* userLeaving */ true, r.activity.mConfigChangeFlags,
+                /* dontReport */ false, /* autoEnteringPip */ false));
         executeTransaction(transaction);
     }
 
     private void scheduleResume(ActivityClientRecord r) {
         final ClientTransaction transaction = ClientTransaction.obtain(this.mAppThread, r.token);
-        transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(/* isForward */ false,
-                /* shouldSendCompatFakeFocus */ false));
+        transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(r.token,
+                /* isForward */ false, /* shouldSendCompatFakeFocus */ false));
         executeTransaction(transaction);
     }
 
@@ -5954,8 +5955,8 @@ public final class ActivityThread extends ClientTransactionHandler
                         ? r.createdConfig : mConfigurationController.getConfiguration(),
                 r.overrideConfig);
         final ActivityRelaunchItem activityRelaunchItem = ActivityRelaunchItem.obtain(
-                null /* pendingResults */, null /* pendingIntents */, 0 /* configChanges */,
-                mergedConfiguration, r.mPreserveWindow);
+                r.token, null /* pendingResults */, null /* pendingIntents */,
+                0 /* configChanges */, mergedConfiguration, r.mPreserveWindow);
         // Make sure to match the existing lifecycle state in the end of the transaction.
         final ActivityLifecycleItem lifecycleRequest =
                 TransactionExecutorHelper.getLifecycleRequestForCurrentState(r);
diff --git a/core/java/android/app/servertransaction/ActivityConfigurationChangeItem.java b/core/java/android/app/servertransaction/ActivityConfigurationChangeItem.java
index e40925441f0f..c2c54278a84e 100644
--- a/core/java/android/app/servertransaction/ActivityConfigurationChangeItem.java
+++ b/core/java/android/app/servertransaction/ActivityConfigurationChangeItem.java
@@ -45,7 +45,7 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
         CompatibilityInfo.applyOverrideScaleIfNeeded(mConfiguration);
         // Notify the client of an upcoming change in the token configuration. This ensures that
         // batches of config change items only process the newest configuration.
-        client.updatePendingActivityConfiguration(token, mConfiguration);
+        client.updatePendingActivityConfiguration(getActivityToken(), mConfiguration);
     }
 
     @Override
@@ -61,8 +61,7 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
     @Override
     public Context getContextToUpdate(@NonNull ClientTransactionHandler client,
             @Nullable IBinder token) {
-        // TODO(b/260873529): Update ClientTransaction to bundle multiple activity config updates.
-        return client.getActivity(token);
+        return client.getActivity(getActivityToken());
     }
 
     // ObjectPoolItem implementation
@@ -70,7 +69,9 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
     private ActivityConfigurationChangeItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static ActivityConfigurationChangeItem obtain(@NonNull Configuration config) {
+    @NonNull
+    public static ActivityConfigurationChangeItem obtain(@NonNull IBinder activityToken,
+            @NonNull Configuration config) {
         if (config == null) {
             throw new IllegalArgumentException("Config must not be null.");
         }
@@ -80,6 +81,7 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
         if (instance == null) {
             instance = new ActivityConfigurationChangeItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mConfiguration = config;
 
         return instance;
@@ -87,6 +89,7 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mConfiguration = Configuration.EMPTY;
         ObjectPool.recycle(this);
     }
@@ -96,32 +99,34 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeTypedObject(mConfiguration, flags);
     }
 
     /** Read from Parcel. */
-    private ActivityConfigurationChangeItem(Parcel in) {
+    private ActivityConfigurationChangeItem(@NonNull Parcel in) {
+        super(in);
         mConfiguration = in.readTypedObject(Configuration.CREATOR);
     }
 
     public static final @NonNull Creator<ActivityConfigurationChangeItem> CREATOR =
-            new Creator<ActivityConfigurationChangeItem>() {
-        public ActivityConfigurationChangeItem createFromParcel(Parcel in) {
-            return new ActivityConfigurationChangeItem(in);
-        }
+            new Creator<>() {
+                public ActivityConfigurationChangeItem createFromParcel(@NonNull Parcel in) {
+                    return new ActivityConfigurationChangeItem(in);
+                }
 
-        public ActivityConfigurationChangeItem[] newArray(int size) {
-            return new ActivityConfigurationChangeItem[size];
-        }
-    };
+                public ActivityConfigurationChangeItem[] newArray(int size) {
+                    return new ActivityConfigurationChangeItem[size];
+                }
+            };
 
     @Override
     public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final ActivityConfigurationChangeItem other = (ActivityConfigurationChangeItem) o;
@@ -130,11 +135,15 @@ public class ActivityConfigurationChangeItem extends ActivityTransactionItem {
 
     @Override
     public int hashCode() {
-        return mConfiguration.hashCode();
+        int result = 17;
+        result = 31 * result + super.hashCode();
+        result = 31 * result + Objects.hashCode(mConfiguration);
+        return result;
     }
 
     @Override
     public String toString() {
-        return "ActivityConfigurationChange{config=" + mConfiguration + "}";
+        return "ActivityConfigurationChange{" + super.toString()
+                + ",config=" + mConfiguration + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/ActivityLifecycleItem.java b/core/java/android/app/servertransaction/ActivityLifecycleItem.java
index cadb6606b1be..b34f6788fb60 100644
--- a/core/java/android/app/servertransaction/ActivityLifecycleItem.java
+++ b/core/java/android/app/servertransaction/ActivityLifecycleItem.java
@@ -17,6 +17,8 @@
 package android.app.servertransaction;
 
 import android.annotation.IntDef;
+import android.annotation.NonNull;
+import android.os.Parcel;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -50,12 +52,13 @@ public abstract class ActivityLifecycleItem extends ActivityTransactionItem {
     public static final int ON_DESTROY = 6;
     public static final int ON_RESTART = 7;
 
+    ActivityLifecycleItem() {}
+
+    ActivityLifecycleItem(@NonNull Parcel in) {
+        super(in);
+    }
+
     /** A final lifecycle state that an activity should reach. */
     @LifecycleState
     public abstract int getTargetState();
-
-    /** Called by subclasses to make sure base implementation is cleaned up */
-    @Override
-    public void recycle() {
-    }
 }
diff --git a/core/java/android/app/servertransaction/ActivityRelaunchItem.java b/core/java/android/app/servertransaction/ActivityRelaunchItem.java
index a8b058ac3583..491d0260f6fb 100644
--- a/core/java/android/app/servertransaction/ActivityRelaunchItem.java
+++ b/core/java/android/app/servertransaction/ActivityRelaunchItem.java
@@ -56,18 +56,18 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
     private ActivityClientRecord mActivityClientRecord;
 
     @Override
-    public void preExecute(ClientTransactionHandler client, IBinder token) {
+    public void preExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token) {
         // The local config is already scaled so only apply if this item is from server side.
         if (!client.isExecutingLocalTransaction()) {
             CompatibilityInfo.applyOverrideScaleIfNeeded(mConfig);
         }
-        mActivityClientRecord = client.prepareRelaunchActivity(token, mPendingResults,
+        mActivityClientRecord = client.prepareRelaunchActivity(getActivityToken(), mPendingResults,
                 mPendingNewIntents, mConfigChanges, mConfig, mPreserveWindow);
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         if (mActivityClientRecord == null) {
             if (DEBUG_ORDER) Slog.d(TAG, "Activity relaunch cancelled");
             return;
@@ -78,9 +78,9 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
     }
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
-        final ActivityClientRecord r = getActivityClientRecord(client, token);
+    public void postExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
+        final ActivityClientRecord r = getActivityClientRecord(client);
         client.reportRelaunch(r);
     }
 
@@ -89,13 +89,16 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
     private ActivityRelaunchItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static ActivityRelaunchItem obtain(List<ResultInfo> pendingResults,
-            List<ReferrerIntent> pendingNewIntents, int configChanges, MergedConfiguration config,
-            boolean preserveWindow) {
+    @NonNull
+    public static ActivityRelaunchItem obtain(@NonNull IBinder activityToken,
+            @Nullable List<ResultInfo> pendingResults,
+            @Nullable List<ReferrerIntent> pendingNewIntents, int configChanges,
+            @NonNull MergedConfiguration config, boolean preserveWindow) {
         ActivityRelaunchItem instance = ObjectPool.obtain(ActivityRelaunchItem.class);
         if (instance == null) {
             instance = new ActivityRelaunchItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mPendingResults = pendingResults;
         instance.mPendingNewIntents = pendingNewIntents;
         instance.mConfigChanges = configChanges;
@@ -107,6 +110,7 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mPendingResults = null;
         mPendingNewIntents = null;
         mConfigChanges = 0;
@@ -121,7 +125,8 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeTypedList(mPendingResults, flags);
         dest.writeTypedList(mPendingNewIntents, flags);
         dest.writeInt(mConfigChanges);
@@ -130,7 +135,8 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
     }
 
     /** Read from Parcel. */
-    private ActivityRelaunchItem(Parcel in) {
+    private ActivityRelaunchItem(@NonNull Parcel in) {
+        super(in);
         mPendingResults = in.createTypedArrayList(ResultInfo.CREATOR);
         mPendingNewIntents = in.createTypedArrayList(ReferrerIntent.CREATOR);
         mConfigChanges = in.readInt();
@@ -139,22 +145,22 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
     }
 
     public static final @NonNull Creator<ActivityRelaunchItem> CREATOR =
-            new Creator<ActivityRelaunchItem>() {
-        public ActivityRelaunchItem createFromParcel(Parcel in) {
-            return new ActivityRelaunchItem(in);
-        }
+            new Creator<>() {
+                public ActivityRelaunchItem createFromParcel(@NonNull Parcel in) {
+                    return new ActivityRelaunchItem(in);
+                }
 
-        public ActivityRelaunchItem[] newArray(int size) {
-            return new ActivityRelaunchItem[size];
-        }
-    };
+                public ActivityRelaunchItem[] newArray(int size) {
+                    return new ActivityRelaunchItem[size];
+                }
+            };
 
     @Override
     public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final ActivityRelaunchItem other = (ActivityRelaunchItem) o;
@@ -167,6 +173,7 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + Objects.hashCode(mPendingResults);
         result = 31 * result + Objects.hashCode(mPendingNewIntents);
         result = 31 * result + mConfigChanges;
@@ -177,8 +184,11 @@ public class ActivityRelaunchItem extends ActivityTransactionItem {
 
     @Override
     public String toString() {
-        return "ActivityRelaunchItem{pendingResults=" + mPendingResults
-                + ",pendingNewIntents=" + mPendingNewIntents + ",configChanges="  + mConfigChanges
-                + ",config=" + mConfig + ",preserveWindow" + mPreserveWindow + "}";
+        return "ActivityRelaunchItem{" + super.toString()
+                + ",pendingResults=" + mPendingResults
+                + ",pendingNewIntents=" + mPendingNewIntents
+                + ",configChanges="  + mConfigChanges
+                + ",config=" + mConfig
+                + ",preserveWindow" + mPreserveWindow + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/ActivityResultItem.java b/core/java/android/app/servertransaction/ActivityResultItem.java
index 27d104b59284..24fced4981d6 100644
--- a/core/java/android/app/servertransaction/ActivityResultItem.java
+++ b/core/java/android/app/servertransaction/ActivityResultItem.java
@@ -30,6 +30,7 @@ import android.compat.annotation.ChangeId;
 import android.compat.annotation.EnabledAfter;
 import android.compat.annotation.UnsupportedAppUsage;
 import android.os.Build;
+import android.os.IBinder;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.os.Trace;
@@ -61,24 +62,26 @@ public class ActivityResultItem extends ActivityTransactionItem {
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
         client.handleSendResult(r, mResultInfoList, "ACTIVITY_RESULT");
         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
     }
 
-
     // ObjectPoolItem implementation
 
     private ActivityResultItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static ActivityResultItem obtain(List<ResultInfo> resultInfoList) {
+    @NonNull
+    public static ActivityResultItem obtain(@NonNull IBinder activityToken,
+            @NonNull List<ResultInfo> resultInfoList) {
         ActivityResultItem instance = ObjectPool.obtain(ActivityResultItem.class);
         if (instance == null) {
             instance = new ActivityResultItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mResultInfoList = resultInfoList;
 
         return instance;
@@ -86,41 +89,43 @@ public class ActivityResultItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mResultInfoList = null;
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeTypedList(mResultInfoList, flags);
     }
 
     /** Read from Parcel. */
-    private ActivityResultItem(Parcel in) {
+    private ActivityResultItem(@NonNull Parcel in) {
+        super(in);
         mResultInfoList = in.createTypedArrayList(ResultInfo.CREATOR);
     }
 
     public static final @NonNull Parcelable.Creator<ActivityResultItem> CREATOR =
-            new Parcelable.Creator<ActivityResultItem>() {
-        public ActivityResultItem createFromParcel(Parcel in) {
-            return new ActivityResultItem(in);
-        }
+            new Parcelable.Creator<>() {
+                public ActivityResultItem createFromParcel(@NonNull Parcel in) {
+                    return new ActivityResultItem(in);
+                }
 
-        public ActivityResultItem[] newArray(int size) {
-            return new ActivityResultItem[size];
-        }
-    };
+                public ActivityResultItem[] newArray(int size) {
+                    return new ActivityResultItem[size];
+                }
+            };
 
     @Override
     public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final ActivityResultItem other = (ActivityResultItem) o;
@@ -129,11 +134,15 @@ public class ActivityResultItem extends ActivityTransactionItem {
 
     @Override
     public int hashCode() {
-        return mResultInfoList.hashCode();
+        int result = 17;
+        result = 31 * result + super.hashCode();
+        result = 31 * result + Objects.hashCode(mResultInfoList);
+        return result;
     }
 
     @Override
     public String toString() {
-        return "ActivityResultItem{resultInfoList=" + mResultInfoList + "}";
+        return "ActivityResultItem{" + super.toString()
+                + ",resultInfoList=" + mResultInfoList + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/ActivityTransactionItem.java b/core/java/android/app/servertransaction/ActivityTransactionItem.java
index 469a9bfe59ef..0f8879e1429b 100644
--- a/core/java/android/app/servertransaction/ActivityTransactionItem.java
+++ b/core/java/android/app/servertransaction/ActivityTransactionItem.java
@@ -18,13 +18,18 @@ package android.app.servertransaction;
 
 import static com.android.internal.annotations.VisibleForTesting.Visibility.PACKAGE;
 
+import android.annotation.CallSuper;
 import android.annotation.NonNull;
+import android.annotation.Nullable;
 import android.app.ActivityThread.ActivityClientRecord;
 import android.app.ClientTransactionHandler;
 import android.os.IBinder;
+import android.os.Parcel;
 
 import com.android.internal.annotations.VisibleForTesting;
 
+import java.util.Objects;
+
 /**
  * An activity-targeting callback message to a client that can be scheduled and executed.
  * It also provides nullity-free version of
@@ -37,11 +42,16 @@ import com.android.internal.annotations.VisibleForTesting;
  * @hide
  */
 public abstract class ActivityTransactionItem extends ClientTransactionItem {
-    @Override
-    public final void execute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
-        final ActivityClientRecord r = getActivityClientRecord(client, token);
 
+    /** Target client activity. */
+    private IBinder mActivityToken;
+
+    ActivityTransactionItem() {}
+
+    @Override
+    public final void execute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
+        final ActivityClientRecord r = getActivityClientRecord(client);
         execute(client, r, pendingActions);
     }
 
@@ -51,25 +61,80 @@ public abstract class ActivityTransactionItem extends ClientTransactionItem {
      */
     @VisibleForTesting(visibility = PACKAGE)
     public abstract void execute(@NonNull ClientTransactionHandler client,
-            @NonNull ActivityClientRecord r, PendingTransactionActions pendingActions);
+            @NonNull ActivityClientRecord r, @NonNull PendingTransactionActions pendingActions);
 
     /**
-     * Gets the {@link ActivityClientRecord} instance that corresponds to the provided token.
+     * Gets the {@link ActivityClientRecord} instance that this transaction item is for.
      * @param client Target client handler.
-     * @param token Target activity token.
-     * @return The {@link ActivityClientRecord} instance that corresponds to the provided token.
+     * @return The {@link ActivityClientRecord} instance that this transaction item is for.
      */
-    @NonNull ActivityClientRecord getActivityClientRecord(
-            @NonNull ClientTransactionHandler client, IBinder token) {
-        final ActivityClientRecord r = client.getActivityClient(token);
+    @NonNull
+    final ActivityClientRecord getActivityClientRecord(@NonNull ClientTransactionHandler client) {
+        final ActivityClientRecord r = client.getActivityClient(getActivityToken());
         if (r == null) {
             throw new IllegalArgumentException("Activity client record must not be null to execute "
                     + "transaction item: " + this);
         }
-        if (client.getActivity(token) == null) {
+        if (client.getActivity(getActivityToken()) == null) {
             throw new IllegalArgumentException("Activity must not be null to execute "
                     + "transaction item: " + this);
         }
         return r;
     }
+
+    @VisibleForTesting(visibility = PACKAGE)
+    @NonNull
+    @Override
+    public IBinder getActivityToken() {
+        return mActivityToken;
+    }
+
+    void setActivityToken(@NonNull IBinder activityToken) {
+        mActivityToken = activityToken;
+    }
+
+    // To be overridden
+
+    ActivityTransactionItem(@NonNull Parcel in) {
+        mActivityToken = in.readStrongBinder();
+    }
+
+    @CallSuper
+    @Override
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        dest.writeStrongBinder(mActivityToken);
+    }
+
+    @CallSuper
+    @Override
+    public void recycle() {
+        mActivityToken = null;
+    }
+
+    // Subclass must override and call super.equals to compare the mActivityToken.
+    @SuppressWarnings("EqualsGetClass")
+    @CallSuper
+    @Override
+    public boolean equals(@Nullable Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        final ActivityTransactionItem other = (ActivityTransactionItem) o;
+        return Objects.equals(mActivityToken, other.mActivityToken);
+    }
+
+    @CallSuper
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(mActivityToken);
+    }
+
+    @CallSuper
+    @Override
+    public String toString() {
+        return "mActivityToken=" + mActivityToken;
+    }
 }
diff --git a/core/java/android/app/servertransaction/ClientTransactionItem.java b/core/java/android/app/servertransaction/ClientTransactionItem.java
index fe75d89e1257..30fc104a71b7 100644
--- a/core/java/android/app/servertransaction/ClientTransactionItem.java
+++ b/core/java/android/app/servertransaction/ClientTransactionItem.java
@@ -19,6 +19,8 @@ package android.app.servertransaction;
 import static android.app.servertransaction.ActivityLifecycleItem.LifecycleState;
 import static android.app.servertransaction.ActivityLifecycleItem.UNDEFINED;
 
+import static com.android.internal.annotations.VisibleForTesting.Visibility.PACKAGE;
+
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.ClientTransactionHandler;
@@ -26,13 +28,15 @@ import android.content.Context;
 import android.os.IBinder;
 import android.os.Parcelable;
 
+import com.android.internal.annotations.VisibleForTesting;
+
 /**
  * A callback message to a client that can be scheduled and executed.
  * Examples of these might be activity configuration change, multi-window mode change, activity
  * result delivery etc.
  *
  * @see ClientTransaction
- * @see com.android.server.am.ClientLifecycleManager
+ * @see com.android.server.wm.ClientLifecycleManager
  * @hide
  */
 public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {
@@ -57,6 +61,16 @@ public abstract class ClientTransactionItem implements BaseClientRequest, Parcel
         return null;
     }
 
+    /**
+     * Returns the activity token if this transaction item is activity-targeting. Otherwise,
+     * returns {@code null}.
+     */
+    @VisibleForTesting(visibility = PACKAGE)
+    @Nullable
+    public IBinder getActivityToken() {
+        return null;
+    }
+
     // Parcelable
 
     @Override
diff --git a/core/java/android/app/servertransaction/DestroyActivityItem.java b/core/java/android/app/servertransaction/DestroyActivityItem.java
index a074286a4ecd..a327a99435ce 100644
--- a/core/java/android/app/servertransaction/DestroyActivityItem.java
+++ b/core/java/android/app/servertransaction/DestroyActivityItem.java
@@ -36,13 +36,13 @@ public class DestroyActivityItem extends ActivityLifecycleItem {
     private int mConfigChanges;
 
     @Override
-    public void preExecute(ClientTransactionHandler client, IBinder token) {
-        client.getActivitiesToBeDestroyed().put(token, this);
+    public void preExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token) {
+        client.getActivitiesToBeDestroyed().put(getActivityToken(), this);
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
         client.handleDestroyActivity(r, mFinished, mConfigChanges,
                 false /* getNonConfigInstance */, "DestroyActivityItem");
@@ -54,17 +54,19 @@ public class DestroyActivityItem extends ActivityLifecycleItem {
         return ON_DESTROY;
     }
 
-
     // ObjectPoolItem implementation
 
     private DestroyActivityItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static DestroyActivityItem obtain(boolean finished, int configChanges) {
+    @NonNull
+    public static DestroyActivityItem obtain(@NonNull IBinder activityToken, boolean finished,
+            int configChanges) {
         DestroyActivityItem instance = ObjectPool.obtain(DestroyActivityItem.class);
         if (instance == null) {
             instance = new DestroyActivityItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mFinished = finished;
         instance.mConfigChanges = configChanges;
 
@@ -79,25 +81,25 @@ public class DestroyActivityItem extends ActivityLifecycleItem {
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeBoolean(mFinished);
         dest.writeInt(mConfigChanges);
     }
 
     /** Read from Parcel. */
-    private DestroyActivityItem(Parcel in) {
+    private DestroyActivityItem(@NonNull Parcel in) {
+        super(in);
         mFinished = in.readBoolean();
         mConfigChanges = in.readInt();
     }
 
-    public static final @NonNull Creator<DestroyActivityItem> CREATOR =
-            new Creator<DestroyActivityItem>() {
-        public DestroyActivityItem createFromParcel(Parcel in) {
+    public static final @NonNull Creator<DestroyActivityItem> CREATOR = new Creator<>() {
+        public DestroyActivityItem createFromParcel(@NonNull Parcel in) {
             return new DestroyActivityItem(in);
         }
 
@@ -111,7 +113,7 @@ public class DestroyActivityItem extends ActivityLifecycleItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final DestroyActivityItem other = (DestroyActivityItem) o;
@@ -121,6 +123,7 @@ public class DestroyActivityItem extends ActivityLifecycleItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + (mFinished ? 1 : 0);
         result = 31 * result + mConfigChanges;
         return result;
@@ -128,7 +131,8 @@ public class DestroyActivityItem extends ActivityLifecycleItem {
 
     @Override
     public String toString() {
-        return "DestroyActivityItem{finished=" + mFinished + ",mConfigChanges="
-                + mConfigChanges + "}";
+        return "DestroyActivityItem{" + super.toString()
+                + ",finished=" + mFinished
+                + ",mConfigChanges=" + mConfigChanges + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/EnterPipRequestedItem.java b/core/java/android/app/servertransaction/EnterPipRequestedItem.java
index 7dcae654e1d0..743653f4896e 100644
--- a/core/java/android/app/servertransaction/EnterPipRequestedItem.java
+++ b/core/java/android/app/servertransaction/EnterPipRequestedItem.java
@@ -16,9 +16,10 @@
 
 package android.app.servertransaction;
 
-import android.annotation.Nullable;
+import android.annotation.NonNull;
 import android.app.ActivityThread.ActivityClientRecord;
 import android.app.ClientTransactionHandler;
+import android.os.IBinder;
 import android.os.Parcel;
 
 /**
@@ -28,8 +29,8 @@ import android.os.Parcel;
 public final class EnterPipRequestedItem extends ActivityTransactionItem {
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         client.handlePictureInPictureRequested(r);
     }
 
@@ -38,28 +39,32 @@ public final class EnterPipRequestedItem extends ActivityTransactionItem {
     private EnterPipRequestedItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static EnterPipRequestedItem obtain() {
+    @NonNull
+    public static EnterPipRequestedItem obtain(@NonNull IBinder activityToken) {
         EnterPipRequestedItem instance = ObjectPool.obtain(EnterPipRequestedItem.class);
         if (instance == null) {
             instance = new EnterPipRequestedItem();
         }
+        instance.setActivityToken(activityToken);
         return instance;
     }
 
     @Override
     public void recycle() {
+        super.recycle();
         ObjectPool.recycle(this);
     }
 
     // Parcelable implementation
 
-    @Override
-    public void writeToParcel(Parcel dest, int flags) { }
+    private EnterPipRequestedItem(@NonNull Parcel in) {
+        super(in);
+    }
 
-    public static final @android.annotation.NonNull Creator<EnterPipRequestedItem> CREATOR =
-            new Creator<EnterPipRequestedItem>() {
-                public EnterPipRequestedItem createFromParcel(Parcel in) {
-                    return new EnterPipRequestedItem();
+    public static final @NonNull Creator<EnterPipRequestedItem> CREATOR =
+            new Creator<>() {
+                public EnterPipRequestedItem createFromParcel(@NonNull Parcel in) {
+                    return new EnterPipRequestedItem(in);
                 }
 
                 public EnterPipRequestedItem[] newArray(int size) {
@@ -68,12 +73,7 @@ public final class EnterPipRequestedItem extends ActivityTransactionItem {
             };
 
     @Override
-    public boolean equals(@Nullable Object o) {
-        return this == o;
-    }
-
-    @Override
     public String toString() {
-        return "EnterPipRequestedItem{}";
+        return "EnterPipRequestedItem{" + super.toString() + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/LaunchActivityItem.java b/core/java/android/app/servertransaction/LaunchActivityItem.java
index 5833f1b87254..9b37a35cdb8f 100644
--- a/core/java/android/app/servertransaction/LaunchActivityItem.java
+++ b/core/java/android/app/servertransaction/LaunchActivityItem.java
@@ -18,6 +18,8 @@ package android.app.servertransaction;
 
 import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
 
+import static com.android.internal.annotations.VisibleForTesting.Visibility.PACKAGE;
+
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.ActivityClient;
@@ -39,6 +41,7 @@ import android.os.Parcel;
 import android.os.PersistableBundle;
 import android.os.Trace;
 
+import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.app.IVoiceInteractor;
 import com.android.internal.content.ReferrerIntent;
 
@@ -51,6 +54,7 @@ import java.util.Objects;
  */
 public class LaunchActivityItem extends ClientTransactionItem {
 
+    private IBinder mActivityToken;
     @UnsupportedAppUsage
     private Intent mIntent;
     private int mIdent;
@@ -80,7 +84,7 @@ public class LaunchActivityItem extends ClientTransactionItem {
     private IActivityClientController mActivityClientController;
 
     @Override
-    public void preExecute(ClientTransactionHandler client, IBinder token) {
+    public void preExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token) {
         client.countLaunchingActivities(1);
         client.updateProcessState(mProcState, false);
         CompatibilityInfo.applyOverrideScaleIfNeeded(mCurConfig);
@@ -92,10 +96,10 @@ public class LaunchActivityItem extends ClientTransactionItem {
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
-        ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
+        ActivityClientRecord r = new ActivityClientRecord(mActivityToken, mIntent, mIdent, mInfo,
                 mOverrideConfig, mReferrer, mVoiceInteractor, mState, mPersistentState,
                 mPendingResults, mPendingNewIntents, mActivityOptions, mIsForward, mProfilerInfo,
                 client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble,
@@ -105,31 +109,34 @@ public class LaunchActivityItem extends ClientTransactionItem {
     }
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
+    public void postExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
         client.countLaunchingActivities(-1);
     }
 
-
     // ObjectPoolItem implementation
 
     private LaunchActivityItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static LaunchActivityItem obtain(Intent intent, int ident, ActivityInfo info,
-            Configuration curConfig, Configuration overrideConfig, int deviceId,
-            String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,
-            PersistableBundle persistentState, List<ResultInfo> pendingResults,
-            List<ReferrerIntent> pendingNewIntents, ActivityOptions activityOptions,
-            boolean isForward, ProfilerInfo profilerInfo, IBinder assistToken,
-            IActivityClientController activityClientController, IBinder shareableActivityToken,
-            boolean launchedFromBubble, IBinder taskFragmentToken) {
+    @NonNull
+    public static LaunchActivityItem obtain(@NonNull IBinder activityToken, @NonNull Intent intent,
+            int ident, @NonNull ActivityInfo info, @NonNull Configuration curConfig,
+            @NonNull Configuration overrideConfig, int deviceId, @Nullable String referrer,
+            @Nullable IVoiceInteractor voiceInteractor, int procState, @Nullable Bundle state,
+            @Nullable PersistableBundle persistentState, @Nullable List<ResultInfo> pendingResults,
+            @Nullable List<ReferrerIntent> pendingNewIntents,
+            @Nullable ActivityOptions activityOptions,
+            boolean isForward, @Nullable ProfilerInfo profilerInfo, @NonNull IBinder assistToken,
+            @Nullable IActivityClientController activityClientController,
+            @NonNull IBinder shareableActivityToken, boolean launchedFromBubble,
+            @Nullable IBinder taskFragmentToken) {
         LaunchActivityItem instance = ObjectPool.obtain(LaunchActivityItem.class);
         if (instance == null) {
             instance = new LaunchActivityItem();
         }
-        setValues(instance, intent, ident, info, curConfig, overrideConfig, deviceId, referrer,
-                voiceInteractor, procState, state, persistentState, pendingResults,
+        setValues(instance, activityToken, intent, ident, info, curConfig, overrideConfig, deviceId,
+                referrer, voiceInteractor, procState, state, persistentState, pendingResults,
                 pendingNewIntents, activityOptions, isForward, profilerInfo, assistToken,
                 activityClientController, shareableActivityToken,
                 launchedFromBubble, taskFragmentToken);
@@ -137,19 +144,26 @@ public class LaunchActivityItem extends ClientTransactionItem {
         return instance;
     }
 
+    @VisibleForTesting(visibility = PACKAGE)
+    @NonNull
+    @Override
+    public IBinder getActivityToken() {
+        return mActivityToken;
+    }
+
     @Override
     public void recycle() {
-        setValues(this, null, 0, null, null, null, 0, null, null, 0, null, null, null, null,
+        setValues(this, null, null, 0, null, null, null, 0, null, null, 0, null, null, null, null,
                 null, false, null, null, null, null, false, null);
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write from Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        dest.writeStrongBinder(mActivityToken);
         dest.writeTypedObject(mIntent, flags);
         dest.writeInt(mIdent);
         dest.writeTypedObject(mInfo, flags);
@@ -174,8 +188,8 @@ public class LaunchActivityItem extends ClientTransactionItem {
     }
 
     /** Read from Parcel. */
-    private LaunchActivityItem(Parcel in) {
-        setValues(this, in.readTypedObject(Intent.CREATOR), in.readInt(),
+    private LaunchActivityItem(@NonNull Parcel in) {
+        setValues(this, in.readStrongBinder(), in.readTypedObject(Intent.CREATOR), in.readInt(),
                 in.readTypedObject(ActivityInfo.CREATOR), in.readTypedObject(Configuration.CREATOR),
                 in.readTypedObject(Configuration.CREATOR), in.readInt(), in.readString(),
                 IVoiceInteractor.Stub.asInterface(in.readStrongBinder()), in.readInt(),
@@ -192,9 +206,8 @@ public class LaunchActivityItem extends ClientTransactionItem {
                 in.readStrongBinder());
     }
 
-    public static final @NonNull Creator<LaunchActivityItem> CREATOR =
-            new Creator<LaunchActivityItem>() {
-        public LaunchActivityItem createFromParcel(Parcel in) {
+    public static final @NonNull Creator<LaunchActivityItem> CREATOR = new Creator<>() {
+        public LaunchActivityItem createFromParcel(@NonNull Parcel in) {
             return new LaunchActivityItem(in);
         }
 
@@ -214,7 +227,8 @@ public class LaunchActivityItem extends ClientTransactionItem {
         final LaunchActivityItem other = (LaunchActivityItem) o;
         final boolean intentsEqual = (mIntent == null && other.mIntent == null)
                 || (mIntent != null && mIntent.filterEquals(other.mIntent));
-        return intentsEqual && mIdent == other.mIdent
+        return intentsEqual
+                && Objects.equals(mActivityToken, other.mActivityToken) && mIdent == other.mIdent
                 && activityInfoEqual(other.mInfo) && Objects.equals(mCurConfig, other.mCurConfig)
                 && Objects.equals(mOverrideConfig, other.mOverrideConfig)
                 && mDeviceId == other.mDeviceId
@@ -234,6 +248,7 @@ public class LaunchActivityItem extends ClientTransactionItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + Objects.hashCode(mActivityToken);
         result = 31 * result + mIntent.filterHashCode();
         result = 31 * result + mIdent;
         result = 31 * result + Objects.hashCode(mCurConfig);
@@ -254,7 +269,7 @@ public class LaunchActivityItem extends ClientTransactionItem {
         return result;
     }
 
-    private boolean activityInfoEqual(ActivityInfo other) {
+    private boolean activityInfoEqual(@Nullable ActivityInfo other) {
         if (mInfo == null) {
             return other == null;
         }
@@ -270,36 +285,51 @@ public class LaunchActivityItem extends ClientTransactionItem {
      * unparceling if a customized class loader is not set to the bundle. So the hash code is
      * simply determined by the bundle is empty or not.
      */
-    private static int getRoughBundleHashCode(BaseBundle bundle) {
+    private static int getRoughBundleHashCode(@Nullable BaseBundle bundle) {
         return (bundle == null || bundle.isDefinitelyEmpty()) ? 0 : 1;
     }
 
     /** Compares the bundles without unparceling them (avoid BadParcelableException). */
-    private static boolean areBundlesEqualRoughly(BaseBundle a, BaseBundle b) {
+    private static boolean areBundlesEqualRoughly(@Nullable BaseBundle a, @Nullable BaseBundle b) {
         return getRoughBundleHashCode(a) == getRoughBundleHashCode(b);
     }
 
     @Override
     public String toString() {
-        return "LaunchActivityItem{intent=" + mIntent + ",ident=" + mIdent + ",info=" + mInfo
-                + ",curConfig=" + mCurConfig + ",overrideConfig=" + mOverrideConfig
-                + ",deviceId=" + mDeviceId + ",referrer=" + mReferrer + ",procState=" + mProcState
-                + ",state=" + mState + ",persistentState=" + mPersistentState
-                + ",pendingResults=" + mPendingResults + ",pendingNewIntents=" + mPendingNewIntents
-                + ",options=" + mActivityOptions + ",profilerInfo=" + mProfilerInfo
-                + ",assistToken=" + mAssistToken + ",shareableActivityToken="
-                + mShareableActivityToken + "}";
+        return "LaunchActivityItem{activityToken=" + mActivityToken
+                + ",intent=" + mIntent
+                + ",ident=" + mIdent
+                + ",info=" + mInfo
+                + ",curConfig=" + mCurConfig
+                + ",overrideConfig=" + mOverrideConfig
+                + ",deviceId=" + mDeviceId
+                + ",referrer=" + mReferrer
+                + ",procState=" + mProcState
+                + ",state=" + mState
+                + ",persistentState=" + mPersistentState
+                + ",pendingResults=" + mPendingResults
+                + ",pendingNewIntents=" + mPendingNewIntents
+                + ",options=" + mActivityOptions
+                + ",profilerInfo=" + mProfilerInfo
+                + ",assistToken=" + mAssistToken
+                + ",shareableActivityToken=" + mShareableActivityToken + "}";
     }
 
     // Using the same method to set and clear values to make sure we don't forget anything
-    private static void setValues(LaunchActivityItem instance, Intent intent, int ident,
-            ActivityInfo info, Configuration curConfig, Configuration overrideConfig, int deviceId,
-            String referrer, IVoiceInteractor voiceInteractor,
-            int procState, Bundle state, PersistableBundle persistentState,
-            List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
-            ActivityOptions activityOptions, boolean isForward, ProfilerInfo profilerInfo,
-            IBinder assistToken, IActivityClientController activityClientController,
-            IBinder shareableActivityToken, boolean launchedFromBubble, IBinder taskFragmentToken) {
+    private static void setValues(@Nullable LaunchActivityItem instance,
+            @Nullable IBinder activityToken, @Nullable Intent intent, int ident,
+            @Nullable ActivityInfo info, @Nullable Configuration curConfig,
+            @Nullable Configuration overrideConfig, int deviceId,
+            @Nullable String referrer, @Nullable IVoiceInteractor voiceInteractor,
+            int procState, @Nullable Bundle state, @Nullable PersistableBundle persistentState,
+            @Nullable List<ResultInfo> pendingResults,
+            @Nullable List<ReferrerIntent> pendingNewIntents,
+            @Nullable ActivityOptions activityOptions, boolean isForward,
+            @Nullable ProfilerInfo profilerInfo, @Nullable IBinder assistToken,
+            @Nullable IActivityClientController activityClientController,
+            @Nullable IBinder shareableActivityToken, boolean launchedFromBubble,
+            @Nullable IBinder taskFragmentToken) {
+        instance.mActivityToken = activityToken;
         instance.mIntent = intent;
         instance.mIdent = ident;
         instance.mInfo = info;
diff --git a/core/java/android/app/servertransaction/MoveToDisplayItem.java b/core/java/android/app/servertransaction/MoveToDisplayItem.java
index f13bd748f486..fb57bed94160 100644
--- a/core/java/android/app/servertransaction/MoveToDisplayItem.java
+++ b/core/java/android/app/servertransaction/MoveToDisplayItem.java
@@ -40,37 +40,34 @@ public class MoveToDisplayItem extends ActivityTransactionItem {
     private Configuration mConfiguration;
 
     @Override
-    public void preExecute(ClientTransactionHandler client, IBinder token) {
+    public void preExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token) {
         CompatibilityInfo.applyOverrideScaleIfNeeded(mConfiguration);
         // Notify the client of an upcoming change in the token configuration. This ensures that
         // batches of config change items only process the newest configuration.
-        client.updatePendingActivityConfiguration(token, mConfiguration);
+        client.updatePendingActivityConfiguration(getActivityToken(), mConfiguration);
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityMovedToDisplay");
         client.handleActivityConfigurationChanged(r, mConfiguration, mTargetDisplayId);
         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
     }
 
-
     // ObjectPoolItem implementation
 
     private MoveToDisplayItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static MoveToDisplayItem obtain(int targetDisplayId,
+    @NonNull
+    public static MoveToDisplayItem obtain(@NonNull IBinder activityToken, int targetDisplayId,
             @NonNull Configuration configuration) {
-        if (configuration == null) {
-            throw new IllegalArgumentException("Configuration must not be null");
-        }
-
         MoveToDisplayItem instance = ObjectPool.obtain(MoveToDisplayItem.class);
         if (instance == null) {
             instance = new MoveToDisplayItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mTargetDisplayId = targetDisplayId;
         instance.mConfiguration = configuration;
 
@@ -79,30 +76,31 @@ public class MoveToDisplayItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mTargetDisplayId = 0;
         mConfiguration = Configuration.EMPTY;
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeInt(mTargetDisplayId);
         dest.writeTypedObject(mConfiguration, flags);
     }
 
     /** Read from Parcel. */
-    private MoveToDisplayItem(Parcel in) {
+    private MoveToDisplayItem(@NonNull Parcel in) {
+        super(in);
         mTargetDisplayId = in.readInt();
         mConfiguration = in.readTypedObject(Configuration.CREATOR);
     }
 
-    public static final @NonNull Creator<MoveToDisplayItem> CREATOR =
-            new Creator<MoveToDisplayItem>() {
-        public MoveToDisplayItem createFromParcel(Parcel in) {
+    public static final @NonNull Creator<MoveToDisplayItem> CREATOR = new Creator<>() {
+        public MoveToDisplayItem createFromParcel(@NonNull Parcel in) {
             return new MoveToDisplayItem(in);
         }
 
@@ -116,7 +114,7 @@ public class MoveToDisplayItem extends ActivityTransactionItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final MoveToDisplayItem other = (MoveToDisplayItem) o;
@@ -127,6 +125,7 @@ public class MoveToDisplayItem extends ActivityTransactionItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + mTargetDisplayId;
         result = 31 * result + mConfiguration.hashCode();
         return result;
@@ -134,7 +133,8 @@ public class MoveToDisplayItem extends ActivityTransactionItem {
 
     @Override
     public String toString() {
-        return "MoveToDisplayItem{targetDisplayId=" + mTargetDisplayId
+        return "MoveToDisplayItem{" + super.toString()
+                + ",targetDisplayId=" + mTargetDisplayId
                 + ",configuration=" + mConfiguration + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/NewIntentItem.java b/core/java/android/app/servertransaction/NewIntentItem.java
index 723fa012c902..8e995aa05a48 100644
--- a/core/java/android/app/servertransaction/NewIntentItem.java
+++ b/core/java/android/app/servertransaction/NewIntentItem.java
@@ -25,6 +25,7 @@ import android.app.ActivityThread.ActivityClientRecord;
 import android.app.ClientTransactionHandler;
 import android.compat.annotation.UnsupportedAppUsage;
 import android.os.Build;
+import android.os.IBinder;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.os.Trace;
@@ -50,24 +51,26 @@ public class NewIntentItem extends ActivityTransactionItem {
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");
         client.handleNewIntent(r, mIntents);
         Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
     }
 
-
     // ObjectPoolItem implementation
 
     private NewIntentItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static NewIntentItem obtain(List<ReferrerIntent> intents, boolean resume) {
+    @NonNull
+    public static NewIntentItem obtain(@NonNull IBinder activityToken,
+            @NonNull List<ReferrerIntent> intents, boolean resume) {
         NewIntentItem instance = ObjectPool.obtain(NewIntentItem.class);
         if (instance == null) {
             instance = new NewIntentItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mIntents = intents;
         instance.mResume = resume;
 
@@ -76,44 +79,46 @@ public class NewIntentItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mIntents = null;
         mResume = false;
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeBoolean(mResume);
         dest.writeTypedList(mIntents, flags);
     }
 
     /** Read from Parcel. */
-    private NewIntentItem(Parcel in) {
+    private NewIntentItem(@NonNull Parcel in) {
+        super(in);
         mResume = in.readBoolean();
         mIntents = in.createTypedArrayList(ReferrerIntent.CREATOR);
     }
 
     public static final @NonNull Parcelable.Creator<NewIntentItem> CREATOR =
-            new Parcelable.Creator<NewIntentItem>() {
-        public NewIntentItem createFromParcel(Parcel in) {
-            return new NewIntentItem(in);
-        }
+            new Parcelable.Creator<>() {
+                public NewIntentItem createFromParcel(@NonNull Parcel in) {
+                    return new NewIntentItem(in);
+                }
 
-        public NewIntentItem[] newArray(int size) {
-            return new NewIntentItem[size];
-        }
-    };
+                public NewIntentItem[] newArray(int size) {
+                    return new NewIntentItem[size];
+                }
+            };
 
     @Override
     public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final NewIntentItem other = (NewIntentItem) o;
@@ -123,6 +128,7 @@ public class NewIntentItem extends ActivityTransactionItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + (mResume ? 1 : 0);
         result = 31 * result + mIntents.hashCode();
         return result;
@@ -130,6 +136,8 @@ public class NewIntentItem extends ActivityTransactionItem {
 
     @Override
     public String toString() {
-        return "NewIntentItem{intents=" + mIntents + ",resume=" + mResume + "}";
+        return "NewIntentItem{" + super.toString()
+                + ",intents=" + mIntents
+                + ",resume=" + mResume + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/PauseActivityItem.java b/core/java/android/app/servertransaction/PauseActivityItem.java
index 965e761ebfb3..a8e6772b4e32 100644
--- a/core/java/android/app/servertransaction/PauseActivityItem.java
+++ b/core/java/android/app/servertransaction/PauseActivityItem.java
@@ -42,8 +42,8 @@ public class PauseActivityItem extends ActivityLifecycleItem {
     private boolean mAutoEnteringPip;
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
         client.handlePauseActivity(r, mFinished, mUserLeaving, mConfigChanges, mAutoEnteringPip,
                 pendingActions, "PAUSE_ACTIVITY_ITEM");
@@ -56,27 +56,28 @@ public class PauseActivityItem extends ActivityLifecycleItem {
     }
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
+    public void postExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
         if (mDontReport) {
             return;
         }
         // TODO(lifecycler): Use interface callback instead of actual implementation.
-        ActivityClient.getInstance().activityPaused(token);
+        ActivityClient.getInstance().activityPaused(getActivityToken());
     }
 
-
     // ObjectPoolItem implementation
 
     private PauseActivityItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static PauseActivityItem obtain(boolean finished, boolean userLeaving, int configChanges,
-            boolean dontReport, boolean autoEnteringPip) {
+    @NonNull
+    public static PauseActivityItem obtain(@NonNull IBinder activityToken, boolean finished,
+            boolean userLeaving, int configChanges, boolean dontReport, boolean autoEnteringPip) {
         PauseActivityItem instance = ObjectPool.obtain(PauseActivityItem.class);
         if (instance == null) {
             instance = new PauseActivityItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mFinished = finished;
         instance.mUserLeaving = userLeaving;
         instance.mConfigChanges = configChanges;
@@ -87,18 +88,10 @@ public class PauseActivityItem extends ActivityLifecycleItem {
     }
 
     /** Obtain an instance initialized with default params. */
-    public static PauseActivityItem obtain() {
-        PauseActivityItem instance = ObjectPool.obtain(PauseActivityItem.class);
-        if (instance == null) {
-            instance = new PauseActivityItem();
-        }
-        instance.mFinished = false;
-        instance.mUserLeaving = false;
-        instance.mConfigChanges = 0;
-        instance.mDontReport = true;
-        instance.mAutoEnteringPip = false;
-
-        return instance;
+    @NonNull
+    public static PauseActivityItem obtain(@NonNull IBinder activityToken) {
+        return obtain(activityToken, false /* finished */, false /* userLeaving */,
+                0 /* configChanges */, true /* dontReport */, false /* autoEnteringPip*/);
     }
 
     @Override
@@ -116,7 +109,8 @@ public class PauseActivityItem extends ActivityLifecycleItem {
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeBoolean(mFinished);
         dest.writeBoolean(mUserLeaving);
         dest.writeInt(mConfigChanges);
@@ -125,7 +119,8 @@ public class PauseActivityItem extends ActivityLifecycleItem {
     }
 
     /** Read from Parcel. */
-    private PauseActivityItem(Parcel in) {
+    private PauseActivityItem(@NonNull Parcel in) {
+        super(in);
         mFinished = in.readBoolean();
         mUserLeaving = in.readBoolean();
         mConfigChanges = in.readInt();
@@ -133,9 +128,8 @@ public class PauseActivityItem extends ActivityLifecycleItem {
         mAutoEnteringPip = in.readBoolean();
     }
 
-    public static final @NonNull Creator<PauseActivityItem> CREATOR =
-            new Creator<PauseActivityItem>() {
-        public PauseActivityItem createFromParcel(Parcel in) {
+    public static final @NonNull Creator<PauseActivityItem> CREATOR = new Creator<>() {
+        public PauseActivityItem createFromParcel(@NonNull Parcel in) {
             return new PauseActivityItem(in);
         }
 
@@ -149,7 +143,7 @@ public class PauseActivityItem extends ActivityLifecycleItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final PauseActivityItem other = (PauseActivityItem) o;
@@ -161,6 +155,7 @@ public class PauseActivityItem extends ActivityLifecycleItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + (mFinished ? 1 : 0);
         result = 31 * result + (mUserLeaving ? 1 : 0);
         result = 31 * result + mConfigChanges;
@@ -171,8 +166,11 @@ public class PauseActivityItem extends ActivityLifecycleItem {
 
     @Override
     public String toString() {
-        return "PauseActivityItem{finished=" + mFinished + ",userLeaving=" + mUserLeaving
-                + ",configChanges=" + mConfigChanges + ",dontReport=" + mDontReport
+        return "PauseActivityItem{" + super.toString()
+                + ",finished=" + mFinished
+                + ",userLeaving=" + mUserLeaving
+                + ",configChanges=" + mConfigChanges
+                + ",dontReport=" + mDontReport
                 + ",autoEnteringPip=" + mAutoEnteringPip + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/PipStateTransactionItem.java b/core/java/android/app/servertransaction/PipStateTransactionItem.java
index 167f5a43b1b1..30289ef9f794 100644
--- a/core/java/android/app/servertransaction/PipStateTransactionItem.java
+++ b/core/java/android/app/servertransaction/PipStateTransactionItem.java
@@ -16,12 +16,16 @@
 
 package android.app.servertransaction;
 
+import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.ActivityThread.ActivityClientRecord;
 import android.app.ClientTransactionHandler;
 import android.app.PictureInPictureUiState;
+import android.os.IBinder;
 import android.os.Parcel;
 
+import java.util.Objects;
+
 /**
  * Request an activity to enter picture-in-picture mode.
  * @hide
@@ -31,8 +35,8 @@ public final class PipStateTransactionItem extends ActivityTransactionItem {
     private PictureInPictureUiState mPipState;
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         client.handlePictureInPictureStateChanged(r, mPipState);
     }
 
@@ -41,11 +45,14 @@ public final class PipStateTransactionItem extends ActivityTransactionItem {
     private PipStateTransactionItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static PipStateTransactionItem obtain(PictureInPictureUiState pipState) {
+    @NonNull
+    public static PipStateTransactionItem obtain(@NonNull IBinder activityToken,
+            @NonNull PictureInPictureUiState pipState) {
         PipStateTransactionItem instance = ObjectPool.obtain(PipStateTransactionItem.class);
         if (instance == null) {
             instance = new PipStateTransactionItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mPipState = pipState;
 
         return instance;
@@ -53,6 +60,7 @@ public final class PipStateTransactionItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mPipState = null;
         ObjectPool.recycle(this);
     }
@@ -61,33 +69,49 @@ public final class PipStateTransactionItem extends ActivityTransactionItem {
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         mPipState.writeToParcel(dest, flags);
     }
 
     /** Read from Parcel. */
-    private PipStateTransactionItem(Parcel in) {
+    private PipStateTransactionItem(@NonNull Parcel in) {
+        super(in);
         mPipState = PictureInPictureUiState.CREATOR.createFromParcel(in);
     }
 
-    public static final @android.annotation.NonNull Creator<PipStateTransactionItem> CREATOR =
-            new Creator<PipStateTransactionItem>() {
-                public PipStateTransactionItem createFromParcel(Parcel in) {
-                    return new PipStateTransactionItem(in);
-                }
+    public static final @NonNull Creator<PipStateTransactionItem> CREATOR = new Creator<>() {
+        public PipStateTransactionItem createFromParcel(@NonNull Parcel in) {
+            return new PipStateTransactionItem(in);
+        }
 
-                public PipStateTransactionItem[] newArray(int size) {
-                    return new PipStateTransactionItem[size];
-                }
-            };
+        public PipStateTransactionItem[] newArray(int size) {
+            return new PipStateTransactionItem[size];
+        }
+    };
 
     @Override
     public boolean equals(@Nullable Object o) {
-        return this == o;
+        if (this == o) {
+            return true;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+        final PipStateTransactionItem other = (PipStateTransactionItem) o;
+        return Objects.equals(mPipState, other.mPipState);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = 31 * result + super.hashCode();
+        result = 31 * result + Objects.hashCode(mPipState);
+        return result;
     }
 
     @Override
     public String toString() {
-        return "PipStateTransactionItem{}";
+        return "PipStateTransactionItem{" + super.toString() + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/RefreshCallbackItem.java b/core/java/android/app/servertransaction/RefreshCallbackItem.java
index 74abab22b0a6..00128f0d298f 100644
--- a/core/java/android/app/servertransaction/RefreshCallbackItem.java
+++ b/core/java/android/app/servertransaction/RefreshCallbackItem.java
@@ -48,12 +48,12 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
 
     @Override
     public void execute(@NonNull ClientTransactionHandler client,
-            @NonNull ActivityClientRecord r, PendingTransactionActions pendingActions) {}
+            @NonNull ActivityClientRecord r, @NonNull PendingTransactionActions pendingActions) {}
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
-        final ActivityClientRecord r = getActivityClientRecord(client, token);
+    public void postExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
+        final ActivityClientRecord r = getActivityClientRecord(client);
         client.reportRefresh(r);
     }
 
@@ -71,6 +71,7 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         ObjectPool.recycle(this);
     }
 
@@ -79,7 +80,9 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
     * @param postExecutionState indicating whether refresh should happen using the
     *        "stopped -> resumed" cycle or "paused -> resumed" cycle.
     */
-    public static RefreshCallbackItem obtain(@LifecycleState int postExecutionState) {
+    @NonNull
+    public static RefreshCallbackItem obtain(@NonNull IBinder activityToken,
+            @LifecycleState int postExecutionState) {
         if (postExecutionState != ON_STOP && postExecutionState != ON_PAUSE) {
             throw new IllegalArgumentException(
                     "Only ON_STOP or ON_PAUSE are allowed as a post execution state for "
@@ -90,6 +93,7 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
         if (instance == null) {
             instance = new RefreshCallbackItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mPostExecutionState = postExecutionState;
         return instance;
     }
@@ -99,7 +103,8 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
     // Parcelable implementation
 
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeInt(mPostExecutionState);
     }
 
@@ -108,7 +113,7 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final RefreshCallbackItem other = (RefreshCallbackItem) o;
@@ -118,23 +123,25 @@ public class RefreshCallbackItem extends ActivityTransactionItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + mPostExecutionState;
         return result;
     }
 
     @Override
     public String toString() {
-        return "RefreshCallbackItem{mPostExecutionState=" + mPostExecutionState + "}";
+        return "RefreshCallbackItem{" + super.toString()
+                + ",mPostExecutionState=" + mPostExecutionState + "}";
     }
 
-    private RefreshCallbackItem(Parcel in) {
+    private RefreshCallbackItem(@NonNull Parcel in) {
+        super(in);
         mPostExecutionState = in.readInt();
     }
 
-    public static final @NonNull Creator<RefreshCallbackItem> CREATOR =
-            new Creator<RefreshCallbackItem>() {
+    public static final @NonNull Creator<RefreshCallbackItem> CREATOR = new Creator<>() {
 
-        public RefreshCallbackItem createFromParcel(Parcel in) {
+        public RefreshCallbackItem createFromParcel(@NonNull Parcel in) {
             return new RefreshCallbackItem(in);
         }
 
diff --git a/core/java/android/app/servertransaction/ResumeActivityItem.java b/core/java/android/app/servertransaction/ResumeActivityItem.java
index 222f8ca61e09..b11e73cbef96 100644
--- a/core/java/android/app/servertransaction/ResumeActivityItem.java
+++ b/core/java/android/app/servertransaction/ResumeActivityItem.java
@@ -44,15 +44,15 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
     private boolean mShouldSendCompatFakeFocus;
 
     @Override
-    public void preExecute(ClientTransactionHandler client, IBinder token) {
+    public void preExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token) {
         if (mUpdateProcState) {
             client.updateProcessState(mProcState, false);
         }
     }
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
         client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
                 mShouldSendCompatFakeFocus, "RESUME_ACTIVITY");
@@ -60,10 +60,11 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
     }
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
+    public void postExecute(@NonNull ClientTransactionHandler client, IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
         // TODO(lifecycler): Use interface callback instead of actual implementation.
-        ActivityClient.getInstance().activityResumed(token, client.isHandleSplashScreenExit(token));
+        ActivityClient.getInstance().activityResumed(getActivityToken(),
+                client.isHandleSplashScreenExit(getActivityToken()));
     }
 
     @Override
@@ -71,18 +72,19 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
         return ON_RESUME;
     }
 
-
     // ObjectPoolItem implementation
 
     private ResumeActivityItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static ResumeActivityItem obtain(int procState, boolean isForward,
-            boolean shouldSendCompatFakeFocus) {
+    @NonNull
+    public static ResumeActivityItem obtain(@NonNull IBinder activityToken, int procState,
+            boolean isForward, boolean shouldSendCompatFakeFocus) {
         ResumeActivityItem instance = ObjectPool.obtain(ResumeActivityItem.class);
         if (instance == null) {
             instance = new ResumeActivityItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mProcState = procState;
         instance.mUpdateProcState = true;
         instance.mIsForward = isForward;
@@ -92,11 +94,14 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
     }
 
     /** Obtain an instance initialized with provided params. */
-    public static ResumeActivityItem obtain(boolean isForward, boolean shouldSendCompatFakeFocus) {
+    @NonNull
+    public static ResumeActivityItem obtain(@NonNull IBinder activityToken, boolean isForward,
+            boolean shouldSendCompatFakeFocus) {
         ResumeActivityItem instance = ObjectPool.obtain(ResumeActivityItem.class);
         if (instance == null) {
             instance = new ResumeActivityItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mProcState = ActivityManager.PROCESS_STATE_UNKNOWN;
         instance.mUpdateProcState = false;
         instance.mIsForward = isForward;
@@ -115,12 +120,12 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeInt(mProcState);
         dest.writeBoolean(mUpdateProcState);
         dest.writeBoolean(mIsForward);
@@ -128,15 +133,15 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
     }
 
     /** Read from Parcel. */
-    private ResumeActivityItem(Parcel in) {
+    private ResumeActivityItem(@NonNull Parcel in) {
+        super(in);
         mProcState = in.readInt();
         mUpdateProcState = in.readBoolean();
         mIsForward = in.readBoolean();
         mShouldSendCompatFakeFocus = in.readBoolean();
     }
 
-    public static final @NonNull Creator<ResumeActivityItem> CREATOR =
-            new Creator<ResumeActivityItem>() {
+    public static final @NonNull Creator<ResumeActivityItem> CREATOR = new Creator<>() {
         public ResumeActivityItem createFromParcel(Parcel in) {
             return new ResumeActivityItem(in);
         }
@@ -151,7 +156,7 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final ResumeActivityItem other = (ResumeActivityItem) o;
@@ -163,6 +168,7 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + mProcState;
         result = 31 * result + (mUpdateProcState ? 1 : 0);
         result = 31 * result + (mIsForward ? 1 : 0);
@@ -172,8 +178,10 @@ public class ResumeActivityItem extends ActivityLifecycleItem {
 
     @Override
     public String toString() {
-        return "ResumeActivityItem{procState=" + mProcState
-                + ",updateProcState=" + mUpdateProcState + ",isForward=" + mIsForward
+        return "ResumeActivityItem{" + super.toString()
+                + ",procState=" + mProcState
+                + ",updateProcState=" + mUpdateProcState
+                + ",isForward=" + mIsForward
                 + ",shouldSendCompatFakeFocus=" + mShouldSendCompatFakeFocus + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/StartActivityItem.java b/core/java/android/app/servertransaction/StartActivityItem.java
index 15f65f6d9d26..8b98b2184043 100644
--- a/core/java/android/app/servertransaction/StartActivityItem.java
+++ b/core/java/android/app/servertransaction/StartActivityItem.java
@@ -23,6 +23,7 @@ import android.annotation.Nullable;
 import android.app.ActivityOptions;
 import android.app.ActivityThread.ActivityClientRecord;
 import android.app.ClientTransactionHandler;
+import android.os.IBinder;
 import android.os.Parcel;
 import android.os.Trace;
 
@@ -37,8 +38,8 @@ public class StartActivityItem extends ActivityLifecycleItem {
     private ActivityOptions mActivityOptions;
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "startActivityItem");
         client.handleStartActivity(r, pendingActions, mActivityOptions);
         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
@@ -49,17 +50,19 @@ public class StartActivityItem extends ActivityLifecycleItem {
         return ON_START;
     }
 
-
     // ObjectPoolItem implementation
 
     private StartActivityItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static StartActivityItem obtain(ActivityOptions activityOptions) {
+    @NonNull
+    public static StartActivityItem obtain(@NonNull IBinder activityToken,
+            @Nullable ActivityOptions activityOptions) {
         StartActivityItem instance = ObjectPool.obtain(StartActivityItem.class);
         if (instance == null) {
             instance = new StartActivityItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mActivityOptions = activityOptions;
 
         return instance;
@@ -72,37 +75,37 @@ public class StartActivityItem extends ActivityLifecycleItem {
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeBundle(mActivityOptions != null ? mActivityOptions.toBundle() : null);
     }
 
     /** Read from Parcel. */
-    private StartActivityItem(Parcel in) {
+    private StartActivityItem(@NonNull Parcel in) {
+        super(in);
         mActivityOptions = ActivityOptions.fromBundle(in.readBundle());
     }
 
-    public static final @NonNull Creator<StartActivityItem> CREATOR =
-            new Creator<StartActivityItem>() {
-                public StartActivityItem createFromParcel(Parcel in) {
-                    return new StartActivityItem(in);
-                }
+    public static final @NonNull Creator<StartActivityItem> CREATOR = new Creator<>() {
+        public StartActivityItem createFromParcel(@NonNull Parcel in) {
+            return new StartActivityItem(in);
+        }
 
-                public StartActivityItem[] newArray(int size) {
-                    return new StartActivityItem[size];
-                }
-            };
+        public StartActivityItem[] newArray(int size) {
+            return new StartActivityItem[size];
+        }
+    };
 
     @Override
     public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final StartActivityItem other = (StartActivityItem) o;
@@ -112,13 +115,15 @@ public class StartActivityItem extends ActivityLifecycleItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + (mActivityOptions != null ? 1 : 0);
         return result;
     }
 
     @Override
     public String toString() {
-        return "StartActivityItem{options=" + mActivityOptions + "}";
+        return "StartActivityItem{" + super.toString()
+                + ",options=" + mActivityOptions + "}";
     }
 }
 
diff --git a/core/java/android/app/servertransaction/StopActivityItem.java b/core/java/android/app/servertransaction/StopActivityItem.java
index 7e9116dfdfc7..f4325670c4fc 100644
--- a/core/java/android/app/servertransaction/StopActivityItem.java
+++ b/core/java/android/app/servertransaction/StopActivityItem.java
@@ -37,8 +37,8 @@ public class StopActivityItem extends ActivityLifecycleItem {
     private int mConfigChanges;
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
         client.handleStopActivity(r, mConfigChanges, pendingActions,
                 true /* finalStateRequest */, "STOP_ACTIVITY_ITEM");
@@ -46,8 +46,8 @@ public class StopActivityItem extends ActivityLifecycleItem {
     }
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
+    public void postExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
         client.reportStop(pendingActions);
     }
 
@@ -56,20 +56,22 @@ public class StopActivityItem extends ActivityLifecycleItem {
         return ON_STOP;
     }
 
-
     // ObjectPoolItem implementation
 
     private StopActivityItem() {}
 
     /**
      * Obtain an instance initialized with provided params.
+     * @param activityToken the activity that stops.
      * @param configChanges Configuration pieces that changed.
      */
-    public static StopActivityItem obtain(int configChanges) {
+    @NonNull
+    public static StopActivityItem obtain(@NonNull IBinder activityToken, int configChanges) {
         StopActivityItem instance = ObjectPool.obtain(StopActivityItem.class);
         if (instance == null) {
             instance = new StopActivityItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mConfigChanges = configChanges;
 
         return instance;
@@ -82,23 +84,23 @@ public class StopActivityItem extends ActivityLifecycleItem {
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeInt(mConfigChanges);
     }
 
     /** Read from Parcel. */
-    private StopActivityItem(Parcel in) {
+    private StopActivityItem(@NonNull Parcel in) {
+        super(in);
         mConfigChanges = in.readInt();
     }
 
-    public static final @NonNull Creator<StopActivityItem> CREATOR =
-            new Creator<StopActivityItem>() {
-        public StopActivityItem createFromParcel(Parcel in) {
+    public static final @NonNull Creator<StopActivityItem> CREATOR = new Creator<>() {
+        public StopActivityItem createFromParcel(@NonNull Parcel in) {
             return new StopActivityItem(in);
         }
 
@@ -112,7 +114,7 @@ public class StopActivityItem extends ActivityLifecycleItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final StopActivityItem other = (StopActivityItem) o;
@@ -122,12 +124,14 @@ public class StopActivityItem extends ActivityLifecycleItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + mConfigChanges;
         return result;
     }
 
     @Override
     public String toString() {
-        return "StopActivityItem{configChanges=" + mConfigChanges + "}";
+        return "StopActivityItem{" + super.toString()
+                + ",configChanges=" + mConfigChanges + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/TopResumedActivityChangeItem.java b/core/java/android/app/servertransaction/TopResumedActivityChangeItem.java
index 5cd3d68f0326..693599fa229c 100644
--- a/core/java/android/app/servertransaction/TopResumedActivityChangeItem.java
+++ b/core/java/android/app/servertransaction/TopResumedActivityChangeItem.java
@@ -35,16 +35,16 @@ public class TopResumedActivityChangeItem extends ActivityTransactionItem {
     private boolean mOnTop;
 
     @Override
-    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+    public void execute(@NonNull ClientTransactionHandler client, @NonNull ActivityClientRecord r,
+            @NonNull PendingTransactionActions pendingActions) {
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "topResumedActivityChangeItem");
         client.handleTopResumedActivityChanged(r, mOnTop, "topResumedActivityChangeItem");
         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
     }
 
     @Override
-    public void postExecute(ClientTransactionHandler client, IBinder token,
-            PendingTransactionActions pendingActions) {
+    public void postExecute(@NonNull ClientTransactionHandler client, @NonNull IBinder token,
+            @NonNull PendingTransactionActions pendingActions) {
         if (mOnTop) {
             return;
         }
@@ -58,18 +58,20 @@ public class TopResumedActivityChangeItem extends ActivityTransactionItem {
         ActivityClient.getInstance().activityTopResumedStateLost();
     }
 
-
     // ObjectPoolItem implementation
 
     private TopResumedActivityChangeItem() {}
 
     /** Obtain an instance initialized with provided params. */
-    public static TopResumedActivityChangeItem obtain(boolean onTop) {
+    @NonNull
+    public static TopResumedActivityChangeItem obtain(@NonNull IBinder activityToken,
+            boolean onTop) {
         TopResumedActivityChangeItem instance =
                 ObjectPool.obtain(TopResumedActivityChangeItem.class);
         if (instance == null) {
             instance = new TopResumedActivityChangeItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mOnTop = onTop;
 
         return instance;
@@ -77,27 +79,28 @@ public class TopResumedActivityChangeItem extends ActivityTransactionItem {
 
     @Override
     public void recycle() {
+        super.recycle();
         mOnTop = false;
         ObjectPool.recycle(this);
     }
 
-
     // Parcelable implementation
 
     /** Write to Parcel. */
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeBoolean(mOnTop);
     }
 
     /** Read from Parcel. */
-    private TopResumedActivityChangeItem(Parcel in) {
+    private TopResumedActivityChangeItem(@NonNull Parcel in) {
+        super(in);
         mOnTop = in.readBoolean();
     }
 
-    public static final @NonNull Creator<TopResumedActivityChangeItem> CREATOR =
-            new Creator<TopResumedActivityChangeItem>() {
-        public TopResumedActivityChangeItem createFromParcel(Parcel in) {
+    public static final @NonNull Creator<TopResumedActivityChangeItem> CREATOR = new Creator<>() {
+        public TopResumedActivityChangeItem createFromParcel(@NonNull Parcel in) {
             return new TopResumedActivityChangeItem(in);
         }
 
@@ -111,7 +114,7 @@ public class TopResumedActivityChangeItem extends ActivityTransactionItem {
         if (this == o) {
             return true;
         }
-        if (o == null || getClass() != o.getClass()) {
+        if (!super.equals(o)) {
             return false;
         }
         final TopResumedActivityChangeItem other = (TopResumedActivityChangeItem) o;
@@ -121,12 +124,14 @@ public class TopResumedActivityChangeItem extends ActivityTransactionItem {
     @Override
     public int hashCode() {
         int result = 17;
+        result = 31 * result + super.hashCode();
         result = 31 * result + (mOnTop ? 1 : 0);
         return result;
     }
 
     @Override
     public String toString() {
-        return "TopResumedActivityChangeItem{onTop=" + mOnTop + "}";
+        return "TopResumedActivityChangeItem{" + super.toString()
+                + ",onTop=" + mOnTop + "}";
     }
 }
diff --git a/core/java/android/app/servertransaction/TransactionExecutorHelper.java b/core/java/android/app/servertransaction/TransactionExecutorHelper.java
index baf2a4722dff..0f9c517e2916 100644
--- a/core/java/android/app/servertransaction/TransactionExecutorHelper.java
+++ b/core/java/android/app/servertransaction/TransactionExecutorHelper.java
@@ -196,13 +196,13 @@ public class TransactionExecutorHelper {
                 // Fall through to return the PAUSE item to ensure the activity is properly
                 // resumed while relaunching.
             case ON_PAUSE:
-                lifecycleItem = PauseActivityItem.obtain();
+                lifecycleItem = PauseActivityItem.obtain(r.token);
                 break;
             case ON_STOP:
-                lifecycleItem = StopActivityItem.obtain(0 /* configChanges */);
+                lifecycleItem = StopActivityItem.obtain(r.token, 0 /* configChanges */);
                 break;
             default:
-                lifecycleItem = ResumeActivityItem.obtain(false /* isForward */,
+                lifecycleItem = ResumeActivityItem.obtain(r.token, false /* isForward */,
                         false /* shouldSendCompatFakeFocus */);
                 break;
         }
diff --git a/core/java/android/app/servertransaction/TransferSplashScreenViewStateItem.java b/core/java/android/app/servertransaction/TransferSplashScreenViewStateItem.java
index 767fd28b8a2a..11947e9b11d8 100644
--- a/core/java/android/app/servertransaction/TransferSplashScreenViewStateItem.java
+++ b/core/java/android/app/servertransaction/TransferSplashScreenViewStateItem.java
@@ -20,10 +20,13 @@ import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.ActivityThread;
 import android.app.ClientTransactionHandler;
+import android.os.IBinder;
 import android.os.Parcel;
 import android.view.SurfaceControl;
 import android.window.SplashScreenView.SplashScreenViewParcelable;
 
+import java.util.Objects;
+
 /**
  * Transfer a splash screen view to an Activity.
  * @hide
@@ -36,36 +39,44 @@ public class TransferSplashScreenViewStateItem extends ActivityTransactionItem {
     @Override
     public void execute(@NonNull ClientTransactionHandler client,
             @NonNull ActivityThread.ActivityClientRecord r,
-            PendingTransactionActions pendingActions) {
+            @NonNull PendingTransactionActions pendingActions) {
         client.handleAttachSplashScreenView(r, mSplashScreenViewParcelable, mStartingWindowLeash);
     }
 
     @Override
     public void recycle() {
+        super.recycle();
+        mSplashScreenViewParcelable = null;
+        mStartingWindowLeash = null;
         ObjectPool.recycle(this);
     }
 
     @Override
-    public void writeToParcel(Parcel dest, int flags) {
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
         dest.writeTypedObject(mSplashScreenViewParcelable, flags);
         dest.writeTypedObject(mStartingWindowLeash, flags);
     }
 
     private TransferSplashScreenViewStateItem() {}
-    private TransferSplashScreenViewStateItem(Parcel in) {
+
+    private TransferSplashScreenViewStateItem(@NonNull Parcel in) {
+        super(in);
         mSplashScreenViewParcelable = in.readTypedObject(SplashScreenViewParcelable.CREATOR);
         mStartingWindowLeash = in.readTypedObject(SurfaceControl.CREATOR);
     }
 
     /** Obtain an instance initialized with provided params. */
+    @NonNull
     public static TransferSplashScreenViewStateItem obtain(
-            @Nullable SplashScreenViewParcelable parcelable,
+            @NonNull IBinder activityToken, @Nullable SplashScreenViewParcelable parcelable,
             @Nullable SurfaceControl startingWindowLeash) {
         TransferSplashScreenViewStateItem instance =
                 ObjectPool.obtain(TransferSplashScreenViewStateItem.class);
         if (instance == null) {
             instance = new TransferSplashScreenViewStateItem();
         }
+        instance.setActivityToken(activityToken);
         instance.mSplashScreenViewParcelable = parcelable;
         instance.mStartingWindowLeash = startingWindowLeash;
 
@@ -73,8 +84,8 @@ public class TransferSplashScreenViewStateItem extends ActivityTransactionItem {
     }
 
     public static final @NonNull Creator<TransferSplashScreenViewStateItem> CREATOR =
-            new Creator<TransferSplashScreenViewStateItem>() {
-                public TransferSplashScreenViewStateItem createFromParcel(Parcel in) {
+            new Creator<>() {
+                public TransferSplashScreenViewStateItem createFromParcel(@NonNull Parcel in) {
                     return new TransferSplashScreenViewStateItem(in);
                 }
 
@@ -82,4 +93,33 @@ public class TransferSplashScreenViewStateItem extends ActivityTransactionItem {
                     return new TransferSplashScreenViewStateItem[size];
                 }
             };
+
+    @Override
+    public boolean equals(@Nullable Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+        final TransferSplashScreenViewStateItem other = (TransferSplashScreenViewStateItem) o;
+        return Objects.equals(mSplashScreenViewParcelable, other.mSplashScreenViewParcelable)
+                && Objects.equals(mStartingWindowLeash, other.mStartingWindowLeash);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = 31 * result + super.hashCode();
+        result = 31 * result + Objects.hashCode(mSplashScreenViewParcelable);
+        result = 31 * result + Objects.hashCode(mStartingWindowLeash);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "TransferSplashScreenViewStateItem{" + super.toString()
+                + ",splashScreenViewParcelable=" + mSplashScreenViewParcelable
+                + ",startingWindowLeash=" + mStartingWindowLeash + "}";
+    }
 }
diff --git a/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java b/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java
index 0778311e98bd..cd1ca7e9c3ad 100644
--- a/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java
+++ b/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java
@@ -245,7 +245,7 @@ public class ActivityThreadTest {
             newConfig.smallestScreenWidthDp++;
             transaction = newTransaction(activityThread, activity.getActivityToken());
             transaction.addCallback(ActivityConfigurationChangeItem.obtain(
-                    new Configuration(newConfig)));
+                    activity.getActivityToken(), new Configuration(newConfig)));
             appThread.scheduleTransaction(transaction);
             InstrumentationRegistry.getInstrumentation().waitForIdleSync();
 
@@ -450,10 +450,12 @@ public class ActivityThreadTest {
         appThread.scheduleTransaction(transaction);
 
         transaction = newTransaction(activityThread, activity.getActivityToken());
-        transaction.addCallback(ActivityConfigurationChangeItem.obtain(activityConfigLandscape));
+        transaction.addCallback(ActivityConfigurationChangeItem.obtain(
+                activity.getActivityToken(), activityConfigLandscape));
         transaction.addCallback(ConfigurationChangeItem.obtain(
                 processConfigPortrait, DEVICE_ID_INVALID));
-        transaction.addCallback(ActivityConfigurationChangeItem.obtain(activityConfigPortrait));
+        transaction.addCallback(ActivityConfigurationChangeItem.obtain(
+                activity.getActivityToken(), activityConfigPortrait));
         appThread.scheduleTransaction(transaction);
 
         activity.mTestLatch.await(TIMEOUT_SEC, TimeUnit.SECONDS);
@@ -829,11 +831,12 @@ public class ActivityThreadTest {
 
     private static ClientTransaction newRelaunchResumeTransaction(Activity activity) {
         final Configuration currentConfig = activity.getResources().getConfiguration();
-        final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(null,
-                null, 0, new MergedConfiguration(currentConfig, currentConfig),
+        final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(
+                activity.getActivityToken(), null, null, 0,
+                new MergedConfiguration(currentConfig, currentConfig),
                 false /* preserveWindow */);
         final ResumeActivityItem resumeStateRequest =
-                ResumeActivityItem.obtain(true /* isForward */,
+                ResumeActivityItem.obtain(activity.getActivityToken(), true /* isForward */,
                         false /* shouldSendCompatFakeFocus*/);
 
         final ClientTransaction transaction = newTransaction(activity);
@@ -845,7 +848,7 @@ public class ActivityThreadTest {
 
     private static ClientTransaction newResumeTransaction(Activity activity) {
         final ResumeActivityItem resumeStateRequest =
-                ResumeActivityItem.obtain(true /* isForward */,
+                ResumeActivityItem.obtain(activity.getActivityToken(), true /* isForward */,
                         false /* shouldSendCompatFakeFocus */);
 
         final ClientTransaction transaction = newTransaction(activity);
@@ -855,7 +858,8 @@ public class ActivityThreadTest {
     }
 
     private static ClientTransaction newStopTransaction(Activity activity) {
-        final StopActivityItem stopStateRequest = StopActivityItem.obtain(0 /* configChanges */);
+        final StopActivityItem stopStateRequest = StopActivityItem.obtain(
+                activity.getActivityToken(), 0 /* configChanges */);
 
         final ClientTransaction transaction = newTransaction(activity);
         transaction.setLifecycleStateRequest(stopStateRequest);
@@ -865,7 +869,8 @@ public class ActivityThreadTest {
 
     private static ClientTransaction newActivityConfigTransaction(Activity activity,
             Configuration config) {
-        final ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem.obtain(config);
+        final ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem.obtain(
+                activity.getActivityToken(), config);
 
         final ClientTransaction transaction = newTransaction(activity);
         transaction.addCallback(item);
@@ -875,7 +880,8 @@ public class ActivityThreadTest {
 
     private static ClientTransaction newNewIntentTransaction(Activity activity,
             List<ReferrerIntent> intents, boolean resume) {
-        final NewIntentItem item = NewIntentItem.obtain(intents, resume);
+        final NewIntentItem item = NewIntentItem.obtain(activity.getActivityToken(), intents,
+                resume);
 
         final ClientTransaction transaction = newTransaction(activity);
         transaction.addCallback(item);
diff --git a/core/tests/coretests/src/android/app/servertransaction/ActivityConfigurationChangeItemTest.java b/core/tests/coretests/src/android/app/servertransaction/ActivityConfigurationChangeItemTest.java
index 1560c0c2c195..08033cc4009c 100644
--- a/core/tests/coretests/src/android/app/servertransaction/ActivityConfigurationChangeItemTest.java
+++ b/core/tests/coretests/src/android/app/servertransaction/ActivityConfigurationChangeItemTest.java
@@ -65,7 +65,7 @@ public class ActivityConfigurationChangeItemTest {
         doReturn(mActivity).when(mHandler).getActivity(mToken);
 
         final ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem
-                .obtain(mConfiguration);
+                .obtain(mToken, mConfiguration);
         final Context context = item.getContextToUpdate(mHandler, mToken);
 
         assertEquals(mActivity, context);
diff --git a/core/tests/coretests/src/android/app/servertransaction/ObjectPoolTests.java b/core/tests/coretests/src/android/app/servertransaction/ObjectPoolTests.java
index ca6735bc6c32..c8d8f4be9e0a 100644
--- a/core/tests/coretests/src/android/app/servertransaction/ObjectPoolTests.java
+++ b/core/tests/coretests/src/android/app/servertransaction/ObjectPoolTests.java
@@ -22,7 +22,6 @@ import static android.app.servertransaction.TestUtils.referrerIntentList;
 import static android.app.servertransaction.TestUtils.resultInfoList;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
@@ -61,39 +60,44 @@ import java.util.function.Supplier;
 @Presubmit
 public class ObjectPoolTests {
 
+    private final IBinder mActivityToken = new Binder();
+
     // 1. Check if two obtained objects from pool are not the same.
     // 2. Check if the state of the object is cleared after recycling.
     // 3. Check if the same object is obtained from pool after recycling.
 
     @Test
     public void testRecycleActivityConfigurationChangeItem() {
-        ActivityConfigurationChangeItem emptyItem =
-                ActivityConfigurationChangeItem.obtain(Configuration.EMPTY);
-        ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem.obtain(config());
+        ActivityConfigurationChangeItem emptyItem = ActivityConfigurationChangeItem.obtain(
+                null /* activityToken */, Configuration.EMPTY);
+        ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem.obtain(
+                mActivityToken, config());
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        ActivityConfigurationChangeItem item2 = ActivityConfigurationChangeItem.obtain(config());
+        ActivityConfigurationChangeItem item2 = ActivityConfigurationChangeItem.obtain(
+                mActivityToken, config());
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleActivityResultItem() {
-        ActivityResultItem emptyItem = ActivityResultItem.obtain(null);
-        ActivityResultItem item = ActivityResultItem.obtain(resultInfoList());
+        ActivityResultItem emptyItem = ActivityResultItem.obtain(
+                null /* activityToken */, null /* resultInfoList */);
+        ActivityResultItem item = ActivityResultItem.obtain(mActivityToken, resultInfoList());
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        ActivityResultItem item2 = ActivityResultItem.obtain(resultInfoList());
+        ActivityResultItem item2 = ActivityResultItem.obtain(mActivityToken, resultInfoList());
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
@@ -101,166 +105,188 @@ public class ObjectPoolTests {
         ConfigurationChangeItem emptyItem = ConfigurationChangeItem.obtain(null, 0);
         ConfigurationChangeItem item = ConfigurationChangeItem.obtain(config(), 1);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
         ConfigurationChangeItem item2 = ConfigurationChangeItem.obtain(config(), 1);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleDestroyActivityItem() {
-        DestroyActivityItem emptyItem = DestroyActivityItem.obtain(false, 0);
-        DestroyActivityItem item = DestroyActivityItem.obtain(true, 117);
+        DestroyActivityItem emptyItem = DestroyActivityItem.obtain(
+                null /* activityToken */, false, 0);
+        DestroyActivityItem item = DestroyActivityItem.obtain(mActivityToken, true, 117);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        DestroyActivityItem item2 = DestroyActivityItem.obtain(true, 14);
+        DestroyActivityItem item2 = DestroyActivityItem.obtain(mActivityToken, true, 14);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleLaunchActivityItem() {
-        Intent intent = new Intent("action");
+        final IBinder activityToken = new Binder();
+        final Intent intent = new Intent("action");
         int ident = 57;
-        ActivityInfo activityInfo = new ActivityInfo();
+        final ActivityInfo activityInfo = new ActivityInfo();
         activityInfo.flags = 42;
         activityInfo.setMaxAspectRatio(2.4f);
         activityInfo.launchToken = "token";
         activityInfo.applicationInfo = new ApplicationInfo();
         activityInfo.packageName = "packageName";
         activityInfo.name = "name";
-        Configuration overrideConfig = new Configuration();
+        final Configuration overrideConfig = new Configuration();
         overrideConfig.assetsSeq = 5;
-        String referrer = "referrer";
+        final String referrer = "referrer";
         int procState = 4;
-        Bundle bundle = new Bundle();
+        final Bundle bundle = new Bundle();
         bundle.putString("key", "value");
-        PersistableBundle persistableBundle = new PersistableBundle();
+        final PersistableBundle persistableBundle = new PersistableBundle();
         persistableBundle.putInt("k", 4);
-        IBinder assistToken = new Binder();
-        IBinder shareableActivityToken = new Binder();
+        final IBinder assistToken = new Binder();
+        final IBinder shareableActivityToken = new Binder();
         int deviceId = 3;
 
-        Supplier<LaunchActivityItem> itemSupplier = () -> new LaunchActivityItemBuilder()
-                .setIntent(intent).setIdent(ident).setInfo(activityInfo).setCurConfig(config())
-                .setOverrideConfig(overrideConfig).setReferrer(referrer)
-                .setProcState(procState).setState(bundle).setPersistentState(persistableBundle)
-                .setPendingResults(resultInfoList()).setPendingNewIntents(referrerIntentList())
-                .setIsForward(true).setAssistToken(assistToken)
+        final Supplier<LaunchActivityItem> itemSupplier = () -> new LaunchActivityItemBuilder()
+                .setActivityToken(activityToken)
+                .setIntent(intent)
+                .setIdent(ident)
+                .setInfo(activityInfo)
+                .setCurConfig(config())
+                .setOverrideConfig(overrideConfig)
+                .setReferrer(referrer)
+                .setProcState(procState)
+                .setState(bundle)
+                .setPersistentState(persistableBundle)
+                .setPendingResults(resultInfoList())
+                .setPendingNewIntents(referrerIntentList())
+                .setIsForward(true)
+                .setAssistToken(assistToken)
                 .setShareableActivityToken(shareableActivityToken)
-                .setTaskFragmentToken(new Binder()).setDeviceId(deviceId).build();
+                .setTaskFragmentToken(new Binder())
+                .setDeviceId(deviceId)
+                .build();
 
         LaunchActivityItem emptyItem = new LaunchActivityItemBuilder().build();
         LaunchActivityItem item = itemSupplier.get();
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
         LaunchActivityItem item2 = itemSupplier.get();
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleActivityRelaunchItem() {
-        ActivityRelaunchItem emptyItem = ActivityRelaunchItem.obtain(null, null, 0, null, false);
+        ActivityRelaunchItem emptyItem = ActivityRelaunchItem.obtain(
+                null /* activityToken */, null, null, 0, null, false);
         Configuration overrideConfig = new Configuration();
         overrideConfig.assetsSeq = 5;
-        ActivityRelaunchItem item = ActivityRelaunchItem.obtain(resultInfoList(),
+        ActivityRelaunchItem item = ActivityRelaunchItem.obtain(mActivityToken, resultInfoList(),
                 referrerIntentList(), 42, mergedConfig(), true);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        ActivityRelaunchItem item2 = ActivityRelaunchItem.obtain(resultInfoList(),
+        ActivityRelaunchItem item2 = ActivityRelaunchItem.obtain(mActivityToken, resultInfoList(),
                 referrerIntentList(), 42, mergedConfig(), true);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleMoveToDisplayItem() {
-        MoveToDisplayItem emptyItem = MoveToDisplayItem.obtain(0, Configuration.EMPTY);
-        MoveToDisplayItem item = MoveToDisplayItem.obtain(4, config());
+        MoveToDisplayItem emptyItem = MoveToDisplayItem.obtain(
+                null /* activityToken */, 0, Configuration.EMPTY);
+        MoveToDisplayItem item = MoveToDisplayItem.obtain(mActivityToken, 4, config());
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        MoveToDisplayItem item2 = MoveToDisplayItem.obtain(3, config());
+        MoveToDisplayItem item2 = MoveToDisplayItem.obtain(mActivityToken, 3, config());
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleNewIntentItem() {
-        NewIntentItem emptyItem = NewIntentItem.obtain(null, false);
-        NewIntentItem item = NewIntentItem.obtain(referrerIntentList(), false);
+        NewIntentItem emptyItem = NewIntentItem.obtain(
+                null /* activityToken */, null /* intents */, false /* resume */);
+        NewIntentItem item = NewIntentItem.obtain(mActivityToken, referrerIntentList(), false);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        NewIntentItem item2 = NewIntentItem.obtain(referrerIntentList(), false);
+        NewIntentItem item2 = NewIntentItem.obtain(mActivityToken, referrerIntentList(), false);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecyclePauseActivityItemItem() {
-        PauseActivityItem emptyItem = PauseActivityItem.obtain(false, false, 0, false, false);
-        PauseActivityItem item = PauseActivityItem.obtain(true, true, 5, true, true);
+        PauseActivityItem emptyItem = PauseActivityItem.obtain(
+                null /* activityToken */, false, false, 0, false, false);
+        PauseActivityItem item = PauseActivityItem.obtain(
+                mActivityToken, true, true, 5, true, true);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        PauseActivityItem item2 = PauseActivityItem.obtain(true, false, 5, true, true);
+        PauseActivityItem item2 = PauseActivityItem.obtain(
+                mActivityToken, true, false, 5, true, true);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleResumeActivityItem() {
-        ResumeActivityItem emptyItem = ResumeActivityItem.obtain(false, false);
-        ResumeActivityItem item = ResumeActivityItem.obtain(3, true, false);
+        ResumeActivityItem emptyItem = ResumeActivityItem.obtain(
+                null /* activityToken */, false, false);
+        ResumeActivityItem item = ResumeActivityItem.obtain(mActivityToken, 3, true, false);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        ResumeActivityItem item2 = ResumeActivityItem.obtain(2, true, false);
+        ResumeActivityItem item2 = ResumeActivityItem.obtain(mActivityToken, 2, true, false);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
     public void testRecycleStartActivityItem() {
-        StartActivityItem emptyItem = StartActivityItem.obtain(null /* activityOptions */);
-        StartActivityItem item = StartActivityItem.obtain(ActivityOptions.makeBasic());
+        StartActivityItem emptyItem = StartActivityItem.obtain(
+                null /* activityToken */, null /* activityOptions */);
+        StartActivityItem item = StartActivityItem.obtain(mActivityToken,
+                ActivityOptions.makeBasic());
         assertNotSame(item, emptyItem);
         assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        StartActivityItem item2 = StartActivityItem.obtain(
+        StartActivityItem item2 = StartActivityItem.obtain(mActivityToken,
                 ActivityOptions.makeBasic().setLaunchDisplayId(10));
         assertSame(item, item2);
         assertNotEquals(item2, emptyItem);
@@ -268,17 +294,17 @@ public class ObjectPoolTests {
 
     @Test
     public void testRecycleStopItem() {
-        StopActivityItem emptyItem = StopActivityItem.obtain(0);
-        StopActivityItem item = StopActivityItem.obtain(4);
+        StopActivityItem emptyItem = StopActivityItem.obtain(null /* activityToken */, 0);
+        StopActivityItem item = StopActivityItem.obtain(mActivityToken, 4);
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
-        StopActivityItem item2 = StopActivityItem.obtain(3);
+        StopActivityItem item2 = StopActivityItem.obtain(mActivityToken, 3);
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 
     @Test
@@ -286,13 +312,13 @@ public class ObjectPoolTests {
         ClientTransaction emptyItem = ClientTransaction.obtain(null, null);
         ClientTransaction item = ClientTransaction.obtain(null, new Binder());
         assertNotSame(item, emptyItem);
-        assertFalse(item.equals(emptyItem));
+        assertNotEquals(item, emptyItem);
 
         item.recycle();
         assertEquals(item, emptyItem);
 
         ClientTransaction item2 = ClientTransaction.obtain(null, new Binder());
         assertSame(item, item2);
-        assertFalse(item2.equals(emptyItem));
+        assertNotEquals(item2, emptyItem);
     }
 }
diff --git a/core/tests/coretests/src/android/app/servertransaction/TestUtils.java b/core/tests/coretests/src/android/app/servertransaction/TestUtils.java
index 0ed6a29cdd9d..5a88bad37d5f 100644
--- a/core/tests/coretests/src/android/app/servertransaction/TestUtils.java
+++ b/core/tests/coretests/src/android/app/servertransaction/TestUtils.java
@@ -18,6 +18,8 @@ package android.app.servertransaction;
 
 import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
 
+import android.annotation.NonNull;
+import android.annotation.Nullable;
 import android.app.ActivityOptions;
 import android.app.ProfilerInfo;
 import android.app.ResultInfo;
@@ -90,129 +92,175 @@ class TestUtils {
     }
 
     static class LaunchActivityItemBuilder {
+        @Nullable
+        private IBinder mActivityToken;
+        @Nullable
         private Intent mIntent;
         private int mIdent;
+        @Nullable
         private ActivityInfo mInfo;
+        @Nullable
         private Configuration mCurConfig;
+        @Nullable
         private Configuration mOverrideConfig;
         private int mDeviceId;
+        @Nullable
         private String mReferrer;
+        @Nullable
         private IVoiceInteractor mVoiceInteractor;
         private int mProcState;
+        @Nullable
         private Bundle mState;
+        @Nullable
         private PersistableBundle mPersistentState;
+        @Nullable
         private List<ResultInfo> mPendingResults;
+        @Nullable
         private List<ReferrerIntent> mPendingNewIntents;
+        @Nullable
         private ActivityOptions mActivityOptions;
         private boolean mIsForward;
+        @Nullable
         private ProfilerInfo mProfilerInfo;
+        @Nullable
         private IBinder mAssistToken;
+        @Nullable
         private IBinder mShareableActivityToken;
         private boolean mLaunchedFromBubble;
+        @Nullable
         private IBinder mTaskFragmentToken;
 
-        LaunchActivityItemBuilder setIntent(Intent intent) {
+        @NonNull
+        LaunchActivityItemBuilder setActivityToken(@Nullable IBinder activityToken) {
+            mActivityToken = activityToken;
+            return this;
+        }
+
+        @NonNull
+        LaunchActivityItemBuilder setIntent(@Nullable Intent intent) {
             mIntent = intent;
             return this;
         }
 
+        @NonNull
         LaunchActivityItemBuilder setIdent(int ident) {
             mIdent = ident;
             return this;
         }
 
-        LaunchActivityItemBuilder setInfo(ActivityInfo info) {
+        @NonNull
+        LaunchActivityItemBuilder setInfo(@Nullable ActivityInfo info) {
             mInfo = info;
             return this;
         }
 
-        LaunchActivityItemBuilder setCurConfig(Configuration curConfig) {
+        @NonNull
+        LaunchActivityItemBuilder setCurConfig(@Nullable Configuration curConfig) {
             mCurConfig = curConfig;
             return this;
         }
 
-        LaunchActivityItemBuilder setOverrideConfig(Configuration overrideConfig) {
+        @NonNull
+        LaunchActivityItemBuilder setOverrideConfig(@Nullable Configuration overrideConfig) {
             mOverrideConfig = overrideConfig;
             return this;
         }
 
+        @NonNull
         LaunchActivityItemBuilder setDeviceId(int deviceId) {
             mDeviceId = deviceId;
             return this;
         }
 
-        LaunchActivityItemBuilder setReferrer(String referrer) {
+        @NonNull
+        LaunchActivityItemBuilder setReferrer(@Nullable String referrer) {
             mReferrer = referrer;
             return this;
         }
 
-        LaunchActivityItemBuilder setVoiceInteractor(IVoiceInteractor voiceInteractor) {
+        @NonNull
+        LaunchActivityItemBuilder setVoiceInteractor(@Nullable IVoiceInteractor voiceInteractor) {
             mVoiceInteractor = voiceInteractor;
             return this;
         }
 
+        @NonNull
         LaunchActivityItemBuilder setProcState(int procState) {
             mProcState = procState;
             return this;
         }
 
-        LaunchActivityItemBuilder setState(Bundle state) {
+        @NonNull
+        LaunchActivityItemBuilder setState(@Nullable Bundle state) {
             mState = state;
             return this;
         }
 
-        LaunchActivityItemBuilder setPersistentState(PersistableBundle persistentState) {
+        @NonNull
+        LaunchActivityItemBuilder setPersistentState(@Nullable PersistableBundle persistentState) {
             mPersistentState = persistentState;
             return this;
         }
 
-        LaunchActivityItemBuilder setPendingResults(List<ResultInfo> pendingResults) {
+        @NonNull
+        LaunchActivityItemBuilder setPendingResults(@Nullable List<ResultInfo> pendingResults) {
             mPendingResults = pendingResults;
             return this;
         }
 
-        LaunchActivityItemBuilder setPendingNewIntents(List<ReferrerIntent> pendingNewIntents) {
+        @NonNull
+        LaunchActivityItemBuilder setPendingNewIntents(
+                @Nullable List<ReferrerIntent> pendingNewIntents) {
             mPendingNewIntents = pendingNewIntents;
             return this;
         }
 
-        LaunchActivityItemBuilder setActivityOptions(ActivityOptions activityOptions) {
+        @NonNull
+        LaunchActivityItemBuilder setActivityOptions(@Nullable ActivityOptions activityOptions) {
             mActivityOptions = activityOptions;
             return this;
         }
 
+        @NonNull
         LaunchActivityItemBuilder setIsForward(boolean isForward) {
             mIsForward = isForward;
             return this;
         }
 
-        LaunchActivityItemBuilder setProfilerInfo(ProfilerInfo profilerInfo) {
+        @NonNull
+        LaunchActivityItemBuilder setProfilerInfo(@Nullable ProfilerInfo profilerInfo) {
             mProfilerInfo = profilerInfo;
             return this;
         }
 
-        LaunchActivityItemBuilder setAssistToken(IBinder assistToken) {
+        @NonNull
+        LaunchActivityItemBuilder setAssistToken(@Nullable IBinder assistToken) {
             mAssistToken = assistToken;
             return this;
         }
 
-        LaunchActivityItemBuilder setShareableActivityToken(IBinder shareableActivityToken) {
+        @NonNull
+        LaunchActivityItemBuilder setShareableActivityToken(
+                @Nullable IBinder shareableActivityToken) {
             mShareableActivityToken = shareableActivityToken;
             return this;
         }
 
+        @NonNull
         LaunchActivityItemBuilder setLaunchedFromBubble(boolean launchedFromBubble) {
             mLaunchedFromBubble = launchedFromBubble;
             return this;
         }
 
-        LaunchActivityItemBuilder setTaskFragmentToken(IBinder taskFragmentToken) {
+        @NonNull
+        LaunchActivityItemBuilder setTaskFragmentToken(@Nullable IBinder taskFragmentToken) {
             mTaskFragmentToken = taskFragmentToken;
             return this;
         }
 
+        @NonNull
         LaunchActivityItem build() {
-            return LaunchActivityItem.obtain(mIntent, mIdent, mInfo,
+            return LaunchActivityItem.obtain(mActivityToken, mIntent, mIdent, mInfo,
                     mCurConfig, mOverrideConfig, mDeviceId, mReferrer, mVoiceInteractor,
                     mProcState, mState, mPersistentState, mPendingResults, mPendingNewIntents,
                     mActivityOptions, mIsForward, mProfilerInfo, mAssistToken,
diff --git a/core/tests/coretests/src/android/app/servertransaction/TransactionExecutorTests.java b/core/tests/coretests/src/android/app/servertransaction/TransactionExecutorTests.java
index 32f892924ac5..a998b26b09c1 100644
--- a/core/tests/coretests/src/android/app/servertransaction/TransactionExecutorTests.java
+++ b/core/tests/coretests/src/android/app/servertransaction/TransactionExecutorTests.java
@@ -227,6 +227,7 @@ public class TransactionExecutorTests {
         when(callback2.getPostExecutionState()).thenReturn(UNDEFINED);
         ActivityLifecycleItem stateRequest = mock(ActivityLifecycleItem.class);
         IBinder token = mock(IBinder.class);
+        when(stateRequest.getActivityToken()).thenReturn(token);
         when(mTransactionHandler.getActivity(token)).thenReturn(mock(Activity.class));
 
         ClientTransaction transaction = ClientTransaction.obtain(null /* client */,
@@ -256,7 +257,7 @@ public class TransactionExecutorTests {
         final ClientTransaction destroyTransaction = ClientTransaction.obtain(null /* client */,
                 token /* activityToken */);
         destroyTransaction.setLifecycleStateRequest(
-                DestroyActivityItem.obtain(false /* finished */, 0 /* configChanges */));
+                DestroyActivityItem.obtain(token, false /* finished */, 0 /* configChanges */));
         destroyTransaction.preExecute(mTransactionHandler);
         // The activity should be added to to-be-destroyed container.
         assertEquals(1, mTransactionHandler.getActivitiesToBeDestroyed().size());
@@ -264,7 +265,8 @@ public class TransactionExecutorTests {
         // A previous queued launch transaction runs on main thread (execute).
         final ClientTransaction launchTransaction = ClientTransaction.obtain(null /* client */,
                 token /* activityToken */);
-        final LaunchActivityItem launchItem = spy(new LaunchActivityItemBuilder().build());
+        final LaunchActivityItem launchItem =
+                spy(new LaunchActivityItemBuilder().setActivityToken(token).build());
         launchTransaction.addCallback(launchItem);
         mExecutor.execute(launchTransaction);
 
@@ -450,9 +452,11 @@ public class TransactionExecutorTests {
         final ClientTransaction transaction = ClientTransaction.obtain(null /* client */, token);
         final ActivityTransactionItem activityItem = mock(ActivityTransactionItem.class);
         when(activityItem.getPostExecutionState()).thenReturn(UNDEFINED);
+        when(activityItem.getActivityToken()).thenReturn(token);
         transaction.addCallback(activityItem);
         final ActivityLifecycleItem stateRequest = mock(ActivityLifecycleItem.class);
         transaction.setLifecycleStateRequest(stateRequest);
+        when(stateRequest.getActivityToken()).thenReturn(token);
         when(mTransactionHandler.getActivity(token)).thenReturn(mock(Activity.class));
 
         mExecutor.execute(transaction);
diff --git a/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java b/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java
index 48a824915015..abc5d6b35b02 100644
--- a/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java
+++ b/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java
@@ -22,7 +22,6 @@ import static android.app.servertransaction.TestUtils.referrerIntentList;
 import static android.app.servertransaction.TestUtils.resultInfoList;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 
 import android.app.ActivityOptions;
 import android.app.servertransaction.TestUtils.LaunchActivityItemBuilder;
@@ -32,6 +31,7 @@ import android.content.pm.ApplicationInfo;
 import android.content.res.Configuration;
 import android.os.Binder;
 import android.os.Bundle;
+import android.os.IBinder;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.os.PersistableBundle;
@@ -61,10 +61,12 @@ import java.util.ArrayList;
 public class TransactionParcelTests {
 
     private Parcel mParcel;
+    private IBinder mActivityToken;
 
     @Before
     public void setUp() throws Exception {
         mParcel = Parcel.obtain();
+        mActivityToken = new Binder();
     }
 
     @Test
@@ -77,13 +79,14 @@ public class TransactionParcelTests {
         ConfigurationChangeItem result = ConfigurationChangeItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testActivityConfigChange() {
         // Write to parcel
-        ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem.obtain(config());
+        ActivityConfigurationChangeItem item = ActivityConfigurationChangeItem.obtain(
+                mActivityToken, config());
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
@@ -91,51 +94,52 @@ public class TransactionParcelTests {
                 ActivityConfigurationChangeItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testMoveToDisplay() {
         // Write to parcel
-        MoveToDisplayItem item = MoveToDisplayItem.obtain(4 /* targetDisplayId */, config());
+        MoveToDisplayItem item = MoveToDisplayItem.obtain(mActivityToken, 4 /* targetDisplayId */,
+                config());
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
         MoveToDisplayItem result = MoveToDisplayItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testNewIntent() {
         // Write to parcel
-        NewIntentItem item = NewIntentItem.obtain(referrerIntentList(), false);
+        NewIntentItem item = NewIntentItem.obtain(mActivityToken, referrerIntentList(), false);
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
         NewIntentItem result = NewIntentItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testActivityResult() {
         // Write to parcel
-        ActivityResultItem item = ActivityResultItem.obtain(resultInfoList());
+        ActivityResultItem item = ActivityResultItem.obtain(mActivityToken, resultInfoList());
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
         ActivityResultItem result = ActivityResultItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testDestroy() {
-        DestroyActivityItem item = DestroyActivityItem.obtain(true /* finished */,
+        DestroyActivityItem item = DestroyActivityItem.obtain(mActivityToken, true /* finished */,
                 135 /* configChanges */);
         writeAndPrepareForReading(item);
 
@@ -143,48 +147,59 @@ public class TransactionParcelTests {
         DestroyActivityItem result = DestroyActivityItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testLaunch() {
         // Write to parcel
-        Intent intent = new Intent("action");
+        final IBinder activityToken = new Binder();
+        final Intent intent = new Intent("action");
         int ident = 57;
-        ActivityInfo activityInfo = new ActivityInfo();
+        final ActivityInfo activityInfo = new ActivityInfo();
         activityInfo.flags = 42;
         activityInfo.setMaxAspectRatio(2.4f);
         activityInfo.launchToken = "token";
         activityInfo.applicationInfo = new ApplicationInfo();
         activityInfo.packageName = "packageName";
         activityInfo.name = "name";
-        Configuration overrideConfig = new Configuration();
+        final Configuration overrideConfig = new Configuration();
         overrideConfig.assetsSeq = 5;
-        String referrer = "referrer";
+        final String referrer = "referrer";
         int procState = 4;
-        Bundle bundle = new Bundle();
+        final Bundle bundle = new Bundle();
         bundle.putString("key", "value");
         bundle.putParcelable("data", new ParcelableData(1));
-        PersistableBundle persistableBundle = new PersistableBundle();
+        final PersistableBundle persistableBundle = new PersistableBundle();
         persistableBundle.putInt("k", 4);
 
-        LaunchActivityItem item = new LaunchActivityItemBuilder()
-                .setIntent(intent).setIdent(ident).setInfo(activityInfo).setCurConfig(config())
-                .setOverrideConfig(overrideConfig).setReferrer(referrer)
-                .setProcState(procState).setState(bundle).setPersistentState(persistableBundle)
-                .setPendingResults(resultInfoList()).setActivityOptions(ActivityOptions.makeBasic())
-                .setPendingNewIntents(referrerIntentList()).setIsForward(true)
-                .setAssistToken(new Binder()).setShareableActivityToken(new Binder())
+        final LaunchActivityItem item = new LaunchActivityItemBuilder()
+                .setActivityToken(activityToken)
+                .setIntent(intent)
+                .setIdent(ident)
+                .setInfo(activityInfo)
+                .setCurConfig(config())
+                .setOverrideConfig(overrideConfig)
+                .setReferrer(referrer)
+                .setProcState(procState)
+                .setState(bundle)
+                .setPersistentState(persistableBundle)
+                .setPendingResults(resultInfoList())
+                .setActivityOptions(ActivityOptions.makeBasic())
+                .setPendingNewIntents(referrerIntentList())
+                .setIsForward(true)
+                .setAssistToken(new Binder())
+                .setShareableActivityToken(new Binder())
                 .setTaskFragmentToken(new Binder())
                 .build();
 
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
-        LaunchActivityItem result = LaunchActivityItem.CREATOR.createFromParcel(mParcel);
+        final LaunchActivityItem result = LaunchActivityItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
@@ -192,7 +207,7 @@ public class TransactionParcelTests {
         // Write to parcel
         Configuration overrideConfig = new Configuration();
         overrideConfig.assetsSeq = 5;
-        ActivityRelaunchItem item = ActivityRelaunchItem.obtain(resultInfoList(),
+        ActivityRelaunchItem item = ActivityRelaunchItem.obtain(mActivityToken, resultInfoList(),
                 referrerIntentList(), 35, mergedConfig(), true);
         writeAndPrepareForReading(item);
 
@@ -200,13 +215,13 @@ public class TransactionParcelTests {
         ActivityRelaunchItem result = ActivityRelaunchItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testPause() {
         // Write to parcel
-        PauseActivityItem item = PauseActivityItem.obtain(true /* finished */,
+        PauseActivityItem item = PauseActivityItem.obtain(mActivityToken, true /* finished */,
                 true /* userLeaving */, 135 /* configChanges */, true /* dontReport */,
                 true /* autoEnteringPip */);
         writeAndPrepareForReading(item);
@@ -215,13 +230,13 @@ public class TransactionParcelTests {
         PauseActivityItem result = PauseActivityItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testResume() {
         // Write to parcel
-        ResumeActivityItem item = ResumeActivityItem.obtain(27 /* procState */,
+        ResumeActivityItem item = ResumeActivityItem.obtain(mActivityToken, 27 /* procState */,
                 true /* isForward */, false /* shouldSendCompatFakeFocus */);
         writeAndPrepareForReading(item);
 
@@ -229,26 +244,27 @@ public class TransactionParcelTests {
         ResumeActivityItem result = ResumeActivityItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testStop() {
         // Write to parcel
-        StopActivityItem item = StopActivityItem.obtain(14 /* configChanges */);
+        StopActivityItem item = StopActivityItem.obtain(mActivityToken, 14 /* configChanges */);
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
         StopActivityItem result = StopActivityItem.CREATOR.createFromParcel(mParcel);
 
         assertEquals(item.hashCode(), result.hashCode());
-        assertTrue(item.equals(result));
+        assertEquals(item, result);
     }
 
     @Test
     public void testStart() {
         // Write to parcel
-        StartActivityItem item = StartActivityItem.obtain(ActivityOptions.makeBasic());
+        StartActivityItem item = StartActivityItem.obtain(mActivityToken,
+                ActivityOptions.makeBasic());
         writeAndPrepareForReading(item);
 
         // Read from parcel and assert
@@ -261,11 +277,12 @@ public class TransactionParcelTests {
     @Test
     public void testClientTransaction() {
         // Write to parcel
-        NewIntentItem callback1 = NewIntentItem.obtain(new ArrayList<>(), true);
+        NewIntentItem callback1 = NewIntentItem.obtain(mActivityToken, new ArrayList<>(), true);
         ActivityConfigurationChangeItem callback2 = ActivityConfigurationChangeItem.obtain(
-                config());
+                mActivityToken, config());
 
-        StopActivityItem lifecycleRequest = StopActivityItem.obtain(78 /* configChanges */);
+        StopActivityItem lifecycleRequest = StopActivityItem.obtain(mActivityToken,
+                78 /* configChanges */);
 
         Binder activityToken = new Binder();
 
@@ -280,15 +297,15 @@ public class TransactionParcelTests {
         ClientTransaction result = ClientTransaction.CREATOR.createFromParcel(mParcel);
 
         assertEquals(transaction.hashCode(), result.hashCode());
-        assertTrue(transaction.equals(result));
+        assertEquals(transaction, result);
     }
 
     @Test
     public void testClientTransactionCallbacksOnly() {
         // Write to parcel
-        NewIntentItem callback1 = NewIntentItem.obtain(new ArrayList<>(), true);
+        NewIntentItem callback1 = NewIntentItem.obtain(mActivityToken, new ArrayList<>(), true);
         ActivityConfigurationChangeItem callback2 = ActivityConfigurationChangeItem.obtain(
-                config());
+                mActivityToken, config());
 
         Binder activityToken = new Binder();
 
@@ -302,13 +319,14 @@ public class TransactionParcelTests {
         ClientTransaction result = ClientTransaction.CREATOR.createFromParcel(mParcel);
 
         assertEquals(transaction.hashCode(), result.hashCode());
-        assertTrue(transaction.equals(result));
+        assertEquals(transaction, result);
     }
 
     @Test
     public void testClientTransactionLifecycleOnly() {
         // Write to parcel
-        StopActivityItem lifecycleRequest = StopActivityItem.obtain(78 /* configChanges */);
+        StopActivityItem lifecycleRequest = StopActivityItem.obtain(mActivityToken,
+                78 /* configChanges */);
 
         Binder activityToken = new Binder();
 
@@ -321,7 +339,7 @@ public class TransactionParcelTests {
         ClientTransaction result = ClientTransaction.CREATOR.createFromParcel(mParcel);
 
         assertEquals(transaction.hashCode(), result.hashCode());
-        assertTrue(transaction.equals(result));
+        assertEquals(transaction, result);
     }
 
     /** Write to {@link #mParcel} and reset its position to prepare for reading from the start. */
diff --git a/services/core/java/com/android/server/wm/ActivityClientController.java b/services/core/java/com/android/server/wm/ActivityClientController.java
index d430dda1b463..d1a666cd4c19 100644
--- a/services/core/java/com/android/server/wm/ActivityClientController.java
+++ b/services/core/java/com/android/server/wm/ActivityClientController.java
@@ -1018,7 +1018,7 @@ class ActivityClientController extends IActivityClientController.Stub {
         try {
             final ClientTransaction transaction = ClientTransaction.obtain(
                     r.app.getThread(), r.token);
-            transaction.addCallback(EnterPipRequestedItem.obtain());
+            transaction.addCallback(EnterPipRequestedItem.obtain(r.token));
             mService.getLifecycleManager().scheduleTransaction(transaction);
             return true;
         } catch (Exception e) {
@@ -1040,7 +1040,7 @@ class ActivityClientController extends IActivityClientController.Stub {
         try {
             final ClientTransaction transaction = ClientTransaction.obtain(
                     r.app.getThread(), r.token);
-            transaction.addCallback(PipStateTransactionItem.obtain(pipState));
+            transaction.addCallback(PipStateTransactionItem.obtain(r.token, pipState));
             mService.getLifecycleManager().scheduleTransaction(transaction);
         } catch (Exception e) {
             Slog.w(TAG, "Failed to send pip state transaction item: "
diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
index 582536b662ce..ca18e0cc36aa 100644
--- a/services/core/java/com/android/server/wm/ActivityRecord.java
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -1444,7 +1444,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                     config);
 
             mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                    MoveToDisplayItem.obtain(displayId, config));
+                    MoveToDisplayItem.obtain(token, displayId, config));
         } catch (RemoteException e) {
             // If process died, whatever.
         }
@@ -1461,7 +1461,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                     + "config: %s", this, config);
 
             mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                    ActivityConfigurationChangeItem.obtain(config));
+                    ActivityConfigurationChangeItem.obtain(token, config));
         } catch (RemoteException e) {
             // If process died, whatever.
         }
@@ -1482,7 +1482,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                     this, onTop);
 
             mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                    TopResumedActivityChangeItem.obtain(onTop));
+                    TopResumedActivityChangeItem.obtain(token, onTop));
         } catch (RemoteException e) {
             // If process died, whatever.
             Slog.w(TAG, "Failed to send top-resumed=" + onTop + " to " + this, e);
@@ -2729,7 +2729,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
         try {
             mTransferringSplashScreenState = TRANSFER_SPLASH_SCREEN_ATTACH_TO_CLIENT;
             mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                    TransferSplashScreenViewStateItem.obtain(parcelable,
+                    TransferSplashScreenViewStateItem.obtain(token, parcelable,
                             windowAnimationLeash));
             scheduleTransferSplashScreenTimeout();
         } catch (Exception e) {
@@ -3896,7 +3896,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
             try {
                 if (DEBUG_SWITCH) Slog.i(TAG_SWITCH, "Destroying: " + this);
                 mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                        DestroyActivityItem.obtain(finishing, configChangeFlags));
+                        DestroyActivityItem.obtain(token, finishing, configChangeFlags));
             } catch (Exception e) {
                 // We can just ignore exceptions here...  if the process has crashed, our death
                 // notification will clean things up.
@@ -4804,7 +4804,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                 final ArrayList<ResultInfo> list = new ArrayList<ResultInfo>();
                 list.add(new ResultInfo(resultWho, requestCode, resultCode, data));
                 mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                        ActivityResultItem.obtain(list));
+                        ActivityResultItem.obtain(token, list));
                 return;
             } catch (Exception e) {
                 Slog.w(TAG, "Exception thrown sending result to " + this, e);
@@ -4817,7 +4817,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
             final ClientTransaction transaction = ClientTransaction.obtain(app.getThread(), token);
             // Build result to be returned immediately.
             transaction.addCallback(ActivityResultItem.obtain(
-                    List.of(new ResultInfo(resultWho, requestCode, resultCode, data))));
+                    token, List.of(new ResultInfo(resultWho, requestCode, resultCode, data))));
             // When the activity result is delivered, the activity will transition to RESUMED.
             // Since the activity is only resumed so the result can be immediately delivered,
             // return it to its original lifecycle state.
@@ -4858,13 +4858,13 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
     private ActivityLifecycleItem getLifecycleItemForCurrentStateForResult() {
         switch (mState) {
             case STARTED:
-                return StartActivityItem.obtain(null);
+                return StartActivityItem.obtain(token, null);
             case PAUSING:
             case PAUSED:
-                return PauseActivityItem.obtain();
+                return PauseActivityItem.obtain(token);
             case STOPPING:
             case STOPPED:
-                return StopActivityItem.obtain(configChangeFlags);
+                return StopActivityItem.obtain(token, configChangeFlags);
             default:
                 // Do not send a result immediately if the activity is in state INITIALIZING,
                 // RESTARTING_PROCESS, FINISHING, DESTROYING, or DESTROYED.
@@ -4910,7 +4910,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                 // so only if activity is currently RESUMED. Otherwise, client may have extra
                 // life-cycle calls to RESUMED (and PAUSED later).
                 mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                        NewIntentItem.obtain(ar, mState == RESUMED));
+                        NewIntentItem.obtain(token, ar, mState == RESUMED));
                 unsent = false;
             } catch (RemoteException e) {
                 Slog.w(TAG, "Exception thrown sending new intent to " + this, e);
@@ -6145,7 +6145,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                     shortComponentName, "userLeaving=false", "make-active");
             try {
                 mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                        PauseActivityItem.obtain(finishing, false /* userLeaving */,
+                        PauseActivityItem.obtain(token, finishing, false /* userLeaving */,
                                 configChangeFlags, false /* dontReport */, mAutoEnteringPip));
             } catch (Exception e) {
                 Slog.w(TAG, "Exception thrown sending pause: " + intent.getComponent(), e);
@@ -6158,7 +6158,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
 
             try {
                 mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                        StartActivityItem.obtain(takeOptions()));
+                        StartActivityItem.obtain(token, takeOptions()));
             } catch (Exception e) {
                 Slog.w(TAG, "Exception thrown sending start: " + intent.getComponent(), e);
             }
@@ -6456,7 +6456,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
             EventLogTags.writeWmStopActivity(
                     mUserId, System.identityHashCode(this), shortComponentName);
             mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                    StopActivityItem.obtain(configChangeFlags));
+                    StopActivityItem.obtain(token, configChangeFlags));
 
             mAtmService.mH.postDelayed(mStopTimeoutRunnable, STOP_TIMEOUT);
         } catch (Exception e) {
@@ -9871,17 +9871,17 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
                     (andResume ? "RESUMED" : "PAUSED"), this, Debug.getCallers(6));
             forceNewConfig = false;
             startRelaunching();
-            final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(pendingResults,
-                    pendingNewIntents, configChangeFlags,
+            final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(token,
+                    pendingResults, pendingNewIntents, configChangeFlags,
                     new MergedConfiguration(getProcessGlobalConfiguration(),
                             getMergedOverrideConfiguration()),
                     preserveWindow);
             final ActivityLifecycleItem lifecycleItem;
             if (andResume) {
-                lifecycleItem = ResumeActivityItem.obtain(isTransitionForward(),
+                lifecycleItem = ResumeActivityItem.obtain(token, isTransitionForward(),
                         shouldSendCompatFakeFocus());
             } else {
-                lifecycleItem = PauseActivityItem.obtain();
+                lifecycleItem = PauseActivityItem.obtain(token);
             }
             final ClientTransaction transaction = ClientTransaction.obtain(app.getThread(), token);
             transaction.addCallback(callbackItem);
@@ -9978,7 +9978,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
         // {@link ActivityTaskManagerService.activityStopped}).
         try {
             mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
-                    StopActivityItem.obtain(0 /* configChanges */));
+                    StopActivityItem.obtain(token, 0 /* configChanges */));
         } catch (RemoteException e) {
             Slog.w(TAG, "Exception thrown during restart " + this, e);
         }
diff --git a/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java b/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
index 6eb9ed695133..137e84145e8a 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
@@ -928,8 +928,8 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
                 final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();
 
                 final int deviceId = getDeviceIdForDisplayId(r.getDisplayId());
-                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
-                        System.identityHashCode(r), r.info,
+                clientTransaction.addCallback(LaunchActivityItem.obtain(r.token,
+                        new Intent(r.intent), System.identityHashCode(r), r.info,
                         // TODO: Have this take the merged configuration instead of separate global
                         // and override configs.
                         mergedConfiguration.getGlobalConfiguration(),
@@ -943,10 +943,10 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
                 // Set desired final state.
                 final ActivityLifecycleItem lifecycleItem;
                 if (andResume) {
-                    lifecycleItem = ResumeActivityItem.obtain(isTransitionForward,
+                    lifecycleItem = ResumeActivityItem.obtain(r.token, isTransitionForward,
                             r.shouldSendCompatFakeFocus());
                 } else {
-                    lifecycleItem = PauseActivityItem.obtain();
+                    lifecycleItem = PauseActivityItem.obtain(r.token);
                 }
                 clientTransaction.setLifecycleStateRequest(lifecycleItem);
 
diff --git a/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java b/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java
index f96f99d50053..c4ed0dd9d606 100644
--- a/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java
+++ b/services/core/java/com/android/server/wm/DisplayRotationCompatPolicy.java
@@ -228,9 +228,9 @@ final class DisplayRotationCompatPolicy {
                             + "activityRecord=%s", activity);
             final ClientTransaction transaction = ClientTransaction.obtain(
                     activity.app.getThread(), activity.token);
-            transaction.addCallback(
-                    RefreshCallbackItem.obtain(cycleThroughStop ? ON_STOP : ON_PAUSE));
-            transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(
+            transaction.addCallback(RefreshCallbackItem.obtain(activity.token,
+                            cycleThroughStop ? ON_STOP : ON_PAUSE));
+            transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(activity.token,
                     /* isForward */ false, /* shouldSendCompatFakeFocus */ false));
             activity.mAtmService.getLifecycleManager().scheduleTransaction(transaction);
             mHandler.postDelayed(
diff --git a/services/core/java/com/android/server/wm/TaskFragment.java b/services/core/java/com/android/server/wm/TaskFragment.java
index 6dc896a92e52..57f44cb599fe 100644
--- a/services/core/java/com/android/server/wm/TaskFragment.java
+++ b/services/core/java/com/android/server/wm/TaskFragment.java
@@ -1466,13 +1466,13 @@ class TaskFragment extends WindowContainer<WindowContainer> {
                         if (DEBUG_RESULTS) {
                             Slog.v(TAG_RESULTS, "Delivering results to " + next + ": " + a);
                         }
-                        transaction.addCallback(ActivityResultItem.obtain(a));
+                        transaction.addCallback(ActivityResultItem.obtain(next.token, a));
                     }
                 }
 
                 if (next.newIntents != null) {
                     transaction.addCallback(
-                            NewIntentItem.obtain(next.newIntents, true /* resume */));
+                            NewIntentItem.obtain(next.token, next.newIntents, true /* resume */));
                 }
 
                 // Well the app will no longer be stopped.
@@ -1486,7 +1486,7 @@ class TaskFragment extends WindowContainer<WindowContainer> {
                 next.app.setPendingUiCleanAndForceProcessStateUpTo(mAtmService.mTopProcessState);
                 next.abortAndClearOptionsAnimation();
                 transaction.setLifecycleStateRequest(
-                        ResumeActivityItem.obtain(next.app.getReportedProcState(),
+                        ResumeActivityItem.obtain(next.token, next.app.getReportedProcState(),
                                 dc.isNextTransitionForward(), next.shouldSendCompatFakeFocus()));
                 mAtmService.getLifecycleManager().scheduleTransaction(transaction);
 
@@ -1726,7 +1726,7 @@ class TaskFragment extends WindowContainer<WindowContainer> {
                     prev.shortComponentName, "userLeaving=" + userLeaving, reason);
 
             mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
-                    prev.token, PauseActivityItem.obtain(prev.finishing, userLeaving,
+                    prev.token, PauseActivityItem.obtain(prev.token, prev.finishing, userLeaving,
                             prev.configChangeFlags, pauseImmediately, autoEnteringPip));
         } catch (Exception e) {
             // Ignore exception, if process died other code will cleanup.
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
index 31682bc9e879..ae587003c1c2 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
@@ -517,7 +517,7 @@ public class ActivityRecordTests extends WindowTestsBase {
 
         // The configuration change is still sent to the activity, even if it doesn't relaunch.
         final ActivityConfigurationChangeItem expected =
-                ActivityConfigurationChangeItem.obtain(newConfig);
+                ActivityConfigurationChangeItem.obtain(activity.token, newConfig);
         verify(mAtm.getLifecycleManager()).scheduleTransaction(
                 eq(activity.app.getThread()), eq(activity.token), eq(expected));
     }
@@ -597,7 +597,7 @@ public class ActivityRecordTests extends WindowTestsBase {
         activity.setRequestedOrientation(requestedOrientation);
 
         final ActivityConfigurationChangeItem expected =
-                ActivityConfigurationChangeItem.obtain(newConfig);
+                ActivityConfigurationChangeItem.obtain(activity.token, newConfig);
         verify(mAtm.getLifecycleManager()).scheduleTransaction(eq(activity.app.getThread()),
                 eq(activity.token), eq(expected));
 
@@ -815,7 +815,7 @@ public class ActivityRecordTests extends WindowTestsBase {
                     false /* preserveWindow */, true /* ignoreStopState */);
 
             final ActivityConfigurationChangeItem expected =
-                    ActivityConfigurationChangeItem.obtain(newConfig);
+                    ActivityConfigurationChangeItem.obtain(activity.token, newConfig);
             verify(mAtm.getLifecycleManager()).scheduleTransaction(
                     eq(activity.app.getThread()), eq(activity.token), eq(expected));
         } finally {
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayRotationCompatPolicyTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayRotationCompatPolicyTests.java
index 769a309cf5a7..1b44c01bfab5 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayRotationCompatPolicyTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayRotationCompatPolicyTests.java
@@ -573,8 +573,9 @@ public final class DisplayRotationCompatPolicyTests extends WindowTestsBase {
 
         final ClientTransaction transaction = ClientTransaction.obtain(
                 mActivity.app.getThread(), mActivity.token);
-        transaction.addCallback(RefreshCallbackItem.obtain(cycleThroughStop ? ON_STOP : ON_PAUSE));
-        transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(
+        transaction.addCallback(RefreshCallbackItem.obtain(mActivity.token,
+                cycleThroughStop ? ON_STOP : ON_PAUSE));
+        transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(mActivity.token,
                 /* isForward */ false, /* shouldSendCompatFakeFocus */ false));
 
         verify(mActivity.mAtmService.getLifecycleManager(), times(refreshRequested ? 1 : 0))