![](https://developer.android.com/static/images/about/versions/13/app-compat-dev-options-13.png)**Figure 1**. The App Compatibility Changes screen in developer options lists the changes that you can toggle.

This page describes toggleable changes that are part of the compatibility framework in Android 13 (API level 33). Use this list in conjunction with the[developer options and ADB commands](https://developer.android.com/guide/app-compatibility/test-debug)to test and debug your app as you prepare to support and target Android 13.

Here are some of the things you can do using the compatibility framework tools:

- **Test targeted changes without actually changing the app's targetSdkVersion**. You can use the toggles to force-enable specific targeted behavior changes to evaluate the impact on your existing app.
- **Focus your testing on specific changes only**. Rather than having to address all targeted changes at once, the toggles let you disable all targeted changes except the ones you want to test against.
- **Manage toggles through adb**. You can use adb commands to enable and disable the toggleable changes in your automated test environment.
- **Debug faster using standard change IDs**. Toggleable changes each have a unique ID and name that you can use to quickly debug root cause in log output.

For complete details on using the tools for each of these use cases, see[Compatibility framework tools](https://developer.android.com/guide/app-compatibility/test-debug).

## Behavior changes included in the compatibility framework

The list in this section describes toggleable changes that are included in the compatibility framework in Android 13.

You can filter the list of changes by**Default State**.  
Enabled for all appsEnabled when targeting Android 13Disabled for all appsLogging only

|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Toggleable changes in the compatibility framework in Android 13                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| |
| ### `ACCOUNT_ACCESS_CHECK_CHANGE_ID` **Change ID:** 201794303 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, enables checking for account access for the calling UID on all sync-related APIs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ### `ALLOW_COPY_SOLID_COLOR_VIEW` **Change ID:** 205907456 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows an app to receive the[`SplashScreen.OnExitAnimationListener.onSplashScreenExit(SplashScreenView)`](https://developer.android.com/reference/android/window/SplashScreen.OnExitAnimationListener#onSplashScreenExit(android.window.SplashScreenView))callback, even when the splash screen only shows a solid color.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ### `ALLOW_SECURE_ACTIVITY_DISPLAY_ON_REMOTE_DEVICE` **Change ID:** 201712607 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows a secure activity to display on remote devices if required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ### `BORINGLAYOUT_FALLBACK_LINESPACING` **Change ID:** 210923482 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, enables the fallback text line spacing (line height) for`BoringLayout`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ### `CALL_REDIRECTION_AUDIO_MODES` **Change ID:** 189472651 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows use of audio modes for call audio redirection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ### `CAMERA_MIC_INDICATORS_NOT_PRESENT` **Change ID:** 162547999 **Default State** : Disabled for all apps. Indicates that this device supports camera and microphone indicators. Will be`false`if present, because the[`CompatChanges#isChangeEnabled`](https://cs.android.com/android/platform/superproject/main/+/main:frameworks/base/core/java/android/app/compat/CompatChanges.java;l=58?q=isChangeEnabled)method returns`true`if the Change ID is not present.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ### `CLEAR_SHOW_FORCED_FLAG_WHEN_LEAVING` **Change ID:** 214016041 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, prevents the[`SHOW_FORCED`](https://developer.android.com/reference/android/view/inputmethod/InputMethodManager#SHOW_FORCED)flag from having any effect unless the caller is currently focused.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ### `DEFER_BOOT_COMPLETED_BROADCAST_CHANGE_ID` **Change ID:** 203704822 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, defer`LOCKED_BOOT_COMPLETED`and`BOOT_COMPLETED`broadcasts until the first time any process in the UID is started.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ### `DISALLOW_DEADLINES_FOR_PREFETCH_JOBS` **Change ID:** 194532703 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, disallows setting a deadline (using[`JobInfo.Builder.setOverrideDeadline(long)`](https://developer.android.com/reference/android/app/job/JobInfo.Builder#setOverrideDeadline(long))) for prefetch jobs ([`JobInfo.Builder.setPrefetch(boolean)`](https://developer.android.com/reference/android/app/job/JobInfo.Builder#setPrefetch(boolean)). Prefetch jobs are meant to run close to the next app launch, so they are not allowed to have deadlines. However, the system doesn't drop or cancel any previously scheduled prefetch jobs with a deadline. There's no way for an app to keep a perpetually-scheduled prefetch job with a deadline. Prefetch jobs with a deadline will run and apps under this restriction won't be able to schedule new prefetch jobs with a deadline. If a job is rescheduled by providing`true`using the return value from[`JobService.jobFinished(JobParameters, boolean)`](https://developer.android.com/reference/android/app/job/JobService#jobFinished(android.app.job.JobParameters,%20boolean))or[`JobService.onStopJob(JobParameters)`](https://developer.android.com/reference/android/app/job/JobService#onStopJob(android.app.job.JobParameters)), the deadline is dropped. Periodic jobs require all constraints to be met, so these restrictions do not apply to their deadlines.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ### `DOWNSCALED` **Change ID:** 168419799 **Default State** : Disabled for all apps. This change is the gatekeeper of all per-app buffer downscaling changes. Enabling this change allows the following scaling factors to be applied: - [`DOWNSCALE_30`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_30) - [`DOWNSCALE_35`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_35) - [`DOWNSCALE_40`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_40) - [`DOWNSCALE_45`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_45) - [`DOWNSCALE_50`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_50) - [`DOWNSCALE_55`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_55) - [`DOWNSCALE_60`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_60) - [`DOWNSCALE_65`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_65) - [`DOWNSCALE_70`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_70) - [`DOWNSCALE_75`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_75) - [`DOWNSCALE_80`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_80) - [`DOWNSCALE_85`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_85) - [`DOWNSCALE_90`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_90) When this change is enabled for an app package, the app is forcibly resized to the highest, enabled scaling factor. For example, 80% is used if both 80% and 70% ([`DOWNSCALE_80`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_80)and[`DOWNSCALE_70`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscale_70)) are enabled. |
| ### `DOWNSCALE_30` **Change ID:** 189970040 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 30% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_35` **Change ID:** 189969749 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 35% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_40` **Change ID:** 189970038 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 40% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_45` **Change ID:** 189969782 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 45% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_50` **Change ID:** 176926741 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 50% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_55` **Change ID:** 189970036 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 55% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_60` **Change ID:** 176926771 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 60% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_65` **Change ID:** 189969744 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 65% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_70` **Change ID:** 176926829 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 70% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_75` **Change ID:** 189969779 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 75% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_80` **Change ID:** 176926753 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 80% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_85` **Change ID:** 189969734 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 85% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DOWNSCALE_90` **Change ID:** 182811243 **Default State** : Disabled for all apps. When[`DOWNSCALED`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#downscaled)is also enabled, enabling this change for a package forces the app to assume it's running on a display with 90% of the vertical and horizontal resolution of the real display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `DUMP_IGNORES_SPECIAL_ARGS` **Change ID:** 149254050 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher,[`dump(String, FileDescriptor, PrintWriter, String[])`](https://developer.android.com/reference/android/app/Activity#dump(java.lang.String,%20java.io.FileDescriptor,%20java.io.PrintWriter,%20java.lang.String[]))is not called if`dumpsys activity`is called with some special arguments.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ### `DYNAMIC_RECEIVER_EXPLICIT_EXPORT_REQUIRED` **Change ID:** 161145287 **Default State** : Disabled for all apps. When enabled, requires an app to explicitly set either`Context.RECEIVER_EXPORTED`or`Context.RECEIVER_NOT_EXPORTED`when registering a receiver for an unprotected broadcast in code. To learn more, see the section on[Safer exporting of context-registered receivers](https://developer.android.com/about/versions/13/features#runtime-receivers).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ### `ENABLE_PENDING_INTENT_BAL_OPTION` **Change ID:** 192341120 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, protects`PendingIntent`from being abused to start background activity.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ### `ENABLE_SIMPLIFIED_DARK_MODE` **Change ID:** 214741472 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows web content to apply light or dark style according to the app's theme and WebView to attempt to darken web content by algorithmic darkening when appropriate. Refer to[`setAlgorithmicDarkeningAllowed(boolean)`](https://developer.android.com/reference/android/webkit/WebSettings#setAlgorithmicDarkeningAllowed(boolean))for details.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ### `ENABLE_TOUCH_OPAQUE_ACTIVITIES` **Change ID:** 194480991 **Default State** : Enabled for all apps. For apps running on Android 13 (API level 33) or higher, makes activities consume all touches within their task bounds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ### `ENABLE_USE_EXACT_ALARM` **Change ID:** 218533173 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows certain kinds of apps to use[`Manifest.permission.USE_EXACT_ALARM`](https://developer.android.com/reference/android/Manifest.permission#USE_EXACT_ALARM)to schedule exact alarms.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ### `ENFORCE_INTENTS_TO_MATCH_INTENT_FILTERS` **Change ID:** 161252188 **Default State** : Enabled for all apps. Components will stop receiving intents from external callers that do not match its declared intent filters. When an app registers an exported component in its manifest and adds an intent filter, the component can be started by any intent, even those that do not match the intent filter. This has proven to be something that many developers find counterintuitive. Without checking the intent when the component is started, in some circumstances this can allow third- party apps to trigger internal-only functionality.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ### `ENFORCE_STRICT_QUERY_BUILDER` **Change ID:** 143231523 **Default State** : Disabled for all apps. When enabled, the`SQLiteQueryBuilder`verifies all`CalendarProvider2`query selections against malicious arguments.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ### `FORCE_DISABLE_HEVC_SUPPORT` **Change ID:** 174227820 **Default State** : Disabled for all apps. Force disable an app from supporting the HEVC media capability. Apps should declare their supported media capabilities in their manifest but this flag can be used to force an app into not supporting HEVC, hence forcing transcoding while accessing media encoded in HEVC. Setting this flag overrides any OS level defaults for apps. It is disabled by default, meaning that the OS defaults take precedence. If both this flag and`FORCE_ENABLE_HEVC_SUPPORT`are enabled, the OS ignores both flags.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ### `FORCE_ENABLE_HEVC_SUPPORT` **Change ID:** 174228127 **Default State** : Disabled for all apps. Force enable an app to support the HEVC media capability Apps should declare their supported media capabilities in their manifest but this flag can be used to force an app into supporting HEVC, hence avoiding transcoding while accessing media encoded in HEVC. Setting this flag overrides any OS level defaults for apps. It is disabled by default, meaning that the OS defaults would take precedence. If both this flag and`FORCE_DISABLE_HEVC_SUPPORT`are enabled, the OS ignores both flags.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ### `FORCE_NON_RESIZE_APP` **Change ID:** 181136395 **Default State** : Disabled for all apps. Forces the packages it is applied to to be nonresizable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ### `FORCE_RESIZE_APP` **Change ID:** 174042936 **Default State** : Disabled for all apps. Forces the packages it is applied to to be resizable. We only allow resizing in fullscreen windowing mode, but not forcing the app into resizable multi-windowing mode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ### `GET_API_SIGNATURES_FROM_UICC_PORT_INFO` **Change ID:** 202110963 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows a SIM card can have more than one ICCID active at the same time. Support for this is provided by Multiple Enabled Profiles (MEP).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ### `GWP_ASAN` **Change ID:** 135634846 **Default State** : Disabled for all apps. Enables sampled native memory bug detection in apps. To learn more about using GWP-ASan, see the[GWP-ASan guide](https://developer.android.com/ndk/guides/gwp-asan).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ### `ICC_CLOSE_CHANNEL_EXCEPTION_ON_FAILURE` **Change ID:** 208739934 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, an exception is now thrown whenever an ICC close channel operation fails.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ### `MEDIA_CONTROL_SESSION_ACTIONS` **Change ID:** 203800354 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, media controls based on[`Notification.MediaStyle`](https://developer.android.com/reference/android/app/Notification.MediaStyle)notifications now have actions based on the media session's[`PlaybackState`](https://developer.android.com/reference/android/media/session/PlaybackState), rather than the notification's actions. To learn more about this change, see the section in the Android 13 behavior changes page about the[changes to media controls](https://developer.android.com/about/versions/13/behavior-changes-13#playback-controls).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ### `NATIVE_HEAP_ZERO_INIT` **Change ID:** 178038272 **Default State** : Disabled for all apps. Enable automatic zero-initialization of native heap memory allocations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ### `NATIVE_MEMTAG_ASYNC` **Change ID:** 135772972 **Default State** : Disabled for all apps. Enable asynchronous (ASYNC) memory tag checking in this process. This flag only affects hardware supporting the ARM Memory Tagging Extension (MTE).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ### `NATIVE_MEMTAG_SYNC` **Change ID:** 177438394 **Default State** : Disabled for all apps. Enables synchronous (SYNC) memory tag checking in this process. This flag only affects hardware supporting the ARM Memory Tagging Extension (MTE). If both`NATIVE_MEMTAG_ASYNC`and this option are enabled, this option takes precedence and MTE is enabled in SYNC mode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `NOTIFICATION_LOG_ASSISTANT_CANCEL` **Change ID:** 195579280 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, enables listeners to understand the more specific reason provided for notification cancellations from an assistant, rather than using the more general`REASON_LISTENER_CANCEL`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ### `NOTIFICATION_PERM_CHANGE_ID` **Change ID:** 194833441 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, enables behavior changes related to the runtime permission for notifications. To learn more about this change, see the page about the new[notification runtime permission](https://developer.android.com/about/versions/13/changes/notification-permission).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `NOTIFICATION_TRAMPOLINE_BLOCK_FOR_EXEMPT_ROLES` **Change ID:** 227752274 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher,`Activity`starts coming from broadcast receivers or services in response to notification and notification action clicks are be blocked for UX and performance reasons for previously-exempt role holders (browsers).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ### `OVERRIDABLE_COMPONENT_CALLBACKS` **Change ID:** 193247900 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher,[`registerComponentCallbacks(ComponentCallbacks)`](https://developer.android.com/reference/android/content/Context#registerComponentCallbacks(android.content.ComponentCallbacks))adds a[`ComponentCallbacks`](https://developer.android.com/reference/android/content/ComponentCallbacks)to[`Activity`](https://developer.android.com/reference/android/app/Activity)or[`ContextWrapper.getBaseContext()`](https://developer.android.com/reference/android/content/ContextWrapper#getBaseContext())instead of always adding to[`getApplicationContext()`](https://developer.android.com/reference/android/content/Context#getApplicationContext()).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ### `OVERRIDE_CAMERA_RESIZABLE_AND_SDK_CHECK` **Change ID:** 191513214 **Default State** : Disabled for all apps. When enabled this change id forces the packages it is applied to ignore the current value of`android:resizeableActivity`as well as target SDK equal to or below M and consider the activity as nonresizable. In this case, the value of camera rotate and crop will only depend on the needed compensation considering the current display rotation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ### `OVERRIDE_CAMERA_ROTATE_AND_CROP_DEFAULTS` **Change ID:** 189229956 **Default State** : Disabled for all apps. When enabled this change id forces the packages it is applied to override the default camera rotate and crop behavior and always return`CaptureRequest.SCALER_ROTATE_AND_CROP_NONE`. The default behavior along with all possible override combinations is discussed in the table below.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ### `OVERRIDE_MIN_ASPECT_RATIO` **Change ID:** 174042980 **Default State** : Disabled for all apps. This change is the gatekeeper of all changes that force a given minimum aspect ratio. Enabling this change allows the following minimum aspect ratios to be applied: - [`OVERRIDE_MIN_ASPECT_RATIO_LARGE`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio_large) - [`OVERRIDE_MIN_ASPECT_RATIO_MEDIUM`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio_medium) - [`OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio_portrait_only) When this change is enabled for an app package, the minimum aspect ratio given in the app's manifest is overridden to the largest enabled aspect ratio unless the app's manifest value is higher.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ### `OVERRIDE_MIN_ASPECT_RATIO_LARGE` **Change ID:** 180326787 **Default State** : Disabled for all apps. When[`OVERRIDE_MIN_ASPECT_RATIO`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio)is also enabled, enabling this change for a package sets the activity's minimum aspect ratio to a large value as defined by`OVERRIDE_MIN_ASPECT_RATIO_LARGE_VALUE`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ### `OVERRIDE_MIN_ASPECT_RATIO_MEDIUM` **Change ID:** 180326845 **Default State** : Disabled for all apps. When[`OVERRIDE_MIN_ASPECT_RATIO`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio)is also enabled, enabling this change for a package sets the activity's minimum aspect ratio to a medium value as defined by`OVERRIDE_MIN_ASPECT_RATIO_MEDIUM_VALUE`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ### `OVERRIDE_MIN_ASPECT_RATIO_PORTRAIT_ONLY` **Change ID:** 203647190 **Default State** : Enabled for all apps. When[`OVERRIDE_MIN_ASPECT_RATIO`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio)is also enabled, this change limits any other changes that force an activity's minimum aspect ratio to a certain value---such as[`OVERRIDE_MIN_ASPECT_RATIO_LARGE`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio_large)and[`OVERRIDE_MIN_ASPECT_RATIO_MEDIUM`](https://developer.android.com/about/versions/13/reference/compat-framework-changes#override_min_aspect_ratio_medium)---to activities that also have a portrait orientation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ### `RATE_LIMIT_TOASTS` **Change ID:** 174840628 **Default State** : This change can't be toggled. It is only logged by the compatibility framework. Enables rate limiting on the number of[`Toast.show()`](https://developer.android.com/reference/android/widget/Toast#show())calls to prevent overburdening the user with too many toasts in a limited time. Any attempt to show more toasts than allowed in a certain timeframe results in the toast being discarded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ### `REQUEST_LISTENING_MUST_MATCH_PACKAGE` **Change ID:** 172251878 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, calling[`TileService.requestListeningState(Context, ComponentName)`](https://developer.android.com/reference/android/service/quicksettings/TileService#requestListeningState(android.content.Context,%20android.content.ComponentName))checks that the calling package (UID) and the package of the target[`ComponentName`](https://developer.android.com/reference/android/content/ComponentName)match. The system also checks that the context used can take actions on behalf of the current user.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ### `RETURN_ADVANCED_VIDEO_PROFILES` **Change ID:** 206033068 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, controls the kind of video profiles returned by[`getAll(String, int)`](https://developer.android.com/reference/android/media/CamcorderProfile#getAll(java.lang.String,%20int)).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ### `SHOULD_RESOLVE_PORT_INDEX_FOR_APPS` **Change ID:** 224562872 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, allows SIM cards to enable Multiple Enabled Profiles (MEP) on different ports. To preserve backward compatibility for carrier apps, when an app that targets API level 32 or lower calls the`switchToSubscription`or download APIs without specifying the port index, the system retains the existing behaviour by always using port index 0 even if the device itself has MEP eUICC enabled.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ### `SWITCH_WITHOUT_PORT_INDEX_EXCEPTION_ON_DISABLE` **Change ID:** 218393363 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, the system throws an exception whenever[`switchToSubscription()`](https://developer.android.com/reference/android/telephony/euicc/EuiccManager#switchToSubscription(int,%20int,%20android.app.PendingIntent))is called without`portIndex`to disable a subscription.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ### `THROW_ON_INVALID_PRIORITY_VALUE` **Change ID:** 140852299 **Default State** : Enabled for apps that target Android 13 (API level 33) or higher. For apps targeting Android 13 (API level 33) and higher, the system throws an exception when an app provides an invalid priority value using[`JobInfo.Builder.setPriority(int)`](https://developer.android.com/reference/android/app/job/JobInfo.Builder#setPriority(int)). Legacy apps may be incorrectly using the API, so the call silently fails if they continue using the API.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ### `USE_EXPERIMENTAL_COMPONENT_ALIAS` **Change ID:** 196254758 **Default State** : Disabled for all apps. When enabled, the system allows the "android" package to use component aliases.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |