Présentation des fonctionnalités et des API

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

Appareil photo et contenu multimédia

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

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

Amplification luminosité faible

Android 15 introduces Low Light Boost, a new 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 new 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 caméra dans l'application

Android 15 ajoute une nouvelle extension pour mieux contrôler le matériel de l'appareil photo et ses algorithmes sur les appareils compatibles:

• Ajustements avancés de l'intensité du flash permettant de contrôler précisément l'intensité du flash dans les modes SINGLE et TORCH lors de la capture d'images.

Contrôle de la marge HDR

Android 15 chooses HDR headroom that is appropriate for the underlying device capabilities and bit-depth of the panel. For pages that have lots of SDR content, such as a messaging app displaying a single HDR thumbnail, this behavior can end up adversely influencing the perceived brightness of the SDR content. Android 15 lets you control the HDR headroom with setDesiredHdrHeadroom to strike a balance between SDR and HDR content.

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 virtuels MIDI 2.0

Android 13 prend en charge la connexion aux appareils MIDI 2.0 via USB, qui communiquent à l'aide de paquets UMP (Universal MIDI Packets). Android 15 étend la compatibilité 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 décodeur logiciel AV1 populaire de VideoLAN est désormais disponible pour les appareils Android qui ne sont pas compatibles avec le décodage AV1 sur le matériel. Il est jusqu'à trois fois plus performant que l'ancien décodeur logiciel AV1, ce qui permet à davantage d'utilisateurs de lire des contenus HD AV1, y compris sur certains appareils de niveau inférieur ou supérieur.

Pour l'instant, votre application doit accepter d'utiliser dav1d en l'appelant avec le nom "c2.android.av1-dav1d.decoder". dav1d deviendra le décodeur logiciel AV1 par défaut lors d'une mise à jour ultérieure. Cette prise en charge est standardisée et rétroportée sur les appareils Android 11 qui reçoivent les mises à jour du système Google Play.

Productivité et outils des développeurs

Bien que la majeure partie de notre travail consiste à améliorer vos centres de productivité autour d'outils tels qu'Android Studio, Jetpack Compose et les bibliothèques Android Jetpack, nous cherchons toujours des moyens sur la plate-forme de vous aider à concrétiser 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 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.

Affinements automatiques pour le changement de langue

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 improves the usability of the OpenType variable font. You can now create a FontFamily instance from a variable font without specifying weight axes with the buildVariableFamily API. The text renderer overrides the value of wght axis to match the displaying text.

Using the new API, this simplifies the code for creating a Typeface considerably:

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();

Previously, to create the same Typeface, you would need much more 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();

Here's an example of how a Typeface created with both the old and new APIs renders:

In this example, the Typeface created with the old API doesn't have the capability to create accurate font weights for the 350, 450, 550 and 650 Font instances, so the renderer falls back to the closest weight. So in this case, 300 is rendered instead of 350, 400 is rendered instead of 450, and so on. By contrast, the Typeface created with the new APIs dynamically creates a Font instance for a given weight, so accurate weights are rendered for 350, 450, 550, and 650 as well.

Contrôles précis des sauts de ligne

Starting in Android 15, a TextView and the underlying line breaker can preserve the given portion of text in the same line to improve readability. You can take advantage of this line break customization by using the <nobreak> tag in string resources or createNoBreakSpan. Similarly, you can preserve words from hyphenation by using the <nohyphen> tag or createNoHyphenationSpan.

For example, the following string resource doesn't include a line break, and renders with the text "Pixel 8 Pro." breaking in an undesirable place:

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

In contrast, this string resource includes the <nobreak> tag, which wraps the phrase "Pixel 8 Pro." and prevents line breaks:

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

The difference in how these strings are rendered is shown in the following images:

Layout for a line of text where the phrase "Pixel 8 Pro." isn't wrapped using a <nobreak> tag.

Layout for the same line of text where the phrase "Pixel 8 Pro." is wrapped using a <nobreak> tag.

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 now 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.

Graphismes

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

Moderniser l'accès aux 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 de nouvelles fonctionnalités:

• Matrix44 fournit une matrice 4x4 pour transformer les coordonnées à utiliser lorsque vous souhaitez manipuler le canevas en 3D.
• clipShader croise l'extrait actuel avec le nuanceur spécifié, tandis que clipOutShader définit l'extrait sur la différence entre l'extrait actuel et le nuanceur, traitant chacun 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 de nouvelles API qui permettent de rendre les tâches de votre application plus efficaces à exécuter, d'optimiser les performances de l'application et de recueillir des insights sur vos applications.

Pour connaître les bonnes pratiques d'économie de batterie, déboguer le débogage de la consommation du réseau et de l'énergie, et découvrir comment nous améliorons l'efficacité de la batterie pour les tâches en arrière-plan sur Android 15 et les versions récentes d'Android, consultez la vidéo Améliorer l'efficacité de la batterie des tâches en arrière-plan sur Android de Google I/O.

API ApplicationStartInfo

Dans les versions précédentes d'Android, le démarrage des applications était un peu mystérieux. Il était difficile de déterminer dans votre application si elle commençait à partir d'un état froid, chaud ou chaud. Il était également difficile de savoir combien de temps votre application passait au cours des différentes phases de lancement: duplication du processus, appel de onCreate, dessin du premier frame, etc. Lorsque votre classe Application était instanciée, vous n'aviez aucun moyen de savoir si l'application avait démarré à partir d'une diffusion, d'un fournisseur de contenu, d'une tâche, d'une sauvegarde, d'un démarrage terminé, d'une alarme ou d'une Activity.

L'API ApplicationStartInfo sur Android 15 fournit tout cela et plus encore. Vous pouvez même choisir d'ajouter vos propres horodatages dans le flux pour faciliter la collecte des données temporelles à un seul endroit. En plus de collecter des métriques, vous pouvez utiliser ApplicationStartInfo pour optimiser directement le démarrage de l'application. Par exemple, vous pouvez éliminer l'instanciation coûteuse des bibliothèques liées à l'interface utilisateur dans votre classe Application lorsque votre application démarre en raison d'une diffusion.

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

Since Android 8.0 (API level 26), Android has included the StorageStats.getAppBytes API that summarizes the installed size of an app as a single number of bytes, which is a sum of the APK size, the size of files extracted from the APK, and files that were generated on the device such as ahead-of-time (AOT) compiled code. This number is not very insightful in terms of how your app is using storage.

Android 15 adds the StorageStats.getAppBytesByDataType([type]) API, which lets you get insight into how your app is using up all that space, including APK file splits, AOT and speedup related code, dex metadata, libraries, and guided profiles.

Profilage géré par l'application

Android 15 inclut la toute nouvelle classe ProfilingManager, qui vous permet de collecter des informations de profilage à partir de votre application. Nous prévoyons de l'intégrer à une API Android Jetpack qui simplifiera la construction des requêtes de profilage. Toutefois, l'API principale permettra la collecte d'empreintes de mémoire, de profils de tas de mémoire, d'échantillonnage de pile, etc. Elle fournit un rappel à votre application avec une balise fournie pour identifier le fichier de sortie, qui est envoyé dans le répertoire de fichiers de votre application. L'API limite le débit pour minimiser l'impact sur les performances.

Améliorations de la base de données SQLite

Android 15 introduces new SQLite APIs that expose advanced features from the underlying SQLite engine that target specific performance issues that can manifest in apps.

Developers should consult best practices for SQLite performance to get the most out of their SQLite database, especially when working with large databases or when running latency-sensitive queries.

