From 95bf5aef9f304018cb4298c603d3b5fdebe68d49 Mon Sep 17 00:00:00 2001 From: MrSluffy Date: Tue, 5 Nov 2024 22:11:23 +0800 Subject: [PATCH] fixes crashes --- build.gradle | 4 +- .../android/launcher3/FeatureFlagsImpl.java | 8 +- .../quickstep/util/DeviceConfigHelper.kt | 75 +- .../android/systemui/FeatureFlagsImpl.java | 13 +- .../systemui/shared/FeatureFlagsImpl.java | 9 +- .../window/flags/CustomFeatureFlags.java | 923 ++++++++++ .../window/flags/FakeFeatureFlagsImpl.java | 49 + .../android/window/flags/FeatureFlags.java | 214 +++ .../window/flags/FeatureFlagsImpl.java | 1638 +++++++++++++++++ flags/src/com/android/window/flags/Flags.java | 632 +++++++ .../android/wm/shell/FeatureFlagsImpl.java | 7 +- lawnchair/res/layout-v30/task_desktop.xml | 2 +- .../util/LawnchairWindowManagerProxy.kt | 29 +- quickstep/res/layout/task_desktop.xml | 2 +- quickstep/res/values/config.xml | 2 +- .../launcher3/QuickstepTransitionManager.java | 26 +- .../statehandlers/DepthController.java | 9 +- .../taskbar/NavbarButtonsViewController.java | 4 +- .../taskbar/TaskbarActivityContext.java | 2 - .../uioverrides/QuickstepLauncher.java | 31 +- .../quickstep/BaseContainerInterface.java | 4 +- .../LauncherBackAnimationController.java | 11 +- .../android/quickstep/RecentsActivity.java | 6 +- .../RecentsAnimationDeviceState.java | 4 +- .../com/android/quickstep/SystemUiProxy.java | 14 +- .../quickstep/TaskAnimationManager.java | 2 +- .../quickstep/util/GestureExclusionManager.kt | 47 +- .../util/SurfaceTransactionApplier.java | 4 +- src/com/android/launcher3/Utilities.java | 4 +- .../RemoteAnimationRunnerCompat.java | 63 +- .../system/InteractionJankMonitorWrapper.java | 2 +- .../shared/system/QuickStepContract.java | 9 +- .../system/TaskStackChangeListeners.java | 4 +- .../desktopmode/DesktopTasksController.kt | 6 +- .../shell/draganddrop/DragAndDropPolicy.java | 16 +- 35 files changed, 3680 insertions(+), 195 deletions(-) rename {quickstep => flags}/src/com/android/quickstep/util/DeviceConfigHelper.kt (56%) create mode 100644 flags/src/com/android/window/flags/CustomFeatureFlags.java create mode 100644 flags/src/com/android/window/flags/FakeFeatureFlagsImpl.java create mode 100644 flags/src/com/android/window/flags/FeatureFlags.java create mode 100644 flags/src/com/android/window/flags/FeatureFlagsImpl.java create mode 100644 flags/src/com/android/window/flags/Flags.java diff --git a/build.gradle b/build.gradle index efad3d348b..d98d53a33f 100644 --- a/build.gradle +++ b/build.gradle @@ -126,7 +126,7 @@ final def ciRef = System.getenv("GITHUB_REF") ?: "" final def ciRunNumber = System.getenv("GITHUB_RUN_NUMBER") ?: "" final def isReleaseBuild = ciBuild && ciRef.contains("beta") final def devReleaseName = ciBuild ? "Dev.(#${ciRunNumber})" : "Dev.(${buildCommit})" -final def version = "14" +final def version = "15" final def releaseName = "Beta 3" final def versionDisplayName = "${version}.${isReleaseBuild ? releaseName : devReleaseName}" final def majorVersion = versionDisplayName.split("\\.")[0] @@ -139,7 +139,7 @@ android { defaultConfig { // Lawnchair Launcher 14.0 Beta 3 // See CONTRIBUTING.md#versioning-scheme - versionCode 14_00_02_03 + versionCode 15_00_00_00 versionName "${versionDisplayName}" buildConfigField "String", "VERSION_DISPLAY_NAME", "\"${versionDisplayName}\"" buildConfigField "String", "MAJOR_VERSION", "\"${majorVersion}\"" diff --git a/flags/src/com/android/launcher3/FeatureFlagsImpl.java b/flags/src/com/android/launcher3/FeatureFlagsImpl.java index 80a7c80fd5..695f7b7ba6 100644 --- a/flags/src/com/android/launcher3/FeatureFlagsImpl.java +++ b/flags/src/com/android/launcher3/FeatureFlagsImpl.java @@ -1,7 +1,7 @@ package com.android.launcher3; // TODO(b/303773055): Remove the annotation after access issue is resolved. -import android.provider.DeviceConfig; -import android.provider.DeviceConfig.Properties; +import com.android.quickstep.util.DeviceConfigHelper; + import java.nio.file.Files; import java.nio.file.Paths; /** @hide */ @@ -63,7 +63,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_launcher() { try { - Properties properties = DeviceConfig.getProperties("launcher"); + var properties = DeviceConfigHelper.Companion.getPrefs(); enableAddAppWidgetViaConfigActivityV2 = properties.getBoolean(Flags.FLAG_ENABLE_ADD_APP_WIDGET_VIA_CONFIG_ACTIVITY_V2, true); enableAdditionalHomeAnimations = @@ -155,7 +155,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_launcher_search() { try { - Properties properties = DeviceConfig.getProperties("launcher_search"); + var properties = DeviceConfigHelper.Companion.getPrefs(); enablePrivateSpace = properties.getBoolean(Flags.FLAG_ENABLE_PRIVATE_SPACE, true); privateSpaceAddFloatingMaskView = diff --git a/quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt b/flags/src/com/android/quickstep/util/DeviceConfigHelper.kt similarity index 56% rename from quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt rename to flags/src/com/android/quickstep/util/DeviceConfigHelper.kt index dbfae18a92..a8a2991fd1 100644 --- a/quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt +++ b/flags/src/com/android/quickstep/util/DeviceConfigHelper.kt @@ -20,12 +20,7 @@ import android.app.ActivityThread import android.content.Context import android.content.SharedPreferences import android.content.SharedPreferences.OnSharedPreferenceChangeListener -import android.provider.DeviceConfig -import android.provider.DeviceConfig.OnPropertiesChangedListener -import android.provider.DeviceConfig.Properties import androidx.annotation.WorkerThread -import com.android.launcher3.BuildConfigs -import com.android.launcher3.util.Executors /** Utility class to manage a set of device configurations */ class DeviceConfigHelper(private val factory: (PropReader) -> ConfigType) { @@ -33,7 +28,6 @@ class DeviceConfigHelper(private val factory: (PropReader) -> Config var config: ConfigType private set private val allKeys: Set - private val propertiesListener = OnPropertiesChangedListener { onDevicePropsChanges(it) } private val sharedPrefChangeListener = OnSharedPreferenceChangeListener { _, _ -> recreateConfig() } @@ -43,58 +37,44 @@ class DeviceConfigHelper(private val factory: (PropReader) -> Config init { // Initialize the default config once. allKeys = HashSet() - config = - factory( - PropReader( - object : PropProvider { - override fun get(key: String, fallback: T): T { - if (fallback is Int) { - allKeys.add(key) - return DeviceConfig.getInt(NAMESPACE_LAUNCHER, key, fallback) as T - } else if (fallback is Boolean) { - allKeys.add(key) - return DeviceConfig.getBoolean(NAMESPACE_LAUNCHER, key, fallback) - as T - } else return fallback + config = factory( + PropReader( + object : PropProvider { + override fun get(key: String, fallback: T): T { + val prefs = prefs + allKeys.add(key) + return when (fallback) { + is Int -> prefs.getInt(key, fallback) as T + is Boolean -> prefs.getBoolean(key, fallback) as T + else -> fallback } } - ) + } ) - - DeviceConfig.addOnPropertiesChangedListener( - NAMESPACE_LAUNCHER, - Executors.UI_HELPER_EXECUTOR, - propertiesListener ) - if (BuildConfigs.IS_DEBUG_DEVICE) { - prefs.registerOnSharedPreferenceChangeListener(sharedPrefChangeListener) - } + + prefs.registerOnSharedPreferenceChangeListener(sharedPrefChangeListener) } @WorkerThread - private fun onDevicePropsChanges(properties: Properties) { - if (NAMESPACE_LAUNCHER != properties.namespace) return - if (!allKeys.any(properties.keyset::contains)) return + private fun onDevicePropsChanges() { recreateConfig() } private fun recreateConfig() { - val myProps = - DeviceConfig.getProperties(NAMESPACE_LAUNCHER, *allKeys.toTypedArray()) - config = - factory( - PropReader( - object : PropProvider { - override fun get(key: String, fallback: T): T { - if (fallback is Int) return myProps.getInt(key, fallback) as T - else if (fallback is Boolean) - return myProps.getBoolean(key, fallback) as T - else return fallback + config = factory( + PropReader( + object : PropProvider { + override fun get(key: String, fallback: T): T { + return when (fallback) { + is Int -> prefs.getInt(key, fallback) as T + is Boolean -> prefs.getBoolean(key, fallback) as T + else -> fallback } } - ) + } ) - Executors.MAIN_EXECUTOR.execute { changeListeners.forEach(Runnable::run) } + ) } /** Adds a listener for property changes */ @@ -104,10 +84,7 @@ class DeviceConfigHelper(private val factory: (PropReader) -> Config fun removeChangeListener(r: Runnable) = changeListeners.remove(r) fun close() { - DeviceConfig.removeOnPropertiesChangedListener(propertiesListener) - if (BuildConfigs.IS_DEBUG_DEVICE) { - prefs.unregisterOnSharedPreferenceChangeListener(sharedPrefChangeListener) - } + prefs.unregisterOnSharedPreferenceChangeListener(sharedPrefChangeListener) } internal interface PropProvider { @@ -120,7 +97,7 @@ class DeviceConfigHelper(private val factory: (PropReader) -> Config @JvmOverloads fun get(key: String, fallback: T, desc: String? = null): T { val v = f.get(key, fallback) - if (BuildConfigs.IS_DEBUG_DEVICE && desc != null) { + if (desc != null) { if (v is Int) { allProps[key] = DebugInfo(key, desc, true, fallback) return prefs.getInt(key, v) as T diff --git a/flags/src/com/android/systemui/FeatureFlagsImpl.java b/flags/src/com/android/systemui/FeatureFlagsImpl.java index 258a6ba5fe..0112adbffe 100644 --- a/flags/src/com/android/systemui/FeatureFlagsImpl.java +++ b/flags/src/com/android/systemui/FeatureFlagsImpl.java @@ -1,7 +1,8 @@ package com.android.systemui; // TODO(b/303773055): Remove the annotation after access issue is resolved. -import android.provider.DeviceConfig; -import android.provider.DeviceConfig.Properties; + +import com.android.quickstep.util.DeviceConfigHelper; + import java.nio.file.Files; import java.nio.file.Paths; /** @hide */ @@ -373,7 +374,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_accessibility() { try { - Properties properties = DeviceConfig.getProperties("accessibility"); + var properties = DeviceConfigHelper.Companion.getPrefs(); createWindowlessWindowMagnifier = properties.getBoolean(Flags.FLAG_CREATE_WINDOWLESS_WINDOW_MAGNIFIER, true); delayShowMagnificationButton = @@ -411,7 +412,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_biometrics_framework() { try { - Properties properties = DeviceConfig.getProperties("biometrics_framework"); + var properties = DeviceConfigHelper.Companion.getPrefs(); bpTalkback = properties.getBoolean(Flags.FLAG_BP_TALKBACK, true); constraintBp = @@ -431,7 +432,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_communal() { try { - Properties properties = DeviceConfig.getProperties("communal"); + var properties = DeviceConfigHelper.Companion.getPrefs(); communalHub = properties.getBoolean(Flags.FLAG_COMMUNAL_HUB, true); enableWidgetPickerSizeFilter = @@ -451,7 +452,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_systemui() { try { - Properties properties = DeviceConfig.getProperties("systemui"); + var properties = DeviceConfigHelper.Companion.getPrefs(); activityTransitionUseLargestWindow = properties.getBoolean(Flags.FLAG_ACTIVITY_TRANSITION_USE_LARGEST_WINDOW, true); ambientTouchMonitorListenToDisplayChanges = diff --git a/flags/src/com/android/systemui/shared/FeatureFlagsImpl.java b/flags/src/com/android/systemui/shared/FeatureFlagsImpl.java index f3df7770be..39a1f0ee3a 100644 --- a/flags/src/com/android/systemui/shared/FeatureFlagsImpl.java +++ b/flags/src/com/android/systemui/shared/FeatureFlagsImpl.java @@ -1,7 +1,8 @@ package com.android.systemui.shared; // TODO(b/303773055): Remove the annotation after access issue is resolved. -import android.provider.DeviceConfig; -import android.provider.DeviceConfig.Properties; + +import com.android.quickstep.util.DeviceConfigHelper; + import java.nio.file.Files; import java.nio.file.Paths; /** @hide */ @@ -46,7 +47,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_biometrics_framework() { try { - Properties properties = DeviceConfig.getProperties("biometrics_framework"); + var properties = DeviceConfigHelper.Companion.getPrefs(); sidefpsControllerRefactor = properties.getBoolean(Flags.FLAG_SIDEFPS_CONTROLLER_REFACTOR, true); } catch (NullPointerException e) { @@ -64,7 +65,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_systemui() { try { - Properties properties = DeviceConfig.getProperties("systemui"); + var properties = DeviceConfigHelper.Companion.getPrefs(); bouncerAreaExclusion = properties.getBoolean(Flags.FLAG_BOUNCER_AREA_EXCLUSION, true); enableHomeDelay = diff --git a/flags/src/com/android/window/flags/CustomFeatureFlags.java b/flags/src/com/android/window/flags/CustomFeatureFlags.java new file mode 100644 index 0000000000..70b2873fcc --- /dev/null +++ b/flags/src/com/android/window/flags/CustomFeatureFlags.java @@ -0,0 +1,923 @@ +package com.android.window.flags; + +// TODO(b/303773055): Remove the annotation after access issue is resolved. +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.BiPredicate; +import java.util.function.Predicate; + +/** @hide */ +public class CustomFeatureFlags implements FeatureFlags { + + private BiPredicate> mGetValueImpl; + + public CustomFeatureFlags(BiPredicate> getValueImpl) { + mGetValueImpl = getValueImpl; + } + @Override + + public boolean activityEmbeddingAnimationCustomizationFlag() { + return getValue(Flags.FLAG_ACTIVITY_EMBEDDING_ANIMATION_CUSTOMIZATION_FLAG, + FeatureFlags::activityEmbeddingAnimationCustomizationFlag); + } + + @Override + + public boolean activityEmbeddingInteractiveDividerFlag() { + return getValue(Flags.FLAG_ACTIVITY_EMBEDDING_INTERACTIVE_DIVIDER_FLAG, + FeatureFlags::activityEmbeddingInteractiveDividerFlag); + } + + @Override + + public boolean activityEmbeddingOverlayPresentationFlag() { + return getValue(Flags.FLAG_ACTIVITY_EMBEDDING_OVERLAY_PRESENTATION_FLAG, + FeatureFlags::activityEmbeddingOverlayPresentationFlag); + } + + @Override + + public boolean activitySnapshotByDefault() { + return getValue(Flags.FLAG_ACTIVITY_SNAPSHOT_BY_DEFAULT, + FeatureFlags::activitySnapshotByDefault); + } + + @Override + + public boolean activityWindowInfoFlag() { + return getValue(Flags.FLAG_ACTIVITY_WINDOW_INFO_FLAG, + FeatureFlags::activityWindowInfoFlag); + } + + @Override + + public boolean allowDisableActivityRecordInputSink() { + return getValue(Flags.FLAG_ALLOW_DISABLE_ACTIVITY_RECORD_INPUT_SINK, + FeatureFlags::allowDisableActivityRecordInputSink); + } + + @Override + + public boolean allowHideScmButton() { + return getValue(Flags.FLAG_ALLOW_HIDE_SCM_BUTTON, + FeatureFlags::allowHideScmButton); + } + + @Override + + public boolean allowsScreenSizeDecoupledFromStatusBarAndCutout() { + return getValue(Flags.FLAG_ALLOWS_SCREEN_SIZE_DECOUPLED_FROM_STATUS_BAR_AND_CUTOUT, + FeatureFlags::allowsScreenSizeDecoupledFromStatusBarAndCutout); + } + + @Override + + public boolean alwaysDeferTransitionWhenApplyWct() { + return getValue(Flags.FLAG_ALWAYS_DEFER_TRANSITION_WHEN_APPLY_WCT, + FeatureFlags::alwaysDeferTransitionWhenApplyWct); + } + + @Override + + public boolean alwaysDrawMagnificationFullscreenBorder() { + return getValue(Flags.FLAG_ALWAYS_DRAW_MAGNIFICATION_FULLSCREEN_BORDER, + FeatureFlags::alwaysDrawMagnificationFullscreenBorder); + } + + @Override + + public boolean alwaysUpdateWallpaperPermission() { + return getValue(Flags.FLAG_ALWAYS_UPDATE_WALLPAPER_PERMISSION, + FeatureFlags::alwaysUpdateWallpaperPermission); + } + + @Override + + public boolean appCompatPropertiesApi() { + return getValue(Flags.FLAG_APP_COMPAT_PROPERTIES_API, + FeatureFlags::appCompatPropertiesApi); + } + + @Override + + public boolean appCompatRefactoring() { + return getValue(Flags.FLAG_APP_COMPAT_REFACTORING, + FeatureFlags::appCompatRefactoring); + } + + @Override + + public boolean balDontBringExistingBackgroundTaskStackToFg() { + return getValue(Flags.FLAG_BAL_DONT_BRING_EXISTING_BACKGROUND_TASK_STACK_TO_FG, + FeatureFlags::balDontBringExistingBackgroundTaskStackToFg); + } + + @Override + + public boolean balImproveRealCallerVisibilityCheck() { + return getValue(Flags.FLAG_BAL_IMPROVE_REAL_CALLER_VISIBILITY_CHECK, + FeatureFlags::balImproveRealCallerVisibilityCheck); + } + + @Override + + public boolean balImprovedMetrics() { + return getValue(Flags.FLAG_BAL_IMPROVED_METRICS, + FeatureFlags::balImprovedMetrics); + } + + @Override + + public boolean balRequireOptInByPendingIntentCreator() { + return getValue(Flags.FLAG_BAL_REQUIRE_OPT_IN_BY_PENDING_INTENT_CREATOR, + FeatureFlags::balRequireOptInByPendingIntentCreator); + } + + @Override + + public boolean balRequireOptInSameUid() { + return getValue(Flags.FLAG_BAL_REQUIRE_OPT_IN_SAME_UID, + FeatureFlags::balRequireOptInSameUid); + } + + @Override + + public boolean balRespectAppSwitchStateWhenCheckBoundByForegroundUid() { + return getValue(Flags.FLAG_BAL_RESPECT_APP_SWITCH_STATE_WHEN_CHECK_BOUND_BY_FOREGROUND_UID, + FeatureFlags::balRespectAppSwitchStateWhenCheckBoundByForegroundUid); + } + + @Override + + public boolean balShowToasts() { + return getValue(Flags.FLAG_BAL_SHOW_TOASTS, + FeatureFlags::balShowToasts); + } + + @Override + + public boolean balShowToastsBlocked() { + return getValue(Flags.FLAG_BAL_SHOW_TOASTS_BLOCKED, + FeatureFlags::balShowToastsBlocked); + } + + @Override + + public boolean blastSyncNotificationShadeOnDisplaySwitch() { + return getValue(Flags.FLAG_BLAST_SYNC_NOTIFICATION_SHADE_ON_DISPLAY_SWITCH, + FeatureFlags::blastSyncNotificationShadeOnDisplaySwitch); + } + + @Override + + public boolean bundleClientTransactionFlag() { + return getValue(Flags.FLAG_BUNDLE_CLIENT_TRANSACTION_FLAG, + FeatureFlags::bundleClientTransactionFlag); + } + + @Override + + public boolean cameraCompatForFreeform() { + return getValue(Flags.FLAG_CAMERA_COMPAT_FOR_FREEFORM, + FeatureFlags::cameraCompatForFreeform); + } + + @Override + + public boolean closeToSquareConfigIncludesStatusBar() { + return getValue(Flags.FLAG_CLOSE_TO_SQUARE_CONFIG_INCLUDES_STATUS_BAR, + FeatureFlags::closeToSquareConfigIncludesStatusBar); + } + + @Override + + public boolean configurableFontScaleDefault() { + return getValue(Flags.FLAG_CONFIGURABLE_FONT_SCALE_DEFAULT, + FeatureFlags::configurableFontScaleDefault); + } + + @Override + + public boolean coverDisplayOptIn() { + return getValue(Flags.FLAG_COVER_DISPLAY_OPT_IN, + FeatureFlags::coverDisplayOptIn); + } + + @Override + + public boolean deferDisplayUpdates() { + return getValue(Flags.FLAG_DEFER_DISPLAY_UPDATES, + FeatureFlags::deferDisplayUpdates); + } + + @Override + + public boolean delayNotificationToMagnificationWhenRecentsWindowToFrontTransition() { + return getValue(Flags.FLAG_DELAY_NOTIFICATION_TO_MAGNIFICATION_WHEN_RECENTS_WINDOW_TO_FRONT_TRANSITION, + FeatureFlags::delayNotificationToMagnificationWhenRecentsWindowToFrontTransition); + } + + @Override + + public boolean delegateUnhandledDrags() { + return getValue(Flags.FLAG_DELEGATE_UNHANDLED_DRAGS, + FeatureFlags::delegateUnhandledDrags); + } + + @Override + + public boolean deleteCaptureDisplay() { + return getValue(Flags.FLAG_DELETE_CAPTURE_DISPLAY, + FeatureFlags::deleteCaptureDisplay); + } + + @Override + + public boolean density390Api() { + return getValue(Flags.FLAG_DENSITY_390_API, + FeatureFlags::density390Api); + } + + @Override + + public boolean disableObjectPool() { + return getValue(Flags.FLAG_DISABLE_OBJECT_POOL, + FeatureFlags::disableObjectPool); + } + + @Override + + public boolean disableThinLetterboxingPolicy() { + return getValue(Flags.FLAG_DISABLE_THIN_LETTERBOXING_POLICY, + FeatureFlags::disableThinLetterboxingPolicy); + } + + @Override + + public boolean doNotCheckIntersectionWhenNonMagnifiableWindowTransitions() { + return getValue(Flags.FLAG_DO_NOT_CHECK_INTERSECTION_WHEN_NON_MAGNIFIABLE_WINDOW_TRANSITIONS, + FeatureFlags::doNotCheckIntersectionWhenNonMagnifiableWindowTransitions); + } + + @Override + + public boolean drawSnapshotAspectRatioMatch() { + return getValue(Flags.FLAG_DRAW_SNAPSHOT_ASPECT_RATIO_MATCH, + FeatureFlags::drawSnapshotAspectRatioMatch); + } + + @Override + + public boolean edgeToEdgeByDefault() { + return getValue(Flags.FLAG_EDGE_TO_EDGE_BY_DEFAULT, + FeatureFlags::edgeToEdgeByDefault); + } + + @Override + + public boolean embeddedActivityBackNavFlag() { + return getValue(Flags.FLAG_EMBEDDED_ACTIVITY_BACK_NAV_FLAG, + FeatureFlags::embeddedActivityBackNavFlag); + } + + @Override + + public boolean enableAdditionalWindowsAboveStatusBar() { + return getValue(Flags.FLAG_ENABLE_ADDITIONAL_WINDOWS_ABOVE_STATUS_BAR, + FeatureFlags::enableAdditionalWindowsAboveStatusBar); + } + + @Override + + public boolean enableAppHeaderWithTaskDensity() { + return getValue(Flags.FLAG_ENABLE_APP_HEADER_WITH_TASK_DENSITY, + FeatureFlags::enableAppHeaderWithTaskDensity); + } + + @Override + + public boolean enableBufferTransformHintFromDisplay() { + return getValue(Flags.FLAG_ENABLE_BUFFER_TRANSFORM_HINT_FROM_DISPLAY, + FeatureFlags::enableBufferTransformHintFromDisplay); + } + + @Override + + public boolean enableCameraCompatForDesktopWindowing() { + return getValue(Flags.FLAG_ENABLE_CAMERA_COMPAT_FOR_DESKTOP_WINDOWING, + FeatureFlags::enableCameraCompatForDesktopWindowing); + } + + @Override + + public boolean enableCompatuiSysuiLauncher() { + return getValue(Flags.FLAG_ENABLE_COMPATUI_SYSUI_LAUNCHER, + FeatureFlags::enableCompatuiSysuiLauncher); + } + + @Override + + public boolean enableDesktopWindowingImmersiveHandleHiding() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_IMMERSIVE_HANDLE_HIDING, + FeatureFlags::enableDesktopWindowingImmersiveHandleHiding); + } + + @Override + + public boolean enableDesktopWindowingModalsPolicy() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODALS_POLICY, + FeatureFlags::enableDesktopWindowingModalsPolicy); + } + + @Override + + public boolean enableDesktopWindowingMode() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODE, + FeatureFlags::enableDesktopWindowingMode); + } + + @Override + + public boolean enableDesktopWindowingQuickSwitch() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_QUICK_SWITCH, + FeatureFlags::enableDesktopWindowingQuickSwitch); + } + + @Override + + public boolean enableDesktopWindowingScvhCache() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_SCVH_CACHE, + FeatureFlags::enableDesktopWindowingScvhCache); + } + + @Override + + public boolean enableDesktopWindowingSizeConstraints() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_SIZE_CONSTRAINTS, + FeatureFlags::enableDesktopWindowingSizeConstraints); + } + + @Override + + public boolean enableDesktopWindowingTaskLimit() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_TASK_LIMIT, + FeatureFlags::enableDesktopWindowingTaskLimit); + } + + @Override + + public boolean enableDesktopWindowingTaskbarRunningApps() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_TASKBAR_RUNNING_APPS, + FeatureFlags::enableDesktopWindowingTaskbarRunningApps); + } + + @Override + + public boolean enableDesktopWindowingWallpaperActivity() { + return getValue(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY, + FeatureFlags::enableDesktopWindowingWallpaperActivity); + } + + @Override + + public boolean enableScaledResizing() { + return getValue(Flags.FLAG_ENABLE_SCALED_RESIZING, + FeatureFlags::enableScaledResizing); + } + + @Override + + public boolean enableTaskStackObserverInShell() { + return getValue(Flags.FLAG_ENABLE_TASK_STACK_OBSERVER_IN_SHELL, + FeatureFlags::enableTaskStackObserverInShell); + } + + @Override + + public boolean enableThemedAppHeaders() { + return getValue(Flags.FLAG_ENABLE_THEMED_APP_HEADERS, + FeatureFlags::enableThemedAppHeaders); + } + + @Override + + public boolean enableWindowingDynamicInitialBounds() { + return getValue(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS, + FeatureFlags::enableWindowingDynamicInitialBounds); + } + + @Override + + public boolean enableWindowingEdgeDragResize() { + return getValue(Flags.FLAG_ENABLE_WINDOWING_EDGE_DRAG_RESIZE, + FeatureFlags::enableWindowingEdgeDragResize); + } + + @Override + + public boolean enableWmExtensionsForAllFlag() { + return getValue(Flags.FLAG_ENABLE_WM_EXTENSIONS_FOR_ALL_FLAG, + FeatureFlags::enableWmExtensionsForAllFlag); + } + + @Override + + public boolean enforceEdgeToEdge() { + return getValue(Flags.FLAG_ENFORCE_EDGE_TO_EDGE, + FeatureFlags::enforceEdgeToEdge); + } + + @Override + + public boolean ensureWallpaperInTransitions() { + return getValue(Flags.FLAG_ENSURE_WALLPAPER_IN_TRANSITIONS, + FeatureFlags::ensureWallpaperInTransitions); + } + + @Override + + public boolean explicitRefreshRateHints() { + return getValue(Flags.FLAG_EXPLICIT_REFRESH_RATE_HINTS, + FeatureFlags::explicitRefreshRateHints); + } + + @Override + + public boolean fifoPriorityForMajorUiProcesses() { + return getValue(Flags.FLAG_FIFO_PRIORITY_FOR_MAJOR_UI_PROCESSES, + FeatureFlags::fifoPriorityForMajorUiProcesses); + } + + @Override + + public boolean fixNoContainerUpdateWithoutResize() { + return getValue(Flags.FLAG_FIX_NO_CONTAINER_UPDATE_WITHOUT_RESIZE, + FeatureFlags::fixNoContainerUpdateWithoutResize); + } + + @Override + + public boolean fixPipRestoreToOverlay() { + return getValue(Flags.FLAG_FIX_PIP_RESTORE_TO_OVERLAY, + FeatureFlags::fixPipRestoreToOverlay); + } + + @Override + + public boolean fullscreenDimFlag() { + return getValue(Flags.FLAG_FULLSCREEN_DIM_FLAG, + FeatureFlags::fullscreenDimFlag); + } + + @Override + + public boolean getDimmerOnClosing() { + return getValue(Flags.FLAG_GET_DIMMER_ON_CLOSING, + FeatureFlags::getDimmerOnClosing); + } + + @Override + + public boolean immersiveAppRepositioning() { + return getValue(Flags.FLAG_IMMERSIVE_APP_REPOSITIONING, + FeatureFlags::immersiveAppRepositioning); + } + + @Override + + public boolean insetsControlChangedItem() { + return getValue(Flags.FLAG_INSETS_CONTROL_CHANGED_ITEM, + FeatureFlags::insetsControlChangedItem); + } + + @Override + + public boolean insetsControlSeq() { + return getValue(Flags.FLAG_INSETS_CONTROL_SEQ, + FeatureFlags::insetsControlSeq); + } + + @Override + + public boolean insetsDecoupledConfiguration() { + return getValue(Flags.FLAG_INSETS_DECOUPLED_CONFIGURATION, + FeatureFlags::insetsDecoupledConfiguration); + } + + @Override + + public boolean introduceSmootherDimmer() { + return getValue(Flags.FLAG_INTRODUCE_SMOOTHER_DIMMER, + FeatureFlags::introduceSmootherDimmer); + } + + @Override + + public boolean keyguardAppearTransition() { + return getValue(Flags.FLAG_KEYGUARD_APPEAR_TRANSITION, + FeatureFlags::keyguardAppearTransition); + } + + @Override + + public boolean letterboxBackgroundWallpaper() { + return getValue(Flags.FLAG_LETTERBOX_BACKGROUND_WALLPAPER, + FeatureFlags::letterboxBackgroundWallpaper); + } + + @Override + + public boolean movableCutoutConfiguration() { + return getValue(Flags.FLAG_MOVABLE_CUTOUT_CONFIGURATION, + FeatureFlags::movableCutoutConfiguration); + } + + @Override + + public boolean moveAnimationOptionsToChange() { + return getValue(Flags.FLAG_MOVE_ANIMATION_OPTIONS_TO_CHANGE, + FeatureFlags::moveAnimationOptionsToChange); + } + + @Override + + public boolean multiCrop() { + return getValue(Flags.FLAG_MULTI_CROP, + FeatureFlags::multiCrop); + } + + @Override + + public boolean navBarTransparentByDefault() { + return getValue(Flags.FLAG_NAV_BAR_TRANSPARENT_BY_DEFAULT, + FeatureFlags::navBarTransparentByDefault); + } + + @Override + + public boolean noConsecutiveVisibilityEvents() { + return getValue(Flags.FLAG_NO_CONSECUTIVE_VISIBILITY_EVENTS, + FeatureFlags::noConsecutiveVisibilityEvents); + } + + @Override + + public boolean noVisibilityEventOnDisplayStateChange() { + return getValue(Flags.FLAG_NO_VISIBILITY_EVENT_ON_DISPLAY_STATE_CHANGE, + FeatureFlags::noVisibilityEventOnDisplayStateChange); + } + + @Override + + public boolean offloadColorExtraction() { + return getValue(Flags.FLAG_OFFLOAD_COLOR_EXTRACTION, + FeatureFlags::offloadColorExtraction); + } + + @Override + + public boolean predictiveBackSystemAnims() { + return getValue(Flags.FLAG_PREDICTIVE_BACK_SYSTEM_ANIMS, + FeatureFlags::predictiveBackSystemAnims); + } + + @Override + + public boolean rearDisplayDisableForceDesktopSystemDecorations() { + return getValue(Flags.FLAG_REAR_DISPLAY_DISABLE_FORCE_DESKTOP_SYSTEM_DECORATIONS, + FeatureFlags::rearDisplayDisableForceDesktopSystemDecorations); + } + + @Override + + public boolean releaseSnapshotAggressively() { + return getValue(Flags.FLAG_RELEASE_SNAPSHOT_AGGRESSIVELY, + FeatureFlags::releaseSnapshotAggressively); + } + + @Override + + public boolean removePrepareSurfaceInPlacement() { + return getValue(Flags.FLAG_REMOVE_PREPARE_SURFACE_IN_PLACEMENT, + FeatureFlags::removePrepareSurfaceInPlacement); + } + + @Override + + public boolean screenRecordingCallbacks() { + return getValue(Flags.FLAG_SCREEN_RECORDING_CALLBACKS, + FeatureFlags::screenRecordingCallbacks); + } + + @Override + + public boolean sdkDesiredPresentTime() { + return getValue(Flags.FLAG_SDK_DESIRED_PRESENT_TIME, + FeatureFlags::sdkDesiredPresentTime); + } + + @Override + + public boolean secureWindowState() { + return getValue(Flags.FLAG_SECURE_WINDOW_STATE, + FeatureFlags::secureWindowState); + } + + @Override + + public boolean setScPropertiesInClient() { + return getValue(Flags.FLAG_SET_SC_PROPERTIES_IN_CLIENT, + FeatureFlags::setScPropertiesInClient); + } + + @Override + + public boolean skipSleepingWhenSwitchingDisplay() { + return getValue(Flags.FLAG_SKIP_SLEEPING_WHEN_SWITCHING_DISPLAY, + FeatureFlags::skipSleepingWhenSwitchingDisplay); + } + + @Override + + public boolean supportsMultiInstanceSystemUi() { + return getValue(Flags.FLAG_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI, + FeatureFlags::supportsMultiInstanceSystemUi); + } + + @Override + + public boolean surfaceControlInputReceiver() { + return getValue(Flags.FLAG_SURFACE_CONTROL_INPUT_RECEIVER, + FeatureFlags::surfaceControlInputReceiver); + } + + @Override + + public boolean surfaceTrustedOverlay() { + return getValue(Flags.FLAG_SURFACE_TRUSTED_OVERLAY, + FeatureFlags::surfaceTrustedOverlay); + } + + @Override + + public boolean syncScreenCapture() { + return getValue(Flags.FLAG_SYNC_SCREEN_CAPTURE, + FeatureFlags::syncScreenCapture); + } + + @Override + + public boolean taskFragmentSystemOrganizerFlag() { + return getValue(Flags.FLAG_TASK_FRAGMENT_SYSTEM_ORGANIZER_FLAG, + FeatureFlags::taskFragmentSystemOrganizerFlag); + } + + @Override + + public boolean transitReadyTracking() { + return getValue(Flags.FLAG_TRANSIT_READY_TRACKING, + FeatureFlags::transitReadyTracking); + } + + @Override + + public boolean trustedPresentationListenerForWindow() { + return getValue(Flags.FLAG_TRUSTED_PRESENTATION_LISTENER_FOR_WINDOW, + FeatureFlags::trustedPresentationListenerForWindow); + } + + @Override + + public boolean untrustedEmbeddingAnyAppPermission() { + return getValue(Flags.FLAG_UNTRUSTED_EMBEDDING_ANY_APP_PERMISSION, + FeatureFlags::untrustedEmbeddingAnyAppPermission); + } + + @Override + + public boolean untrustedEmbeddingStateSharing() { + return getValue(Flags.FLAG_UNTRUSTED_EMBEDDING_STATE_SHARING, + FeatureFlags::untrustedEmbeddingStateSharing); + } + + @Override + + public boolean useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds() { + return getValue(Flags.FLAG_USE_WINDOW_ORIGINAL_TOUCHABLE_REGION_WHEN_MAGNIFICATION_RECOMPUTE_BOUNDS, + FeatureFlags::useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds); + } + + @Override + + public boolean userMinAspectRatioAppDefault() { + return getValue(Flags.FLAG_USER_MIN_ASPECT_RATIO_APP_DEFAULT, + FeatureFlags::userMinAspectRatioAppDefault); + } + + @Override + + public boolean waitForTransitionOnDisplaySwitch() { + return getValue(Flags.FLAG_WAIT_FOR_TRANSITION_ON_DISPLAY_SWITCH, + FeatureFlags::waitForTransitionOnDisplaySwitch); + } + + @Override + + public boolean wallpaperOffsetAsync() { + return getValue(Flags.FLAG_WALLPAPER_OFFSET_ASYNC, + FeatureFlags::wallpaperOffsetAsync); + } + + @Override + + public boolean windowSessionRelayoutInfo() { + return getValue(Flags.FLAG_WINDOW_SESSION_RELAYOUT_INFO, + FeatureFlags::windowSessionRelayoutInfo); + } + + @Override + + public boolean windowTokenConfigThreadSafe() { + return getValue(Flags.FLAG_WINDOW_TOKEN_CONFIG_THREAD_SAFE, + FeatureFlags::windowTokenConfigThreadSafe); + } + + public boolean isFlagReadOnlyOptimized(String flagName) { + if (mReadOnlyFlagsSet.contains(flagName) && + isOptimizationEnabled()) { + return true; + } + return false; + } + + private boolean isOptimizationEnabled() { + return false; + } + + protected boolean getValue(String flagName, Predicate getter) { + return mGetValueImpl.test(flagName, getter); + } + + public List getFlagNames() { + return Arrays.asList( + Flags.FLAG_ACTIVITY_EMBEDDING_ANIMATION_CUSTOMIZATION_FLAG, + Flags.FLAG_ACTIVITY_EMBEDDING_INTERACTIVE_DIVIDER_FLAG, + Flags.FLAG_ACTIVITY_EMBEDDING_OVERLAY_PRESENTATION_FLAG, + Flags.FLAG_ACTIVITY_SNAPSHOT_BY_DEFAULT, + Flags.FLAG_ACTIVITY_WINDOW_INFO_FLAG, + Flags.FLAG_ALLOW_DISABLE_ACTIVITY_RECORD_INPUT_SINK, + Flags.FLAG_ALLOW_HIDE_SCM_BUTTON, + Flags.FLAG_ALLOWS_SCREEN_SIZE_DECOUPLED_FROM_STATUS_BAR_AND_CUTOUT, + Flags.FLAG_ALWAYS_DEFER_TRANSITION_WHEN_APPLY_WCT, + Flags.FLAG_ALWAYS_DRAW_MAGNIFICATION_FULLSCREEN_BORDER, + Flags.FLAG_ALWAYS_UPDATE_WALLPAPER_PERMISSION, + Flags.FLAG_APP_COMPAT_PROPERTIES_API, + Flags.FLAG_APP_COMPAT_REFACTORING, + Flags.FLAG_BAL_DONT_BRING_EXISTING_BACKGROUND_TASK_STACK_TO_FG, + Flags.FLAG_BAL_IMPROVE_REAL_CALLER_VISIBILITY_CHECK, + Flags.FLAG_BAL_IMPROVED_METRICS, + Flags.FLAG_BAL_REQUIRE_OPT_IN_BY_PENDING_INTENT_CREATOR, + Flags.FLAG_BAL_REQUIRE_OPT_IN_SAME_UID, + Flags.FLAG_BAL_RESPECT_APP_SWITCH_STATE_WHEN_CHECK_BOUND_BY_FOREGROUND_UID, + Flags.FLAG_BAL_SHOW_TOASTS, + Flags.FLAG_BAL_SHOW_TOASTS_BLOCKED, + Flags.FLAG_BLAST_SYNC_NOTIFICATION_SHADE_ON_DISPLAY_SWITCH, + Flags.FLAG_BUNDLE_CLIENT_TRANSACTION_FLAG, + Flags.FLAG_CAMERA_COMPAT_FOR_FREEFORM, + Flags.FLAG_CLOSE_TO_SQUARE_CONFIG_INCLUDES_STATUS_BAR, + Flags.FLAG_CONFIGURABLE_FONT_SCALE_DEFAULT, + Flags.FLAG_COVER_DISPLAY_OPT_IN, + Flags.FLAG_DEFER_DISPLAY_UPDATES, + Flags.FLAG_DELAY_NOTIFICATION_TO_MAGNIFICATION_WHEN_RECENTS_WINDOW_TO_FRONT_TRANSITION, + Flags.FLAG_DELEGATE_UNHANDLED_DRAGS, + Flags.FLAG_DELETE_CAPTURE_DISPLAY, + Flags.FLAG_DENSITY_390_API, + Flags.FLAG_DISABLE_OBJECT_POOL, + Flags.FLAG_DISABLE_THIN_LETTERBOXING_POLICY, + Flags.FLAG_DO_NOT_CHECK_INTERSECTION_WHEN_NON_MAGNIFIABLE_WINDOW_TRANSITIONS, + Flags.FLAG_DRAW_SNAPSHOT_ASPECT_RATIO_MATCH, + Flags.FLAG_EDGE_TO_EDGE_BY_DEFAULT, + Flags.FLAG_EMBEDDED_ACTIVITY_BACK_NAV_FLAG, + Flags.FLAG_ENABLE_ADDITIONAL_WINDOWS_ABOVE_STATUS_BAR, + Flags.FLAG_ENABLE_APP_HEADER_WITH_TASK_DENSITY, + Flags.FLAG_ENABLE_BUFFER_TRANSFORM_HINT_FROM_DISPLAY, + Flags.FLAG_ENABLE_CAMERA_COMPAT_FOR_DESKTOP_WINDOWING, + Flags.FLAG_ENABLE_COMPATUI_SYSUI_LAUNCHER, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_IMMERSIVE_HANDLE_HIDING, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODALS_POLICY, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODE, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_QUICK_SWITCH, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_SCVH_CACHE, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_SIZE_CONSTRAINTS, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_TASK_LIMIT, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_TASKBAR_RUNNING_APPS, + Flags.FLAG_ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY, + Flags.FLAG_ENABLE_SCALED_RESIZING, + Flags.FLAG_ENABLE_TASK_STACK_OBSERVER_IN_SHELL, + Flags.FLAG_ENABLE_THEMED_APP_HEADERS, + Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS, + Flags.FLAG_ENABLE_WINDOWING_EDGE_DRAG_RESIZE, + Flags.FLAG_ENABLE_WM_EXTENSIONS_FOR_ALL_FLAG, + Flags.FLAG_ENFORCE_EDGE_TO_EDGE, + Flags.FLAG_ENSURE_WALLPAPER_IN_TRANSITIONS, + Flags.FLAG_EXPLICIT_REFRESH_RATE_HINTS, + Flags.FLAG_FIFO_PRIORITY_FOR_MAJOR_UI_PROCESSES, + Flags.FLAG_FIX_NO_CONTAINER_UPDATE_WITHOUT_RESIZE, + Flags.FLAG_FIX_PIP_RESTORE_TO_OVERLAY, + Flags.FLAG_FULLSCREEN_DIM_FLAG, + Flags.FLAG_GET_DIMMER_ON_CLOSING, + Flags.FLAG_IMMERSIVE_APP_REPOSITIONING, + Flags.FLAG_INSETS_CONTROL_CHANGED_ITEM, + Flags.FLAG_INSETS_CONTROL_SEQ, + Flags.FLAG_INSETS_DECOUPLED_CONFIGURATION, + Flags.FLAG_INTRODUCE_SMOOTHER_DIMMER, + Flags.FLAG_KEYGUARD_APPEAR_TRANSITION, + Flags.FLAG_LETTERBOX_BACKGROUND_WALLPAPER, + Flags.FLAG_MOVABLE_CUTOUT_CONFIGURATION, + Flags.FLAG_MOVE_ANIMATION_OPTIONS_TO_CHANGE, + Flags.FLAG_MULTI_CROP, + Flags.FLAG_NAV_BAR_TRANSPARENT_BY_DEFAULT, + Flags.FLAG_NO_CONSECUTIVE_VISIBILITY_EVENTS, + Flags.FLAG_NO_VISIBILITY_EVENT_ON_DISPLAY_STATE_CHANGE, + Flags.FLAG_OFFLOAD_COLOR_EXTRACTION, + Flags.FLAG_PREDICTIVE_BACK_SYSTEM_ANIMS, + Flags.FLAG_REAR_DISPLAY_DISABLE_FORCE_DESKTOP_SYSTEM_DECORATIONS, + Flags.FLAG_RELEASE_SNAPSHOT_AGGRESSIVELY, + Flags.FLAG_REMOVE_PREPARE_SURFACE_IN_PLACEMENT, + Flags.FLAG_SCREEN_RECORDING_CALLBACKS, + Flags.FLAG_SDK_DESIRED_PRESENT_TIME, + Flags.FLAG_SECURE_WINDOW_STATE, + Flags.FLAG_SET_SC_PROPERTIES_IN_CLIENT, + Flags.FLAG_SKIP_SLEEPING_WHEN_SWITCHING_DISPLAY, + Flags.FLAG_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI, + Flags.FLAG_SURFACE_CONTROL_INPUT_RECEIVER, + Flags.FLAG_SURFACE_TRUSTED_OVERLAY, + Flags.FLAG_SYNC_SCREEN_CAPTURE, + Flags.FLAG_TASK_FRAGMENT_SYSTEM_ORGANIZER_FLAG, + Flags.FLAG_TRANSIT_READY_TRACKING, + Flags.FLAG_TRUSTED_PRESENTATION_LISTENER_FOR_WINDOW, + Flags.FLAG_UNTRUSTED_EMBEDDING_ANY_APP_PERMISSION, + Flags.FLAG_UNTRUSTED_EMBEDDING_STATE_SHARING, + Flags.FLAG_USE_WINDOW_ORIGINAL_TOUCHABLE_REGION_WHEN_MAGNIFICATION_RECOMPUTE_BOUNDS, + Flags.FLAG_USER_MIN_ASPECT_RATIO_APP_DEFAULT, + Flags.FLAG_WAIT_FOR_TRANSITION_ON_DISPLAY_SWITCH, + Flags.FLAG_WALLPAPER_OFFSET_ASYNC, + Flags.FLAG_WINDOW_SESSION_RELAYOUT_INFO, + Flags.FLAG_WINDOW_TOKEN_CONFIG_THREAD_SAFE + ); + } + + private Set mReadOnlyFlagsSet = new HashSet<>( + Arrays.asList( + Flags.FLAG_ACTIVITY_SNAPSHOT_BY_DEFAULT, + Flags.FLAG_ACTIVITY_WINDOW_INFO_FLAG, + Flags.FLAG_ALLOW_DISABLE_ACTIVITY_RECORD_INPUT_SINK, + Flags.FLAG_ALLOWS_SCREEN_SIZE_DECOUPLED_FROM_STATUS_BAR_AND_CUTOUT, + Flags.FLAG_APP_COMPAT_PROPERTIES_API, + Flags.FLAG_APP_COMPAT_REFACTORING, + Flags.FLAG_BUNDLE_CLIENT_TRANSACTION_FLAG, + Flags.FLAG_CAMERA_COMPAT_FOR_FREEFORM, + Flags.FLAG_CONFIGURABLE_FONT_SCALE_DEFAULT, + Flags.FLAG_COVER_DISPLAY_OPT_IN, + Flags.FLAG_DEFER_DISPLAY_UPDATES, + Flags.FLAG_DELEGATE_UNHANDLED_DRAGS, + Flags.FLAG_DELETE_CAPTURE_DISPLAY, + Flags.FLAG_DENSITY_390_API, + Flags.FLAG_DISABLE_OBJECT_POOL, + Flags.FLAG_DRAW_SNAPSHOT_ASPECT_RATIO_MATCH, + Flags.FLAG_ENABLE_BUFFER_TRANSFORM_HINT_FROM_DISPLAY, + Flags.FLAG_ENABLE_SCALED_RESIZING, + Flags.FLAG_ENABLE_WM_EXTENSIONS_FOR_ALL_FLAG, + Flags.FLAG_ENFORCE_EDGE_TO_EDGE, + Flags.FLAG_EXPLICIT_REFRESH_RATE_HINTS, + Flags.FLAG_FIFO_PRIORITY_FOR_MAJOR_UI_PROCESSES, + Flags.FLAG_FIX_NO_CONTAINER_UPDATE_WITHOUT_RESIZE, + Flags.FLAG_GET_DIMMER_ON_CLOSING, + Flags.FLAG_INSETS_CONTROL_SEQ, + Flags.FLAG_INSETS_DECOUPLED_CONFIGURATION, + Flags.FLAG_INTRODUCE_SMOOTHER_DIMMER, + Flags.FLAG_KEYGUARD_APPEAR_TRANSITION, + Flags.FLAG_MOVABLE_CUTOUT_CONFIGURATION, + Flags.FLAG_REAR_DISPLAY_DISABLE_FORCE_DESKTOP_SYSTEM_DECORATIONS, + Flags.FLAG_RELEASE_SNAPSHOT_AGGRESSIVELY, + Flags.FLAG_REMOVE_PREPARE_SURFACE_IN_PLACEMENT, + Flags.FLAG_SCREEN_RECORDING_CALLBACKS, + Flags.FLAG_SDK_DESIRED_PRESENT_TIME, + Flags.FLAG_SECURE_WINDOW_STATE, + Flags.FLAG_SET_SC_PROPERTIES_IN_CLIENT, + Flags.FLAG_SKIP_SLEEPING_WHEN_SWITCHING_DISPLAY, + Flags.FLAG_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI, + Flags.FLAG_SURFACE_CONTROL_INPUT_RECEIVER, + Flags.FLAG_SURFACE_TRUSTED_OVERLAY, + Flags.FLAG_SYNC_SCREEN_CAPTURE, + Flags.FLAG_TRUSTED_PRESENTATION_LISTENER_FOR_WINDOW, + Flags.FLAG_UNTRUSTED_EMBEDDING_ANY_APP_PERMISSION, + Flags.FLAG_UNTRUSTED_EMBEDDING_STATE_SHARING, + Flags.FLAG_WALLPAPER_OFFSET_ASYNC, + Flags.FLAG_WINDOW_SESSION_RELAYOUT_INFO, + "" + ) + ); +} diff --git a/flags/src/com/android/window/flags/FakeFeatureFlagsImpl.java b/flags/src/com/android/window/flags/FakeFeatureFlagsImpl.java new file mode 100644 index 0000000000..de7588f881 --- /dev/null +++ b/flags/src/com/android/window/flags/FakeFeatureFlagsImpl.java @@ -0,0 +1,49 @@ +package com.android.window.flags; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.Predicate; + +/** @hide */ +public class FakeFeatureFlagsImpl extends CustomFeatureFlags { + private final Map mFlagMap = new HashMap<>(); + private final FeatureFlags mDefaults; + + public FakeFeatureFlagsImpl() { + this(null); + } + + public FakeFeatureFlagsImpl(FeatureFlags defaults) { + super(null); + mDefaults = defaults; + // Initialize the map with null values + for (String flagName : getFlagNames()) { + mFlagMap.put(flagName, null); + } + } + + @Override + protected boolean getValue(String flagName, Predicate getter) { + Boolean value = this.mFlagMap.get(flagName); + if (value != null) { + return value; + } + if (mDefaults != null) { + return getter.test(mDefaults); + } + throw new IllegalArgumentException(flagName + " is not set"); + } + + public void setFlag(String flagName, boolean value) { + if (!this.mFlagMap.containsKey(flagName)) { + throw new IllegalArgumentException("no such flag " + flagName); + } + this.mFlagMap.put(flagName, value); + } + + public void resetAll() { + for (Map.Entry entry : mFlagMap.entrySet()) { + entry.setValue(null); + } + } +} diff --git a/flags/src/com/android/window/flags/FeatureFlags.java b/flags/src/com/android/window/flags/FeatureFlags.java new file mode 100644 index 0000000000..49b9dfbf35 --- /dev/null +++ b/flags/src/com/android/window/flags/FeatureFlags.java @@ -0,0 +1,214 @@ +package com.android.window.flags; +// TODO(b/303773055): Remove the annotation after access issue is resolved. +/** @hide */ +public interface FeatureFlags { + + + boolean activityEmbeddingAnimationCustomizationFlag(); + + boolean activityEmbeddingInteractiveDividerFlag(); + + boolean activityEmbeddingOverlayPresentationFlag(); + + boolean activitySnapshotByDefault(); + + boolean activityWindowInfoFlag(); + + boolean allowDisableActivityRecordInputSink(); + + boolean allowHideScmButton(); + + boolean allowsScreenSizeDecoupledFromStatusBarAndCutout(); + + boolean alwaysDeferTransitionWhenApplyWct(); + + boolean alwaysDrawMagnificationFullscreenBorder(); + + boolean alwaysUpdateWallpaperPermission(); + + boolean appCompatPropertiesApi(); + + boolean appCompatRefactoring(); + + boolean balDontBringExistingBackgroundTaskStackToFg(); + + boolean balImproveRealCallerVisibilityCheck(); + + boolean balImprovedMetrics(); + + boolean balRequireOptInByPendingIntentCreator(); + + boolean balRequireOptInSameUid(); + + boolean balRespectAppSwitchStateWhenCheckBoundByForegroundUid(); + + boolean balShowToasts(); + + boolean balShowToastsBlocked(); + + boolean blastSyncNotificationShadeOnDisplaySwitch(); + + boolean bundleClientTransactionFlag(); + + boolean cameraCompatForFreeform(); + + boolean closeToSquareConfigIncludesStatusBar(); + + boolean configurableFontScaleDefault(); + + boolean coverDisplayOptIn(); + + boolean deferDisplayUpdates(); + + boolean delayNotificationToMagnificationWhenRecentsWindowToFrontTransition(); + + boolean delegateUnhandledDrags(); + + boolean deleteCaptureDisplay(); + + boolean density390Api(); + + boolean disableObjectPool(); + + boolean disableThinLetterboxingPolicy(); + + boolean doNotCheckIntersectionWhenNonMagnifiableWindowTransitions(); + + boolean drawSnapshotAspectRatioMatch(); + + boolean edgeToEdgeByDefault(); + + boolean embeddedActivityBackNavFlag(); + + boolean enableAdditionalWindowsAboveStatusBar(); + + boolean enableAppHeaderWithTaskDensity(); + + boolean enableBufferTransformHintFromDisplay(); + + boolean enableCameraCompatForDesktopWindowing(); + + boolean enableCompatuiSysuiLauncher(); + + boolean enableDesktopWindowingImmersiveHandleHiding(); + + boolean enableDesktopWindowingModalsPolicy(); + + boolean enableDesktopWindowingMode(); + + boolean enableDesktopWindowingQuickSwitch(); + + boolean enableDesktopWindowingScvhCache(); + + boolean enableDesktopWindowingSizeConstraints(); + + boolean enableDesktopWindowingTaskLimit(); + + boolean enableDesktopWindowingTaskbarRunningApps(); + + boolean enableDesktopWindowingWallpaperActivity(); + + boolean enableScaledResizing(); + + boolean enableTaskStackObserverInShell(); + + boolean enableThemedAppHeaders(); + + boolean enableWindowingDynamicInitialBounds(); + + boolean enableWindowingEdgeDragResize(); + + boolean enableWmExtensionsForAllFlag(); + + boolean enforceEdgeToEdge(); + + boolean ensureWallpaperInTransitions(); + + boolean explicitRefreshRateHints(); + + boolean fifoPriorityForMajorUiProcesses(); + + boolean fixNoContainerUpdateWithoutResize(); + + boolean fixPipRestoreToOverlay(); + + boolean fullscreenDimFlag(); + + boolean getDimmerOnClosing(); + + boolean immersiveAppRepositioning(); + + boolean insetsControlChangedItem(); + + boolean insetsControlSeq(); + + boolean insetsDecoupledConfiguration(); + + boolean introduceSmootherDimmer(); + + boolean keyguardAppearTransition(); + + boolean letterboxBackgroundWallpaper(); + + boolean movableCutoutConfiguration(); + + boolean moveAnimationOptionsToChange(); + + boolean multiCrop(); + + boolean navBarTransparentByDefault(); + + boolean noConsecutiveVisibilityEvents(); + + boolean noVisibilityEventOnDisplayStateChange(); + + boolean offloadColorExtraction(); + + boolean predictiveBackSystemAnims(); + + boolean rearDisplayDisableForceDesktopSystemDecorations(); + + boolean releaseSnapshotAggressively(); + + boolean removePrepareSurfaceInPlacement(); + + boolean screenRecordingCallbacks(); + + boolean sdkDesiredPresentTime(); + + boolean secureWindowState(); + + boolean setScPropertiesInClient(); + + boolean skipSleepingWhenSwitchingDisplay(); + + boolean supportsMultiInstanceSystemUi(); + + boolean surfaceControlInputReceiver(); + + boolean surfaceTrustedOverlay(); + + boolean syncScreenCapture(); + + boolean taskFragmentSystemOrganizerFlag(); + + boolean transitReadyTracking(); + + boolean trustedPresentationListenerForWindow(); + + boolean untrustedEmbeddingAnyAppPermission(); + + boolean untrustedEmbeddingStateSharing(); + + boolean useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds(); + + boolean userMinAspectRatioAppDefault(); + + boolean waitForTransitionOnDisplaySwitch(); + + boolean wallpaperOffsetAsync(); + + boolean windowSessionRelayoutInfo(); + + boolean windowTokenConfigThreadSafe(); +} diff --git a/flags/src/com/android/window/flags/FeatureFlagsImpl.java b/flags/src/com/android/window/flags/FeatureFlagsImpl.java new file mode 100644 index 0000000000..577e7aa4d5 --- /dev/null +++ b/flags/src/com/android/window/flags/FeatureFlagsImpl.java @@ -0,0 +1,1638 @@ +package com.android.window.flags; +// TODO(b/303773055): Remove the annotation after access issue is resolved. + +import com.android.quickstep.util.DeviceConfigHelper; + +import java.nio.file.Files; +import java.nio.file.Paths; +/** @hide */ +public final class FeatureFlagsImpl implements FeatureFlags { + private static final boolean isReadFromNew = Files.exists(Paths.get("/metadata/aconfig/boot/enable_only_new_storage")); + private static volatile boolean isCached = false; + private static volatile boolean accessibility_is_cached = false; + private static volatile boolean large_screen_experiences_app_compat_is_cached = false; + private static volatile boolean lse_desktop_experience_is_cached = false; + private static volatile boolean multitasking_is_cached = false; + private static volatile boolean responsible_apis_is_cached = false; + private static volatile boolean systemui_is_cached = false; + private static volatile boolean wear_frameworks_is_cached = false; + private static volatile boolean window_surfaces_is_cached = false; + private static volatile boolean windowing_frontend_is_cached = false; + private static volatile boolean windowing_sdk_is_cached = false; + private static boolean activityEmbeddingAnimationCustomizationFlag = false; + private static boolean activityEmbeddingInteractiveDividerFlag = true; + private static boolean activityEmbeddingOverlayPresentationFlag = true; + private static boolean allowHideScmButton = true; + private static boolean alwaysDeferTransitionWhenApplyWct = true; + private static boolean alwaysDrawMagnificationFullscreenBorder = true; + private static boolean alwaysUpdateWallpaperPermission = true; + private static boolean balDontBringExistingBackgroundTaskStackToFg = true; + private static boolean balImproveRealCallerVisibilityCheck = true; + private static boolean balImprovedMetrics = true; + private static boolean balRequireOptInByPendingIntentCreator = true; + private static boolean balRequireOptInSameUid = false; + private static boolean balRespectAppSwitchStateWhenCheckBoundByForegroundUid = true; + private static boolean balShowToasts = false; + private static boolean balShowToastsBlocked = true; + private static boolean blastSyncNotificationShadeOnDisplaySwitch = true; + private static boolean closeToSquareConfigIncludesStatusBar = false; + private static boolean delayNotificationToMagnificationWhenRecentsWindowToFrontTransition = true; + private static boolean disableThinLetterboxingPolicy = true; + private static boolean doNotCheckIntersectionWhenNonMagnifiableWindowTransitions = true; + private static boolean edgeToEdgeByDefault = false; + private static boolean embeddedActivityBackNavFlag = true; + private static boolean enableAdditionalWindowsAboveStatusBar = false; + private static boolean enableAppHeaderWithTaskDensity = true; + private static boolean enableCameraCompatForDesktopWindowing = true; + private static boolean enableCompatuiSysuiLauncher = false; + private static boolean enableDesktopWindowingImmersiveHandleHiding = false; + private static boolean enableDesktopWindowingModalsPolicy = true; + private static boolean enableDesktopWindowingMode = false; + private static boolean enableDesktopWindowingQuickSwitch = false; + private static boolean enableDesktopWindowingScvhCache = false; + private static boolean enableDesktopWindowingSizeConstraints = false; + private static boolean enableDesktopWindowingTaskLimit = true; + private static boolean enableDesktopWindowingTaskbarRunningApps = true; + private static boolean enableDesktopWindowingWallpaperActivity = false; + private static boolean enableTaskStackObserverInShell = true; + private static boolean enableThemedAppHeaders = true; + private static boolean enableWindowingDynamicInitialBounds = false; + private static boolean enableWindowingEdgeDragResize = false; + private static boolean ensureWallpaperInTransitions = false; + private static boolean fixPipRestoreToOverlay = true; + private static boolean fullscreenDimFlag = true; + private static boolean immersiveAppRepositioning = true; + private static boolean insetsControlChangedItem = false; + private static boolean letterboxBackgroundWallpaper = false; + private static boolean moveAnimationOptionsToChange = true; + private static boolean multiCrop = true; + private static boolean navBarTransparentByDefault = true; + private static boolean noConsecutiveVisibilityEvents = true; + private static boolean noVisibilityEventOnDisplayStateChange = true; + private static boolean offloadColorExtraction = false; + private static boolean predictiveBackSystemAnims = true; + private static boolean taskFragmentSystemOrganizerFlag = true; + private static boolean transitReadyTracking = false; + private static boolean useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds = true; + private static boolean userMinAspectRatioAppDefault = true; + private static boolean waitForTransitionOnDisplaySwitch = true; + private static boolean windowTokenConfigThreadSafe = true; + + + private void init() { + isCached = true; + } + + + + + private void load_overrides_accessibility() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + alwaysDrawMagnificationFullscreenBorder = + properties.getBoolean(Flags.FLAG_ALWAYS_DRAW_MAGNIFICATION_FULLSCREEN_BORDER, true); + delayNotificationToMagnificationWhenRecentsWindowToFrontTransition = + properties.getBoolean(Flags.FLAG_DELAY_NOTIFICATION_TO_MAGNIFICATION_WHEN_RECENTS_WINDOW_TO_FRONT_TRANSITION, true); + doNotCheckIntersectionWhenNonMagnifiableWindowTransitions = + properties.getBoolean(Flags.FLAG_DO_NOT_CHECK_INTERSECTION_WHEN_NON_MAGNIFIABLE_WINDOW_TRANSITIONS, true); + useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds = + properties.getBoolean(Flags.FLAG_USE_WINDOW_ORIGINAL_TOUCHABLE_REGION_WHEN_MAGNIFICATION_RECOMPUTE_BOUNDS, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace accessibility " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + accessibility_is_cached = true; + } + + private void load_overrides_large_screen_experiences_app_compat() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + allowHideScmButton = + properties.getBoolean(Flags.FLAG_ALLOW_HIDE_SCM_BUTTON, true); + disableThinLetterboxingPolicy = + properties.getBoolean(Flags.FLAG_DISABLE_THIN_LETTERBOXING_POLICY, true); + enableCompatuiSysuiLauncher = + properties.getBoolean(Flags.FLAG_ENABLE_COMPATUI_SYSUI_LAUNCHER, false); + immersiveAppRepositioning = + properties.getBoolean(Flags.FLAG_IMMERSIVE_APP_REPOSITIONING, true); + letterboxBackgroundWallpaper = + properties.getBoolean(Flags.FLAG_LETTERBOX_BACKGROUND_WALLPAPER, false); + userMinAspectRatioAppDefault = + properties.getBoolean(Flags.FLAG_USER_MIN_ASPECT_RATIO_APP_DEFAULT, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace large_screen_experiences_app_compat " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + large_screen_experiences_app_compat_is_cached = true; + } + + private void load_overrides_lse_desktop_experience() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + enableAdditionalWindowsAboveStatusBar = + properties.getBoolean(Flags.FLAG_ENABLE_ADDITIONAL_WINDOWS_ABOVE_STATUS_BAR, false); + enableAppHeaderWithTaskDensity = + properties.getBoolean(Flags.FLAG_ENABLE_APP_HEADER_WITH_TASK_DENSITY, true); + enableCameraCompatForDesktopWindowing = + properties.getBoolean(Flags.FLAG_ENABLE_CAMERA_COMPAT_FOR_DESKTOP_WINDOWING, true); + enableDesktopWindowingImmersiveHandleHiding = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_IMMERSIVE_HANDLE_HIDING, false); + enableDesktopWindowingModalsPolicy = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODALS_POLICY, true); + enableDesktopWindowingMode = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODE, true); + enableDesktopWindowingQuickSwitch = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_QUICK_SWITCH, false); + enableDesktopWindowingScvhCache = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_SCVH_CACHE, false); + enableDesktopWindowingSizeConstraints = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_SIZE_CONSTRAINTS, false); + enableDesktopWindowingTaskLimit = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_TASK_LIMIT, true); + enableDesktopWindowingTaskbarRunningApps = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_TASKBAR_RUNNING_APPS, true); + enableDesktopWindowingWallpaperActivity = + properties.getBoolean(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY, false); + enableTaskStackObserverInShell = + properties.getBoolean(Flags.FLAG_ENABLE_TASK_STACK_OBSERVER_IN_SHELL, true); + enableThemedAppHeaders = + properties.getBoolean(Flags.FLAG_ENABLE_THEMED_APP_HEADERS, true); + enableWindowingDynamicInitialBounds = + properties.getBoolean(Flags.FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS, false); + enableWindowingEdgeDragResize = + properties.getBoolean(Flags.FLAG_ENABLE_WINDOWING_EDGE_DRAG_RESIZE, false); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace lse_desktop_experience " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + lse_desktop_experience_is_cached = true; + } + + private void load_overrides_multitasking() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace multitasking " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + multitasking_is_cached = true; + } + + private void load_overrides_responsible_apis() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + balDontBringExistingBackgroundTaskStackToFg = + properties.getBoolean(Flags.FLAG_BAL_DONT_BRING_EXISTING_BACKGROUND_TASK_STACK_TO_FG, true); + balImproveRealCallerVisibilityCheck = + properties.getBoolean(Flags.FLAG_BAL_IMPROVE_REAL_CALLER_VISIBILITY_CHECK, true); + balImprovedMetrics = + properties.getBoolean(Flags.FLAG_BAL_IMPROVED_METRICS, true); + balRequireOptInByPendingIntentCreator = + properties.getBoolean(Flags.FLAG_BAL_REQUIRE_OPT_IN_BY_PENDING_INTENT_CREATOR, true); + balRequireOptInSameUid = + properties.getBoolean(Flags.FLAG_BAL_REQUIRE_OPT_IN_SAME_UID, false); + balRespectAppSwitchStateWhenCheckBoundByForegroundUid = + properties.getBoolean(Flags.FLAG_BAL_RESPECT_APP_SWITCH_STATE_WHEN_CHECK_BOUND_BY_FOREGROUND_UID, true); + balShowToasts = + properties.getBoolean(Flags.FLAG_BAL_SHOW_TOASTS, false); + balShowToastsBlocked = + properties.getBoolean(Flags.FLAG_BAL_SHOW_TOASTS_BLOCKED, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace responsible_apis " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + responsible_apis_is_cached = true; + } + + private void load_overrides_systemui() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + multiCrop = + properties.getBoolean(Flags.FLAG_MULTI_CROP, true); + noConsecutiveVisibilityEvents = + properties.getBoolean(Flags.FLAG_NO_CONSECUTIVE_VISIBILITY_EVENTS, true); + offloadColorExtraction = + properties.getBoolean(Flags.FLAG_OFFLOAD_COLOR_EXTRACTION, false); + predictiveBackSystemAnims = + properties.getBoolean(Flags.FLAG_PREDICTIVE_BACK_SYSTEM_ANIMS, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace systemui " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + systemui_is_cached = true; + } + + private void load_overrides_wear_frameworks() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + alwaysUpdateWallpaperPermission = + properties.getBoolean(Flags.FLAG_ALWAYS_UPDATE_WALLPAPER_PERMISSION, true); + noVisibilityEventOnDisplayStateChange = + properties.getBoolean(Flags.FLAG_NO_VISIBILITY_EVENT_ON_DISPLAY_STATE_CHANGE, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace wear_frameworks " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + wear_frameworks_is_cached = true; + } + + private void load_overrides_window_surfaces() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace window_surfaces " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + window_surfaces_is_cached = true; + } + + private void load_overrides_windowing_frontend() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + blastSyncNotificationShadeOnDisplaySwitch = + properties.getBoolean(Flags.FLAG_BLAST_SYNC_NOTIFICATION_SHADE_ON_DISPLAY_SWITCH, true); + closeToSquareConfigIncludesStatusBar = + properties.getBoolean(Flags.FLAG_CLOSE_TO_SQUARE_CONFIG_INCLUDES_STATUS_BAR, false); + edgeToEdgeByDefault = + properties.getBoolean(Flags.FLAG_EDGE_TO_EDGE_BY_DEFAULT, false); + ensureWallpaperInTransitions = + properties.getBoolean(Flags.FLAG_ENSURE_WALLPAPER_IN_TRANSITIONS, false); + navBarTransparentByDefault = + properties.getBoolean(Flags.FLAG_NAV_BAR_TRANSPARENT_BY_DEFAULT, true); + transitReadyTracking = + properties.getBoolean(Flags.FLAG_TRANSIT_READY_TRACKING, false); + waitForTransitionOnDisplaySwitch = + properties.getBoolean(Flags.FLAG_WAIT_FOR_TRANSITION_ON_DISPLAY_SWITCH, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace windowing_frontend " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + windowing_frontend_is_cached = true; + } + + private void load_overrides_windowing_sdk() { + try { + var properties = DeviceConfigHelper.Companion.getPrefs(); + activityEmbeddingAnimationCustomizationFlag = + properties.getBoolean(Flags.FLAG_ACTIVITY_EMBEDDING_ANIMATION_CUSTOMIZATION_FLAG, false); + activityEmbeddingInteractiveDividerFlag = + properties.getBoolean(Flags.FLAG_ACTIVITY_EMBEDDING_INTERACTIVE_DIVIDER_FLAG, true); + activityEmbeddingOverlayPresentationFlag = + properties.getBoolean(Flags.FLAG_ACTIVITY_EMBEDDING_OVERLAY_PRESENTATION_FLAG, true); + alwaysDeferTransitionWhenApplyWct = + properties.getBoolean(Flags.FLAG_ALWAYS_DEFER_TRANSITION_WHEN_APPLY_WCT, true); + embeddedActivityBackNavFlag = + properties.getBoolean(Flags.FLAG_EMBEDDED_ACTIVITY_BACK_NAV_FLAG, true); + fixPipRestoreToOverlay = + properties.getBoolean(Flags.FLAG_FIX_PIP_RESTORE_TO_OVERLAY, true); + fullscreenDimFlag = + properties.getBoolean(Flags.FLAG_FULLSCREEN_DIM_FLAG, true); + insetsControlChangedItem = + properties.getBoolean(Flags.FLAG_INSETS_CONTROL_CHANGED_ITEM, false); + moveAnimationOptionsToChange = + properties.getBoolean(Flags.FLAG_MOVE_ANIMATION_OPTIONS_TO_CHANGE, true); + taskFragmentSystemOrganizerFlag = + properties.getBoolean(Flags.FLAG_TASK_FRAGMENT_SYSTEM_ORGANIZER_FLAG, true); + windowTokenConfigThreadSafe = + properties.getBoolean(Flags.FLAG_WINDOW_TOKEN_CONFIG_THREAD_SAFE, true); + } catch (NullPointerException e) { + throw new RuntimeException( + "Cannot read value from namespace windowing_sdk " + + "from DeviceConfig. It could be that the code using flag " + + "executed before SettingsProvider initialization. Please use " + + "fixed read-only flag by adding is_fixed_read_only: true in " + + "flag declaration.", + e + ); + } catch (SecurityException e) { + // for isolated process case, skip loading flag value from the storage, use the default + } + windowing_sdk_is_cached = true; + } + + @Override + + public boolean activityEmbeddingAnimationCustomizationFlag() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return activityEmbeddingAnimationCustomizationFlag; + + } + + @Override + + public boolean activityEmbeddingInteractiveDividerFlag() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return activityEmbeddingInteractiveDividerFlag; + + } + + @Override + + public boolean activityEmbeddingOverlayPresentationFlag() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return activityEmbeddingOverlayPresentationFlag; + + } + + @Override + + public boolean activitySnapshotByDefault() { + return true; + + } + + @Override + + public boolean activityWindowInfoFlag() { + return true; + + } + + @Override + + public boolean allowDisableActivityRecordInputSink() { + return true; + + } + + @Override + + public boolean allowHideScmButton() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!large_screen_experiences_app_compat_is_cached) { + load_overrides_large_screen_experiences_app_compat(); + } + } + return allowHideScmButton; + + } + + @Override + + public boolean allowsScreenSizeDecoupledFromStatusBarAndCutout() { + return true; + + } + + @Override + + public boolean alwaysDeferTransitionWhenApplyWct() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return alwaysDeferTransitionWhenApplyWct; + + } + + @Override + + public boolean alwaysDrawMagnificationFullscreenBorder() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!accessibility_is_cached) { + load_overrides_accessibility(); + } + } + return alwaysDrawMagnificationFullscreenBorder; + + } + + @Override + + public boolean alwaysUpdateWallpaperPermission() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!wear_frameworks_is_cached) { + load_overrides_wear_frameworks(); + } + } + return alwaysUpdateWallpaperPermission; + + } + + @Override + + public boolean appCompatPropertiesApi() { + return true; + + } + + @Override + + public boolean appCompatRefactoring() { + return false; + + } + + @Override + + public boolean balDontBringExistingBackgroundTaskStackToFg() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balDontBringExistingBackgroundTaskStackToFg; + + } + + @Override + + public boolean balImproveRealCallerVisibilityCheck() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balImproveRealCallerVisibilityCheck; + + } + + @Override + + public boolean balImprovedMetrics() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balImprovedMetrics; + + } + + @Override + + public boolean balRequireOptInByPendingIntentCreator() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balRequireOptInByPendingIntentCreator; + + } + + @Override + + public boolean balRequireOptInSameUid() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balRequireOptInSameUid; + + } + + @Override + + public boolean balRespectAppSwitchStateWhenCheckBoundByForegroundUid() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balRespectAppSwitchStateWhenCheckBoundByForegroundUid; + + } + + @Override + + public boolean balShowToasts() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balShowToasts; + + } + + @Override + + public boolean balShowToastsBlocked() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!responsible_apis_is_cached) { + load_overrides_responsible_apis(); + } + } + return balShowToastsBlocked; + + } + + @Override + + public boolean blastSyncNotificationShadeOnDisplaySwitch() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return blastSyncNotificationShadeOnDisplaySwitch; + + } + + @Override + + public boolean bundleClientTransactionFlag() { + return true; + + } + + @Override + + public boolean cameraCompatForFreeform() { + return true; + + } + + @Override + + public boolean closeToSquareConfigIncludesStatusBar() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return closeToSquareConfigIncludesStatusBar; + + } + + @Override + + public boolean configurableFontScaleDefault() { + return true; + + } + + @Override + + public boolean coverDisplayOptIn() { + return true; + + } + + @Override + + public boolean deferDisplayUpdates() { + return true; + + } + + @Override + + public boolean delayNotificationToMagnificationWhenRecentsWindowToFrontTransition() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!accessibility_is_cached) { + load_overrides_accessibility(); + } + } + return delayNotificationToMagnificationWhenRecentsWindowToFrontTransition; + + } + + @Override + + public boolean delegateUnhandledDrags() { + return true; + + } + + @Override + + public boolean deleteCaptureDisplay() { + return true; + + } + + @Override + + public boolean density390Api() { + return true; + + } + + @Override + + public boolean disableObjectPool() { + return true; + + } + + @Override + + public boolean disableThinLetterboxingPolicy() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!large_screen_experiences_app_compat_is_cached) { + load_overrides_large_screen_experiences_app_compat(); + } + } + return disableThinLetterboxingPolicy; + + } + + @Override + + public boolean doNotCheckIntersectionWhenNonMagnifiableWindowTransitions() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!accessibility_is_cached) { + load_overrides_accessibility(); + } + } + return doNotCheckIntersectionWhenNonMagnifiableWindowTransitions; + + } + + @Override + + public boolean drawSnapshotAspectRatioMatch() { + return false; + + } + + @Override + + public boolean edgeToEdgeByDefault() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return edgeToEdgeByDefault; + + } + + @Override + + public boolean embeddedActivityBackNavFlag() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return embeddedActivityBackNavFlag; + + } + + @Override + + public boolean enableAdditionalWindowsAboveStatusBar() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableAdditionalWindowsAboveStatusBar; + + } + + @Override + + public boolean enableAppHeaderWithTaskDensity() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableAppHeaderWithTaskDensity; + + } + + @Override + + public boolean enableBufferTransformHintFromDisplay() { + return true; + + } + + @Override + + public boolean enableCameraCompatForDesktopWindowing() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableCameraCompatForDesktopWindowing; + + } + + @Override + + public boolean enableCompatuiSysuiLauncher() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!large_screen_experiences_app_compat_is_cached) { + load_overrides_large_screen_experiences_app_compat(); + } + } + return enableCompatuiSysuiLauncher; + + } + + @Override + + public boolean enableDesktopWindowingImmersiveHandleHiding() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingImmersiveHandleHiding; + + } + + @Override + + public boolean enableDesktopWindowingModalsPolicy() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingModalsPolicy; + + } + + @Override + + public boolean enableDesktopWindowingMode() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingMode; + + } + + @Override + + public boolean enableDesktopWindowingQuickSwitch() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingQuickSwitch; + + } + + @Override + + public boolean enableDesktopWindowingScvhCache() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingScvhCache; + + } + + @Override + + public boolean enableDesktopWindowingSizeConstraints() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingSizeConstraints; + + } + + @Override + + public boolean enableDesktopWindowingTaskLimit() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingTaskLimit; + + } + + @Override + + public boolean enableDesktopWindowingTaskbarRunningApps() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingTaskbarRunningApps; + + } + + @Override + + public boolean enableDesktopWindowingWallpaperActivity() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableDesktopWindowingWallpaperActivity; + + } + + @Override + + public boolean enableScaledResizing() { + return false; + + } + + @Override + + public boolean enableTaskStackObserverInShell() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableTaskStackObserverInShell; + + } + + @Override + + public boolean enableThemedAppHeaders() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableThemedAppHeaders; + + } + + @Override + + public boolean enableWindowingDynamicInitialBounds() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableWindowingDynamicInitialBounds; + + } + + @Override + + public boolean enableWindowingEdgeDragResize() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!lse_desktop_experience_is_cached) { + load_overrides_lse_desktop_experience(); + } + } + return enableWindowingEdgeDragResize; + + } + + @Override + + public boolean enableWmExtensionsForAllFlag() { + return true; + + } + + @Override + + public boolean enforceEdgeToEdge() { + return true; + + } + + @Override + + public boolean ensureWallpaperInTransitions() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return ensureWallpaperInTransitions; + + } + + @Override + + public boolean explicitRefreshRateHints() { + return true; + + } + + @Override + + public boolean fifoPriorityForMajorUiProcesses() { + return false; + + } + + @Override + + public boolean fixNoContainerUpdateWithoutResize() { + return false; + + } + + @Override + + public boolean fixPipRestoreToOverlay() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return fixPipRestoreToOverlay; + + } + + @Override + + public boolean fullscreenDimFlag() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return fullscreenDimFlag; + + } + + @Override + + public boolean getDimmerOnClosing() { + return true; + + } + + @Override + + public boolean immersiveAppRepositioning() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!large_screen_experiences_app_compat_is_cached) { + load_overrides_large_screen_experiences_app_compat(); + } + } + return immersiveAppRepositioning; + + } + + @Override + + public boolean insetsControlChangedItem() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return insetsControlChangedItem; + + } + + @Override + + public boolean insetsControlSeq() { + return false; + + } + + @Override + + public boolean insetsDecoupledConfiguration() { + return true; + + } + + @Override + + public boolean introduceSmootherDimmer() { + return true; + + } + + @Override + + public boolean keyguardAppearTransition() { + return true; + + } + + @Override + + public boolean letterboxBackgroundWallpaper() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!large_screen_experiences_app_compat_is_cached) { + load_overrides_large_screen_experiences_app_compat(); + } + } + return letterboxBackgroundWallpaper; + + } + + @Override + + public boolean movableCutoutConfiguration() { + return true; + + } + + @Override + + public boolean moveAnimationOptionsToChange() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return moveAnimationOptionsToChange; + + } + + @Override + + public boolean multiCrop() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!systemui_is_cached) { + load_overrides_systemui(); + } + } + return multiCrop; + + } + + @Override + + public boolean navBarTransparentByDefault() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return navBarTransparentByDefault; + + } + + @Override + + public boolean noConsecutiveVisibilityEvents() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!systemui_is_cached) { + load_overrides_systemui(); + } + } + return noConsecutiveVisibilityEvents; + + } + + @Override + + public boolean noVisibilityEventOnDisplayStateChange() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!wear_frameworks_is_cached) { + load_overrides_wear_frameworks(); + } + } + return noVisibilityEventOnDisplayStateChange; + + } + + @Override + + public boolean offloadColorExtraction() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!systemui_is_cached) { + load_overrides_systemui(); + } + } + return offloadColorExtraction; + + } + + @Override + + public boolean predictiveBackSystemAnims() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!systemui_is_cached) { + load_overrides_systemui(); + } + } + return predictiveBackSystemAnims; + + } + + @Override + + public boolean rearDisplayDisableForceDesktopSystemDecorations() { + return true; + + } + + @Override + + public boolean releaseSnapshotAggressively() { + return false; + + } + + @Override + + public boolean removePrepareSurfaceInPlacement() { + return true; + + } + + @Override + + public boolean screenRecordingCallbacks() { + return true; + + } + + @Override + + public boolean sdkDesiredPresentTime() { + return true; + + } + + @Override + + public boolean secureWindowState() { + return true; + + } + + @Override + + public boolean setScPropertiesInClient() { + return false; + + } + + @Override + + public boolean skipSleepingWhenSwitchingDisplay() { + return true; + + } + + @Override + + public boolean supportsMultiInstanceSystemUi() { + return true; + + } + + @Override + + public boolean surfaceControlInputReceiver() { + return true; + + } + + @Override + + public boolean surfaceTrustedOverlay() { + return true; + + } + + @Override + + public boolean syncScreenCapture() { + return true; + + } + + @Override + + public boolean taskFragmentSystemOrganizerFlag() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return taskFragmentSystemOrganizerFlag; + + } + + @Override + + public boolean transitReadyTracking() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return transitReadyTracking; + + } + + @Override + + public boolean trustedPresentationListenerForWindow() { + return true; + + } + + @Override + + public boolean untrustedEmbeddingAnyAppPermission() { + return true; + + } + + @Override + + public boolean untrustedEmbeddingStateSharing() { + return true; + + } + + @Override + + public boolean useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!accessibility_is_cached) { + load_overrides_accessibility(); + } + } + return useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds; + + } + + @Override + + public boolean userMinAspectRatioAppDefault() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!large_screen_experiences_app_compat_is_cached) { + load_overrides_large_screen_experiences_app_compat(); + } + } + return userMinAspectRatioAppDefault; + + } + + @Override + + public boolean waitForTransitionOnDisplaySwitch() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_frontend_is_cached) { + load_overrides_windowing_frontend(); + } + } + return waitForTransitionOnDisplaySwitch; + + } + + @Override + + public boolean wallpaperOffsetAsync() { + return true; + + } + + @Override + + public boolean windowSessionRelayoutInfo() { + return true; + + } + + @Override + + public boolean windowTokenConfigThreadSafe() { + if (isReadFromNew) { + if (!isCached) { + init(); + } + } else { + if (!windowing_sdk_is_cached) { + load_overrides_windowing_sdk(); + } + } + return windowTokenConfigThreadSafe; + + } + +} + + + diff --git a/flags/src/com/android/window/flags/Flags.java b/flags/src/com/android/window/flags/Flags.java new file mode 100644 index 0000000000..3416fbfed3 --- /dev/null +++ b/flags/src/com/android/window/flags/Flags.java @@ -0,0 +1,632 @@ +package com.android.window.flags; +// TODO(b/303773055): Remove the annotation after access issue is resolved. +/** @hide */ +public final class Flags { + /** @hide */ + public static final String FLAG_ACTIVITY_EMBEDDING_ANIMATION_CUSTOMIZATION_FLAG = "com.android.window.flags.activity_embedding_animation_customization_flag"; + /** @hide */ + public static final String FLAG_ACTIVITY_EMBEDDING_INTERACTIVE_DIVIDER_FLAG = "com.android.window.flags.activity_embedding_interactive_divider_flag"; + /** @hide */ + public static final String FLAG_ACTIVITY_EMBEDDING_OVERLAY_PRESENTATION_FLAG = "com.android.window.flags.activity_embedding_overlay_presentation_flag"; + /** @hide */ + public static final String FLAG_ACTIVITY_SNAPSHOT_BY_DEFAULT = "com.android.window.flags.activity_snapshot_by_default"; + /** @hide */ + public static final String FLAG_ACTIVITY_WINDOW_INFO_FLAG = "com.android.window.flags.activity_window_info_flag"; + /** @hide */ + public static final String FLAG_ALLOW_DISABLE_ACTIVITY_RECORD_INPUT_SINK = "com.android.window.flags.allow_disable_activity_record_input_sink"; + /** @hide */ + public static final String FLAG_ALLOW_HIDE_SCM_BUTTON = "com.android.window.flags.allow_hide_scm_button"; + /** @hide */ + public static final String FLAG_ALLOWS_SCREEN_SIZE_DECOUPLED_FROM_STATUS_BAR_AND_CUTOUT = "com.android.window.flags.allows_screen_size_decoupled_from_status_bar_and_cutout"; + /** @hide */ + public static final String FLAG_ALWAYS_DEFER_TRANSITION_WHEN_APPLY_WCT = "com.android.window.flags.always_defer_transition_when_apply_wct"; + /** @hide */ + public static final String FLAG_ALWAYS_DRAW_MAGNIFICATION_FULLSCREEN_BORDER = "com.android.window.flags.always_draw_magnification_fullscreen_border"; + /** @hide */ + public static final String FLAG_ALWAYS_UPDATE_WALLPAPER_PERMISSION = "com.android.window.flags.always_update_wallpaper_permission"; + /** @hide */ + public static final String FLAG_APP_COMPAT_PROPERTIES_API = "com.android.window.flags.app_compat_properties_api"; + /** @hide */ + public static final String FLAG_APP_COMPAT_REFACTORING = "com.android.window.flags.app_compat_refactoring"; + /** @hide */ + public static final String FLAG_BAL_DONT_BRING_EXISTING_BACKGROUND_TASK_STACK_TO_FG = "com.android.window.flags.bal_dont_bring_existing_background_task_stack_to_fg"; + /** @hide */ + public static final String FLAG_BAL_IMPROVE_REAL_CALLER_VISIBILITY_CHECK = "com.android.window.flags.bal_improve_real_caller_visibility_check"; + /** @hide */ + public static final String FLAG_BAL_IMPROVED_METRICS = "com.android.window.flags.bal_improved_metrics"; + /** @hide */ + public static final String FLAG_BAL_REQUIRE_OPT_IN_BY_PENDING_INTENT_CREATOR = "com.android.window.flags.bal_require_opt_in_by_pending_intent_creator"; + /** @hide */ + public static final String FLAG_BAL_REQUIRE_OPT_IN_SAME_UID = "com.android.window.flags.bal_require_opt_in_same_uid"; + /** @hide */ + public static final String FLAG_BAL_RESPECT_APP_SWITCH_STATE_WHEN_CHECK_BOUND_BY_FOREGROUND_UID = "com.android.window.flags.bal_respect_app_switch_state_when_check_bound_by_foreground_uid"; + /** @hide */ + public static final String FLAG_BAL_SHOW_TOASTS = "com.android.window.flags.bal_show_toasts"; + /** @hide */ + public static final String FLAG_BAL_SHOW_TOASTS_BLOCKED = "com.android.window.flags.bal_show_toasts_blocked"; + /** @hide */ + public static final String FLAG_BLAST_SYNC_NOTIFICATION_SHADE_ON_DISPLAY_SWITCH = "com.android.window.flags.blast_sync_notification_shade_on_display_switch"; + /** @hide */ + public static final String FLAG_BUNDLE_CLIENT_TRANSACTION_FLAG = "com.android.window.flags.bundle_client_transaction_flag"; + /** @hide */ + public static final String FLAG_CAMERA_COMPAT_FOR_FREEFORM = "com.android.window.flags.camera_compat_for_freeform"; + /** @hide */ + public static final String FLAG_CLOSE_TO_SQUARE_CONFIG_INCLUDES_STATUS_BAR = "com.android.window.flags.close_to_square_config_includes_status_bar"; + /** @hide */ + public static final String FLAG_CONFIGURABLE_FONT_SCALE_DEFAULT = "com.android.window.flags.configurable_font_scale_default"; + /** @hide */ + public static final String FLAG_COVER_DISPLAY_OPT_IN = "com.android.window.flags.cover_display_opt_in"; + /** @hide */ + public static final String FLAG_DEFER_DISPLAY_UPDATES = "com.android.window.flags.defer_display_updates"; + /** @hide */ + public static final String FLAG_DELAY_NOTIFICATION_TO_MAGNIFICATION_WHEN_RECENTS_WINDOW_TO_FRONT_TRANSITION = "com.android.window.flags.delay_notification_to_magnification_when_recents_window_to_front_transition"; + /** @hide */ + public static final String FLAG_DELEGATE_UNHANDLED_DRAGS = "com.android.window.flags.delegate_unhandled_drags"; + /** @hide */ + public static final String FLAG_DELETE_CAPTURE_DISPLAY = "com.android.window.flags.delete_capture_display"; + /** @hide */ + public static final String FLAG_DENSITY_390_API = "com.android.window.flags.density_390_api"; + /** @hide */ + public static final String FLAG_DISABLE_OBJECT_POOL = "com.android.window.flags.disable_object_pool"; + /** @hide */ + public static final String FLAG_DISABLE_THIN_LETTERBOXING_POLICY = "com.android.window.flags.disable_thin_letterboxing_policy"; + /** @hide */ + public static final String FLAG_DO_NOT_CHECK_INTERSECTION_WHEN_NON_MAGNIFIABLE_WINDOW_TRANSITIONS = "com.android.window.flags.do_not_check_intersection_when_non_magnifiable_window_transitions"; + /** @hide */ + public static final String FLAG_DRAW_SNAPSHOT_ASPECT_RATIO_MATCH = "com.android.window.flags.draw_snapshot_aspect_ratio_match"; + /** @hide */ + public static final String FLAG_EDGE_TO_EDGE_BY_DEFAULT = "com.android.window.flags.edge_to_edge_by_default"; + /** @hide */ + public static final String FLAG_EMBEDDED_ACTIVITY_BACK_NAV_FLAG = "com.android.window.flags.embedded_activity_back_nav_flag"; + /** @hide */ + public static final String FLAG_ENABLE_ADDITIONAL_WINDOWS_ABOVE_STATUS_BAR = "com.android.window.flags.enable_additional_windows_above_status_bar"; + /** @hide */ + public static final String FLAG_ENABLE_APP_HEADER_WITH_TASK_DENSITY = "com.android.window.flags.enable_app_header_with_task_density"; + /** @hide */ + public static final String FLAG_ENABLE_BUFFER_TRANSFORM_HINT_FROM_DISPLAY = "com.android.window.flags.enable_buffer_transform_hint_from_display"; + /** @hide */ + public static final String FLAG_ENABLE_CAMERA_COMPAT_FOR_DESKTOP_WINDOWING = "com.android.window.flags.enable_camera_compat_for_desktop_windowing"; + /** @hide */ + public static final String FLAG_ENABLE_COMPATUI_SYSUI_LAUNCHER = "com.android.window.flags.enable_compatui_sysui_launcher"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_IMMERSIVE_HANDLE_HIDING = "com.android.window.flags.enable_desktop_windowing_immersive_handle_hiding"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_MODALS_POLICY = "com.android.window.flags.enable_desktop_windowing_modals_policy"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_MODE = "com.android.window.flags.enable_desktop_windowing_mode"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_QUICK_SWITCH = "com.android.window.flags.enable_desktop_windowing_quick_switch"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_SCVH_CACHE = "com.android.window.flags.enable_desktop_windowing_scvh_cache"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_SIZE_CONSTRAINTS = "com.android.window.flags.enable_desktop_windowing_size_constraints"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_TASK_LIMIT = "com.android.window.flags.enable_desktop_windowing_task_limit"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_TASKBAR_RUNNING_APPS = "com.android.window.flags.enable_desktop_windowing_taskbar_running_apps"; + /** @hide */ + public static final String FLAG_ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY = "com.android.window.flags.enable_desktop_windowing_wallpaper_activity"; + /** @hide */ + public static final String FLAG_ENABLE_SCALED_RESIZING = "com.android.window.flags.enable_scaled_resizing"; + /** @hide */ + public static final String FLAG_ENABLE_TASK_STACK_OBSERVER_IN_SHELL = "com.android.window.flags.enable_task_stack_observer_in_shell"; + /** @hide */ + public static final String FLAG_ENABLE_THEMED_APP_HEADERS = "com.android.window.flags.enable_themed_app_headers"; + /** @hide */ + public static final String FLAG_ENABLE_WINDOWING_DYNAMIC_INITIAL_BOUNDS = "com.android.window.flags.enable_windowing_dynamic_initial_bounds"; + /** @hide */ + public static final String FLAG_ENABLE_WINDOWING_EDGE_DRAG_RESIZE = "com.android.window.flags.enable_windowing_edge_drag_resize"; + /** @hide */ + public static final String FLAG_ENABLE_WM_EXTENSIONS_FOR_ALL_FLAG = "com.android.window.flags.enable_wm_extensions_for_all_flag"; + /** @hide */ + public static final String FLAG_ENFORCE_EDGE_TO_EDGE = "com.android.window.flags.enforce_edge_to_edge"; + /** @hide */ + public static final String FLAG_ENSURE_WALLPAPER_IN_TRANSITIONS = "com.android.window.flags.ensure_wallpaper_in_transitions"; + /** @hide */ + public static final String FLAG_EXPLICIT_REFRESH_RATE_HINTS = "com.android.window.flags.explicit_refresh_rate_hints"; + /** @hide */ + public static final String FLAG_FIFO_PRIORITY_FOR_MAJOR_UI_PROCESSES = "com.android.window.flags.fifo_priority_for_major_ui_processes"; + /** @hide */ + public static final String FLAG_FIX_NO_CONTAINER_UPDATE_WITHOUT_RESIZE = "com.android.window.flags.fix_no_container_update_without_resize"; + /** @hide */ + public static final String FLAG_FIX_PIP_RESTORE_TO_OVERLAY = "com.android.window.flags.fix_pip_restore_to_overlay"; + /** @hide */ + public static final String FLAG_FULLSCREEN_DIM_FLAG = "com.android.window.flags.fullscreen_dim_flag"; + /** @hide */ + public static final String FLAG_GET_DIMMER_ON_CLOSING = "com.android.window.flags.get_dimmer_on_closing"; + /** @hide */ + public static final String FLAG_IMMERSIVE_APP_REPOSITIONING = "com.android.window.flags.immersive_app_repositioning"; + /** @hide */ + public static final String FLAG_INSETS_CONTROL_CHANGED_ITEM = "com.android.window.flags.insets_control_changed_item"; + /** @hide */ + public static final String FLAG_INSETS_CONTROL_SEQ = "com.android.window.flags.insets_control_seq"; + /** @hide */ + public static final String FLAG_INSETS_DECOUPLED_CONFIGURATION = "com.android.window.flags.insets_decoupled_configuration"; + /** @hide */ + public static final String FLAG_INTRODUCE_SMOOTHER_DIMMER = "com.android.window.flags.introduce_smoother_dimmer"; + /** @hide */ + public static final String FLAG_KEYGUARD_APPEAR_TRANSITION = "com.android.window.flags.keyguard_appear_transition"; + /** @hide */ + public static final String FLAG_LETTERBOX_BACKGROUND_WALLPAPER = "com.android.window.flags.letterbox_background_wallpaper"; + /** @hide */ + public static final String FLAG_MOVABLE_CUTOUT_CONFIGURATION = "com.android.window.flags.movable_cutout_configuration"; + /** @hide */ + public static final String FLAG_MOVE_ANIMATION_OPTIONS_TO_CHANGE = "com.android.window.flags.move_animation_options_to_change"; + /** @hide */ + public static final String FLAG_MULTI_CROP = "com.android.window.flags.multi_crop"; + /** @hide */ + public static final String FLAG_NAV_BAR_TRANSPARENT_BY_DEFAULT = "com.android.window.flags.nav_bar_transparent_by_default"; + /** @hide */ + public static final String FLAG_NO_CONSECUTIVE_VISIBILITY_EVENTS = "com.android.window.flags.no_consecutive_visibility_events"; + /** @hide */ + public static final String FLAG_NO_VISIBILITY_EVENT_ON_DISPLAY_STATE_CHANGE = "com.android.window.flags.no_visibility_event_on_display_state_change"; + /** @hide */ + public static final String FLAG_OFFLOAD_COLOR_EXTRACTION = "com.android.window.flags.offload_color_extraction"; + /** @hide */ + public static final String FLAG_PREDICTIVE_BACK_SYSTEM_ANIMS = "com.android.window.flags.predictive_back_system_anims"; + /** @hide */ + public static final String FLAG_REAR_DISPLAY_DISABLE_FORCE_DESKTOP_SYSTEM_DECORATIONS = "com.android.window.flags.rear_display_disable_force_desktop_system_decorations"; + /** @hide */ + public static final String FLAG_RELEASE_SNAPSHOT_AGGRESSIVELY = "com.android.window.flags.release_snapshot_aggressively"; + /** @hide */ + public static final String FLAG_REMOVE_PREPARE_SURFACE_IN_PLACEMENT = "com.android.window.flags.remove_prepare_surface_in_placement"; + /** @hide */ + public static final String FLAG_SCREEN_RECORDING_CALLBACKS = "com.android.window.flags.screen_recording_callbacks"; + /** @hide */ + public static final String FLAG_SDK_DESIRED_PRESENT_TIME = "com.android.window.flags.sdk_desired_present_time"; + /** @hide */ + public static final String FLAG_SECURE_WINDOW_STATE = "com.android.window.flags.secure_window_state"; + /** @hide */ + public static final String FLAG_SET_SC_PROPERTIES_IN_CLIENT = "com.android.window.flags.set_sc_properties_in_client"; + /** @hide */ + public static final String FLAG_SKIP_SLEEPING_WHEN_SWITCHING_DISPLAY = "com.android.window.flags.skip_sleeping_when_switching_display"; + /** @hide */ + public static final String FLAG_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI = "com.android.window.flags.supports_multi_instance_system_ui"; + /** @hide */ + public static final String FLAG_SURFACE_CONTROL_INPUT_RECEIVER = "com.android.window.flags.surface_control_input_receiver"; + /** @hide */ + public static final String FLAG_SURFACE_TRUSTED_OVERLAY = "com.android.window.flags.surface_trusted_overlay"; + /** @hide */ + public static final String FLAG_SYNC_SCREEN_CAPTURE = "com.android.window.flags.sync_screen_capture"; + /** @hide */ + public static final String FLAG_TASK_FRAGMENT_SYSTEM_ORGANIZER_FLAG = "com.android.window.flags.task_fragment_system_organizer_flag"; + /** @hide */ + public static final String FLAG_TRANSIT_READY_TRACKING = "com.android.window.flags.transit_ready_tracking"; + /** @hide */ + public static final String FLAG_TRUSTED_PRESENTATION_LISTENER_FOR_WINDOW = "com.android.window.flags.trusted_presentation_listener_for_window"; + /** @hide */ + public static final String FLAG_UNTRUSTED_EMBEDDING_ANY_APP_PERMISSION = "com.android.window.flags.untrusted_embedding_any_app_permission"; + /** @hide */ + public static final String FLAG_UNTRUSTED_EMBEDDING_STATE_SHARING = "com.android.window.flags.untrusted_embedding_state_sharing"; + /** @hide */ + public static final String FLAG_USE_WINDOW_ORIGINAL_TOUCHABLE_REGION_WHEN_MAGNIFICATION_RECOMPUTE_BOUNDS = "com.android.window.flags.use_window_original_touchable_region_when_magnification_recompute_bounds"; + /** @hide */ + public static final String FLAG_USER_MIN_ASPECT_RATIO_APP_DEFAULT = "com.android.window.flags.user_min_aspect_ratio_app_default"; + /** @hide */ + public static final String FLAG_WAIT_FOR_TRANSITION_ON_DISPLAY_SWITCH = "com.android.window.flags.wait_for_transition_on_display_switch"; + /** @hide */ + public static final String FLAG_WALLPAPER_OFFSET_ASYNC = "com.android.window.flags.wallpaper_offset_async"; + /** @hide */ + public static final String FLAG_WINDOW_SESSION_RELAYOUT_INFO = "com.android.window.flags.window_session_relayout_info"; + /** @hide */ + public static final String FLAG_WINDOW_TOKEN_CONFIG_THREAD_SAFE = "com.android.window.flags.window_token_config_thread_safe"; + + public static boolean activityEmbeddingAnimationCustomizationFlag() { + return FEATURE_FLAGS.activityEmbeddingAnimationCustomizationFlag(); + } + + public static boolean activityEmbeddingInteractiveDividerFlag() { + return FEATURE_FLAGS.activityEmbeddingInteractiveDividerFlag(); + } + + public static boolean activityEmbeddingOverlayPresentationFlag() { + return FEATURE_FLAGS.activityEmbeddingOverlayPresentationFlag(); + } + + public static boolean activitySnapshotByDefault() { + return FEATURE_FLAGS.activitySnapshotByDefault(); + } + + public static boolean activityWindowInfoFlag() { + return FEATURE_FLAGS.activityWindowInfoFlag(); + } + + public static boolean allowDisableActivityRecordInputSink() { + return FEATURE_FLAGS.allowDisableActivityRecordInputSink(); + } + + public static boolean allowHideScmButton() { + return FEATURE_FLAGS.allowHideScmButton(); + } + + public static boolean allowsScreenSizeDecoupledFromStatusBarAndCutout() { + return FEATURE_FLAGS.allowsScreenSizeDecoupledFromStatusBarAndCutout(); + } + + public static boolean alwaysDeferTransitionWhenApplyWct() { + return FEATURE_FLAGS.alwaysDeferTransitionWhenApplyWct(); + } + + public static boolean alwaysDrawMagnificationFullscreenBorder() { + return FEATURE_FLAGS.alwaysDrawMagnificationFullscreenBorder(); + } + + public static boolean alwaysUpdateWallpaperPermission() { + return FEATURE_FLAGS.alwaysUpdateWallpaperPermission(); + } + + public static boolean appCompatPropertiesApi() { + return FEATURE_FLAGS.appCompatPropertiesApi(); + } + + public static boolean appCompatRefactoring() { + return FEATURE_FLAGS.appCompatRefactoring(); + } + + public static boolean balDontBringExistingBackgroundTaskStackToFg() { + return FEATURE_FLAGS.balDontBringExistingBackgroundTaskStackToFg(); + } + + public static boolean balImproveRealCallerVisibilityCheck() { + return FEATURE_FLAGS.balImproveRealCallerVisibilityCheck(); + } + + public static boolean balImprovedMetrics() { + return FEATURE_FLAGS.balImprovedMetrics(); + } + + public static boolean balRequireOptInByPendingIntentCreator() { + return FEATURE_FLAGS.balRequireOptInByPendingIntentCreator(); + } + + public static boolean balRequireOptInSameUid() { + return FEATURE_FLAGS.balRequireOptInSameUid(); + } + + public static boolean balRespectAppSwitchStateWhenCheckBoundByForegroundUid() { + return FEATURE_FLAGS.balRespectAppSwitchStateWhenCheckBoundByForegroundUid(); + } + + public static boolean balShowToasts() { + return FEATURE_FLAGS.balShowToasts(); + } + + public static boolean balShowToastsBlocked() { + return FEATURE_FLAGS.balShowToastsBlocked(); + } + + public static boolean blastSyncNotificationShadeOnDisplaySwitch() { + return FEATURE_FLAGS.blastSyncNotificationShadeOnDisplaySwitch(); + } + + public static boolean bundleClientTransactionFlag() { + return FEATURE_FLAGS.bundleClientTransactionFlag(); + } + + public static boolean cameraCompatForFreeform() { + return FEATURE_FLAGS.cameraCompatForFreeform(); + } + + public static boolean closeToSquareConfigIncludesStatusBar() { + return FEATURE_FLAGS.closeToSquareConfigIncludesStatusBar(); + } + + public static boolean configurableFontScaleDefault() { + return FEATURE_FLAGS.configurableFontScaleDefault(); + } + + public static boolean coverDisplayOptIn() { + return FEATURE_FLAGS.coverDisplayOptIn(); + } + + public static boolean deferDisplayUpdates() { + return FEATURE_FLAGS.deferDisplayUpdates(); + } + + public static boolean delayNotificationToMagnificationWhenRecentsWindowToFrontTransition() { + return FEATURE_FLAGS.delayNotificationToMagnificationWhenRecentsWindowToFrontTransition(); + } + + public static boolean delegateUnhandledDrags() { + return FEATURE_FLAGS.delegateUnhandledDrags(); + } + + public static boolean deleteCaptureDisplay() { + return FEATURE_FLAGS.deleteCaptureDisplay(); + } + + public static boolean density390Api() { + return FEATURE_FLAGS.density390Api(); + } + + public static boolean disableObjectPool() { + return FEATURE_FLAGS.disableObjectPool(); + } + + public static boolean disableThinLetterboxingPolicy() { + return FEATURE_FLAGS.disableThinLetterboxingPolicy(); + } + + public static boolean doNotCheckIntersectionWhenNonMagnifiableWindowTransitions() { + return FEATURE_FLAGS.doNotCheckIntersectionWhenNonMagnifiableWindowTransitions(); + } + + public static boolean drawSnapshotAspectRatioMatch() { + return FEATURE_FLAGS.drawSnapshotAspectRatioMatch(); + } + + public static boolean edgeToEdgeByDefault() { + return FEATURE_FLAGS.edgeToEdgeByDefault(); + } + + public static boolean embeddedActivityBackNavFlag() { + return FEATURE_FLAGS.embeddedActivityBackNavFlag(); + } + + public static boolean enableAdditionalWindowsAboveStatusBar() { + return FEATURE_FLAGS.enableAdditionalWindowsAboveStatusBar(); + } + + public static boolean enableAppHeaderWithTaskDensity() { + return FEATURE_FLAGS.enableAppHeaderWithTaskDensity(); + } + + public static boolean enableBufferTransformHintFromDisplay() { + return FEATURE_FLAGS.enableBufferTransformHintFromDisplay(); + } + + public static boolean enableCameraCompatForDesktopWindowing() { + return FEATURE_FLAGS.enableCameraCompatForDesktopWindowing(); + } + + public static boolean enableCompatuiSysuiLauncher() { + return FEATURE_FLAGS.enableCompatuiSysuiLauncher(); + } + + public static boolean enableDesktopWindowingImmersiveHandleHiding() { + return FEATURE_FLAGS.enableDesktopWindowingImmersiveHandleHiding(); + } + + public static boolean enableDesktopWindowingModalsPolicy() { + return FEATURE_FLAGS.enableDesktopWindowingModalsPolicy(); + } + + public static boolean enableDesktopWindowingMode() { + return FEATURE_FLAGS.enableDesktopWindowingMode(); + } + + public static boolean enableDesktopWindowingQuickSwitch() { + return FEATURE_FLAGS.enableDesktopWindowingQuickSwitch(); + } + + public static boolean enableDesktopWindowingScvhCache() { + return FEATURE_FLAGS.enableDesktopWindowingScvhCache(); + } + + public static boolean enableDesktopWindowingSizeConstraints() { + return FEATURE_FLAGS.enableDesktopWindowingSizeConstraints(); + } + + public static boolean enableDesktopWindowingTaskLimit() { + return FEATURE_FLAGS.enableDesktopWindowingTaskLimit(); + } + + public static boolean enableDesktopWindowingTaskbarRunningApps() { + return FEATURE_FLAGS.enableDesktopWindowingTaskbarRunningApps(); + } + + public static boolean enableDesktopWindowingWallpaperActivity() { + return FEATURE_FLAGS.enableDesktopWindowingWallpaperActivity(); + } + + public static boolean enableScaledResizing() { + return FEATURE_FLAGS.enableScaledResizing(); + } + + public static boolean enableTaskStackObserverInShell() { + return FEATURE_FLAGS.enableTaskStackObserverInShell(); + } + + public static boolean enableThemedAppHeaders() { + return FEATURE_FLAGS.enableThemedAppHeaders(); + } + + public static boolean enableWindowingDynamicInitialBounds() { + return FEATURE_FLAGS.enableWindowingDynamicInitialBounds(); + } + + public static boolean enableWindowingEdgeDragResize() { + return FEATURE_FLAGS.enableWindowingEdgeDragResize(); + } + + public static boolean enableWmExtensionsForAllFlag() { + return FEATURE_FLAGS.enableWmExtensionsForAllFlag(); + } + + public static boolean enforceEdgeToEdge() { + return FEATURE_FLAGS.enforceEdgeToEdge(); + } + + public static boolean ensureWallpaperInTransitions() { + return FEATURE_FLAGS.ensureWallpaperInTransitions(); + } + + public static boolean explicitRefreshRateHints() { + return FEATURE_FLAGS.explicitRefreshRateHints(); + } + + public static boolean fifoPriorityForMajorUiProcesses() { + return FEATURE_FLAGS.fifoPriorityForMajorUiProcesses(); + } + + public static boolean fixNoContainerUpdateWithoutResize() { + return FEATURE_FLAGS.fixNoContainerUpdateWithoutResize(); + } + + public static boolean fixPipRestoreToOverlay() { + return FEATURE_FLAGS.fixPipRestoreToOverlay(); + } + + public static boolean fullscreenDimFlag() { + return FEATURE_FLAGS.fullscreenDimFlag(); + } + + public static boolean getDimmerOnClosing() { + return FEATURE_FLAGS.getDimmerOnClosing(); + } + + public static boolean immersiveAppRepositioning() { + return FEATURE_FLAGS.immersiveAppRepositioning(); + } + + public static boolean insetsControlChangedItem() { + return FEATURE_FLAGS.insetsControlChangedItem(); + } + + public static boolean insetsControlSeq() { + return FEATURE_FLAGS.insetsControlSeq(); + } + + public static boolean insetsDecoupledConfiguration() { + return FEATURE_FLAGS.insetsDecoupledConfiguration(); + } + + public static boolean introduceSmootherDimmer() { + return FEATURE_FLAGS.introduceSmootherDimmer(); + } + + public static boolean keyguardAppearTransition() { + return FEATURE_FLAGS.keyguardAppearTransition(); + } + + public static boolean letterboxBackgroundWallpaper() { + return FEATURE_FLAGS.letterboxBackgroundWallpaper(); + } + + public static boolean movableCutoutConfiguration() { + return FEATURE_FLAGS.movableCutoutConfiguration(); + } + + public static boolean moveAnimationOptionsToChange() { + return FEATURE_FLAGS.moveAnimationOptionsToChange(); + } + + public static boolean multiCrop() { + return FEATURE_FLAGS.multiCrop(); + } + + public static boolean navBarTransparentByDefault() { + return FEATURE_FLAGS.navBarTransparentByDefault(); + } + + public static boolean noConsecutiveVisibilityEvents() { + return FEATURE_FLAGS.noConsecutiveVisibilityEvents(); + } + + public static boolean noVisibilityEventOnDisplayStateChange() { + return FEATURE_FLAGS.noVisibilityEventOnDisplayStateChange(); + } + + public static boolean offloadColorExtraction() { + return FEATURE_FLAGS.offloadColorExtraction(); + } + + public static boolean predictiveBackSystemAnims() { + return FEATURE_FLAGS.predictiveBackSystemAnims(); + } + + public static boolean rearDisplayDisableForceDesktopSystemDecorations() { + return FEATURE_FLAGS.rearDisplayDisableForceDesktopSystemDecorations(); + } + + public static boolean releaseSnapshotAggressively() { + return FEATURE_FLAGS.releaseSnapshotAggressively(); + } + + public static boolean removePrepareSurfaceInPlacement() { + return FEATURE_FLAGS.removePrepareSurfaceInPlacement(); + } + + public static boolean screenRecordingCallbacks() { + return FEATURE_FLAGS.screenRecordingCallbacks(); + } + + public static boolean sdkDesiredPresentTime() { + return FEATURE_FLAGS.sdkDesiredPresentTime(); + } + + public static boolean secureWindowState() { + return FEATURE_FLAGS.secureWindowState(); + } + + public static boolean setScPropertiesInClient() { + return FEATURE_FLAGS.setScPropertiesInClient(); + } + + public static boolean skipSleepingWhenSwitchingDisplay() { + return FEATURE_FLAGS.skipSleepingWhenSwitchingDisplay(); + } + + public static boolean supportsMultiInstanceSystemUi() { + return FEATURE_FLAGS.supportsMultiInstanceSystemUi(); + } + + public static boolean surfaceControlInputReceiver() { + return FEATURE_FLAGS.surfaceControlInputReceiver(); + } + + public static boolean surfaceTrustedOverlay() { + return FEATURE_FLAGS.surfaceTrustedOverlay(); + } + + public static boolean syncScreenCapture() { + return FEATURE_FLAGS.syncScreenCapture(); + } + + public static boolean taskFragmentSystemOrganizerFlag() { + return FEATURE_FLAGS.taskFragmentSystemOrganizerFlag(); + } + + public static boolean transitReadyTracking() { + return FEATURE_FLAGS.transitReadyTracking(); + } + + public static boolean trustedPresentationListenerForWindow() { + return FEATURE_FLAGS.trustedPresentationListenerForWindow(); + } + + public static boolean untrustedEmbeddingAnyAppPermission() { + return FEATURE_FLAGS.untrustedEmbeddingAnyAppPermission(); + } + + public static boolean untrustedEmbeddingStateSharing() { + return FEATURE_FLAGS.untrustedEmbeddingStateSharing(); + } + + public static boolean useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds() { + return FEATURE_FLAGS.useWindowOriginalTouchableRegionWhenMagnificationRecomputeBounds(); + } + + public static boolean userMinAspectRatioAppDefault() { + return FEATURE_FLAGS.userMinAspectRatioAppDefault(); + } + + public static boolean waitForTransitionOnDisplaySwitch() { + return FEATURE_FLAGS.waitForTransitionOnDisplaySwitch(); + } + + public static boolean wallpaperOffsetAsync() { + return FEATURE_FLAGS.wallpaperOffsetAsync(); + } + + public static boolean windowSessionRelayoutInfo() { + return FEATURE_FLAGS.windowSessionRelayoutInfo(); + } + + public static boolean windowTokenConfigThreadSafe() { + return FEATURE_FLAGS.windowTokenConfigThreadSafe(); + } + + private static FeatureFlags FEATURE_FLAGS = new FeatureFlagsImpl(); + +} diff --git a/flags/src/com/android/wm/shell/FeatureFlagsImpl.java b/flags/src/com/android/wm/shell/FeatureFlagsImpl.java index 26af996c32..a5bba4b5ee 100644 --- a/flags/src/com/android/wm/shell/FeatureFlagsImpl.java +++ b/flags/src/com/android/wm/shell/FeatureFlagsImpl.java @@ -1,7 +1,8 @@ package com.android.wm.shell; // TODO(b/303773055): Remove the annotation after access issue is resolved. -import android.provider.DeviceConfig; -import android.provider.DeviceConfig.Properties; + +import com.android.quickstep.util.DeviceConfigHelper; + import java.nio.file.Files; import java.nio.file.Paths; /** @hide */ @@ -82,7 +83,7 @@ public final class FeatureFlagsImpl implements FeatureFlags { private void load_overrides_multitasking() { try { - Properties properties = DeviceConfig.getProperties("multitasking"); + var properties = DeviceConfigHelper.Companion.getPrefs(); animateBubbleSizeChange = properties.getBoolean(Flags.FLAG_ANIMATE_BUBBLE_SIZE_CHANGE, false); enableAppPairs = diff --git a/lawnchair/res/layout-v30/task_desktop.xml b/lawnchair/res/layout-v30/task_desktop.xml index 96aabb4dfc..112ec6354e 100644 --- a/lawnchair/res/layout-v30/task_desktop.xml +++ b/lawnchair/res/layout-v30/task_desktop.xml @@ -35,7 +35,7 @@ views that do not inherint from TaskView only or create a generic TaskView that have N number of tasks. --> - >() val windowManager = displayInfoContext.getSystemService(WindowManager::class.java) - val possibleMaximumWindowMetrics = - windowManager!!.getPossibleMaximumWindowMetrics(DEFAULT_DISPLAY) - for (windowMetrics in possibleMaximumWindowMetrics) { - val info = getDisplayInfo(windowMetrics, Surface.ROTATION_0) - val bounds = estimateWindowBounds(displayInfoContext, info) - result[info] = bounds - } +// val possibleMaximumWindowMetrics = +// windowManager!!.getPossibleMaximumWindowMetrics(DEFAULT_DISPLAY) +// for (windowMetrics in possibleMaximumWindowMetrics) { +// val info = getDisplayInfo(windowMetrics, Surface.ROTATION_0) +// val bounds = estimateWindowBounds(displayInfoContext, info) +// result[info] = bounds +// } return result } return super.estimateInternalDisplayBounds(displayInfoContext) diff --git a/quickstep/res/layout/task_desktop.xml b/quickstep/res/layout/task_desktop.xml index a91531d41e..1545406ca8 100644 --- a/quickstep/res/layout/task_desktop.xml +++ b/quickstep/res/layout/task_desktop.xml @@ -38,7 +38,7 @@ views that do not inherint from TaskView only or create a generic TaskView that have N number of tasks. --> - - com.android.launcher3.uioverrides.SystemApiWrapper + diff --git a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java index a90bd9b809..f692ba462e 100644 --- a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java +++ b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java @@ -176,6 +176,8 @@ import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; +import app.lawnchair.compat.LawnchairQuickstepCompat; + /** * Manages the opening and closing app transitions from Launcher */ @@ -353,10 +355,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener long statusBarTransitionDelay = duration - STATUS_BAR_TRANSITION_DURATION - STATUS_BAR_TRANSITION_PRE_DELAY; - ActivityOptions options = ActivityOptions.makeRemoteAnimation( + ActivityOptions options = LawnchairQuickstepCompat.getActivityOptionsCompat().makeRemoteAnimation( new RemoteAnimationAdapter(runner, duration, statusBarTransitionDelay), - new RemoteTransition(runner.toRemoteTransition(), - mLauncher.getIApplicationThread(), "QuickstepLaunch")); + LawnchairQuickstepCompat.getRemoteTransitionCompat().getRemoteTransition(runner.toRemoteTransition(), + mLauncher.getIApplicationThread(), "QuickstepLaunch"), + "Lawnchair"); IRemoteCallback endCallback = completeRunnableListCallback(onEndCallback); options.setOnAnimationAbortListener(endCallback); options.setOnAnimationFinishedListener(endCallback); @@ -1116,7 +1119,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener } RemoteAnimationDefinition definition = new RemoteAnimationDefinition(); addRemoteAnimations(definition); - mLauncher.registerRemoteAnimations(definition); + try { + mLauncher.registerRemoteAnimations(definition); + } catch (Throwable t) { + // Ignore + } } /** @@ -1148,15 +1155,16 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener * Registers remote animations used when closing apps to home screen. */ public void registerRemoteTransitions() { - if (ENABLE_SHELL_TRANSITIONS) { - SystemUiProxy.INSTANCE.get(mLauncher).shareTransactionQueue(); - } - if (SEPARATE_RECENTS_ACTIVITY.get()) { + if (SEPARATE_RECENTS_ACTIVITY.get() && !Utilities.ATLEAST_T) { return; } + if (ENABLE_SHELL_TRANSITIONS) { + SystemUiProxy.INSTANCE.get(mLauncher).shareTransactionQueue(); + } + mWallpaperOpenTransitionRunner = createWallpaperOpenRunner(false /* fromUnlock */); - mLauncherOpenTransition = new RemoteTransition( + mLauncherOpenTransition = LawnchairQuickstepCompat.getRemoteTransitionCompat().getRemoteTransition( new LauncherAnimationRunner(mHandler, mWallpaperOpenTransitionRunner, false /* startAtFrontOfQueue */).toRemoteTransition(), mLauncher.getIApplicationThread(), "QuickstepLaunchHome"); diff --git a/quickstep/src/com/android/launcher3/statehandlers/DepthController.java b/quickstep/src/com/android/launcher3/statehandlers/DepthController.java index dc5afb4729..49de6cd453 100644 --- a/quickstep/src/com/android/launcher3/statehandlers/DepthController.java +++ b/quickstep/src/com/android/launcher3/statehandlers/DepthController.java @@ -73,9 +73,14 @@ public class DepthController extends BaseDepthController implements StateHandler private void onLauncherDraw() { View view = mLauncher.getDragLayer(); ViewRootImpl viewRootImpl = view.getViewRootImpl(); - if (Utilities.ATLEAST_Q) { - setSurface(viewRootImpl != null ? viewRootImpl.getSurfaceControl() : null); + try { + if (Utilities.ATLEAST_Q) { + setSurface(viewRootImpl != null ? viewRootImpl.getSurfaceControl() : null); + } + } catch (Throwable t) { + } + view.post(() -> view.getViewTreeObserver().removeOnDrawListener(mOnDrawListener)); } diff --git a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java index f2c6cc9774..293c2b2a65 100644 --- a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java +++ b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java @@ -258,9 +258,7 @@ public class NavbarButtonsViewController implements TaskbarControllers.LoggableT mContext.isPhoneMode()); mNavButtonsView.getLayoutParams().height = p.y; - mIsImeRenderingNavButtons = app.lawnchair.LawnchairApp.isAtleastT() - ? InputMethodService.canImeRenderGesturalNavButtons() && mContext.imeDrawsImeNavBar() - : mContext.imeDrawsImeNavBar(); + mIsImeRenderingNavButtons = mContext.imeDrawsImeNavBar(); // mDisplayController = DisplayController.INSTANCE.get(mContext); if (!mIsImeRenderingNavButtons) { diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java index ec943282ed..d332e5e62c 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java @@ -780,8 +780,6 @@ public class TaskbarActivityContext extends BaseTaskbarContext { options.setSplashScreenStyle(splashScreenStyle); } Utilities.allowBGLaunch(options); - options.setPendingIntentBackgroundActivityStartMode( - ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED); IRemoteCallback endCallback = completeRunnableListCallback(callbacks); options.setOnAnimationAbortListener(endCallback); options.setOnAnimationFinishedListener(endCallback); diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java index 89faba85be..465062e2f4 100644 --- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java +++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java @@ -199,6 +199,7 @@ import com.android.systemui.unfold.dagger.UnfoldMain; import com.android.systemui.unfold.progress.RemoteUnfoldTransitionReceiver; import com.android.systemui.unfold.updates.RotationChangeProvider; +import app.lawnchair.LawnchairApp; import kotlin.Unit; import java.io.FileDescriptor; @@ -276,7 +277,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer asContext(), deviceState); if (enableDesktopWindowingMode()) { mDesktopRecentsTransitionController = new DesktopRecentsTransitionController( - getStateManager(), systemUiProxy, getIApplicationThread(), + getStateManager(), systemUiProxy, this.getIApplicationThread(), getDepthController()); } overviewPanel.init(mActionsView, mSplitSelectStateController, @@ -288,9 +289,11 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer mActionsView.updateDimension(getDeviceProfile(), overviewPanel.getLastComputedTaskSize()); mActionsView.updateVerticalMargin(DisplayController.getNavigationMode(this)); - mAppTransitionManager = buildAppTransitionManager(); - mAppTransitionManager.registerRemoteAnimations(); - mAppTransitionManager.registerRemoteTransitions(); + if (LawnchairApp.isRecentsEnabled()) { + mAppTransitionManager = buildAppTransitionManager(); + mAppTransitionManager.registerRemoteAnimations(); + mAppTransitionManager.registerRemoteTransitions(); + } mTISBindHelper = new TISBindHelper(this, this::onTISConnected); mDepthController = new DepthController(this); @@ -302,7 +305,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer } mHotseatPredictionController = new HotseatPredictionController(this); - mEnableWidgetDepth = SystemProperties.getBoolean("ro.launcher.depth.widget", true); + mEnableWidgetDepth = LawnchairApp.isRecentsEnabled() ? SystemProperties.getBoolean("ro.launcher.depth.widget", true) : false; getWorkspace().addOverlayCallback(progress -> onTaskbarInAppDisplayProgressUpdate(progress, MINUS_ONE_PAGE_PROGRESS_INDEX)); addBackAnimationCallback(mSplitSelectStateController.getSplitBackHandler()); @@ -675,17 +678,18 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer if (FeatureFlags.CONTINUOUS_VIEW_TREE_CAPTURE.get()) { mViewCapture = ViewCaptureFactory.getInstance(this).startCapture(getWindow()); } - getWindow().addPrivateFlags(PRIVATE_FLAG_OPTIMIZE_MEASURE); +// getWindow().addPrivateFlags(PRIVATE_FLAG_OPTIMIZE_MEASURE); QuickstepOnboardingPrefs.setup(this); - View.setTraceLayoutSteps(TRACE_LAYOUTS); - View.setTracedRequestLayoutClassClass(TRACE_RELAYOUT_CLASS); +// View.setTraceLayoutSteps(TRACE_LAYOUTS); +// View.setTracedRequestLayoutClassClass(TRACE_RELAYOUT_CLASS); } @Override protected boolean initDeviceProfile(InvariantDeviceProfile idp) { final boolean ret = super.initDeviceProfile(idp); - mDeviceProfile.isPredictiveBackSwipe = - getApplicationInfo().isOnBackInvokedCallbackEnabled(); +// mDeviceProfile.isPredictiveBackSwipe = +// getApplicationInfo().isOnBackInvokedCallbackEnabled(); + mDeviceProfile.isPredictiveBackSwipe = false; return ret; } @@ -1180,8 +1184,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer activityOptions.options.setLaunchDisplayId( (v != null && v.getDisplay() != null) ? v.getDisplay().getDisplayId() : Display.DEFAULT_DISPLAY); - activityOptions.options.setPendingIntentBackgroundActivityStartMode( - ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED); + Utilities.allowBGLaunch(activityOptions.options); addLaunchCookie(item, activityOptions.options); return activityOptions; } @@ -1191,9 +1194,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer RunnableList callbacks = new RunnableList(); ActivityOptions options = ActivityOptions.makeCustomAnimation(this, 0, 0); options.setSplashScreenStyle(splashScreenStyle); - options.setPendingIntentBackgroundActivityStartMode( - ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED); - + Utilities.allowBGLaunch(options); IRemoteCallback endCallback = completeRunnableListCallback(callbacks); options.setOnAnimationAbortListener(endCallback); options.setOnAnimationFinishedListener(endCallback); diff --git a/quickstep/src/com/android/quickstep/BaseContainerInterface.java b/quickstep/src/com/android/quickstep/BaseContainerInterface.java index b1d511cfcd..20f9f04b0b 100644 --- a/quickstep/src/com/android/quickstep/BaseContainerInterface.java +++ b/quickstep/src/com/android/quickstep/BaseContainerInterface.java @@ -283,7 +283,7 @@ public abstract class BaseContainerInterface implem if (enableDesktopWindowingMode()) { mDesktopRecentsTransitionController = new DesktopRecentsTransitionController( - getStateManager(), systemUiProxy, getIApplicationThread(), + getStateManager(), systemUiProxy, this.getIApplicationThread(), null /* depthController */ ); } @@ -304,7 +304,7 @@ public final class RecentsActivity extends StatefulActivity implem RECENTS_LAUNCH_DURATION - STATUS_BAR_TRANSITION_DURATION - STATUS_BAR_TRANSITION_PRE_DELAY), LawnchairQuickstepCompat.getRemoteTransitionCompat().getRemoteTransition(wrapper.toRemoteTransition(), - getIApplicationThread(), + this.getIApplicationThread(), "LaunchFromRecents"), "Lawnchair"); final ActivityOptionsWrapper activityOptions = new ActivityOptionsWrapper(options, @@ -460,7 +460,7 @@ public final class RecentsActivity extends StatefulActivity implem ActivityOptions options = LawnchairQuickstepCompat.getActivityOptionsCompat().makeRemoteAnimation( new RemoteAnimationAdapter(runner, HOME_APPEAR_DURATION, 0), LawnchairQuickstepCompat.getRemoteTransitionCompat().getRemoteTransition(runner.toRemoteTransition(), - getIApplicationThread(), + this.getIApplicationThread(), "StartHomeFromRecents"), "Lawnchair"); startHomeIntentSafely(this, options.toBundle(), TAG); diff --git a/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java b/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java index 739f10ff3c..9bf1eb8c49 100644 --- a/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java +++ b/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java @@ -107,9 +107,7 @@ public class RecentsAnimationDeviceState implements DisplayInfoChangeListener, E private final RotationTouchHelper mRotationTouchHelper; private final TaskStackChangeListener mPipListener; // Cache for better performance since it doesn't change at runtime. - private final boolean mCanImeRenderGesturalNavButtons = LawnchairApp.isAtleastT() - ? InputMethodService.canImeRenderGesturalNavButtons() - : isImeRenderingNavButtons(); + private final boolean mCanImeRenderGesturalNavButtons = isImeRenderingNavButtons(); private final ArrayList mOnDestroyActions = new ArrayList<>(); diff --git a/quickstep/src/com/android/quickstep/SystemUiProxy.java b/quickstep/src/com/android/quickstep/SystemUiProxy.java index cabe40c2f3..02ac28a0d9 100644 --- a/quickstep/src/com/android/quickstep/SystemUiProxy.java +++ b/quickstep/src/com/android/quickstep/SystemUiProxy.java @@ -64,6 +64,7 @@ import androidx.annotation.WorkerThread; import com.android.internal.logging.InstanceId; import com.android.internal.util.ScreenshotRequest; import com.android.internal.view.AppearanceRegion; +import com.android.launcher3.Utilities; import com.android.launcher3.util.MainThreadInitializedObject; import com.android.launcher3.util.Preconditions; import com.android.launcher3.util.SafeCloseable; @@ -191,9 +192,8 @@ public class SystemUiProxy implements ISystemUiProxy, NavHandle, SafeCloseable { mContext = context; mAsyncHandler = new Handler(UI_HELPER_EXECUTOR.getLooper(), this::handleMessageAsync); final Intent baseIntent = new Intent().setPackage(mContext.getPackageName()); - final ActivityOptions options = ActivityOptions.makeBasic() - .setPendingIntentCreatorBackgroundActivityStartMode( - ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED); + final ActivityOptions options = ActivityOptions.makeBasic(); + Utilities.allowBGLaunch(options); mRecentsPendingIntent = PendingIntent.getActivity(mContext, 0, baseIntent, PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT | Intent.FILL_IN_COMPONENT, options.toBundle()); @@ -1204,7 +1204,7 @@ public class SystemUiProxy implements ISystemUiProxy, NavHandle, SafeCloseable { */ public void shareTransactionQueue() { if (mOriginalTransactionToken == null) { - mOriginalTransactionToken = SurfaceControl.Transaction.getDefaultApplyToken(); +// mOriginalTransactionToken = SurfaceControl.Transaction.getDefaultApplyToken(); } setupTransactionQueue(); } @@ -1216,7 +1216,7 @@ public class SystemUiProxy implements ISystemUiProxy, NavHandle, SafeCloseable { if (mOriginalTransactionToken == null) { return; } - SurfaceControl.Transaction.setDefaultApplyToken(mOriginalTransactionToken); +// SurfaceControl.Transaction.setDefaultApplyToken(mOriginalTransactionToken); mOriginalTransactionToken = null; } @@ -1225,7 +1225,7 @@ public class SystemUiProxy implements ISystemUiProxy, NavHandle, SafeCloseable { return; } if (mShellTransitions == null) { - SurfaceControl.Transaction.setDefaultApplyToken(mOriginalTransactionToken); +// SurfaceControl.Transaction.setDefaultApplyToken(mOriginalTransactionToken); return; } final IBinder shellApplyToken; @@ -1239,7 +1239,7 @@ public class SystemUiProxy implements ISystemUiProxy, NavHandle, SafeCloseable { Log.e(TAG, "Didn't receive apply token from Shell"); return; } - SurfaceControl.Transaction.setDefaultApplyToken(shellApplyToken); +// SurfaceControl.Transaction.setDefaultApplyToken(shellApplyToken); } // diff --git a/quickstep/src/com/android/quickstep/TaskAnimationManager.java b/quickstep/src/com/android/quickstep/TaskAnimationManager.java index acb686b6d9..6a622911ef 100644 --- a/quickstep/src/com/android/quickstep/TaskAnimationManager.java +++ b/quickstep/src/com/android/quickstep/TaskAnimationManager.java @@ -58,7 +58,7 @@ import java.io.PrintWriter; import java.util.HashMap; public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAnimationListener { - public static final boolean ENABLE_SHELL_TRANSITIONS = true; + public static final boolean ENABLE_SHELL_TRANSITIONS = false; public static final boolean SHELL_TRANSITIONS_ROTATION = ENABLE_SHELL_TRANSITIONS && SystemProperties.getBoolean("persist.wm.debug.shell_transit_rotate", false); diff --git a/quickstep/src/com/android/quickstep/util/GestureExclusionManager.kt b/quickstep/src/com/android/quickstep/util/GestureExclusionManager.kt index 24b0e3aa6e..445db8f240 100644 --- a/quickstep/src/com/android/quickstep/util/GestureExclusionManager.kt +++ b/quickstep/src/com/android/quickstep/util/GestureExclusionManager.kt @@ -17,13 +17,10 @@ package com.android.quickstep.util import android.graphics.Region -import android.os.RemoteException import android.util.Log import android.view.Display.DEFAULT_DISPLAY -import android.view.ISystemGestureExclusionListener import android.view.IWindowManager import android.view.WindowManagerGlobal -import androidx.annotation.BinderThread import androidx.annotation.VisibleForTesting import com.android.launcher3.util.Executors @@ -36,26 +33,26 @@ class GestureExclusionManager(private val windowManager: IWindowManager) { private var lastUnrestrictedOrNull: Region? = null @VisibleForTesting - val exclusionListener = - object : ISystemGestureExclusionListener.Stub() { - @BinderThread - override fun onSystemGestureExclusionChanged( - displayId: Int, - exclusionRegion: Region?, - unrestrictedOrNull: Region? - ) { - if (displayId != DEFAULT_DISPLAY) { - return - } - Executors.MAIN_EXECUTOR.execute { - lastExclusionRegion = exclusionRegion - lastUnrestrictedOrNull = unrestrictedOrNull - listeners.forEach { - it.onGestureExclusionChanged(exclusionRegion, unrestrictedOrNull) - } - } - } - } + val exclusionListener = null +// object : ISystemGestureExclusionListener.Stub() { +// @BinderThread +// override fun onSystemGestureExclusionChanged( +// displayId: Int, +// exclusionRegion: Region?, +// unrestrictedOrNull: Region? +// ) { +// if (displayId != DEFAULT_DISPLAY) { +// return +// } +// Executors.MAIN_EXECUTOR.execute { +// lastExclusionRegion = exclusionRegion +// lastUnrestrictedOrNull = unrestrictedOrNull +// listeners.forEach { +// it.onGestureExclusionChanged(exclusionRegion, unrestrictedOrNull) +// } +// } +// } +// } /** Adds a listener for receiving gesture exclusion regions */ fun addListener(listener: ExclusionListener) { @@ -68,7 +65,7 @@ class GestureExclusionManager(private val windowManager: IWindowManager) { exclusionListener, DEFAULT_DISPLAY ) - } catch (e: RemoteException) { + } catch (e: Throwable) { Log.e(TAG, "Failed to register gesture exclusion listener", e) } } @@ -88,7 +85,7 @@ class GestureExclusionManager(private val windowManager: IWindowManager) { exclusionListener, DEFAULT_DISPLAY ) - } catch (e: RemoteException) { + } catch (e: Throwable) { Log.e(TAG, "Failed to unregister gesture exclusion listener", e) } } diff --git a/quickstep/src/com/android/quickstep/util/SurfaceTransactionApplier.java b/quickstep/src/com/android/quickstep/util/SurfaceTransactionApplier.java index fb56f385a4..2462478d1f 100644 --- a/quickstep/src/com/android/quickstep/util/SurfaceTransactionApplier.java +++ b/quickstep/src/com/android/quickstep/util/SurfaceTransactionApplier.java @@ -75,7 +75,7 @@ public class SurfaceTransactionApplier extends ReleaseCheck { private void initialize(View view) { mTargetViewRootImpl = view.getViewRootImpl(); - mBarrierSurfaceControl = mTargetViewRootImpl.getSurfaceControl(); +// mBarrierSurfaceControl = mTargetViewRootImpl.getSurfaceControl(); mInitialized = true; } @@ -108,7 +108,7 @@ public class SurfaceTransactionApplier extends ReleaseCheck { final int toApplySeqNo = mLastSequenceNumber; setCanRelease(false); mTargetViewRootImpl.registerRtFrameCallback(frame -> { - if (mBarrierSurfaceControl == null || !mBarrierSurfaceControl.isValid()) { + if (mBarrierSurfaceControl == null && !mBarrierSurfaceControl.isValid()) { Message.obtain(mApplyHandler, MSG_UPDATE_SEQUENCE_NUMBER, toApplySeqNo, 0) .sendToTarget(); return; diff --git a/src/com/android/launcher3/Utilities.java b/src/com/android/launcher3/Utilities.java index 26e8253d49..5183dac5c6 100644 --- a/src/com/android/launcher3/Utilities.java +++ b/src/com/android/launcher3/Utilities.java @@ -177,7 +177,7 @@ public final class Utilities { public static final int TRANSLATE_LEFT = 2; public static final int TRANSLATE_RIGHT = 3; - public static final boolean SHOULD_SHOW_FIRST_PAGE_WIDGET = enableSmartspaceAsAWidget() && WIDGET_ON_FIRST_SCREEN; + public static final boolean SHOULD_SHOW_FIRST_PAGE_WIDGET = WIDGET_ON_FIRST_SCREEN; @IntDef({ TRANSLATE_UP, TRANSLATE_DOWN, TRANSLATE_LEFT, TRANSLATE_RIGHT }) public @interface AdjustmentDirection { @@ -698,7 +698,7 @@ public final class Utilities { * options */ public static ActivityOptions allowBGLaunch(ActivityOptions options) { - if (ATLEAST_U) { + if (ATLEAST_V) { options.setPendingIntentBackgroundActivityStartMode( ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED); } diff --git a/systemUIAnim/src/com/android/systemui/animation/RemoteAnimationRunnerCompat.java b/systemUIAnim/src/com/android/systemui/animation/RemoteAnimationRunnerCompat.java index 94f884673f..abfc2c879b 100644 --- a/systemUIAnim/src/com/android/systemui/animation/RemoteAnimationRunnerCompat.java +++ b/systemUIAnim/src/com/android/systemui/animation/RemoteAnimationRunnerCompat.java @@ -38,6 +38,7 @@ import android.window.IRemoteTransition; import android.window.IRemoteTransitionFinishedCallback; import android.window.RemoteTransitionStub; import android.window.TransitionInfo; +import android.window.WindowAnimationState; import com.android.wm.shell.shared.CounterRotator; @@ -45,15 +46,15 @@ public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner private static final String TAG = "RemoteAnimRunnerCompat"; public abstract void onAnimationStart(@WindowManager.TransitionOldType int transit, - RemoteAnimationTarget[] apps, RemoteAnimationTarget[] wallpapers, - RemoteAnimationTarget[] nonApps, Runnable finishedCallback); + RemoteAnimationTarget[] apps, RemoteAnimationTarget[] wallpapers, + RemoteAnimationTarget[] nonApps, Runnable finishedCallback); @Override public final void onAnimationStart(@TransitionOldType int transit, - RemoteAnimationTarget[] apps, - RemoteAnimationTarget[] wallpapers, - RemoteAnimationTarget[] nonApps, - final IRemoteAnimationFinishedCallback finishedCallback) { + RemoteAnimationTarget[] apps, + RemoteAnimationTarget[] wallpapers, + RemoteAnimationTarget[] nonApps, + final IRemoteAnimationFinishedCallback finishedCallback) { onAnimationStart(transit, apps, wallpapers, nonApps, () -> { @@ -65,19 +66,46 @@ public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner }); } - public IRemoteTransition toRemoteTransition() { - return wrap(this); + // Called only in R + public void onAnimationStart(RemoteAnimationTarget[] appTargets, + RemoteAnimationTarget[] wallpaperTargets, IRemoteAnimationFinishedCallback finishedCallback) { + onAnimationStart(0 /* transit */, appTargets, wallpaperTargets, + new RemoteAnimationTarget[0], finishedCallback); } + // Called only in Q + public void onAnimationStart(RemoteAnimationTarget[] appTargets, + IRemoteAnimationFinishedCallback finishedCallback) { + onAnimationStart(appTargets, new RemoteAnimationTarget[0], finishedCallback); + } + + public void onAnimationCancelled(boolean isKeyguardOccluded) { + onAnimationCancelled(); + } + + // Called only in S+ + public void onAnimationCancelled() {} + /** Wraps a remote animation runner in a remote-transition. */ public static RemoteTransitionStub wrap(IRemoteAnimationRunner runner) { return new RemoteTransitionStub() { + @Override + public void startAnimation(IBinder token , TransitionInfo info , SurfaceControl.Transaction t , IRemoteTransitionFinishedCallback finishCallback) throws RemoteException { + + } + }; + } + + public IRemoteTransition toRemoteTransition() { + return new IRemoteTransition.Stub() { final ArrayMap mFinishRunnables = new ArrayMap<>(); + public void onTransitionConsumed(IBinder transition, boolean aborted) {} + @Override public void startAnimation(IBinder token, TransitionInfo info, - SurfaceControl.Transaction t, - IRemoteTransitionFinishedCallback finishCallback) throws RemoteException { + SurfaceControl.Transaction t, + IRemoteTransitionFinishedCallback finishCallback) { final ArrayMap leashMap = new ArrayMap<>(); final RemoteAnimationTarget[] apps = RemoteAnimationTargetCompat.wrapApps(info, t, leashMap); @@ -162,6 +190,8 @@ public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner counterLauncher.addChild(t, leashMap.get(launcherTask.getLeash())); } if (wallpaper != null && rotateDelta != 0 && wallpaper.getParent() != null) { + counterWallpaper.setup(t, info.getChange(wallpaper.getParent()).getLeash(), + rotateDelta, displayW, displayH); final TransitionInfo.Change parent = info.getChange(wallpaper.getParent()); if (parent != null) { counterWallpaper.setup(t, parent.getLeash(), rotateDelta, displayW, @@ -200,7 +230,7 @@ public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner mFinishRunnables.put(token, animationFinishedCallback); } // TODO(bc-unlcok): Pass correct transit type. - runner.onAnimationStart(TRANSIT_OLD_NONE, + onAnimationStart(TRANSIT_OLD_NONE, apps, wallpapers, nonApps, new IRemoteAnimationFinishedCallback() { @Override public void onAnimationFinished() { @@ -219,8 +249,8 @@ public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner @Override public void mergeAnimation(IBinder token, TransitionInfo info, - SurfaceControl.Transaction t, IBinder mergeTarget, - IRemoteTransitionFinishedCallback finishCallback) throws RemoteException { + SurfaceControl.Transaction t, IBinder mergeTarget, + IRemoteTransitionFinishedCallback finishCallback) throws RemoteException { // TODO: hook up merge to recents onTaskAppeared if applicable. Until then, adapt // to legacy cancel. final Runnable finishRunnable; @@ -231,9 +261,14 @@ public abstract class RemoteAnimationRunnerCompat extends IRemoteAnimationRunner t.close(); info.releaseAllSurfaces(); if (finishRunnable == null) return; - runner.onAnimationCancelled(); + onAnimationCancelled(false /* isKeyguardOccluded */); finishRunnable.run(); } + + @Override + public void takeOverAnimation(IBinder transition , TransitionInfo info , SurfaceControl.Transaction t , IRemoteTransitionFinishedCallback finishCallback , WindowAnimationState[] states) throws RemoteException { + + } }; } } diff --git a/systemUIShared/src/com/android/systemui/shared/system/InteractionJankMonitorWrapper.java b/systemUIShared/src/com/android/systemui/shared/system/InteractionJankMonitorWrapper.java index 3250a0cbb3..f1e7c1039a 100644 --- a/systemUIShared/src/com/android/systemui/shared/system/InteractionJankMonitorWrapper.java +++ b/systemUIShared/src/com/android/systemui/shared/system/InteractionJankMonitorWrapper.java @@ -59,7 +59,7 @@ public final class InteractionJankMonitorWrapper { * @param tag the tag to distinguish different flow of same type CUJ. */ public static void begin(View v, @Cuj.CujType int cujType, String tag) { - if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return; + if (true) return; Configuration.Builder builder = Configuration.Builder.withView(cujType, v); if (!TextUtils.isEmpty(tag)) { diff --git a/systemUIShared/src/com/android/systemui/shared/system/QuickStepContract.java b/systemUIShared/src/com/android/systemui/shared/system/QuickStepContract.java index 08e26b4c0f..2b663bf15b 100644 --- a/systemUIShared/src/com/android/systemui/shared/system/QuickStepContract.java +++ b/systemUIShared/src/com/android/systemui/shared/system/QuickStepContract.java @@ -139,7 +139,7 @@ public class QuickStepContract { SYSUI_STATE_WAKEFULNESS_TRANSITION | SYSUI_STATE_AWAKE; // Whether the back gesture is allowed (or ignored) by the Shade - public static final boolean ALLOW_BACK_GESTURE_IN_SHADE = shadeAllowBackGesture(); + public static final boolean ALLOW_BACK_GESTURE_IN_SHADE = false; @Retention(RetentionPolicy.SOURCE) @LongDef({SYSUI_STATE_SCREEN_PINNING, @@ -410,6 +410,11 @@ public class QuickStepContract { * If live rounded corners are supported on windows. */ public static boolean supportsRoundedCornersOnWindows(Resources resources) { - return ScreenDecorationsUtils.supportsRoundedCornersOnWindows(resources); + try { + return ScreenDecorationsUtils.supportsRoundedCornersOnWindows(resources); + + } catch (Throwable t) { + return false; + } } } diff --git a/systemUIShared/src/com/android/systemui/shared/system/TaskStackChangeListeners.java b/systemUIShared/src/com/android/systemui/shared/system/TaskStackChangeListeners.java index cf8ec62f19..823d7f72e6 100644 --- a/systemUIShared/src/com/android/systemui/shared/system/TaskStackChangeListeners.java +++ b/systemUIShared/src/com/android/systemui/shared/system/TaskStackChangeListeners.java @@ -167,7 +167,7 @@ public class TaskStackChangeListeners { if (!mRegistered) { // Register mTaskStackListener to IActivityManager only once if needed. try { - ActivityTaskManager.getService().registerTaskStackListener(this); +// ActivityTaskManager.getService().registerTaskStackListener(this); mRegistered = true; } catch (Exception e) { Log.w(TAG, "Failed to call registerTaskStackListener", e); @@ -184,7 +184,7 @@ public class TaskStackChangeListeners { if (isEmpty && mRegistered) { // Unregister mTaskStackListener once we have no more listeners try { - ActivityTaskManager.getService().unregisterTaskStackListener(this); +// ActivityTaskManager.getService().unregisterTaskStackListener(this); mRegistered = false; } catch (Exception e) { Log.w(TAG, "Failed to call unregisterTaskStackListener", e); diff --git a/wmshell/src/com/android/wm/shell/desktopmode/DesktopTasksController.kt b/wmshell/src/com/android/wm/shell/desktopmode/DesktopTasksController.kt index c5111d6888..952889806c 100644 --- a/wmshell/src/com/android/wm/shell/desktopmode/DesktopTasksController.kt +++ b/wmshell/src/com/android/wm/shell/desktopmode/DesktopTasksController.kt @@ -1377,9 +1377,9 @@ class DesktopTasksController( launchWindowingMode = WINDOWING_MODE_FREEFORM pendingIntentLaunchFlags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK - setPendingIntentBackgroundActivityStartMode( - ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_DENIED - ) +// setPendingIntentBackgroundActivityStartMode( +// ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_DENIED +// ) isPendingIntentBackgroundActivityLaunchAllowedByPermission = true } val wct = WindowContainerTransaction() diff --git a/wmshell/src/com/android/wm/shell/draganddrop/DragAndDropPolicy.java b/wmshell/src/com/android/wm/shell/draganddrop/DragAndDropPolicy.java index a42ca1905e..ed8c7edca9 100644 --- a/wmshell/src/com/android/wm/shell/draganddrop/DragAndDropPolicy.java +++ b/wmshell/src/com/android/wm/shell/draganddrop/DragAndDropPolicy.java @@ -264,9 +264,9 @@ public class DragAndDropPolicy { final ActivityOptions baseActivityOpts = ActivityOptions.makeBasic(); baseActivityOpts.setDisallowEnterPictureInPictureWhileLaunching(true); // Put BAL flags to avoid activity start aborted. - baseActivityOpts.setPendingIntentBackgroundActivityStartMode( - MODE_BACKGROUND_ACTIVITY_START_ALLOWED); - baseActivityOpts.setPendingIntentBackgroundActivityLaunchAllowedByPermission(true); +// baseActivityOpts.setPendingIntentBackgroundActivityStartMode( +// MODE_BACKGROUND_ACTIVITY_START_ALLOWED); +// baseActivityOpts.setPendingIntentBackgroundActivityLaunchAllowedByPermission(true); final Bundle opts = baseActivityOpts.toBundle(); if (session.appData.hasExtra(EXTRA_ACTIVITY_OPTIONS)) { opts.putAll(session.appData.getBundleExtra(EXTRA_ACTIVITY_OPTIONS)); @@ -300,13 +300,13 @@ public class DragAndDropPolicy { ProtoLog.v(ShellProtoLogGroup.WM_SHELL_DRAG_AND_DROP, "Launching intent at position=%d", position); final ActivityOptions baseActivityOpts = ActivityOptions.makeBasic(); - baseActivityOpts.setDisallowEnterPictureInPictureWhileLaunching(true); - baseActivityOpts.setPendingIntentBackgroundActivityStartMode( - MODE_BACKGROUND_ACTIVITY_START_DENIED); +// baseActivityOpts.setDisallowEnterPictureInPictureWhileLaunching(true); +// baseActivityOpts.setPendingIntentBackgroundActivityStartMode( +// MODE_BACKGROUND_ACTIVITY_START_DENIED); // TODO(b/255649902): Rework this so that SplitScreenController can always use the options // instead of a fillInIntent since it's assuming that the PendingIntent is mutable - baseActivityOpts.setPendingIntentLaunchFlags(FLAG_ACTIVITY_NEW_TASK - | FLAG_ACTIVITY_MULTIPLE_TASK); +// baseActivityOpts.setPendingIntentLaunchFlags(FLAG_ACTIVITY_NEW_TASK +// | FLAG_ACTIVITY_MULTIPLE_TASK); final Bundle opts = baseActivityOpts.toBundle(); mStarter.startIntent(session.launchableIntent,