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

Commit e0853063 authored by Achim Thesmann's avatar Achim Thesmann Committed by MSe1969
Browse files

Revert "RESTRICT AUTOMERGE Ignore pinned Windows" 

This reverts commit 85f96289058efd23af98480e8cc74cc073662676.

Reason for revert: app compatibility regression

Bug: 406880479
Cherrypick-From: https://googleplex-android-review.googlesource.com/q/commit:1ee36749484bf96fd866081c24f7bca8fd47fdd7
Merged-In: I7f1239055d24718529afdd34e7b44497f7051518
Change-Id: I7f1239055d24718529afdd34e7b44497f7051518
parent 43532786

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

+16 −48
Original line number Diff line number Diff line
@@ -239,9 +239,7 @@ public class BackgroundActivityStartController { 
        private final int mCallingUid;

        private final int mCallingPid;

        private final @ActivityTaskManagerService.AppSwitchState int mAppSwitchState;

        private final boolean mCallingUidHasVisibleActivity;

        private final boolean mCallingUidHasVisibleNotPinnedActivity;

        private final boolean mCallingUidHasNonAppVisibleWindow;

        private final boolean mCallingUidHasAnyVisibleWindow;

        private final @ActivityManager.ProcessState int mCallingUidProcState;

        private final boolean mIsCallingUidPersistentSystemProcess;

        final BackgroundStartPrivileges mBalAllowedByPiSender;
@@ -250,9 +248,7 @@ public class BackgroundActivityStartController { 
        private final String mRealCallingPackage;

        private final int mRealCallingUid;

        private final int mRealCallingPid;

        private final boolean mRealCallingUidHasVisibleActivity;

        private final boolean mRealCallingUidHasVisibleNotPinnedActivity;

        private final boolean mRealCallingUidHasNonAppVisibleWindow;

        private final boolean mRealCallingUidHasAnyVisibleWindow;

        private final @ActivityManager.ProcessState int mRealCallingUidProcState;

        private final boolean mIsRealCallingUidPersistentSystemProcess;

        private final PendingIntentRecord mOriginatingPendingIntent;
@@ -347,25 +343,16 @@ public class BackgroundActivityStartController { 
            mCallingUidProcState = mService.mActiveUids.getUidState(callingUid);

            mIsCallingUidPersistentSystemProcess =

                    mCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;

            mCallingUidHasVisibleActivity =

                    mService.mVisibleActivityProcessTracker.hasVisibleActivity(callingUid);

            mCallingUidHasVisibleNotPinnedActivity = mService.mVisibleActivityProcessTracker

                    .hasVisibleNotPinnedActivity(callingUid);

            mCallingUidHasNonAppVisibleWindow = mService.mActiveUids.hasNonAppVisibleWindow(

                    callingUid);

            mCallingUidHasAnyVisibleWindow = mService.hasActiveVisibleWindow(callingUid);

            if (realCallingUid == NO_PROCESS_UID) {

                // no process provided

                mRealCallingUidProcState = PROCESS_STATE_NONEXISTENT;

                mRealCallingUidHasVisibleActivity = false;

                mRealCallingUidHasNonAppVisibleWindow = false;

                mRealCallingUidHasVisibleNotPinnedActivity = false;

                mRealCallingUidHasAnyVisibleWindow = false;

                mRealCallerApp = null;

                mIsRealCallingUidPersistentSystemProcess = false;

            } else if (callingUid == realCallingUid) {

                mRealCallingUidProcState = mCallingUidProcState;

                mRealCallingUidHasVisibleActivity = mCallingUidHasVisibleActivity;

                mRealCallingUidHasVisibleNotPinnedActivity = mCallingUidHasVisibleNotPinnedActivity;

                mRealCallingUidHasNonAppVisibleWindow = mCallingUidHasNonAppVisibleWindow;

                mRealCallingUidHasAnyVisibleWindow = mCallingUidHasAnyVisibleWindow;

                // In the PendingIntent case callerApp is not passed in, so resolve it ourselves.

                mRealCallerApp = callerApp == null

                        ? mService.getProcessController(realCallingPid, realCallingUid)
@@ -373,14 +360,8 @@ public class BackgroundActivityStartController { 
                mIsRealCallingUidPersistentSystemProcess = mIsCallingUidPersistentSystemProcess;

            } else {

                mRealCallingUidProcState = mService.mActiveUids.getUidState(realCallingUid);

                mRealCallingUidHasVisibleActivity =

                        mService.mVisibleActivityProcessTracker.hasVisibleActivity(

                                realCallingUid);

                mRealCallingUidHasVisibleNotPinnedActivity =

                        mService.mVisibleActivityProcessTracker.hasVisibleNotPinnedActivity(

                                realCallingUid);

                mRealCallingUidHasNonAppVisibleWindow =

                        mService.mActiveUids.hasNonAppVisibleWindow(realCallingUid);

                mRealCallingUidHasAnyVisibleWindow =

                        mService.hasActiveVisibleWindow(realCallingUid);

                mRealCallerApp = mService.getProcessController(realCallingPid, realCallingUid);

                mIsRealCallingUidPersistentSystemProcess =

                        mRealCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;
@@ -477,11 +458,7 @@ public class BackgroundActivityStartController { 
            sb.append("; callingUid: ").append(mCallingUid);

            sb.append("; callingPid: ").append(mCallingPid);

            sb.append("; appSwitchState: ").append(mAppSwitchState);

            sb.append("; callingUidHasVisibleActivity: ").append(mCallingUidHasVisibleActivity);

            sb.append("; callingUidHasVisibleNotPinnedActivity: ")

                    .append(mCallingUidHasVisibleNotPinnedActivity);

            sb.append("; callingUidHasNonAppVisibleWindow: ").append(

                    mCallingUidHasNonAppVisibleWindow);

            sb.append("; callingUidHasAnyVisibleWindow: ").append(mCallingUidHasAnyVisibleWindow);

            sb.append("; callingUidProcState: ").append(DebugUtils.valueToString(

                    ActivityManager.class, "PROCESS_STATE_", mCallingUidProcState));

            sb.append("; isCallingUidPersistentSystemProcess: ")
@@ -507,12 +484,8 @@ public class BackgroundActivityStartController { 
                        .append(getTargetSdk(mRealCallingPackage));

                sb.append("; realCallingUid: ").append(mRealCallingUid);

                sb.append("; realCallingPid: ").append(mRealCallingPid);

                sb.append("; realCallingUidHasVisibleActivity: ")

                        .append(mRealCallingUidHasVisibleActivity);

                sb.append("; realCallingUidHasVisibleNotPinnedActivity: ")

                        .append(mRealCallingUidHasVisibleNotPinnedActivity);

                sb.append("; realCallingUidHasNonAppVisibleWindow: ")

                        .append(mRealCallingUidHasNonAppVisibleWindow);

                sb.append("; realCallingUidHasAnyVisibleWindow: ")

                        .append(mRealCallingUidHasAnyVisibleWindow);

                sb.append("; realCallingUidProcState: ").append(DebugUtils.valueToString(

                        ActivityManager.class, "PROCESS_STATE_", mRealCallingUidProcState));

                sb.append("; isRealCallingUidPersistentSystemProcess: ")
@@ -594,10 +567,6 @@ public class BackgroundActivityStartController { 
        /** indicates that this verdict is based on the real calling UID and not the calling UID */

        private boolean mBasedOnRealCaller;



        BalVerdict(@BalCode int balCode, String message) {

            this(balCode, true, message);

        }



        BalVerdict(@BalCode int balCode, boolean background, String message) {

            this.mBackground = background;

            this.mCode = balCode;
@@ -878,9 +847,9 @@ public class BackgroundActivityStartController { 
        // is allowed, or apps like live wallpaper with non app visible window will be allowed.

        final boolean appSwitchAllowedOrFg =

                appSwitchState == APP_SWITCH_ALLOW || appSwitchState == APP_SWITCH_FG_ONLY;

        if (appSwitchAllowedOrFg && state.mCallingUidHasVisibleNotPinnedActivity) {

        if (appSwitchAllowedOrFg && state.mCallingUidHasAnyVisibleWindow) {

            return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,

                    "callingUid has visible non-pinned window");

                    /*background*/ false, "callingUid has visible window");

        }

        if (mService.mActiveUids.hasNonAppVisibleWindow(callingUid)) {

            return new BalVerdict(BAL_ALLOW_NON_APP_VISIBLE_WINDOW,
@@ -974,7 +943,7 @@ public class BackgroundActivityStartController { 
                || state.mAppSwitchState == APP_SWITCH_FG_ONLY

                || isHomeApp(state.mRealCallingUid, state.mRealCallingPackage);

        if (balImproveRealCallerVisibilityCheck()) {

            if (appSwitchAllowedOrFg && state.mRealCallingUidHasVisibleNotPinnedActivity) {

            if (appSwitchAllowedOrFg && state.mRealCallingUidHasAnyVisibleWindow) {

                return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,

                        /*background*/ false, "realCallingUid has visible window");

            }
@@ -985,8 +954,7 @@ public class BackgroundActivityStartController { 
        } else {

            // don't abort if the realCallingUid has a visible window

            // TODO(b/171459802): We should check appSwitchAllowed also

            if (state.mRealCallingUidHasVisibleNotPinnedActivity

                    || mService.mActiveUids.hasNonAppVisibleWindow(state.mRealCallingUid)) {

            if (state.mRealCallingUidHasAnyVisibleWindow) {

                return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,

                        /*background*/ false,

                        "realCallingUid has visible (non-toast) window.");
@@ -1692,10 +1660,10 @@ public class BackgroundActivityStartController { 
                            state.mCallingUid,

                            state.mCallingPackage,

                            state.mCallingUidProcState,

                            state.mCallingUidHasVisibleActivity,

                            state.mCallingUidHasAnyVisibleWindow,

                            state.mRealCallingUid,

                            state.mRealCallingUidProcState,

                            state.mRealCallingUidHasVisibleActivity,

                            state.mRealCallingUidHasAnyVisibleWindow,

                            (state.mOriginatingPendingIntent != null));

        }

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

+4 −7
Original line number Diff line number Diff line
@@ -100,8 +100,7 @@ class BackgroundLaunchProcessController { 
    BalVerdict areBackgroundActivityStartsAllowed(

            int pid, int uid, String packageName,

            int appSwitchState, boolean isCheckingForFgsStart,

            boolean hasActivityInVisibleTask, boolean inPinnedWindow,

            boolean hasBackgroundActivityStartPrivileges,

            boolean hasActivityInVisibleTask, boolean hasBackgroundActivityStartPrivileges,

            long lastStopAppSwitchesTime, long lastActivityLaunchTime,

            long lastActivityFinishTime) {

        // Allow if the proc is instrumenting with background activity starts privs.
@@ -124,11 +123,9 @@ class BackgroundLaunchProcessController { 
            return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW, /*background*/ false,

                    "process bound by foreground uid");

        }

        // Allow if the caller has an activity in any foreground task, unless it's a pinned window

        // and not a foreground service start.

        if ((isCheckingForFgsStart || !inPinnedWindow)

                && hasActivityInVisibleTask && appSwitchState != APP_SWITCH_DISALLOW) {

            return new BalVerdict(BAL_ALLOW_FOREGROUND, /*background*/

        // Allow if the caller has an activity in any foreground task.

        if (hasActivityInVisibleTask && appSwitchState != APP_SWITCH_DISALLOW) {

            return new BalVerdict(BAL_ALLOW_FOREGROUND, /*background*/ false,

                    "process has activity in foreground task");

        }

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

+2 −10
Original line number Diff line number Diff line
@@ -81,22 +81,14 @@ class VisibleActivityProcessTracker { 
     * {@link ActivityRecord#mVisibleRequested} or {@link ActivityRecord#isVisible()} is true.

     */

    boolean hasVisibleActivity(int uid) {

        return match(uid, ALWAYS_TRUE);

    }



    /**

     * Returns {@code true} if the uid has a process that contains an activity with

     * {@link ActivityRecord#mVisibleRequested} or {@link ActivityRecord#isVisible()} is true.

     */

    boolean hasVisibleNotPinnedActivity(int uid) {

        return match(uid, wpc -> !wpc.inPinnedWindowingMode());

        return match(uid, null /* predicate */);

    }



    private boolean match(int uid, Predicate<WindowProcessController> predicate) {

        synchronized (mProcMap) {

            for (int i = mProcMap.size() - 1; i >= 0; i--) {

                final WindowProcessController wpc = mProcMap.keyAt(i);

                if (wpc.mUid == uid && predicate.test(wpc)) {

                if (wpc.mUid == uid && (predicate == null || predicate.test(wpc))) {

                    return true;

                }

            }

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

+1 −2
Original line number Diff line number Diff line
@@ -665,8 +665,7 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio 
            int appSwitchState, boolean isCheckingForFgsStart) {

        return mBgLaunchController.areBackgroundActivityStartsAllowed(mPid, mUid,

                mInfo.packageName, appSwitchState, isCheckingForFgsStart,

                hasActivityInVisibleTask(), inPinnedWindowingMode(),

                mInstrumentingWithBackgroundActivityStartPrivileges,

                hasActivityInVisibleTask(), mInstrumentingWithBackgroundActivityStartPrivileges,

                mAtm.getLastStopAppSwitchesTime(),

                mLastActivityLaunchTime, mLastActivityFinishTime);

    }

services/tests/wmtests/src/com/android/server/wm/BackgroundActivityStartControllerTests.java

+6 −14
Original line number Diff line number Diff line
@@ -108,8 +108,6 @@ public class BackgroundActivityStartControllerTests { 
    AppOpsManager mAppOpsManager;

    MirrorActiveUids mActiveUids = new MirrorActiveUids();

    WindowProcessControllerMap mProcessMap = new WindowProcessControllerMap();

    @Mock

    VisibleActivityProcessTracker mVisibleActivityProcessTracker;



    @Mock

    ActivityTaskSupervisor mSupervisor;
@@ -186,8 +184,6 @@ public class BackgroundActivityStartControllerTests { 
        mService.mRootWindowContainer = mRootWindowContainer;

        Mockito.when(mService.getAppOpsManager()).thenReturn(mAppOpsManager);

        setViaReflection(mService, "mProcessMap", mProcessMap);

        setViaReflection(mService, "mVisibleActivityProcessTracker",

                mVisibleActivityProcessTracker);



        //Mockito.when(mSupervisor.getBackgroundActivityLaunchController()).thenReturn(mController);

        setViaReflection(mSupervisor, "mRecentTasks", mRecentTasks);
@@ -510,9 +506,8 @@ public class BackgroundActivityStartControllerTests { 
        assertThat(balState.realCallerExplicitOptInOrOut()).isFalse();

        assertThat(balState.toString()).isEqualTo(

                "[callingPackage: package.app1; callingPackageTargetSdk: -1; callingUid: 10001; "

                        + "callingPid: 11001; appSwitchState: 0; callingUidHasVisibleActivity: "

                        + "false; callingUidHasVisibleNotPinnedActivity: false; "

                        + "callingUidHasNonAppVisibleWindow: false; callingUidProcState: NONEXISTENT; "

                        + "callingPid: 11001; appSwitchState: 0; "

                        + "callingUidHasAnyVisibleWindow: false; callingUidProcState: NONEXISTENT; "

                        + "isCallingUidPersistentSystemProcess: false; forcedBalByPiSender: BSP"

                        + ".NONE; intent: Intent { cmp=package.app3/someClass }; callerApp: "

                        + "mCallerApp; inVisibleTask: false; balAllowedByPiCreator: BSP"
@@ -595,9 +590,8 @@ public class BackgroundActivityStartControllerTests { 
        assertThat(balState.realCallerExplicitOptInOrOut()).isFalse();

        assertThat(balState.toString()).isEqualTo(

                "[callingPackage: package.app1; callingPackageTargetSdk: -1; callingUid: 10001; "

                        + "callingPid: 11001; appSwitchState: 0; callingUidHasVisibleActivity: "

                        + "false; callingUidHasVisibleNotPinnedActivity: false; "

                        + "callingUidHasNonAppVisibleWindow: false; callingUidProcState: NONEXISTENT; "

                        + "callingPid: 11001; appSwitchState: 0; "

                        + "callingUidHasAnyVisibleWindow: false; callingUidProcState: NONEXISTENT; "

                        + "isCallingUidPersistentSystemProcess: false; forcedBalByPiSender: BSP"

                        + ".NONE; intent: Intent { cmp=package.app3/someClass }; callerApp: "

                        + "mCallerApp; inVisibleTask: false; balAllowedByPiCreator: BSP"
@@ -606,9 +600,7 @@ public class BackgroundActivityStartControllerTests { 
                        + "isCallForResult: false; isPendingIntent: true; autoOptInReason: "

                        + "null; realCallingPackage: uid=1[debugOnly]; "

                        + "realCallingPackageTargetSdk: -1; realCallingUid: 1; realCallingPid: 1; "

                        + " realCallingUidHasVisibleActivity: false; "

                        + "realCallingUidHasVisibleNotPinnedActivity: false; "

                        + "realCallingUidHasNonAppVisibleWindow: false; realCallingUidProcState: "

                        + " realCallingUidHasAnyVisibleWindow: false; realCallingUidProcState: "

                        + "NONEXISTENT; isRealCallingUidPersistentSystemProcess: false; "

                        + "originatingPendingIntent: PendingIntentRecord; realCallerApp: null; "

                        + "balAllowedByPiSender: BSP.ALLOW_FGS; resultIfPiSenderAllowsBal: null]");