Verhaltensänderungen: Apps, die auf Android 15 oder höher ausgerichtet sind

Wie bei früheren Versionen enthält Android 15 Verhaltensänderungen, die sich auf Ihre App auswirken können. Die folgenden Verhaltensänderungen gelten ausschließlich für Apps, die auf Android 15 oder höher ausgerichtet sind. Wenn Ihre App auf Android 15 oder höher ausgerichtet ist, sollten Sie sie entsprechend anpassen.

Sehen Sie sich auch die Liste der Verhaltensänderungen an, die sich auf alle Apps auswirken, die unter Android 15 ausgeführt werden, unabhängig vom targetSdkVersion Ihrer App.

Hauptfunktion

In Android 15 werden verschiedene Kernfunktionen des Android-Systems geändert oder erweitert.

Änderungen an Vordergrunddiensten

We are making the following changes to foreground services with Android 15.

• Data sync foreground service timeout behavior
• New media processing foreground service type
• Restrictions on BOOT_COMPLETED broadcast receivers launching foreground services
• Restrictions on starting foreground services while an app holds the SYSTEM_ALERT_WINDOW permission

Data sync foreground service timeout behavior

Android 15 introduces a new timeout behavior to dataSync for apps targeting Android 15 (API level 35) or higher. This behavior also applies to the new mediaProcessing foreground service type.

The system permits an app's dataSync services to run for a total of 6 hours in a 24-hour period, after which the system calls the running service's Service.onTimeout(int, int) method (introduced in Android 15). At this time, the service has a few seconds to call Service.stopSelf(). When Service.onTimeout() is called, the service is no longer considered a foreground service. If the service does not call Service.stopSelf(), the system throws an internal exception. The exception is logged in Logcat with the following message:

Fatal Exception: android.app.RemoteServiceException: "A foreground service of
type dataSync did not stop within its timeout: [component name]"

Note: The 6-hour time limit is shared by all of an app's dataSync foreground services. For example, if an app runs a dataSync service for four hours, then starts a different dataSync service, that second service will only be allowed to run for two hours. However, if the user brings the app to the foreground, the timer resets and the app has 6 hours available.

To avoid problems with this behavior change, you can do one or more of the following:

