Comme les versions précédentes, Android 15 inclut des modifications de comportement susceptibles d'affecter votre application. Les modifications de comportement suivantes s'appliquent exclusivement aux applications qui ciblent Android 15 ou version ultérieure. Si votre application cible Android 15 ou une version ultérieure, vous devez la modifier pour prendre en charge ces comportements correctement, le cas échéant.
Veillez également à consulter la liste des modifications de comportement qui affectent toutes les applications exécutées sous Android 15, quel que soit le targetSdkVersion
de votre application.
Fonctionnalité de base
Android 15 modifie ou étend diverses fonctionnalités de base du système Android.
Modifications apportées aux services de premier plan
We are making the following changes to foreground services with Android 15.
- New media processing foreground service type
- Restrictions on
BOOT_COMPLETED
broadcast receivers launching foreground services
Data sync foreground service timeout behavior
Android 15 introduces a new timeout behavior to dataSync
for apps targeting
Android 15 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]"
To avoid problems with this behavior change, you can do one or more of the following:
- Have your service implement the new
Service.onTimeout(int, int)
method. When your app receives the callback, make sure to callstopSelf()
within a few seconds. (If you don't stop the app right away, the system generates a failure.) - 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). - 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. - 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 introduit un nouveau type de service de premier plan : mediaProcessing
. Ce type de service convient pour des opérations telles que le transcodage de fichiers multimédias. Par exemple, une application multimédia peut télécharger un fichier audio et doit le convertir dans un autre format avant de le lire. Vous pouvez utiliser un service de premier plan mediaProcessing
pour vous assurer que la conversion se poursuit même lorsque l'application est exécutée en arrière-plan.
Le système autorise les services mediaProcessing
d'une application à s'exécuter pendant six heures au total sur une période de 24 heures, après quoi le système appelle la méthode Service.onTimeout(int, int)
du service en cours d'exécution (introduite dans Android 15). Pour le moment, le service dispose de quelques secondes pour appeler Service.stopSelf()
. Si le service n'appelle pas Service.stopSelf()
, le système génère une exception interne. L'exception est enregistrée dans Logcat avec le message suivant:
Fatal Exception: android.app.RemoteServiceException: "A foreground service of
type mediaProcessing did not stop within its timeout: [component name]"
Pour éviter l'exception, vous pouvez effectuer l'une des opérations suivantes:
- Demandez à votre service d'implémenter la nouvelle méthode
Service.onTimeout(int, int)
. Lorsque votre application reçoit le rappel, veillez à appelerstopSelf()
dans un délai de quelques secondes. (Si vous n'arrêtez pas l'application immédiatement, le système génère une défaillance.) - Assurez-vous que les services
mediaProcessing
de votre application ne s'exécutent pas pendant plus de six heures au total sur une période de 24 heures (sauf si l'utilisateur interagit avec l'application et réinitialise le minuteur). - Ne démarrez les services de premier plan
mediaProcessing
qu'à la suite d'une interaction directe de l'utilisateur. Étant donné que votre application est au premier plan au démarrage du service, votre service dispose des six heures complètes suivant le passage de l'application en arrière-plan. - Au lieu d'utiliser un service de premier plan
mediaProcessing
, utilisez une API alternative, comme WorkManager.
Si les services de premier plan mediaProcessing
de votre application ont été exécutés pendant six heures au cours des 24 dernières heures, vous ne pouvez pas démarrer un autre service de premier plan mediaProcessing
, sauf si l'utilisateur a mis votre application au premier plan (ce qui réinitialise le minuteur). Si vous essayez de démarrer un autre service de premier plan mediaProcessing
, le système génère une erreur ForegroundServiceStartNotAllowedException
avec un message d'erreur du type "Time limit already expired for premier service type mediaProcessing".
Pour en savoir plus sur le type de service mediaProcessing
, consultez Modifications apportées aux types de services de premier plan pour Android 15: Traitement multimédia.
Tests
Pour tester le comportement de votre application, vous pouvez activer les délais avant expiration du traitement multimédia même si votre application ne cible pas Android 15 (à condition qu'elle s'exécute sur un appareil Android 15). Pour activer les délais avant expiration, exécutez la commande adb
suivante:
adb shell am compat enable FGS_INTRODUCE_TIME_LIMITS your-package-name
Vous pouvez également ajuster le délai avant expiration pour tester plus facilement le comportement de votre application une fois la limite atteinte. Pour définir un nouveau délai avant expiration, exécutez la commande adb
suivante:
adb shell device_config put activity_manager media_processing_fgs_timeout_duration duration-in-milliseconds
Restrictions on BOOT_COMPLETED
broadcast receivers launching foreground services
De nouvelles restrictions s'appliquent aux broadcast receivers BOOT_COMPLETED
qui lancent les services de premier plan. Les récepteurs BOOT_COMPLETED
ne sont pas autorisés à lancer les types de services de premier plan suivants:
dataSync
camera
mediaPlayback
phoneCall
mediaProjection
microphone
(cette restriction s'applique àmicrophone
depuis Android 14)
Si un récepteur BOOT_COMPLETED
tente de lancer l'un de ces types de services de premier plan, le système génère une erreur ForegroundServiceStartNotAllowedException
.
Restrictions on starting foreground services while an app holds the SYSTEM_ALERT_WINDOW
permission
Auparavant, si une application détenait l'autorisation SYSTEM_ALERT_WINDOW
, elle pouvait lancer un service de premier plan même si l'application était actuellement en arrière-plan (comme indiqué dans la section Exceptions des restrictions de démarrage en arrière-plan).
Si une application cible Android 15, cette exception est désormais plus restrictive. L'application doit désormais disposer de l'autorisation SYSTEM_ALERT_WINDOW
et également disposer d'une fenêtre en superposition visible. Autrement dit, l'application doit d'abord lancer une fenêtre TYPE_APPLICATION_OVERLAY
et celle-ci doit être visible avant de démarrer un service de premier plan.
Si votre application tente de démarrer un service de premier plan à partir de l'arrière-plan sans remplir ces nouvelles exigences (et qu'elle ne dispose pas d'une autre exception), le système génère une exception ForegroundServiceStartNotAllowedException
.
Si votre application déclare l'autorisation SYSTEM_ALERT_WINDOW
et lance des services de premier plan en arrière-plan, elle peut être affectée par cette modification. Si votre application reçoit un ForegroundServiceStartNotAllowedException
, vérifiez l'ordre des opérations et assurez-vous qu'elle dispose déjà d'une fenêtre de superposition active avant de tenter de démarrer un service de premier plan en arrière-plan. Vous pouvez vérifier si votre fenêtre de superposition est actuellement visible en appelant View.getWindowVisibility()
. Vous pouvez également ignorer View.onWindowVisibilityChanged()
afin d'être averti chaque fois que la visibilité change.
Modifications concernant les cas dans lesquels les applications peuvent modifier l'état général du mode Ne pas déranger
Les applications qui ciblent Android 15 ne peuvent plus modifier l'état ni la règle globaux du mode Ne pas déranger sur un appareil (en modifiant les paramètres utilisateur ou en désactivant le mode Ne pas déranger). À la place, les applications doivent contribuer à un AutomaticZenRule
, que le système combine dans une règle globale avec le schéma "most-restrictive-policy-wins" existant. Les appels d'API existantes qui ont précédemment affecté l'état global (setInterruptionFilter
, setNotificationPolicy
) entraînent la création ou la mise à jour d'un AutomaticZenRule
implicite, qui est activé ou désactivé en fonction du cycle d'appel de ces appels d'API.
Notez que cette modification n'affecte le comportement observable que si l'application appelle setInterruptionFilter(INTERRUPTION_FILTER_ALL)
et s'attend à ce que cet appel désactive un AutomaticZenRule
précédemment activé par ses propriétaires.
Modifications apportées à l'API OpenJDK
Android 15 continues the work of refreshing Android's core libraries to align with the features in the latest OpenJDK LTS releases.
One of these changes can affect app compatibility for apps targeting Android 15 (API level 35):
Changes to string formatting APIs: Validation of argument index, flags, width, and precision are now more strict when using the following
String.format()
andFormatter.format()
APIs:String.format(String, Object[])
String.format(Locale, String, Object[])
Formatter.format(String, Object[])
Formatter.format(Locale, String, Object[])
For example, the following exception is thrown when an argument index of 0 is used (
%0
in the format string):IllegalFormatArgumentIndexException: Illegal format argument index = 0
In this case, the issue can be fixed by using an argument index of 1 (
%1
in the format string).Changes to component type of
Arrays.asList(...).toArray()
: When usingArrays.asList(...).toArray()
, the component type of the resulting array is now anObject
—not the type of the underlying array's elements. So the following code throws aClassCastException
:String[] elements = (String[]) Arrays.asList("one", "two").toArray();
For this case, to preserve
String
as the component type in the resulting array, you could useCollection.toArray(Object[])
instead:String[] elements = Arrays.asList("two", "one").toArray(new String[0]);
Changes to language code handling: When using the
Locale
API, language codes for Hebrew, Yiddish, and Indonesian are no longer converted to their obsolete forms (Hebrew:iw
, Yiddish:ji
, and Indonesian:in
). When specifying the language code for one of these locales, use the codes from ISO 639-1 instead (Hebrew:he
, Yiddish:yi
, and Indonesian:id
).Changes to random int sequences: Following the changes made in https://bugs.openjdk.org/browse/JDK-8301574, the following
Random.ints()
methods now return a different sequence of numbers than theRandom.nextInt()
methods do:Generally, this change shouldn't result in app-breaking behavior, but your code shouldn't expect the sequence generated from
Random.ints()
methods to matchRandom.nextInt()
.
The new SequencedCollection
API can affect your app's compatibility
after you update compileSdk
in your app's build configuration to use
Android 15 (API level 35):
Collision with
MutableList.removeFirst()
andMutableList.removeLast()
extension functions inkotlin-stdlib
The
List
type in Java is mapped to theMutableList
type in Kotlin. Because theList.removeFirst()
andList.removeLast()
APIs have been introduced in Android 15 (API level 35), the Kotlin compiler resolves function calls, for examplelist.removeFirst()
, statically to the newList
APIs instead of to the extension functions inkotlin-stdlib
.If an app is re-compiled with
compileSdk
set to35
andminSdk
set to34
or lower, and then the app is run on Android 14 and lower, a runtime error is thrown:java.lang.NoSuchMethodError: No virtual method removeFirst()Ljava/lang/Object; in class Ljava/util/ArrayList;
The existing
NewApi
lint option in Android Gradle Plugin can catch these new API usages../gradlew lint
MainActivity.kt:41: Error: Call requires API level 35 (current min is 34): java.util.List#removeFirst [NewApi] list.removeFirst()To fix the runtime exception and lint errors, the
removeFirst()
andremoveLast()
function calls can be replaced withremoveAt(0)
andremoveAt(list.lastIndex)
respectively in Kotlin. If you're using Android Studio Ladybug | 2024.1.3 or higher, it also provides a quick fix option for these errors.Consider removing
@SuppressLint("NewApi")
andlintOptions { disable 'NewApi' }
if the lint option has been disabled.Collision with other methods in Java
New methods have been added into the existing types, for example,
List
andDeque
. These new methods might not be compatible with the methods with the same name and argument types in other interfaces and classes. In the case of a method signature collision with incompatibility, thejavac
compiler outputs a build-time error. For example:Example error 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 ListExample error 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 errorExample error 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 errorTo fix these build errors, the class implementing these interfaces should override the method with a compatible return type. For example:
@Override public Object getFirst() { return List.super.getLast(); }
Sécurité
Android 15 inclut des modifications qui favorisent la sécurité du système afin de protéger les applications et les utilisateurs contre les applications malveillantes.
Lancement de l'activité en arrière-plan sécurisée
Android 15 protects users from malicious apps and gives them more control over their devices by adding changes that prevent malicious background apps from bringing other apps to the foreground, elevating their privileges, and abusing user interaction. Background activity launches have been restricted since Android 10 (API level 29).
Block apps that don't match the top UID on the stack from launching activities
Malicious apps can launch another app's activity within the same task, then
overlay themselves on top, creating the illusion of being that app. This "task
hijacking" attack bypasses current background launch restrictions because it all
occurs within the same visible task. To mitigate this risk, Android 15 adds a
flag that blocks apps that don't match the top UID on the stack from launching
activities. To opt in for all of your app's activities, update the
allowCrossUidActivitySwitchFromBelow
attribute in your app's AndroidManifest.xml
file:
<application android:allowCrossUidActivitySwitchFromBelow="false" >
The new security measures are active if all of the following are true:
- The app performing the launch targets Android 15.
- The app on top of the task stack targets Android 15.
- Any visible activity has opted in to the new protections
If the security measures are enabled, apps might return home, rather than the last visible app, if they finish their own task.
Other changes
In addition to the restriction for UID matching, these other changes are also included:
- Change
PendingIntent
creators to block background activity launches by default. This helps prevent apps from accidentally creating aPendingIntent
that could be abused by malicious actors. - Don't bring an app to the foreground unless the
PendingIntent
sender allows it. This change aims to prevent malicious apps from abusing the ability to start activities in the background. By default, apps are not allowed to bring the task stack to the foreground unless the creator allows background activity launch privileges or the sender has background activity launch privileges. - Control how the top activity of a task stack can finish its task. If the top activity finishes a task, Android will go back to whichever task was last active. Moreover, if a non-top activity finishes its task, Android will go back to the home screen; it won't block the finish of this non-top activity.
- Prevent launching arbitrary activities from other apps into your own task. This change prevents malicious apps from phishing users by creating activities that appear to be from other apps.
- Block non-visible windows from being considered for background activity launches. This helps prevent malicious apps from abusing background activity launches to display unwanted or malicious content to users.
Intents plus sécurisés
Android 15 introduces new 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.
- Pending intents: The creator of the pending intent is treated as the sender of the enclosing intent, not the sender of the pending intent
Kotlin
fun onCreate() { StrictMode.setVmPolicy(VmPolicy.Builder() .detectUnsafeIntentLaunch() .build() ) }
Java
public void onCreate() { StrictMode.setVmPolicy(new VmPolicy.Builder() .detectUnsafeIntentLaunch() .build()); }
Expérience utilisateur et UI du système
Android 15 inclut certaines modifications destinées à créer une expérience utilisateur plus cohérente et intuitive.
Modifications de l'encart de la fenêtre
Il existe deux modifications liées aux encarts de fenêtre dans Android 15: l'application bord à bord est appliquée par défaut, et il existe également des modifications de configuration, telles que la configuration par défaut des barres système.
Application bord à bord
Les applications sont bord à bord par défaut sur les appareils équipés d'Android 15 si elles sont ciblant Android 15 (niveau d'API 35).
<ph type="x-smartling-placeholder">![](https://developer.android.com/static/about/versions/15/images/edge-to-edge-1.png?authuser=5&hl=fr)
Il s'agit d'une modification destructive qui pourrait avoir un impact négatif sur l'interface utilisateur de votre application. La les modifications affectent les zones d'interface utilisateur suivantes:
- Barre de navigation par gestes
<ph type="x-smartling-placeholder">
- </ph>
- Transparent par défaut.
- Le décalage inférieur est désactivé afin que le contenu s'affiche derrière la navigation système sauf si des encarts sont appliqués.
setNavigationBarColor
etR.attr#navigationBarColor
sont obsolète et n'affectent pas la navigation par gestes.setNavigationBarContrastEnforced
etR.attr#navigationBarContrastEnforced
n'ont toujours aucun effet sur la navigation par gestes.
- Navigation à trois boutons
<ph type="x-smartling-placeholder">
- </ph>
- L'opacité est définie sur 80% par défaut, et la couleur peut correspondre à celle de la fenêtre. en arrière-plan.
- Décalage inférieur désactivé afin que le contenu s'affiche derrière la barre de navigation système sauf si des encarts sont appliqués.
setNavigationBarColor
etR.attr#navigationBarColor
sont définie pour correspondre à l'arrière-plan de la fenêtre par défaut. Arrière-plan de la fenêtre doit être un drawable couleur pour que cette valeur par défaut s'applique. Cette API est obsolète mais continue à affecter la navigation à trois boutons.setNavigationBarContrastEnforced
etR.attr#navigationBarContrastEnforced
est défini sur "true" par défaut, ce qui ajoute Arrière-plan opaque à 80% pour une navigation à trois boutons.
- Barre d'état
<ph type="x-smartling-placeholder">
- </ph>
- Transparent par défaut.
- Le décalage supérieur est désactivé afin que le contenu s'affiche derrière la barre d'état, sauf et des encarts sont appliqués.
setStatusBarColor
etR.attr#statusBarColor
sont obsolètes et n'ont aucun effet sur Android 15.setStatusBarContrastEnforced
etR.attr#statusBarContrastEnforced
sont obsolètes, mais ont toujours une sur Android 15.
- Encoche
<ph type="x-smartling-placeholder">
- </ph>
layoutInDisplayCutoutMode
des fenêtres non flottantes doivent êtreLAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
SHORT_EDGES
,NEVER
et LesDEFAULT
sont interprétés commeALWAYS
, de sorte que les utilisateurs ne voient pas causée par l'encoche et s'affiche de bord à bord.
L'exemple suivant présente une application avant et après le ciblage Android 15 (niveau d'API 35), et avant et après l'application des encarts.
<ph type="x-smartling-placeholder">![](https://developer.android.com/static/about/versions/15/images/edge-to-edge-4.png?authuser=5&hl=fr)
![](https://developer.android.com/static/about/versions/15/images/edge-to-edge-6.png?authuser=5&hl=fr)
![](https://developer.android.com/static/about/versions/15/images/edge-to-edge-2.png?authuser=5&hl=fr)
Comment vérifier si votre application est déjà de bord à bord ?
Si votre application est déjà bord à bord et applique des encarts, n'ont quasiment aucun impact, sauf dans les cas suivants. Cependant, même si vous pensez vous n'êtes pas concerné, nous vous recommandons de tester votre application.
- Vous disposez d'une fenêtre non flottante, telle qu'un
Activity
qui utiliseSHORT_EDGES
,NEVER
ouDEFAULT
au lieu deLAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
Si votre application plante au lancement, en raison de votre écran de démarrage. Vous pouvez soit mettre à niveau splashscreen par rapport à 1.2.0-alpha01 ou une version ultérieure, ou définissezwindow.attributes.layoutInDisplayCutoutMode = WindowManager.LayoutInDisplayCutoutMode.always
. - Il est possible que l'interface utilisateur soit masquée sur des écrans à faible trafic. Vérifier ces éléments
les écrans moins consultés n'ont pas d'interface utilisateur obstruée. Les écrans qui affichent moins de trafic sont les suivants:
<ph type="x-smartling-placeholder">
- </ph>
- Écrans d'accueil ou de connexion
- Pages de paramètres
Vérifier si votre application n'est pas déjà bord à bord
Si votre application n'est pas déjà bord à bord, vous êtes probablement affecté. Dans en plus des scénarios d'applications déjà bord à bord, tenez compte des éléments suivants:
- Si votre application utilise des composants Material 3 (
androidx.compose.material3
) dans Compose, par exempleTopAppBar
,BottomAppBar
etNavigationBar
, il est probable que ces composants ne soient pas car ils gèrent automatiquement les encarts. - Si votre application utilise des composants Material 2 (
androidx.compose.material
) dans Compose, ces composants ne gèrent pas automatiquement les encarts. Cependant, vous pouvez accéder aux encarts et les appliquer manuellement. Dans androidx.compose.material 1.6.0 puis utilisez le paramètrewindowInsets
pour appliquer les encarts manuellementBottomAppBar
,TopAppBar
BottomNavigation
etNavigationRail
. De même, utilisez le paramètrecontentWindowInsets
pourScaffold
. - Si votre application utilise des vues et des composants Material
(
com.google.android.material
), Material Design principalement basé sur les vues Des composants tels queBottomNavigationView
,BottomAppBar
,NavigationRailView
ouNavigationView
gèrent les encarts et ne nécessitent aucune travail supplémentaire. Cependant, vous devez ajouterandroid:fitsSystemWindows="true"
si vous utilisezAppBarLayout
. - Pour les composables personnalisés, appliquez manuellement les encarts en tant que marge intérieure. Si votre
contenu dans un
Scaffold
, vous pouvez utiliser des encarts à l'aide de l'Scaffold
les valeurs de marge intérieure. Sinon, appliquez une marge intérieure à l'aide de l'une desWindowInsets
. - Si votre application utilise des vues et des
BottomSheet
,SideSheet
ou personnalisées des conteneurs, appliquez un remplissage à l'aide deViewCompat.setOnApplyWindowInsetsListener
PourRecyclerView
, appliquer une marge intérieure à l'aide de cet écouteur et ajouterclipToPadding="false"
Points à vérifier si votre application doit proposer une protection personnalisée en arrière-plan
Si votre application doit offrir une protection personnalisée en arrière-plan pour la navigation à trois boutons ou
la barre d'état, votre application doit placer un composable ou une vue derrière la barre système
avec WindowInsets.Type#tappableElement()
pour obtenir les trois boutons
hauteur de la barre de navigation ou WindowInsets.Type#statusBars
.
Ressources de bord à bord supplémentaires
Consultez les vues Edge à Edge et Edge to Edge Compose. pour en savoir plus sur l'application d'encarts.
API obsolètes
Les API suivantes sont désormais obsolètes:
R.attr#enforceStatusBarContrast
R.attr#navigationBarColor
R.attr#navigationBarDividerColor
R.attr#statusBarColor
Window#getNavigationBarColor
Window#getNavigationBarDividerColor
Window#getStatusBarColor
Window#isStatusBarContrastEnforced
Window#setDecorFitsSystemWindows
Window#setNavigationBarColor
Window#setNavigationBarDividerColor
Window#setStatusBarColor
Window#setStatusBarContrastEnforced
Configuration stable
Si votre application cible Android 15 (niveau d'API 35) ou une version ultérieure, Configuration
non
exclut plus longtemps
les barres système. Si vous utilisez la taille d'écran
Classe Configuration
pour le calcul de la mise en page, à remplacer par une
des alternatives comme ViewGroup
, WindowInsets
ou
WindowMetricsCalculator
selon vos besoins.
Configuration
est disponible depuis l'API 1. Elle est généralement obtenue à partir de
Activity.onConfigurationChanged
Il fournit des informations telles que
la densité de la fenêtre,
l'orientation et les tailles. Une caractéristique importante
de la taille des fenêtres
renvoyé par Configuration
signifie qu'il excluait auparavant les barres système.
La taille de configuration sert généralement à sélectionner des ressources, par exemple
/res/layout-h500dp
, et ce cas d'utilisation reste valide. Cependant, son utilisation pour
le calcul de mise en page a toujours été déconseillé. Dans ce cas, vous devez migrer
tout de suite. Vous devez remplacer l'utilisation de Configuration
par quelque chose
plus adapté à votre cas d'utilisation.
Si vous l'utilisez pour calculer la mise en page, utilisez un ViewGroup
approprié, tel que
CoordinatorLayout
ou ConstraintLayout
. Si vous l'utilisez pour déterminer la hauteur
de la barre de navigation du système, utilisez WindowInsets
. Si vous voulez connaître la taille actuelle
de la fenêtre de votre application, utilisez computeCurrentWindowMetrics
.
La liste suivante décrit les champs concernés par cette modification:
- Les tailles
Configuration.screenWidthDp
etscreenHeightDp
ne sont plus disponibles exclure les barres système. Configuration.smallestScreenWidthDp
est indirectement affecté par les modifications àscreenWidthDp
etscreenHeightDp
.Configuration.orientation
est indirectement affecté par les modifications apportées àscreenWidthDp
etscreenHeightDp
sur les appareils proches de la position carrée.Display.getSize(Point)
est indirectement affecté par les modifications apportées àConfiguration
Cette fonctionnalité est obsolète depuis le niveau d'API 30.Display.getMetrics()
fonctionne déjà de cette manière depuis le niveau d'API 33.
Par défaut, l'attribut élégantTextHeight est défini sur "true".
For apps targeting Android 15, the elegantTextHeight
TextView
attribute becomes true
by default, replacing the
compact font used by default with some scripts that have large vertical metrics
with one that is much more readable. The compact font was introduced to prevent
breaking layouts; Android 13 (API level 33) prevents many of these breakages by
allowing the text layout to stretch the vertical height utilizing the
fallbackLineSpacing
attribute.
In Android 15, the compact font still remains in the system, so your app can set
elegantTextHeight
to false
to get the same behavior as before, but it is
unlikely to be supported in upcoming releases. So, if your app supports the
following scripts: Arabic, Lao, Myanmar, Tamil, Gujarati, Kannada, Malayalam,
Odia, Telugu or Thai, test your app by setting elegantTextHeight
to true
.
![](https://developer.android.com/static/about/versions/15/images/elegant-text-height-before.png?authuser=5&hl=fr)
elegantTextHeight
behavior for apps targeting Android 14 (API level 34) and lower.![](https://developer.android.com/static/about/versions/15/images/elegant-text-height-after.png?authuser=5&hl=fr)
elegantTextHeight
behavior for apps targeting Android 15.Modifications de la largeur de TextView pour les lettres complexes
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 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.
![](https://developer.android.com/static/about/versions/15/images/cursive-clipped.png?authuser=5&hl=fr)
<TextView android:fontFamily="cursive" android:text="java" />
![](https://developer.android.com/static/about/versions/15/images/cursive-noclipping.png?authuser=5&hl=fr)
<TextView android:fontFamily="cursive" android:text="java" android:useBoundsForWidth="true" android:shiftDrawingOffsetForStartOverhang="true" />
![](https://developer.android.com/static/about/versions/15/images/thai-clipped.png?authuser=5&hl=fr)
<TextView android:text="คอมพิวเตอร์" />
![](https://developer.android.com/static/about/versions/15/images/thai-noclipping.png?authuser=5&hl=fr)
<TextView android:text="คอมพิวเตอร์" android:useBoundsForWidth="true" android:shiftDrawingOffsetForStartOverhang="true" />
Hauteur de ligne par défaut en fonction des paramètres régionaux pour EditText
In previous versions of Android, the text layout stretched the height of the
text to meet the line height of the font that matched the current locale. For
example, if the content was in Japanese, because the line height of the Japanese
font is slightly larger than the one of a Latin font, the height of the text
became slightly larger. However, despite these differences in line heights, the
EditText
element was sized uniformly, regardless
of the locale being used, as illustrated in the following image:
![](https://developer.android.com/static/about/versions/15/images/locale-aware-line-height-before.png?authuser=5&hl=fr)
EditText
elements that
can contain text from English (en), Japanese (ja), and Burmese (my). The
height of the EditText
is the same, even though these languages
have different line heights from each other.For apps targeting Android 15, a minimum line height is now reserved for
EditText
to match the reference font for the specified Locale, as shown in the
following image:
![](https://developer.android.com/static/about/versions/15/images/locale-aware-line-height-after.png?authuser=5&hl=fr)
EditText
elements that
can contain text from English (en), Japanese (ja), and Burmese (my). The
height of the EditText
now includes space to accommodate the
default line height for these languages' fonts.If needed, your app can restore the previous behavior by specifying the
useLocalePreferredLineHeightForMinimum
attribute
to false
, and your app can set custom minimum vertical metrics using the
setMinimumFontMetrics
API in Kotlin and Java.
Appareil photo et contenus multimédias
Android 15 apporte les modifications suivantes au comportement de l'appareil photo et des contenus multimédias pour les applications qui ciblent Android 15 ou version ultérieure.
Restrictions concernant la demande de priorité audio
Les applications qui ciblent Android 15 doivent être l'application principale ou exécuter un service de premier plan pour demander la priorité audio. Si une application tente de demander la sélection alors qu'elle ne répond pas à l'une de ces exigences, l'appel renvoie AUDIOFOCUS_REQUEST_FAILED
.
Pour en savoir plus sur la priorité audio, consultez Gérer la priorité audio.
Mise à jour des restrictions non SDK
Android 15 inclut des listes à jour de listes d'autorisations non SDK limitées grâce à une collaboration avec des développeurs Android tests internes. Dans la mesure du possible, nous nous assurons que des alternatives publiques sont disponibles avant de limiter les interfaces non SDK.
Si votre application ne cible pas Android 15, certaines de ces modifications pourrait ne pas vous affecter immédiatement. Toutefois, même s'il est possible que votre application accéder à certaines interfaces non SDK selon le niveau d'API cible de votre application, en utilisant des API la méthode ou le champ comporte toujours un risque élevé d'endommager votre application.
Si vous n'êtes pas sûr que votre application utilise des interfaces non SDK, vous pouvez Testez votre application pour le savoir. Si votre application repose sur un outil non SDK vous devez commencer à planifier une migration vers des alternatives SDK. Nous comprenons néanmoins que certaines applications ont des cas d'utilisation valables interfaces non SDK. Si vous ne trouvez pas d'alternative à l'utilisation d'un autre SDK d'une fonctionnalité de votre application, vous devez demander une nouvelle API publique.
Pour en savoir plus sur les modifications apportées à cette version d'Android, consultez Mises à jour des restrictions des interfaces non SDK dans Android 15. Pour en savoir plus sur les interfaces non SDK de manière générale, consultez la section Restrictions concernant les interfaces non SDK.