API Android 5.0

Niveau d'API: 21

Android 5.0 (LOLLIPOP) offre de nouvelles fonctionnalités aux utilisateurs et aux développeurs d'applications. Ce document présente les nouvelles API les plus importantes.

Si vous avez publié une application, veillez à consulter les modifications de comportement d'Android 5.0 dont vous devez tenir compte dans votre application. Ces changements de comportement peuvent affecter votre application sur les appareils Android 5.0, même si vous n'utilisez pas de nouvelles API ni ne ciblez de nouvelles fonctionnalités.

Pour une présentation générale des nouvelles fonctionnalités de la plate-forme, consultez les points forts d'Android Lollipop.

Premiers pas en tant que développeur

Pour commencer à créer des applications pour Android 5.0, vous devez d'abord obtenir le SDK Android. Utilisez ensuite SDK Manager pour télécharger la plate-forme du SDK et les images système Android 5.0.

Mettre à jour votre niveau d'API cible

Afin d'optimiser votre application pour les appareils équipés d'Android 5.0, définissez targetSdkVersion sur "21", installez votre application sur une image système Android 5.0, testez-la, puis publiez l'application mise à jour avec cette modification.

Vous pouvez utiliser les API Android 5.0 tout en prenant en charge les anciennes versions. Pour ce faire, ajoutez à votre code des conditions qui vérifient le niveau d'API du système avant d'exécuter des API non compatibles avec votre minSdkVersion. Pour en savoir plus sur la gestion de la rétrocompatibilité, consultez la page Compatibilité avec différentes versions de plate-forme.

Pour en savoir plus sur le fonctionnement des niveaux d'API, consultez Qu'est-ce que le niveau d'API ?

Changements de comportement importants

Si vous avez déjà publié une application pour Android, sachez qu'elle peut être affectée par des modifications dans Android 5.0.

Pour en savoir plus, consultez Modifications apportées à Android 5.0.

Interface utilisateur

Compatibilité avec Material Design

Android 5.0 est compatible avec le nouveau style Material Design d'Android. Vous pouvez créer des applications Material Design visuellement dynamiques avec des transitions d'éléments d'interface utilisateur naturelles pour les utilisateurs. Cette assistance comprend les éléments suivants:

  • Le thème Material
  • Afficher les ombres
  • Widget RecyclerView
  • Animation et effets de style drawables
  • Animations et effets de transition d'activités Material Design
  • Animateurs des propriétés de vue basées sur l'état de la vue
  • Des widgets d'interface utilisateur personnalisables et des barres d'application avec des palettes de couleurs que vous contrôlez
  • Drawables animés et non animés basés sur des graphiques vectoriels XML

Pour en savoir plus sur l'ajout de fonctionnalités Material Design à votre application, consultez Material Design.

Documents et activités simultanés sur l'écran "Récents"

Dans les versions précédentes, l'écran "Récents" ne pouvait afficher qu'une seule tâche pour chaque application avec laquelle l'utilisateur a interagi le plus récemment. Votre application peut maintenant ouvrir davantage de tâches si nécessaire pour des activités simultanées supplémentaires pour les documents. Cette fonctionnalité facilite le multitâche en permettant aux utilisateurs de basculer rapidement entre des activités et des documents individuels à partir de l'écran "Récents", avec une expérience de basculement cohérente entre toutes les applications. Ces tâches simultanées peuvent inclure des onglets ouverts dans une application de navigateur Web, des documents dans une application de productivité, des parties simultanées dans un jeu ou des chats dans une application de chat. Votre application peut gérer ses tâches via la classe ActivityManager.AppTask.

Pour insérer une pause logique afin que le système traite votre activité comme une nouvelle tâche, utilisez FLAG_ACTIVITY_NEW_DOCUMENT lors du lancement de l'activité avec startActivity(). Vous pouvez également obtenir ce comportement en définissant l'attribut documentLaunchMode de l'élément <activity> sur "intoExisting" ou "always" dans votre fichier manifeste.

Pour éviter d'encombrer l'écran des éléments récents, vous pouvez définir le nombre maximal de tâches de votre application pouvant s'afficher sur cet écran. Pour ce faire, définissez l'attribut <application> android:maxRecents. Vous ne pouvez actuellement pas spécifier plus de 50 tâches par utilisateur (25 pour les appareils à faible RAM).

Les tâches de l'écran "Recents" (Éléments récents) peuvent être configurées pour être conservées lors des redémarrages. Pour contrôler le comportement de persistance, utilisez l'attribut android:persistableMode. Vous pouvez également modifier les propriétés visuelles d'une activité dans l'écran des éléments récents, comme la couleur, le libellé et l'icône de l'activité, en appelant la méthode setTaskDescription().

Mises à jour de WebView