1. Have your service implement the new Service.onTimeout(int, int) method. When your app receives the callback, make sure to call stopSelf() within a few seconds. (If you don't stop the app right away, the system generates a failure.)
2. Make sure your app's dataSync services don't run for more than a total of 6 hours in any 24-hour period (unless the user interacts with the app, resetting the timer).
3. Only start dataSync foreground services as a result of direct user interaction; since your app is in the foreground when the service starts, your service has the full six hours after the app goes to the background.
4. Instead of using a dataSync foreground service, use an alternative API.

If your app's dataSync foreground services have run for 6 hours in the last 24, you cannot start another dataSync foreground service unless the user has brought your app to the foreground (which resets the timer). If you try to start another dataSync foreground service, the system throws ForegroundServiceStartNotAllowedException with an error message like "Time limit already exhausted for foreground service type dataSync".

Testing

To test your app's behavior, you can enable data sync timeouts even if your app is not targeting Android 15 (as long as the app is running on an Android 15 device). To enable timeouts, run the following adb command:

adb shell am compat enable FGS_INTRODUCE_TIME_LIMITS your-package-name

You can also adjust the timeout period, to make it easier to test how your app behaves when the limit is reached. To set a new timeout period, run the following adb command:

adb shell device_config put activity_manager data_sync_fgs_timeout_duration duration-in-milliseconds

New media processing foreground service type

Android 15 introduces a new foreground service type, mediaProcessing. This service type is appropriate for operations like transcoding media files. For example, a media app might download an audio file and need to convert it to a different format before playing it. You can use a mediaProcessing foreground service to make sure the conversion continues even while the app is in the background.

The system permits an app's mediaProcessing services to run for a total of 6 hours in a 24-hour period, after which the system calls the running service's Service.onTimeout(int, int) method (introduced in Android 15). At this time, the service has a few seconds to call Service.stopSelf(). If the service does not call Service.stopSelf(), the system throws an internal exception. The exception is logged in Logcat with the following message:

Fatal Exception: android.app.RemoteServiceException: "A foreground service of
type mediaProcessing did not stop within its timeout: [component name]"

Note: The 6-hour time limit is shared by all of an app's mediaProcessing foreground services. For example, if an app runs a mediaProcessing service for four hours, then starts a different mediaProcessing service, that second service will only be allowed to run for two hours. However, if the user brings the app to the foreground, the timer resets and the app has 6 hours available.

To avoid having the exception, you can do one of the following:

1. Have your service implement the new Service.onTimeout(int, int) method. When your app receives the callback, make sure to call stopSelf() within a few seconds. (If you don't stop the app right away, the system generates a failure.)
2. Make sure your app's mediaProcessing services don't run for more than a total of 6 hours in any 24-hour period (unless the user interacts with the app, resetting the timer).
3. Only start mediaProcessing foreground services as a result of direct user interaction; since your app is in the foreground when the service starts, your service has the full six hours after the app goes to the background.
4. Instead of using a mediaProcessing foreground service, use an alternative API, like WorkManager.

If your app's mediaProcessing foreground services have run for 6 hours in the last 24, you cannot start another mediaProcessing foreground service unless the user has brought your app to the foreground (which resets the timer). If you try to start another mediaProcessing foreground service, the system throws ForegroundServiceStartNotAllowedException with an error message like "Time limit already exhausted for foreground service type mediaProcessing".

For more information about the mediaProcessing service type, see Changes to foreground service types for Android 15: Media processing.

Testing

To test your app's behavior, you can enable media processing timeouts even if your app is not targeting Android 15 (as long as the app is running on an Android 15 device). To enable timeouts, run the following adb command:

adb shell am compat enable FGS_INTRODUCE_TIME_LIMITS your-package-name

You can also adjust the timeout period, to make it easier to test how your app behaves when the limit is reached. To set a new timeout period, run the following adb command:

adb shell device_config put activity_manager media_processing_fgs_timeout_duration duration-in-milliseconds

Restrictions on BOOT_COMPLETED broadcast receivers launching foreground services

There are new restrictions on BOOT_COMPLETED broadcast receivers launching foreground services. BOOT_COMPLETED receivers are not allowed to launch the following types of foreground services:

• dataSync
• camera
• mediaPlayback
• phoneCall
• mediaProjection
• microphone (this restriction has been in place for microphone since Android 14)

If a BOOT_COMPLETED receiver tries to launch any of those types of foreground services, the system throws ForegroundServiceStartNotAllowedException.

Testing

To test your app's behavior, you can enable these new restrictions even if your app is not targeting Android 15 (as long as the app is running on an Android 15 device). Run the following adb command:

adb shell am compat enable FGS_BOOT_COMPLETED_RESTRICTIONS your-package-name

To send a BOOT_COMPLETED broadcast without restarting the device, run the following adb command:

adb shell am broadcast -a android.intent.action.BOOT_COMPLETED your-package-name

Restrictions on starting foreground services while an app holds the SYSTEM_ALERT_WINDOW permission

Previously, if an app held the SYSTEM_ALERT_WINDOW permission, it could launch a foreground service even if the app was currently in the background (as discussed in exemptions from background start restrictions).

If an app targets Android 15, this exemption is now narrower. The app now needs to have the SYSTEM_ALERT_WINDOW permission and also have a visible overlay window. That is, the app needs to first launch a TYPE_APPLICATION_OVERLAY window and the window needs to be visible before you start a foreground service.

If your app attempts to start a foreground service from the background without meeting these new requirements (and it does not have some other exemption), the system throws ForegroundServiceStartNotAllowedException.

If your app declares the SYSTEM_ALERT_WINDOW permission and launches foreground services from the background, it may be affected by this change. If your app gets a ForegroundServiceStartNotAllowedException, check your app's order of operations and make sure your app already has an active overlay window before it attempts to start a foreground service from the background. You can check if your overlay window is currently visible by calling View.getWindowVisibility(), or you can override View.onWindowVisibilityChanged() to get notified whenever the visibility changes.

Testing

To test your app's behavior, you can enable these new restrictions even if your app is not targeting Android 15 (as long as the app is running on an Android 15 device). To enable these new restrictions on starting foreground services from the background, run the following adb command:

adb shell am compat enable FGS_SAW_RESTRICTIONS your-package-name

Änderungen daran, wann Apps den globalen Status des Modus „Bitte nicht stören“ ändern können

以 Android 15（API 级别 35）及更高版本为目标平台的应用无法再更改设备上的勿扰 (DND) 功能的全局状态或政策（无论是通过修改用户设置还是关闭勿扰模式）。相反，应用必须提供 AutomaticZenRule，系统会将其与现有的“最严格的政策优先”方案合并为一个全局政策。对之前会影响全局状态的现有 API 的调用（setInterruptionFilter、setNotificationPolicy）会导致创建或更新隐式 AutomaticZenRule，该 AutomaticZenRule 会根据这些 API 调用的调用周期开启和关闭。

请注意，只有当应用调用 setInterruptionFilter(INTERRUPTION_FILTER_ALL) 并希望该调用停用之前由其所有者激活的 AutomaticZenRule 时，此更改才会影响可观察到的行为。

OpenJDK-API-Änderungen

In Android 15 werden die Core-Bibliotheken von Android weiter aktualisiert, um sie an die Funktionen in den neuesten OpenJDK-LTS-Releases anzupassen.

Einige dieser Änderungen können sich auf die App-Kompatibilität von Apps auswirken, die auf Android 15 (API-Level 35) ausgerichtet sind:

• Änderungen an APIs für die Stringformatierung: Die Validierung von Argumentindex, Flags, Breite und Genauigkeit ist jetzt strenger, wenn die folgenden String.format()- und Formatter.format()-APIs verwendet werden:

  • String.format(String, Object[])
  • String.format(Locale, String, Object[])
  • Formatter.format(String, Object[])
  • Formatter.format(Locale, String, Object[])

  Die folgende Ausnahme wird beispielsweise ausgelöst, wenn ein Argumentindex von 0 verwendet wird (%0 im Formatstring):

  IllegalFormatArgumentIndexException: Illegal format argument index = 0
  

  In diesem Fall kann das Problem behoben werden, indem Sie den Argumentindex 1 (%1 im Formatstring) verwenden.

• Änderungen am Komponententyp von Arrays.asList(...).toArray(): Bei Verwendung von Arrays.asList(...).toArray() ist der Komponententyp des resultierenden Arrays jetzt ein Object und nicht der Typ der Elemente des zugrunde liegenden Arrays. Der folgende Code löst also eine ClassCastException aus:

  String[] elements = (String[]) Arrays.asList("one", "two").toArray();
  

  Um in diesem Fall String als Komponententyp im resultierenden Array beizubehalten, können Sie stattdessen Collection.toArray(Object[]) verwenden:

  String[] elements = Arrays.asList("two", "one").toArray(new String[0]);
  

• Änderungen bei der Verarbeitung von Sprachcodes: Wenn Sie die Locale API verwenden, werden Sprachcodes für Hebräisch, Jiddisch und Indonesisch nicht mehr in ihre veralteten Formen konvertiert (Hebräisch: iw, Jiddisch: ji und Indonesisch: in). Wenn Sie den Sprachcode für eines dieser Gebietsschemas angeben, verwenden Sie stattdessen die Codes aus ISO 639-1 (Hebräisch: he, Jiddisch: yi und Indonesisch: id).

• Änderungen an zufälligen Ganzzahlfolgen: Nach den Änderungen in https://bugs.openjdk.org/browse/JDK-8301574 geben die folgenden Random.ints()-Methoden jetzt eine andere Zahlenfolge als die Random.nextInt()-Methoden zurück:

  • Random.ints(long)
  • Random.ints(long, int, int)
  • Random.ints(int, int)
  • Random.ints()

  Im Allgemeinen sollte diese Änderung nicht zu einem fehlerhaften Verhalten der App führen. Ihr Code sollte jedoch nicht davon ausgehen, dass die Sequenz, die von Random.ints()-Methoden generiert wird, mit Random.nextInt() übereinstimmt.

Die neue API SequencedCollection kann sich auf die Kompatibilität Ihrer App auswirken, nachdem Sie compileSdk in der Build-Konfiguration Ihrer App aktualisiert haben, um Android 15 (API-Level 35) zu verwenden:

• Kollision mit den Erweiterungsfunktionen MutableList.removeFirst() und MutableList.removeLast() in kotlin-stdlib

  Der Typ List in Java wird dem Typ MutableList in Kotlin zugeordnet. Da die APIs List.removeFirst() und List.removeLast() in Android 15 (API-Level 35) eingeführt wurden, löst der Kotlin-Compiler Funktionsaufrufe wie list.removeFirst() statisch zu den neuen List-APIs auf, anstatt zu den Erweiterungsfunktionen in kotlin-stdlib.

  Wenn eine App mit compileSdk auf 35 und minSdk auf 34 oder niedriger neu kompiliert und dann auf Android 14 oder niedriger ausgeführt wird, wird ein Laufzeitfehler ausgegeben:

  java.lang.NoSuchMethodError: No virtual method
  removeFirst()Ljava/lang/Object; in class Ljava/util/ArrayList;
  

  Die vorhandene Lint-Option NewApi im Android-Gradle-Plug-in kann diese neuen API-Verwendungen erkennen.

  ./gradlew lint
  
  MainActivity.kt:41: Error: Call requires API level 35 (current min is 34): java.util.List#removeFirst [NewApi]
        list.removeFirst()
  

  Um die Laufzeit-Ausnahme und die Lint-Fehler zu beheben, können die Funktionsaufrufe removeFirst() und removeLast() in Kotlin durch removeAt(0) bzw. removeAt(list.lastIndex) ersetzt werden. Wenn Sie Android Studio Ladybug | 2024.1.3 oder höher verwenden, wird auch eine Schnellkorrektur für diese Fehler angeboten.

  Entfernen Sie @SuppressLint("NewApi") und lintOptions { disable 'NewApi' }, wenn die Lint-Option deaktiviert wurde.

• Kollision mit anderen Methoden in Java

  Den vorhandenen Typen wurden neue Methoden hinzugefügt, z. B. List und Deque. Diese neuen Methoden sind möglicherweise nicht mit den Methoden mit demselben Namen und denselben Argumenttypen in anderen Schnittstellen und Klassen kompatibel. Bei einer Kollision der Methodensignatur mit Inkompatibilität gibt der javac-Compiler einen Build-Zeit-Fehler aus. Beispiel:

  Beispiel für Fehler 1:

  javac MyList.java
  
  MyList.java:135: error: removeLast() in MyList cannot implement removeLast() in List
    public void removeLast() {
                ^
    return type void is not compatible with Object
    where E is a type-variable:
      E extends Object declared in interface List
  

  Beispiel für Fehler 2:

  javac MyList.java
  
  MyList.java:7: error: types Deque<Object> and List<Object> are incompatible;
  public class MyList implements  List<Object>, Deque<Object> {
    both define reversed(), but with unrelated return types
  1 error
  

  Beispiel für Fehler 3:

  javac MyList.java
  
  MyList.java:43: error: types List<E#1> and MyInterface<E#2> are incompatible;
  public static class MyList implements List<Object>, MyInterface<Object> {
    class MyList inherits unrelated defaults for getFirst() from types List and MyInterface
    where E#1,E#2 are type-variables:
      E#1 extends Object declared in interface List
      E#2 extends Object declared in interface MyInterface
  1 error
  

  Um diese Build-Fehler zu beheben, sollte die Klasse, die diese Schnittstellen implementiert, die Methode mit einem kompatiblen Rückgabetyp überschreiben. Beispiel:

  @Override
  public Object getFirst() {
      return List.super.getFirst();
  }
  

Sicherheit

Android 15 enthält Änderungen, die die Systemsicherheit fördern und dazu beitragen, Apps und Nutzer vor schädlichen Apps zu schützen.

Eingeschränkte TLS-Versionen

Android 15 限制了对 TLS 版本 1.0 和 1.1 的使用。这些版本之前已在 Android 中被弃用，但现在不允许面向 Android 15 的应用使用。

Sichere Starts von Hintergrundaktivitäten

Android 15 可保护用户免受恶意应用的侵害，并让用户更好地控制 来防止恶意后台应用 将其他应用置于前台、提升其权限以及滥用 用户互动自以下时间以来，后台活动启动一直受到限制 Android 10（API 级别 29）。

其他变更

除了 UID 匹配限制之外，还包括以下其他更改：

• 默认情况下，将 PendingIntent 创建者更改为屏蔽后台活动启动。这有助于防止应用意外创建可能会被恶意操作者滥用的 PendingIntent。
• 除非 PendingIntent 发件人允许，否则请勿将应用调至前台。此变更旨在防止恶意应用滥用 在后台启动 activity 的功能。默认情况下，应用 允许将任务堆栈转到前台，除非创建者允许 后台活动启动权限或发送者有后台活动 启动权限
• 控制任务堆栈顶部 activity 如何完成其任务。如果顶部 activity 完成任务，Android 将返回上次处于活动状态的任务。此外，如果非顶层 activity 完成其任务，Android 将 返回主屏幕；它不会挡住这个非顶层的 活动。
• 防止将其他应用中的任意 activity 启动到您自己的 activity 任务。这项变更可防止恶意应用通过创建看似来自其他应用的 activity 来钓鱼式攻击用户。
• 阻止系统考虑非可见窗口来启动后台 activity。这有助于防止恶意应用滥用后台 activity 启动来向用户显示不需要或恶意的内容。

Sicherere Intents

Android 15 introduces new optional security measures to make intents safer and more robust. These changes are aimed at preventing potential vulnerabilities and misuse of intents that can be exploited by malicious apps. There are two main improvements to the security of intents in Android 15:

• Match target intent-filters: Intents that target specific components must accurately match the target's intent-filter specifications. If you send an intent to launch another app's activity, the target intent component needs to align with the receiving activity's declared intent-filters.
• Intents must have actions: Intents without an action will no longer match any intent-filters. This means that intents used to start activities or services must have a clearly defined action.

Important: A PendingIntent acts as a wrapper for a standard Intent, so these security measures apply to the Intent contained within the PendingIntent.

In order to check how your app responds to these changes, use StrictMode in your app. To see detailed logs about Intent usage violations, add the following method:

Kotlin

fun onCreate() {
    StrictMode.setVmPolicy(VmPolicy.Builder()
        .detectUnsafeIntentLaunch()
        .build()
    )
}

Java

public void onCreate() {
    StrictMode.setVmPolicy(new VmPolicy.Builder()
            .detectUnsafeIntentLaunch()
            .build());
}

Nutzerfreundlichkeit und System-UI

Android 15 enthält einige Änderungen, die für eine einheitlichere und intuitivere User Experience sorgen sollen.

Änderungen am Fenstereinsatz

There are two changes related to window insets in Android 15: edge-to-edge is enforced by default, and there are also configuration changes, such as the default configuration of system bars.

Edge-to-edge enforcement

Apps are edge-to-edge by default on devices running Android 15 if the app is targeting Android 15 (API level 35).

Important: If your app is not already edge-to-edge, portions of your app may be obscured and you must handle insets. Depending on the app, this work may or may not be significant. The Material 3 Scaffold component can reduce the work required to be compatible with the Android 15 edge-to-edge enforcement.

An app that targets Android 14 and is not edge-to-edge on an Android 15 device.

An app that targets Android 15 (API level 35) and is edge-to-edge on an Android 15 device. This app mostly uses Material 3 Compose Components that automatically apply insets. This screen is not negatively impacted by the Android 15 edge-to-edge enforcement.

This is a breaking change that might negatively impact your app's UI. The changes affect the following UI areas:

• Gesture handle navigation bar
  • Transparent by default.
  • Bottom offset is disabled so content draws behind the system navigation bar unless insets are applied.
  • setNavigationBarColor and R.attr#navigationBarColor are deprecated and don't affect gesture navigation.
  • setNavigationBarContrastEnforced and R.attr#navigationBarContrastEnforced continue to have no effect on gesture navigation.
• 3-button navigation
  • Opacity set to 80% by default, with color possibly matching the window background.
  • Bottom offset disabled so content draws behind the system navigation bar unless insets are applied.
  • setNavigationBarColor and R.attr#navigationBarColor are set to match the window background by default. The window background must be a color drawable for this default to apply. This API is deprecated but continues to affect 3-button navigation.
  • setNavigationBarContrastEnforced and R.attr#navigationBarContrastEnforced is true by default, which adds an 80% opaque background across 3-button navigation.
• Status bar
  • Transparent by default.
  • The top offset is disabled so content draws behind the status bar unless insets are applied.
  • setStatusBarColor and R.attr#statusBarColor are deprecated and have no effect on Android 15.
  • setStatusBarContrastEnforced and R.attr#statusBarContrastEnforced are deprecated but still have an effect on Android 15.
• Display cutout
  • layoutInDisplayCutoutMode of non-floating windows must be LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS. SHORT_EDGES, NEVER, and DEFAULT are interpreted as ALWAYS so that users don't see a black bar caused by the display cutout and appear edge-to-edge.

The following example shows an app before and after targeting Android 15 (API level 35), and before and after applying insets. This example is not comprehensive, this might appear differently on Android Auto.

An app that targets Android 14 and is not edge-to-edge on an Android 15 device.

An app that targets Android 15 (API level 35) and is edge-to-edge on an Android 15 device. However, many elements are now hidden by the status bar, 3-button navigation bar, or display cutout due to the Android 15 edge-to-edge enforcements. Hidden UI includes the Material 2 top app bar, floating action buttons, and list items.

An app that targets Android 15 (API level 35), is edge to edge on an Android 15 device and applies insets so that UI is not hidden.

What to check if your app is already edge-to-edge

If your app is already edge-to-edge and applies insets, you are mostly unimpacted, except in the following scenarios. However, even if you think you aren't impacted, we recommend you test your app.

• You have a non-floating window, such as an Activity that uses SHORT_EDGES, NEVER or DEFAULT instead of LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS. If your app crashes on launch, this might be due to your splashscreen. You can either upgrade the core splashscreen dependency to 1.2.0-alpha01 or later or set window.attributes.layoutInDisplayCutoutMode = WindowManager.LayoutInDisplayCutoutMode.always.
• There might be lower-traffic screens with occluded UI. Verify these less-visited screens don't have occluded UI. Lower-traffic screens include:
  • Onboarding or sign-in screens
  • Settings pages

What to check if your app is not already edge-to-edge

If your app is not already edge-to-edge, you are most likely impacted. In addition to the scenarios for apps that are already edge-to-edge, you should consider the following:

• If your app uses Material 3 Components ( androidx.compose.material3) in compose, such as TopAppBar, BottomAppBar, and NavigationBar, these components are likely not impacted because they automatically handle insets.
• If your app is using Material 2 Components ( androidx.compose.material) in Compose, these components don't automatically handle insets. However, you can get access to the insets and apply them manually. In androidx.compose.material 1.6.0 and later, use the windowInsets parameter to apply the insets manually for BottomAppBar, TopAppBar, BottomNavigation, and NavigationRail. Likewise, use the contentWindowInsets parameter for Scaffold.
• If your app uses views and Material Components (com.google.android.material), most views-based Material Components such as BottomNavigationView, BottomAppBar, NavigationRailView, or NavigationView, handle insets and require no additional work. However, you need to add android:fitsSystemWindows="true" if using AppBarLayout.
• For custom composables, apply the insets manually as padding. If your content is within a Scaffold, you can consume insets using the Scaffold padding values. Otherwise, apply padding using one of the WindowInsets.
• If your app is using views and BottomSheet, SideSheet or custom containers, apply padding using ViewCompat.setOnApplyWindowInsetsListener. For RecyclerView, apply padding using this listener and also add clipToPadding="false".

What to check if your app must offer custom background protection

If your app must offer custom background protection to 3-button navigation or the status bar, your app should place a composable or view behind the system bar using WindowInsets.Type#tappableElement() to get the 3-button navigation bar height or WindowInsets.Type#statusBars.

Additional edge-to-edge resources

See the Edge to Edge Views and Edge to Edge Compose guides for additional considerations on applying insets.

Deprecated APIs

The following APIs are deprecated but not disabled:

• R.attr#enforceStatusBarContrast
• R.attr#navigationBarColor (for 3 button navigation, with 80% alpha)
• Window#isStatusBarContrastEnforced
• Window#setNavigationBarColor (for 3 button navigation, with 80% alpha)
• Window#setStatusBarContrastEnforced

The following APIs are deprecated and disabled:

• R.attr#navigationBarColor (for gesture navigation)
• R.attr#navigationBarDividerColor
• R.attr#statusBarColor
• Window#setDecorFitsSystemWindows
• Window#getNavigationBarColor
• Window#getNavigationBarDividerColor
• Window#getStatusBarColor
• Window#setNavigationBarColor (for gesture navigation)
• Window#setNavigationBarDividerColor
• Window#setStatusBarColor

Stable configuration

如果您的应用以 Android 15（API 级别 35）或更高版本为目标平台，Configuration 不再排除系统栏。如果您在 Configuration 类中使用屏幕尺寸进行布局计算，则应根据需要将其替换为更好的替代方案，例如适当的 ViewGroup、WindowInsets 或 WindowMetricsCalculator。

Configuration 自 API 1 起便已开始提供。它通常从 Activity.onConfigurationChanged 中获取。它提供窗口密度、方向和大小等信息。从 Configuration 返回的窗口大小的一个重要特征是，它之前排除了系统栏。

配置大小通常用于资源选择，例如 /res/layout-h500dp，这仍然是一个有效的使用情形。不过，我们一直不建议使用它进行布局计算。如果您正在这样做，请立即远离该设备。您应根据自己的使用场景，将 Configuration 的使用替换为更合适的用法。

如果您使用它来计算布局，请使用适当的 ViewGroup，例如 CoordinatorLayout 或 ConstraintLayout。如果您使用它来确定系统导航栏的高度，请使用 WindowInsets。如果您想知道应用窗口的当前大小，请使用 computeCurrentWindowMetrics。

以下列表介绍了受此变更影响的字段：

• Configuration.screenWidthDp 和 screenHeightDp 尺寸不再排除系统栏。
• Configuration.smallestScreenWidthDp 会受到 screenWidthDp 和 screenHeightDp 更改的间接影响。
• Configuration.orientation 会受到近乎正方形的设备上 screenWidthDp 和 screenHeightDp 更改的间接影响。
• Display.getSize(Point) 间接受到 Configuration 中的更改影响。此方法已从 API 级别 30 开始弃用。
• 自 API 级别 33 以来，Display.getMetrics() 一直以这种方式运行。

Das Attribut „elegantTextHeight“ ist standardmäßig auf „true“ gesetzt.

对于以 Android 15（API 级别 35）为目标平台的应用，elegantTextHeight TextView 属性默认会变为 true，将默认使用的紧凑字体替换为一些具有较大垂直测量的脚本，使其更易于阅读。紧凑字体旨在防止布局中断；Android 13（API 级别 33）允许文本布局利用 fallbackLineSpacing 属性拉伸垂直高度，从而防止许多此类中断。

在 Android 15 中，系统中仍保留了紧凑字体，因此您的应用可以将 elegantTextHeight 设置为 false 以获得与之前相同的行为，但即将发布的版本不太可能支持此字体。因此，如果您的应用支持以下脚本：阿拉伯语、老挝语、缅甸语、泰米尔语、古吉拉特语、卡纳达语、马拉雅拉姆语、奥里亚语、泰卢固语或泰语，请将 elegantTextHeight 设置为 true 以测试您的应用。

针对以 Android 14（API 级别 34）及更低版本为目标平台的应用的 elegantTextHeight 行为。

以 Android 15 为目标平台的应用的 elegantTextHeight 行为。

TextView-Breite ändert sich bei komplexen Buchstabenformen

In previous versions of Android, some cursive fonts or languages that have complex shaping might draw the letters in the previous or next character's area. In some cases, such letters were clipped at the beginning or ending position. Starting in Android 15, a TextView allocates width for drawing enough space for such letters and allows apps to request extra paddings to the left to prevent clipping.

Because this change affects how a TextView decides the width, TextView allocates more width by default if the app targets Android 15 (API level 35) or higher. You can enable or disable this behavior by calling the setUseBoundsForWidth API on TextView.

Because adding left padding might cause a misalignment for existing layouts, the padding is not added by default even for apps that target Android 15 or higher. However, you can add extra padding to preventing clipping by calling setShiftDrawingOffsetForStartOverhang.

The following examples show how these changes can improve text layout for some fonts and languages.

Standard layout for English text in a cursive font. Some of the letters are clipped. Here is the corresponding XML:

<TextView
    android:fontFamily="cursive"
    android:text="java" />

Layout for the same English text with additional width and padding. Here is the corresponding XML:

<TextView
    android:fontFamily="cursive"
    android:text="java"
    android:useBoundsForWidth="true"
    android:shiftDrawingOffsetForStartOverhang="true" />

Standard layout for Thai text. Some of the letters are clipped. Here is the corresponding XML:

<TextView
    android:text="คอมพิวเตอร์" />

Layout for the same Thai text with additional width and padding. Here is the corresponding XML:

<TextView
    android:text="คอมพิวเตอร์"
    android:useBoundsForWidth="true"
    android:shiftDrawingOffsetForStartOverhang="true" />

Gebietsschemaabhängige Standardzeilenhöhe für EditText

在较低版本的 Android 中，文本布局会拉伸文本的高度，以满足与当前语言区域匹配的字体的行高。例如，如果内容是日语，由于日语字体的行高略高于拉丁字体，因此文本的高度会略高。不过，尽管行高存在这些差异，但无论使用的是哪种语言区域，EditText 元素的大小都是统一的，如下图所示：

三个框，表示可以包含英语 (en)、日语 (ja) 和缅甸语 (my) 文本的 EditText 元素。EditText 的高度相同，即使这些语言的行高各不相同。

对于以 Android 15（API 级别 35）为目标平台的应用，现在为 EditText 预留了最小行高，以匹配指定语言区域的参考字体，如下图所示：

三个框，表示可以包含英语 (en)、日语 (ja) 和缅甸语 (my) 文本的 EditText 元素。EditText 的高度现在包含足够的空间来容纳这些语言字体的默认行高。

如有需要，您的应用可以将 useLocalePreferredLineHeightForMinimum 属性指定为 false，以恢复之前的行为；您的应用还可以在 Kotlin 和 Java 中使用 setMinimumFontMetrics API 设置自定义最小垂直指标。

Kamera und Medien

Unter Android 15 werden die folgenden Änderungen am Kamera- und Medienverhalten für Apps eingeführt, die auf Android 15 oder höher ausgerichtet sind.

Einschränkungen beim Anfordern des Audiofokus

以 Android 15（API 级别 35）为目标平台的应用必须是顶部应用或正在运行前台服务，才能请求音频焦点。如果应用在未满足上述任一要求的情况下尝试请求焦点，调用将返回 AUDIOFOCUS_REQUEST_FAILED。

如需详细了解音频焦点，请参阅管理音频焦点。

Aktualisierte Einschränkungen für Nicht-SDKs

Android 15 enthält aktualisierte Listen eingeschränkter Nicht-SDK-Schnittstellen, die auf der Zusammenarbeit mit Android-Entwicklern und den neuesten internen Tests basieren. Wir sorgen nach Möglichkeit dafür, dass öffentliche Alternativen verfügbar sind, bevor wir Nicht-SDK-Schnittstellen einschränken.

Wenn Ihre App nicht auf Android 15 ausgerichtet ist, wirken sich einige dieser Änderungen möglicherweise nicht sofort auf Sie aus. Zwar kann Ihre App je nach Ziel-API-Level Ihrer App auf einige Nicht-SDK-Schnittstellen zugreifen, die Verwendung einer Nicht-SDK-Methode oder eines Nicht-SDK-Felds birgt jedoch immer ein hohes Risiko, dass Ihre App nicht mehr funktioniert.

Wenn Sie sich nicht sicher sind, ob Ihre App Nicht-SDK-Schnittstellen verwendet, können Sie Ihre App testen, um das herauszufinden. Wenn Ihre App auf Nicht-SDK-Schnittstellen basiert, sollten Sie mit der Planung einer Migration zu SDK-Alternativen beginnen. Wir verstehen jedoch, dass einige Apps gültige Anwendungsfälle für die Verwendung von Nicht-SDK-Schnittstellen haben. Wenn Sie für eine Funktion in Ihrer App keine Alternative zur Verwendung einer Nicht-SDK-Schnittstelle finden, sollten Sie eine neue öffentliche API anfordern.

Weitere Informationen zu den Änderungen in dieser Android-Version finden Sie unter Änderungen an den Einschränkungen für nicht SDK-spezifische Oberflächen in Android 15. Weitere Informationen zu Nicht-SDK-Schnittstellen finden Sie unter Einschränkungen für Nicht-SDK-Schnittstellen.