[2/n] Migrate to SynchedDeviceConfig (cffafd6d) · Commits · e / os / android_frameworks_base

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

+82 −78

Original line number	Diff line number	Diff line
		@@ -18,11 +18,6 @@ package com.android.server.wm;

		import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
		import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
		import static com.android.server.wm.LetterboxConfigurationDeviceConfig.KEY_ALLOW_IGNORE_ORIENTATION_REQUEST;
		import static com.android.server.wm.LetterboxConfigurationDeviceConfig.KEY_ENABLE_CAMERA_COMPAT_TREATMENT;
		import static com.android.server.wm.LetterboxConfigurationDeviceConfig.KEY_ENABLE_COMPAT_FAKE_FOCUS;
		import static com.android.server.wm.LetterboxConfigurationDeviceConfig.KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY;
		import static com.android.server.wm.LetterboxConfigurationDeviceConfig.KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY;

		import android.annotation.IntDef;
		import android.annotation.NonNull;
		@@ -44,6 +39,45 @@ final class LetterboxConfiguration {

		private static final String TAG = TAG_WITH_CLASS_NAME ? "LetterboxConfiguration" : TAG_ATM;

		// Whether camera compatibility treatment is enabled.
		// See DisplayRotationCompatPolicy for context.
		private static final String KEY_ENABLE_CAMERA_COMPAT_TREATMENT =
		"enable_compat_camera_treatment";

		private static final boolean DEFAULT_VALUE_ENABLE_CAMERA_COMPAT_TREATMENT = true;

		// Whether enabling rotation compat policy for immersive apps that prevents auto
		// rotation into non-optimal screen orientation while in fullscreen. This is needed
		// because immersive apps, such as games, are often not optimized for all
		// orientations and can have a poor UX when rotated. Additionally, some games rely
		// on sensors for the gameplay so users can trigger such rotations accidentally
		// when auto rotation is on.
		private static final String KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY =
		"enable_display_rotation_immersive_app_compat_policy";

		private static final boolean DEFAULT_VALUE_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY =
		true;

		// Whether ignore orientation request is allowed
		private static final String KEY_ALLOW_IGNORE_ORIENTATION_REQUEST =
		"allow_ignore_orientation_request";

		private static final boolean DEFAULT_VALUE_ALLOW_IGNORE_ORIENTATION_REQUEST = true;

		// Whether sending compat fake focus is enabled for unfocused apps in splitscreen.
		// Some game engines wait to get focus before drawing the content of the app so
		// this needs to be used otherwise the apps get blacked out when they are resumed
		// and do not have focus yet.
		private static final String KEY_ENABLE_COMPAT_FAKE_FOCUS = "enable_compat_fake_focus";

		private static final boolean DEFAULT_VALUE_ENABLE_COMPAT_FAKE_FOCUS = true;

		// Whether translucent activities policy is enabled
		private static final String KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY =
		"enable_letterbox_translucent_activity";

		private static final boolean DEFAULT_VALUE_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY = true;

		/**
		* Override of aspect ratio for fixed orientation letterboxing that is set via ADB with
		* set-fixed-orientation-letterbox-aspect-ratio or via {@link
		@@ -205,26 +239,13 @@ final class LetterboxConfiguration {
		// unresizable apps
		private boolean mIsDisplayAspectRatioEnabledForFixedOrientationLetterbox;

		// Whether letterboxing strategy is enabled for translucent activities. If {@value false}
		// all the feature is disabled
		private boolean mTranslucentLetterboxingEnabled;

		// Allows to enable letterboxing strategy for translucent activities ignoring flags.
		private boolean mTranslucentLetterboxingOverrideEnabled;

		// Whether sending compat fake focus is enabled for unfocused apps in splitscreen. Some game
		// engines wait to get focus before drawing the content of the app so this needs to be used
		// otherwise the apps get blacked out when they are resumed and do not have focus yet.
		private boolean mIsCompatFakeFocusEnabled;

		// Whether we should use split screen aspect ratio for the activity when camera compat treatment
		// is enabled and activity is connected to the camera in fullscreen.
		private final boolean mIsCameraCompatSplitScreenAspectRatioEnabled;

		// Whether camera compatibility treatment is enabled.
		// See DisplayRotationCompatPolicy for context.
		private final boolean mIsCameraCompatTreatmentEnabled;

		// Whether activity "refresh" in camera compatibility treatment is enabled.
		// See RefreshCallbackItem for context.
		private boolean mIsCameraCompatTreatmentRefreshEnabled = true;
		@@ -240,15 +261,8 @@ final class LetterboxConfiguration {
		// LetterboxUiController#shouldIgnoreRequestedOrientation for details.
		private final boolean mIsPolicyForIgnoringRequestedOrientationEnabled;

		// Whether enabling rotation compat policy for immersive apps that prevents auto rotation
		// into non-optimal screen orientation while in fullscreen. This is needed because immersive
		// apps, such as games, are often not optimized for all orientations and can have a poor UX
		// when rotated. Additionally, some games rely on sensors for the gameplay so users can trigger
		// such rotations accidentally when auto rotation is on.
		private final boolean mIsDisplayRotationImmersiveAppCompatPolicyEnabled;

		// Flags dynamically updated with {@link android.provider.DeviceConfig}.
		@NonNull private final LetterboxConfigurationDeviceConfig mDeviceConfig;
		@NonNull private final SynchedDeviceConfig mDeviceConfig;

		LetterboxConfiguration(@NonNull final Context systemUiContext) {
		this(systemUiContext,
		@@ -267,7 +281,6 @@ final class LetterboxConfiguration {
		LetterboxConfiguration(@NonNull final Context systemUiContext,
		@NonNull final LetterboxConfigurationPersister letterboxConfigurationPersister) {
		mContext = systemUiContext;
		mDeviceConfig = new LetterboxConfigurationDeviceConfig(systemUiContext.getMainExecutor());

		mFixedOrientationLetterboxAspectRatio = mContext.getResources().getFloat(
		R.dimen.config_fixedOrientationLetterboxAspectRatio);
		@@ -305,36 +318,34 @@ final class LetterboxConfiguration {
		mIsDisplayAspectRatioEnabledForFixedOrientationLetterbox = mContext.getResources()
		.getBoolean(R.bool
		.config_letterboxIsDisplayAspectRatioForFixedOrientationLetterboxEnabled);
		mTranslucentLetterboxingEnabled = mContext.getResources().getBoolean(
		R.bool.config_letterboxIsEnabledForTranslucentActivities);
		mIsCameraCompatTreatmentEnabled = mContext.getResources().getBoolean(
		R.bool.config_isWindowManagerCameraCompatTreatmentEnabled);
		mIsCameraCompatSplitScreenAspectRatioEnabled = mContext.getResources().getBoolean(
		R.bool.config_isWindowManagerCameraCompatSplitScreenAspectRatioEnabled);
		mIsCompatFakeFocusEnabled = mContext.getResources().getBoolean(
		R.bool.config_isCompatFakeFocusEnabled);
		mIsPolicyForIgnoringRequestedOrientationEnabled = mContext.getResources().getBoolean(
		R.bool.config_letterboxIsPolicyForIgnoringRequestedOrientationEnabled);
		mIsDisplayRotationImmersiveAppCompatPolicyEnabled = mContext.getResources().getBoolean(
		R.bool.config_letterboxIsDisplayRotationImmersiveAppCompatPolicyEnabled);
		mDeviceConfig.updateFlagActiveStatus(
		/* isActive */ mIsCameraCompatTreatmentEnabled,
		/* key */ KEY_ENABLE_CAMERA_COMPAT_TREATMENT);
		mDeviceConfig.updateFlagActiveStatus(
		/* isActive */ mIsDisplayRotationImmersiveAppCompatPolicyEnabled,
		/* key */ KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY);
		mDeviceConfig.updateFlagActiveStatus(
		/* isActive */ true,
		/* key */ KEY_ALLOW_IGNORE_ORIENTATION_REQUEST);
		mDeviceConfig.updateFlagActiveStatus(
		/* isActive */ mIsCompatFakeFocusEnabled,
		/* key */ KEY_ENABLE_COMPAT_FAKE_FOCUS);
		mDeviceConfig.updateFlagActiveStatus(
		/* isActive */ mTranslucentLetterboxingEnabled,
		/* key */ KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY);

		mLetterboxConfigurationPersister = letterboxConfigurationPersister;
		mLetterboxConfigurationPersister.start();

		mDeviceConfig = SynchedDeviceConfig.builder(DeviceConfig.NAMESPACE_WINDOW_MANAGER,
		systemUiContext.getMainExecutor())
		.addDeviceConfigEntry(KEY_ENABLE_CAMERA_COMPAT_TREATMENT,
		DEFAULT_VALUE_ENABLE_CAMERA_COMPAT_TREATMENT,
		mContext.getResources().getBoolean(
		R.bool.config_isWindowManagerCameraCompatTreatmentEnabled))
		.addDeviceConfigEntry(KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY,
		DEFAULT_VALUE_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY,
		mContext.getResources().getBoolean(R.bool
		.config_letterboxIsDisplayRotationImmersiveAppCompatPolicyEnabled))
		.addDeviceConfigEntry(KEY_ALLOW_IGNORE_ORIENTATION_REQUEST,
		DEFAULT_VALUE_ALLOW_IGNORE_ORIENTATION_REQUEST, /* enabled */ true)
		.addDeviceConfigEntry(KEY_ENABLE_COMPAT_FAKE_FOCUS,
		DEFAULT_VALUE_ENABLE_COMPAT_FAKE_FOCUS,
		mContext.getResources().getBoolean(R.bool.config_isCompatFakeFocusEnabled))
		.addDeviceConfigEntry(KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY,
		DEFAULT_VALUE_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY,
		mContext.getResources().getBoolean(
		R.bool.config_letterboxIsEnabledForTranslucentActivities))
		.build();
		}

		/**
		@@ -342,7 +353,7 @@ final class LetterboxConfiguration {
		* via {@link android.provider.DeviceConfig}.
		*/
		boolean isIgnoreOrientationRequestAllowed() {
		return mDeviceConfig.getFlag(KEY_ALLOW_IGNORE_ORIENTATION_REQUEST);
		return mDeviceConfig.getFlagValue(KEY_ALLOW_IGNORE_ORIENTATION_REQUEST);
		}

		/**
		@@ -1049,28 +1060,21 @@ final class LetterboxConfiguration {
		}

		boolean isTranslucentLetterboxingEnabled() {
		return mTranslucentLetterboxingOverrideEnabled \|\| (mTranslucentLetterboxingEnabled
		&& mDeviceConfig.getFlag(KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY));
		}

		void setTranslucentLetterboxingEnabled(boolean translucentLetterboxingEnabled) {
		mTranslucentLetterboxingEnabled = translucentLetterboxingEnabled;
		return mTranslucentLetterboxingOverrideEnabled
		\|\| mDeviceConfig.getFlagValue(KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY);
		}

		void setTranslucentLetterboxingOverrideEnabled(
		boolean translucentLetterboxingOverrideEnabled) {
		mTranslucentLetterboxingOverrideEnabled = translucentLetterboxingOverrideEnabled;
		setTranslucentLetterboxingEnabled(translucentLetterboxingOverrideEnabled);
		}

		/**
		* Resets whether we use the constraints override strategy for letterboxing when dealing
		* with translucent activities {@link R.bool.config_letterboxIsEnabledForTranslucentActivities}.
		* with translucent activities
		* {@link mDeviceConfig.getFlagValue(KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY)}.
		*/
		void resetTranslucentLetterboxingEnabled() {
		final boolean newValue = mContext.getResources().getBoolean(
		R.bool.config_letterboxIsEnabledForTranslucentActivities);
		setTranslucentLetterboxingEnabled(newValue);
		setTranslucentLetterboxingOverrideEnabled(false);
		}

		@@ -1100,15 +1104,7 @@ final class LetterboxConfiguration {

		/** Whether fake sending focus is enabled for unfocused apps in splitscreen */
		boolean isCompatFakeFocusEnabled() {
		return mIsCompatFakeFocusEnabled && mDeviceConfig.getFlag(KEY_ENABLE_COMPAT_FAKE_FOCUS);
		}

		/**
		* Overrides whether fake sending focus is enabled for unfocused apps in splitscreen
		*/
		@VisibleForTesting
		void setIsCompatFakeFocusEnabled(boolean enabled) {
		mIsCompatFakeFocusEnabled = enabled;
		return mDeviceConfig.getFlagValue(KEY_ENABLE_COMPAT_FAKE_FOCUS);
		}

		/**
		@@ -1128,10 +1124,16 @@ final class LetterboxConfiguration {
		return mIsCameraCompatSplitScreenAspectRatioEnabled;
		}

		/** Whether camera compatibility treatment is enabled. */
		/**
		* Whether camera compatibility treatment is enabled.
		*
		* @param checkDeviceConfig whether it should check both build time flag and a dynamic property
		* from {@link DeviceConfig} or only build time flag value.
		*/
		boolean isCameraCompatTreatmentEnabled(boolean checkDeviceConfig) {
		return mIsCameraCompatTreatmentEnabled && (!checkDeviceConfig
		\|\| mDeviceConfig.getFlag(KEY_ENABLE_CAMERA_COMPAT_TREATMENT));
		return mDeviceConfig.isBuildTimeFlagEnabled(KEY_ENABLE_CAMERA_COMPAT_TREATMENT)
		&& (!checkDeviceConfig
		\|\| mDeviceConfig.getFlagValue(KEY_ENABLE_CAMERA_COMPAT_TREATMENT));
		}

		/** Whether camera compatibility refresh is enabled. */
		@@ -1183,12 +1185,14 @@ final class LetterboxConfiguration {
		* orientations and can have a poor UX when rotated. Additionally, some games rely on sensors
		* for the gameplay so users can trigger such rotations accidentally when auto rotation is on.
		*
		* @param checkDeviceConfig whether should check both static config and a dynamic property
		* from {@link DeviceConfig} or only static value.
		* @param checkDeviceConfig whether it should check both build time flag and a dynamic property
		* from {@link DeviceConfig} or only build time flag value.
		*/
		boolean isDisplayRotationImmersiveAppCompatPolicyEnabled(final boolean checkDeviceConfig) {
		return mIsDisplayRotationImmersiveAppCompatPolicyEnabled && (!checkDeviceConfig
		\|\| mDeviceConfig.getFlag(KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY));
		return mDeviceConfig.isBuildTimeFlagEnabled(
		KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY) && (!checkDeviceConfig
		\|\| mDeviceConfig.getFlagValue(
		KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY));
		}

		}

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

deleted100644 → 0

+0 −180

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.server.wm;

		import android.annotation.NonNull;
		import android.provider.DeviceConfig;
		import android.util.ArraySet;

		import com.android.internal.annotations.VisibleForTesting;

		import java.util.Map;
		import java.util.concurrent.Executor;

		/**
		* Utility class that caches {@link DeviceConfig} flags for app compat features and listens
		* to updates by implementing {@link DeviceConfig.OnPropertiesChangedListener}.
		*/
		final class LetterboxConfigurationDeviceConfig
		implements DeviceConfig.OnPropertiesChangedListener {

		static final String KEY_ENABLE_CAMERA_COMPAT_TREATMENT = "enable_compat_camera_treatment";
		private static final boolean DEFAULT_VALUE_ENABLE_CAMERA_COMPAT_TREATMENT = true;

		static final String KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY =
		"enable_display_rotation_immersive_app_compat_policy";
		private static final boolean DEFAULT_VALUE_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY =
		true;

		static final String KEY_ALLOW_IGNORE_ORIENTATION_REQUEST =
		"allow_ignore_orientation_request";
		private static final boolean DEFAULT_VALUE_ALLOW_IGNORE_ORIENTATION_REQUEST = true;

		static final String KEY_ENABLE_COMPAT_FAKE_FOCUS = "enable_compat_fake_focus";
		private static final boolean DEFAULT_VALUE_ENABLE_COMPAT_FAKE_FOCUS = true;

		static final String KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY =
		"enable_letterbox_translucent_activity";

		private static final boolean DEFAULT_VALUE_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY = true;

		@VisibleForTesting
		static final Map<String, Boolean> sKeyToDefaultValueMap = Map.of(
		KEY_ENABLE_CAMERA_COMPAT_TREATMENT,
		DEFAULT_VALUE_ENABLE_CAMERA_COMPAT_TREATMENT,
		KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY,
		DEFAULT_VALUE_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY,
		KEY_ALLOW_IGNORE_ORIENTATION_REQUEST,
		DEFAULT_VALUE_ALLOW_IGNORE_ORIENTATION_REQUEST,
		KEY_ENABLE_COMPAT_FAKE_FOCUS,
		DEFAULT_VALUE_ENABLE_COMPAT_FAKE_FOCUS,
		KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY,
		DEFAULT_VALUE_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY
		);

		// Whether camera compatibility treatment is enabled.
		// See DisplayRotationCompatPolicy for context.
		private boolean mIsCameraCompatTreatmentEnabled =
		DEFAULT_VALUE_ENABLE_CAMERA_COMPAT_TREATMENT;

		// Whether enabling rotation compat policy for immersive apps that prevents auto rotation
		// into non-optimal screen orientation while in fullscreen. This is needed because immersive
		// apps, such as games, are often not optimized for all orientations and can have a poor UX
		// when rotated. Additionally, some games rely on sensors for the gameplay so users can trigger
		// such rotations accidentally when auto rotation is on.
		private boolean mIsDisplayRotationImmersiveAppCompatPolicyEnabled =
		DEFAULT_VALUE_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY;

		// Whether enabling ignoreOrientationRequest is allowed on the device.
		private boolean mIsAllowIgnoreOrientationRequest =
		DEFAULT_VALUE_ALLOW_IGNORE_ORIENTATION_REQUEST;

		// Whether sending compat fake focus for split screen resumed activities is enabled. This is
		// needed because some game engines wait to get focus before drawing the content of the app
		// which isn't guaranteed by default in multi-window modes.
		private boolean mIsCompatFakeFocusAllowed = DEFAULT_VALUE_ENABLE_COMPAT_FAKE_FOCUS;

		// Whether the letterbox strategy for transparent activities is allowed
		private boolean mIsTranslucentLetterboxingAllowed =
		DEFAULT_VALUE_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY;

		// Set of active device configs that need to be updated in
		// DeviceConfig.OnPropertiesChangedListener#onPropertiesChanged.
		private final ArraySet<String> mActiveDeviceConfigsSet = new ArraySet<>();

		LetterboxConfigurationDeviceConfig(@NonNull final Executor executor) {
		DeviceConfig.addOnPropertiesChangedListener(DeviceConfig.NAMESPACE_WINDOW_MANAGER,
		executor, /* onPropertiesChangedListener */ this);
		}

		@Override
		public void onPropertiesChanged(@NonNull final DeviceConfig.Properties properties) {
		for (int i = mActiveDeviceConfigsSet.size() - 1; i >= 0; i--) {
		String key = mActiveDeviceConfigsSet.valueAt(i);
		// Reads the new configuration, if the device config properties contain the key.
		if (properties.getKeyset().contains(key)) {
		readAndSaveValueFromDeviceConfig(key);
		}
		}
		}

		/**
		* Adds {@code key} to a set of flags that can be updated from the server if
		* {@code isActive} is {@code true} and read it's current value from {@link DeviceConfig}.
		*/
		void updateFlagActiveStatus(boolean isActive, String key) {
		if (!isActive) {
		return;
		}
		mActiveDeviceConfigsSet.add(key);
		readAndSaveValueFromDeviceConfig(key);
		}

		/**
		* Returns values of the {@code key} flag.
		*
		* @throws AssertionError {@code key} isn't recognised.
		*/
		boolean getFlag(String key) {
		switch (key) {
		case KEY_ENABLE_CAMERA_COMPAT_TREATMENT:
		return mIsCameraCompatTreatmentEnabled;
		case KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY:
		return mIsDisplayRotationImmersiveAppCompatPolicyEnabled;
		case KEY_ALLOW_IGNORE_ORIENTATION_REQUEST:
		return mIsAllowIgnoreOrientationRequest;
		case KEY_ENABLE_COMPAT_FAKE_FOCUS:
		return mIsCompatFakeFocusAllowed;
		case KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY:
		return mIsTranslucentLetterboxingAllowed;
		default:
		throw new AssertionError("Unexpected flag name: " + key);
		}
		}

		private void readAndSaveValueFromDeviceConfig(String key) {
		Boolean defaultValue = sKeyToDefaultValueMap.get(key);
		if (defaultValue == null) {
		throw new AssertionError("Haven't found default value for flag: " + key);
		}
		switch (key) {
		case KEY_ENABLE_CAMERA_COMPAT_TREATMENT:
		mIsCameraCompatTreatmentEnabled = getDeviceConfig(key, defaultValue);
		break;
		case KEY_ENABLE_DISPLAY_ROTATION_IMMERSIVE_APP_COMPAT_POLICY:
		mIsDisplayRotationImmersiveAppCompatPolicyEnabled =
		getDeviceConfig(key, defaultValue);
		break;
		case KEY_ALLOW_IGNORE_ORIENTATION_REQUEST:
		mIsAllowIgnoreOrientationRequest = getDeviceConfig(key, defaultValue);
		break;
		case KEY_ENABLE_COMPAT_FAKE_FOCUS:
		mIsCompatFakeFocusAllowed = getDeviceConfig(key, defaultValue);
		break;
		case KEY_ENABLE_LETTERBOX_TRANSLUCENT_ACTIVITY:
		mIsTranslucentLetterboxingAllowed = getDeviceConfig(key, defaultValue);
		break;
		default:
		throw new AssertionError("Unexpected flag name: " + key);
		}
		}

		private boolean getDeviceConfig(String key, boolean defaultValue) {
		return DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_WINDOW_MANAGER,
		key, defaultValue);
		}
		}

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

deleted100644 → 0

+0 −109

File deleted.

Preview size limit exceeded, changes collapsed.