Comme dans les versions précédentes, Android 14 apporte des modifications de comportement susceptibles d'affecter votre application. Les modifications de comportement suivantes s'appliquent exclusivement aux applications qui ciblent Android 14 (niveau d'API 34) ou version ultérieure. Si votre application cible Android 14 ou une version ultérieure, vous devez la modifier pour qu'elle prenne en charge ces comportements, le cas échéant.
Veillez également à consulter la liste des modifications de comportement qui affectent toutes les applications exécutées sur Android 14, quel que soit le targetSdkVersion
de l'application.
Fonctionnalité de base
Le type de service au premier plan doit être indiqué
Si votre application cible Android 14 (niveau d'API 34) ou une version ultérieure, elle doit spécifier au moins un type de service de premier plan pour chaque service de premier plan. Vous devez choisir un type de service de premier plan qui représente le cas d'utilisation de votre application. Le système s'attend à ce que des services de premier plan ayant un type particulier répondent à un cas d'utilisation particulier.
Si un cas d'utilisation dans votre application n'est associé à aucun de ces types, il est fortement recommandé de migrer votre logique pour utiliser WorkManager ou les tâches de transfert de données déclenchées par l'utilisateur.
Application de l'autorisation BLUETOOTH_CONNECT dans BluetoothAdapter
Android 14 applique l'autorisation BLUETOOTH_CONNECT
lors de l'appel de la méthode BluetoothAdapter
getProfileConnectionState()
pour les applications ciblant Android 14 (niveau d'API 34) ou version ultérieure.
Cette méthode nécessitait déjà l'autorisation BLUETOOTH_CONNECT
, mais elle n'a pas été appliquée. Assurez-vous que votre application déclare BLUETOOTH_CONNECT
dans son fichier AndroidManifest.xml
, comme indiqué dans l'extrait de code suivant, et vérifiez qu'un utilisateur a accordé l'autorisation avant d'appeler getProfileConnectionState
.
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
Mises à jour OpenJDK 17
Android 14 continues the work of refreshing Android's core libraries to align with the features in the latest OpenJDK LTS releases, including both library updates and Java 17 language support for app and platform developers.
A few of these changes can affect app compatibility:
- Changes to regular expressions: Invalid group references are now
disallowed to more closely follow the semantics of OpenJDK. You might see
new cases where an
IllegalArgumentException
is thrown by thejava.util.regex.Matcher
class, so make sure to test your app for areas that use regular expressions. To enable or disable this change while testing, toggle theDISALLOW_INVALID_GROUP_REFERENCE
flag using the compatibility framework tools. - UUID handling: The
java.util.UUID.fromString()
method now does more strict checks when validating the input argument, so you might see anIllegalArgumentException
during deserialization. To enable or disable this change while testing, toggle theENABLE_STRICT_VALIDATION
flag using the compatibility framework tools. - ProGuard issues: In some cases, the addition of the
java.lang.ClassValue
class causes an issue if you try to shrink, obfuscate, and optimize your app using ProGuard. The problem originates with a Kotlin library that changes runtime behaviour based on whetherClass.forName("java.lang.ClassValue")
returns a class or not. If your app was developed against an older version of the runtime without thejava.lang.ClassValue
class available, then these optimizations might remove thecomputeValue
method from classes derived fromjava.lang.ClassValue
.
JobScheduler renforce le comportement des rappels et du réseau
Since its introduction, JobScheduler expects your app to return from
onStartJob
or onStopJob
within a few seconds. Prior to Android 14,
if a job runs too long, it stops and fails silently. If your app targets Android
14 (API level 34) or higher and exceeds the granted time on the main thread, the
app triggers an ANR with the error message "No response to onStartJob
" or "No
response to onStopJob
". Consider migrating to WorkManager, which provides
support for asynchronous processing or migrating any heavy work into a
background thread.
JobScheduler
also introduces a requirement to declare the
ACCESS_NETWORK_STATE
permission if using setRequiredNetworkType
or
setRequiredNetwork
constraint. If your app does not declare the
ACCESS_NETWORK_STATE
permission when scheduling the job and is targeting
Android 14 or higher, it will result in a SecurityException
.
Confidentialité
Accès partiel aux photos et aux vidéos
Android 14 introduit l'accès aux photos sélectionnées, qui permet aux utilisateurs d'autoriser des applications à accéder à des images et des vidéos spécifiques de leur bibliothèque, plutôt que d'accorder l'accès à tous les contenus multimédias d'un type donné.
Cette modification n'est activée que si votre application cible Android 14 (niveau d'API 34) ou version ultérieure. Si vous n'utilisez pas encore le sélecteur de photos, nous vous recommandons de le mettre en œuvre dans votre application pour offrir une expérience cohérente de sélection d'images et de vidéos, tout en améliorant la confidentialité des utilisateurs sans avoir à demander d'autorisations de stockage.
Si vous gérez votre propre sélecteur de galerie à l'aide d'autorisations de stockage et que vous devez garder un contrôle total sur votre implémentation, adaptez votre implémentation pour utiliser la nouvelle autorisation READ_MEDIA_VISUAL_USER_SELECTED
. Si votre application n'utilise pas la nouvelle autorisation, le système l'exécute en mode de compatibilité.
Expérience utilisateur
Notifications d'intent plein écran sécurisées
With Android 11 (API level 30), it was possible for any app to use
Notification.Builder.setFullScreenIntent
to send full-screen
intents while the phone is locked. You could auto-grant this on app install by
declaring USE_FULL_SCREEN_INTENT
permission in the
AndroidManifest.
Full-screen intent notifications are designed for extremely high-priority
notifications demanding the user's immediate attention, such as an incoming
phone call or alarm clock settings configured by the user. For apps targeting
Android 14 (API level 34) or higher, apps that are allowed to use this
permission are limited to those that provide calling and alarms only. The Google
Play Store revokes default USE_FULL_SCREEN_INTENT
permissions for any apps
that don't fit this profile. The deadline for these policy changes is May 31,
2024.
This permission remains enabled for apps installed on the phone before the user updates to Android 14. Users can turn this permission on and off.
You can use the new API
NotificationManager.canUseFullScreenIntent
to check if your app
has the permission; if not, your app can use the new intent
ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT
to launch the settings
page where users can grant the permission.
Sécurité
Restrictions concernant les intents implicites et en attente
Pour les applications ciblant Android 14 (niveau d'API 34) ou version ultérieure, Android empêche les applications d'envoyer des intents implicites à des composants d'application internes comme suit:
- Les intents implicites ne sont transmis qu'aux composants exportés. Les applications doivent utiliser un intent explicite pour transmettre les composants non exportés, ou marquer le composant comme exporté.
- Si une application crée un intent en attente modifiable avec un intent qui ne spécifie pas de composant ni de package, le système génère une exception.
Ces modifications empêchent les applications malveillantes d'intercepter les intents implicites destinés à être utilisés par les composants internes d'une application.
Voici par exemple un filtre d'intent qui peut être déclaré dans le fichier manifeste de votre application :
<activity
android:name=".AppActivity"
android:exported="false">
<intent-filter>
<action android:name="com.example.action.APP_ACTION" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
Si votre application a tenté de lancer cette activité à l'aide d'un intent implicite, une exception sera générée :
Kotlin
// Throws an exception when targeting Android 14. context.startActivity(Intent("com.example.action.APP_ACTION"))
Java
// Throws an exception when targeting Android 14. context.startActivity(new Intent("com.example.action.APP_ACTION"));
Pour lancer l'activité non exportée, votre application doit utiliser un intent explicite :
Kotlin
// This makes the intent explicit. val explicitIntent = Intent("com.example.action.APP_ACTION") explicitIntent.apply { package = context.packageName } context.startActivity(explicitIntent)
Java
// This makes the intent explicit. Intent explicitIntent = new Intent("com.example.action.APP_ACTION") explicitIntent.setPackage(context.getPackageName()); context.startActivity(explicitIntent);
Les broadcasts receivers enregistrés lors de l'exécution doivent spécifier le comportement d'exportation
Les applications et les services qui ciblent Android 14 (niveau d'API 34) ou version ultérieure et utilisent des récepteurs enregistrés en contexte doivent spécifier un indicateur pour indiquer si le récepteur doit être exporté ou non vers toutes les autres applications de l'appareil: RECEIVER_EXPORTED
ou RECEIVER_NOT_EXPORTED
, respectivement.
Cette exigence permet de protéger les applications contre les failles de sécurité en exploitant les fonctionnalités pour ces récepteurs introduites dans Android 13.
Exception pour les récepteurs qui ne reçoivent que des annonces du système
Si votre application n'enregistre un récepteur que pour les annonces du système via des méthodes Context#registerReceiver
, telles que Context#registerReceiver()
, elle ne doit pas spécifier d'indicateur lors de l'enregistrement du récepteur.
Chargement de code dynamique plus sécurisé
If your app targets Android 14 (API level 34) or higher and uses Dynamic Code Loading (DCL), all dynamically-loaded files must be marked as read-only. Otherwise, the system throws an exception. We recommend that apps avoid dynamically loading code whenever possible, as doing so greatly increases the risk that an app can be compromised by code injection or code tampering.
If you must dynamically load code, use the following approach to set the dynamically-loaded file (such as a DEX, JAR, or APK file) as read-only as soon as the file is opened and before any content is written:
Kotlin
val jar = File("DYNAMICALLY_LOADED_FILE.jar") val os = FileOutputStream(jar) os.use { // Set the file to read-only first to prevent race conditions jar.setReadOnly() // Then write the actual file content } val cl = PathClassLoader(jar, parentClassLoader)
Java
File jar = new File("DYNAMICALLY_LOADED_FILE.jar"); try (FileOutputStream os = new FileOutputStream(jar)) { // Set the file to read-only first to prevent race conditions jar.setReadOnly(); // Then write the actual file content } catch (IOException e) { ... } PathClassLoader cl = new PathClassLoader(jar, parentClassLoader);
Handle dynamically-loaded files that already exist
To prevent exceptions from being thrown for existing dynamically-loaded files, we recommend deleting and recreating the files before you try to dynamically load them again in your app. As you recreate the files, follow the preceding guidance for marking the files read-only at write time. Alternatively, you can re-label the existing files as read-only, but in this case, we strongly recommend that you verify the integrity of the files first (for example, by checking the file's signature against a trusted value), to help protect your app from malicious actions.
Restrictions supplémentaires concernant le démarrage d'activités en arrière-plan
Pour les applications ciblant Android 14 (niveau d'API 34) ou version ultérieure, le système limite davantage le moment où les applications sont autorisées à démarrer des activités en arrière-plan:
- Lorsqu'une application envoie un
PendingIntent
à l'aide dePendingIntent#send()
ou de méthodes similaires, elle doit l'activer si elle souhaite accorder ses propres privilèges de lancement d'activité en arrière-plan pour démarrer l'intent en attente. Pour l'activer, l'application doit transmettre un bundleActivityOptions
avecsetPendingIntentBackgroundActivityStartMode(MODE_BACKGROUND_ACTIVITY_START_ALLOWED)
. - Lorsqu'une application visible associe un service à une autre application en arrière-plan à l'aide de la méthode
bindService()
, elle doit désormais l'activer si elle souhaite accorder ses propres privilèges de lancement d'activité en arrière-plan au service lié. Pour l'activer, l'application doit inclure l'indicateurBIND_ALLOW_ACTIVITY_STARTS
lors de l'appel de la méthodebindService()
.
Ces modifications étendent l'ensemble de restrictions existant pour protéger les utilisateurs en empêchant les applications malveillantes d'utiliser les API de manière abusive pour lancer des activités perturbatrices en arrière-plan.
Traversée de répertoire ZIP
Pour les applications ciblant Android 14 (niveau d'API 34) ou version ultérieure, Android empêche la faille de traversée de répertoires ZIP de la manière suivante : ZipFile(String)
et ZipInputStream.getNextEntry()
génèrent une erreur ZipException
si les noms des entrées de fichiers ZIP contiennent ".." ou commencent par "/".
Les applications peuvent désactiver cette validation en appelant dalvik.system.ZipPathValidator.clearCallback()
.
Consentement de l'utilisateur requis pour chaque session de capture MediaProjection
Pour les applications ciblant Android 14 (niveau d'API 34) ou version ultérieure, une SecurityException
est générée par MediaProjection#createVirtualDisplay
dans l'un des scénarios suivants:
- Votre application met en cache le
Intent
renvoyé parMediaProjectionManager#createScreenCaptureIntent
et le transmet plusieurs fois àMediaProjectionManager#getMediaProjection
. - Votre application appelle
MediaProjection#createVirtualDisplay
plusieurs fois sur la même instanceMediaProjection
.
Votre application doit demander à l'utilisateur de donner son consentement avant chaque session de capture. Une session de capture unique correspond à un appel unique sur MediaProjection#createVirtualDisplay
, et chaque instance MediaProjection
ne doit être utilisée qu'une seule fois.
Gérer les modifications de configuration
Si votre application doit appeler MediaProjection#createVirtualDisplay
pour gérer les modifications de configuration (telles que l'orientation ou la taille de l'écran), vous pouvez suivre ces étapes pour mettre à jour VirtualDisplay
pour l'instance MediaProjection
existante:
- Appelez
VirtualDisplay#resize
avec les nouvelles largeurs et hauteurs. - Fournissez un nouveau
Surface
avec de nouvelles largeurs et hauteurs définies pourVirtualDisplay#setSurface
.
Enregistrer un rappel
Votre application doit enregistrer un rappel pour gérer les cas où l'utilisateur ne donne pas son consentement pour poursuivre une session de capture. Pour ce faire, implémentez Callback#onStop
et demandez à votre application de publier toutes les ressources associées (telles que VirtualDisplay
et Surface
).
Si votre application n'enregistre pas ce rappel, MediaProjection#createVirtualDisplay
génère une exception IllegalStateException
lorsque votre application l'appelle.
Mise à jour des restrictions non SDK
Android 14 inclut des listes à jour d'interfaces non SDK limitées grâce à la collaboration avec les développeurs Android et aux derniers 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 14, certaines de ces modifications ne vous affecteront peut-être pas immédiatement. Cependant, bien que vous puissiez actuellement utiliser certaines interfaces non SDK (en fonction du niveau d'API cible de votre application), l'utilisation d'un champ ou d'une méthode non SDK présente 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 tester votre application pour le savoir. Si votre application repose sur des interfaces non SDK, vous devriez commencer à planifier une migration vers des alternatives SDK. Nous comprenons néanmoins que certaines applications ont des cas d'utilisation valides pour utiliser des interfaces non SDK. Si vous ne trouvez pas d'alternative à l'utilisation d'une interface non SDK pour une fonctionnalité de votre application, vous devriez 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 14. Pour en savoir plus sur les interfaces non SDK de manière générale, consultez la section Restrictions concernant les interfaces non SDK.