Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e8d079cc authored by Chris Li's avatar Chris Li
Browse files

Synchronize window config updates (9/n) 

Refactor to call scheduleTransaction through ClientLifecycleManager.

Bug: 260873529
Test: atest WmTests:ClientLifecycleManagerTests
Change-Id: I1ffc8e78b4a7c7c0363e385efbf404aff5f181a2
parent 37a77dfd

core/java/android/app/servertransaction/ActivityLifecycleItem.java

+1 −1
Original line number Diff line number Diff line
@@ -59,7 +59,7 @@ public abstract class ActivityLifecycleItem extends ActivityTransactionItem { 
    }



    @Override

    boolean isActivityLifecycleItem() {

    public boolean isActivityLifecycleItem() {

        return true;

    }

core/java/android/app/servertransaction/ClientTransactionItem.java

+1 −1
Original line number Diff line number Diff line
@@ -75,7 +75,7 @@ public abstract class ClientTransactionItem implements BaseClientRequest, Parcel 
    /**

     * Whether this is a {@link ActivityLifecycleItem}.

     */

    boolean isActivityLifecycleItem() {

    public boolean isActivityLifecycleItem() {

        return false;

    }

core/tests/coretests/src/android/app/servertransaction/TransactionExecutorTests.java

+37 −32
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ import static org.junit.Assert.assertEquals; 
import static org.junit.Assert.assertTrue;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.inOrder;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;
@@ -59,6 +60,8 @@ import org.junit.Before; 
import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.InOrder;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



import java.util.Arrays;

import java.util.Collections;
@@ -80,20 +83,32 @@ import java.util.stream.Collectors; 
@Presubmit

public class TransactionExecutorTests {



    @Mock

    private ClientTransactionHandler mTransactionHandler;

    @Mock

    private ActivityLifecycleItem mActivityLifecycleItem;

    @Mock

    private IBinder mActivityToken;

    @Mock

    private Activity mActivity;



    private TransactionExecutor mExecutor;

    private TransactionExecutorHelper mExecutorHelper;

    private ClientTransactionHandler mTransactionHandler;

    private ActivityClientRecord mClientRecord;



    @Before

    public void setUp() throws Exception {

        mTransactionHandler = mock(ClientTransactionHandler.class);

        MockitoAnnotations.initMocks(this);



        mClientRecord = new ActivityClientRecord();

        when(mTransactionHandler.getActivityClient(any())).thenReturn(mClientRecord);



        mExecutor = spy(new TransactionExecutor(mTransactionHandler));

        mExecutorHelper = new TransactionExecutorHelper();



        doReturn(true).when(mActivityLifecycleItem).isActivityLifecycleItem();

        doReturn(mActivityToken).when(mActivityLifecycleItem).getActivityToken();

        doReturn(mActivity).when(mTransactionHandler).getActivity(mActivityToken);

    }



    @Test
@@ -229,23 +244,21 @@ public class TransactionExecutorTests { 
        when(callback1.getPostExecutionState()).thenReturn(UNDEFINED);

        ClientTransactionItem callback2 = mock(ClientTransactionItem.class);

        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 */);

        transaction.addCallback(callback1);

        transaction.addCallback(callback2);

        transaction.setLifecycleStateRequest(stateRequest);

        transaction.setLifecycleStateRequest(mActivityLifecycleItem);



        transaction.preExecute(mTransactionHandler);

        mExecutor.execute(transaction);



        InOrder inOrder = inOrder(mTransactionHandler, callback1, callback2, stateRequest);

        InOrder inOrder = inOrder(mTransactionHandler, callback1, callback2,

                mActivityLifecycleItem);

        inOrder.verify(callback1).execute(eq(mTransactionHandler), any());

        inOrder.verify(callback2).execute(eq(mTransactionHandler), any());

        inOrder.verify(stateRequest).execute(eq(mTransactionHandler), eq(mClientRecord), any());

        inOrder.verify(mActivityLifecycleItem).execute(eq(mTransactionHandler), eq(mClientRecord),

                any());

    }



    @Test
@@ -254,23 +267,21 @@ public class TransactionExecutorTests { 
        when(callback1.getPostExecutionState()).thenReturn(UNDEFINED);

        ClientTransactionItem callback2 = mock(ClientTransactionItem.class);

        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 */);

        transaction.addTransactionItem(callback1);

        transaction.addTransactionItem(callback2);

        transaction.addTransactionItem(stateRequest);

        transaction.addTransactionItem(mActivityLifecycleItem);



        transaction.preExecute(mTransactionHandler);

        mExecutor.execute(transaction);



        InOrder inOrder = inOrder(mTransactionHandler, callback1, callback2, stateRequest);

        InOrder inOrder = inOrder(mTransactionHandler, callback1, callback2,

                mActivityLifecycleItem);

        inOrder.verify(callback1).execute(eq(mTransactionHandler), any());

        inOrder.verify(callback2).execute(eq(mTransactionHandler), any());

        inOrder.verify(stateRequest).execute(eq(mTransactionHandler), eq(mClientRecord), any());

        inOrder.verify(mActivityLifecycleItem).execute(eq(mTransactionHandler), eq(mClientRecord),

                any());

    }



    @Test
@@ -536,42 +547,36 @@ public class TransactionExecutorTests { 


    @Test

    public void testActivityItemExecute() {

        final IBinder token = mock(IBinder.class);

        final ClientTransaction transaction = ClientTransaction.obtain(null /* client */);

        final ActivityTransactionItem activityItem = mock(ActivityTransactionItem.class);

        when(activityItem.getPostExecutionState()).thenReturn(UNDEFINED);

        when(activityItem.getActivityToken()).thenReturn(token);

        when(activityItem.getActivityToken()).thenReturn(mActivityToken);

        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));

        transaction.setLifecycleStateRequest(mActivityLifecycleItem);



        mExecutor.execute(transaction);



        final InOrder inOrder = inOrder(activityItem, stateRequest);

        final InOrder inOrder = inOrder(activityItem, mActivityLifecycleItem);

        inOrder.verify(activityItem).execute(eq(mTransactionHandler), eq(mClientRecord), any());

        inOrder.verify(stateRequest).execute(eq(mTransactionHandler), eq(mClientRecord), any());

        inOrder.verify(mActivityLifecycleItem).execute(eq(mTransactionHandler), eq(mClientRecord),

                any());

    }



    @Test

    public void testExecuteTransactionItems_activityItemExecute() {

        final IBinder token = mock(IBinder.class);

        final ClientTransaction transaction = ClientTransaction.obtain(null /* client */);

        final ActivityTransactionItem activityItem = mock(ActivityTransactionItem.class);

        when(activityItem.getPostExecutionState()).thenReturn(UNDEFINED);

        when(activityItem.getActivityToken()).thenReturn(token);

        when(activityItem.getActivityToken()).thenReturn(mActivityToken);

        transaction.addTransactionItem(activityItem);

        final ActivityLifecycleItem stateRequest = mock(ActivityLifecycleItem.class);

        transaction.addTransactionItem(stateRequest);

        when(stateRequest.getActivityToken()).thenReturn(token);

        when(mTransactionHandler.getActivity(token)).thenReturn(mock(Activity.class));

        transaction.addTransactionItem(mActivityLifecycleItem);



        mExecutor.execute(transaction);



        final InOrder inOrder = inOrder(activityItem, stateRequest);

        final InOrder inOrder = inOrder(activityItem, mActivityLifecycleItem);

        inOrder.verify(activityItem).execute(eq(mTransactionHandler), eq(mClientRecord), any());

        inOrder.verify(stateRequest).execute(eq(mTransactionHandler), eq(mClientRecord), any());

        inOrder.verify(mActivityLifecycleItem).execute(eq(mTransactionHandler), eq(mClientRecord),

                any());

    }



    private static int[] shuffledArray(int[] inputArray) {

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

+3 −5
Original line number Diff line number Diff line
@@ -70,7 +70,6 @@ import android.app.IRequestFinishCallback; 
import android.app.PictureInPictureParams;

import android.app.PictureInPictureUiState;

import android.app.compat.CompatChanges;

import android.app.servertransaction.ClientTransaction;

import android.app.servertransaction.EnterPipRequestedItem;

import android.app.servertransaction.PipStateTransactionItem;

import android.compat.annotation.ChangeId;
@@ -1018,7 +1017,7 @@ class ActivityClientController extends IActivityClientController.Stub { 
        }



        try {

            mService.getLifecycleManager().scheduleTransaction(r.app.getThread(),

            mService.getLifecycleManager().scheduleTransactionItem(r.app.getThread(),

                    EnterPipRequestedItem.obtain(r.token));

            return true;

        } catch (Exception e) {
@@ -1038,9 +1037,8 @@ class ActivityClientController extends IActivityClientController.Stub { 
        }



        try {

            final ClientTransaction transaction = ClientTransaction.obtain(r.app.getThread());

            transaction.addCallback(PipStateTransactionItem.obtain(r.token, pipState));

            mService.getLifecycleManager().scheduleTransaction(transaction);

            mService.getLifecycleManager().scheduleTransactionItem(r.app.getThread(),

                    PipStateTransactionItem.obtain(r.token, pipState));

        } catch (Exception e) {

            Slog.w(TAG, "Failed to send pip state transaction item: "

                    + r.intent.getComponent(), e);

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

+25 −27
Original line number Diff line number Diff line
@@ -277,7 +277,6 @@ import android.app.servertransaction.ActivityConfigurationChangeItem; 
import android.app.servertransaction.ActivityLifecycleItem;

import android.app.servertransaction.ActivityRelaunchItem;

import android.app.servertransaction.ActivityResultItem;

import android.app.servertransaction.ClientTransaction;

import android.app.servertransaction.ClientTransactionItem;

import android.app.servertransaction.DestroyActivityItem;

import android.app.servertransaction.MoveToDisplayItem;
@@ -1449,7 +1448,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
                    + "display, activityRecord=%s, displayId=%d, config=%s", this, displayId,

                    config);



            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

            mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                    MoveToDisplayItem.obtain(token, displayId, config));

        } catch (RemoteException e) {

            // If process died, whatever.
@@ -1466,7 +1465,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            ProtoLog.v(WM_DEBUG_CONFIGURATION, "Sending new config to %s, "

                    + "config: %s", this, config);



            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

            mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                    ActivityConfigurationChangeItem.obtain(token, config));

        } catch (RemoteException e) {

            // If process died, whatever.
@@ -1487,7 +1486,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            ProtoLog.v(WM_DEBUG_STATES, "Sending position change to %s, onTop: %b",

                    this, onTop);



            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

            mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                    TopResumedActivityChangeItem.obtain(token, onTop));

        } catch (RemoteException e) {

            // If process died, whatever.
@@ -2744,7 +2743,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        }

        try {

            mTransferringSplashScreenState = TRANSFER_SPLASH_SCREEN_ATTACH_TO_CLIENT;

            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

            mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                    TransferSplashScreenViewStateItem.obtain(token, parcelable,

                            windowAnimationLeash));

            scheduleTransferSplashScreenTimeout();
