Présentation des fonctionnalités et des API

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Android 15 offre aux développeurs de nouvelles fonctionnalités et API de qualité. Les sections suivantes résument ces fonctionnalités pour vous aider à vous lancer avec les API associées.

Pour obtenir une liste détaillée des API ajoutées, modifiées et supprimées, consultez le rapport de différences des API. Pour en savoir plus sur les API ajoutées, consultez la documentation de référence des API Android. Pour Android 15, recherchez les API ajoutées au niveau d'API 35. Pour savoir dans quels domaines les changements de plate-forme peuvent affecter vos applications, consultez les modifications de comportement d'Android 15pour les applications ciblant Android 15 et pour toutes les applications.

Appareil photo et médias

Android 15 inclut diverses fonctionnalités qui améliorent l'expérience de l'appareil photo et des contenus multimédias, et qui vous donnent accès à des outils et du matériel pour aider les créateurs à donner vie à leur vision sur Android.

Pour en savoir plus sur les dernières fonctionnalités et solutions pour les développeurs pour les contenus multimédias et l'appareil photo Android, consultez la présentation Créer des expériences multimédias et d'appareil photo Android modernes de Google I/O.

Amplification luminosité faible

Android 15 introduces Low Light Boost, an auto-exposure mode available to both Camera 2 and the night mode camera extension. Low Light Boost adjusts the exposure of the Preview stream in low-light conditions. This is different from how the night mode camera extension creates still images, because night mode combines a burst of photos to create a single, enhanced image. While night mode works very well for creating a still image, it can't create a continuous stream of frames, but Low Light Boost can. Thus, Low Light Boost enables camera capabilities, such as:

• Providing an enhanced image preview, so users are better able to frame their low-light pictures
• Scanning QR codes in low light

If you enable Low Light Boost, it automatically turns on when there's a low light level, and turns off when there's more light.

Apps can record off the Preview stream in low-light conditions to save a brightened video.

For more information, see Low Light Boost.

Commandes de la caméra dans l'application

Android 15 adds an extension for more control over the camera hardware and its algorithms on supported devices:

• Advanced flash strength adjustments enabling precise control of flash intensity in both SINGLE and TORCH modes while capturing images.

Contrôle de la plage dynamique HDR

Android 15 choisit la plage dynamique appropriée pour les fonctionnalités de l'appareil sous-jacent et la profondeur de bits du panneau. Pour les pages contenant beaucoup de contenu SDR, comme une application de messagerie affichant une seule vignette HDR, ce comportement peut avoir un impact négatif sur la luminosité perçue du contenu SDR. Android 15 vous permet de contrôler la plage dynamique HDR avec setDesiredHdrHeadroom pour trouver un équilibre entre le contenu SDR et HDR.

Contrôle du volume

Android 15 introduces support for the CTA-2075 loudness standard to help you avoid audio loudness inconsistencies and ensure users don't have to constantly adjust volume when switching between content. The system leverages known characteristics of the output devices (headphones and speaker) along with loudness metadata available in AAC audio content to intelligently adjust the audio loudness and dynamic range compression levels.

To enable this feature, you need to ensure loudness metadata is available in your AAC content and enable the platform feature in your app. For this, you instantiate a LoudnessCodecController object by calling its create factory method with the audio session ID from the associated AudioTrack; this automatically starts applying audio updates. You can pass an OnLoudnessCodecUpdateListener to modify or filter loudness parameters before they are applied on the MediaCodec.

// Media contains metadata of type MPEG_4 OR MPEG_D
val mediaCodec = …
val audioTrack = AudioTrack.Builder()
                                .setSessionId(sessionId)
                                .build()
...
// Create new loudness controller that applies the parameters to the MediaCodec
try {
   val lcController = LoudnessCodecController.create(mSessionId)
   // Starts applying audio updates for each added MediaCodec
}

AndroidX media3 ExoPlayer will also be updated to use the LoudnessCodecController APIs for a seamless app integration.

Appareils MIDI 2.0 virtuels

Android 13 est compatible avec la connexion à des appareils MIDI 2.0 via USB, qui communiquent à l'aide de paquets MIDI universels (UMP). Android 15 étend la compatibilité avec UMP aux applications MIDI virtuelles, ce qui permet aux applications de composition de contrôler les applications de synthétiseur en tant qu'appareil MIDI 2.0 virtuel, comme elles le feraient avec un appareil USB MIDI 2.0.

Décodage logiciel AV1 plus efficace

dav1d, le populaire décodeur logiciel AV1 de VideoLAN, est disponible pour les appareils Android qui ne prennent pas en charge le décodage AV1 en matériel. dav1d est jusqu'à trois fois plus performant que l'ancien décodeur logiciel AV1, ce qui permet de lire des vidéos AV1 HD pour plus d'utilisateurs, y compris sur certains appareils de milieu de gamme.

Votre application doit activer l'utilisation de dav1d en l'appelant par nom "c2.android.av1-dav1d.decoder". dav1d deviendra le décodeur logiciel AV1 par défaut lors d'une mise à jour ultérieure. Cette compatibilité est standardisée et rétroportée vers les appareils Android 11 qui reçoivent des mises à jour du système Google Play.

Productivité et outils pour les développeurs

Bien que la plupart de nos efforts visant à améliorer votre productivité soient axés sur des outils tels que Android Studio, Jetpack Compose et les bibliothèques Android Jetpack, nous cherchons toujours à trouver des moyens de vous aider à réaliser plus facilement votre vision.

Mises à jour OpenJDK 17

Android 15 continues the work of refreshing Android's core libraries to align with the features in the latest OpenJDK LTS releases.

The following key features and improvements are included:

