Merge "[1/n] Force incompatible activities to fullscreen via desktop launch params" into main (2cbbe4a1) · Commits · e / os / android_frameworks_base

core/java/com/android/internal/policy/DesktopModeCompatPolicy.java

0 → 100644

+266 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2025 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.internal.policy;

		import android.Manifest;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.TaskInfo;
		import android.content.ComponentName;
		import android.content.Context;
		import android.content.pm.ActivityInfo;
		import android.content.pm.PackageInfo;
		import android.content.pm.PackageManager;
		import android.window.DesktopExperienceFlags;
		import android.window.DesktopModeFlags;

		import com.android.internal.R;

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.Map;
		import java.util.Objects;
		import java.util.function.Supplier;

		public class DesktopModeCompatPolicy {
		@NonNull
		private final Context mContext;
		@NonNull
		private final String mSystemUiPackage;
		private final Map<String, Boolean> mPackageInfoCache = new HashMap<>();
		private PackageManager mPackageManager = null;

		public Supplier<String> mDefaultHomePackageSupplier;

		public DesktopModeCompatPolicy(@NonNull Context context) {
		mContext = context;
		mSystemUiPackage = context.getResources().getString(R.string.config_systemUi);
		mDefaultHomePackageSupplier = () -> {
		final ComponentName homeActivities = getPackageManager().getHomeActivities(
		new ArrayList<>());
		if (homeActivities != null) {
		return homeActivities.getPackageName();
		}
		return null;
		};
		}

		public void setDefaultHomePackageSupplier(
		@NonNull Supplier<String> defaultHomePackageSupplier) {
		mDefaultHomePackageSupplier = defaultHomePackageSupplier;
		}

		@NonNull
		private PackageManager getPackageManager() {
		if (mPackageManager != null) {
		return mPackageManager;
		}

		mPackageManager = mContext.getPackageManager();
		return mPackageManager;
		}

		private String getDefaultHomePackage() {
		if (mDefaultHomePackageSupplier != null) {
		return mDefaultHomePackageSupplier.get();
		}

		final ComponentName homeActivities = getPackageManager().getHomeActivities(
		new ArrayList<>());
		if (homeActivities != null) {
		return homeActivities.getPackageName();
		}
		return null;
		}

		/**
		* @see #isTopActivityExemptFromDesktopWindowing(ComponentName, boolean, boolean, int, int,
		* ActivityInfo)
		*/
		public boolean isTopActivityExemptFromDesktopWindowing(@NonNull TaskInfo task) {
		return isTopActivityExemptFromDesktopWindowing(task.baseActivity,
		task.isTopActivityNoDisplay, task.isActivityStackTransparent, task.numActivities,
		task.userId, task.topActivityInfo);
		}

		/**
		* If the top activity should be exempt from desktop windowing and forced back to fullscreen.
		* Currently includes all system ui, default home and transparent stack activities with the
		* relevant permission or signature. However if the top activity is not being displayed,
		* regardless of its configuration, we will not exempt it as to remain in the desktop windowing
		* environment.
		*/
		public boolean isTopActivityExemptFromDesktopWindowing(@Nullable ComponentName baseActivity,
		boolean isTopActivityNoDisplay, boolean isActivityStackTransparent, int numActivities,
		int userId, ActivityInfo info) {
		final String packageName = baseActivity != null ? baseActivity.getPackageName() : null;
		if (packageName == null) {
		return false;
		}

		if (!DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_MODALS_POLICY.isTrue()) {
		return false;
		}
		// If activity is not being displayed, window mode change has no visual affect so leave
		// unchanged.
		if (isTopActivityNoDisplay) {
		return false;
		}
		// If activity belongs to system ui package, safe to force out of desktop.
		if (isSystemUiTask(packageName)) {
		return true;
		}
		// If activity belongs to default home package, safe to force out of desktop.
		if (isPartOfDefaultHomePackageOrNoHomeAvailable(packageName)) {
		return true;
		}
		// If all activities in task stack are transparent AND package has the relevant
		// fullscreen transparent permission OR is signed with platform key, safe to force out
		// of desktop.
		return isTransparentTask(isActivityStackTransparent, numActivities)
		&& (hasFullscreenTransparentPermission(packageName, userId)
		\|\| hasPlatformSignature(info));
		}

		/** @see #shouldDisableDesktopEntryPoints(String, int, boolean, boolean) */
		public boolean shouldDisableDesktopEntryPoints(@NonNull TaskInfo task) {
		final String packageName = task.baseActivity != null ? task.baseActivity.getPackageName() :
		null;
		return shouldDisableDesktopEntryPoints(
		packageName,
		task.numActivities,
		task.isTopActivityNoDisplay,
		task.isActivityStackTransparent
		);
		}

		/**
		* Whether all desktop entry points should be disabled for a given activity. Currently includes
		* all system ui, default home, transparent stack and no display activities.
		*/
		public boolean shouldDisableDesktopEntryPoints(
		@Nullable String packageName,
		int numActivities,
		boolean isTopActivityNoDisplay,
		boolean isActivityStackTransparent) {
		// Activity will not be displayed, no need to show desktop entry point.
		if (isTopActivityNoDisplay) {
		return true;
		}
		// If activity belongs to system ui package, hide desktop entry point.
		if (isSystemUiTask(packageName)) {
		return true;
		}
		// If activity belongs to default home package, safe to force out of desktop.
		if (isPartOfDefaultHomePackageOrNoHomeAvailable(packageName)) {
		return true;
		}
		// If all activities in task stack are transparent AND package has the relevant fullscreen
		// transparent permission, safe to force out of desktop.
		return isTransparentTask(isActivityStackTransparent, numActivities);
		}


		/** @see DesktopModeCompatUtils#shouldExcludeCaptionFromAppBounds */
		public boolean shouldExcludeCaptionFromAppBounds(@NonNull TaskInfo taskInfo) {
		if (taskInfo.topActivityInfo != null) {
		return DesktopModeCompatUtils.shouldExcludeCaptionFromAppBounds(
		taskInfo.topActivityInfo,
		taskInfo.isResizeable,
		taskInfo.appCompatTaskInfo != null
		&& taskInfo.appCompatTaskInfo.hasOptOutEdgeToEdge()
		);
		}
		return false;
		}

		/**
		* Returns true if all activities in a tasks stack are transparent. If there are no activities
		* will return false.
		*/
		public boolean isTransparentTask(@NonNull TaskInfo task) {
		return isTransparentTask(task.isActivityStackTransparent, task.numActivities);
		}

		private boolean isTransparentTask(boolean isActivityStackTransparent, int numActivities) {
		return isActivityStackTransparent && numActivities > 0;
		}

		private boolean isSystemUiTask(@Nullable String packageName) {
		return Objects.equals(packageName, mSystemUiPackage);
		}

		// Checks if the app for the given package has the SYSTEM_ALERT_WINDOW permission.
		private boolean hasFullscreenTransparentPermission(@NonNull String packageName, int userId) {
		if (!DesktopModeFlags.ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS.isTrue()) {
		// If the ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS flag is disabled, make neutral
		// condition
		// dependant on the ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE flag.
		return !DesktopExperienceFlags.ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE
		.isTrue();
		}

		final String cacheKey = userId + "@" + packageName;
		if (mPackageInfoCache.containsKey(cacheKey)) {
		return mPackageInfoCache.get(cacheKey);
		}

		boolean hasPermission = false;
		try {
		PackageInfo packageInfo = getPackageManager().getPackageInfoAsUser(
		packageName,
		PackageManager.GET_PERMISSIONS,
		userId
		);
		if (packageInfo != null && packageInfo.requestedPermissions != null) {
		for (String permission : packageInfo.requestedPermissions) {
		if (Objects.equals(permission, Manifest.permission.SYSTEM_ALERT_WINDOW)) {
		hasPermission = true;
		break;
		}
		}
		}
		} catch (PackageManager.NameNotFoundException e) {
		// Package not found, so no permission
		}
		mPackageInfoCache.put(cacheKey, hasPermission);
		return hasPermission;

		}

		// Checks if the app is signed with the platform signature.
		private boolean hasPlatformSignature(@Nullable ActivityInfo info) {
		if (DesktopExperienceFlags.ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE.isTrue()) {
		return info != null
		&& info.applicationInfo != null
		&& info.applicationInfo.isSignedWithPlatformKey();
		}
		// If the ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE flag is disabled, make neutral
		// condition dependant on the ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS flag.
		return !DesktopModeFlags.ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS.isTrue();
		}

		/**
		* Returns true if the tasks base activity is part of the default home package, or there is
		* currently no default home package available.
		*/
		private boolean isPartOfDefaultHomePackageOrNoHomeAvailable(@Nullable String packageName) {
		final String defaultHomePackage = mDefaultHomePackageSupplier.get();
		return defaultHomePackage == null \|\| (packageName != null
		&& packageName.equals(defaultHomePackage));
		}
		}

