RESTRICT AUTOMERGE Ignore pinned Windows (Consolidated fix) (1933dcbb) · Commits · e / os / android_frameworks_base

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

+48 −16

Original line number	Original line	Diff line number	Diff line
	@@ -239,7 +239,9 @@ public class BackgroundActivityStartController {
	private final int mCallingUid;		private final int mCallingUid;
	private final int mCallingPid;		private final int mCallingPid;
	private final @ActivityTaskManagerService.AppSwitchState int mAppSwitchState;		private final @ActivityTaskManagerService.AppSwitchState int mAppSwitchState;
	private final boolean mCallingUidHasAnyVisibleWindow;		private final boolean mCallingUidHasVisibleActivity;
			private final boolean mCallingUidHasVisibleNotPinnedActivity;
			private final boolean mCallingUidHasNonAppVisibleWindow;
	private final @ActivityManager.ProcessState int mCallingUidProcState;		private final @ActivityManager.ProcessState int mCallingUidProcState;
	private final boolean mIsCallingUidPersistentSystemProcess;		private final boolean mIsCallingUidPersistentSystemProcess;
	final BackgroundStartPrivileges mBalAllowedByPiSender;		final BackgroundStartPrivileges mBalAllowedByPiSender;
	@@ -248,7 +250,9 @@ public class BackgroundActivityStartController {
	private final String mRealCallingPackage;		private final String mRealCallingPackage;
	private final int mRealCallingUid;		private final int mRealCallingUid;
	private final int mRealCallingPid;		private final int mRealCallingPid;
	private final boolean mRealCallingUidHasAnyVisibleWindow;		private final boolean mRealCallingUidHasVisibleActivity;
			private final boolean mRealCallingUidHasVisibleNotPinnedActivity;
			private final boolean mRealCallingUidHasNonAppVisibleWindow;
	private final @ActivityManager.ProcessState int mRealCallingUidProcState;		private final @ActivityManager.ProcessState int mRealCallingUidProcState;
	private final boolean mIsRealCallingUidPersistentSystemProcess;		private final boolean mIsRealCallingUidPersistentSystemProcess;
	private final PendingIntentRecord mOriginatingPendingIntent;		private final PendingIntentRecord mOriginatingPendingIntent;
	@@ -343,16 +347,25 @@ public class BackgroundActivityStartController {
	mCallingUidProcState = mService.mActiveUids.getUidState(callingUid);		mCallingUidProcState = mService.mActiveUids.getUidState(callingUid);
	mIsCallingUidPersistentSystemProcess =		mIsCallingUidPersistentSystemProcess =
	mCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;		mCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;
	mCallingUidHasAnyVisibleWindow = mService.hasActiveVisibleWindow(callingUid);		mCallingUidHasVisibleActivity =
			mService.mVisibleActivityProcessTracker.hasVisibleActivity(callingUid);
			mCallingUidHasVisibleNotPinnedActivity = mService.mVisibleActivityProcessTracker
			.hasVisibleNotPinnedActivity(callingUid);
			mCallingUidHasNonAppVisibleWindow = mService.mActiveUids.hasNonAppVisibleWindow(
			callingUid);
	if (realCallingUid == NO_PROCESS_UID) {		if (realCallingUid == NO_PROCESS_UID) {
	// no process provided		// no process provided
	mRealCallingUidProcState = PROCESS_STATE_NONEXISTENT;		mRealCallingUidProcState = PROCESS_STATE_NONEXISTENT;
	mRealCallingUidHasAnyVisibleWindow = false;		mRealCallingUidHasVisibleActivity = false;
			mRealCallingUidHasNonAppVisibleWindow = false;
			mRealCallingUidHasVisibleNotPinnedActivity = false;
	mRealCallerApp = null;		mRealCallerApp = null;
	mIsRealCallingUidPersistentSystemProcess = false;		mIsRealCallingUidPersistentSystemProcess = false;
	} else if (callingUid == realCallingUid) {		} else if (callingUid == realCallingUid) {
	mRealCallingUidProcState = mCallingUidProcState;		mRealCallingUidProcState = mCallingUidProcState;
	mRealCallingUidHasAnyVisibleWindow = mCallingUidHasAnyVisibleWindow;		mRealCallingUidHasVisibleActivity = mCallingUidHasVisibleActivity;
			mRealCallingUidHasVisibleNotPinnedActivity = mCallingUidHasVisibleNotPinnedActivity;
			mRealCallingUidHasNonAppVisibleWindow = mCallingUidHasNonAppVisibleWindow;
	// In the PendingIntent case callerApp is not passed in, so resolve it ourselves.		// In the PendingIntent case callerApp is not passed in, so resolve it ourselves.
	mRealCallerApp = callerApp == null		mRealCallerApp = callerApp == null
	? mService.getProcessController(realCallingPid, realCallingUid)		? mService.getProcessController(realCallingPid, realCallingUid)
	@@ -360,8 +373,14 @@ public class BackgroundActivityStartController {
	mIsRealCallingUidPersistentSystemProcess = mIsCallingUidPersistentSystemProcess;		mIsRealCallingUidPersistentSystemProcess = mIsCallingUidPersistentSystemProcess;
	} else {		} else {
	mRealCallingUidProcState = mService.mActiveUids.getUidState(realCallingUid);		mRealCallingUidProcState = mService.mActiveUids.getUidState(realCallingUid);
	mRealCallingUidHasAnyVisibleWindow =		mRealCallingUidHasVisibleActivity =
	mService.hasActiveVisibleWindow(realCallingUid);		mService.mVisibleActivityProcessTracker.hasVisibleActivity(
			realCallingUid);
			mRealCallingUidHasVisibleNotPinnedActivity =
			mService.mVisibleActivityProcessTracker.hasVisibleNotPinnedActivity(
			realCallingUid);
			mRealCallingUidHasNonAppVisibleWindow =
			mService.mActiveUids.hasNonAppVisibleWindow(realCallingUid);
	mRealCallerApp = mService.getProcessController(realCallingPid, realCallingUid);		mRealCallerApp = mService.getProcessController(realCallingPid, realCallingUid);
	mIsRealCallingUidPersistentSystemProcess =		mIsRealCallingUidPersistentSystemProcess =
	mRealCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;		mRealCallingUidProcState <= ActivityManager.PROCESS_STATE_PERSISTENT_UI;
	@@ -458,7 +477,11 @@ public class BackgroundActivityStartController {
	sb.append("; callingUid: ").append(mCallingUid);		sb.append("; callingUid: ").append(mCallingUid);
	sb.append("; callingPid: ").append(mCallingPid);		sb.append("; callingPid: ").append(mCallingPid);
	sb.append("; appSwitchState: ").append(mAppSwitchState);		sb.append("; appSwitchState: ").append(mAppSwitchState);
	sb.append("; callingUidHasAnyVisibleWindow: ").append(mCallingUidHasAnyVisibleWindow);		sb.append("; callingUidHasVisibleActivity: ").append(mCallingUidHasVisibleActivity);
			sb.append("; callingUidHasVisibleNotPinnedActivity: ")
			.append(mCallingUidHasVisibleNotPinnedActivity);
			sb.append("; callingUidHasNonAppVisibleWindow: ").append(
			mCallingUidHasNonAppVisibleWindow);
	sb.append("; callingUidProcState: ").append(DebugUtils.valueToString(		sb.append("; callingUidProcState: ").append(DebugUtils.valueToString(
	ActivityManager.class, "PROCESS_STATE_", mCallingUidProcState));		ActivityManager.class, "PROCESS_STATE_", mCallingUidProcState));
	sb.append("; isCallingUidPersistentSystemProcess: ")		sb.append("; isCallingUidPersistentSystemProcess: ")
	@@ -484,8 +507,12 @@ public class BackgroundActivityStartController {
	.append(getTargetSdk(mRealCallingPackage));		.append(getTargetSdk(mRealCallingPackage));
	sb.append("; realCallingUid: ").append(mRealCallingUid);		sb.append("; realCallingUid: ").append(mRealCallingUid);
	sb.append("; realCallingPid: ").append(mRealCallingPid);		sb.append("; realCallingPid: ").append(mRealCallingPid);
	sb.append("; realCallingUidHasAnyVisibleWindow: ")		sb.append("; realCallingUidHasVisibleActivity: ")
	.append(mRealCallingUidHasAnyVisibleWindow);		.append(mRealCallingUidHasVisibleActivity);
			sb.append("; realCallingUidHasVisibleNotPinnedActivity: ")
			.append(mRealCallingUidHasVisibleNotPinnedActivity);
			sb.append("; realCallingUidHasNonAppVisibleWindow: ")
			.append(mRealCallingUidHasNonAppVisibleWindow);
	sb.append("; realCallingUidProcState: ").append(DebugUtils.valueToString(		sb.append("; realCallingUidProcState: ").append(DebugUtils.valueToString(
	ActivityManager.class, "PROCESS_STATE_", mRealCallingUidProcState));		ActivityManager.class, "PROCESS_STATE_", mRealCallingUidProcState));
	sb.append("; isRealCallingUidPersistentSystemProcess: ")		sb.append("; isRealCallingUidPersistentSystemProcess: ")
	@@ -567,6 +594,10 @@ public class BackgroundActivityStartController {
	/** indicates that this verdict is based on the real calling UID and not the calling UID */		/** indicates that this verdict is based on the real calling UID and not the calling UID */
	private boolean mBasedOnRealCaller;		private boolean mBasedOnRealCaller;

			BalVerdict(@BalCode int balCode, String message) {
			this(balCode, true, message);
			}

	BalVerdict(@BalCode int balCode, boolean background, String message) {		BalVerdict(@BalCode int balCode, boolean background, String message) {
	this.mBackground = background;		this.mBackground = background;
	this.mCode = balCode;		this.mCode = balCode;
	@@ -847,9 +878,9 @@ public class BackgroundActivityStartController {
	// is allowed, or apps like live wallpaper with non app visible window will be allowed.		// is allowed, or apps like live wallpaper with non app visible window will be allowed.
	final boolean appSwitchAllowedOrFg =		final boolean appSwitchAllowedOrFg =
	appSwitchState == APP_SWITCH_ALLOW \|\| appSwitchState == APP_SWITCH_FG_ONLY;		appSwitchState == APP_SWITCH_ALLOW \|\| appSwitchState == APP_SWITCH_FG_ONLY;
	if (appSwitchAllowedOrFg && state.mCallingUidHasAnyVisibleWindow) {		if (appSwitchAllowedOrFg && state.mCallingUidHasVisibleNotPinnedActivity) {
	return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,		return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,
	/background/ false, "callingUid has visible window");		"callingUid has visible non-pinned window");
	}		}
	if (mService.mActiveUids.hasNonAppVisibleWindow(callingUid)) {		if (mService.mActiveUids.hasNonAppVisibleWindow(callingUid)) {
	return new BalVerdict(BAL_ALLOW_NON_APP_VISIBLE_WINDOW,		return new BalVerdict(BAL_ALLOW_NON_APP_VISIBLE_WINDOW,
	@@ -943,7 +974,7 @@ public class BackgroundActivityStartController {
	\|\| state.mAppSwitchState == APP_SWITCH_FG_ONLY		\|\| state.mAppSwitchState == APP_SWITCH_FG_ONLY
	\|\| isHomeApp(state.mRealCallingUid, state.mRealCallingPackage);		\|\| isHomeApp(state.mRealCallingUid, state.mRealCallingPackage);
	if (balImproveRealCallerVisibilityCheck()) {		if (balImproveRealCallerVisibilityCheck()) {
	if (appSwitchAllowedOrFg && state.mRealCallingUidHasAnyVisibleWindow) {		if (appSwitchAllowedOrFg && state.mRealCallingUidHasVisibleNotPinnedActivity) {
	return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,		return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,
	/background/ false, "realCallingUid has visible window");		/background/ false, "realCallingUid has visible window");
	}		}
	@@ -954,7 +985,8 @@ public class BackgroundActivityStartController {
	} else {		} else {
	// don't abort if the realCallingUid has a visible window		// don't abort if the realCallingUid has a visible window
	// TODO(b/171459802): We should check appSwitchAllowed also		// TODO(b/171459802): We should check appSwitchAllowed also
	if (state.mRealCallingUidHasAnyVisibleWindow) {		if (state.mRealCallingUidHasVisibleNotPinnedActivity
			\|\| mService.mActiveUids.hasNonAppVisibleWindow(state.mRealCallingUid)) {
	return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,		return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW,
	/background/ false,		/background/ false,
	"realCallingUid has visible (non-toast) window.");		"realCallingUid has visible (non-toast) window.");
	@@ -1660,10 +1692,10 @@ public class BackgroundActivityStartController {
	state.mCallingUid,		state.mCallingUid,
	state.mCallingPackage,		state.mCallingPackage,
	state.mCallingUidProcState,		state.mCallingUidProcState,
	state.mCallingUidHasAnyVisibleWindow,		state.mCallingUidHasVisibleActivity,
	state.mRealCallingUid,		state.mRealCallingUid,
	state.mRealCallingUidProcState,		state.mRealCallingUidProcState,
	state.mRealCallingUidHasAnyVisibleWindow,		state.mRealCallingUidHasVisibleActivity,
	(state.mOriginatingPendingIntent != null));		(state.mOriginatingPendingIntent != null));
	}		}

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

+7 −4

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

+10 −2

Original line number	Original line	Diff line number	Diff line
	@@ -81,14 +81,22 @@ class VisibleActivityProcessTracker {
	* {@link ActivityRecord#mVisibleRequested} or {@link ActivityRecord#isVisible()} is true.		* {@link ActivityRecord#mVisibleRequested} or {@link ActivityRecord#isVisible()} is true.
	*/		*/
	boolean hasVisibleActivity(int uid) {		boolean hasVisibleActivity(int uid) {
	return match(uid, null /* predicate */);		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.hasVisibleNotPinnedActivity());
	}		}

	private boolean match(int uid, Predicate<WindowProcessController> predicate) {		private boolean match(int uid, Predicate<WindowProcessController> predicate) {
	synchronized (mProcMap) {		synchronized (mProcMap) {
	for (int i = mProcMap.size() - 1; i >= 0; i--) {		for (int i = mProcMap.size() - 1; i >= 0; i--) {
	final WindowProcessController wpc = mProcMap.keyAt(i);		final WindowProcessController wpc = mProcMap.keyAt(i);
	if (wpc.mUid == uid && (predicate == null \|\| predicate.test(wpc))) {		if (wpc.mUid == uid && predicate.test(wpc)) {
	return true;		return true;
	}		}
	}		}

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

+17 −1

Original line number	Original line	Diff line number	Diff line
	@@ -665,7 +665,8 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
	int appSwitchState, boolean isCheckingForFgsStart) {		int appSwitchState, boolean isCheckingForFgsStart) {
	return mBgLaunchController.areBackgroundActivityStartsAllowed(mPid, mUid,		return mBgLaunchController.areBackgroundActivityStartsAllowed(mPid, mUid,
	mInfo.packageName, appSwitchState, isCheckingForFgsStart,		mInfo.packageName, appSwitchState, isCheckingForFgsStart,
	hasActivityInVisibleTask(), mInstrumentingWithBackgroundActivityStartPrivileges,		hasActivityInVisibleTask(), inPinnedWindowingMode(),
			mInstrumentingWithBackgroundActivityStartPrivileges,
	mAtm.getLastStopAppSwitchesTime(),		mAtm.getLastStopAppSwitchesTime(),
	mLastActivityLaunchTime, mLastActivityFinishTime);		mLastActivityLaunchTime, mLastActivityFinishTime);
	}		}
	@@ -834,6 +835,21 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
	return mHasActivities \|\| mHasRecentTasks;		return mHasActivities \|\| mHasRecentTasks;
	}		}

			/**
			* Check if any Activity is visible (or visibility requested) and not pinned.
			*/
			boolean hasVisibleNotPinnedActivity() {
			if (!hasVisibleActivities()) return false;
			for (int i = mActivities.size() - 1; i >= 0; --i) {
			final ActivityRecord activityRecord = mActivities.get(i);
			if ((activityRecord.isVisible() \|\| activityRecord.isVisibleRequested())
			&& !activityRecord.inPinnedWindowingMode()) {
			return true;
			}
			}
			return false;
			}

	@Nullable		@Nullable
	TaskDisplayArea getTopActivityDisplayArea() {		TaskDisplayArea getTopActivityDisplayArea() {
	if (mActivities.isEmpty()) {		if (mActivities.isEmpty()) {

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

+14 −6

Original line number	Original line	Diff line number	Diff line
	@@ -100,7 +100,8 @@ class BackgroundLaunchProcessController {
	BalVerdict areBackgroundActivityStartsAllowed(		BalVerdict areBackgroundActivityStartsAllowed(
	int pid, int uid, String packageName,		int pid, int uid, String packageName,
	int appSwitchState, boolean isCheckingForFgsStart,		int appSwitchState, boolean isCheckingForFgsStart,
	boolean hasActivityInVisibleTask, boolean hasBackgroundActivityStartPrivileges,		boolean hasActivityInVisibleTask, boolean inPinnedWindow,
			boolean hasBackgroundActivityStartPrivileges,
	long lastStopAppSwitchesTime, long lastActivityLaunchTime,		long lastStopAppSwitchesTime, long lastActivityLaunchTime,
	long lastActivityFinishTime) {		long lastActivityFinishTime) {
	// Allow if the proc is instrumenting with background activity starts privs.		// Allow if the proc is instrumenting with background activity starts privs.
	@@ -123,9 +124,11 @@ class BackgroundLaunchProcessController {
	return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW, /background/ false,		return new BalVerdict(BAL_ALLOW_VISIBLE_WINDOW, /background/ false,
	"process bound by foreground uid");		"process bound by foreground uid");
	}		}
	// Allow if the caller has an activity in any foreground task.		// Allow if the caller has an activity in any foreground task, unless it's a pinned window
	if (hasActivityInVisibleTask && appSwitchState != APP_SWITCH_DISALLOW) {		// and not a foreground service start.
	return new BalVerdict(BAL_ALLOW_FOREGROUND, /background/ false,		if ((isCheckingForFgsStart \|\| !inPinnedWindow)
			&& hasActivityInVisibleTask && appSwitchState != APP_SWITCH_DISALLOW) {
			return new BalVerdict(BAL_ALLOW_FOREGROUND, /background/
	"process has activity in foreground task");		"process has activity in foreground task");
	}		}

Original line number	Original line	Diff line number	Diff line
	@@ -108,6 +108,8 @@ public class BackgroundActivityStartControllerTests {
	AppOpsManager mAppOpsManager;		AppOpsManager mAppOpsManager;
	MirrorActiveUids mActiveUids = new MirrorActiveUids();		MirrorActiveUids mActiveUids = new MirrorActiveUids();
	WindowProcessControllerMap mProcessMap = new WindowProcessControllerMap();		WindowProcessControllerMap mProcessMap = new WindowProcessControllerMap();
			@Mock
			VisibleActivityProcessTracker mVisibleActivityProcessTracker;

	@Mock		@Mock
	ActivityTaskSupervisor mSupervisor;		ActivityTaskSupervisor mSupervisor;
	@@ -184,6 +186,8 @@ public class BackgroundActivityStartControllerTests {
	mService.mRootWindowContainer = mRootWindowContainer;		mService.mRootWindowContainer = mRootWindowContainer;
	Mockito.when(mService.getAppOpsManager()).thenReturn(mAppOpsManager);		Mockito.when(mService.getAppOpsManager()).thenReturn(mAppOpsManager);
	setViaReflection(mService, "mProcessMap", mProcessMap);		setViaReflection(mService, "mProcessMap", mProcessMap);
			setViaReflection(mService, "mVisibleActivityProcessTracker",
			mVisibleActivityProcessTracker);

	//Mockito.when(mSupervisor.getBackgroundActivityLaunchController()).thenReturn(mController);		//Mockito.when(mSupervisor.getBackgroundActivityLaunchController()).thenReturn(mController);
	setViaReflection(mSupervisor, "mRecentTasks", mRecentTasks);		setViaReflection(mSupervisor, "mRecentTasks", mRecentTasks);
	@@ -506,8 +510,9 @@ public class BackgroundActivityStartControllerTests {
	assertThat(balState.realCallerExplicitOptInOrOut()).isFalse();		assertThat(balState.realCallerExplicitOptInOrOut()).isFalse();
	assertThat(balState.toString()).isEqualTo(		assertThat(balState.toString()).isEqualTo(
	"[callingPackage: package.app1; callingPackageTargetSdk: -1; callingUid: 10001; "		"[callingPackage: package.app1; callingPackageTargetSdk: -1; callingUid: 10001; "
	+ "callingPid: 11001; appSwitchState: 0; "		+ "callingPid: 11001; appSwitchState: 0; callingUidHasVisibleActivity: "
	+ "callingUidHasAnyVisibleWindow: false; callingUidProcState: NONEXISTENT; "		+ "false; callingUidHasVisibleNotPinnedActivity: false; "
			+ "callingUidHasNonAppVisibleWindow: false; callingUidProcState: NONEXISTENT; "
	+ "isCallingUidPersistentSystemProcess: false; forcedBalByPiSender: BSP"		+ "isCallingUidPersistentSystemProcess: false; forcedBalByPiSender: BSP"
	+ ".NONE; intent: Intent { cmp=package.app3/someClass }; callerApp: "		+ ".NONE; intent: Intent { cmp=package.app3/someClass }; callerApp: "
	+ "mCallerApp; inVisibleTask: false; balAllowedByPiCreator: BSP"		+ "mCallerApp; inVisibleTask: false; balAllowedByPiCreator: BSP"
	@@ -590,8 +595,9 @@ public class BackgroundActivityStartControllerTests {
	assertThat(balState.realCallerExplicitOptInOrOut()).isFalse();		assertThat(balState.realCallerExplicitOptInOrOut()).isFalse();
	assertThat(balState.toString()).isEqualTo(		assertThat(balState.toString()).isEqualTo(
	"[callingPackage: package.app1; callingPackageTargetSdk: -1; callingUid: 10001; "		"[callingPackage: package.app1; callingPackageTargetSdk: -1; callingUid: 10001; "
	+ "callingPid: 11001; appSwitchState: 0; "		+ "callingPid: 11001; appSwitchState: 0; callingUidHasVisibleActivity: "
	+ "callingUidHasAnyVisibleWindow: false; callingUidProcState: NONEXISTENT; "		+ "false; callingUidHasVisibleNotPinnedActivity: false; "
			+ "callingUidHasNonAppVisibleWindow: false; callingUidProcState: NONEXISTENT; "
	+ "isCallingUidPersistentSystemProcess: false; forcedBalByPiSender: BSP"		+ "isCallingUidPersistentSystemProcess: false; forcedBalByPiSender: BSP"
	+ ".NONE; intent: Intent { cmp=package.app3/someClass }; callerApp: "		+ ".NONE; intent: Intent { cmp=package.app3/someClass }; callerApp: "
	+ "mCallerApp; inVisibleTask: false; balAllowedByPiCreator: BSP"		+ "mCallerApp; inVisibleTask: false; balAllowedByPiCreator: BSP"
	@@ -600,7 +606,9 @@ public class BackgroundActivityStartControllerTests {
	+ "isCallForResult: false; isPendingIntent: true; autoOptInReason: "		+ "isCallForResult: false; isPendingIntent: true; autoOptInReason: "