• Quality-of-life improvements around NIO buffers
• Streams
• Additional math and strictmath methods
• util package updates including sequenced collection, map, and set
• ByteBuffer support in Deflater
• Security updates such as X500PrivateCredential and security key updates

These APIs are updated on over a billion devices running Android 12 (API level 31) and higher through Google Play System updates, so you can target the latest programming features.

Améliorations apportées aux fichiers PDF

Android 15 apporte des améliorations substantielles aux API PdfRenderer. Les applications peuvent intégrer des fonctionnalités avancées telles que l'affichage de fichiers protégés par un mot de passe, les annotations, la modification de formulaire, la recherche et la sélection avec copie. Les optimisations linéarisées des PDF sont compatibles pour accélérer l'affichage des PDF en local et réduire l'utilisation des ressources.

PdfRenderer a été déplacé vers un module qui peut être mis à jour à l'aide des mises à jour du système Google Play indépendamment de la version de la plate-forme. Nous acceptons ces modifications à nouveau sur Android 11 (niveau d'API 30) en créant une version de surface d'API compatible antérieure à Android 15, appelée PdfRendererPreV.

Vos commentaires sur les améliorations que nous avons apportées à la surface de l'API PdfRenderer nous intéressent, et nous prévoyons de faciliter l'intégration de ces API dans votre application avec une prochaine bibliothèque Android Jetpack.

Améliorations du changement de langue automatique

Android 14 added on-device, multi-language recognition in audio with automatic switching between languages, but this can cause words to get dropped, especially when languages switch with less of a pause between the two utterances. Android 15 adds additional controls to help apps tune this switching to their use case. EXTRA_LANGUAGE_SWITCH_INITIAL_ACTIVE_DURATION_TIME_MILLIS confines the automatic switching to the beginning of the audio session, while EXTRA_LANGUAGE_SWITCH_MATCH_SWITCHES deactivates the language switching after a defined number of switches. These options are particularly useful if you expect that there will be a single language spoken during the session that should be autodetected.

Amélioration de l'API OpenType Variable Font

Android 15 améliore la facilité d'utilisation de la police variable OpenType. Vous pouvez maintenant créer une instance FontFamily à partir d'une police variable sans spécifier ; des axes de pondération avec l'API buildVariableFamily. Le moteur de rendu de texte remplace la valeur de l'axe wght pour qu'elle corresponde au texte affiché.

L'utilisation de la nouvelle API simplifie le code pour créer un Typeface. considérablement:

val newTypeface = Typeface.CustomFallbackBuilder(
            FontFamily.Builder(
                Font.Builder(assets, "RobotoFlex.ttf").build())
                    .buildVariableFamily())
    .build()

Typeface newTypeface = Typeface.CustomFallbackBuilder(
            new FontFamily.Builder(
                new Font.Builder(assets, "RobotoFlex.ttf").build())
                    .buildVariableFamily())
    .build();

Auparavant, pour créer le même Typeface, vous aviez besoin de beaucoup plus de code:

val oldTypeface = Typeface.CustomFallbackBuilder(
            FontFamily.Builder(
                Font.Builder(assets, "RobotoFlex.ttf")
                    .setFontVariationSettings("'wght' 400")
                    .setWeight(400)
                    .build())
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 100")
                        .setWeight(100)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 200")
                        .setWeight(200)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 300")
                        .setWeight(300)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 500")
                        .setWeight(500)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 600")
                        .setWeight(600)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 700")
                        .setWeight(700)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 800")
                        .setWeight(800)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 900")
                        .setWeight(900)
                        .build()
                ).build()
        ).build()

Typeface oldTypeface = new Typeface.CustomFallbackBuilder(
    new FontFamily.Builder(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 400")
            .setWeight(400)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 100")
            .setWeight(100)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 200")
            .setWeight(200)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 300")
            .setWeight(300)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 500")
            .setWeight(500)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 600")
            .setWeight(600)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 700")
            .setWeight(700)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 800")
            .setWeight(800)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 900")
            .setWeight(900)
            .build()
    )
    .build()
).build();

Voici un exemple de la façon dont un Typeface a été créé avec les anciennes et les nouvelles API affiche:

Dans cet exemple, le Typeface créé avec l'ancienne API n'a pas pour créer des épaisseurs de police précises pour les tailles 350, 450, 550 et 650 Font. Ainsi, le moteur de rendu revient à la pondération la plus proche. Ainsi, dans dans ce cas, 300 s'affiche au lieu de 350, 400 s'affiche au lieu de 450, et ainsi de suite. En revanche, le Typeface créé avec les nouvelles API crée dynamiquement une instance Font pour une pondération donnée, afin d'obtenir des pondérations précises pour 350. 450, 550 et 650.

Contrôles précis des sauts de ligne

À partir d'Android 15, un TextView et le séparateur de ligne sous-jacent peuvent conserver la partie de texte donnée sur la même ligne pour améliorer la lisibilité. Vous pouvez profiter de cette personnalisation de la casse en utilisant la balise <nobreak> dans les ressources de chaîne ou createNoBreakSpan. De même, vous pouvez empêcher la césure des mots à l'aide de la balise <nohyphen> ou createNoHyphenationSpan.

Par exemple, la ressource de chaîne suivante n'inclut pas de saut de ligne et s'affiche avec le texte "Pixel 8 Pro." qui se brise à un endroit indésirable:

<resources>
    <string name="pixel8pro">The power and brains behind Pixel 8 Pro.</string>
</resources>

En revanche, cette ressource de chaîne inclut la balise <nobreak>, qui affiche la phrase "Pixel 8 Pro" et empêche les sauts de ligne:

<resources>
    <string name="pixel8pro">The power and brains behind <nobreak>Pixel 8 Pro.</nobreak></string>