• Read-only deferred transactions: when issuing transactions that are read-only (don't include write statements), use beginTransactionReadOnly() and beginTransactionWithListenerReadOnly(SQLiteTransactionListener) to issue read-only DEFERRED transactions. Such transactions can run concurrently with each other, and if the database is in WAL mode, they can run concurrently with IMMEDIATE or EXCLUSIVE transactions.
• Row counts and IDs: new APIs were added to retrieve the count of changed rows or the last inserted row ID without issuing an additional query. getLastChangedRowCount() returns the number of rows that were inserted, updated, or deleted by the most recent SQL statement within the current transaction, while getTotalChangedRowCount() returns the count on the current connection. getLastInsertRowId() returns the rowid of the last row to be inserted on the current connection.
• Raw statements: issue a raw SQlite statement, bypassing convenience wrappers and any additional processing overhead that they may incur.

Mises à jour du framework de performances dynamiques Android

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

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

Pour en savoir plus sur l'utilisation d'ADPF dans vos applications et vos 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 de l'enregistrement d'écran

Android 15 ajoute la prise en charge des applications pour détecter qu'elles sont enregistrées. Un rappel est appelé chaque fois que l'application passe de l'état visible à l'invisible dans un enregistrement d'écran. Une application est considérée comme visible si les activités appartenant à l'UID du processus d'enregistrement sont enregistrées. Ainsi, si votre application effectue une opération sensible, vous pouvez informer l'utilisateur que ces opérations sont enregistrées.

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 étendues d'IntentFilter

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 new <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 new android:query and android:fragment attributes.

Here's an example of the AndroidManifest syntax:

<intent-filter>
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.BROWSABLE" />
  <data android:scheme="http" />
  <data android:scheme="https" />
  <data android:domain="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. When a user locks the private space, the profile is paused and any apps in the private space are no longer active. 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.

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.
• Launcher apps
• App store apps

Interroger la sélection la plus récente des utilisateurs pour l'accès aux photos sélectionnées

It is now possible for apps to 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 inclut les dernières extensions Android Ad Services, qui incorporent la dernière version de Privacy Sandbox sur Android. Cet ajout s'inscrit dans le cadre de notre travail de développement de nouvelles technologies visant à améliorer la confidentialité des utilisateurs et à proposer des expériences publicitaires efficaces et personnalisées pour les applications mobiles. Pour vous aider à faire vos premiers pas, consultez la page Privacy Sandbox pour en savoir plus sur la version Preview développeur et les programmes bêta de la Privacy Sandbox sur Android.

Santé Connect

Android 15 intègre les dernières extensions de Santé Connect par Android, une plate-forme sécurisée et centralisée permettant de gérer et de partager les données de santé et de remise en forme collectées par l'application. Cette mise à jour prend en charge de nouveaux types de données concernant la forme de remise en forme, la nutrition, la température cutanée, les programmes d'entraînement, etc.

Le suivi de la température cutanée permet aux utilisateurs de stocker et de partager des données de température plus précises provenant d'un accessoire connecté ou d'un autre appareil de suivi.

Les plans d'entraînement sont des programmes d'entraînement structurés qui aident un utilisateur à atteindre ses objectifs de remise en forme. Ils prennent en charge divers objectifs de réussite et de performance:

• Objectifs réalisés en termes de calories brûlées, de distance, de durée, de répétition et de pas.
• Les objectifs de performances axés sur le nombre de répétitions possible (AMRAP), la cadence, la fréquence cardiaque, la puissance, le taux d'effort perçu et la vitesse.

Pour en savoir plus sur les dernières mises à jour de Santé Connect sur Android, consultez la vidéo Building adaptable with Android Health (Créer des expériences adaptables avec la santé Android) de la conférence Google I/O.

Partage d'écran partiel

Android 15 prend en charge le partage d'écran partiel afin que les utilisateurs puissent partager ou enregistrer simplement une fenêtre d'application plutôt que l'intégralité de l'écran de l'appareil. Cette fonctionnalité, activée pour la première fois dans Android 14 QPR2, inclut des rappels MediaProjection qui permettent à votre application de personnaliser l'expérience de partage d'écran partiel. Notez que pour les applications ciblant Android 14 (niveau d'API 34) ou version ultérieure, le consentement de l'utilisateur est désormais requis pour chaque session de capture MediaProjection.

Expérience utilisateur et UI du système

Android 15 offre aux développeurs et aux utilisateurs d'applications 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 afin d'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 plus complets des widgets avec l'API Generated Previews

Avant Android 15, le seul moyen de fournir des aperçus de 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 faire une capture d'écran de son widget ou créer une mise en page XML pour avoir un aperçu du widget.

Android 15 est compatible avec les aperçus générés. Cela signifie que les fournisseurs de widgets d'applications peuvent générer des 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 comme 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 sur le fournisseur.
2. setWidgetPreview informe les hôtes d'un aperçu mis à jour via le rappel AppWidgetHost.onProvidersChanged. En réponse, l'hôte de widget actualise toutes ses informations de fournisseur.
3. Lors de l'affichage d'un aperçu de widget, l'hôte vérifie AppWidgetProviderInfo.generatedPreviewCategories, et si la catégorie choisie est disponible, appelle AppWidgetManager.getWidgetPreview pour renvoyer l'aperçu enregistré pour ce fournisseur.

Quand appeler setWidgetPreview

Comme aucun rappel ne permet de fournir des aperçus, les applications peuvent choisir d'en envoyer à tout moment lorsqu'elles sont en cours d'exécution. La fréquence de mise à jour 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 des aperçus:

• Fournisseurs qui affichent des données réelles dans leurs aperçus de widget, telles que 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 leur application. Ils peuvent ensuite configurer une tâche périodique pour mettre à jour les aperçus au rythme de leur choix. Il peut s'agir, par exemple, d'un widget de photo, d'agenda, de météo ou d'actualités.
• Fournisseurs affichant 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. Il peut s'agir, par exemple, du widget d'actions rapides de Drive ou de raccourcis Chrome.

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

Picture-in-picture

Android 15 apporte de nouvelles modifications au mode Picture-in-picture (PIP) afin d'assurer une transition encore plus fluide lorsque vous passez en mode PIP. Cela sera utile pour les applications dont les éléments d'interface utilisateur se superposent à l'interface utilisateur principale, qui est intégrée au PIP.

Les développeurs utilisent le rappel onPictureInPictureModeChanged pour définir une logique qui active/désactive la visibilité des éléments d'interface utilisateur superposés. Ce rappel est déclenché à la fin de l'animation d'entrée ou de sortie du PIP. À partir d'Android 15, la classe PictureInPictureUiState inclut un nouvel état.

Avec ce nouvel état de l'interface utilisateur, les applications ciblant Android 15 observent que le rappel Activity#onPictureInPictureUiStateChanged est appelé avec isTransitioningToPip() dès le démarrage de l'animation PIP. De nombreux éléments d'interface utilisateur ne sont pas pertinents pour l'application en mode PIP, par exemple les vues ou la mise en page qui incluent des informations telles que des suggestions, des vidéos à venir, des notes et des titres. Lorsque l'application passe en mode PIP, utilisez le rappel onPictureInPictureUiStateChanged pour masquer ces éléments d'interface utilisateur. Lorsque l'application passe en mode plein écran à partir de la fenêtre PIP, utilisez le rappel onPictureInPictureModeChanged pour afficher ces éléments, comme illustré dans les exemples suivants:

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

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

Cette option de visibilité rapide des éléments d'interface utilisateur non pertinents (pour une fenêtre PIP) permet d'assurer une animation d'entrée en mode PIP plus fluide et sans scintillement.

Amélioration des règles Ne pas déranger

AutomaticZenRule permet aux applications de personnaliser les règles de gestion de l'attention (Ne pas déranger) et de décider quand les activer ou les désactiver. Android 15 améliore considérablement ces règles afin d'améliorer l'expérience utilisateur. Les améliorations suivantes sont incluses:

• Ajout de types à AutomaticZenRule, ce qui permet au système d'appliquer un traitement spécial à certaines règles.
• Ajout d'une icône à AutomaticZenRule, ce qui permet de rendre les modes plus reconnaissables.
• Ajout d'une chaîne triggerDescription à AutomaticZenRule qui décrit les conditions dans lesquelles la règle doit devenir active pour l'utilisateur.
• Ajout de ZenDeviceEffects à AutomaticZenRule, ce qui permet aux règles de déclencher des éléments tels que l'affichage en nuances de gris, le mode Nuit ou la diminution de la luminosité du fond d'écran.

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.

Grands écrans et facteurs de forme

Android 15 permet à vos applications d'exploiter tout le potentiel des facteurs de forme d'Android, y compris les grands écrans, les appareils pliables et les pliables.

Amélioration du mode multitâche sur grand écran

Android 15 gives users better ways to multitask on large screen devices. For example, users can save their favorite split-screen app combinations for quick access and pin the taskbar on screen to quickly switch between apps. This means that making sure your app is adaptive is more important than ever.

Google I/O has sessions on Building adaptive Android apps and Building UI with the Material 3 adaptive library that can help, and our documentation has more to help you Design for large screens.

Compatibilité avec l'écran de protection

Votre application peut déclarer une propriété qu'Android 15 utilise pour permettre l'affichage de votre Application ou Activity sur les petits écrans de couverture des appareils pliables compatibles. Ces écrans sont trop petits pour être considérés comme des cibles compatibles avec les applications Android, mais votre application peut les accepter, ce qui la rend disponible à davantage d'endroits.

Connectivité

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

Compatibilité satellite

Android 15 continues to extend platform support for satellite connectivity and includes some UI elements to ensure a consistent user experience across the satellite connectivity landscape.

Apps can use ServiceState.isUsingNonTerrestrialNetwork() to detect when a device is connected to a satellite, giving them more awareness of why full network services might be unavailable. Additionally, Android 15 provides support for SMS and MMS apps as well as preloaded RCS apps to use satellite connectivity for sending and receiving messages.

Expériences NFC plus fluides