@@ -3908,7 +3907,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 


            try {

                if (DEBUG_SWITCH) Slog.i(TAG_SWITCH, "Destroying: " + this);

                mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

                mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                        DestroyActivityItem.obtain(token, finishing, configChangeFlags));

            } catch (Exception e) {

                // We can just ignore exceptions here...  if the process has crashed, our death
@@ -4819,7 +4818,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            try {

                final ArrayList<ResultInfo> list = new ArrayList<>();

                list.add(new ResultInfo(resultWho, requestCode, resultCode, data));

                mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

                mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                        ActivityResultItem.obtain(token, list));

                return;

            } catch (Exception e) {
@@ -4830,22 +4829,23 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        // Schedule sending results now for Media Projection setup.

        if (forceSendForMediaProjection && attachedToProcess() && isState(STARTED, PAUSING, PAUSED,

                STOPPING, STOPPED)) {

            final ClientTransaction transaction = ClientTransaction.obtain(app.getThread());

            // Build result to be returned immediately.

            transaction.addCallback(ActivityResultItem.obtain(

                    token, List.of(new ResultInfo(resultWho, requestCode, resultCode, data))));

            final ActivityResultItem activityResultItem = ActivityResultItem.obtain(

                    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.

            ActivityLifecycleItem lifecycleItem = getLifecycleItemForCurrentStateForResult();

            final ActivityLifecycleItem lifecycleItem = getLifecycleItemForCurrentStateForResult();

            try {

                if (lifecycleItem != null) {

                transaction.setLifecycleStateRequest(lifecycleItem);

                    mAtmService.getLifecycleManager().scheduleTransactionAndLifecycleItems(

                            app.getThread(), activityResultItem, lifecycleItem);

                } else {

                    Slog.w(TAG, "Unable to get the lifecycle item for state " + mState

                            + " so couldn't immediately send result");

                    mAtmService.getLifecycleManager().scheduleTransactionItem(

                            app.getThread(), activityResultItem);

                }

            try {

                mAtmService.getLifecycleManager().scheduleTransaction(transaction);

            } catch (RemoteException e) {

                Slog.w(TAG, "Exception thrown sending result to " + this, e);

            }
@@ -4925,7 +4925,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
                // Making sure the client state is RESUMED after transaction completed and doing

                // 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(),

                mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                        NewIntentItem.obtain(token, ar, mState == RESUMED));

                unsent = false;

            } catch (RemoteException e) {
@@ -6150,7 +6150,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            EventLogTags.writeWmPauseActivity(mUserId, System.identityHashCode(this),

                    shortComponentName, "userLeaving=false", "make-active");

            try {

                mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

                mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                        PauseActivityItem.obtain(token, finishing, false /* userLeaving */,

                                configChangeFlags, false /* dontReport */, mAutoEnteringPip));

            } catch (Exception e) {
@@ -6163,7 +6163,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            setState(STARTED, "makeActiveIfNeeded");



            try {

                mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

                mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                        StartActivityItem.obtain(token, takeOptions()));

            } catch (Exception e) {

                Slog.w(TAG, "Exception thrown sending start: " + intent.getComponent(), e);
@@ -6461,7 +6461,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            }

            EventLogTags.writeWmStopActivity(

                    mUserId, System.identityHashCode(this), shortComponentName);

            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

            mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                    StopActivityItem.obtain(token, configChangeFlags));



            mAtmService.mH.postDelayed(mStopTimeoutRunnable, STOP_TIMEOUT);
@@ -9895,10 +9895,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
            } else {

                lifecycleItem = PauseActivityItem.obtain(token);

            }

            final ClientTransaction transaction = ClientTransaction.obtain(app.getThread());

            transaction.addCallback(callbackItem);

            transaction.setLifecycleStateRequest(lifecycleItem);

            mAtmService.getLifecycleManager().scheduleTransaction(transaction);

            mAtmService.getLifecycleManager().scheduleTransactionAndLifecycleItems(

                    app.getThread(), callbackItem, lifecycleItem);

            startRelaunching();

            // Note: don't need to call pauseIfSleepingLocked() here, because the caller will only

            // request resume if this activity is currently resumed, which implies we aren't
@@ -9990,7 +9988,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 
        // The process will be killed until the activity reports stopped with saved state (see

        // {@link ActivityTaskManagerService.activityStopped}).

        try {

            mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(),

            mAtmService.getLifecycleManager().scheduleTransactionItem(app.getThread(),

                    StopActivityItem.obtain(token, 0 /* configChanges */));

        } catch (RemoteException e) {

            Slog.w(TAG, "Exception thrown during restart " + this, e);