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

Commit 58a95019 authored by Achim Thesmann's avatar Achim Thesmann Committed by Android Build Coastguard Worker
Browse files

Revert "RESTRICT AUTOMERGE Ignore pinned Windows" 

This reverts commit fc5dc86b6b79ca43758ca337f7ef858009acdc9d.

Reason for revert: Reason for revert: app compatibility regression

Bug: 406880479
Cherrypick-From: https://googleplex-android-review.googlesource.com/q/commit:38c7b6499acffda22267416a60860d7d5c5bbc7b
Merged-In: Iff954bf96857cdf5cafdc7bcf28908c1c6cb20a7
Change-Id: Iff954bf96857cdf5cafdc7bcf28908c1c6cb20a7
parent e64667ef

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

+2 −6
Original line number Diff line number Diff line
@@ -239,9 +239,7 @@ public class BackgroundActivityStartController { 


        // don't abort if the callingUid has a visible window or is a persistent system process

        final int callingUidProcState = mService.mActiveUids.getUidState(callingUid);

        final boolean callingUidHasAnyVisibleWindow =

                mService.mVisibleActivityProcessTracker.hasVisibleNotPinnedActivity(callingUid)

                        || mService.mActiveUids.hasNonAppVisibleWindow(callingUid);

        final boolean callingUidHasAnyVisibleWindow = mService.hasActiveVisibleWindow(callingUid);

        final boolean isCallingUidPersistentSystemProcess =

                callingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;
@@ -269,9 +267,7 @@ public class BackgroundActivityStartController { 
        final boolean realCallingUidHasAnyVisibleWindow =

                (callingUid == realCallingUid)

                        ? callingUidHasAnyVisibleWindow

                        : (mService.mVisibleActivityProcessTracker.hasVisibleNotPinnedActivity(

                                realCallingUid) || mService.mActiveUids.hasNonAppVisibleWindow(

                                realCallingUid));

                        : mService.hasActiveVisibleWindow(realCallingUid);

        final int realCallingAppId = UserHandle.getAppId(realCallingUid);

        final boolean isRealCallingUidPersistentSystemProcess =

                (callingUid == realCallingUid)

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

+5 −7
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM; 
import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;

import static com.android.server.wm.ActivityTaskManagerService.ACTIVITY_BG_START_GRACE_PERIOD_MS;

import static com.android.server.wm.ActivityTaskManagerService.APP_SWITCH_ALLOW;

import static com.android.server.wm.ActivityTaskManagerService.APP_SWITCH_DISALLOW;

import static com.android.server.wm.ActivityTaskManagerService.APP_SWITCH_FG_ONLY;

import static com.android.server.wm.BackgroundActivityStartController.BAL_ALLOW_FOREGROUND;

import static com.android.server.wm.BackgroundActivityStartController.BAL_ALLOW_GRACE_PERIOD;

import static com.android.server.wm.BackgroundActivityStartController.BAL_ALLOW_PERMISSION;
@@ -99,8 +99,7 @@ class BackgroundLaunchProcessController { 
    @BackgroundActivityStartController.BalCode

    int 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.
@@ -122,10 +121,9 @@ class BackgroundLaunchProcessController { 
                    BAL_ALLOW_VISIBLE_WINDOW, /*background*/ false, uid, uid, /*intent*/ null,

                    pid, "Activity start allowed: 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) {

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

        if (hasActivityInVisibleTask

                && (appSwitchState == APP_SWITCH_ALLOW || appSwitchState == APP_SWITCH_FG_ONLY)) {

            return BackgroundActivityStartController.logStartAllowedAndReturnCode(

                    BAL_ALLOW_FOREGROUND, /*background*/ false, uid, uid, /*intent*/ null,

                    pid, "Activity start allowed: process has activity in foreground task");

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

+2 −11
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ import java.util.function.Predicate; 
 * host process with foreground (resumed) activity.

 */

class VisibleActivityProcessTracker {

    private static final Predicate<WindowProcessController> ALWAYS_TRUE = wpc -> true;

    @GuardedBy("mProcMap")

    private final ArrayMap<WindowProcessController, CpuTimeRecord> mProcMap = new ArrayMap<>();

    final Executor mBgExecutor = BackgroundThread.getExecutor();
@@ -81,22 +80,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

+0 −1
Original line number Diff line number Diff line
@@ -624,7 +624,6 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio 
            boolean isCheckingForFgsStart) {

        return mBgLaunchController.areBackgroundActivityStartsAllowed(mPid, mUid, mInfo.packageName,

                appSwitchState, isCheckingForFgsStart, hasActivityInVisibleTask(),

                inPinnedWindowingMode(),

                mInstrumentingWithBackgroundActivityStartPrivileges,

                mAtm.getLastStopAppSwitchesTime(),

                mLastActivityLaunchTime, mLastActivityFinishTime);

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

deleted100644 → 0
+0 −95
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.server.wm;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.Mockito.mock;



import android.app.IApplicationThread;

import android.app.WindowConfiguration;

import android.content.pm.ApplicationInfo;

import android.platform.test.annotations.Presubmit;



import androidx.test.filters.SmallTest;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;





/**

 * Tests for the {@link com.android.server.wm.VisibleActivityProcessTracker} class.

 *

 * Build/Install/Run:

 * atest WmTests:VisibleActivityProcessTrackerTests

 */

@SmallTest

@Presubmit

@RunWith(WindowTestRunner.class)

public class VisibleActivityProcessTrackerTests extends WindowTestsBase {



    private VisibleActivityProcessTracker mTracker;



    @Before

    public void setup() {

        mTracker = mAtm.mVisibleActivityProcessTracker;

    }



    @Test

    public void testVisibleActivity() {

        WindowProcessController wpc = createWindowProcessController();

        assertThat(mTracker.hasVisibleActivity(wpc.mUid)).isFalse();

        mTracker.onAnyActivityVisible(wpc);

        assertThat(mTracker.hasVisibleActivity(wpc.mUid)).isTrue();

        mTracker.onAllActivitiesInvisible(wpc);

        assertThat(mTracker.hasVisibleActivity(wpc.mUid)).isFalse();

    }



    @Test

    public void testVisibleNotPinnedActivity() {

        WindowProcessController wpc = createWindowProcessController();

        assertThat(mTracker.hasVisibleNotPinnedActivity(wpc.mUid)).isFalse();

        mTracker.onAnyActivityVisible(wpc);

        assertThat(mTracker.hasVisibleNotPinnedActivity(wpc.mUid)).isTrue();

        mTracker.onAllActivitiesInvisible(wpc);

        assertThat(mTracker.hasVisibleNotPinnedActivity(wpc.mUid)).isFalse();

    }



    @Test

    public void testVisiblePinnedActivity() {

        WindowProcessController wpc = createWindowProcessController();

        wpc.getConfiguration().windowConfiguration.setWindowingMode(

                WindowConfiguration.WINDOWING_MODE_PINNED);

        assertThat(mTracker.hasVisibleNotPinnedActivity(wpc.mUid)).isFalse();

        mTracker.onAnyActivityVisible(wpc);

        assertThat(mTracker.hasVisibleActivity(wpc.mUid)).isTrue();

        assertThat(mTracker.hasVisibleNotPinnedActivity(wpc.mUid)).isFalse();

        mTracker.onAllActivitiesInvisible(wpc);

        assertThat(mTracker.hasVisibleNotPinnedActivity(wpc.mUid)).isFalse();

    }



    WindowProcessController createWindowProcessController() {

        WindowProcessListener mMockListener = mock(WindowProcessListener.class);

        ApplicationInfo info = mock(ApplicationInfo.class);

        info.packageName = "test.package.name";

        WindowProcessController mWpc = new WindowProcessController(

                mAtm, info, null, 0, -1, null, mMockListener);

        mWpc.setThread(mock(IApplicationThread.class));

        return mWpc;

    }

}