libs/WindowManager/Shell/shared/src/com/android/wm/shell/shared/desktopmode/DesktopModeCompatPolicy.kt

deleted100644 → 0

+0 −154

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.wm.shell.shared.desktopmode

		import android.Manifest.permission.SYSTEM_ALERT_WINDOW
		import android.app.TaskInfo
		import android.content.Context
		import android.content.pm.PackageManager
		import android.window.DesktopExperienceFlags
		import android.window.DesktopModeFlags
		import com.android.internal.R
		import com.android.internal.policy.DesktopModeCompatUtils
		import java.util.function.Supplier

		/**
		* Class to decide whether to apply app compat policies in desktop mode.
		*/
		// TODO(b/347289970): Consider replacing with API
		class DesktopModeCompatPolicy(private val context: Context) {

		private val systemUiPackage: String = context.resources.getString(R.string.config_systemUi)
		private val pkgManager: PackageManager
		get() = context.getPackageManager()
		private val defaultHomePackage: String?
		get() = defaultHomePackageSupplier?.get()
		?: pkgManager.getHomeActivities(ArrayList())?.packageName
		private val packageInfoCache = mutableMapOf<String, Boolean>()

		var defaultHomePackageSupplier: Supplier<String?>? = null

		/**
		* If the top activity should be exempt from desktop windowing and forced back to fullscreen.
		* Currently includes all system ui, default home and transparent stack activities with the
		* relevant permission or signature. However if the top activity is not being displayed,
		* regardless of its configuration, we will not exempt it as to remain in the desktop windowing
		* environment.
		*/
		fun isTopActivityExemptFromDesktopWindowing(task: TaskInfo): Boolean {
		val packageName = task.baseActivity?.packageName ?: return false

		return when {
		!DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_MODALS_POLICY.isTrue -> false
		// If activity is not being displayed, window mode change has no visual affect so leave
		// unchanged.
		task.isTopActivityNoDisplay -> false
		// If activity belongs to system ui package, safe to force out of desktop.
		isSystemUiTask(packageName) -> true
		// If activity belongs to default home package, safe to force out of desktop.
		isPartOfDefaultHomePackageOrNoHomeAvailable(packageName) -> true
		// If all activities in task stack are transparent AND package has the relevant
		// fullscreen transparent permission OR is signed with platform key, safe to force out
		// of desktop.
		isTransparentTask(task.isActivityStackTransparent, task.numActivities) &&
		(hasFullscreenTransparentPermission(packageName, task.userId) \|\|
		hasPlatformSignature(task)) -> true

		else -> false
		}
		}

		fun shouldDisableDesktopEntryPoints(task: TaskInfo) = shouldDisableDesktopEntryPoints(
		task.baseActivity?.packageName, task.numActivities, task.isTopActivityNoDisplay,
		task.isActivityStackTransparent)

		fun shouldDisableDesktopEntryPoints(
		packageName: String?,
		numActivities: Int,
		isTopActivityNoDisplay: Boolean,
		isActivityStackTransparent: Boolean,
		) = when {
		// Activity will not be displayed, no need to show desktop entry point.
		isTopActivityNoDisplay -> true
		// If activity belongs to system ui package, hide desktop entry point.
		isSystemUiTask(packageName) -> true
		// If activity belongs to default home package, safe to force out of desktop.
		isPartOfDefaultHomePackageOrNoHomeAvailable(packageName) -> true
		// If all activities in task stack are transparent AND package has the relevant fullscreen
		// transparent permission, safe to force out of desktop.
		isTransparentTask(isActivityStackTransparent, numActivities) -> true
		else -> false
		}


		/** @see DesktopModeCompatUtils.shouldExcludeCaptionFromAppBounds */
		fun shouldExcludeCaptionFromAppBounds(taskInfo: TaskInfo): Boolean =
		taskInfo.topActivityInfo?.let {
		DesktopModeCompatUtils.shouldExcludeCaptionFromAppBounds(it, taskInfo.isResizeable,
		taskInfo.appCompatTaskInfo.hasOptOutEdgeToEdge())
		} ?: false

		/**
		* Returns true if all activities in a tasks stack are transparent. If there are no activities
		* will return false.
		*/
		fun isTransparentTask(task: TaskInfo): Boolean =
		isTransparentTask(task.isActivityStackTransparent, task.numActivities)

		private fun isTransparentTask(isActivityStackTransparent: Boolean, numActivities: Int) =
		isActivityStackTransparent && numActivities > 0

		private fun isSystemUiTask(packageName: String?) = packageName == systemUiPackage

		// Checks if the app for the given package has the SYSTEM_ALERT_WINDOW permission.
		private fun hasFullscreenTransparentPermission(packageName: String, userId: Int): Boolean {
		if (DesktopModeFlags.ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS.isTrue) {
		return packageInfoCache.getOrPut("$userId@$packageName") {
		try {
		val packageInfo = pkgManager.getPackageInfoAsUser(
		packageName,
		PackageManager.GET_PERMISSIONS,
		userId
		)
		packageInfo?.requestedPermissions?.contains(SYSTEM_ALERT_WINDOW) == true
		} catch (e: PackageManager.NameNotFoundException) {
		false // Package not found
		}
		}
		}
		// If the ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS flag is disabled, make neutral condition
		// dependant on the ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE flag.
		return !DesktopExperienceFlags.ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE.isTrue
		}

		// Checks if the app is signed with the platform signature.
		private fun hasPlatformSignature(task: TaskInfo): Boolean {
		if (DesktopExperienceFlags.ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE.isTrue) {
		return task.topActivityInfo?.applicationInfo?.isSignedWithPlatformKey ?: false
		}
		// If the ENABLE_MODALS_FULLSCREEN_WITH_PLATFORM_SIGNATURE flag is disabled, make neutral
		// condition dependant on the ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS flag.
		return !DesktopModeFlags.ENABLE_MODALS_FULLSCREEN_WITH_PERMISSIONS.isTrue
		}

		/**
		* Returns true if the tasks base activity is part of the default home package, or there is
		* currently no default home package available.
		*/
		private fun isPartOfDefaultHomePackageOrNoHomeAvailable(packageName: String?) =
		defaultHomePackage == null \|\| (packageName != null && packageName == defaultHomePackage)
		}

