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.
Pour obtenir une liste détaillée des nouvelles API, des API modifiées et supprimées, consultez le rapport de différences des API. Pour en savoir plus sur les nouvelles API, consultez la documentation de référence des API Android. Les nouvelles API sont mises en évidence pour plus de visibilité. En outre, pour en savoir plus sur les domaines dans lesquels les modifications de la plate-forme peuvent affecter vos applications, consultez les modifications de comportement qui affectent les applications qui affectent les applications lorsqu'elles ciblent Android 15 et les modifications de comportement qui affectent toutes les applications, quel que soit letargetSdkVersion
.
Appareil photo et contenus multimé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 appareils photo et les contenus multimédias Android, regardez la vidéo Concevoir des expériences photo et multimédias Android modernes de la conférence Google I/O.
Amplification par faible luminosité
Android 15 introduit Low Light Boost, un nouveau mode d'exposition automatique disponible à la fois pour Camera 2 et l'extension de caméra en mode Nuit. L'amplification luminosité faible ajuste l'exposition du flux de prévisualisation lorsque la luminosité est faible. Ce mode est différent de celui utilisé par l'extension d'appareil photo du mode Nuit pour créer des images fixes, car le mode Nuit combine une rafale de photos pour créer une seule image améliorée. Bien que le mode Nuit fonctionne très bien pour créer une image fixe, il ne peut pas créer de flux continu d'images, contrairement à l'amplification luminosité faible. L'amplification luminosité faible permet donc d'utiliser de nouvelles fonctionnalités de l'appareil photo, par exemple:
- fournir un aperçu amélioré de l'image afin que les utilisateurs puissent mieux cadrer leurs photos lorsque la luminosité est faible ;
- Scanner des codes QR par faible luminosité
Si vous activez cette fonctionnalité, elle s'active automatiquement lorsque la luminosité est faible et s'éteint lorsque la luminosité est plus forte.
Les applications peuvent enregistrer en dehors du flux d'aperçu dans des conditions de faible luminosité afin de conserver une vidéo lumineuse.
Pour en savoir plus, consultez Amplification luminosité faible.
Commandes de caméra intégrées à l'application
Android 15 adds a new 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
andTORCH
modes while capturing 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 MIDI 2.0 virtuels
Android 13 added support for connecting to MIDI 2.0 devices using USB, which communicate using Universal MIDI Packets (UMP). Android 15 extends UMP support to virtual MIDI apps, enabling composition apps to control synthesizer apps as a virtual MIDI 2.0 device just like they would with an USB MIDI 2.0 device.
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 l'essentiel de nos efforts pour améliorer votre productivité soit axé sur des outils tels qu'Android Studio, Jetpack Compose et les bibliothèques Android Jetpack, nous cherchons toujours des moyens de réaliser plus facilement votre vision sur la plate-forme.
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
andstrictmath
methods util
package updates including sequencedcollection
,map
, andset
ByteBuffer
support inDeflater
- 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 includes substantial improvements to the PdfRenderer
APIs. Apps can incorporate advanced features such as rendering
password-protected files, annotations, form editing,
searching, and selection with copy. Linearized PDF
optimizations are supported to speed local PDF viewing and reduce resource use.
The PdfRenderer
has been moved to a module that can be updated using Google
Play system updates independent of the platform release, and we're supporting
these changes back to Android 11 (API level 30) by creating a compatible
pre-Android 15 version of the API surface, called
PdfRendererPreV
.
We value your feedback on the enhancements we've made to the PdfRenderer
API
surface, and we plan to make it even easier to incorporate these APIs into your
app with an upcoming Android Jetpack library.
Améliorations apportées au changement automatique de langue
Android 14 a ajouté la reconnaissance multilingue sur l'appareil pour l'audio avec le basculement automatique entre les langues, mais cela peut entraîner une suppression de mots, en particulier lorsque les langues changent avec moins de pause entre les deux énoncés. Android 15 ajoute des commandes supplémentaires pour aider les applications à adapter cette transition à leur cas d'utilisation.
EXTRA_LANGUAGE_SWITCH_INITIAL_ACTIVE_DURATION_TIME_MILLIS
place automatiquement le basculement automatique au début de la session audio, tandis que EXTRA_LANGUAGE_SWITCH_MATCH_SWITCHES
désactive le changement de langue après un nombre défini de commutateurs. Ces options sont particulièrement utiles si vous pensez qu'une seule langue parlée au cours de la session doit être détectée automatiquement.
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 d'axes de pondération avec l'API buildVariableFamily
. Le moteur de rendu de texte remplace la valeur de l'axe wght
pour correspondre au texte affiché.
La nouvelle API simplifie considérablement le code pour créer un Typeface
:
Kotlin
val newTypeface = Typeface.CustomFallbackBuilder( FontFamily.Builder( Font.Builder(assets, "RobotoFlex.ttf").build()) .buildVariableFamily()) .build()
Java
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:
Kotlin
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()
Java
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
créé avec l'ancienne et la nouvelle API s'affiche:
Dans cet exemple, le Typeface
créé avec l'ancienne API ne permet pas de créer des épaisseurs de police précises pour les instances Font
350, 450, 550 et 650. Le moteur de rendu utilise donc l'épaisseur la plus proche. Dans ce cas, 300 est affiché au lieu de 350, 400 est affiché 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, de sorte que des pondérations précises sont également affichées pour 350, 450, 550 et 650.
Commandes de saut de ligne précises
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:
Archivage des applications
L'année dernière, Android et Google Play ont annoncé la compatibilité avec l'archivage des applications, qui permet aux utilisateurs de libérer de l'espace en supprimant partiellement de l'appareil les applications peu utilisées et publiées à l'aide d'Android App Bundle sur Google Play. Android 15 prend désormais en charge l'archivage et le désarchivage d'applications au niveau de l'OS, ce qui permet à toutes les plates-formes de téléchargement d'applications de les implémenter plus facilement.
Les applications disposant de l'autorisation REQUEST_DELETE_PACKAGES
peuvent appeler la méthode PackageInstaller
requestArchive
pour demander l'archivage d'un package d'application installé, ce qui supprime l'APK et tous les fichiers mis en cache, mais conserve les données utilisateur. Les applications archivées sont renvoyées en tant qu'applications affichables via les API LauncherApps
. Les utilisateurs verront un traitement dans l'interface utilisateur indiquant que ces applications sont archivées. Si un utilisateur appuie sur une application archivée, le programme d'installation responsable reçoit une demande de désarchivage de celle-ci, et le processus de restauration peut être surveillé par la diffusion ACTION_PACKAGE_ADDED
.
Graphismes
Android 15 apporte 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 continues our modernization of Android's Canvas graphics system with new capabilities:
Matrix44
provides a 4x4 matrix for transforming coordinates that should be used when you want to manipulate the canvas in 3D.clipShader
intersects the current clip with the specified shader, whileclipOutShader
sets the clip to the difference of the current clip and the shader, each treating the shader as an alpha mask. This supports the drawing of complex shapes efficiently.
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 d'exécuter les tâches de votre application plus efficacement, d'optimiser ses performances et de recueillir des insights sur vos applications.
Pour découvrir les bonnes pratiques d'optimisation de la batterie, le débogage du réseau et la consommation d'énergie, ainsi que la façon dont nous améliorons l'efficacité de la batterie des tâches en arrière-plan dans Android 15 et les versions récentes d'Android, consultez l'article Améliorer l'efficacité de la batterie des tâches en arrière-plan sur Android dans la conférence 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
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 includes the all-new ProfilingManager
class, which lets you
collect profiling information from within your app. We're planning to wrap this
with an Android Jetpack API that will simplify construction of profiling
requests, but the core API will allow the collection of 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.
Améliorations de la base de données SQLite
Android 15 introduit de nouvelles API SQLite qui exposent des fonctionnalités avancées du moteur SQLite sous-jacent, qui ciblent des problèmes de performances spécifiques pouvant se manifester dans les applications.
Les développeurs sont invités à consulter les bonnes pratiques concernant les performances de SQLite pour tirer le meilleur parti de leur base de données SQLite, en particulier lorsqu'ils travaillent avec des bases de données volumineuses ou lorsqu'ils exécutent des requêtes sensibles à la latence.
- Transactions différées en lecture seule: lorsque vous émettez des transactions en lecture seule (sans instructions d'écriture), utilisez
beginTransactionReadOnly()
etbeginTransactionWithListenerReadOnly(SQLiteTransactionListener)
pour émettre des transactionsDEFERRED
en lecture seule. Ces transactions peuvent s'exécuter simultanément. Si la base de données est en mode WAL, elles peuvent s'exécuter simultanément avec les transactionsIMMEDIATE
ouEXCLUSIVE
. - Nombre de lignes et ID: de nouvelles API ont été ajoutées pour récupérer le nombre de lignes modifiées ou le dernier ID de ligne inséré sans émettre de requête supplémentaire.
getLastChangedRowCount()
renvoie le nombre de lignes insérées, mises à jour ou supprimées par l'instruction SQL la plus récente dans la transaction en cours, tandis quegetTotalChangedRowCount()
renvoie le nombre de lignes sur la connexion actuelle.getLastInsertRowId()
renvoie lerowid
de la dernière ligne à insérer dans la connexion actuelle. - Instructions brutes: émettez une instruction SQlite brute, en contournant les wrappers de commodité et toute surcharge de traitement supplémentaire qu'ils pourraient entraîner.
Mises à jour du framework de performances dynamiques Android
Android 15 continues our investment in the Android Dynamic Performance Framework (ADPF), a set of APIs that allow games and performance intensive apps to interact more directly with power and thermal systems of Android devices. On supported devices, Android 15 will add new ADPF capabilities:
- A power-efficiency mode for hint sessions to indicate that their associated threads should prefer power saving over performance, great for long-running background workloads.
- GPU and CPU work durations can both be reported in hint sessions, allowing the system to adjust CPU and GPU frequencies together to best meet workload demands.
- Thermal headroom thresholds to interpret possible thermal throttling status based on headroom prediction.
To learn more about how to use ADPF in your apps and games, head over to the 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 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 prend en charge une résolution Intent
plus précise via UriRelativeFilterGroup
, qui contient un ensemble d'objets UriRelativeFilter
qui forment un ensemble de règles de correspondance Intent
qui doivent être respectées, y compris les paramètres de requête d'URL, les fragments d'URL et les règles de blocage ou d'exclusion.
Ces règles peuvent être définies dans le fichier XML AndroidManifest
avec la nouvelle balise <uri-relative-filter-group>
, qui peut éventuellement inclure une balise android:allow
. Ces balises peuvent contenir des balises <data>
qui utilisent des attributs de balises de données existants, ainsi que les nouveaux attributs android:query
et android:fragment
.
Voici un exemple de la syntaxe AndroidManifest
:
<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é
L'espace privé permet aux utilisateurs de créer un espace distinct sur leur appareil dans lequel ils peuvent protéger les applications sensibles des regards indiscrets, grâce à une couche d'authentification supplémentaire. L'espace privé utilise un profil utilisateur distinct. L'utilisateur peut choisir d'utiliser le verrouillage de l'appareil ou un facteur de verrouillage distinct pour l'espace privé.
Les applications présentes dans l'espace privé s'affichent dans un conteneur distinct du lanceur d'applications. Elles sont masquées dans la vue des éléments récents, dans les notifications, dans les paramètres et dans les autres applications lorsque l'espace privé est verrouillé. Les contenus générés et téléchargés par l'utilisateur (tels que des contenus multimédias ou des fichiers) et les comptes sont séparés entre l'espace privé et l'espace principal. La feuille de partage du système et le sélecteur de photos permettent d'autoriser les applications à accéder au contenu de plusieurs espaces lorsque l'espace privé est déverrouillé.
Les utilisateurs ne peuvent pas déplacer les applications existantes ni leurs données dans l'espace privé. À la place, les utilisateurs sélectionnent une option d'installation dans l'espace privé pour installer une application à l'aide de la plate-forme de téléchargement d'applications de leur choix. Les applications de l'espace privé sont installées en tant que copies distinctes de toutes les applications de l'espace principal (nouvelles copies de la même application).
Lorsqu'un utilisateur verrouille l'espace privé, le profil est arrêté. Lorsque le profil est arrêté, les applications de l'espace privé ne sont plus actives et ne peuvent pas effectuer d'activités au premier plan ou en arrière-plan, y compris l'affichage de notifications.
Nous vous recommandons de tester votre application avec un espace privé pour vous assurer qu'elle fonctionne comme prévu, en particulier si elle appartient à l'une des catégories suivantes:
- Applications avec une logique pour les profils professionnels, qui suppose que toutes les copies installées de leur application qui ne figurent pas dans le profil principal se trouvent dans le profil professionnel.
- Applications de lancement
- Applications de plates-formes de téléchargement d'applications
Interroger la dernière sélection effectuée par l'utilisateur pour accéder aux photos sélectionnées
Les applications peuvent désormais mettre en surbrillance uniquement les photos et vidéos sélectionnées les plus récemment lorsqu'un accès partiel aux autorisations multimédias est accordé. Cette fonctionnalité peut améliorer l'expérience utilisateur pour les applications qui demandent fréquemment l'accès aux photos et aux vidéos. Pour utiliser cette fonctionnalité dans votre application, activez l'argument QUERY_ARG_LATEST_SELECTION_ONLY
lorsque vous interrogez MediaStore
via ContentResolver
.
Kotlin
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() ) )
Java
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 supports partial 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 partial screen sharing experience. Note that for apps targeting
Android 14 (API level 34) or higher,
user consent is now required for each
MediaProjection
capture session.
Expérience utilisateur et UI 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 savoir 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 la conférence Google I/O.
Aperçus de widgets plus complets 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:
- Le fournisseur de widgets appelle
setWidgetPreview
à tout moment. Les aperçus fournis sont conservés dansAppWidgetService
avec d'autres informations sur le fournisseur. setWidgetPreview
informe les hôtes d'un aperçu mis à jour via le rappelAppWidgetHost.onProvidersChanged
. En réponse, l'hôte de widget actualise toutes ses informations de fournisseur.- 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, appelleAppWidgetManager.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
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 toAutomaticZenRule
that describes the conditions on which the rule should become active for the user. - Added
ZenDeviceEffects
toAutomaticZenRule
, allowing rules to trigger things like grayscale display, night mode, or dimming the wallpaper.
Définir VibrationEffect pour les canaux de notification
Android 15 supports setting rich vibrations for incoming notifications by
channel using NotificationChannel.setVibrationEffect
, so
your users can distinguish between different types of notifications without
having to look at their device.
Grands écrans et facteurs de forme
Android 15 permet à vos applications d'exploiter tout le potentiel des facteurs de forme Android, y compris les grands écrans, les appareils pliables et les appareils 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.
Prise en charge de l'écran de couverture
Your app can declare a property that Android 15 uses to
allow your Application
or Activity
to be presented on the small cover
screens of supported flippable devices. These screens are too small to be
considered as compatible targets for Android apps to run on, but your app can
opt in to supporting them, making your app available in more places.
Connectivité
Android 15 met à jour la plate-forme pour permettre à votre application d'accéder aux dernières avancées en matière de communication et de technologies 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érience NFC plus fluide
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 filter 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 à renforcer 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 protection des utilisateurs et protéger votre application contre les nouvelles menaces, consultez l'entretien Protéger la sécurité des utilisateurs sur Android de Google I/O.
Intégrer le Gestionnaire d'identifiants à la saisie automatique
Starting with Android 15, developers can link specific views like username or password fields with Credential Manager requests, making it easier to provide a tailored user experience during the sign-in process. When the user focuses on one of these views, a corresponding request is sent to Credential Manager. The resulting credentials are aggregated across providers and displayed in autofill fallback UIs, such as inline suggestions or drop-down suggestions. The Jetpack androidx.credentials library is the preferred endpoint for developers to use and will soon be available to further enhance this feature in Android 15 and higher.
Intégrez l'inscription et la connexion en un seul geste avec les requêtes 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
We are introducing the E2eeContactKeysManager
in Android 15, which
facilitates end-to-end encryption (E2EE) in your Android apps by providing an
OS-level API for the storage of cryptographic public keys.
The E2eeContactKeysManager
is designed to integrate with the platform
contacts app to give users a centralized way to manage and verify their
contacts' public keys.
Vérification des 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 attributerequireContentUriPermissionFromCaller
: This enforces specified permissions on the provided content URIs at activity launch.ComponentCaller
class forActivity
callers: This represents the app that launched the activity.
Accessibilité
Android 15 ajoute des fonctionnalités qui améliorent l'accessibilité pour les utilisateurs.
Améliorer le braille
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
Starting with Android 15, the font file for Chinese, Japanese, and Korean (CJK) languages, NotoSansCJK, is now a variable font. Variable fonts open up new 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.
Configuration automatique des sauts 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 now 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:
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.
VideoLAN cone Copyright (c) 1996-2010 VideoLAN. This logo or a modified version may be used or modified by anyone to refer to the VideoLAN project or any product developed by the VideoLAN team, but does not indicate endorsement by the project.
Vulkan and the Vulkan logo are registered trademarks of the Khronos Group Inc.
OpenGL is a registered trademark and the OpenGL ES logo is a trademark of Hewlett Packard Enterprise used by permission by Khronos.