</resources>

La différence d'affichage de ces chaînes est illustrée dans les images suivantes:

Mise en page pour une ligne de texte dans laquelle l'expression "Pixel 8 Pro" n'est pas enveloppée à l'aide d'une balise <nobreak>.

Mise en page de la même ligne de texte où la phrase "Pixel 8 Pro." est mise en forme à l'aide d'une balise <nobreak>.

Archivage des applications

Android and Google Play announced support for app archiving last year, allowing users to free up space by partially removing infrequently used apps from the device that were published using Android App Bundle on Google Play. Android 15 includes OS level support for app archiving and unarchiving, making it easier for all app stores to implement it.

Apps with the REQUEST_DELETE_PACKAGES permission can call the PackageInstaller requestArchive method to request archiving an installed app package, which removes the APK and any cached files, but persists user data. Archived apps are returned as displayable apps through the LauncherApps APIs; users will see a UI treatment to highlight that those apps are archived. If a user taps on an archived app, the responsible installer will get a request to unarchive it, and the restoration process can be monitored by the ACTION_PACKAGE_ADDED broadcast.

Activer le mode 16 ko sur un appareil à l'aide des options pour les développeurs

Activez l'option de développement Démarrer avec une page de 16 ko pour démarrer un appareil en mode 16 ko.

À partir d'Android 15 QPR1, vous pouvez utiliser l'option pour les développeurs disponible sur certains appareils pour démarrer l'appareil en mode 16 ko et effectuer des tests sur l'appareil. Avant d'utiliser l'option pour les développeurs, accédez à Paramètres -> Système -> Mises à jour logicielles et appliquez toutes les mises à jour disponibles.

Cette option pour les développeurs est disponible sur les appareils suivants:

• Pixel 8 et Pixel 8 Pro (avec Android 15 QPR1 ou version ultérieure)

  Avertissement: En raison d'un problème connu avec Android 15 QPR2 bêta 3, l'écran tactile ne fonctionne pas sur les appareils Pixel 8 après l'installation d'Android 15 QPR2 bêta 3 et le démarrage de l'appareil en mode 16 ko. Ce problème ne concerne pas les appareils Pixel 8 Pro.

• Pixel 8a (avec Android 15 QPR1 ou version ultérieure)

  Avertissement: En raison d'un problème connu avec Android 15 QPR2 bêta 3, l'écran tactile ne fonctionne pas sur les appareils Pixel 8a après l'installation d'Android 15 QPR2 bêta 3 et le démarrage de l'appareil en mode 16 ko.