Android 5.0 met à jour l'implémentation WebView vers Chromium M37, ce qui apporte des améliorations en termes de sécurité et de stabilité, ainsi que des corrections de bugs. La chaîne user-agent par défaut d'un WebView exécuté sur Android 5.0 a été mise à jour pour intégrer 37.0.0.0 comme numéro de version.

Cette version introduit la classe PermissionRequest, qui permet à votre application d'accorder l'autorisation WebView à votre application pour accéder à des ressources protégées telles que l'appareil photo et le micro, via des API Web telles que getUserMedia(). Votre application doit disposer des autorisations Android appropriées pour ces ressources afin d'accorder les autorisations au WebView.

Avec la nouvelle méthode onShowFileChooser(), vous pouvez maintenant utiliser un champ de formulaire de saisie dans WebView et lancer un sélecteur de fichier pour sélectionner des images et des fichiers à partir de l'appareil Android.

En outre, cette version est compatible avec les normes ouvertes WebAudio, WebGL et WebRTC. Pour en savoir plus sur les nouvelles fonctionnalités incluses dans cette version, consultez WebView pour Android.

Capture et partage d'écran

Android 5.0 vous permet d'ajouter des fonctionnalités de capture d'écran et de partage d'écran à votre application grâce aux nouvelles API android.media.projection. Cette fonctionnalité est utile, par exemple, si vous souhaitez activer le partage d'écran dans une application de visioconférence.

La nouvelle méthode createVirtualDisplay() permet à votre application de capturer le contenu de l'écran principal (affichage par défaut) dans un objet Surface, qu'elle peut ensuite envoyer sur le réseau. L'API ne permet de capturer que du contenu d'écran non sécurisé, et non l'audio du système. Pour commencer la capture d'écran, votre application doit d'abord demander l'autorisation de l'utilisateur en lançant une boîte de dialogue de capture d'écran à l'aide d'un Intent obtenu via la méthode createScreenCaptureIntent().

Pour savoir comment utiliser les nouvelles API, consultez la classe MediaProjectionDemo de l'exemple de projet.

Notifications

Notifications sur l'écran de verrouillage

Les écrans de verrouillage sous Android 5.0 peuvent afficher des notifications. Dans les Paramètres, les utilisateurs peuvent choisir d'autoriser ou non l'affichage du contenu des notifications sensibles sur un écran de verrouillage sécurisé.

Votre application peut contrôler le niveau de détail visible lorsque ses notifications sont affichées sur l'écran de verrouillage sécurisé. Pour contrôler le niveau de visibilité, appelez setVisibility() et spécifiez l'une des valeurs suivantes:

  • VISIBILITY_PRIVATE : affiche des informations de base, telles que l'icône de la notification, mais masque tout le contenu de la notification.
  • VISIBILITY_PUBLIC : affiche tout le contenu de la notification.
  • VISIBILITY_SECRET : n'affiche rien, sauf même l'icône de la notification.

Lorsque le niveau de visibilité est VISIBILITY_PRIVATE, vous pouvez également fournir une version masquée du contenu de la notification qui masque les informations personnelles. Par exemple, une application de SMS peut afficher la notification "Vous avez trois nouveaux SMS", mais masquer le contenu et les expéditeurs du message. Pour fournir cette notification alternative, commencez par créer la notification de remplacement à l'aide de Notification.Builder. Lorsque vous créez l'objet de notification privé, joignez-lui la notification de remplacement via la méthode setPublicVersion().

Métadonnées des notifications

Android 5.0 utilise les métadonnées associées aux notifications de votre application pour les trier plus intelligemment. Pour définir les métadonnées, appelez les méthodes suivantes dans Notification.Builder lorsque vous créez la notification:

  • setCategory(): indique au système comment gérer les notifications de votre application lorsque l'appareil est en mode priorité (par exemple, si une notification représente un appel entrant, un message instantané ou une alarme).
  • setPriority() : marque la notification comme plus ou moins importante que les notifications normales. Les notifications dont le champ de priorité est défini sur PRIORITY_MAX ou PRIORITY_HIGH s'affichent dans une petite fenêtre flottante si elles sont également accompagnées d'un son ou d'une vibration.
  • addPerson(): permet d'ajouter une ou plusieurs personnes concernées par une notification. Votre application peut l'utiliser pour signaler au système qu'elle doit regrouper les notifications des personnes spécifiées ou classer les notifications de ces personnes comme étant plus importantes.

Graphismes

Compatibilité avec OpenGL ES 3.1