Android 15 is working to make the tap to pay experience more seamless and reliable while continuing to support Android's robust NFC app ecosystem. On supported devices, apps can request the NfcAdapter to enter observe mode, where the device listens but doesn't respond to NFC readers, sending the app's NFC service PollingFrame objects to process. The PollingFrame objects can be used to auth ahead of the first communication to the NFC reader, allowing for a one tap transaction in many cases.

In addition, apps can now register a fingerprint on supported devices so they can be notified of polling loop activity, which allows for smooth operation with multiple NFC-aware applications.

Rôle Wallet

Android 15 introduces a new Wallet role that allows tighter integration with the user's preferred wallet app. This role replaces the NFC default contactless payment setting. Users can manage the Wallet role holder by navigating to Settings > Apps > Default Apps.

The Wallet role is used when routing NFC taps for AIDs registered in the payment category. Taps always go to the Wallet role holder unless another app that is registered for the same AID is running in the foreground.

This role is also used to determine where the Wallet QuickAccess tile should go when activated. When the role is set to "None", the QuickAccess tile isn't available and payment category NFC taps are only delivered to the foreground app.

Sécurité

Android 15 vous aide à améliorer la sécurité de votre application, à protéger les données de votre application, et à offrir aux utilisateurs plus de transparence et de contrôle sur leurs données. Consultez la vidéo Protéger la sécurité des utilisateurs sur Android de Google I/O pour en savoir plus sur les mesures que nous prenons pour améliorer la protection des utilisateurs et protéger votre application contre les nouvelles menaces.

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 du système d'exploitation 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 d'offrir aux utilisateurs un moyen centralisé de gérer et de valider les clés publiques de leurs contacts.

Contrôles d'autorisations sur les URI de contenu

Android 15 introduces a new set of APIs that perform permission checks on content URIs:

• Context.checkContentUriPermissionFull: This performs a full permission check on content URIs.
• Activity manifest attribute requireContentUriPermissionFromCaller: This enforces specified permissions on the provided content URIs at activity launch.
• ComponentCaller class for Activity callers: This represents the app that launched the activity.

Accessibilité

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

Braille amélioré

Avec Android 15, TalkBack est compatible avec les plages braille qui utilisent la norme HID via USB et le Bluetooth sécurisé.

Cette norme, tout comme celle utilisée par les souris et les claviers, aidera Android à prendre en charge une plus large gamme de plages braille au fil du temps.

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

À partir d'Android 15, le fichier de police NotoSansCJK pour le chinois, le coréen et le japonais (CJK) est désormais une police variable. Les polices variables offrent de nouvelles possibilités pour la typographie créative dans les langages CJK. Les concepteurs peuvent explorer un plus large éventail de styles et créer des mises en page visuellement remarquables qui étaient auparavant difficiles, voire impossibles à réaliser.

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 new JUSTIFICATION_MODE_INTER_CHARACTER.

Layout for English text using the new JUSTIFICATION_MODE_INTER_CHARACTER.

Configuration automatique des sauts de ligne

Android a commencé à accepter les sauts de ligne basés sur des expressions pour le coréen et le japonais avec Android 13 (niveau d'API 33). Toutefois, si les sauts de ligne basés sur des expressions améliorent la lisibilité des lignes de texte courtes, ils ne sont pas adaptés aux longues lignes de texte. Sous Android 15, les applications ne peuvent désormais appliquer des sauts de ligne basés sur des expressions que pour les petites lignes de texte, à l'aide de l'option LINE_BREAK_WORD_STYLE_AUTO. Cette option sélectionne le meilleur style de mot pour le texte.

Pour les lignes de texte courtes, des sauts de ligne basés sur des expressions sont utilisés, fonctionnant de la même manière que LINE_BREAK_WORD_STYLE_PHRASE, comme illustré dans l'image suivante:

Pour les lignes de texte plus longues, LINE_BREAK_WORD_STYLE_AUTO utilise un style de mot sans saut de ligne, fonctionnant de la même manière que LINE_BREAK_WORD_STYLE_NONE, comme illustré dans l'image suivante:

Nouvelle police Hentaigana japonaise

Dans Android 15, un nouveau fichier de police de l'ancien hiragana japonais (connu sous le nom de Hentaigana) est regroupé par défaut. Les formes uniques des personnages Hentaigana apportent une touche distinctive aux œuvres d'art ou aux dessins, tout en contribuant à préserver la précision de la transmission et de la compréhension des documents japonais anciens.

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

Vulkan et le logo Vulkan sont des marques déposées de 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 l'autorisation de Khronos.