• Pixel 9, Pixel 9 Pro et Pixel 9 Pro XL (avec la version bêta 2 de QPR2 d'Android 15 ou version ultérieure)

Graphiques

Android 15 apporte les dernières améliorations graphiques, y compris ANGLE et des ajouts au système graphique Canvas.

Moderniser l'accès au GPU d'Android

Android hardware has evolved quite a bit from the early days where the core OS would run on a single CPU and GPUs were accessed using APIs based on fixed-function pipelines. The Vulkan® graphics API has been available in the NDK since Android 7.0 (API level 24) with a lower-level abstraction that better reflects modern GPU hardware, scales better to support multiple CPU cores, and offers reduced CPU driver overhead — leading to improved app performance. Vulkan is supported by all modern game engines.

Vulkan is Android's preferred interface to the GPU. Therefore, Android 15 includes ANGLE as an optional layer for running OpenGL® ES on top of Vulkan. Moving to ANGLE will standardize the Android OpenGL implementation for improved compatibility, and, in some cases, improved performance. You can test out your OpenGL ES app stability and performance with ANGLE by enabling the developer option in Settings -> System -> Developer Options -> Experimental: Enable ANGLE on Android 15.

The Android ANGLE on Vulkan roadmap

As part of streamlining our GPU stack, going forward we will be shipping ANGLE as the GL system driver on more new devices, with the future expectation that OpenGL/ES will be only available through ANGLE. That being said, we plan to continue support for OpenGL ES on all devices.

Recommended next steps

Use the developer options to select the ANGLE driver for OpenGL ES and test your app. For new projects, we strongly encourage using Vulkan for C/C++.

Améliorations apportées à Canvas

Android 15 poursuit la modernisation du système graphique Canvas d'Android avec des fonctionnalités supplémentaires:

• Matrix44 fournit une matrice 4x4 pour transformer les coordonnées à utiliser lorsque vous souhaitez manipuler le canevas en 3D.
• clipShader croise le clip actuel avec le nuanceur spécifié, tandis que clipOutShader définit le clip sur la différence entre le clip actuel et le nuanceur, chacun traitant le nuanceur comme un masque alpha. Cela permet de dessiner efficacement des formes complexes.

Performances et batterie

Android continue de vous aider à améliorer les performances et la qualité de vos applications. Android 15 introduit des API qui permettent d'exécuter les tâches de votre application plus efficacement, d'optimiser ses performances et de collecter des insights sur vos applications.

Pour découvrir les bonnes pratiques d'économie d'énergie, le débogage de l'utilisation du réseau et de l'alimentation, et comment nous améliorons l'efficacité énergétique des tâches en arrière-plan dans Android 15 et les versions récentes d'Android, consultez la présentation Améliorer l'efficacité énergétique des tâches en arrière-plan sur Android de Google I/O.

API ApplicationStartInfo

In previous versions of Android, app startup has been a bit of a mystery. It was challenging to determine within your app whether it started from a cold, warm, or hot state. It was also difficult to know how long your app spent during the various launch phases: forking the process, calling onCreate, drawing the first frame, and more. When your Application class was instantiated, you had no way of knowing whether the app started from a broadcast, a content provider, a job, a backup, boot complete, an alarm, or an Activity.

The ApplicationStartInfo API on Android 15 provides all of this and more. You can even choose to add your own timestamps into the flow to help collect timing data in one place. In addition to collecting metrics, you can use ApplicationStartInfo to help directly optimize app startup; for example, you can eliminate the costly instantiation of UI-related libraries within your Application class when your app is starting up due to a broadcast.

Informations détaillées sur la taille de l'application

Depuis Android 8.0 (niveau d'API 26), Android inclut l'API StorageStats.getAppBytes, qui résume la taille installée d'une application en un seul nombre d'octets, qui correspond à la somme de la taille de l'APK, de la taille des fichiers extraits de l'APK et des fichiers générés sur l'appareil, tels que le code compilé à l'avance (AOT). Ce nombre n'est pas très révélateur de la façon dont votre application utilise l'espace de stockage.

Android 15 ajoute l'API StorageStats.getAppBytesByDataType([type]), qui vous permet d'obtenir des informations sur la façon dont votre application utilise tout cet espace, y compris les fractionnements de fichiers APK, le code lié à l'AOT et à l'accélération, les métadonnées dex, les bibliothèques et les profils guidés.

Profilage géré par l'application

Android 15 includes the ProfilingManager class, which lets you collect profiling information from within your app such as heap dumps, heap profiles, stack sampling, and more. It provides a callback to your app with a supplied tag to identify the output file, which is delivered to your app's files directory. The API does rate limiting to minimize the performance impact.

To simplify constructing profiling requests in your app, we recommend using the corresponding Profiling AndroidX API, available in Core 1.15.0-rc01 or higher.

Améliorations apportées à la base de données SQLite

Android 15 introduit les API SQLite qui exposent les fonctionnalités avancées du SQLite sous-jacent qui ciblent des problèmes de performances spécifiques manifeste dans les applications. Ces API sont incluses dans la mise à jour de SQLite vers 3.44.3.

Les développeurs doivent consulter les bonnes pratiques concernant les performances de SQLite. pour exploiter pleinement leur base de données SQLite, en particulier lorsqu'ils travaillent avec de grands ou lors de l'exécution de requêtes sensibles à la latence.

• Transactions différées en lecture seule: lors de l'émission de transactions qui sont en lecture seule (pas les instructions d'écriture), utilisez beginTransactionReadOnly() et beginTransactionWithListenerReadOnly(SQLiteTransactionListener) pour émettre des transactions DEFERRED en lecture seule. Ces transactions peuvent s'exécuter simultanément les unes avec les autres. Si la base de données est en mode WAL, elles peuvent s'exécuter simultanément avec des transactions IMMEDIATE ou EXCLUSIVE.
• Nombre et ID de lignes : des API ont été ajoutées pour récupérer le nombre de lignes modifiées ou l'ID de la dernière ligne insérée sans émettre de requête supplémentaire. getLastChangedRowCount() renvoie le nombre de lignes ont été insérées, mises à jour ou supprimées par l'instruction SQL la plus récente dans la transaction en cours, tandis que getTotalChangedRowCount() renvoie le nombre défini pour la connexion en cours. getLastInsertRowId() renvoie l'rowid de la dernière ligne. à insérer sur la connexion actuelle.
• Instructions brutes : émettez une instruction SQlite brute, en contournant les wrappers pratiques et tout coût de traitement supplémentaire qu'ils pourraient entraîner.

Mises à jour d'Android Dynamic Performance Framework

Android 15 poursuit notre investissement dans le Framework de performances dynamiques Android (ADPF), un ensemble d'API permettant aux jeux et aux applications haute performance d'interagir plus directement avec les systèmes d'alimentation et thermiques des appareils Android. Sur les appareils compatibles, Android 15 ajoute des fonctionnalités ADPF:

• Un mode d'économie d'énergie pour les sessions d'indices afin d'indiquer que leurs threads associés doivent privilégier l'économie d'énergie aux performances, ce qui est idéal pour les charges de travail en arrière-plan de longue durée.
• Les durées de travail du GPU et du CPU peuvent toutes deux être signalées dans les sessions d'indices, ce qui permet au système d'ajuster les fréquences du CPU et du GPU ensemble pour mieux répondre aux exigences de la charge de travail.
• Seuils de plage de température pour interpréter l'état de limitation thermique possible en fonction de la prévision de la plage de température.

Pour en savoir plus sur l'utilisation de l'ADPF dans vos applications et jeux, consultez la documentation.

Confidentialité

Android 15 inclut diverses fonctionnalités qui aident les développeurs d'applications à protéger la confidentialité des utilisateurs.

Détection d'enregistrement d'écran

Android 15 adds support for apps to detect that they are being recorded. A callback is invoked whenever the app transitions between being visible or invisible within a screen recording. An app is considered visible if activities owned by the registering process's UID are being recorded. This way, if your app is performing a sensitive operation, you can inform the user that they're being recorded.

val mCallback = Consumer<Int> { state ->
  if (state == SCREEN_RECORDING_STATE_VISIBLE) {
    // We're being recorded
  } else {
    // We're not being recorded
  }
}

override fun onStart() {
   super.onStart()
   val initialState =
      windowManager.addScreenRecordingCallback(mainExecutor, mCallback)
   mCallback.accept(initialState)
}

override fun onStop() {
    super.onStop()
    windowManager.removeScreenRecordingCallback(mCallback)
}

Fonctionnalités IntentFilter étendues

Android 15 builds in support for more precise Intent resolution through UriRelativeFilterGroup, which contains a set of UriRelativeFilter objects that form a set of Intent matching rules that must each be satisfied, including URL query parameters, URL fragments, and blocking or exclusion rules.

These rules can be defined in the AndroidManifest XML file with the <uri-relative-filter-group> tag, which can optionally include an android:allow tag. These tags can contain <data> tags that use existing data tag attributes as well as the android:query and android:fragment attributes.

Here's an example of the AndroidManifest syntax:

<intent-filter android:autoVerify="true">
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.BROWSABLE" />
  <category android:name="android.intent.category.DEFAULT" />
  <data android:scheme="http" />
  <data android:scheme="https" />
  <data android:host="astore.com" />
  <uri-relative-filter-group>
    <data android:pathPrefix="/auth" />
    <data android:query="region=na" />
  </uri-relative-filter-group>
  <uri-relative-filter-group android:allow="false">
    <data android:pathPrefix="/auth" />
    <data android:query="mobileoptout=true" />
  </uri-relative-filter-group>
  <uri-relative-filter-group android:allow="false">
    <data android:pathPrefix="/auth" />
    <data android:fragmentPrefix="faq" />
  </uri-relative-filter-group>
</intent-filter>

Espace privé

Private space lets users create a separate space on their device where they can keep sensitive apps away from prying eyes, under an additional layer of authentication. The private space uses a separate user profile. The user can choose to use the device lock or a separate lock factor for the private space.

Apps in the private space show up in a separate container in the launcher, and are hidden from the recents view, notifications, settings, and from other apps when the private space is locked. User-generated and downloaded content (such as media or files) and accounts are separated between the private space and the main space. The system sharesheet and the photo picker can be used to give apps access to content across spaces when the private space is unlocked.

Users can't move existing apps and their data into the private space. Instead, users select an install option in the private space to install an app using whichever app store they prefer. Apps in the private space are installed as separate copies from any apps in the main space (new copies of the same app).

When a user locks the private space, the profile is stopped. While the profile is stopped, apps in the private space are no longer active and can't perform foreground or background activities, including showing notifications.

We recommend that you test your app with private space to make sure your app works as expected, especially if your app falls into one of the following categories:

• Apps with logic for work profiles that assumes that any installed copies of their app that aren't in the main profile are in the work profile.
• Medical apps
• Launcher apps
• App store apps

Interroger la dernière sélection de l'utilisateur pour l'accès aux photos sélectionnées

Apps can now highlight only the most-recently-selected photos and videos when partial access to media permissions is granted. This feature can improve the user experience for apps that frequently request access to photos and videos. To use this feature in your app, enable the QUERY_ARG_LATEST_SELECTION_ONLY argument when querying MediaStore through ContentResolver.

val externalContentUri = MediaStore.Files.getContentUri("external")

val mediaColumns = arrayOf(
   FileColumns._ID,
   FileColumns.DISPLAY_NAME,
   FileColumns.MIME_TYPE,
)

val queryArgs = bundleOf(
   // Return only items from the last selection (selected photos access)
   QUERY_ARG_LATEST_SELECTION_ONLY to true,
   // Sort returned items chronologically based on when they were added to the device's storage
   QUERY_ARG_SQL_SORT_ORDER to "${FileColumns.DATE_ADDED} DESC",
   QUERY_ARG_SQL_SELECTION to "${FileColumns.MEDIA_TYPE} = ? OR ${FileColumns.MEDIA_TYPE} = ?",
   QUERY_ARG_SQL_SELECTION_ARGS to arrayOf(
       FileColumns.MEDIA_TYPE_IMAGE.toString(),
       FileColumns.MEDIA_TYPE_VIDEO.toString()
   )
)

Uri externalContentUri = MediaStore.Files.getContentUri("external");

String[] mediaColumns = {
    FileColumns._ID,
    FileColumns.DISPLAY_NAME,
    FileColumns.MIME_TYPE
};

Bundle queryArgs = new Bundle();
queryArgs.putBoolean(MediaStore.QUERY_ARG_LATEST_SELECTION_ONLY, true);
queryArgs.putString(MediaStore.QUERY_ARG_SQL_SORT_ORDER, FileColumns.DATE_ADDED + " DESC");
queryArgs.putString(MediaStore.QUERY_ARG_SQL_SELECTION, FileColumns.MEDIA_TYPE + " = ? OR " + FileColumns.MEDIA_TYPE + " = ?");
queryArgs.putStringArray(MediaStore.QUERY_ARG_SQL_SELECTION_ARGS, new String[] {
    String.valueOf(FileColumns.MEDIA_TYPE_IMAGE),
    String.valueOf(FileColumns.MEDIA_TYPE_VIDEO)
});

Privacy Sandbox sur Android

Android 15 includes the latest Android Ad Services extensions, incorporating the latest version of the Privacy Sandbox on Android. This addition is part of our work to develop technologies that improve user privacy and enable effective, personalized advertising experiences for mobile apps. Our privacy sandbox page has more information about the Privacy Sandbox on Android developer preview and beta programs to help you get started.

Santé Connect

Android 15 integrates the latest extensions around Health Connect by Android, a secure and centralized platform to manage and share app-collected health and fitness data. This update adds support for additional data types across fitness, nutrition, skin temperature, training plans, and more.

Skin temperature tracking allows users to store and share more accurate temperature data from a wearable or other tracking device.

Training plans are structured workout plans to help a user achieve their fitness goals. Training plans support includes a variety of completion and performance goals:

• Completion goals around calories burned, distance, duration, repetition, and steps.
• Performance goals around as many repetitions as possible (AMRAP), cadence, heart rate, power, perceived rate of exertion, and speed.

Learn more about the latest updates to Health Connect in Android in the Building adaptable experiences with Android Health talk from Google I/O.

Partager le contenu d'une appli sur l'écran

Android 15 supports app screen sharing so users can share or record just an app window rather than the entire device screen. This feature, first enabled in Android 14 QPR2, includes MediaProjection callbacks that allow your app to customize the app screen sharing experience. Note that for apps targeting Android 14 (API level 34) or higher, user consent is required for each MediaProjection capture session.

Expérience utilisateur et interface utilisateur du système

Android 15 offre aux développeurs d'applications et aux utilisateurs plus de contrôle et de flexibilité pour configurer leur appareil en fonction de leurs besoins.

Pour découvrir comment utiliser les dernières améliorations d'Android 15 pour améliorer l'expérience utilisateur de votre application, consultez la conférence Améliorer l'expérience utilisateur de votre application Android de Google I/O.

Aperçus de widgets plus riches avec l'API Generated Previews

Avant Android 15, le seul moyen de fournir des aperçus du sélecteur de widgets était de spécifier une ressource d'image ou de mise en page statique. Ces aperçus diffèrent souvent considérablement de l'apparence du widget réel lorsqu'il est placé sur l'écran d'accueil. De plus, les ressources statiques ne peuvent pas être créées avec Jetpack Glance. Un développeur Glance doit donc prendre une capture d'écran de son widget ou créer une mise en page XML pour obtenir un aperçu du widget.

Android 15 prend en charge les aperçus générés. Cela signifie que les fournisseurs de widgets d'application peuvent générer RemoteViews à utiliser comme aperçu du sélecteur au lieu d'une ressource statique.

API Push

Les applications peuvent fournir des aperçus générés via une API push. Les applications peuvent fournir des aperçus à tout moment de leur cycle de vie et ne reçoivent pas de demande explicite de la part de l'hôte. Les aperçus sont conservés dans AppWidgetService, et les hôtes peuvent les demander à la demande. L'exemple suivant charge une ressource de mise en page de widget XML et la définit en tant qu'aperçu:

AppWidgetManager.getInstance(appContext).setWidgetPreview(
   ComponentName(
       appContext,
       SociaLiteAppWidgetReceiver::class.java
   ),
   AppWidgetProviderInfo.WIDGET_CATEGORY_HOME_SCREEN,
   RemoteViews("com.example", R.layout.widget_preview)
)

Le flux attendu est le suivant:

1. Le fournisseur de widgets appelle setWidgetPreview à tout moment. Les aperçus fournis sont conservés dans AppWidgetService avec d'autres informations du fournisseur.
2. setWidgetPreview informe les hôtes d'un aperçu mis à jour via le rappel AppWidgetHost.onProvidersChanged. En réponse, l'hôte du widget recharge toutes ses informations sur le fournisseur.
3. Lorsque l'hôte affiche un aperçu de widget, il vérifie AppWidgetProviderInfo.generatedPreviewCategories. Si la catégorie choisie est disponible, il appelle AppWidgetManager.getWidgetPreview pour renvoyer l'aperçu enregistré pour ce fournisseur.

Quand appeler le setWidgetPreview

Étant donné qu'il n'y a pas de rappel pour fournir des aperçus, les applications peuvent choisir d'envoyer des aperçus à tout moment lorsqu'elles s'exécutent. La fréquence d'actualisation de l'aperçu dépend du cas d'utilisation du widget.

La liste suivante décrit les deux principales catégories de cas d'utilisation d'aperçu:

• Fournisseurs qui affichent des données réelles dans leurs aperçus de widgets, comme des informations personnalisées ou récentes. Ces fournisseurs peuvent définir l'aperçu une fois que l'utilisateur s'est connecté ou a effectué la configuration initiale dans son application. Ensuite, ils peuvent configurer une tâche périodique pour mettre à jour les aperçus à la fréquence de leur choix. Il peut s'agir d'un widget photo, d'un widget agenda, d'un widget météo ou d'un widget d'actualités.
• Fournisseurs qui affichent des informations statiques dans des aperçus ou des widgets d'action rapide qui n'affichent aucune donnée. Ces fournisseurs peuvent définir des aperçus une seule fois, lors du premier lancement de l'application. Exemples de ce type de widget : widget d'actions rapides Drive ou widget de raccourcis Chrome.

Certains fournisseurs peuvent afficher des aperçus statiques dans le sélecteur de mode Hub, mais des informations réelles dans le sélecteur de l'écran d'accueil. Ces fournisseurs doivent suivre les consignes pour ces deux cas d'utilisation afin de définir des aperçus.

Picture-in-picture

Android 15 introduces changes in Picture-in-Picture (PiP) ensuring an even smoother transition when entering into PiP mode. This will be beneficial for apps having UI elements overlaid on top of their main UI, which goes into PiP.

Developers use the onPictureInPictureModeChanged callback to define logic that toggles the visibility of the overlaid UI elements. This callback is triggered when the PiP enter or exit animation is completed. Beginning in Android 15, the PictureInPictureUiState class includes another state.

With this UI state, apps targeting Android 15 (API level 35) will observe the Activity#onPictureInPictureUiStateChanged callback being invoked with isTransitioningToPip() as soon as the PiP animation starts. There are many UI elements that are not relevant for the app when it is in PiP mode, for example views or layout that include information such as suggestions, upcoming video, ratings, and titles. When the app goes to PiP mode, use the onPictureInPictureUiStateChanged callback to hide these UI elements. When the app goes to full screen mode from the PiP window, use onPictureInPictureModeChanged callback to unhide these elements, as shown in the following examples:

override fun onPictureInPictureUiStateChanged(pipState: PictureInPictureUiState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements
        }
    }