libs/WindowManager/Shell/src/com/android/wm/shell/dagger/WMShellBaseModule.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ import android.window.DesktopModeFlags;
		import android.window.SystemPerformanceHinter;

		import com.android.internal.logging.UiEventLogger;
		import com.android.internal.policy.DesktopModeCompatPolicy;
		import com.android.launcher3.icons.IconProvider;
		import com.android.window.flags.Flags;
		import com.android.wm.shell.ProtoLogController;
		@@ -121,7 +122,6 @@ import com.android.wm.shell.shared.annotations.ShellMainThread;
		import com.android.wm.shell.shared.annotations.ShellSplashscreenThread;
		import com.android.wm.shell.shared.desktopmode.DesktopConfig;
		import com.android.wm.shell.shared.desktopmode.DesktopConfigImpl;
		import com.android.wm.shell.shared.desktopmode.DesktopModeCompatPolicy;
		import com.android.wm.shell.shared.desktopmode.DesktopState;
		import com.android.wm.shell.shared.desktopmode.DesktopStateImpl;
		import com.android.wm.shell.splitscreen.SplitScreen;

libs/WindowManager/Shell/src/com/android/wm/shell/dagger/WMShellModule.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ import androidx.annotation.OptIn;
		import com.android.app.viewcapture.ViewCaptureAwareWindowManagerFactory;
		import com.android.internal.jank.InteractionJankMonitor;
		import com.android.internal.logging.UiEventLogger;
		import com.android.internal.policy.DesktopModeCompatPolicy;
		import com.android.internal.statusbar.IStatusBarService;
		import com.android.internal.util.LatencyTracker;
		import com.android.launcher3.icons.IconProvider;
		@@ -163,7 +164,6 @@ import com.android.wm.shell.shared.annotations.ShellBackgroundThread;
		import com.android.wm.shell.shared.annotations.ShellDesktopThread;
		import com.android.wm.shell.shared.annotations.ShellMainThread;
		import com.android.wm.shell.shared.desktopmode.DesktopConfig;
		import com.android.wm.shell.shared.desktopmode.DesktopModeCompatPolicy;
		import com.android.wm.shell.shared.desktopmode.DesktopState;
		import com.android.wm.shell.splitscreen.SplitScreenController;
		import com.android.wm.shell.sysui.ShellCommandHandler;

libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopTasksController.kt

+1 −1

Original line number	Diff line number	Diff line
		@@ -87,6 +87,7 @@ import com.android.internal.jank.Cuj.CUJ_DESKTOP_MODE_ENTER_APP_HANDLE_DRAG_HOLD
		import com.android.internal.jank.Cuj.CUJ_DESKTOP_MODE_ENTER_APP_HANDLE_DRAG_RELEASE
		import com.android.internal.jank.Cuj.CUJ_DESKTOP_MODE_SNAP_RESIZE
		import com.android.internal.jank.InteractionJankMonitor
		import com.android.internal.policy.DesktopModeCompatPolicy
		import com.android.internal.policy.SystemBarUtils.getDesktopViewAppHeaderHeightPx
		import com.android.internal.protolog.ProtoLog
		import com.android.internal.util.LatencyTracker
		@@ -146,7 +147,6 @@ import com.android.wm.shell.shared.annotations.ShellDesktopThread
		import com.android.wm.shell.shared.annotations.ShellMainThread
		import com.android.wm.shell.shared.desktopmode.DesktopConfig
		import com.android.wm.shell.shared.desktopmode.DesktopFirstListener
		import com.android.wm.shell.shared.desktopmode.DesktopModeCompatPolicy
		import com.android.wm.shell.shared.desktopmode.DesktopModeTransitionSource
		import com.android.wm.shell.shared.desktopmode.DesktopState
		import com.android.wm.shell.shared.desktopmode.DesktopTaskToFrontReason