Android 5.0 ajoute des interfaces Java et est compatible en natif avec OpenGL ES 3.1. Les principales nouvelles fonctionnalités fournies dans OpenGL ES 3.1 sont les suivantes:

  • Nuanceurs de calcul
  • Séparer les objets du nuanceur
  • Commandes de dessin indirects
  • Textures au pochoir et échantillons multiples
  • Améliorations de la langue d'ombrage
  • Extensions pour les modes de fusion et le débogage avancés
  • Rétrocompatibilité avec OpenGL ES 2.0 et 3.0

L'interface Java pour OpenGL ES 3.1 sur Android est fournie avec GLES31. Lorsque vous utilisez OpenGL ES 3.1, veillez à le déclarer dans votre fichier manifeste avec la balise <uses-feature> et l'attribut android:glEsVersion. Par exemple :

<manifest>
    <uses-feature android:glEsVersion="0x00030001" />
    ...
</manifest>

Pour en savoir plus sur l'utilisation d'OpenGL ES, y compris sur la vérification de la version compatible d'OpenGL ES de l'appareil au moment de l'exécution, consultez le guide de l'API OpenGL ES.

Pack d'extensions Android

En plus d'OpenGL ES 3.1, cette version fournit un pack d'extensions avec des interfaces Java et une compatibilité native avec des fonctionnalités graphiques avancées. Ces extensions sont traitées comme un package unique par Android. (Si l'extension ANDROID_extension_pack_es31a est présente, votre application peut supposer que toutes les extensions du package sont présentes et activer les fonctionnalités du langage d'ombrage avec une seule instruction #extension).

Le pack d'extensions est compatible avec:

  • Garantie de compatibilité du nuanceur de fragments avec les tampons de stockage du nuanceur, les images et les images atomiques (la compatibilité du nuanceur de fragments est facultative dans OpenGL ES 3.1)
  • Nuanceurs de tessellation et de géométrie
  • Format de compression de texture ASTC (LDR)
  • Interpolation et ombrage par échantillon
  • Différents modes de fusion pour chaque pièce jointe de couleur dans un tampon cadre

L'interface Java du pack d'extensions est fournie avec GLES31Ext. Dans le fichier manifeste de votre application, vous pouvez déclarer que celle-ci ne doit être installée que sur les appareils compatibles avec le pack d'extensions. Par exemple :

<manifest>
    <uses-feature android:name=“android.hardware.opengles.aep”
        android:required="true" />
    ...
</manifest>

Contenus multimédias

API Camera pour des fonctionnalités photo et vidéo avancées

Android 5.0 introduit la nouvelle API android.hardware.camera2 pour faciliter la capture de photos et le traitement d'image précis. Vous pouvez désormais accéder de manière programmatique aux caméras disponibles sur le système avec getCameraIdList() et vous connecter à un appareil spécifique avec openCamera(). Pour commencer à capturer des images, créez un CameraCaptureSession et spécifiez les objets Surface auxquels envoyer les images capturées. CameraCaptureSession peut être configuré pour prendre une seule photo ou plusieurs images en rafale.

Pour être averti lorsque de nouvelles images sont capturées, implémentez l'écouteur CameraCaptureSession.CaptureCallback et définissez-le dans votre requête de capture. Désormais, lorsque le système termine la requête de capture d'image, votre écouteur CameraCaptureSession.CaptureCallback reçoit un appel à onCaptureCompleted(), en vous fournissant les métadonnées de capture d'image dans un CaptureResult.

La classe CameraCharacteristics permet à votre application de détecter les fonctionnalités de l'appareil photo disponibles sur un appareil. La propriété INFO_SUPPORTED_HARDWARE_LEVEL de l'objet représente le niveau de fonctionnalité de l'appareil photo.

  • Tous les appareils sont compatibles avec au moins le niveau matériel INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY, ce qui a des fonctionnalités à peu près équivalentes à celles de l'API Camera obsolète.
  • Les appareils compatibles avec le niveau de matériel INFO_SUPPORTED_HARDWARE_LEVEL_FULL peuvent contrôler manuellement la capture et le post-traitement, ainsi que la capture d'images haute résolution à des fréquences d'images élevées.

Pour savoir comment utiliser l'API Camera mise à jour, consultez les exemples d'implémentation de Camera2Basic et Camera2Video de cette version.

Lecture audio

Cette version inclut les modifications suivantes apportées à AudioTrack:

  • Votre application peut désormais fournir des données audio au format à virgule flottante (ENCODING_PCM_FLOAT). Cela permet une plus grande plage dynamique, une précision plus cohérente et une marge de progression supérieure. L'arithmétique à virgule flottante est particulièrement utile pour les calculs intermédiaires. Les points de terminaison de lecture utilisent un format entier pour les données audio, avec une profondeur de bits inférieure. (Dans Android 5.0, certaines parties du pipeline interne ne sont pas encore à virgule flottante.)
  • Votre application peut désormais fournir des données audio sous forme de ByteBuffer, au même format que celui fourni par MediaCodec.
  • L'option WRITE_NON_BLOCKING peut simplifier la mise en mémoire tampon et le multithreading pour certaines applications.

Commande de lecture multimédia

Utilisez les nouvelles API de notification et de contenu multimédia pour vous assurer que l'UI du système connaît votre lecture de contenus multimédias, et qu'elle peut extraire et afficher des pochettes d'albums. Il est désormais plus facile de contrôler la lecture de contenus multimédias dans une interface utilisateur et un service grâce aux nouvelles classes MediaSession et MediaController.

La nouvelle classe MediaSession remplace la classe obsolète RemoteControlClient et fournit un seul ensemble de méthodes de rappel pour la gestion des commandes de transport et des boutons multimédias. Si votre application lit des contenus multimédias et s'exécute sur la plate-forme Android TV ou Wear, utilisez la classe MediaSession pour gérer vos commandes de transport à l'aide des mêmes méthodes de rappel.

Vous pouvez maintenant créer votre propre application de contrôleur multimédia avec la nouvelle classe MediaController. Cette classe fournit un moyen sécurisé de surveiller et de contrôler la lecture des contenus multimédias à partir du processus d'interface utilisateur de votre application. Lorsque vous créez un contrôleur, spécifiez un objet MediaSession.Token afin que votre application puisse interagir avec le MediaSession donné. À l'aide des méthodes MediaController.TransportControls, vous pouvez envoyer des commandes telles que play(), stop(), skipToNext() et setRating() pour contrôler la lecture des contenus multimédias sur cette session. Avec le contrôleur, vous pouvez également enregistrer un objet MediaController.Callback pour écouter les métadonnées et les changements d'état de la session.

En outre, vous pouvez créer des notifications enrichies qui permettent une commande de lecture associée à une session multimédia avec la nouvelle classe Notification.MediaStyle.

Navigation multimédia

Android 5.0 permet aux applications de parcourir la bibliothèque de contenu multimédia d'une autre application via la nouvelle API android.media.Browse. Pour exposer le contenu multimédia dans votre application, étendez la classe MediaBrowserService. Votre implémentation de MediaBrowserService doit donner accès à un MediaSession.Token permettant aux applications de lire le contenu multimédia fourni via votre service.

Pour interagir avec un service de navigateur multimédia, utilisez la classe MediaBrowser. Spécifiez le nom du composant d'une MediaSession lorsque vous créez une instance MediaBrowser. À l'aide de cette instance de navigateur, votre application peut ensuite se connecter au service associé et obtenir un objet MediaSession.Token pour lire le contenu exposé via ce service.

Stockage

Sélection du répertoire

Android 5.0 étend le framework d'accès au stockage pour permettre aux utilisateurs de sélectionner une sous-arborescence de répertoire entière, offrant ainsi aux applications un accès en lecture/écriture à tous les documents contenus sans qu'il soit nécessaire de confirmer l'utilisateur pour chaque élément.

Pour sélectionner une sous-arborescence de répertoire, créez et envoyez un intent OPEN_DOCUMENT_TREE. Le système affiche toutes les instances DocumentsProvider compatibles avec la sélection de sous-arborescences, ce qui permet à l'utilisateur de parcourir et de sélectionner un répertoire. L'URI renvoyé représente l'accès à la sous-arborescence sélectionnée. Vous pouvez ensuite utiliser buildChildDocumentsUriUsingTree() et buildDocumentUriUsingTree() avec query() pour explorer la sous-arborescence.

La nouvelle méthode createDocument() vous permet de créer des documents ou des répertoires n'importe où dans la sous-arborescence. Pour gérer des documents existants, utilisez renameDocument() et deleteDocument(). Vérifiez COLUMN_FLAGS pour vérifier la compatibilité du fournisseur pour ces appels avant de les émettre.

Si vous implémentez un DocumentsProvider et que vous souhaitez prendre en charge la sélection de sous-arborescences, implémentez isChildDocument() et incluez FLAG_SUPPORTS_IS_CHILD dans votre COLUMN_FLAGS.

Android 5.0 introduit également de nouveaux répertoires spécifiques aux packages sur le stockage partagé, dans lesquels votre application peut placer des fichiers multimédias pour les inclure dans MediaStore. Le nouveau getExternalMediaDirs() renvoie les chemins d'accès à ces répertoires sur tous les appareils de stockage partagés. Comme pour getExternalFilesDir(), votre application n'a besoin d'aucune autorisation supplémentaire pour accéder aux chemins renvoyés. La plate-forme recherche régulièrement de nouveaux contenus multimédias dans ces répertoires, mais vous pouvez également utiliser MediaScannerConnection pour rechercher explicitement de nouveaux contenus.

Sans fil et connectivité

Connexions réseau multiples

Android 5.0 fournit de nouvelles API de multiréseau qui permettent à votre application de rechercher de manière dynamique les réseaux disponibles avec des fonctionnalités spécifiques et d'établir une connexion avec ces réseaux. Cette fonctionnalité est utile lorsque votre application nécessite un réseau spécialisé, tel qu'un réseau SUPL, MMS ou de facturation par l'opérateur, ou si vous souhaitez envoyer des données à l'aide d'un type de protocole de transport particulier.

Pour sélectionner un réseau et vous y connecter de manière dynamique depuis votre application, procédez comme suit:

  1. Créez un élément ConnectivityManager.
  2. Utilisez la classe NetworkRequest.Builder pour créer un objet NetworkRequest, et spécifier les fonctionnalités réseau et le type de transport qui intéressent votre application.
  3. Pour rechercher les réseaux appropriés, appelez requestNetwork() ou registerNetworkCallback(), puis transmettez l'objet NetworkRequest et une implémentation de ConnectivityManager.NetworkCallback. Utilisez la méthode requestNetwork() si vous souhaitez passer activement sur un réseau approprié une fois qu'il est détecté. Pour ne recevoir que des notifications pour les réseaux analysés sans changer activement, utilisez plutôt la méthode registerNetworkCallback().

Lorsque le système détecte un réseau approprié, il s'y connecte et appelle le rappel onAvailable(). Vous pouvez utiliser l'objet Network du rappel pour obtenir des informations supplémentaires sur le réseau ou pour diriger le trafic afin qu'il utilise le réseau sélectionné.

Bluetooth à basse consommation

Android 4.3 a introduit la compatibilité de plate-forme avec la technologie Bluetooth Low Energy (Bluetooth LE) au cœur du rôle principal. Sous Android 5.0, un appareil Android peut désormais servir de périphérique Bluetooth LE. Les applications peuvent utiliser cette fonctionnalité pour signaler leur présence aux appareils à proximité. Par exemple, vous pouvez créer des applications qui permettent à un appareil de fonctionner comme podomètre ou à un moniteur de santé, et communiquer ses données avec un autre appareil Bluetooth LE.

Les nouvelles API android.bluetooth.le permettent à vos applications de diffuser des annonces, de rechercher des réponses et de créer des connexions avec des appareils Bluetooth LE à proximité. Pour utiliser les nouvelles fonctionnalités de publicité et d'analyse, ajoutez l'autorisation BLUETOOTH_ADMIN dans votre fichier manifeste. Lorsque les utilisateurs mettent à jour ou téléchargent votre application sur le Play Store, ils sont invités à accorder l'autorisation suivante à votre application : "Informations sur la connexion Bluetooth: permet à l'application de contrôler le Bluetooth, y compris en diffusant ou en obtenant des informations sur les appareils Bluetooth à proximité".

Pour lancer la publicité Bluetooth LE afin que d'autres appareils puissent découvrir votre application, appelez startAdvertising() et transmettez une implémentation de la classe AdvertiseCallback. L'objet de rappel reçoit un rapport sur la réussite ou l'échec de l'opération publicitaire.

Android 5.0 introduit la classe ScanFilter afin que votre application ne puisse rechercher que les types d'appareils spécifiques qui l'intéressent. Pour commencer à rechercher des appareils Bluetooth LE, appelez startScan() et transmettez une liste de filtres. Dans l'appel de méthode, vous devez également fournir une implémentation de ScanCallback pour signaler qu'une annonce Bluetooth LE est détectée.

Améliorations NFC

Android 5.0 ajoute les améliorations suivantes pour permettre une utilisation plus large et plus flexible de la technologie NFC:

  • Android Beam est désormais disponible dans le menu Partager.
  • Votre application peut appeler Android Beam sur l'appareil de l'utilisateur pour partager des données en appelant invokeBeam(). Cela évite à l'utilisateur d'avoir à placer manuellement l'appareil contre un autre appareil compatible NFC pour effectuer le transfert de données.
  • Vous pouvez utiliser la nouvelle méthode createTextRecord() pour créer un enregistrement NDEF contenant des données textuelles UTF-8.
  • Si vous développez une application de paiement, vous pouvez désormais enregistrer un ID application NFC (AID) de manière dynamique en appelant registerAidsForService(). Vous pouvez également utiliser setPreferredService() pour définir le service d'émulation de carte préféré à utiliser lorsqu'une activité spécifique est exécutée au premier plan.

Projet Volta

En plus des nouvelles fonctionnalités, Android 5.0 met l'accent sur les améliorations apportées à l'autonomie de la batterie. Utilisez les nouveaux outils et API pour comprendre et optimiser la consommation d'énergie de votre application.

Planifier des jobs

Android 5.0 fournit une nouvelle API JobScheduler qui vous permet d'optimiser l'autonomie de la batterie en définissant des tâches que le système doit exécuter de manière asynchrone ultérieurement ou dans des conditions spécifiées (par exemple, lorsque l'appareil est en charge). La planification des missions est utile dans les situations suivantes:

  • L'application comporte des tâches qui ne sont pas visibles par l'utilisateur, que vous pouvez reporter.
  • L'application doit effectuer certaines opérations lorsque l'appareil est branché.
  • L'application comporte une tâche qui nécessite un accès réseau ou une connexion Wi-Fi.
  • L'application comporte un certain nombre de tâches que vous souhaitez exécuter par lot à intervalles réguliers.

Une unité de travail est encapsulée par un objet JobInfo. Cet objet spécifie les critères de planification.

Utilisez la classe JobInfo.Builder pour configurer le mode d'exécution de la tâche planifiée. Vous pouvez planifier l'exécution de la tâche dans des conditions spécifiques, telles que:

  • Commencer lorsque l'appareil est en charge
  • Démarrer lorsque l'appareil est connecté à un réseau illimité
  • Démarrer lorsque l'appareil est inactif
  • Terminer avant une certaine date ou dans un délai minimal

Par exemple, vous pouvez ajouter du code comme celui-ci pour exécuter votre tâche sur un réseau non facturé à l'usage:

Kotlin

val uploadTask: JobInfo = JobInfo.Builder(
        jobId,
        serviceComponent /* JobService component */
).run {
    setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)
    build()
}
val jobScheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
jobScheduler.schedule(uploadTask)

Java

JobInfo uploadTask = new JobInfo.Builder(jobId,
                                         serviceComponent /* JobService component */)
        .setRequiredNetworkCapabilities(JobInfo.NETWORK_TYPE_UNMETERED)
        .build();
JobScheduler jobScheduler =
        (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
jobScheduler.schedule(uploadTask);

Si l'appareil dispose d'une alimentation stable (c'est-à-dire s'il est branché depuis plus de deux minutes et que la batterie est à un niveau opérationnel), le système exécute toutes les tâches planifiées prêtes à être exécutées, même si leur date limite n'a pas expiré.

Pour savoir comment utiliser l'API JobScheduler, reportez-vous à l'exemple d'implémentation JobSchedulerSample de cette version.

Outils pour les développeurs sur l'utilisation de la batterie

La nouvelle commande dumpsys batterystats génère des données statistiques intéressantes sur l'utilisation de la batterie sur un appareil, organisées par ID utilisateur unique (UID). Les statistiques comprennent les éléments suivants:

  • Historique des événements liés à la batterie
  • Statistiques globales de l'appareil
  • Consommation énergétique approximative par UID et composant système
  • Nombre de ms mobiles par application et par paquet
  • Statistiques agrégées de l'UID du système
  • Statistiques agrégées de l'UID de l'application

Utilisez l'option --help pour en savoir plus sur les différentes options de personnalisation du résultat. Par exemple, pour afficher des statistiques d'utilisation de la batterie pour un package d'application donné depuis la dernière charge de l'appareil, exécutez la commande suivante :

$ adb shell dumpsys batterystats --charged <package-name>

Vous pouvez utiliser l'outil Battery Historian sur la sortie de la commande dumpsys pour générer une visualisation HTML des événements liés à l'alimentation à partir des journaux. Ces informations vous permettent de comprendre et de diagnostiquer plus facilement les problèmes liés à la batterie.

Android en entreprise et dans l'enseignement

Configuration gérée

Android 5.0 fournit de nouvelles fonctionnalités pour l'exécution d'applications dans un environnement d'entreprise. Un administrateur d'appareil peut lancer un processus de provisionnement géré pour ajouter un profil géré en coprésentation à un appareil, si l'utilisateur possède déjà un compte personnel. Les applications associées à des profils gérés apparaissent à côté des applications non gérées dans le Lanceur d'applications, l'écran "Récents" et les notifications de l'utilisateur.

Pour démarrer le processus de provisionnement géré, envoyez ACTION_PROVISION_MANAGED_PROFILE dans un Intent. Si l'appel aboutit, le système déclenche le rappel onProfileProvisioningComplete(). Vous pouvez ensuite appeler setProfileEnabled() pour activer ce profil géré.

Par défaut, seul un petit sous-ensemble d'applications est activé dans le profil géré. Vous pouvez installer des applications supplémentaires dans le profil géré en appelant enableSystemApp().

Si vous développez une application de lancement, vous pouvez utiliser la nouvelle classe LauncherApps pour obtenir la liste des activités pouvant être lancées pour l'utilisateur actuel et tous les profils gérés associés. Le lanceur d'applications peut rendre les applications gérées visuellement proéminentes en ajoutant un badge professionnel au drawable de l'icône. Pour récupérer l'icône avec badge, appelez getUserBadgedIcon().

Pour savoir comment utiliser la nouvelle fonctionnalité, consultez l'exemple d'implémentation BasicManagedProfile présenté dans cette version.

Propriétaire de l'appareil

Android 5.0 permet de déployer une application de propriétaire d'appareil. Un propriétaire d'appareil est un type spécialisé d'administrateur d'appareil doté de la capacité supplémentaire de créer et de supprimer des utilisateurs secondaires, et de configurer des paramètres généraux sur l'appareil. L'application de propriétaire de l'appareil peut utiliser les méthodes de la classe DevicePolicyManager pour contrôler précisément la configuration, la sécurité et les applications sur les appareils gérés. Un appareil ne peut avoir qu'un seul propriétaire actif à la fois.

Pour déployer et activer un propriétaire d'appareil, vous devez effectuer un transfert de données NFC depuis une application de programmation vers l'appareil lorsque celui-ci est dans son état non provisionné. Ce transfert de données envoie les mêmes informations que dans l'intent de provisionnement décrit dans la section Provisionnement géré.

Épinglage d'écran

Android 5.0 introduit une nouvelle API d'épinglage d'écran qui vous permet d'empêcher temporairement les utilisateurs de quitter votre tâche ou d'être interrompus par des notifications. Cette approche peut être utilisée, par exemple, si vous développez une application éducative pour répondre à des exigences d'évaluation à enjeux élevés sur Android, ou une application à application unique ou kiosque. Une fois que votre application a activé l'épinglage d'écran, les utilisateurs ne peuvent pas voir les notifications, accéder à d'autres applications ni revenir à l'écran d'accueil tant que votre application n'a pas quitté ce mode.

Il existe deux façons d'activer l'épinglage d'écran:

  • Manuellement:les utilisateurs peuvent activer l'épinglage d'écran dans Paramètres > Sécurité > Épinglage d'écran, puis sélectionner les tâches à épingler en appuyant sur l'icône représentant une punaise verte sur l'écran "Récents".
  • Par programmation:pour activer l'épinglage d'écran par programmation, appelez startLockTask() à partir de votre application. Si l'application à l'origine de la demande n'est pas propriétaire d'un appareil, l'utilisateur est invité à confirmer l'opération. Une application de propriétaire d'appareil peut appeler la méthode setLockTaskPackages() pour permettre l'épinglage des applications sans l'étape de confirmation de l'utilisateur.

Lorsque le verrouillage des tâches est actif, le comportement suivant se produit:

  • La barre d'état est vide, et les notifications utilisateur et les informations d'état sont masquées.
  • Les boutons Accueil et Applications récentes sont masqués.
  • Les autres applications ne peuvent pas lancer de nouvelles activités.
  • L'application actuelle peut démarrer de nouvelles activités, à condition de ne pas créer de tâches.
  • Lorsque le propriétaire d'un appareil appelle l'épinglage d'écran, l'utilisateur reste verrouillé sur votre application jusqu'à ce qu'elle appelle stopLockTask().
  • Si l'épinglage d'écran est activé par une autre application qui n'est pas propriétaire de l'appareil ou directement par l'utilisateur, celui-ci peut quitter cette application en appuyant de manière prolongée sur les boutons "Retour" et "Récent".

Cadre d'impression

Afficher le PDF en tant que bitmap

Vous pouvez désormais afficher les pages de documents PDF sous forme d'images bitmap pour l'impression à l'aide de la nouvelle classe PdfRenderer. Vous devez spécifier un ParcelFileDescriptor pouvant être recherché (c'est-à-dire que le contenu est accessible de manière aléatoire) sur lequel le système écrit le contenu imprimable. Votre application peut obtenir une page à afficher avec openPage(), puis appeler render() pour transformer le PdfRenderer.Page ouvert en bitmap. Vous pouvez également définir des paramètres supplémentaires si vous ne souhaitez convertir qu'une partie du document en image bitmap (par exemple, pour implémenter le rendu en mosaïque afin de faire un zoom avant sur le document).

Pour savoir comment utiliser les nouvelles API, consultez l'exemple PdfRendererBasic.

Système

Statistiques utilisation de l'appli

Vous pouvez désormais accéder à l'historique d'utilisation des applications sur un appareil Android avec la nouvelle API android.app.usage. Cette API fournit des informations d'utilisation plus détaillées que la méthode obsolète getRecentTasks(). Pour utiliser cette API, vous devez d'abord déclarer l'autorisation "android.permission.PACKAGE_USAGE_STATS" dans votre fichier manifeste. L'utilisateur doit également activer l'accès à cette application via Paramètres > Sécurité > Applications avec accès aux données d'utilisation.

Le système collecte les données d'utilisation par application, en les regroupant tous les jours, toutes les semaines, tous les mois et tous les ans. La durée maximale de conservation de ces données par le système est la suivante:

  • Données quotidiennes: 7 jours
  • Données hebdomadaires: 4 semaines
  • Données mensuelles: 6 mois
  • Données annuelles: 2 ans

Pour chaque application, le système enregistre les données suivantes:

  • Date de la dernière utilisation de l'application
  • Durée totale pendant laquelle l'application était au premier plan pendant cet intervalle de temps (par jour, semaine, mois ou année)
  • Capture d'horodatage lorsqu'un composant (identifié par un package et un nom d'activité) est déplacé au premier plan ou en arrière-plan pendant une journée
  • Capture du code temporel lorsqu'une modification de la configuration d'un appareil a été effectuée (par exemple, lorsque l'orientation de l'appareil a changé en raison d'une rotation)

Tests et accessibilité

Tests et améliorations de l'accessibilité

Android 5.0 ajoute les fonctionnalités suivantes pour les tests et l'accessibilité:

  • Les nouvelles méthodes getWindowAnimationFrameStats() et getWindowContentFrameStats() capturent des statistiques de frames pour les animations de fenêtre et le contenu. Ces méthodes vous permettent d'écrire des tests d'instrumentation pour évaluer si une application affiche les images à une fréquence d'actualisation suffisante pour offrir une expérience utilisateur fluide.
  • La nouvelle méthode executeShellCommand() vous permet d'exécuter des commandes shell à partir de votre test d'instrumentation. L'exécution de la commande est semblable à l'exécution de adb shell à partir d'un hôte connecté à l'appareil, ce qui vous permet d'utiliser des outils basés sur une interface système tels que dumpsys, am, content et pm.
  • Les services d'accessibilité et les outils de test qui utilisent les API d'accessibilité (telles que UiAutomator) peuvent désormais récupérer des informations détaillées sur les propriétés des fenêtres à l'écran avec lesquelles les utilisateurs voyants peuvent interagir. Pour récupérer la liste des objets AccessibilityWindowInfo, appelez la nouvelle méthode getWindows().
  • La nouvelle classe AccessibilityNodeInfo.AccessibilityAction vous permet de définir des actions standards ou personnalisées à effectuer sur un AccessibilityNodeInfo. La nouvelle classe AccessibilityNodeInfo.AccessibilityAction remplace les API liées aux actions qui se trouvaient précédemment dans AccessibilityNodeInfo.
  • Android 5.0 offre un contrôle plus précis de la synthèse vocale dans votre application. La nouvelle classe Voice permet à votre application d'utiliser des profils vocaux associés à des paramètres régionaux spécifiques, à des niveaux de qualité et de latence spécifiques, ainsi qu'à des paramètres spécifiques au moteur de synthèse vocale.

Éditeur de méthode de saisie

Changer plus facilement de langue de saisie

À partir d'Android 5.0, les utilisateurs peuvent plus facilement basculer entre tous les éditeurs de mode de saisie (IME) pris en charge par la plate-forme. L'action de basculement désignée (généralement en appuyant sur une icône en forme de globe sur le clavier virtuel) permet de parcourir tous ces IME. Ce changement de comportement est mis en œuvre par la méthode shouldOfferSwitchingToNextInputMethod().

En outre, le framework vérifie désormais si l'IME suivant inclut un mécanisme de basculement (et, par conséquent, si cet IME prend en charge le passage à l'IME après celui-ci). Un IME doté d'un mécanisme de basculement ne passe pas à un IME sans ce mécanisme. Ce changement de comportement est mis en œuvre par la méthode switchToNextInputMethod().

Pour voir un exemple d'utilisation des API de basculement IME mises à jour, reportez-vous à l'exemple d'implémentation mis à jour du clavier virtuel dans cette version. Pour en savoir plus sur la mise en œuvre du basculement entre les IME, consultez la section Créer un mode de saisie.

Déclarations du fichier manifeste

Fonctionnalités requises déclarables

Les valeurs suivantes sont désormais compatibles avec l'élément <uses-feature>. Vous pouvez ainsi vous assurer que votre application n'est installée que sur les appareils qui fournissent les fonctionnalités dont elle a besoin.

Autorisations utilisateur

L'autorisation suivante est désormais prise en charge dans l'élément <uses-permission> pour déclarer les autorisations dont votre application a besoin pour accéder à certaines API.

  • BIND_DREAM_SERVICE: lorsque vous ciblez le niveau d'API 21 ou supérieur, cette autorisation est requise par un service Daydream pour garantir que seul le système peut s'y associer.