override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
        if (isInPictureInPictureMode) {
          // Unhide UI elements
        }
    }

This quick visibility toggle of irrelevant UI elements (for a PiP window) helps ensure a smoother and flicker-free PiP enter animation.

Règles du mode Ne pas déranger améliorées

AutomaticZenRule lets apps customize Attention Management (Do Not Disturb) rules and decide when to activate or deactivate them. Android 15 greatly enhances these rules with the goal of improving the user experience. The following enhancements are included:

• Adding types to AutomaticZenRule, allowing the system to apply special treatment to some rules.
• Adding an icon to AutomaticZenRule, helping to make the modes be more recognizable.
• Adding a triggerDescription string to AutomaticZenRule that describes the conditions on which the rule should become active for the user.
• Added ZenDeviceEffects to AutomaticZenRule, allowing rules to trigger things like grayscale display, night mode, or dimming the wallpaper.

Définir VibrationEffect pour les canaux de notification

Android 15 permet de définir des vibrations riches pour les notifications entrantes par canal à l'aide de NotificationChannel.setVibrationEffect. Vos utilisateurs peuvent ainsi distinguer les différents types de notifications sans avoir à regarder leur appareil.

Chip de la barre d'état de la projection multimédia et arrêt automatique

La projection multimédia peut exposer des informations personnelles des utilisateurs. Un nouveau chip de barre d'état proéminent informe les utilisateurs de toute projection d'écran en cours. Les utilisateurs peuvent appuyer sur le chip pour arrêter la diffusion, le partage ou l'enregistrement de l'écran. De plus, pour une expérience utilisateur plus intuitive, toute projection d'écran en cours s'arrête désormais automatiquement lorsque l'écran de l'appareil est verrouillé.

Grands écrans et facteurs de forme

Android 15 permet à vos applications de tirer le meilleur parti des facteurs de forme d'Android, y compris les grands écrans, les téléphones à clapet et les pliables.

Amélioration du multitâche sur grand écran

Android 15 offre aux utilisateurs de meilleurs moyens d'effectuer plusieurs tâches en même temps sur les appareils à grand écran. Pour Par exemple, les utilisateurs peuvent enregistrer leurs combinaisons d'applications en écran partagé préférées pour des accéder à la barre des tâches et l'épingler à l'écran pour passer rapidement d'une application à l'autre. Il est donc plus important que jamais de vous assurer que votre application est adaptative.

Google I/O propose des sessions sur la création d'applications Android adaptatives applications et Créer une interface utilisateur avec Material 3 bibliothèque adaptative et notre documentation peut vous aider. Concevoir pour les grands écrans.

Compatibilité avec l'écran de couverture

Votre application peut déclarer une propriété qu'Android 15 utilise pour permettre à votre Application ou Activity d'être présenté sur les petits écrans de couverture des appareils à clapet compatibles. Ces écrans sont trop petits pour être considérés comme des cibles compatibles pour les applications Android, mais votre application peut les prendre en charge, ce qui la rend disponible dans plus d'endroits.

Connectivité

Android 15 met à jour la plate-forme pour donner à votre application accès aux dernières avancées en matière de communication et de technologies sans fil.

Assistance par satellite

Android 15 continue d'étendre la prise en charge de la plate-forme pour la connectivité par satellite et inclut certains éléments d'interface utilisateur pour garantir une expérience utilisateur cohérente sur l'ensemble des de la connectivité par satellite.

Les applications peuvent utiliser ServiceState.isUsingNonTerrestrialNetwork() pour : détecter lorsqu'un appareil est connecté à un satellite, ce qui leur permet de mieux connaître pourquoi les services réseau complètes peuvent être indisponibles. De plus, Android 15 prend en charge les applications de SMS et MMS, ainsi que les applications RCS préchargées à utiliser. la connectivité satellite pour envoyer et recevoir des messages.

Expériences NFC plus fluides

Android 15 vise à rendre l'expérience de paiement sans contact plus fluide et fiable, tout en continuant à prendre en charge l'écosystème d'applications NFC robuste d'Android. Sur les appareils compatibles, les applications peuvent demander à NfcAdapter de passer en mode observation, où l'appareil écoute, mais ne répond pas aux lecteurs NFC, en envoyant les objets PollingFrame du service NFC de l'application à traiter. Les objets PollingFrame peuvent être utilisés pour l'authentification avant la première communication avec le lecteur NFC, ce qui permet une transaction en un seul geste dans de nombreux cas.

De plus, les applications peuvent enregistrer un filtre sur les appareils compatibles afin d'être informées de l'activité de la boucle de sondage, ce qui permet un fonctionnement fluide avec plusieurs applications compatibles avec la technologie NFC.

Rôle de portefeuille

Android 15 introduit un rôle Wallet qui permet une intégration plus étroite avec l'application de portefeuille préférée de l'utilisateur. Ce rôle remplace le paramètre de paiement sans contact par défaut du NFC. Les utilisateurs peuvent gérer le titulaire du rôle Wallet en accédant à Paramètres > Applications > Applications par défaut.

Le rôle Wallet est utilisé lors du routage des pressions NFC pour les AID enregistrés dans la catégorie de paiement. Les pressions sont toujours dirigées vers le titulaire du rôle Wallet, sauf si une autre application enregistrée pour le même AID s'exécute au premier plan.

Ce rôle permet également de déterminer l'emplacement du bloc d'accès rapide Wallet lorsqu'il est activé. Lorsque le rôle est défini sur "Aucun", la carte d'accès rapide n'est pas disponible et les paiements par contact NFC ne sont envoyés qu'à l'application au premier plan.

Sécurité

Android 15 vous aide à améliorer la sécurité de votre application, à protéger ses données et à offrir aux utilisateurs plus de transparence et de contrôle sur leurs données. Pour en savoir plus sur ce que nous faisons pour améliorer la sécurité des utilisateurs et protéger votre application contre les nouvelles menaces, regardez la conférence Protéger la sécurité des utilisateurs sur Android lors de Google I/O.

Intégrer le Gestionnaire d'identifiants à la saisie automatique

À partir d'Android 15, les développeurs peuvent associer des vues spécifiques telles que les champs de nom d'utilisateur ou de mot de passe à des requêtes du Gestionnaire d'identifiants, ce qui facilite la fourniture d'une expérience utilisateur personnalisée lors du processus de connexion. Lorsque l'utilisateur met en surbrillance l'une de ces vues, une requête correspondante est envoyée au Gestionnaire d'identifiants. Les identifiants obtenus sont agrégés entre les fournisseurs et affichés dans les UI de remplacement de la saisie automatique, telles que les suggestions intégrées ou les suggestions déroulantes. La bibliothèque Jetpack androidx.credentials est le point de terminaison recommandé pour les développeurs. Elle sera bientôt disponible pour améliorer davantage cette fonctionnalité dans Android 15 et versions ultérieures.

Intégrer la connexion et l'inscription en un seul geste avec des invites biométriques

Credential Manager integrates biometric prompts into the credential creation and sign-in processes, eliminating the need for providers to manage biometric prompts. As a result, credential providers only need to focus on the results of the create and get flows, augmented with the biometric flow result. This simplified process creates a more efficient and streamlined credential creation and retrieval process.

Gestion des clés pour le chiffrement de bout en bout

Nous lançons E2eeContactKeysManager dans Android 15, qui facilite le chiffrement de bout en bout dans vos applications Android en fournissant une API au niveau de l'OS pour le stockage des clés publiques cryptographiques.

E2eeContactKeysManager est conçu pour s'intégrer à l'application de contacts de la plate-forme afin de permettre aux utilisateurs de gérer et de valider de manière centralisée les clés publiques de leurs contacts.

Vérifications des autorisations sur les URI de contenu

Android 15 introduit un ensemble d'API qui effectuent des vérifications d'autorisation sur les URI de contenu:

• Context.checkContentUriPermissionFull: effectue une vérification complète des autorisations sur les URI de contenu.
• Attribut de fichier manifeste Activity requireContentUriPermissionFromCaller: applique les autorisations spécifiées aux URI de contenu fournis au lancement de l'activité.
• Classe ComponentCaller pour les appelants Activity: représente l'application qui a lancé l'activité.

Accessibilité

Android 15 ajoute des fonctionnalités qui améliorent l'accessibilité pour les utilisateurs.

Braille amélioré

In Android 15, we've made it possible for TalkBack to support Braille displays that are using the HID standard over both USB and secure Bluetooth.

This standard, much like the one used by mice and keyboards, will help Android support a wider range of Braille displays over time.

Internationalisation

Android 15 ajoute des fonctionnalités qui complètent l'expérience utilisateur lorsqu'un appareil est utilisé dans différentes langues.

Police variable CJK

Starting with Android 15, the font file for Chinese, Japanese, and Korean (CJK) languages, NotoSansCJK, is now a variable font. Variable fonts open up possibilities for creative typography in CJK languages. Designers can explore a broader range of styles and create visually striking layouts that were previously difficult or impossible to achieve.

Justification entre les caractères

Starting with Android 15, text can be justified utilizing letter spacing by using JUSTIFICATION_MODE_INTER_CHARACTER. Inter-word justification was first introduced in Android 8.0 (API level 26), and inter-character justification provides similar capabilities for languages that use the whitespace character for segmentation, such as Chinese, Japanese, and others.

Layout for Japanese text using JUSTIFICATION_MODE_NONE.

Layout for English text using JUSTIFICATION_MODE_NONE.

Layout for Japanese text using JUSTIFICATION_MODE_INTER_WORD.

Layout for English text using JUSTIFICATION_MODE_INTER_WORD.

Layout for Japanese text using the JUSTIFICATION_MODE_INTER_CHARACTER.

Layout for English text using the JUSTIFICATION_MODE_INTER_CHARACTER.

Configuration automatique des coupures de ligne

Android started supporting phrase-based line breaks for Japanese and Korean in Android 13 (API level 33). However, while phrase-based line breaks improve the readability of short lines of text, they don't work well for long lines of text. In Android 15, apps can apply phrase-based line breaks only for short lines of text, using the LINE_BREAK_WORD_STYLE_AUTO option. This option selects the best word style option for the text.

For short lines of text, phrase-based line breaks are used, functioning the same as LINE_BREAK_WORD_STYLE_PHRASE, as shown in the following image:

For longer lines of text, LINE_BREAK_WORD_STYLE_AUTO uses a no line-break word style, functioning the same as LINE_BREAK_WORD_STYLE_NONE, as shown in the following image:

Police Hentaigana japonaise supplémentaire

Dans Android 15, un fichier de police pour l'ancien hiragana japonais (appelé Hentaigana) est regroupé par défaut. Les formes uniques des personnages Hentaigana permettent d'ajouter à l'œuvre ou au design, tout en préservant la précision transmission et compréhension des anciens documents japonais.

Cône VideoLAN Copyright (c) 1996-2010 VideoLAN. Ce logo ou une version modifiée peut être utilisé ou modifié par n'importe qui pour faire référence au projet VideoLAN ou à tout produit développé par l'équipe VideoLAN, mais n'indique pas l'approbation du projet.

Vulkan et le logo Vulkan sont des marques déposées de The Khronos Group Inc.

OpenGL est une marque déposée, et le logo OpenGL ES est une marque de Hewlett Packard Enterprise utilisée avec autorisation par Khronos.