Versions précédentes d'Android Studio

Cette page présente les nouvelles fonctionnalités et améliorations de chaque version majeure des versions précédentes d'Android Studio. Pour découvrir les nouveautés de la dernière version, consultez les notes de version d'Android Studio actuelles.

Pour obtenir les dernières actualités sur les versions, y compris une liste des correctifs notables dans chaque version preview, consultez les mises à jour des versions. Pour en savoir plus sur les nouveautés du plug-in Android Gradle, consultez ses notes de version.

Compatibilité entre le plug-in Android Gradle et Android Studio

Le système de compilation Android Studio est basé sur Gradle, et le plug-in Android Gradle ajoute plusieurs fonctionnalités spécifiques à la création d'applications Android. Le tableau suivant présente les versions du plug-in Android Gradle requises pour chaque version d'Android Studio.

Pour en savoir plus sur les nouveautés du plug-in Android Gradle, consultez les notes de version du plug-in Android Gradle.

Android Studio Bumblebee | 2021.1.1

Android Studio Bumblebee est une version majeure qui inclut les fonctionnalités et améliorations ci-dessous.

Aperçu interactif de Compose activé par défaut

À partir d'Android Studio Bumblebee, la fonctionnalité d'aperçu interactif est activée par défaut. L'aperçu interactif vous permet d'interagir avec un aperçu comme sur un appareil. L'aperçu interactif est isolé des autres aperçus dans un environnement de bac à sable, où vous pouvez cliquer sur des éléments et saisir l'entrée utilisateur. C'est un moyen rapide de tester différents états et gestes de votre composable, comme une case cochée ou vide.

Le mode interactif de l'aperçu s'exécute directement dans Android Studio sans exécution d'un émulateur. Il existe donc certaines limites :

• Aucun accès au réseau.
• Aucun accès aux fichiers.
• Certaines API de contexte peuvent ne pas être entièrement disponibles.

Aperçu du drawable vectoriel animé (AVD)

L'outil Drawable vectoriel animé permet de prévisualiser les ressources drawable animées. Cet outil vous permet de prévisualiser les ressources <animation-list>, <animated-vector> et <animated-selector> dans Android Studio et d'affiner plus facilement vos animations personnalisées.

Mise à jour du sélecteur d'appareils pour les outils de conception

Afin de simplifier la conception de votre application pour le grand nombre d'appareils Android, nous avons mis à jour le sélecteur d'appareils dans différentes fenêtres d'outils de conception (Éditeur de mise en page et Validation de mise en page, par exemple) avec des appareils de référence qui reflètent les tailles courantes de chaque facteur de forme d'appareil. Des téléphones aux tablettes, en passant par les appareils Wear et Android TV, il est maintenant plus facile de prévisualiser, de valider ou de modifier votre mise en page sur les tailles d'écran les plus représentatives des appareils courants du monde réel.

Exécution du test KMP

Vous pouvez exécuter des tests pour les projets Kotlin Multiplatform (KMP) depuis Android Studio Bumblebee.

Pour vous assurer que vos tests s'exécutent correctement à partir d'Android Studio, vous devez remplir toutes les conditions ci-dessous :

• AGP 7.0.0-alpha08 ou version ultérieure
• Gradle 6.8.2 ou version ultérieure
• Plug-in Kotlin 1.4.30 ou version ultérieure

Classes R non transitives activées par défaut

Les classes R non transitives sont à présent activées par défaut. Vous pouvez utiliser des classes R non transitives avec le plug-in Android Gradle pour créer des builds plus rapides pour les applications comportant plusieurs modules. Cela permet d'éviter la duplication des ressources en garantissant que la classe R de chaque module ne contient que des références à ses propres ressources, sans extraire de références de ses dépendances. Cela permet d'obtenir des builds plus à jour et les avantages qui découlent de l'évitement de la compilation.

Si vous avez besoin d'aide pour utiliser cette fonctionnalité, accédez à Refactoriser > Migrer vers des classes R non transitives.

Mise à jour de la prise en charge d'Apple Silicon

Si vous utilisez macOS sur du matériel Apple Silicon (arm64), Android Studio Arctic Fox et Android Emulator sont compatibles avec cette nouvelle architecture depuis l'année dernière. Toutefois, avec cette version, nous avons mis à jour les outils de la plate-forme SDK Android v32.0.0 (qui inclut adb et fastboot) et les outils du build v32.1.0 (qui inclut aapt) afin qu'ils soient des binaires universels et que vos outils pour les développeurs Android n'aient ainsi plus besoin du traducteur binaire Rosetta pour fonctionner. Consultez les notes de version des outils de la plate-forme SDK.

Nouveautés de l'outil d'inspection de la mise en page

Capturer des instantanés de la hiérarchie des mises en page

L'outil d'inspection de la mise en page vous permet maintenant d'enregistrer des instantanés de la hiérarchie de mise en page de votre application en cours d'exécution. Vous pouvez ainsi les partager facilement avec d'autres utilisateurs ou vous y référer ultérieurement.

Les instantanés capturent les données que vous voyez généralement lorsque vous utilisez l'outil d'inspection de la mise en page, y compris un rendu 3D détaillé de votre mise en page, l'arborescence des composants de votre mise en page View, Compose ou hybride, ainsi que des attributs détaillés pour chaque composant de votre interface utilisateur. Pour enregistrer un instantané, procédez comme suit :

1. Déployez votre application sur un appareil exécutant le niveau d'API 23 ou supérieur.
2. Ouvrez l'outil d'inspection de la mise en page en sélectionnant Vue > Fenêtres d'outil > Outil d'inspection de la mise en page.
3. L'outil d'inspection de la mise en page doit se connecter automatiquement au processus de votre application. Si ce n'est pas le cas, sélectionnez le processus d'application dans le menu déroulant.
4. Lorsque vous souhaitez capturer un instantané, cliquez sur Exporter l'instantané dans la barre d'outils de l'outil d'inspection de la mise en page.
5. Dans la boîte de dialogue système qui s'affiche, indiquez le nom et l'emplacement dans lequel vous souhaitez enregistrer votre instantané. Veillez à enregistrer le fichier avec l'extension *.li.

Ensuite, pour charger un instantané de l'outil d'inspection de la mise en page, sélectionnez Fichier > Ouvrir dans la barre de menu principale et ouvrez un fichier *.li.

Compatibilité avec l'inspection de la sémantique Compose

Dans Compose, Semantics décrit l'interface utilisateur d'une manière alternative compréhensible pour les services d'accessibilité et pour le framework de test. Dans Android Studio Bumblebee, vous pouvez maintenant utiliser l'outil d'inspection de la mise en page pour inspecter les informations sémantiques dans vos mises en page Compose.

Lorsque vous sélectionnez un nœud Compose, utilisez la fenêtre Attributs pour vérifier s'il déclare directement les informations sémantiques, s'il fusionne la sémantique de ses enfants, ou les deux. Pour identifier rapidement les nœuds qui incluent la sémantique, qu'ils soient déclarés ou fusionnés, sélectionnez le menu déroulant Afficher les options dans la fenêtre Arborescence des composants, puis sélectionnez Mettre en surbrillance les couches sémantiques. Cela ne met en surbrillance que les nœuds de l'arborescence qui incluent la sémantique. Vous pouvez utiliser votre clavier pour passer rapidement de l'un à l'autre.

Éviter les redémarrages d'activité

Si vous connectez l'outil d'inspection de la mise en page à une application en cours d'exécution sur des versions plus anciennes d'Android Studio, l'activité de votre application pourrait redémarrer. Ceci est nécessaire pour définir un indicateur d'appareil permettant d'inspecter les mises en page de votre application.

Dans Android Studio Bumblebee, vous pouvez éviter les redémarrages d'activité lorsque vous connectez l'outil d'inspection de la mise en page en définissant cet indicateur à l'avance en procédant comme suit :

• Activez une option de configuration d'exécution :

  1. Sélectionnez Exécuter > Modifier les configurations dans la barre de menu principale. La boîte de dialogue Configurations d'exécution/de débogage s'affiche.
  2. Accédez à la configuration d'exécution que vous souhaitez utiliser.
  3. Dans la section Options de l'outil d'inspection de la mise en page, cochez la case Se connecter à l'outil d'inspection de la mise en page sans redémarrer l'activité.
  4. Utilisez la configuration d'exécution la prochaine fois que vous souhaitez inspecter votre application à l'aide de l'outil d'inspection de la mise en page.

• Définissez l'indicateur à partir de la ligne de commande :

  1. Ouvrez une fenêtre de terminal sur l'ordinateur connecté à votre appareil.
  2. Définissez l'indicateur d'appareil de votre application à l'aide de la commande suivante :

  adb shell settings put global debug_view_attributes_application_package <my_package_name>
  

  1. Déployez votre application sur l'appareil et connectez l'outil d'inspection de la mise en page. Android Studio vérifiera si l'indicateur est défini et évite autant que possible de redémarrer l'activité.

Instantanés de l'outil d'inspection de la mise en page de documents

Vous pouvez à présent capturer des instantanés de la hiérarchie de mise en page de votre application pour les enregistrer, les partager ou les inspecter plus tard. Les instantanés capturent les données que vous voyez généralement lorsque vous utilisez l'outil d'inspection de la mise en page, y compris un rendu 3D détaillé de votre mise en page, l'arborescence des composants de votre mise en page View, Compose ou hybride, ainsi que des attributs détaillés pour chaque composant de votre interface utilisateur. Lorsque vous inspectez la mise en page d'une application en cours d'exécution, cliquez sur Exporter l'instantané dans la barre d'outils de l'outil d'inspection de la mise en page, puis enregistrez l'instantané avec l'extension *.li. Ensuite, pour charger un instantané de l'outil d'inspection de la mise en page, sélectionnez Fichier > Ouvrir dans la barre de menu principale et ouvrez un fichier *.li. L'instantané apparaît dans un onglet de la fenêtre de l'éditeur, ce qui vous permet de le comparer facilement à votre application en cours d'exécution.

Nouveautés de l'inspection des applications

Android Studio Bumblebee propose de nouveaux outils et de nouvelles fonctionnalités dans la fenêtre d'inspection des applications. Pour ouvrir App Inspector, sélectionnez Vue > Fenêtres d'outil > Inspection des applications dans la barre de menu principale.

Outil d'inspection du réseau

Le Profileur de réseau dans la fenêtre d'outil Profileurs se trouve maintenant dans la fenêtre d'outil Inspection des applications. Si vous avez déjà utilisé Profileur de réseau, les mêmes fonctionnalités et données enrichies sur le trafic réseau restent disponibles. Il vous suffit de déployer votre application sur un appareil exécutant le niveau d'API 26 ou supérieur, puis d'ouvrir l'onglet Outil d'inspection des applications > Outil d'inspection du réseau.

Inspecter les tâches, les alarmes et les wakelocks

Background Task Inspector vous permet à présent d'inspecter les tâches, les alarmes et les wakelocks de votre application, en plus de la compatibilité existante pour l'inspection des nœuds de calcul. Chaque type de tâche asynchrone apparaît maintenant sous le titre approprié dans l'onglet de l'outil d'inspection, ce qui vous permet de surveiller facilement son état et sa progression. Comme pour les nœuds de calcul, vous pouvez sélectionner une tâche, une alarme ou un wakelock pour inspecter ses informations détaillées dans le panneau Détails de la tâche.

Étant donné que les nœuds de calcul utilisent en arrière-plan des tâches et des wakelocks, les tâches planifiées par les nœuds de calcul apparaissent en tant qu'enfants de chaque nœud de calcul. Gardez à l'esprit que vous ne pouvez voir les nœuds de calcul qu'en mode graphique.

Débogage sans fil

Android Studio Bumblebee est compatible avec la fonctionnalité de débogage sans fil des appareils équipés d'Android 11 ou version ultérieure. Associez et déployez votre application depuis Android Studio via le Wi-Fi sans utiliser de câble USB, ni gérer les connexions Android Debug Bridge (adb) à l'aide de la ligne de commande. Pour cela, accédez à l'option Associer des appareils via le Wi-Fi dans le menu de sélection des appareils, puis choisissez un code QR ou un code PIN d'association. Ensuite, sur votre appareil Android 11 ou version ultérieure, sous Options pour les développeurs, recherchez l'écran Débogage sans fil, puis initialisez l'appareil et connectez-vous à une session adb sans fil avec Android Studio. Pour en savoir plus sur la configuration du débogage sans fil, consultez Se connecter à un appareil via le Wi-Fi (Android 11 ou version ultérieure).

Exécuteur de test Gradle unifié

Le plug-in Android Gradle 7.1.0 et Android Studio Bumblebee et versions ultérieures utilisent la propre implémentation de Gradle de l'exécuteur de test d'instrumentation Android pour exécuter des tests d'instrumentation. En utilisant le même exécuteur de test, les résultats sont susceptibles d'être cohérents, que vous exécutiez à l'aide d'AGP à partir de la ligne de commande, comme sur un serveur d'intégration continue, ou à partir d'Android Studio.

Les versions précédentes d'Android Studio utilisent l'exécuteur de test d'instrumentation Android IntelliJ au lieu de l'exécuteur de test d'instrumentation Android de Gradle. Ainsi, si vous n'utilisez pas la dernière version d'Android Studio, selon que vous exécutez vos tests depuis Android Studio ou depuis la ligne de commande à l'aide du plug-in Gradle, vous pouvez voir des résultats de test différents, tels que des tests satisfaisants avec un exécuteur et négatifs avec un autre.

Si vous avez déjà enregistré des configurations de test d'instrumentation dans votre projet, elles utiliseront Gradle pour exécuter des tests sur votre appareil connecté. Vous pouvez créer une configuration de test d'instrumentation à l'aide de l'action de marge à côté de votre classe ou méthode de test, comme indiqué ci-dessous.

Lorsque vous exécutez vos tests d'instrumentation, vous pouvez vérifier qu'Android Studio utilise l'exécuteur de test Gradle en inspectant le résultat du test dans le résultat de la tâche de matrice de test Gradle. Bien que nous améliorions cette fonctionnalité avec chaque version d'Android Studio, il existe certains problèmes connus. Si vous rencontrez des problèmes, veuillez signaler un bug. Vous pouvez également désactiver le nouveau pipeline de test pour rétablir l'ancien comportement.

Android Emulator s'exécute à présent par défaut directement dans Android Studio

Android Emulator s'exécute par défaut directement dans Android Studio. Cela vous permet de conserver l'espace sur l'écran, de naviguer rapidement entre l'émulateur et la fenêtre de l'éditeur à l'aide de raccourcis clavier, et d'organiser le workflow de l'IDE et de l'émulateur dans une seule fenêtre d'application.

Lorsque l'émulateur est en cours d'exécution, vous avez accès aux actions courantes de l'émulateur, comme la rotation, et aux options de contrôle étendues, comme la lecture de la navigation. Pour exécuter l'émulateur dans une fenêtre distincte, accédez à Fichier > Paramètres > Outils > Émulateur (Android Studio > Préférences > Outils > Émulateur sur macOS) et désélectionnez Lancer dans une fenêtre d'outil.

Désactiver le nouveau pipeline de test

Par défaut, Android Studio Bumblebee utilise Gradle pour exécuter ses tests d'instrumentation. Si vous rencontrez des problèmes, procédez comme suit pour désactiver ce comportement :

1. Sélectionnez Fichier > Paramètres > Compilation, exécution, déploiement > Test (ou Android Studio > Préférences > Compilation, exécution, déploiement > Test) sous MacOS.
2. Décochez la case Exécuter des tests d'instrumentation Android à l'aide de Gradle, puis cliquez sur OK.

Vous pouvez également rétablir les anciens comportements en procédant de l'une des façons suivantes :

• Lorsque vous exécutez des tâches Gradle à partir de la ligne de commande, utilisez le paramètre de ligne de commande suivant : -Pandroid.experimental.androidTest.useUnifiedTestPlatform=false
• Ajoutez le paramètre suivant au fichier gradle.properties de votre projet : android.experimental.androidTest.useUnifiedTestPlatform=false

Pour nous aider à résoudre les problèmes que vous pouvez rencontrer, veuillez signaler un bug.

Nouveau gestionnaire d'appareils

Le Gestionnaire d'appareils remplace AVD Manager, à la fois depuis l'écran d'accueil d'Android Studio ou après l'ouverture d'un projet. Le Gestionnaire d'appareils introduit de nouvelles fonctionnalités qui vous permettent de créer et de gérer plus facilement tous vos appareils de test locaux, tels que :

• Une interface utilisateur plus flexible qui peut être ancrée dans l'IDE, flottante ou dans une fenêtre distincte, comme c'est le cas avec d'autres fenêtres d'outils Android Studio. Vous pouvez ainsi accéder plus facilement à vos appareils sans entraver d'autres fenêtres de l'IDE.
• L'onglet Virtuel qui vous permet de créer, de gérer et de déployer des appareils virtuels, de consulter les détails de chaque appareil en un coup d'œil ou d'inspecter rapidement l'appareil dans l'Explorateur de fichiers de l'appareil.
• L'onglet Physique qui vous permet d'associer rapidement un nouvel appareil à l'aide d'ADB Wifi et de consulter les détails de chaque appareil physique en un coup d'œil. Vous pouvez également inspecter rapidement le système de fichiers de chaque appareil à l'aide de l'Explorateur de fichiers de l'appareil d'un simple clic.

Pour ouvrir le nouveau Gestionnaire d'appareils, effectuez l'une des opérations suivantes :

• Sur l'écran d'accueil d'Android Studio, sélectionnez Autres actions > Gestionnaire d'appareils virtuels.

• Après avoir ouvert un projet, sélectionnez Vue > Fenêtres d'outil > Gestionnaire d'appareils dans la barre de menu principale.

Détection d'à-coups dans l'UI

Lors du profilage de votre application à l'aide d'appareils exécutant Android 11 (niveau d'API 30) ou version ultérieure, le profileur de processeur affiche maintenant un nouveau groupe de pistes illustrant les étapes de chaque image sous Cycle de vie des images : Application, Attendre le GPU, Composition et Images à l'écran. Chaque piste attribue aux images un numéro d'image et au rectangle une couleur afin que vous puissiez facilement voir la position d'une image dans son cycle de vie, ainsi que des guides que vous pouvez activer ou désactiver pour comparer des événements Vsync. Vous pouvez utiliser ces données pour comprendre où les à-coups peuvent se produire dans votre application et pour en identifier les causes possibles. Le panneau Analyse contient à présent un onglet Images, qui résume les informations de rendu pour toutes les images. Pour en savoir plus, consultez Détection des à-coups dans l'interface utilisateur.

Prise en charge du profilage des applications profilables

Lors du profilage de votre application, il est important de générer des données précises avec la version de votre application qui se rapproche le plus de celle que vos utilisateurs installeront. Pour ce faire, vous pouvez à présent inclure la propriété <profileable> dans le fichier manifeste de votre application pour profiler les applications qui ne sont pas débogables, comme illustré par le code suivant.

<profileable android:shell="true"/>

Profileable est une configuration de fichier manifeste introduite dans Android 10. Elle est disponible pour les tâches de profilage du processeur et de la mémoire. L'utilisation de l'indicateur profileable au lieu de l'indicateur debuggable présente l'avantage clé de diminuer les coûts pour mesurer les performances. Cependant, certaines fonctionnalités de profilage ne sont pas disponibles pour les builds Profileable, telles que la chronologie des événements, le profilage de processeur initié par l'API, les vidages de mémoire ou les enregistrements d'emplacements en direct. Pour en savoir plus, consultez Applications de profileable.

Réduire les cadres de pile d'appel

Vous pouvez à présent réduire les cadres qui ne sont pas pertinents pour votre enquête lorsque vous inspectez un enregistrement d'échantillon de pile d'appel dans la fenêtre d'outil Profileurs. Les piles d'appel sont utiles pour comprendre quelle partie du code a été exécutée et la raison de l'appel. Toutefois, la pile d'appel d'un programme Java/Kotlin inclut généralement non seulement du code Java/Kotlin, mais aussi des cadres de code natif qui peuvent être gênants. Pour savoir comment affiner la vue de la pile d'appel, consultez Inspecter des cadres de pile d'appel.

Versions de correctif

Voici une liste des versions de correctif dans Android Studio Bumblebee.

Android Studio Bumblebee | 2021.1.1 Correctif 3 (avril 2022)

Cette mise à jour mineure inclut les corrections de bugs suivantes :

• Plug-in Android Gradle
  • Problèmes de classe en double signalés par R8
• Variantes de compilation
  • versionNameSuffix ne fonctionne plus si le nom de version de la variante est défini via la nouvelle API onVariants
• Aperçu de Compose
  • Corrections de bugs liés aux performances et à la stabilité.
  • Résolvez le blocage qui se produisait occasionnellement lors de l'utilisation de la fonctionnalité Modification en temps réel de littéraux.
• Outil d'inspection du réseau
  • Le nouvel outil d'inspection du réseau plante après la mise à jour de Bumblebee.
  • Ce message d'erreur s'affiche en permanence lorsque le débogueur est connecté à la dernière version d'Android Studio.
  • TrackedHttpURLConnection.getHeaderField plante avec NullPointerException

Android Studio Bumblebee | 2021.1.1 Correctif 2 (février 2022)

Cette mise à jour inclut les corrections de bugs suivantes :

• Build C++
  • ModelCache.safeGet(androidProjectResult.androidProject::getNdkVersion, "") ne doit pas être nul
• Éditeur de code
  • Bug dans les modèles en direct d'Android Studio : l'expression className() ne résout pas le nom de classe
• D8/R8
  • java.lang.NoSuchMethodError : sans méthode statique $jacocoInit
  • Couverture des tests Android interrompue en raison d'une erreur de Mockito
  • Besoin d'une solution pour l'implémentation CAS défectueuse sur l'API 31
  • Les classes scellées ne sont pas acceptées
  • NullPointerException lorsque la fusion de classes horizontales est activée dans Chrome
  • abstractionMethodError après la fusion d'une méthode virtuelle
  • Échec de la vérification des blocs de pile car le type init de la classe est incorrect
  • L'entrée Dex utilise un registre non défini
  • Échec de StringBuilderOptimizerAnalysisTest sur les branches de la version
  • Non-déterminisme dans R8
• Déploiement
  • Échec de l'exécution du projet d'une application propriétaire de l'appareil avec le message d'erreur "Impossible d'arrêter le processus existant pour"
• Outils de conception
  • Les aperçus Compose ne trouvent pas les ressources d'autres modules lorsque les classes R non transitives sont activées
  • Studio se fige lors de la compilation.
• Émulateur intégré
  • Diverses améliorations des performances et de la stabilité.
• Importation/Synchronisation
  • Erreur IDE lors du lancement de Bumblebee : le fichier de compilation de la fiche de sortie n'est pas disponible pour le type de sortie Apk dans IdeBuildTasksAndOutputInformationImp
• IntelliJ
  • Variables d'environnement non extraites lors du lancement à partir de la station d'accueil Mac OS X Monterey
• Jetpack (androidx) > Navigation
  • Mise à niveau de SafeArgs pour utiliser la dernière version stable d'AGP
• Fenêtres d'outils
  • Impossible d'exécuter le Gestionnaire d'appareils Android
  • L'outil d'inspection du réseau de Bumblebee n'affiche pas la réponse de l'API dans un format lisible

Android Studio Bumblebee | 2021.1.1 Correctif 1 (février 2022)

Cette mise à jour mineure inclut les corrections de bugs suivantes :

• Émulateur
  • Impossible de se connecter à l'émulateur intégré après la mise à niveau vers Bumblebee (Mac M1)
• IntelliJ
  • Variables d'environnement non extraites lors du lancement à partir de la station d'accueil Mac OS X Monterey

Pour en savoir plus, consultez cet article de blog sur Android Studio Bumblebee Correctif 1.

Android Studio Arctic Fox | 2020.3.1

Android Studio Arctic Fox est une version majeure qui inclut les fonctionnalités et améliorations ci-dessous.

Nouvelle numérotation de version

Mise à jour de la numérotation de version pour Android Studio

Nous avons modifié le système de numérotation de version d'Android Studio pour qu'il corresponde plus précisément à IntelliJ IDEA, l'IDE sur lequel repose Android Studio.

Dans le système de numérotation précédent, cette version aurait été numérotée Android Studio 4.3 ou version 4.3.0.1. Avec le nouveau système de numérotation, on utilise à présent Android Studio - Arctic Fox | 2020.3.1 ou version 2020.3.1.

À l'avenir, le numéro de version d'Android Studio sera déterminé comme suit :

<Year of IntelliJ Version>.<IntelliJ major version>.<Studio major version>.<Studio minor/patch version>

• Les deux premiers groupes de nombres représentent la version de la plate-forme IntellIj sur laquelle repose une version spécifique d'Android Studio. Dans ce cas, il s'agit de la version 2020.3.
• Le troisième groupe de nombres représente la version majeure de Studio, qui commence par 1 et est incrémentée d'une unité pour chaque version majeure.
• Le quatrième groupe de nombres représente la version mineure/corrective de Studio, qui commence par 1 et est incrémentée d'une unité pour chaque version mineure.
• Nous attribuons également à chaque version majeure un nom de version basé sur un nom d'animal, incrémenté de A à Z. Cette version est nommée Arctic Fox.

Mise à jour de la numérotation de version pour le plug-in Android Gradle

Nous avons modifié la numérotation des versions du plug-in Android Gradle (AGP) afin qu'il corresponde plus précisément à l'outil de compilation Gradle sous-jacent. Par conséquent, la prochaine version après AGP 4.2 sera AGP 7.0.

Pour en savoir plus, consultez Modifications apportées à la gestion des versions dans les notes de version d'AGP.

Plug-in Android Gradle 7.0.0

La dernière version du plug-in Android Gradle comprend de nombreuses mises à jour. Pour en savoir plus, consultez les notes de version complètes du plug-in Android Gradle.

Les tests unitaires utilisent à présent l'exécuteur de test Gradle

Pour améliorer la cohérence globale des exécutions de test, Android Studio utilise maintenant Gradle pour exécuter tous les tests unitaires par défaut. Dans de nombreux cas, cette modification n'affectera pas votre workflow de test dans l'IDE.

Par exemple, lorsque vous cliquez sur la commande Run dans le menu contextuel (visible par un clic droit sur une classe de test) ou sur l'action de marge correspondante , Android Studio utilisera par défaut la configuration d'exécution Gradle pour exécuter les tests unitaires.

Toutefois, Android Studio ne reconnaît plus les configurations d'exécution existantes Android JUnit. Vous devez donc migrer les configurations d'exécution Android JUnit que vous pouvez enregistrer en tant que fichiers de projet vers les configurations d'exécution Gradle.

Pour créer une configuration de test Gradle, sélectionnez le modèle Gradle en suivant les instructions dans Créer une configuration d'exécution/de débogage. Lorsque vous créez une configuration, celle-ci apparaît dans la boîte de dialogue Modifier les configurations de la section Gradle :

Si vous souhaitez inspecter des configurations Android JUnit qui ne sont plus reconnues, vous pouvez effectuer l'une des deux opérations suivantes :

• Ouvrez les configurations enregistrées manuellement dans un éditeur de texte. L'emplacement de ces fichiers est spécifié par l'utilisateur, mais ils apparaissent généralement dans <my-app>/.idea/runConfigurations/.

• Recherchez des configurations temporaires dans <my-app>/.idea/workspace.xml et regardez sous le nœud <component name="RunManager" ...>. Par exemple :

  <component name="RunManager" selected="Gradle.PlantTest">
  …
  <configuration name="PlantTest" type="AndroidJUnit" factoryName="Android JUnit" nameIsGenerated="true">
        <module name="Sunflower.app" />
        <useClassPathOnly />
        <extension name="coverage">
          <pattern>
            <option name="PATTERN" value="com.google.samples.apps.sunflower.data.*" />
            <option name="ENABLED" value="true" />
          </pattern>
        </extension>
        <option name="PACKAGE_NAME" value="com.google.samples.apps.sunflower.data" />
        <option name="MAIN_CLASS_NAME" value="com.google.samples.apps.sunflower.data.PlantTest" />
        <option name="METHOD_NAME" value="" />
        <option name="TEST_OBJECT" value="class" />
        <option name="PARAMETERS" value="" />
        <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
        <method v="2">
          <option name="Android.Gradle.BeforeRunTask" enabled="true" />
        </method>
      </configuration>
  

Nouveau Background Task Inspector

Vous pouvez visualiser, surveiller et déboguer les nœuds de calcul en arrière-plan de votre application à l'aide du nouveau Background Task Inspector. Pour commencer, déployez votre application sur un appareil exécutant la bibliothèque WorkManager 2.5.0 ou version ultérieure, puis sélectionnez Vue > Fenêtres d'outil > Inspection des applications dans la barre de menu.

Vous pouvez afficher des informations plus détaillées en cliquant sur un nœud de calcul. Par exemple, vous pouvez voir la description du nœud de calcul, la manière dont il a été exécuté, les détails de sa chaîne de nœuds de calcul et le résultat de son exécution.

Vous pouvez également voir une représentation visuelle d'une chaîne de nœuds de calcul en sélectionnant un nœud de calcul dans la table, puis en cliquant sur Afficher la vue graphique dans la barre d'outils. Vous pouvez ensuite sélectionner un nœud de calcul de la chaîne pour afficher ses détails, ou l'arrêter s'il est actuellement en file d'attente ou en cours d'exécution. Pour revenir à la table, cliquez sur Afficher la vue en liste .

Pour vous aider à enquêter sur les problèmes des nœuds de calcul avec des erreurs d'exécution, vous pouvez arrêter un nœud de calcul en cours d'exécution ou en file d'attente en le sélectionnant dans la table et en cliquant sur Annuler le nœud de calcul sélectionné dans la barre d'outils. Vous pouvez également filtrer les nœuds de calcul de la table en fonction des tags que vous leur avez attribués à l'aide du menu déroulant Tous les tags.

Mise à jour de l'outil d'inspection de bases de données

L'outil d'inspection de bases de données est maintenant inclus dans la nouvelle fenêtre d'outil Inspection des applications, où se trouve également le nouveau Background Task Inspector. Ouvrez la fenêtre d'outil Inspection des applications à partir de la barre des fenêtres d'outils ou sélectionnez Vue > Fenêtres d'outil > Inspection des applications dans la barre de menu.

Exporter des données à partir de l'outil d'inspection de bases de données

Dans Arctic Fox, vous pouvez facilement exporter des bases de données, des tables et des résultats de requête à partir de l'outil d'inspection de bases de données pour les enregistrer, les partager ou les recréer localement. Lorsque vous ouvrez un projet d'application dans Android Studio et que vous inspectez l'application pour ce projet dans l'outil d'inspection de bases de données, vous pouvez commencer à exporter des données de l'une des manières suivantes :

• Sélectionnez une base de données ou une table dans le panneau Bases de données, puis cliquez sur Exporter dans un fichier en haut du panneau.
• Effectuez un clic droit sur une base de données ou une table dans le panneau Bases de données, puis sélectionnez Exporter vers un fichier dans le menu contextuel.
• Lorsque vous inspectez les résultats d'une table ou d'une requête dans un onglet, cliquez sur Exporter dans un fichier au-dessus des résultats de la table ou de la requête.

Après avoir sélectionné une action d'exportation, utilisez la boîte de dialogue Exporter pour vous guider lors des dernières étapes, comme indiqué ci-dessous. Selon que vous essayez d'exporter une base de données, une table ou des résultats de requête, vous pouvez exporter les données dans un ou plusieurs des formats suivants : DB, SQL ou CSV.

Mise à jour de l'interface utilisateur pour l'enregistrement dans le Profileur de mémoire

Nous avons consolidé l'interface utilisateur du Profileur de mémoire pour différentes activités d'enregistrement, telles que la capture d'une empreinte de la mémoire et l'enregistrement des allocations de mémoire native, de Java et de Kotlin.

Le Profileur de mémoire propose les options suivantes :

• Capturer l'empreinte de la mémoire : affichez les objets de votre application qui utilisent la mémoire à un moment précis.
• Enregistrer des allocations natives : voyez comment chaque objet C/C++ a été alloué sur une période donnée.
• Enregistrer des allocations Java/Kotlin : voyez comment chaque objet Java/Kotlin a été alloué sur une période donnée.

Pour utiliser ces trois options, procédez comme suit :

• Pour capturer une empreinte de la mémoire, sélectionnez Capturer l'empreinte de la mémoire, puis Enregistrer. Une fois que le profileur a terminé la capture de l'empreinte de la mémoire, l'interface utilisateur du Profileur de mémoire passe à un écran distinct qui affiche l'empreinte de la mémoire.

  

• Pour enregistrer des allocations natives sur des appareils équipés d'Android 10 ou version ultérieure, sélectionnez Enregistrer des allocations natives, puis Enregistrer. L'enregistrement se poursuit jusqu'à ce que vous cliquiez sur Arrêter , après quoi l'interface utilisateur du Profileur de mémoire passe à un écran distinct affichant l'enregistrement natif.

  Sous Android 9 et version antérieure, l'option Enregistrer des allocations natives n'est pas disponible.

• Pour enregistrer des allocations Java et Kotlin, sélectionnez Enregistrer des allocations Java/Kotlin, puis Enregistrer. Si l'appareil est équipé d'Android 8 ou version ultérieure, l'interface utilisateur du Profileur de mémoire passe à un écran distinct affichant l'enregistrement en cours. Vous pouvez interagir avec la mini chronologie située au-dessus de l'enregistrement (par exemple, pour modifier la plage de sélection). Pour terminer l'enregistrement, sélectionnez Arrêter .

  

  Sur Android 7.1 et versions antérieures, le Profileur de mémoire utilise l'ancien enregistrement d'allocation, qui affiche l'enregistrement dans la chronologie jusqu'à ce que vous cliquiez sur Arrêter.

Mises à jour pour actualiser le projet C++ associé

Nous avons déplacé les fichiers sans rapport avec la configuration du dossier .cxx/ vers le dossier build/. Les builds CMake C++ nécessitent une phase de configuration qui génère le projet Ninja utilisé pour exécuter les étapes de compilation et d'association. Les projets générés par CMake sont coûteux et sont censés rester propres à Gradle. Pour cette raison, ils sont stockés dans un dossier appelé .cxx/, à côté du dossier build/. En règle générale, le plug-in Android Gradle détecte des modifications de configuration et regénère automatiquement le projet Ninja. Cependant, tous les cas ne sont pas détectés. Lorsque cela se produit, l'option Refresh Linked C++ Project (Actualiser le projet C++ associé) peut être utilisée pour regénérer manuellement le projet Ninja.

Nouvelle matrice de test pour les tests multi-appareils

Les tests d'instrumentation peuvent maintenant être exécutés sur plusieurs appareils en parallèle et peuvent être inspectés à l'aide d'un panneau spécialisé de résultats de test d'instrumentation. Ce panneau vous permet de déterminer si les tests échouent en raison du niveau d'API ou des propriétés matérielles.

Tester votre application sur une grande variété de niveaux d'API et de facteurs de forme est l'un des meilleurs moyens de garantir une expérience optimale à tous les utilisateurs de votre application.

Pour profiter de cette fonctionnalité :

1. Choisissez Sélectionner plusieurs appareils dans le menu déroulant des appareils cibles, en haut au centre de l'IDE.

   

2. Sélectionnez les appareils cibles, puis cliquez sur OK.

   

3. Exécutez vos tests.

Pour afficher les résultats du test dans le panneau Exécuter, accédez à Vue > Fenêtres d'outil > Exécuter.

Le nouveau panneau des résultats de test vous permet de filtrer les résultats par état, appareil et niveau d'API. Vous pouvez également trier chaque colonne en cliquant sur l'en-tête. En cliquant sur un test individuel, vous pouvez afficher les journaux et les informations individuellement pour chaque appareil.

Compatibilité de StateFlow avec la liaison de données

Pour les applications Kotlin qui utilisent des coroutines, vous pouvez maintenant utiliser des objets StateFlow comme source de liaison de données pour informer automatiquement l'UI des modifications apportées aux données. Vos liaisons de données seront sensibles au cycle de vie et ne seront déclenchées que lorsque l'interface utilisateur sera visible à l'écran.

Pour utiliser un objet StateFlow avec votre classe de liaison, vous devez spécifier un propriétaire de cycle de vie pour définir la portée de l'objet StateFlow et, dans votre mise en page, attribuer les propriétés et les méthodes de votre composant ViewModel aux vues correspondantes à l'aide d'expressions de liaison, comme illustré dans l'exemple suivant :

class ViewModel() {
   val username: StateFlow<String>
}

<TextView
    android:id="@+id/name"
    android:text="@{viewmodel.username}" />

Si l'application Kotlin utilise AndroidX, la compatibilité de StateFlow est automatiquement incluse dans les fonctionnalités de liaison de données, y compris les dépendances des coroutines.

Pour en savoir plus, consultez Utiliser des objets de données observables.

Amélioration de l'importation suggérée

Nous avons amélioré le nombre de bibliothèques compatibles avec la fonctionnalité d'importation suggérée et mettons à jour l'index plus souvent. L'importation suggérée vous permet d'importer rapidement et facilement certains artefacts Google Maven dans votre classe et dans votre projet Gradle. Lorsque Android Studio détecte des symboles non résolus de certaines bibliothèques Google, l'IDE suggère d'importer la bibliothèque à la fois dans la classe et dans le projet.

Compatibilité avec le cache de configuration dans Build Analyzer

Build Analyzer identifie à présent lorsqu'un projet n'a pas activé le cache de configuration et le propose comme optimisation. Build Analyzer effectue une évaluation de la compatibilité pour vous informer des problèmes de cache de configuration dans votre projet avant son activation.

Amélioration de l'assistant de mise à niveau pour AGP

L'assistant de mise à niveau du plug-in Android Gradle dispose maintenant d'une fenêtre d'outil persistante avec la liste des étapes qui vont être effectuées. Des informations supplémentaires sont également affichées dans la partie droite de la fenêtre d'outil. Si nécessaire, vous pouvez également choisir une autre version d'AGP pour la mise à niveau. Cliquez sur le bouton Actualiser pour mettre à jour les étapes de mise à jour correspondantes.

Refactorisation pour les classes R non transitives

Vous pouvez utiliser des classes R non transitives avec le plug-in Android Gradle pour créer des builds plus rapides pour les applications comportant plusieurs modules. Cela permet d'éviter la duplication des ressources en garantissant que la classe R de chaque module ne contient que des références à ses propres ressources, sans extraire de références de ses dépendances. Cela permet d'obtenir des builds plus à jour et les avantages qui découlent de l'évitement de la compilation.

Vous pouvez accéder à cette fonctionnalité en accédant à Refactoriser > Migrer vers des classes R non transitives.

Compatibilité avec les outils Jetpack Compose

Nous proposons à présent une compatibilité supplémentaire pour la prévisualisation et le test des applications qui utilisent Jetpack Compose. Pour bénéficier d'une expérience de développement optimale avec Jetpack Compose, vous devez utiliser la dernière version d'Android Studio Arctic Fox afin de pouvoir bénéficier des fonctionnalités d'éditeur intelligent, telles que les modèles de nouveau projet et la possibilité de prévisualiser immédiatement votre UI Compose.

Aperçu de Compose

Les paramètres suivants des méthodes @Preview sont à présent disponibles :

• showBackground : activez et désactivez l'arrière-plan de votre aperçu.
• backgroundColor : définissez une couleur qui n'est utilisée que dans la surface d'aperçu.
• uiMode : ce nouveau paramètre peut utiliser n'importe quelle constante Configuration.UI_* et vous permet de modifier le comportement de l'aperçu pour, par exemple, le définir sur le mode nuit afin de voir comment le thème réagit.

Aperçu interactif

Vous pouvez utiliser cette fonctionnalité pour interagir avec vos composants d'UI, cliquer dessus et voir comment l'état change. Elle permet d'obtenir rapidement des commentaires sur les réactions de votre UI et de prévisualiser les animations. Pour l'activer, cliquez sur l'icône interactif . L'aperçu changera de mode.

Pour l'arrêter, cliquez sur Arrêter l'aperçu interactif dans la barre d'outils supérieure.

Déployer sur un appareil

Vous pouvez utiliser cette fonctionnalité pour déployer un extrait de votre interface utilisateur sur un appareil. Cela permet de tester de petites parties de votre code dans l'appareil sans avoir à démarrer l'application complète.

Cliquez sur l'icône Déployer sur l'appareil à côté de l'annotation @Preview ou en haut de l'aperçu. Android Studio déploiera @Preview sur votre appareil ou votre émulateur connecté.

Modification en temps réel de littéraux

Nous avons ajouté la Modification en temps réel de littéraux pour aider les développeurs qui utilisent Compose à modifier rapidement des littéraux (chaînes, nombres, booléens) dans leur code et à afficher les résultats immédiatement, sans avoir à attendre la compilation. Cette fonctionnalité a pour objectif de vous aider à accroître votre productivité en permettant aux modifications de code d'apparaître presque instantanément dans les aperçus, l'émulateur ou l'appareil physique.

Compatibilité avec Compose dans l'outil d'inspection de la mise en page

L'outil d'inspection de la mise en page vous permet d'obtenir des informations détaillées sur la mise en page de votre application en cours d'exécution sur votre appareil connecté. Vous pouvez interagir avec votre application et voir les mises à jour en direct dans l'outil pour déboguer rapidement les problèmes qui peuvent survenir.

Vous pouvez inspecter les mises en page écrites avec le nouveau framework d'UI déclaratif d'Android, Jetpack Compose. Que votre application utilise des mises en page entièrement écrites dans Compose ou des mises en page hybrides écrites dans Compose et View, l'outil d'inspection de la mise en page vous aide à comprendre comment vos mises en page s'affichent sur votre appareil en cours d'exécution.

Premiers pas

Pour commencer, déployez votre application sur un appareil connecté, puis ouvrez la fenêtre de l'outil d'inspection de la mise en page en sélectionnant Vue > Fenêtres d'outil > Outil d'inspection de la mise en page. Si l'outil d'inspection de la mise en page ne se connecte pas automatiquement à votre processus d'application, sélectionnez le processus souhaité dans la liste déroulante. La mise en page de votre application devrait bientôt s'afficher dans la fenêtre de l'outil. Pour commencer à inspecter votre mise en page Compose, sélectionnez le composant de mise en page visible dans le rendu ou sélectionnez-le dans l'arborescence des composants.

La fenêtre Attributs affiche des informations détaillées sur la fonction Compose actuellement sélectionnée. Dans cette fenêtre, vous pouvez inspecter les paramètres de la fonction et leurs valeurs, y compris les modificateurs et les expressions lambda. Pour les expressions lambda, l'outil d'inspection fournit un raccourci pour vous aider à accéder à l'expression dans votre code source.

L'outil d'inspection de la mise en page affiche toutes les fonctions Compose de la pile d'appel qui génèrent des composants pour la mise en page de votre application. Dans de nombreux cas, cela inclut les fonctions Compose appelées en interne par la bibliothèque Compose. Si vous ne souhaitez afficher que les fonctions Compose dans l'arborescence des composants que votre application appelle directement, cliquez sur l'action de filtrage . Cela peut vous aider à réduire le nombre de nœuds affichés dans l'arborescence à ceux que vous voudrez probablement examiner.

Amélioration du menu déroulant de déploiement

Le menu déroulant des appareils fait à présent la distinction entre les différents types d'erreurs dans la configuration d'appareil que vous avez choisie. L'iconographie et les changements stylistiques font maintenant la différence entre les erreurs (sélections d'appareils qui entraînent une configuration défectueuse) et les avertissements (sélections d'appareils pouvant entraîner un comportement inattendu, mais qui sont toujours exécutables).

En outre, Android Studio vous avertit si vous tentez de lancer votre projet sur un appareil auquel une erreur ou un avertissement est associé.

Nouvel assistant d'association Wear OS

Le nouvel assistant d'association Wear OS guide les développeurs pas à pas dans l'association des émulateurs Wear OS à des téléphones physiques ou virtuels directement dans Android Studio. L'assistant peut vous aider à installer la bonne application associée Wear OS sur votre téléphone et à établir la connexion entre les deux appareils. Pour commencer, accédez au menu déroulant des appareils, puis sélectionnez Assistant d'association de l'émulateur Wear OS.

Modèle de mise en page responsif

Android Studio Arctic Fox inclut maintenant un nouveau modèle de mise en page qui s'adapte aux différentes dimensions d'affichage et au redimensionnement des applications, comme les téléphones, les pliables, les tablettes et les modes d'écran partagé. Lors de la création d'un projet ou d'un module, sélectionnez le modèle "Activité responsive" pour créer une mise en page avec des composants qui sont redimensionnés de manière dynamique.

Pour commencer, accédez à Fichier > Nouveau, sélectionnez Nouveau projet ou Nouveau module, puis sélectionnez le modèle Activité responsive.

Problèmes connus avec Arctic Fox

Cette section décrit les problèmes connus dans Android Studio Arctic Fox.

Les correctifs ne fonctionnent pas sous Windows pour les versions 3.6 à 4.1

Les correctifs de la plate-forme Windows pour les versions 3.6 à 4.1 pour Android Studio Arctic Fox stable risquent de ne pas fonctionner.

4.2 (avril 2021)

Android Studio 4.2 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Plug-in Android Gradle 4.2.0

La dernière version du plug-in Android Gradle comprend de nombreuses mises à jour. Pour en savoir plus, consultez les notes de version complètes du plug-in Android Gradle.

Compatibilité avec Gradle et modifications de configuration

Lorsqu'il s'exécute dans Android Studio, l'outil de compilation Gradle utilise le JDK fourni par Studio. Dans les versions précédentes, le JDK 8 était fourni avec Studio. Dans la version 4.2, cependant, JDK 11 est à présent fourni à la place. L'utilisation du nouveau JDK fourni pour exécuter Gradle peut entraîner une incompatibilité ou une incidence sur les performances de la JVM en raison de modifications apportées au récupérateur de mémoire. Ces problèmes sont décrits dans les notes de version d'AGP.

Option permettant d'optimiser le temps de synchronisation Gradle

Pour améliorer les performances de la synchronisation Gradle, Android Studio ignore la compilation de la liste des tâches lors de la synchronisation. Cela permet à la synchronisation Gradle de se terminer plus rapidement et améliore la réactivité de l'interface utilisateur pour les projets très volumineux. Cette option est activée par défaut dans Android Studio 4.2. Pour la désactiver, accédez à Fichier > Paramètres > Expérimental (Préférences > Expérimental sur Mac) et décochezNe pas créer de liste de tâches Gradle pendant la synchronisation Gradle.

Outil d'inspection de bases de données

Améliorations apportées à l'Éditeur de requête

L'outil d'inspection de bases de données comporte certaines améliorations pour vous aider à écrire et à exécuter vos instructions SQL personnalisées. Lorsque vous ouvrez l'inspecteur et que vous ouvrez un onglet Nouvelle requête, vous devez remarquer une surface d'éditeur plus grande et redimensionnable, permettant de créer et de mettre en forme vos requêtes, comme indiqué ci-dessous.

De plus, nous fournissons maintenant un historique de vos requêtes précédentes. Lorsque vous cliquez sur le bouton Afficher l'historique des requêtes , une liste des requêtes que vous avez précédemment exécutées sur la base de données sélectionnée doit s'afficher. Cliquez sur une requête de la liste pour afficher un aperçu de la requête complète dans l'éditeur, puis appuyez sur Entrée pour la copier dans l'éditeur. Cliquez ensuite sur Exécuter pour exécuter l'instruction.

Mode hors connexion

Dans les versions précédentes d'Android Studio, la déconnexion d'un processus d'application lors de l'utilisation de l'outil d'inspection de bases de données entraînait la fermeture de l'outil d'inspection et de ses données. Dans Android Studio 4.2, nous avons ajouté la possibilité de continuer à inspecter les bases de données de votre application après la déconnexion d'un processus, afin de faciliter le débogage de votre application après un plantage.

En cas de déconnexion, l'outil d'inspection de bases de données télécharge vos bases de données, puis les met à votre disposition en mode hors connexion. En mode hors connexion, vous pouvez ouvrir des tables et exécuter des requêtes.

N'oubliez pas que, lorsque vous vous reconnectez à un processus d'application en direct, l'outil d'inspection de bases de données repasse en mode en direct et n'affiche que les données stockées sur l'appareil. Autrement dit, les données affichées en mode hors connexion ne sont pas conservées lorsque vous vous reconnectez à un processus d'application. De ce fait, l'outil d'inspection de bases de données ne permet pas de modifier ni d'exécuter des instructions de modification en mode hors connexion.

Assistant de mise à niveau pour AGP

Le nouvel assistant de mise à jour du plug-in Android Gradle peut vous aider à mettre à jour la version AGP de votre projet.

Cet outil, basé sur la fonctionnalité de mise à niveau AGP existante, vous guide tout au long des mises à jour/refactorisations d'un projet et inclut un aperçu des mises à jour pour éviter d'éventuelles modifications destructives avant l'exécution de la mise à niveau AGP.

Trace système : amélioration des métriques pour la mémoire et les graphiques

Dans le Profileur de processeur, la fonctionnalité Trace système comprend à présent de nouvelles métriques pour analyser les performances des applications et inclut les éléments suivants :

• Tableau des événements. Présente tous les événements de trace du thread actuellement sélectionné.

• BufferQueue. Dans la section "Affichage", cette nouvelle piste affiche le nombre de tampons de la surface BufferQueue de l'application (0, 1 ou 2) pour vous aider à comprendre l'état des tampons d'image lorsqu'ils se déplacent entre les composants graphiques Android.

  

• Fréquence du processeur. Dans la section "Cœurs de processeur", cette nouvelle piste affiche la fréquence de processeur par cœur, ce qui indique le degré de fonctionnement de chaque cœur.

  

• Mémoire de processus (RSS). Cette nouvelle fenêtre affiche la quantité de mémoire physique actuellement utilisée par l'application.

  

Pour en savoir plus, consultez Inspecter l'activité du processeur avec le Profileur de processeur.

Nouvelle action d'actualisation de l'outil d'inspection de la mise en page

Introduit dans Android Studio 4.0, l'outil d'inspection de la mise en page a été conçu pour inspecter en temps réel la pile d'interface utilisateur de votre application en cours d'exécution. Cependant, vous ne souhaitez pas toujours que l'outil d'inspection de la mise en page reflète immédiatement ce qui se passe dans votre application. En effet, vous pouvez souhaiter inspecter un instantané de la mise en page de votre application à un moment précis ou réduire l'impact sur les performances des mises à jour en temps réel sur votre application.

Mettez en pause les mises à jour en direct et actualisez la capture d'écran dans l'outil d'inspection de la mise en page.

Pour charger manuellement un instantané des données de l'interface utilisateur à partir de votre application, désactivez d'abord l'option Mises à jour en direct. Vous pouvez ensuite cliquer sur le bouton Actualiser pour prendre un nouvel instantané de la pile d'interface utilisateur à inspecter. L'outil d'inspection de la mise en page mémorise maintenant votre préférence de laisser les mises à jour en direct activées ou désactivées entre les sessions.

Compatibilité avec Safe Args

Safe Args est un plug-in Gradle qui génère des classes simples d'objets et de compilateurs pour une navigation sécurisée et l'accès à tous les arguments associés. Android Studio offre à présent une compatibilité plus complète avec Safe Args, comme décrit ci-dessous :

• Saisies semi-automatiques pour Directions, Args et les différentes classes de compilateurs
• Compatibilité avec les plug-ins Safe Args de Java et Kotlin
• Navigation de la source vers le XML

Retrace R8 à présent disponible dans les outils de ligne de commande

Disponible dans la version 4.0 des outils de ligne de commande, Retrace R8 est un outil autonome permettant d'obtenir la trace de la pile d'origine à partir d'une trace de pile obscurcie.

Vous pouvez télécharger ce package à l'aide de SDK Manager qui installe Retrace R8 dans android_sdk/cmdline-tools. Vous pouvez aussi télécharger le package d'outils de ligne de commande autonome.

Pour en savoir plus sur l'utilisation, consultez la page Retrace R8 du guide de l'utilisateur.

Déployer sur plusieurs appareils

Pour simplifier les tests d'application sur les appareils et les niveaux d'API, vous pouvez à présent déployer votre application sur plusieurs appareils ou émulateurs simultanément en procédant comme suit :

1. Choisissez Sélectionner plusieurs appareils dans le menu déroulant des appareils cibles, en haut au centre de l'IDE.

   

2. Sélectionnez les appareils cibles, puis cliquez sur OK.

   

3. Exécutez votre application.

Nouveau paramètre removable pour les modules de fonctionnalités

Le plug-in Android Gradle 4.2 utilise bundletool 1.0.0, qui introduit un changement de comportement pour les applications utilisant des modules de fonctionnalités : tout module de fonctionnalité spécifié comme dist:install-time qui n'est pas explicitement marqué comme dist:removable ne peut plus être supprimé par défaut. Ce nouveau paramètre optimise la fusion des modules de temps d'installation avec le module de base, ce qui peut améliorer les performances de certaines applications.

Pour que les modules de fonctionnalités puissent être supprimés, définissez dist:removable="true" sur tous les modules que vous souhaitez désinstaller.

Pour plus d'informations sur ce nouveau paramètre, consultez la documentation sur le tag dist:removable dans la documentation du fichier manifeste du module de fonctionnalité.

Appliquer les modifications

Pour vous aider à être plus productif lors des itérations sur votre application, nous avons apporté les améliorations suivantes à la fonctionnalité "Appliquer les modifications" pour les appareils équipés d'Android 11 ou version ultérieure :

Compatibilité avec d'autres modifications du code

Pour les appareils équipés d'Android 11 ou version ultérieure, vous pouvez à présent ajouter des champs primitifs finaux statiques, puis déployer ces modifications dans votre application en cours d'exécution en cliquant sur Appliquer les modifications du code ou Appliquer les modifications et redémarrer l'activité.

Vous pouvez également ajouter des ressources et déployer ces modifications sur votre application en cours d'exécution sur les appareils Android 11 en cliquant sur Appliquer les modifications et redémarrer l'activité .

Mise à jour des assistants "Nouveau projet" et "Nouveau module"

Les assistants Nouveau projet et Nouveau module ont été mis à jour pour faciliter la navigation, la sélection d'un modèle et la saisie d'informations sur le nouveau projet ou le nouveau module.

L'option Importer un package .JAR/.AAR de l'assistant Nouveau module a également été supprimée. Pour importer un fichier JAR ou AAR dans votre projet, utilisez plutôt la boîte de dialogue "Structure du projet".

Kotlin 1.4.31

Android Studio 4.2 inclut Kotlin 1.4.31. Consultez le journal des modifications de Kotlin 1.4.0 pour passer en revue les modifications majeures.

Variable d'environnement ANDROID_SDK_HOME obsolète

La variable d'environnement ANDROID_SDK_HOME est obsolète et a été remplacée par ANDROID_PREFS_ROOT. Pour en savoir plus, consultez Variables d'environnement de l'émulateur.

Problèmes connus concernant Android Studio 4.2

Cette section décrit les problèmes connus d'Android Studio 4.2. Pour en obtenir la liste complète, accédez à la page Problèmes connus.

Android Studio 4.2.0 génère des projets associés avec la mauvaise version de Kotlin : "1.5.0-release-764"

Si vous utilisez Android Studio 4.2.0 et que vous avez migré vers le plug-in Kotlin 1.5.0, les projets Kotlin créés par Studio échoueront en raison de l'erreur de synchronisation Gradle suivante : Could not find org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.0-release-764.

Pour contourner ce problème, remplacez "1.5.0-release-764" par "1.5.0" dans les fichiers build.gradle du projet.

Erreur lors de l'utilisation de mots de passe différents pour la clé et le keystore

À partir de la version 4.2, Android Studio s'exécute maintenant sur JDK 11. Cette mise à jour entraîne un changement de comportement sous-jacent lié aux clés de signature.

Lorsque vous accédez à Build > Générer un bundle/APK signé et que vous essayez de configurer la signature d'application pour un app bundle ou un APK, la saisie de mots de passe différents pour la clé et le keystore peut entraîner l'erreur suivante :

Key was created with errors:
Warning: Different store and Key passwords not supported for PKCS12 Key stores

Pour contourner ce problème, saisissez le même mot de passe pour la clé et le keystore.

Android Studio ne démarre pas après l'installation de la version 4.2

Studio essaie d'importer les .vmoptions précédentes et de les nettoyer pour qu'elles fonctionnent avec le récupérateur de mémoire utilisé par JDK 11. Si ce processus échoue, l'IDE peut ne pas démarrer pour certains utilisateurs qui ont défini des options de VM personnalisées dans le fichier .vmoptions.

Pour contourner ce problème, nous vous recommandons de mettre en commentaire les options personnalisées dans .vmoptions (en utilisant le caractère "#"). Le fichier .vmoptions se trouve aux emplacements suivants :

Windows

C:\Users\YourUserName\AppData\[Local|Roaming]\Google\AndroidStudio4.2\studio64.exe.vmoptions

macOS

~/Library/Application Support/Google/AndroidStudio4.2/studio.vmoptions

Linux

~/.config/Google/AndroidStudio4.2/studio64.vmoptions

Si Studio ne démarre toujours pas après cette solution, consultez Studio ne démarre pas après la mise à niveau ci-dessous.

4.1 (août 2020)

Android Studio 4.1 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Plug-in Android Gradle 4.1.0

La dernière version du plug-in Android Gradle comprend de nombreuses mises à jour. Pour en savoir plus, consultez les notes de version complètes du plug-in Android Gradle.

Nouvel outil d'inspection de bases de données

Inspectez, interrogez et modifiez vos bases de données dans votre application en cours d'exécution à l'aide du nouvel outil d'inspection de bases de données. Pour commencer, déployez votre application sur un appareil exécutant le niveau d'API 26 ou supérieur, puis sélectionnez Vue > Fenêtres d'outil > Outil d'inspection de bases de données dans la barre de menu.

Pour en savoir plus, consultez Déboguer votre base de données avec l'outil d'inspection de bases de données.

Exécuter Android Emulator directement dans Android Studio

Vous pouvez maintenant exécuter Android Emulator directement dans Android Studio. Utilisez cette fonctionnalité pour conserver l'espace sur l'écran, naviguer rapidement entre l'émulateur et la fenêtre de l'éditeur à l'aide de raccourcis clavier, et pour organiser le workflow de l'IDE et de l'émulateur dans une seule fenêtre d'application.

Pour en savoir plus, consultez la documentation d'Android Emulator.

Utiliser des modèles TensorFlow Lite

La liaison de modèles de ML vous permet d'importer directement et facilement des fichiers de modèle .tflite et de les utiliser dans vos projets. Android Studio génère des classes faciles à utiliser afin que vous puissiez exécuter votre modèle avec moins de code et une meilleure sécurité des types.

Modèles compatibles

L'implémentation actuelle de la liaison de modèles de ML est compatible avec les modèles de classification d'images et de transfert de style, à condition qu'ils soient améliorés avec des métadonnées. Au fil du temps, la compatibilité sera étendue à d'autres domaines problématiques, tels que la détection d'objets, la segmentation d'images et la classification de texte.

Une large gamme de modèles pré-entraînés avec des métadonnées est fournie sur TensorFlow Hub. Vous pouvez également ajouter vous-même des métadonnées à un modèle TensorFlow Lite, comme indiqué dans Ajouter des métadonnées à un modèle TensorFlow Lite.

Importer un fichier de modèle

Pour importer un fichier de modèle compatible, procédez comme suit :

1. Ouvrez la boîte de dialogue d'importation de modèles TensorFlow Lite dans le menu Fichier dans Fichier > Nouveau > Autre > Modèle TensorFlow Lite.
2. Sélectionnez le fichier de modèle .tflite que vous avez téléchargé ou créé précédemment.
3. Cliquez sur Terminer.

Le fichier de modèle est alors importé dans votre projet et placé dans le dossier ml/. Si le répertoire n'existe pas, Android Studio le crée pour vous.

Afficher les métadonnées et l'utilisation du modèle

Pour afficher les détails d'un modèle importé et obtenir des instructions sur son utilisation dans votre application, double-cliquez sur le fichier de modèle de votre projet afin d'ouvrir la page de la visionneuse de modèles, qui affiche les éléments suivants :

• Modèle : description générale du modèle
• Tensors : description des Tensors d'entrée et de sortie
• Exemple de code : exemple d'interface avec le modèle dans votre application

Voici un exemple utilisant mobilenet_v1_0.25_160_quantized.tflite :

Comme le montre l'exemple, Android Studio crée une classe appelée MobilenetV1025160Quantized pour interagir avec le modèle.

Si le modèle ne comporte pas de métadonnées, cet écran ne fournit que des informations minimales.

Problèmes connus et solutions

• La compatibilité des modèles TensorFlow Lite pour les domaines problématiques autres que la classification d'images et le transfert de style est actuellement limitée. Même si l'importation devrait fonctionner correctement, certaines entrées et/ou sorties de modèles sont représentées par des TensorBuffers plutôt que des types conviviaux. Pour les modèles sans métadonnées, toutes les entrées et sorties du modèle sont des TensorBuffers.
• Les modèles dont les types de données d'entrée et de sortie sont différents de DataType.UINT8 ou DataType.FLOAT32 ne sont pas acceptés.

Cette fonctionnalité est en cours de développement. Veuillez donc envoyer des commentaires ou signaler des bugs.

Profileur de mémoire natif

Le Profileur de mémoire d'Android Studio inclut à présent un profileur de mémoire natif pour les applications déployées sur des appareils physiques exécutant Android 10 ou version ultérieure. Avec le Profileur de mémoire natif, vous pouvez enregistrer les allocations et désallocations de mémoire à partir du code natif et inspecter les statistiques cumulées sur les objets natifs.

Pour en savoir plus sur le format natif du Profileur de mémoire, consultez Inspecter l'utilisation de mémoire de votre application avec le Profileur de mémoire.

Problèmes connus et solutions

• Le Profileur de mémoire natif dans Android Studio 4.1 ne fonctionne pas pour les appareils Android 11. La compatibilité avec le profilage des appareils Android 11 est actuellement disponible dans la version preview 4.2.

• À partir de la version 4.1 initiale, le profilage de démarrage d'application a été désactivé. Cette option sera activée dans une prochaine version.

  En guise de solution, vous pouvez utiliser le profileur de ligne de commande autonome Perfetto pour capturer des profils de démarrage.

UI de Trace système : sélection plus facile, nouvel onglet d'analyse et plus de données de rendu d'image

L'UI de Trace système dans le profileur Android Studio inclut les améliorations suivantes :

• Sélection de zone : dans la section Threads, vous pouvez à présent faire glisser la souris pour sélectionner une zone rectangulaire sur laquelle vous pouvez zoomer en cliquant sur le bouton Zoomer sur la sélection en haut à droite (ou utilisez le raccourci clavier M). Lorsque vous glissez-déposez des threads similaires les uns à côté des autres, vous pouvez sélectionner plusieurs threads pour les inspecter tous en même temps. Par exemple, vous pouvez effectuer une analyse sur plusieurs threads de calcul.

  

• Onglet Résumé  : le nouvel onglet Résumé du panneau Analyse affiche ce qui suit :

  • Statistiques agrégées pour toutes les occurrences d'un événement spécifique, telles que le nombre d'occurrences et la durée minimale/maximale.
  • Statistiques d'événement de trace pour l'occurrence sélectionnée.
  • Données sur la distribution de l'état du thread.
  • Occurrences les plus longues de l'événement de trace sélectionné.

  

  Pour accéder à une autre occurrence, sélectionnez une autre ligne du tableau.

• Données dans Affichage : dans la section Affichage, les nouvelles chronologies pour SurfaceFlinger et VSYNC vous aident à résoudre les problèmes d'affichage dans l'interface utilisateur de votre application.

  

Pour obtenir des instructions d'utilisation de base sur la manière d'enregistrer une trace système, consultez la section Enregistrer les traces de Inspecter l'activité du processeur avec le Profileur de processeur.

Profileurs autonomes à présent disponibles

Grâce aux nouveaux profileurs autonomes, vous pouvez maintenant profiler votre application sans exécuter l'IDE Android Studio complet.

Pour obtenir des instructions sur l'utilisation des profileurs autonomes, consultez Exécuter des profileurs autonomes.

Prise en charge de la navigation Dagger

Android Studio facilite la navigation entre votre code lié à Dagger en fournissant de nouvelles actions de marge et en étendant la compatibilité dans la fenêtre Trouver les utilisations.

• Nouvelles actions de marge : pour les projets qui utilisent Dagger, l'IDE fournit des actions de marge qui vous aident à naviguer entre votre code annoté par Dagger. Par exemple, si vous cliquez sur l'action de marge à côté d'une méthode qui utilise un type donné, vous accédez au fournisseur de ce type. À l'inverse, le fait de cliquer sur l'action de marge vous permet d'accéder à l'emplacement d'un type utilisé comme dépendance.

• Trouver les utilisations : lorsque vous appelez Find Usages sur un fournisseur d'un type donné, la fenêtre Trouver inclut maintenant un nœud Consommateur(s) de dépendance qui présente les consommateurs de ce type. À l'inverse, lorsque vous appelez cette action sur un consommateur d'une dépendance injectée par Dagger, la fenêtre Trouver indique le fournisseur de cette dépendance.

Composants Material Design : thèmes et styles mis à jour dans les nouveaux modèles de projet

Les modèles Android Studio de la boîte de dialogue Créer un projet utilisent à présent des Composants Material Design (MDC) et sont conformes aux consignes mises à jour par défaut pour les thèmes et les styles. Les mises à jour suivantes ont été réalisées :

• MDC : les projets dépendent de com.google.android.material:material dans build.gradle.. Les thèmes d'application de base utilisent les parents Theme.MaterialComponents.* et ignorent la couleur MDC mise à jour et les attributs "on".
• Ressources de couleur : les ressources de couleur dans colors.xml utilisent des noms littéraux (par exemple, purple_500 au lieu de colorPrimary).
• Ressources de thème : les ressources de thème se trouvent dans themes.xml (au lieu de styles.xml) et utilisent des noms Theme.<ApplicationName>.
• Thème sombre : les thèmes d'application de base utilisent des parents DayNight et sont répartis entre res/values et res/values-night.
• Attributs de thème : les ressources de couleur sont référencées en tant qu'attributs de thème (par exemple, ?attr/colorPrimary) dans les mises en page et les styles afin d'éviter les couleurs codées en dur.

IntelliJ IDEA 2020.1

L'IDE principal d'Android Studio a été mis à jour avec des améliorations d'IntelliJ IDEA jusqu'à la version 2020.1, y compris une nouvelle fenêtre Commit qui permet les opérations de contrôle des versions et un nouveau mode Zen pouvant être activé/désactivé en sélectionnant Vue > Apparence > Entrer en mode sans distraction.

Pour en savoir plus sur les améliorations apportées à la version 2020.1, consultez la page suivante :

• IDEA 2020.1

Modifications du répertoire de configuration IDE

Les emplacements des répertoires de configuration utilisateur ont été modifiés comme suit :

Windows

Syntaxe : %APPDATA%\Google\<product><version>

Exemple : C:\Users\YourUserName\AppData\Roaming\Google\AndroidStudio4.1

macOS

Syntaxe : ~/Library/Application Support/Google/<product><version>

Exemple : ~/Library/Application Support/Google/AndroidStudio4.1

Linux

Syntaxe : ~/.config/Google/<product><version>

Exemple : ~/.config/Google/AndroidStudio4.1

Ces nouveaux emplacements de répertoire sont conformes aux mises à jour récentes d'IntelliJ IDEA, l'IDE sur lequel est basé Android Studio.

Kotlin 1.3.72

Android Studio 4.1 inclut Kotlin 1.3.72, qui comprend un certain nombre de correctifs permettant d'améliorer la mise en surbrillance, les inspections et la saisie automatique de code de Kotlin. Pour en savoir plus, consultez le journal des modifications de Kotlin 1.3.72.

Aperçu de la vue personnalisée

Lors de la création d'une vue personnalisée (par exemple, en étendant la classe View ou Button), Android Studio affiche maintenant un aperçu de votre vue personnalisée. Utilisez le menu déroulant de la barre d'outils pour basculer entre plusieurs vues personnalisées, ou cliquez sur les boutons pour encapsuler le contenu verticalement ou horizontalement.

Décodage des rapports d'erreur natifs

Lorsqu'un plantage ou une erreur ANR se produit dans le code natif, le système génère une trace de la pile, qui est un instantané de la séquence de fonctions imbriquées appelées dans votre programme jusqu'au moment du plantage. Ces instantanés peuvent vous aider à identifier et à résoudre les problèmes dans la source. Toutefois, ils doivent d'abord être décodés pour traduire les adresses des machines en noms de fonctions lisibles.

Si votre application ou votre jeu sont développés en code natif (en C++ par exemple), vous pouvez à présent importer des fichiers de décodage dans Play Console pour chaque version de votre application. Play Console utilise ces fichiers de décodage pour décoder les traces de la pile de votre application, et ainsi faciliter l'analyse des plantages et des erreurs ANR. Pour savoir comment importer des fichiers de décodage, consultez Prise en charge des plantages natifs.

Appliquer les modifications

Pour vous aider à être plus productif lors des itérations sur votre application, nous avons apporté les améliorations suivantes à la fonctionnalité "Appliquer les modifications" pour les appareils équipés d'Android 11 Preview développeur 3 ou version ultérieure :

Déploiement plus rapide

Nous avons beaucoup investi pour optimiser la vitesse d'itération en développant une méthode pour déployer et conserver les modifications sur un appareil sans installer l'application. Après un premier déploiement, les déploiements suivants effectués sur des appareils Android 11 à l'aide de Appliquer les modifications du code ou Appliquer les modifications et redémarrer l'activité sont maintenant beaucoup plus rapides.

Pour en savoir plus sur la différence entre ces deux actions, consultez Appliquer les modifications.

Compatibilité avec d'autres modifications du code

Pour les appareils équipés d'Android 11 Preview développeur 3 ou version ultérieure, vous pouvez à présent ajouter des méthodes, puis déployer ces modifications dans votre application en cours d'exécution en cliquant sur Appliquer les modifications du code ou Appliquer les modifications et redémarrer l'activité .

4.0 (mai 2020)

Android Studio 4.0 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Plug-in Android Gradle 4.0.0

La dernière version du plug-in Android Gradle inclut de nombreuses mises à jour, telles que le désucrage de Java 8 pour les anciennes versions d'Android et les dépendances entre fonctionnalités. Pour en savoir plus, consultez les notes de version complètes du plug-in Android Gradle.

De plus, Android Studio inclut maintenant de nouvelles fonctionnalités pour vous aider à améliorer les performances de compilation.

Build Analyzer

Lorsque vous utilisez Android Studio 4.0 avec le plug-in Android Gradle 4.0.0 et versions ultérieures, la fenêtre Build Analyzer vous aide à analyser et à diagnostiquer les problèmes liés à votre processus de compilation, tels que les optimisations désactivées et les tâches mal configurées. Pour ouvrir la fenêtre Build Analyzer, procédez comme suit :

1. Si vous ne l'avez pas déjà fait, créez votre application en sélectionnant Compilation > Créer un projet dans la barre de menu.
2. Sélectionnez Vue > Fenêtres d'outil > Compilation dans la barre de menu.
3. Dans la fenêtre Compilation, ouvrez la fenêtre Build Analyzer de l'une des façons suivantes :
   • Une fois qu'Android Studio a terminé de compiler votre projet, cliquez sur l'onglet Build Analyzer.
   • Une fois qu'Android Studio a terminé de compiler votre projet, cliquez sur le lien situé à droite de la fenêtre Résultat de compilation.

La fenêtre Build Analyzer organise les éventuels problèmes de compilation dans une arborescence à gauche. Vous pouvez examiner chaque problème et cliquer dessus pour examiner ses détails dans le panneau de droite. Quand Android Studio analyse votre compilation, il calcule l'ensemble des tâches qui ont déterminé la durée de la compilation et fournit une visualisation qui vous aide à comprendre l'impact de chacune de ces tâches. Vous pouvez également obtenir des détails sur les avertissements en développant le nœud Avertissements.

Inspection des tâches qui ont déterminé la durée de la compilation

Désucrage de la bibliothèque Java 8 dans D8 et R8

Android Studio permet à présent d'utiliser un certain nombre d'API de langage Java 8 sans nécessiter de niveau d'API minimal pour votre application.

Grâce à un processus appelé désucrage, le compilateur DEX, D8, d'Android Studio 3.0 et versions ultérieures était déjà compatible avec les fonctionnalités du langage Java 8 (telles que les expressions lambda, les méthodes d'interface par défaut, les tentatives avec des ressources, etc.). Dans Android Studio 4.0, le moteur de désucrage a été étendu de manière à pouvoir désucrer les API de langage Java. Cela signifie que vous pouvez maintenant inclure des API en langage standard qui n'étaient disponibles que dans les versions récentes d'Android (telles que java.util.streams) dans les applications compatibles avec d'anciennes versions.

L'ensemble d'API suivant est compatible avec cette version :

• Flux séquentiels (java.util.stream)
• Un sous-ensemble de java.time
• java.util.function
• Ajouts récents à java.util.{Map,Collection,Comparator}
• Options (java.util.Optional, java.util.OptionalInt et java.util.OptionalDouble) et autres nouvelles classes utiles avec les API ci-dessus
• Ajouts à java.util.concurrent.atomic (nouvelles méthodes sur AtomicInteger, AtomicLong et AtomicReference)
• ConcurrentHashMap (avec corrections de bugs pour Android 5.0)

Pour prendre en charge ces API de langage, D8 compile un fichier DEX de bibliothèque distinct qui contient une implémentation des API manquantes et l'inclut dans votre application. Le processus de désucrage réécrit le code de votre application pour utiliser à la place cette bibliothèque lors de l'exécution.

Pour activer la compatibilité avec ces API de langage, incluez les éléments suivants dans le fichier build.gradle de votre module d'application :

android {
    defaultConfig {
        // Required when setting minSdkVersion to 20 or lower
        multiDexEnabled true
    }

    compileOptions {
        // Flag to enable support for the new language APIs
        coreLibraryDesugaringEnabled true
        // Sets Java compatibility to Java 8
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.0.4'
}

android {
    defaultConfig {
        // Required when setting minSdkVersion to 20 or lower
        multiDexEnabled = true
    }

    compileOptions {
        // Flag to enable support for the new language APIs
        coreLibraryDesugaringEnabled = true
        // Sets Java compatibility to Java 8
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

dependencies {
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:1.0.4")
}

Notez que vous devrez peut-être également inclure l'extrait de code ci-dessus dans le fichier build.gradle d'un module de bibliothèque dans les cas suivants :

• Les tests d'instrumentation du module de bibliothèque utilisent ces API de langage (soit directement, soit via le module de bibliothèque ou ses dépendances). Cela permet de fournir les API manquantes pour votre APK de test d'instrumentation.

• Vous souhaitez exécuter lint sur le module de bibliothèque de manière isolée. Cela permet à lint d'identifier les utilisations valides des API de langage et d'éviter de signaler de faux avertissements.

Dépendances entre fonctionnalités

Dans les versions précédentes du plug-in Android Gradle, tous les modules de fonctionnalités pouvaient dépendre uniquement du module de base de l'application. Lorsque vous utilisez le plug-in Android Gradle 4.0.0 et versions ultérieures, vous pouvez à présent inclure un module de fonctionnalité qui dépend d'un autre module. Autrement dit, une fonctionnalité :video peut dépendre de la fonctionnalité :camera, qui dépend du module de base, comme illustré dans la figure ci-dessous.

Le module de fonctionnalité :video dépend de la fonctionnalité :camera, qui dépend du module :app de base.

Cela signifie que, lorsque votre application demande à télécharger un module de fonctionnalité, elle télécharge également d'autres modules de fonctionnalités dont elle dépend. Après avoir créé des modules de fonctionnalités pour votre application, vous pouvez déclarer une dépendance entre fonctionnalités dans le fichier build.gradle du module. Par exemple, le module :video déclare une dépendance à :camera comme suit :

// In the build.gradle file of the ':video' module.
dependencies {
    // All feature modules must declare a dependency
    // on the base module.
    implementation project(':app')
    // Declares that this module also depends on the 'camera' feature module.
    implementation project(':camera')
    ...
}

// In the build.gradle file of the ':video' module.
dependencies {
    // All feature modules must declare a dependency
    // on the base module.
    implementation(project(":app"))
    // Declares that this module also depends on the 'camera' feature module.
    implementation(project(":camera"))
    ...
}

En outre, vous devez activer la fonctionnalité de dépendance entre fonctionnalités dans Android Studio (pour l'activer lorsque vous modifiez la configuration d'exécution, par exemple). Pour cela, cliquez sur Aide > Modifier les options de VM personnalisées dans la barre de menu et incluez ce qui suit :

-Drundebug.feature.on.feature=true

Métadonnées de dépendances

Lors de la compilation de votre application à l'aide du plug-in Android Gradle 4.0.0 et versions ultérieures, le plug-in inclut des métadonnées décrivant les dépendances compilées dans votre application. Lorsque vous importez votre application, Play Console inspecte ces métadonnées pour vous présenter les avantages suivants :

• Recevoir des alertes de problèmes connus liés aux SDK et aux dépendances utilisés par votre application
• Recevoir des commentaires exploitables pour résoudre ces problèmes

Les données sont compressées, chiffrées par une clé de signature Google Play et stockées dans le bloc de signature de votre application de publication. Toutefois, vous pouvez inspecter vous-même les métadonnées dans les fichiers de compilation intermédiaires locaux dans le répertoire <project>/<module>/build/outputs/sdk-dependencies/release/sdkDependency.txt.

Si vous préférez ne pas partager ces informations, vous pouvez inclure les éléments suivants dans le fichier build.gradle de votre module :

android {
    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }
}

android {
    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }
}

Compatibilité avec les fichiers de script DSL Kotlin

Le plug-in Android Gradle est à présent compatible avec les fichiers de script de compilation Kotlin DSL (*.kts). Lorsqu'elles sont utilisées avec Android Studio, certaines fonctionnalités IDE, telles que la boîte de dialogue "Structure du projet" et les corrections rapides de script de compilation, sont à présent compatibles avec la lecture et l'écriture dans des fichiers de script de compilation Kotlin.

Mises à niveau du Profileur de processeur

Suite à vos commentaires, nous avons concentré nos efforts sur l'amélioration de l'expérience utilisateur du Profileur de processeur de deux façons essentielles.

Tout d'abord, par rapport aux versions précédentes d'Android Studio, les taux d'erreur des enregistrements de processeur dans le Profileur de processeur ont été considérablement réduits.

Ensuite, l'interface utilisateur du Profileur de processeur a été repensée pour offrir un workflow plus intuitif. Voici quelques modifications notables apportées à l'interface utilisateur :

• Les enregistrements de processeur sont à présent séparés de la chronologie principale du profileur pour faciliter l'analyse. Les données enregistrées sont organisées en groupes sur le côté gauche de la fenêtre Profileur. Vous pouvez déplacer des groupes vers le haut ou vers le bas pour réorganiser la liste en cliquant sur l'icône des options en haut à droite de la fenêtre ou en glissant-déposant des éléments individuels dans un groupe.
• Pour faciliter l'analyse côte à côte, vous pouvez maintenant afficher toute l'activité des threads dans la chronologie de l'activité des threads (y compris les méthodes, les fonctions et les événements). Vous pouvez parcourir la chronologie de plusieurs manières :
  • Pour vous concentrer sur un moment précis, faites glisser une plage du graphique d'utilisation du processeur en haut à gauche.
  • Pour faire un zoom avant ou arrière, utilisez la molette de la souris tout en maintenant la touche Ctrl enfoncée (ou Commande sous macOS). Pour déplacer la carte vers la gauche ou la droite, faites-la glisser tout en maintenant la barre d'espace enfoncée.
  • Vous pouvez également utiliser les touches W et A pour un zoom avant ou arrière précis, et les touches S et D pour effectuer un panoramique précis vers la gauche et vers la droite.
• Les onglets des analyses Graphique de type "flamme", De haut en bas et De bas en haut se trouvent à présent dans la colonne de droite. Dans le groupe "Threads", les threads sont automatiquement développés pour les enregistrements Trace système et réduits par défaut pour les autres types d'enregistrement. Double-cliquez sur les noms de thread (ou appuyez sur Entrée) pour les développer ou les réduire.
• Comme illustré sur la capture d'écran, l'interface utilisateur de Trace système inclut également des améliorations :
  • Les événements sont à présent de couleur unique pour une différenciation plus facile.
  • Les threads sont triés en fonction du nombre d'événements de trace qu'ils contiennent, de sorte que les threads "plus occupés" soient mieux classés dans la liste.
  • Vous pouvez sélectionner un ou plusieurs threads pour n'afficher que l'analyse correspondante dans la colonne de droite.
  • De même, vous pouvez sélectionner un événement de trace dans n'importe quel thread pour afficher les données d'analyse correspondantes.

Outils de conception

Cette version d'Android Studio inclut des mises à jour des outils de conception, tels que l'outil d'inspection de la mise en page et un tout nouvel Éditeur de mouvement.

Nouvel Éditeur de mouvement

Android Studio inclut maintenant un éditeur de conception visuelle pour le type de mise en page MotionLayout, ce qui facilite la création et la prévisualisation des animations.

L'Éditeur de mouvement fournit une interface simple permettant de manipuler les éléments de la bibliothèque MotionLayout qui sert de base à l'animation dans les applications Android. Dans les versions précédentes, la création et la modification de ces éléments nécessitaient de modifier manuellement les contraintes dans les fichiers de ressources XML. L'Éditeur de mouvement peut maintenant générer le fichier XML pour vous, avec prise en charge des états de début et de fin, des images clés, des transitions et des chronologies.

Pour en savoir plus sur l'utilisation de l'Éditeur de mouvement, consultez le guide de l'utilisateur.

Outil d'inspection de la mise en page en direct

Déboguez votre mise en page avec un outil d'inspection de la mise en page en direct mis à jour qui fournit des informations complètes et en temps réel sur l'interface utilisateur de votre application pendant son déploiement sur un appareil.

Pour ouvrir une fenêtre de l'outil d'inspection de la mise en page, accédez à Vue > Fenêtres d'outil > Outil d'inspection de la mise en page. Outre la plupart des fonctionnalités de l'outil d'inspection de la mise en page existant, l'outil d'inspection de la mise en page en direct inclut également ce qui suit :

• Hiérarchie de mise en page dynamique : la mise à jour s'effectue à mesure que les vues sur l'appareil changent.

• Pile de résolution des valeurs de propriété : déterminez d'où provient une valeur de propriété de ressource dans le code source, puis accédez à son emplacement en suivant les liens hypertexte dans le volet des propriétés.

• Vue 3D : consultez la hiérarchie des vues de votre application lors de l'exécution grâce à la visualisation 3D avancée. Pour utiliser cette fonctionnalité, cliquez simplement sur la mise en page dans la fenêtre de l'outil d'inspection de la mise en page en direct et faites-la pivoter.

Vous ne pouvez utiliser l'outil d'inspection de la mise en page en direct que lorsque vous déployez votre application sur un appareil ou un émulateur exécutant le niveau d'API 29 ou supérieur. Pour activer l'outil d'inspection de la mise en page en direct, accédez à Fichier > Paramètres > Expérimental, puis cochez la case Activer l'outil d'inspection de la mise en page en direct. Cochez ensuite la case à côté de Mises à jour en direct au-dessus de l'écran de mise en page.

Validation de mise en page

Validation de mise en page est un outil visuel permettant de prévisualiser simultanément des mises en page sur différents appareils et configurations, ce qui vous aide à détecter les erreurs de mise en page et à créer des applications plus accessibles.

Vous pouvez accéder à cette fonctionnalité en cliquant sur l'onglet Validation de mise en page en haut à droite de la fenêtre de l'IDE :

Dans la fenêtre "Validation de mise en page", vous pouvez choisir parmi quatre ensembles de configuration différents, y compris :

• Appareils Pixel : prévisualisez votre application sur une sélection d'appareils Pixel.
• Personnalisé : prévisualisez votre application à l'aide d'options d'affichage personnalisées, telles que l'orientation de l'écran ou la langue.
• Daltonisme : prévisualisez votre application à l'aide de simulations de types courants de daltonisme.
• Tailles de police : prévisualisez votre application avec différentes tailles de police.

Pour en savoir plus sur l'utilisation de la Validation de mise en page, consultez Déboguer la mise en page à l'aide de l'outil d'inspection de la mise en page.

Fonctionnalités de l'éditeur intelligent pour les règles de réduction de code

Android Studio fournit à présent des fonctionnalités d'éditeur intelligent lorsque vous ouvrez des fichiers de règles de réduction de code pour R8, telles que la mise en surbrillance de la syntaxe, la saisie automatique de code et la vérification des erreurs. L'éditeur s'intègre également à votre projet Android Studio et fournit une saisie semi-automatique des symboles pour toutes les classes, méthodes et champs. Il inclut une navigation et une refactorisation rapides.

Modèles dynamiques Android pour Kotlin

Android Studio inclut maintenant des modèles dynamiques Android pour vos classes Kotlin. Par exemple, vous pouvez à présent saisir toast et appuyer sur la touche Tab pour insérer rapidement un toast. Pour obtenir la liste complète des modèles dynamiques disponibles, cliquez sur Fichier > Paramètres dans la barre de menu (ou sur Android Studio > Préférences sous macOS), puis accédez à Éditeur > Modèles dynamiques.

Assistant de fragment et nouveaux modèles de fragment

Un nouvel assistant de fragment Android et de nouveaux modèles de fragment sont maintenant disponibles lorsque vous accédez à Fichier > Nouveau > Fragment > Galerie ou que vous cliquez sur Créer une destination dans l'éditeur de navigation.

Compatibilité étendue de l'appareil photo dans Android Emulator

Avec l'image Android 11, l'appareil photo Android Emulator inclut les nouvelles fonctionnalités suivantes :

• Capture RAW
• Retraitement YUV
• Appareils de niveau 3
• Compatibilité avec les appareils photo logiques

Pour en savoir plus sur le développement pour Android 11, consultez la documentation d'Android 11.

clangd à présent disponible pour l'éditeur de code C++

Jetbrains CLion, la technologie sous-jacente au langage C++ d'Android Studio, utilise à présent un moteur d'inspection basé sur LLVM clangd et clang-tidy, ce qui accélère la saisie automatique du code C++ et offre une intégration parfaite à clang-tidy.

À présent disponibles dans l'éditeur de code C++ d'Android Studio, clangd et clang-tidy font tous deux partie des outils supplémentaires Open Source LLVM :

• clangd inclut la saisie automatique du code, la compilation des messages d'erreur dans l'éditeur et la possibilité d'accéder à la définition.
• clang-tidy est un outil linter C++ doté d'un framework extensible qui permet de diagnostiquer et de corriger les erreurs de programmation courantes.

Dans les versions précédentes, les utilisateurs d'Android Studio pouvaient utiliser clang-tidy via le NDK. Avec ce changement, Android Studio ne dépend plus du NDK pour la fonctionnalité Clang-tidy.

Le paramètre ndk.dir du fichier local.properties est obsolète

La valeur de ndk.dir ne doit plus être définie dans le fichier local.properties de votre application. Par ailleurs, la prise en charge de ce paramètre ndk.dir sera supprimée dans une prochaine version. Le plug-in Android Gradle définit la version du NDK par défaut, mais si vous avez besoin d'une version spécifique du NDK, vous pouvez définir android.ndkVersion dans build.gradle.

Pour en savoir plus sur la configuration du NDK, consultez Installer et configurer le NDK et CMake.

IntelliJ IDEA 2019.3.3

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2019.3.3.

Pour en savoir plus sur les améliorations des autres versions d'IntelliJ incluses cumulativement avec la version 2019.3.3, consultez les pages suivantes :

• IntelliJ IDEA 2019.3
• IntelliJ IDEA 2019.3.3

3.6 (février 2020)

Android Studio 3.6 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Nous tenons à remercier tous les contributeurs de la communauté qui ont contribué à cette publication.

Outils de conception

Cette version d'Android Studio inclut des mises à jour de plusieurs outils de conception, tels que l'éditeur de mise en page et le gestionnaire de ressources.

Vue fractionnée et zoom dans les éditeurs de conception

Les mises à jour suivantes apportées aux éditeurs de conception visuelle sont incluses dans cette version :

• Les éditeurs de conception, tels que l'éditeur de mise en page et l'éditeur de navigation, proposent à présent une vue Fractionner qui permet d'afficher les vues Conception et Code de l'interface utilisateur en même temps. En haut à droite de la fenêtre de l'éditeur, trois boutons permettent maintenant d'activer/de désactiver les options d'affichage :

  • Pour activer la vue fractionnée, cliquez sur l'icône Fractionner .
  • Pour activer l'affichage de la source XML, cliquez sur l'icône Source .
  • Pour activer la vue Conception, cliquez sur l'icône Conception .

• Les commandes de zoom et de panoramique dans les éditeurs de conception ont été déplacées vers un panneau flottant situé en bas à droite de la fenêtre de l'éditeur.

Pour en savoir plus, consultez Créer une interface utilisateur avec Layout Editor.

Onglet "Ressource" du sélecteur de couleur

Pour vous aider à mettre à jour rapidement les valeurs de ressource de couleur dans votre application lorsque vous utilisez le sélecteur de couleur dans votre fichier XML ou les outils de conception, l'IDE insère maintenant les valeurs de ressource de couleur pour vous.

Gestionnaire de ressources

Le Gestionnaire de ressources contient les mises à jour suivantes :

• Le Gestionnaire de ressources est à présent compatible avec la plupart des types de ressources.
• Lorsque vous recherchez une ressource, le Gestionnaire de ressources affiche à présent les résultats de tous les modules du projet. Auparavant, les recherches ne renvoyaient que les résultats du module sélectionné.
• Le bouton de filtre vous permet d'afficher les ressources des modules dépendants locaux, des bibliothèques externes et du framework Android. Vous pouvez également utiliser le filtre pour afficher les attributs de thème.
• Vous pouvez maintenant renommer des ressources lors du processus d'importation. Pour ce faire, cliquez dans la zone de texte au-dessus de la ressource.

Pour en savoir plus, consultez Gérer les ressources d'UI de votre application avec le gestionnaire de ressources.

Mises à jour apportées au plug-in Android Gradle

La dernière version du plug-in Android Gradle comprend de nombreuses mises à jour, y compris des optimisations de la vitesse de compilation, la compatibilité avec le plug-in de publication Maven et la compatibilité avec la liaison de vue. Pour en savoir plus, consultez les notes de version complètes.

Liaison de vue

La liaison de vue vous permet d'écrire plus facilement du code qui interagit avec les vues en générant une classe de liaison pour chaque fichier de mise en page XML. Ces classes contiennent des références directes à toutes les vues qui ont un ID dans la mise en page correspondante.

Étant donné qu'elle remplace findViewById(), la liaison de vue élimine le risque d'exceptions de pointeur nul résultant d'un ID de vue non valide.

Pour activer la liaison de vue, vous devez utiliser le plug-in Android Gradle 3.6.0 ou version ultérieure, et inclure les éléments suivants dans le fichier build.gradle de chaque module :

android {
    buildFeatures.viewBinding = true
}

android {
    buildFeatures.viewBinding = true
}

Appliquer les modifications

Vous pouvez maintenant ajouter une classe et déployer cette modification de code dans votre application en cours d'exécution en cliquant sur Appliquer les modifications au code ou sur Appliquer les modifications et redémarrer l'activité .

Pour en savoir plus sur la différence entre ces deux actions, consultez Appliquer les modifications.

Option du menu "Refactoriser" pour activer la compatibilité avec les applis instantanées

Une fois le projet d'application créé, vous pouvez à présent activer instantanément votre module de base à tout moment comme suit :

1. Ouvrez le panneau Projet en sélectionnant Vue > Fenêtres d'outil > Projet dans la barre de menu.
2. Effectuez un clic droit sur votre module de base, généralement nommé "app", puis sélectionnez Refactoriser > Activer la compatibilité avec les applis instantanées.
3. Dans la boîte de dialogue qui s'affiche, sélectionnez votre module de base dans le menu déroulant.
4. Cliquez sur OK.

Pour en savoir plus, consultez la Présentation de Google Play Instant.

Désobscurcir le bytecode de classe et de méthode dans l'analyseur d'APK

Lorsque vous inspectez des fichiers DEX à l'aide de l'analyseur d'APK, vous pouvez désobscurcir le bytecode de classe et de méthode comme suit :

1. Sélectionnez Compiler > Analyser APK dans la barre de menu.
2. Dans la boîte de dialogue qui s'affiche, accédez à l'APK que vous souhaitez inspecter, puis sélectionnez-le.
3. Cliquez sur Ouvrir.
4. Dans l'analyseur d'APK, sélectionnez le fichier DEX à inspecter.
5. Dans la visionneuse de fichiers DEX, chargez le fichier de mappages ProGuard pour l'APK que vous analysez.
6. Effectuez un clic droit sur la classe ou la méthode que vous souhaitez inspecter, puis sélectionnez Afficher le bytecode.

Outils natifs

Les mises à jour suivantes sont compatibles avec le développement natif (C/C++) dans Android Studio.

Compatibilité avec Kotlin

Les fonctionnalités NDK suivantes dans Android Studio, auparavant compatibles avec Java, sont à présent également compatibles avec Kotlin :

• Naviguez d'une déclaration JNI à la fonction d'implémentation correspondante en C/C++. Pour afficher ce mappage, pointez sur le repère d'élément C ou C++ près du numéro de ligne dans le fichier de code source géré.

• Créez automatiquement une fonction d'implémentation bouchon pour une déclaration JNI. Définissez d'abord la déclaration JNI, puis saisissez "jni" ou le nom de la méthode dans le fichier C/C++ à activer.

  

• Les fonctions d'implémentation natives non utilisées sont signalées en tant qu'avertissements dans le code source. Les déclarations JNI avec des implémentations manquantes sont également signalées en tant qu'erreurs.

• Lorsque vous renommez (refactorisez) une fonction d'implémentation native, toutes les déclarations JNI correspondantes sont mises à jour. Renommez une déclaration JNI pour mettre à jour la fonction d'implémentation native.

• Vérification de la signature pour les implémentations JNI liées implicitement

Autres améliorations JNI

L'éditeur de code d'Android Studio accepte à présent un workflow de développement JNI plus fluide, avec des optimisations de type améliorées, la saisie semi-automatique, des inspections et la refactorisation de code.

Actualisation de l'APK pour les bibliothèques natives

Vous n'avez plus besoin de créer de projet lorsque l'APK de votre projet est mis à jour en dehors de l'IDE. Android Studio détecte les modifications apportées à l'APK et vous permet de le réimporter.

Joindre des sources APK Kotlin uniquement

Il est maintenant possible de joindre des sources d'APK externes Kotlin uniquement lorsque vous profilez et déboguez des APK prédéfinis. Pour en savoir plus, consultez Joindre des sources Kotlin/Java.

Détection des fuites dans le Profileur de mémoire

Lorsque vous analysez une empreinte de mémoire dans le Profileur de mémoire, vous pouvez à présent filtrer les données de profilage qui, selon Android Studio, peuvent indiquer des fuites de mémoire pour les instances Activity et Fragment de votre application.

Vous pouvez filtrer les types de données suivants :

• Instances Activity détruites, mais qui sont toujours référencées.
• Instances Fragment qui n'ont pas de FragmentManager valide, mais qui sont toujours référencées.

Dans certaines situations, par exemple dans les cas suivants, le filtre peut générer de faux positifs :

• Un Fragment a été créé, mais n'a pas encore été utilisé.
• Un Fragment est mis en cache, mais ne fait partie d'aucune FragmentTransaction.

Pour utiliser cette fonctionnalité, commencez par capturer une empreinte de la mémoire ou importer un fichier d'empreinte de la mémoire dans Android Studio. Pour afficher les fragments et les activités susceptibles de provoquer une fuite de mémoire, cochez la case Fuites d'activité/de fragment dans le volet d'empreinte de mémoire du Profileur de mémoire.

Filtrage d'une empreinte de la mémoire pour identifier les fuites de mémoire.

Émulateurs

Android Studio 3.6 vous permet de bénéficier de plusieurs mises à jour incluses dans Android Emulator 29.2.7 et versions ultérieures, comme décrit ci-dessous.

Prise en charge de la localisation améliorée

Android Emulator 29.2.7 et versions ultérieures est compatible avec l'émulation des coordonnées GPS et des informations sur les itinéraires. Lorsque vous ouvrez les contrôles étendus des émulateurs, les options de l'onglet "Emplacement" sont maintenant organisées sous deux onglets : Points uniques et Itinéraires.

Points uniques

Dans l'onglet Points uniques, vous pouvez utiliser la WebView de Google Maps pour rechercher des points d'intérêt, comme lorsque vous utilisez Google Maps sur un téléphone ou dans un navigateur. Lorsque vous recherchez ou cliquez sur un emplacement de la carte, vous pouvez l'enregistrer en sélectionnant "Enregistrer le point" au bas de la carte. Tous vos emplacements enregistrés sont listés à droite de la fenêtre Contrôles étendus.

Pour définir la position des émulateurs sur l'emplacement que vous avez sélectionné sur la carte, cliquez sur le bouton Définir l'emplacement en bas à droite de la fenêtre Contrôles étendus.

.

Itinéraires

Semblable à l'onglet Points uniques, l'onglet Itinéraires fournit une WebView Google Maps que vous pouvez utiliser pour créer un itinéraire entre plusieurs lieux. Pour créer et enregistrer un itinéraire, procédez comme suit :

1. Dans la vue plan, recherchez la première destination de votre itinéraire à l'aide du champ de texte.
2. Sélectionnez le lieu souhaité dans les résultats de recherche.
3. Sélectionnez le bouton Naviguer .
4. Sélectionnez le point de départ de votre itinéraire sur la carte.
5. (Facultatif) Cliquez sur Ajouter une destination pour ajouter d'autres étapes à votre itinéraire.
6. Enregistrez votre itinéraire en cliquant sur Enregistrer l'itinéraire dans la vue plan.
7. Attribuez un nom à l'itinéraire, puis cliquez sur Enregistrer.

Pour simuler l'émulateur selon l'itinéraire que vous avez enregistré, sélectionnez l'itinéraire dans la liste Itinéraires enregistrés, puis cliquez sur Lire l'itinéraire en bas à droite de la fenêtre Contrôles étendus. Pour arrêter la simulation, cliquez sur Arrêter l'itinéraire.

.

Pour simuler en continu l'émulateur selon l'itinéraire spécifié, activez le bouton bascule situé à côté de Répéter la lecture. Pour modifier la vitesse à laquelle l'émulateur suit l'itinéraire spécifié, sélectionnez une option dans le menu déroulant Vitesse de lecture.

Compatibilité multi-écran

Android Emulator vous permet à présent de déployer votre application sur plusieurs écrans, qui acceptent des dimensions personnalisables et peuvent vous aider à tester des applications compatibles avec le mode multifenêtre et le mode multi-écran. Lorsqu'un appareil virtuel est en cours d'exécution, vous pouvez ajouter jusqu'à deux écrans supplémentaires comme suit :

1. Ouvrez les Contrôles étendus, puis accédez à l'onglet Écrans.
2. Ajoutez un autre écran en cliquant sur Ajouter un écran secondaire.

3. Dans le menu déroulant sous Écrans secondaires, effectuez l'une des opérations suivantes :

   1. Sélectionnez l'un des formats prédéfinis.
   2. Sélectionnez Personnalisé, puis définissez les valeurs hauteur, largeur et dpi pour l'affichage personnalisé.

4. (Facultatif) Cliquez sur Ajouter un écran secondaire pour en ajouter un troisième.

5. Cliquez sur Appliquer les modifications pour ajouter les écrans spécifiés à l'appareil virtuel en cours d'exécution.

Nouveaux appareils virtuels et modèles de projet pour Android Automotive OS

Lorsque vous créez un projet à l'aide d'Android Studio, vous pouvez maintenant choisir parmi trois modèles dans l'onglet Automobile de l'assistant Créer un projet : Aucune activité, Service multimédia et Service de messagerie instantanée. Pour les projets existants, vous pouvez rendre vos appareils Android Automotive compatibles en sélectionnant Fichier > Nouveau > Nouveau module dans la barre de menu, puis en sélectionnant Module automobile. L'assistant Créer un module vous guide ensuite dans la création d'un module à l'aide de l'un des modèles de projet d'Android Automotive.

.

En outre, vous pouvez maintenant créer un appareil virtuel Android (AVD) pour les appareils Android Automotive OS en sélectionnant l'une des options suivantes dans l'onglet Automobile de l'assistant Configuration de l'appareil virtuel.

1. Polestar 2 : créez un AVD qui émule l'unité principale Polestar 2.
2. Automobile (paysage 1024p) : créez un AVD pour les unités principales d'Android Automotive de 1 024 x 768 px.

.

Téléchargements de SDK avec reprise

Lorsque vous téléchargez des composants et des outils du SDK à l'aide de SDK Manager, Android Studio vous permet à présent de reprendre les téléchargements qui ont été interrompus (en raison d'un problème réseau, par exemple) au lieu de recommencer le téléchargement depuis le début. Cette amélioration est particulièrement utile pour les téléchargements volumineux, comme Android Emulator ou les images système, lorsque la connexion Internet n'est pas fiable.

De plus, si une tâche de téléchargement du SDK s'exécute en arrière-plan, vous pouvez maintenant suspendre ou reprendre le téléchargement à l'aide des commandes de la barre d'état.

Tâche de téléchargement en arrière-plan dans la barre d'état avec de nouvelles commandes qui vous permettent de suspendre ou de reprendre le téléchargement.

Win32 obsolète

La version 32 bits de Windows d'Android Studio ne recevra plus de mises à jour après décembre 2019 et ne sera plus compatible après décembre 2020. Vous pouvez continuer à utiliser Android Studio. Toutefois, pour recevoir des mises à jour supplémentaires, mettez à niveau votre station de travail vers une version 64 bits de Windows.

Pour en savoir plus, consultez le blog sur la fin de la prise en charge de Windows 32 bits.

Nouvelle option permettant d'optimiser le temps de synchronisation Gradle

Dans les versions précédentes, Android Studio récupérait la liste de toutes les tâches Gradle pendant la synchronisation Gradle. Pour les projets volumineux, la récupération de la liste de tâches pouvait ralentir les synchronisations.

Pour améliorer les performances de la synchronisation Gradle, accédez à Fichier > Paramètres > Expérimental, puis sélectionnez "Ne pas créer la liste de tâches Gradle pendant la synchronisation Gradle".

Lorsque vous activez cette option, Android Studio ignore la compilation de la liste des tâches lors de la synchronisation, ce qui permet à la synchronisation Gradle de se terminer plus rapidement et améliore la réactivité de l'interface utilisateur. N'oubliez pas que, lorsque l'IDE ignore la compilation de la liste des tâches, les listes de tâches du panneau Gradle sont vides et la saisie semi-automatique du nom de la tâche dans les fichiers de compilation ne fonctionne pas.

Nouvel emplacement pour activer/désactiver le mode hors connexion de Gradle

Pour activer ou désactiver le mode hors connexion de Gradle, sélectionnez d'abord Vue > Fenêtres d'outil > Gradle dans la barre de menu. Ensuite, en haut de la fenêtre Gradle, cliquez sur Activer/Désactiver le mode hors connexion .

IntelliJ IDEA 2019.2

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2019.2.

Pour en savoir plus sur les améliorations des autres versions d'IntelliJ incluses cumulativement avec la version 2019.2, consultez les pages suivantes :

• IntelliJ IDEA 2019.1.3
• IntelliJ IDEA 2019.1.2
• IntelliJ IDEA 2019.1.1

Contributeurs de la communauté

Merci à tous nos contributeurs de la communauté qui nous ont permis de découvrir des bugs et d'autres moyens d'améliorer Android Studio 3.6. Nous tenons tout particulièrement à remercier les personnes suivantes qui ont signalé des bugs :

3.5 (août 2019)

Android Studio 3.5 est une version majeure et un résultat du projet Marble. Depuis la sortie d'Android Studio 3.3, l'initiative Projet Marble s'étend sur plusieurs versions qui visent à améliorer trois domaines principaux de l'IDE : état du système, perfectionnement des fonctionnalités et correction des bugs.

Pour en savoir plus sur ces mises à jour et d'autres du projet Marble, consultez l'article du blog des développeurs Android ou les sections ci-dessous.

Nous tenons à remercier tous les contributeurs de la communauté qui ont contribué à cette publication.

Projet Marble : état du système

Cette section décrit les modifications apportées à Android Studio 3.5 visant à améliorer l'état du système.

Paramètres de mémoire recommandés

Android Studio vous indique à présent qu'il est possible d'améliorer les performances en augmentant la quantité maximale de RAM que votre OS doit allouer aux processus Android Studio, tels que l'IDE principal, le daemon Gradle et le daemon Kotlin. Vous pouvez accepter les paramètres recommandés en cliquant sur le lien d'action dans la notification ou ajuster ces paramètres manuellement en sélectionnant Fichier > Paramètres (ou Android Studio > Préférences sous macOS), puis en recherchant la section Paramètres de mémoire sous Apparence et comportement > Paramètres système. Pour en savoir plus, consultez Taille maximale des tas de mémoire.

Notification concernant les paramètres de mémoire recommandés.

Rapport sur l'utilisation de la mémoire

Les problèmes de mémoire dans Android Studio sont parfois difficiles à reproduire et à signaler. Pour résoudre ce problème, Android Studio vous permet de générer un rapport d'utilisation de la mémoire en cliquant sur Aide > Analyser l'utilisation de la mémoire dans la barre de menu. Lorsque vous procédez ainsi, l'IDE nettoie localement les données pour les informations personnelles avant de demander si vous souhaitez les envoyer à l'équipe Android Studio afin d'identifier la source des problèmes de mémoire. Pour en savoir plus, consultez Exécuter un rapport sur l'utilisation de la mémoire.

Rapport sur l'utilisation de la mémoire.

Windows : optimisation des E/S de fichiers antivirus

Android Studio vérifie à présent automatiquement si certains répertoires de projet sont exclus de l'analyse antivirus en temps réel. Lorsque des ajustements peuvent être effectués pour améliorer les performances de compilation, Android Studio vous en informe et vous explique comment optimiser votre configuration antivirus. Pour en savoir plus, consultez Minimiser l'impact du logiciel antivirus sur la vitesse de compilation.

Projet Marble : perfectionnement des fonctionnalités

Cette section décrit les modifications apportées à Android Studio 3.5 visant à améliorer les fonctionnalités existantes.

Appliquer les modifications

Appliquer les modifications vous permet d'appliquer des modifications de code et de ressources à votre application en cours d'exécution sans redémarrer l'application et, dans certains cas, sans redémarrer l'activité en cours. Appliquer les modifications met en œuvre une approche entièrement nouvelle pour conserver l'état de votre application. Contrairement à l'exécution instantanée, qui a réécrit le bytecode de votre APK, Appliquer les modifications redéfinit les classes à la volée en exploitant l'instrumentation d'exécution compatible avec Android 8.0 (niveau d'API 26) ou version ultérieure.

Pour en savoir plus, consultez Appliquer les modifications.

Boutons de la barre d'outils pour "Appliquer les modifications".

Flux de déploiement de l'application

L'IDE dispose d'un nouveau menu déroulant qui vous permet de sélectionner rapidement l'appareil sur lequel vous souhaitez déployer votre application. Ce menu inclut également une nouvelle option qui vous permet d'exécuter votre application sur plusieurs appareils à la fois.

Menu déroulant sur l'appareil cible

Amélioration de la synchronisation Gradle et de la détection du cache

L'IDE détecte à présent mieux quand Gradle efface périodiquement votre cache de build lors de la réduction de sa consommation de disque dur. Dans les versions précédentes, cet état provoquait le signalement par l'IDE des dépendances manquantes et l'échec de la synchronisation Gradle. À présent, l'IDE télécharge simplement les dépendances si nécessaire pour s'assurer que la synchronisation Gradle aboutit.

Amélioration du résultat des erreurs de compilation

La fenêtre Compilation fournit maintenant de meilleurs rapports d'erreurs, tels qu'un lien vers le fichier et la ligne de l'erreur signalée, pour les processus de compilation suivants :

• Compilation et association d'AAPT
• R8 et ProGuard
• Conversion en DEX
• Fusion de ressources
• Analyse de fichiers XML
• Compilation Javac, Kotlin et CMake

Mises à niveau du projet

L'expérience de mise à jour a été améliorée pour fournir plus d'informations et d'actions qui vous aident à mettre à jour l'IDE et le plug-in Android Gradle. Par exemple, un plus grand nombre d'erreurs de synchronisation et de compilation incluent des actions permettant de limiter les erreurs lors des mises à jour.

Il est important de se rappeler que vous pouvez mettre à jour l'IDE indépendamment d'autres composants, tels que le plug-in Android Gradle. Ainsi, vous pouvez mettre à jour l'IDE dès qu'une nouvelle version est disponible et mettre à jour d'autres composants ultérieurement.

Éditeur de mise en page

Android Studio 3.5 offre plusieurs améliorations en termes de visualisation, de gestion et d'interaction de la mise en page.

Lorsque vous utilisez ConstraintLayout, la nouvelle section Contraintes du panneau Attributs liste les relations de contraintes du composant d'interface utilisateur sélectionné. Vous pouvez sélectionner une contrainte sur la surface de conception ou dans la liste des contraintes pour la mettre en avant dans les deux zones.

Relations de contrainte pour un élément d'interface utilisateur sélectionné.

De même, vous pouvez à présent supprimer une contrainte en la sélectionnant et en appuyant sur la touche Delete. Vous pouvez également supprimer une contrainte en maintenant enfoncée la touche Control (Command sous macOS) et en cliquant sur l'ancre de contrainte. Notez que, lorsque vous maintenez la touche Control ou Command enfoncée et pointez sur une ancre, toutes les contraintes associées deviennent rouges pour indiquer que vous pouvez cliquer dessus pour les supprimer.

Lorsqu'une vue est sélectionnée, vous pouvez créer une contrainte en cliquant sur l'une des icônes + dans la section Widget de contrainte du panneau Attributs, comme illustré dans l'image ci-dessous. Lorsque vous créez une contrainte, l'éditeur de mise en page la sélectionne et la met en surbrillance. Vous obtenez ainsi un retour visuel immédiat sur les éléments que vous venez d'ajouter.

Utilisation du widget de contrainte pour créer des contraintes.

Lorsque vous créez une contrainte, l'éditeur de mise en page n'affiche à présent que les points d'ancrage éligibles auxquels vous pouvez appliquer une contrainte. Auparavant, l'éditeur de mise en page mettait en surbrillance tous les points d'ancrage sur toutes les vues, que vous puissiez y appliquer une contrainte ou non. De plus, une superposition bleue indique maintenant la cible de la contrainte. Cette mise en surbrillance est particulièrement utile lorsque vous essayez d'appliquer une contrainte sur un composant qui se superpose à un autre.

Création d'une contrainte pour un composant superposé dans Android Studio 3.4.

Création d'une contrainte pour un composant superposé dans Android Studio 3.5.

En plus des mises à jour ci-dessus, Android Studio 3.5 inclut les améliorations suivantes de l'éditeur de mise en page :

• Le widget de contrainte et la liste déroulante des marges par défaut vous permettent à présent d'utiliser les ressources de dimension pour les marges.
• Dans la barre d'outils de l'éditeur de mise en page, la liste des appareils qui déterminent la taille de la surface de conception a été mise à jour. En outre, le comportement d'ancrage a été amélioré lors du redimensionnement, et les poignées de redimensionnement sur la surface de conception sont à présent toujours visibles. Lors du redimensionnement, de nouvelles superpositions qui affichent des tailles d'appareils courantes apparaissent.
• L'éditeur de mise en page dispose d'un nouveau jeu de couleurs qui améliore la cohérence et réduit le contraste entre les composants, le texte et les contraintes.
• Le mode plan prend à présent en charge le texte pour certains composants où le texte n'était pas affiché.

Pour en savoir plus sur ces modifications, consultez Projet Marble d'Android Studio : éditeur de mise en page.

Liaison de données

En plus d'ajouter la compatibilité avec le traitement incrémentiel des annotations pour la liaison de données, l'IDE améliore les fonctionnalités et les performances de l'éditeur intelligent lorsque vous créez des expressions de liaison de données au format XML.

Performances de l'éditeur de code dans Android Studio 3.4.

Amélioration des performances de modification du code dans Android Studio 3.5.

Amélioration de la compatibilité avec les projets C/C++

Android Studio 3.5 inclut plusieurs modifications qui améliorent la compatibilité avec les projets C/C++.

Améliorations du panneau "Variantes de compilation" pour la synchronisation d'une seule variante

Vous pouvez maintenant spécifier la variante de compilation active et l'ABI active dans le panneau Variantes de compilation. Cette fonctionnalité simplifie la configuration de compilation par module et peut également améliorer les performances de synchronisation de Gradle.

Pour en savoir plus, consultez Modifier la variante de compilation.

Panneau "Variantes de compilation" avec sélection d'une seule variante par ABI.

Versions côte à côte du NDK

Vous pouvez à présent utiliser plusieurs versions du NDK côte à côte. Cette fonctionnalité vous offre davantage de flexibilité pour configurer vos projets, par exemple si vous disposez de projets utilisant différentes versions du NDK sur la même machine.

Si votre projet utilise le plug-in Android Gradle 3.5.0 ou version ultérieure, vous pouvez également spécifier la version du NDK que chaque module de votre projet doit utiliser. Vous pouvez utiliser cette fonctionnalité pour créer des builds reproductibles et réduire les incompatibilités entre les versions du NDK et le plug-in Android Gradle.

Pour en savoir plus, consultez Installer et configurer le NDK, CMake et LLDB.

Compatibilité avec ChromeOS

Android Studio est à présent officiellement compatible avec les appareils ChromeOS, tels que le Chromebook HP x360 14, le Chromebook Acer 13/Spin 13 et d'autres que vous pouvez consulter dans la configuration requise. Pour commencer, téléchargez Android Studio sur votre appareil ChromeOS compatible et suivez les instructions d'installation.

Distribution conditionnelle pour les modules de fonctionnalités

La distribution conditionnelle vous permet de définir certaines exigences de configuration de l'appareil pour que les modules de fonctionnalités soient téléchargés automatiquement lors de l'installation de l'application. Par exemple, vous pouvez configurer un module de fonctionnalité qui inclut la fonction de réalité augmentée (RA) afin qu'il ne soit disponible lors de l'installation d'une application que pour les appareils compatibles avec la RA.

Ce mécanisme de distribution permet actuellement de contrôler le téléchargement d'un module au moment de l'installation de l'application en fonction des configurations d'appareil suivantes :

• Fonctionnalités matérielles et logicielles de l'appareil, y compris la version d'OpenGL ES
• Pays de l'utilisateur
• Niveau d'API

Si un appareil ne répond pas à toutes les exigences spécifiées, le module n'est pas téléchargé au moment de l'installation de l'application. Cependant, votre application peut ensuite demander à télécharger le module à la demande à l'aide de la bibliothèque Play Core. Pour en savoir plus, consultez Configurer la distribution conditionnelle.

IntelliJ IDEA 2019.1

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2019.1, telles que la personnalisation du thème.

La dernière version d'IntelliJ incluse avec Android Studio était la version 2018.3.4. Pour en savoir plus sur les améliorations des autres versions d'IntelliJ incluses cumulativement avec cette version d'Android Studio, consultez les mises à jour de correction de bug suivantes :

• IntelliJ IDEA 2018.3.6
• IntelliJ IDEA 2018.3.5

Mises à jour du plug-in Android Gradle 3.5.0

Pour en savoir plus sur les nouveautés du plug-in Android Gradle 3.5.0, telles que l'amélioration de la compatibilité avec le traitement incrémentiel des annotations et les tests unitaires pouvant être mis en cache, consultez les notes de version.

Contributeurs de la communauté

Merci à tous nos contributeurs de la communauté qui nous ont permis de découvrir des bugs et d'autres moyens d'améliorer Android Studio 3.5. Nous tenons tout particulièrement à remercier les personnes suivantes qui ont signalé des bugs P0 et P1 :

3.4 (avril 2019)

Android Studio 3.4 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

IntelliJ IDEA 2018.3.4

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2018.3.4.

Mises à jour du plug-in Android Gradle 3.4.0

Pour en savoir plus sur les nouveautés du plug-in Android Gradle 3.4.0, consultez les notes de version.

Nouvelle boîte de dialogue "Structure du projet"

La nouvelle boîte de dialogue "Structure du projet" facilite la mise à jour des dépendances et la configuration de différents aspects de votre projet, tels que les modules, les variantes de compilation, les configurations de signature et les variables de compilation.

Vous pouvez l'ouvrir en sélectionnant Fichier > Structure du projet dans la barre de menu. Vous pouvez également y accéder en appuyant sur Ctrl+Shift+Alt+S sous Windows et Linux, ou sur Command+; (point-virgule) sous macOS. Vous trouverez ci-dessous la description de certaines des sections nouvelles et mises à jour de cette boîte de dialogue.

Variables

La nouvelle section "Variables" de la boîte de dialogue "Structure du projet" vous permet de créer et de gérer des variables de compilation, telles que celles permettant de garantir la cohérence des numéros de version des dépendances dans votre projet.

• Affichez et modifiez rapidement les variables de compilation qui existent déjà dans les scripts de compilation Gradle de votre projet.
• Ajoutez de nouvelles variables de compilation au niveau d'un projet ou d'un module directement depuis la boîte de dialogue "Structure du projet".

Modules

Configurez les propriétés appliquées à toutes les variantes de compilation d'un module existant ou ajoutez de nouveaux modules à votre projet depuis la section Modules. Par exemple, c'est là que vous pouvez configurer les propriétés defaultConfig ou gérer les configurations de signature.

Dépendances

Inspectez et visualisez chaque dépendance dans le graphique de dépendances de votre projet, tel que résolu par Gradle lors de la synchronisation du projet, en procédant comme suit :

1. Dans le volet gauche de la boîte de dialogue "Structure du projet", sélectionnez Dépendances.
2. Dans le volet Modules, sélectionnez un module dont vous souhaitez inspecter les dépendances résolues.

3. Sur le côté droit de la boîte de dialogue "Structure du projet", ouvrez le volet Dépendances résolues, comme indiqué ci-dessous.

   

Vous pouvez également rechercher rapidement des dépendances et les ajouter à votre projet. Pour cela, sélectionnez un module dans la section Dépendances de la boîte de dialogue "Structure du projet", cliquez sur le bouton (+) dans la section Dépendances déclarées, puis sélectionnez le type de dépendance que vous souhaitez ajouter.

Selon le type de dépendance que vous sélectionnez, une boîte de dialogue semblable à celle ci-dessous doit s'afficher. Elle vous aidera à ajouter la dépendance au module.

Variantes de compilation

Dans cette section de la boîte de dialogue "Structure du projet", créez et configurez des variantes de compilation et des types de produit pour chaque module de votre projet. Vous pouvez ajouter des espaces réservés de fichiers manifestes, des fichiers ProGuard, attribuer des clés de signature, etc.

Suggestions

Consultez les suggestions de mises à jour pour les dépendances du projet et les variables de compilation dans la section Suggestions, comme indiqué ci-dessous.

Nouveau gestionnaire de ressources

Le Gestionnaire de ressources est une nouvelle fenêtre d'outil permettant d'importer, de créer, de gérer et d'utiliser des ressources dans votre application. Vous pouvez ouvrir la fenêtre d'outil en sélectionnant Vue > Fenêtres d'outil > Gestionnaire de ressources dans la barre de menu. Le Gestionnaire de ressources vous permet d'effectuer les opérations suivantes :

• Visualiser les ressources : vous pouvez prévisualiser les drawables, les couleurs et les mises en page pour trouver rapidement les ressources dont vous avez besoin.
• Effectuer une importation groupée : vous pouvez importer plusieurs éléments drawables à la fois en les faisant glisser et en les déposant dans la fenêtre d'outil Gestionnaire de ressources. Vous pouvez également utiliser l'assistant Importer des drawables Pour accéder à l'assistant, sélectionnez le bouton (+) en haut à gauche de la fenêtre d'outil, puis sélectionnez Importer des drawables dans le menu déroulant.
• Convertir des SVG en objets VectorDrawable : vous pouvez utiliser l'assistant Importer des drawables pour convertir vos images SVG en objets VectorDrawable.
• Glisser-déposer des éléments : à partir de la fenêtre d'outil Gestionnaire de ressources, vous pouvez glisser-déposer des drawables sur les vues de conception et XML de l'éditeur de mise en page.
• Afficher les versions alternatives : vous pouvez à présent afficher les versions alternatives de vos ressources en double-cliquant sur une ressource dans la fenêtre Outil. Cette vue affiche les différentes versions que vous avez créées et les qualificatifs inclus.
• Vues Mosaïque et Liste : vous pouvez modifier la vue dans la fenêtre d'outil pour visualiser vos ressources dans différentes dispositions.

Pour en savoir plus, consultez le guide sur la gestion des ressources d'application.

Vérifier les ID de build lors du profilage et du débogage des APK

Lorsque vous fournissez des fichiers de décodage pour les bibliothèques partagées .so dans votre APK, Android Studio vérifie que l'ID de build des fichiers de décodage fournis correspond à l'ID de build des bibliothèques .so dans l'APK.

Si vous compilez les bibliothèques natives dans votre APK avec un ID de build, Android Studio vérifie si l'ID de build de vos fichiers de décodage correspond à celui de vos bibliothèques natives et refuse les fichiers de décodage en cas de non-concordance. Si vous n'avez pas compilé avec un ID de build, le fait de fournir des fichiers de décodage incorrects peut entraîner des problèmes de débogage.

R8 activé par défaut

R8 intègre le désucrage, la réduction, l'obscurcissement, l'optimisation et la conversion en DEX en une seule étape, ce qui entraîne des améliorations notables des performances de compilation. R8 a été introduit dans le plug-in Android Gradle 3.3.0 et est à présent activé par défaut pour les projets de bibliothèques d'applications et Android utilisant le plug-in 3.4.0 et versions ultérieures.

L'image ci-dessous offre une vue d'ensemble du processus de compilation avant l'introduction de R8.

Avec R8, le désucrage, la réduction, l'obscurcissement, l'optimisation et la conversion en DEX (D8) sont effectués en une seule étape, comme illustré ci-dessous.

N'oubliez pas que la version R8 est conçue pour fonctionner avec vos règles ProGuard existantes. Vous n'aurez donc probablement aucune action à effectuer pour bénéficier de R8. Cependant, comme il s'agit d'une technologie différente de ProGuard, spécialement conçue pour les projets Android, la réduction et l'optimisation peuvent entraîner la suppression de code que ProGuard n'a peut-être pas. Dans ce cas peu probable, vous devrez peut-être ajouter des règles supplémentaires pour conserver ce code dans le résultat de votre compilation.

Si vous rencontrez des problèmes lors de l'utilisation de R8, consultez les questions fréquentes sur la compatibilité avec R8 pour voir s'il existe une solution. Si aucune solution n'est documentée, veuillez signaler un bug. Vous pouvez désactiver R8 en ajoutant l'une des lignes suivantes au fichier gradle.properties de votre projet :

# Disables R8 for Android Library modules only.
android.enableR8.libraries = false
# Disables R8 for all modules.
android.enableR8 = false

L'éditeur de navigation est maintenant compatible avec tous les types d'arguments

Tous les types d'arguments compatibles avec le composant Navigation sont à présent acceptés dans l'éditeur de navigation. Pour en savoir plus sur les types compatibles, consultez Transmettre des données entre les destinations.

Améliorations apportées à l'éditeur de mise en page

Le volet Attributs de l'éditeur de mise en page a été simplifié en une seule page, avec des sections que vous pouvez développer pour afficher les attributs que vous pouvez configurer. Le volet Attributs inclut également les mises à jour suivantes :

• La nouvelle section Attributs déclarés présente les attributs spécifiés par le fichier de mise en page et vous permet d'en ajouter rapidement de nouveaux.
• Le volet Attributs comporte maintenant des indicateurs à côté de chaque attribut, qui sont pleins lorsque la valeur de l'attribut est une référence de ressource et vides dans le cas contraire.
• Les attributs avec des erreurs ou des avertissements sont maintenant mis en surbrillance. Les éléments surlignés en rouge indiquent des erreurs (lorsque vous utilisez des valeurs de mise en page non valides, par exemple) et les éléments surlignés en orange indiquent des avertissements (lorsque vous utilisez des valeurs codées en dur, par exemple).

Nouvelle action d'intent pour importer rapidement les dépendances

Si vous commencez à utiliser certaines classes Jetpack et Firebase dans votre code, une nouvelle action d'intent suggère d'ajouter la dépendance de bibliothèque Gradle requise à votre projet, si ce n'est pas déjà fait. Par exemple, si vous référencez la classe WorkManager sans importer au préalable la dépendance android.arch.work:work-runtime requise, une action d'intent vous permet de le faire facilement en un clic, comme indiqué ci-dessous.

En particulier, comme Jetpack a repackagé la bibliothèque Support dans des packages distincts plus faciles à gérer et à mettre à jour, cette action d'intent vous aide à n'ajouter rapidement que les dépendances dont vous avez besoin pour les composants Jetpack que vous souhaitez utiliser.

3.3 (janvier 2019)

Android Studio 3.3 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

IntelliJ IDEA 2018.2.2

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2018.2.2.

Mises à jour du plug-in Android Gradle

Pour en savoir plus sur les nouveautés du plug-in Android Gradle, consultez ses notes de version.

Éditeur de navigation

L'éditeur de navigation vous permet de visualiser et de créer rapidement une navigation dans votre application à l'aide du composant d'architecture de navigation.

Pour en savoir plus, consultez Implémenter la navigation avec le composant d'architecture de navigation.

Supprimer les répertoires Android Studio inutilisés

Lorsque vous exécutez une version majeure d'Android Studio pour la première fois, elle recherche les répertoires contenant des caches, des paramètres, des index et des journaux des versions d'Android Studio pour lesquelles une installation correspondante est introuvable. La boîte de dialogue Supprimer les répertoires Android Studio inutilisés affiche ensuite les emplacements, les tailles et les heures de dernière modification de ces répertoires inutilisés. Elle vous permet également de les supprimer.

Les répertoires qu'Android Studio envisage de supprimer sont indiqués ci-dessous :

• Linux : ~/.AndroidStudio[Preview]_X.Y_
• Mac : ~/Library/{Preferences, Caches, Logs, Application Support}/AndroidStudio[Preview]_X.Y_
• Windows : %USER%\.AndroidStudio[Preview]_X.Y_

Améliorations apportées à lint

Lorsque lint est appelé depuis Gradle, il est beaucoup plus rapide. Les projets plus volumineux peuvent s'exécuter jusqu'à quatre fois plus vite.

Assistant "Créer un projet"

L'assistant Créer un projet a fait peau neuve et contient des mises à jour qui simplifient la création de projets Android Studio.

Pour en savoir plus, consultez Créer un projet.

Mises à jour du profileur

Android Studio 3.3 inclut des mises à jour de plusieurs profileurs individuels.

Performances améliorées

Suite aux commentaires des utilisateurs, nous avons considérablement amélioré les performances de rendu lors de l'utilisation des profileurs. Continuez à envoyer des commentaires, en particulier si vous continuez à rencontrer des problèmes de performances.

Options de suivi de l'allocation de mémoire du profileur

Pour améliorer les performances de l'application lors du profilage, le Profileur de mémoire échantillonne à présent périodiquement les allocations de mémoire par défaut. Si vous le souhaitez, vous pouvez modifier ce comportement à l'aide du menu déroulant Suivi de l'allocation lorsque vous effectuez des tests sur des appareils équipés d'Android 8.0 (niveau d'API 26) ou version ultérieure.

Dans le menu déroulant Suivi de l'allocation, vous pouvez choisir l'un des modes suivants :

• Complet : capture toutes les allocations de mémoire des objets. Notez que si votre application alloue de nombreux objets, vous risquez de rencontrer des problèmes de performances importants lors du profilage.
• Échantillonné : capture un échantillon périodique des allocations de mémoire des objets. Il s'agit du comportement par défaut et il a moins d'impact sur les performances de l'application lors du profilage. Vous risquez de rencontrer des problèmes de performances avec les applications qui allouent de nombreux objets sur une courte période.

• Désactivé : désactive l'allocation de mémoire. S'il n'est pas déjà sélectionné, ce mode est activé automatiquement lors de l'enregistrement d'un processeur, puis revient au paramètre précédent une fois l'enregistrement terminé. Vous pouvez modifier ce comportement dans la boîte de dialogue de configuration de l'enregistrement du processeur.

  Le suivi affecte à la fois les objets Java et les références JNI.

Inspecter les données de rendu des images

Dans le Profileur de processeur, vous pouvez à présent inspecter le temps nécessaire à votre application Java pour afficher chaque image sur le thread UI principal et sur RenderThread. Ces données peuvent être utiles pour identifier les goulots d'étranglement qui provoquent des à-coups dans l'interface utilisateur et des fréquences d'images faibles. Par exemple, chaque image qui prend plus de 16 ms pour maintenir une fréquence d'images fluide s'affiche en rouge.

Pour afficher les données de rendu d'images, enregistrez une trace à l'aide d'une configuration vous permettant de tracer les appels système. Après avoir enregistré la trace, recherchez des informations sur chaque image le long de la chronologie de l'enregistrement dans la section appelée IMAGES, comme indiqué ci-dessous.

Pour en savoir plus sur l'analyse et la résolution des problèmes de fréquence d'images, consultez Affichage lent.

Fragments dans la chronologie des événements

La chronologie des événements indique maintenant quand les fragments sont associés ou dissociés. En outre, lorsque vous pointez sur un fragment, une info-bulle indique l'état du fragment.

Afficher le texte formaté pour les charges utiles de connexion dans le Profileur de réseau

Auparavant, le Profileur de réseau n'affichait que du texte brut provenant des charges utiles de connexion. Android Studio 3.3 formate à présent certains types de texte par défaut, y compris JSON, XML et HTML. Dans les onglets Réponse et Requête, cliquez sur le lien Vue analysée pour afficher le texte formaté et cliquez sur le lien Afficher la source pour afficher le texte brut.

Pour en savoir plus, consultez Inspecter le trafic réseau avec le Profileur de réseau.

Téléchargement automatique des composants du SDK

Lorsque votre projet a besoin d'un composant SDK des plates-formes SDK, NDK ou CMake, Gradle tente maintenant de télécharger automatiquement les packages requis tant que vous avez déjà accepté les contrats de licence associés à l'aide de SDK Manager.

Pour en savoir plus, consultez Télécharger automatiquement les packages manquants avec Gradle.

Compatibilité avec Clang-Tidy

Android Studio est maintenant compatible avec l'analyse de code statique à l'aide de Clang-Tidy pour les projets qui incluent du code natif. Pour activer la compatibilité avec Clang-Tidy, mettez à jour votre NDK vers la version r18 ou ultérieure.

Vous pouvez ensuite activer ou réactiver les inspections en ouvrant la boîte de dialogue Paramètres ou Préférences et en accédant à Éditeur > Inspections > C/C++ > Général > Clang-Tidy. Lorsque vous sélectionnez cette inspection dans la boîte de dialogue Paramètres ou Préférences, vous pouvez également voir la liste des vérifications Clang-Tidy qui sont activées et désactivées dans la section Option du panneau le plus à droite. Pour activer des vérifications supplémentaires, ajoutez-les à la liste, puis cliquez sur Appliquer.

Pour configurer Clang-Tidy avec des options supplémentaires, cliquez sur Configurer les options des vérifications Clang-Tidy, puis ajoutez-les dans la boîte de dialogue qui s'ouvre.

Suppression des options de personnalisation C++

Les options suivantes ont été supprimées de la boîte de dialogue Personnaliser la compatibilité avec C++ :

• Compatibilité avec les exceptions (-fexceptions)
• Compatibilité avec les informations sur le type d'exécution (-ftti)

Les comportements respectifs sont activés pour tous les projets créés via Android Studio.

CMake version 3.10.2

La version 3.10.2 de CMake est à présent incluse dans SDK Manager. Notez que Gradle utilise toujours la version 3.6.0 par défaut.

Pour spécifier une version CMake pour Gradle, ajoutez ce qui suit au fichier build.gradle de votre module :

android {
    ...
    externalNativeBuild {
        cmake {
            ...
            version "3.10.2"
        }
    }
}

Pour en savoir plus sur la configuration de CMake dans build.gradle, consultez Configurer manuellement Gradle.

Nouvelle syntaxe "+" pour spécifier les versions minimales de CMake

Lorsque vous spécifiez une version de CMake dans le fichier build.gradle de votre module principal, vous pouvez maintenant ajouter un signe "+" pour correspondre au comportement de la cmake_minimum_required() de CMake.

Les Android App Bundles sont maintenant compatibles avec les Applis instantanées

Android Studio vous permet à présent de créer des Android App Bundles entièrement compatibles avec Google Play Instant. En d'autres termes, vous pouvez maintenant créer et déployer à la fois des applis installées et des expériences instantanées à partir d'un seul projet Android Studio et les inclure dans un seul Android App Bundle.

Si vous créez un projet Android Studio à l'aide de la boîte de dialogue Créer un projet, veillez à cocher la case Configurer votre projet > Ce projet sera compatible avec les applis instantanées. Android Studio crée ensuite un projet d'application selon la procédure habituelle, mais inclut les propriétés suivantes dans votre fichier manifeste pour que le module de base de votre application soit compatible avec les applis instantanées :

<manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="true" />
    ...
</manifest>

Vous pouvez ensuite créer une fonctionnalité permettant une utilisation instantanée en sélectionnant Fichier > Nouveau > Nouveau module dans la barre de menu, puis en sélectionnant Module de fonctionnalité dynamique instantané de la boîte de dialogue Créer un module. Gardez à l'esprit que la création de ce module permet également une utilisation instantanée du module de base de votre application.

Pour déployer votre application sur un appareil local en tant qu'expérience instantanée, modifiez votre configuration d'exécution et cochez la case Général > Déployer en tant qu'application instantanée.

Synchronisation de projets à variante unique

La synchronisation de votre projet avec votre configuration de compilation est une étape importante pour permettre à Android Studio de comprendre la structure de votre projet. Toutefois, ce processus peut prendre du temps pour les projets de grande envergure. Si votre projet utilise plusieurs variantes de compilation, vous pouvez maintenant optimiser les synchronisations du projet en les limitant à la variante que vous avez actuellement sélectionnée.

Vous devez utiliser Android Studio 3.3 ou version ultérieure avec le plug-in Android Gradle 3.3.0 ou version ultérieure pour activer cette optimisation. Lorsque vous remplissez ces conditions, l'IDE vous invite à activer cette optimisation lorsque vous synchronisez votre projet. L'optimisation est également activée par défaut sur les nouveaux projets.

Pour activer cette optimisation manuellement, cliquez sur Fichier > Paramètres > Expérimental > Gradle (Android Studio > Préférences > Expérimental > Gradle sur un Mac), puis cochez la case Synchroniser uniquement la variante active.

Pour en savoir plus, consultez Activer la synchronisation des projets à variante unique.

Fournir des commentaires rapidement

Si vous avez choisi de partager les statistiques d'utilisation pour améliorer Android Studio, les deux nouvelles icônes suivantes s'afficheront dans la barre d'état en bas de la fenêtre IDE :

Il vous suffit de cliquer sur l'icône qui représente le mieux votre expérience avec l'IDE. Lorsque vous procédez ainsi, l'IDE envoie des statistiques d'utilisation permettant à l'équipe Android Studio de mieux comprendre vos sentiments. Dans certains cas, par exemple lorsque vous indiquez une expérience négative avec l'IDE, vous avez la possibilité d'envoyer des commentaires supplémentaires.

Si vous ne l'avez pas déjà fait, vous pouvez activer le partage des statistiques d'utilisation. Pour cela, ouvrez la boîte de dialogue Paramètres (Préférences sur Mac), accédez à Apparence et comportement > Paramètres système > Partage des données, puis cochez la case Envoyer des statistiques d'utilisation à Google.

3.2 (septembre 2018)

Android Studio 3.2 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Assistant "Nouveautés"

Un assistant "Nouveautés" vous informe des dernières modifications apportées à Android Studio.

L'assistant s'ouvre au démarrage d'Android Studio après une nouvelle installation ou mise à jour s'il détecte de nouvelles informations à afficher. Vous pouvez également ouvrir l'assistant en sélectionnant Aide > Nouveautés d'Android Studio.

Android Jetpack

Android Jetpack permet d'accélérer le développement d'Android grâce à des composants, des outils et des conseils qui éliminent les tâches répétitives et vous permettent de créer plus rapidement et plus facilement des applications testables de haute qualité. Android Studio inclut les mises à jour suivantes pour assurer la compatibilité avec Jetpack. Pour en savoir plus, consultez la documentation de Jetpack.

Éditeur de navigation

Le nouvel éditeur de navigation s'intègre aux composants de navigation d'Android Jetpack pour fournir une vue graphique permettant de créer la structure de navigation de votre application. L'éditeur de navigation simplifie la conception et l'implémentation de la navigation entre les destinations intégrées à l'application.

Dans Android Studio 3.2, l'éditeur de navigation est une fonctionnalité expérimentale. Pour l'activer, cliquez sur Fichier > Paramètres (Android Studio > Préférences sous Mac), puis sélectionnez la catégorie Expérimental dans le volet de gauche. Cochez la case Activer l'éditeur de navigation, puis redémarrez Android Studio.

Pour en savoir plus, consultez la documentation de l'éditeur de navigation.

Migration vers AndroidX

En lien avec Jetpack, nous migrons les bibliothèques Android Support vers une nouvelle bibliothèque d'extensions Android à l'aide de l'espace de noms androidx. Pour en savoir plus, consultez la présentation d'AndroidX.

Android Studio 3.2 vous aide tout au long de ce processus grâce à une nouvelle fonctionnalité de migration.

Pour migrer un projet existant vers AndroidX, sélectionnez Refactoriser > Migrer vers AndroidX. Si vous disposez de dépendances Maven qui n'ont pas été migrées vers l'espace de noms AndroidX, le système de compilation Android Studio convertit également automatiquement ces dépendances de projet.

Le plug-in Android Gradle fournit les indicateurs globaux suivants que vous pouvez définir dans votre fichier gradle.properties :

• android.useAndroidX : lorsque cet indicateur est défini sur true, il indique que vous souhaitez commencer à utiliser AndroidX à partir de maintenant. S'il est absent, Android Studio se comporte comme s'il était défini sur false.
• android.enableJetifier : lorsque cet indicateur est défini sur true, il indique que vous souhaitez disposer d'un outil compatible (à partir du plug-in Android Gradle) pour convertir automatiquement les bibliothèques tierces existantes comme si elles avaient été écrites pour AndroidX. S'il est absent, Android Studio se comporte comme s'il était défini sur false.

Les deux indicateurs sont définis sur true lorsque vous utilisez la commande Migrer vers AndroidX.

Si vous souhaitez commencer à utiliser les bibliothèques AndroidX immédiatement et que vous n'avez pas besoin de convertir les bibliothèques tierces existantes, vous pouvez définir l'indicateur android.useAndroidX sur true et l'indicateur android.enableJetifier sur false.

Android App Bundle

Android App Bundle est un nouveau format d'importation qui inclut l'ensemble du code et des ressources compilés de votre application, mais qui diffère la génération des APK et leur signature sur le Google Play Store.

Le nouveau modèle de diffusion d'applications de Google Play utilise ensuite votre app bundle pour générer et diffuser des APK optimisés pour la configuration de l'appareil de chaque utilisateur. Ainsi, chaque utilisateur ne télécharge que le code et les ressources nécessaires pour exécuter votre application. Vous n'avez plus besoin de créer, de signer ni de gérer plusieurs APK, et les utilisateurs bénéficient de téléchargements plus petits et plus optimisés.

Vous pouvez également ajouter des modules de fonctionnalités à votre projet d'application et les inclure dans votre app bundle. Vos utilisateurs peuvent ensuite télécharger et installer les fonctionnalités de votre application à la demande.

Pour créer un groupe, choisissez Compilation > Compiler des bundle(s)/APK > Compiler des bundle(s).

Pour obtenir plus d'informations, y compris des instructions sur la création et l'analyse d'un Android App Bundle, consultez Android App Bundle.

Exemple de données dans l'éditeur de mise en page

De nombreuses mises en page Android comportent des données d'exécution qui peuvent compliquer la visualisation de l'apparence d'une mise en page lors de la phase de conception du développement d'applications. Vous pouvez maintenant prévisualiser facilement votre vue dans l'éditeur de mise en page avec de nombreux exemples de données. Lorsque vous ajoutez une vue, un bouton apparaît sous la vue dans la fenêtre Conception. Cliquez sur ce bouton pour définir les attributs de la vue au moment de la conception. Vous pouvez choisir parmi plusieurs exemples de modèles de données et spécifier le nombre d'exemples d'éléments qui rempliront la vue.

Pour essayer d'utiliser des exemples de données, ajoutez un élément RecyclerView à une nouvelle mise en page. Ensuite, cliquez sur le bouton des attributs au moment de la conception sous la vue, puis choisissez une sélection dans le carrousel d'exemples de modèles de données.

Segments d'application

Les segments d'application constituent un nouveau moyen d'intégrer des parties de la fonctionnalité de votre application dans d'autres surfaces d'interface utilisateur sur Android. Par exemple, les segments d'application permettent d'afficher les fonctionnalités et le contenu de l'application dans les suggestions de la recherche Google.

Android Studio 3.2 dispose d'un modèle intégré pour vous aider à étendre votre application avec les nouvelles API de fournisseur de segments d'application, ainsi que de nouvelles vérifications lint pour vous assurer de suivre les bonnes pratiques lors de la création des segments d'application.

Pour commencer, effectuez un clic droit sur un dossier de projet et choisissez Nouveau > Autre > Fournisseur de segments d'application.

Pour en savoir plus et découvrir comment tester les interactions de segments d'application, lisez le guide de démarrage des segments d'application.

Kotlin 1.2.61

Android Studio 3.2 intègre Kotlin 1.2.61 et le nouveau SDK Android s'intègre mieux à Kotlin. Pour en savoir plus, consultez le blog des développeurs Android.

IntelliJ IDEA 2018.1.6

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2018.1.6.

Profileurs Android

Essayez les nouvelles fonctionnalités du Profileur Android suivantes dans Android Studio 3.2.

Sessions

Vous pouvez à présent enregistrer les données de Profileur en tant que sessions pour les revoir et les inspecter plus tard. Le profileur conserve les données de votre session jusqu'à ce que vous redémarriez l'IDE.

Lorsque vous enregistrez une trace de méthode ou capturez une empreinte de la mémoire, l'IDE ajoute ces données (ainsi que l'activité réseau de votre application) en tant qu'entrée distincte de la session en cours. Vous pouvez facilement basculer entre les enregistrements pour comparer les données.

Trace système

Dans le Profileur de processeur, sélectionnez la nouvelle configuration Trace système pour inspecter l'activité du processeur et du thread système de votre appareil. Cette configuration de trace est basée sur systrace et est utile pour étudier les problèmes au niveau du système, tels que les à-coups dans l'interface utilisateur.

Lorsque vous utilisez cette configuration de trace, vous pouvez marquer visuellement des routines de code importantes dans la chronologie du profileur en instrumentant votre code C/C++ avec l'API de traçage natif ou votre code Java avec la classe Trace.

Inspecter les références JNI dans le Profileur de mémoire

Si vous déployez votre application sur un appareil équipé d'Android 8.0 (niveau d'API 26) ou version ultérieure, vous pouvez à présent inspecter les allocations de mémoire pour le code JNI de votre application à l'aide de l'outil Profileur de mémoire.

Pendant l'exécution de votre application, sélectionnez une partie de la chronologie que vous souhaitez inspecter, puis sélectionnez Segment de mémoire JNI dans le menu déroulant situé au-dessus de la liste des classes, comme indiqué ci-dessous. Vous pouvez ensuite inspecter les objets du segment de mémoire comme vous le feriez normalement et double-cliquer sur les objets dans l'onglet Pile d'appel de l'allocation pour voir où les références JNI sont allouées et libérées dans votre code.

Importer, exporter et inspecter des fichiers d'empreinte de la mémoire

Vous pouvez maintenant importer, exporter et inspecter les fichiers de vidage de la mémoire de .hprof créés avec Memory Profiler.

Importez votre fichier .hprof en cliquant sur Démarrer une nouvelle session de profileur dans le volet Sessions du profileur, puis en sélectionnant Charger à partir du fichier. Vous pouvez ensuite inspecter ses données dans le Profileur de mémoire comme vous le feriez pour toute autre empreinte de la mémoire.

Pour enregistrer des données d'empreinte de la mémoire afin de les consulter ultérieurement, cliquez sur le bouton Exporter l'empreinte de la mémoire à droite de l'entrée de l'empreinte de la mémoire dans les Sessions. volet. Dans la boîte de dialogue Exporter sous forme de qui s'affiche, enregistrez le fichier avec l'extension .hprof.

Enregistrer l'activité du processeur au démarrage de l'application

Vous pouvez maintenant enregistrer l'activité du processeur au démarrage de votre application, comme suit :

1. Sélectionnez Exécuter > Modifier les configurations dans le menu principal.
2. Dans l'onglet Profilage de la configuration d'exécution souhaitée, cochez la case Commencer à enregistrer une trace de méthode au démarrage.
3. Sélectionnez une configuration d'enregistrement CPU à utiliser dans le menu déroulant.
4. Déployez votre application sur un appareil équipé d'Android 8.0 (niveau d'API 26) ou version ultérieure en sélectionnant Exécuter > Profil.

Exporter les traces du processeur

Après avoir enregistré l'activité du processeur avec le Profileur de processeur, vous pouvez exporter les données sous forme de fichier .trace pour les partager avec d'autres utilisateurs ou les inspecter ultérieurement.

Pour exporter une trace après avoir enregistré l'activité du processeur, procédez comme suit :

1. Effectuez un clic droit sur l'enregistrement à exporter depuis la chronologie du processeur.
2. Sélectionnez Exporter la trace dans le menu déroulant.
3. Accédez à l'emplacement dans lequel vous souhaitez enregistrer le fichier, puis cliquez sur Enregistrer.

Importer et inspecter les fichiers de suivi du processeur

Vous pouvez maintenant importer et inspecter des fichiers .trace créés avec l'API de débogage ou le Profileur de processeur. (Il n'est actuellement pas possible d'importer les enregistrements de trace système.)

Importez votre fichier de suivi en cliquant sur Démarrer une nouvelle session de profileur dans le volet Sessions du profileur, puis en sélectionnant Charger à partir du fichier. Vous pouvez ensuite inspecter ses données dans le Profileur de processeur comme vous le feriez normalement, avec les exceptions suivantes :

• L'activité du processeur n'est pas représentée dans la chronologie du processeur.
• La chronologie d'activité des threads indique uniquement où les données de trace sont disponibles pour chaque thread, et non les états réels des threads (en cours d'exécution, en attente ou en veille, par exemple).

Enregistrer l'activité du processeur à l'aide de l'API Debug

Vous pouvez à présent démarrer et arrêter l'enregistrement de l'activité du processeur dans le Profileur de processeur en instrumentant votre application avec l'API de débogage. Une fois votre application déployée sur un appareil, le profileur commence automatiquement à enregistrer l'activité du processeur lorsque votre application appelle startMethodTracing(String tracePath) et arrête l'enregistrement lorsque votre application appelle stopMethodTracing(). Lors de l'enregistrement de l'activité du processeur déclenchée à l'aide de cette API, le Profileur de processeur indique Debug API (API de débogage) comme configuration d'enregistrement du processeur sélectionnée.

Profileur d'énergie

Le Profileur d'énergie affiche une estimation de la consommation d'énergie de votre application, ainsi que des événements système qui affectent la consommation d'énergie, tels que les wakelocks, les alarmes et les tâches.

Le Profileur d'énergie apparaît sous la forme d'une nouvelle ligne au bas de la fenêtre Profileur lorsque vous exécutez votre application sur un appareil connecté ou sur Android Emulator exécutant Android 8.0 (API 26) ou version ultérieure.

Cliquez sur la ligne Énergie pour agrandir la vue "Profileur d'énergie". Placez le pointeur de la souris sur une barre de la chronologie pour afficher la répartition de la consommation d'énergie en fonction des ressources de processeur, de réseau et de localisation (GPS), ainsi que des événements système pertinents.

Les événements système qui affectent la consommation d'énergie sont indiqués dans la chronologie Système, sous la chronologie Énergie. Les détails des événements système sur la période spécifiée s'affichent dans le volet des événements lorsque vous sélectionnez une période dans la chronologie Énergie.

Pour afficher la pile d'appel et d'autres détails concernant un événement système, tel qu'un wakelock, sélectionnez-le dans le volet des événements. Pour accéder au code responsable d'un événement système, double-cliquez sur l'entrée dans la pile d'appel.

Vérification lint

Android Studio 3.2 inclut de nombreuses nouvelles fonctionnalités améliorées pour la vérification lint.

Les nouvelles vérifications lint vous aident à détecter et à identifier les problèmes de code courants, allant des avertissements sur les problèmes potentiels d'usabilité à des erreurs hautement prioritaires concernant d'éventuelles failles de sécurité.

Vérifications lint pour l'interopérabilité Java/Kotlin

Pour vous assurer que votre code Java fonctionne correctement avec votre code Kotlin, de nouvelles vérifications lint appliquent les bonnes pratiques décrites dans le guide d'interopérabilité Kotlin. Ces vérifications incluent, par exemple, la recherche de la présence d'annotations signalant la possibilité de valeur nulle, l'utilisation de mots clés durs Kotlin et le positionnement des paramètres lambda en dernier.

Pour activer ces vérifications, cliquez sur Fichier > Paramètres (Android Studio > Préférences sous Mac) pour ouvrir la boîte de dialogue Paramètres, accédez à la section Éditeur > Inspections > Android > Lint > Interopérabilité > Interopérabilité Kotlin, puis sélectionnez les règles que vous souhaitez activer.

Pour activer ces vérifications pour les builds de ligne de commande, ajoutez ce qui suit à votre fichier build.gradle :

android {
    lintOptions {
        check 'Interoperability'
    }
}

Vérifications lint pour les segments d'application

De nouvelles vérifications lint pour les segments d'application vous permettent de vous assurer que vous les créez correctement. Par exemple, les vérifications lint vous avertissent si vous n'avez attribué aucune action principale à un segment d'application.

Nouvelle cible Gradle

Utilisez la nouvelle tâche lintFix Gradle pour appliquer tous les correctifs sécurisés suggérés par la vérification lint directement au code source. SyntheticAccessor est un exemple de vérification lint qui suggère une solution sécurisée à appliquer.

Mises à jour des métadonnées

Différentes métadonnées, telles que la vérification de la diffusion du service, ont été mises à jour pour que les vérifications lint fonctionnent avec Android 9 (niveau d'API 28).

Avertissement en cas d'exécution de lint sur une nouvelle variante

Lint enregistre à présent la variante et la version avec lesquelles une référence est enregistrée, et vous avertit si vous l'exécutez sur une variante différente de celle avec laquelle la référence a été créée.

Améliorations apportées aux vérifications de lint existantes

Android Studio 3.2 inclut de nombreuses améliorations apportées aux vérifications lint existantes. Par exemple, les vérifications du cycle de ressources s'appliquent à présent à d'autres types de ressources, et le détecteur de traduction peut détecter rapidement les traductions manquantes dans l'éditeur.

ID de problème plus facilement détectables

Les ID de problème sont à présent affichés à d'autres emplacements, y compris dans la fenêtre Résultats de l'inspection. Vous pouvez ainsi trouver plus facilement les informations dont vous avez besoin pour activer ou désactiver des vérifications spécifiques via lintOptions dans build.gradle.

Pour en savoir plus, consultez Configurer les options lint avec Gradle.

Liaison de données V2

La liaison de données V2 est à présent activée par défaut et compatible avec V1. Cela signifie que, si vous avez compilé des dépendances de bibliothèque avec la version 1, vous pouvez les utiliser avec des projets utilisant la liaison de données V2. Notez toutefois que les projets utilisant la version 1 ne peuvent pas utiliser les dépendances compilées avec la version 2.

Désucrage de D8

Dans Android Studio 3.1, nous avons intégré l'étape de désucrage dans l'outil D8 en tant que fonctionnalité expérimentale, ce qui réduit la durée de compilation globale. Dans Android Studio 3.2, le désucrage avec D8 est activé par défaut.

Nouveau réducteur de code

R8 est un nouvel outil de minification de code et d'obscurcissement qui remplace ProGuard. Vous pouvez commencer à utiliser la version preview de R8 en incluant les éléments suivants dans le fichier gradle.properties de votre projet :

android.enableR8 = true

Modification des ABI par défaut pour les APK multiples

Lorsque vous créez plusieurs APK qui ciblent une ABI différente, le plug-in ne génère plus d'APK pour les ABI suivants par défaut : mips, mips64 et armeabi

Si vous souhaitez créer des APK ciblant ces ABI, vous devez utiliser NDK r16b ou une version antérieure et les spécifier dans votre fichier build.gradle, comme indiqué ci-dessous :

splits {
    abi {
        include 'armeabi', 'mips', 'mips64'
        ...
    }
}

splits {
    abi {
        include("armeabi", "mips", "mips64")
        ...
    }
}

Amélioration des fonctionnalités de l'éditeur pour les fichiers de compilation CMake

Si vous utilisez CMake pour ajouter du code C et C++ à votre projet, Android Studio inclut à présent des fonctionnalités d'édition améliorées pour vous aider à modifier vos scripts de compilation CMake, tels que le suivantes :

• Mise en surbrillance de la syntaxe et achèvement du code : l'IDE met à présent en évidence et suggère la saisie semi-automatique du code pour les commandes CMake courantes. Vous pouvez également accéder à un fichier en cliquant dessus tout en appuyant sur la touche Ctrl (Commande sur Mac).
• Reformatage du code : vous pouvez maintenant utiliser l'option de reformatage du code d'IntelliJ pour appliquer des styles de code à vos scripts de compilation CMake.
• Refactorisation sécurisée : les outils de refactorisation intégrés de l'IDE vérifient à présent si vous renommez ou supprimez des fichiers que vous référencez dans vos scripts de compilation CMake.

Accéder aux fichiers d'en-tête externes

Lorsque vous utilisez la fenêtre Projet dans les versions précédentes d'Android Studio, vous pouvez parcourir et inspecter uniquement les fichiers d'en-tête appartenant aux bibliothèques que vous avez compilées à partir d'un projet local. Avec cette version, vous pouvez également afficher et inspecter les fichiers d'en-tête inclus dans les dépendances de bibliothèques C/C++ externes que vous importez dans votre projet d'application.

Si vous incluez déjà du code C/C++ et des bibliothèques dans votre projet, ouvrez la fenêtre Projet à gauche de l'IDE en sélectionnant Vue > Fenêtres d'outil > Projet dans le menu principal, puis sélectionnez Android dans le menu déroulant. Dans le répertoire cpp, tous les en-têtes dans la portée de votre projet d'application sont organisés sous le nœud include pour chacune de vos dépendances de bibliothèques C/C++ locales, comme indiqué ci-dessous.

Multidex natif activé par défaut

Les versions précédentes d'Android Studio activaient le multidex natif lors du déploiement de la version de débogage d'une application sur un appareil exécutant l'API Android niveau 21 ou supérieur. À présent, que vous décidiez de déployer un appareil ou de créer un APK en vue de sa publication, le plug-in Android pour Gradle active le multidex natif pour tous les modules qui définissent minSdkVersion=21 ou version ultérieure.

AAPT2 déplacé vers le dépôt Maven de Google

À partir d'Android Studio 3.2, le dépôt Maven de Google est la source d'AAPT2 (Android Asset Packaging Tool 2).

Pour utiliser AAPT2, assurez-vous que votre fichier build.gradle comporte une dépendance google(), comme indiqué ci-dessous :

buildscript {
    repositories {
        google() // here
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.2.0'
    }
}
allprojects {
    repositories {
        google() // and here
        jcenter()
    }
}

buildscript {
    repositories {
        google() // here
        jcenter()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:3.2.0")
    }
}
allprojects {
    repositories {
        google() // and here
        jcenter()
    }
}

La nouvelle version d'AAPT2 résout de nombreux problèmes, y compris une meilleure gestion des caractères non-ASCII sous Windows.

Suppression de la configuration à la demande

La préférence Configurer à la demande a été supprimée d'Android Studio.

Android Studio ne transmet plus l'argument --configure-on-demand à Gradle.

Assistant de connexion ADB

Le nouvel assistant de connexion ADB fournit des instructions détaillées pour vous aider à configurer et à utiliser un appareil via la connexion Android Debug Bridge (ADB).

Pour lancer l'assistant, sélectionnez Outils > Assistant de connexion.

L'assistant de connexion ADB fournit des instructions, des commandes en contexte et une liste d'appareils connectés dans une série de pages du panneau Assistant.

Améliorations de l'émulateur

Vous pouvez à présent enregistrer et charger des instantanés d'un AVD (appareil virtuel Android) à tout moment dans Android Emulator. Vous pouvez ainsi rapidement et facilement renvoyer un appareil émulé à un état connu pour le tester. Lorsque vous modifiez un AVD à l'aide d'AVD Manager, vous pouvez spécifier l'instantané à charger au démarrage de l'AVD.

Les commandes permettant d'enregistrer, de charger et de gérer les instantanés AVD sont maintenant disponibles dans l'onglet Instantanés de la fenêtre Commandes étendues de l'émulateur.

Pour en savoir plus, consultez Instantanés.

Pour plus d'informations sur les nouveautés et les modifications apportées à l'émulateur, consultez les notes de version de l'émulateur.

3.1 (mars 2018)

Android Studio 3.1.0 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Codage/IDE

IntelliJ 2017.3.3

L'IDE principal d'Android Studio a été mis à jour avec les améliorations d'IntelliJ IDEA via la version 2017.3.3. Les améliorations incluent une meilleure analyse du flux de contrôle pour les collections et les chaînes, une meilleure inférence de possibilité de valeur nulle, de nouvelles corrections rapides, et bien plus encore.

Pour en savoir plus, consultez les notes de version JetBrains pour les versions 2017.2 et 2017.3 d'IntelliJ IDEA, ainsi que les notes de version JetBrains concernant les mises à jour de correction de bug.

Améliorations de l'édition SQL avec Room

Lorsque vous utilisez la bibliothèque de base de données Room, vous pouvez bénéficier de plusieurs améliorations apportées à la modification SQL :

• La saisie automatique du code dans une Query comprend les tables SQL (entités), les colonnes, les paramètres de requête, les alias, les jointures, les sous-requêtes et les clauses WITH.
• La mise en surbrillance de la syntaxe SQL est à présent possible.
• Vous pouvez effectuer un clic droit sur un nom de table dans SQL et le renommer, ce qui réécrit également le code Java ou Kotlin correspondant (par exemple, le type renvoyé de la requête). Le changement de nom fonctionne également dans l'autre sens. Par conséquent, renommer une classe ou un champ Java réécrit le code SQL correspondant.
• Les utilisations SQL sont affichées lorsque vous cliquez sur Trouver les utilisations (effectuez un clic droit et choisissez Trouver les utilisations dans le menu contextuel).
• Pour accéder à la déclaration d'une entité SQL en code Java ou Kotlin, vous pouvez maintenir la touche Ctrl (Commande sur Mac) enfoncée tout en cliquant sur l'entité.

Pour en savoir plus sur l'utilisation de SQL avec Room, consultez Enregistrer des données dans une base de données locale à l'aide de Room.

Mises à jour de la liaison de données

Cette mise à jour inclut plusieurs améliorations pour la liaison de données :

• Vous pouvez maintenant utiliser un objet LiveData comme champ observable dans les expressions de liaison de données. La classe ViewDataBinding inclut à présent une nouvelle méthode setLifecycle() que vous utilisez pour observer des objets LiveData.

• La classe ObservableField peut maintenant accepter d'autres objets Observable dans son constructeur.

• Vous pouvez prévisualiser un nouveau compilateur incrémentiel pour vos classes de liaison de données. Pour en savoir plus sur ce nouveau compilateur et obtenir des instructions d'activation, consultez Compileur de liaisons de données V2.

  Voici les avantages du nouveau compilateur :

  • Les classes ViewBinding sont générées par le plug-in Android pour Gradle avant le compilateur Java.

  • Les bibliothèques conservent leurs classes de liaison générées lorsque l'application est compilée, au lieu d'être régénérées à chaque fois. Cela peut améliorer considérablement les performances des projets multimodules.

Compilateur et Gradle

D8 est le compilateur DEX par défaut

Le compilateur D8 est à présent utilisé par défaut pour générer le bytecode DEX.

Ce nouveau compilateur DEX apporte plusieurs avantages, dont les suivants :

• Conversion en DEX plus rapide
• Utilisation de mémoire réduite
• Génération de code améliorée (meilleure allocation de registre, tables de chaînes plus intelligentes)
• Meilleure expérience de débogage lors de l'exécution du code

Vous n'avez pas besoin de modifier votre code ni votre workflow de développement pour bénéficier de ces avantages, sauf si vous avez précédemment désactivé manuellement le compilateur D8. Si vous définissez android.enableD8 sur false dans gradle.properties, supprimez cet indicateur ou définissez-le sur true :

android.enableD8=true

Pour en savoir plus, consultez Nouveau compilateur DEX.

Désucrage incrémentiel

Pour les projets qui utilisent les fonctionnalités du langage Java 8, le désucrage incrémentiel est activé par défaut, ce qui peut améliorer les durées de compilation.

Le désucrage convertit le sucre syntaxique en une forme que le compilateur peut traiter plus efficacement.

Vous pouvez désactiver le découpage incrémentiel en spécifiant les éléments suivants dans le fichier gradle.properties de votre projet :

android.enableIncrementalDesugaring=false

Fenêtre de sortie simplifiée

La console Gradle a été remplacée par la fenêtre Compilation, qui comporte les onglets Synchronisation et Compilation.

Pour savoir comment utiliser la nouvelle fenêtre simplifiée Compilation, consultez Surveiller le processus de compilation.

Mises à jour groupées et simultanéité d'indexation

Les processus de synchronisation Gradle et d'indexation IDE sont à présent beaucoup plus efficaces, ce qui réduit le temps perdu sur de nombreuses opérations d'indexation redondantes.

C++ et LLDB

Nous avons amélioré la qualité et les performances des phases de codage, de synchronisation, de compilation et de débogage du développement C++. Voici les améliorations apportées :

• Si vous travaillez avec des projets C++ volumineux, vous devriez constater une amélioration significative de la réduction du temps passé à compiler les symboles. La durée de synchronisation est aussi considérablement réduite pour les projets de grande envergure.

• Les performances de compilation et de synchronisation avec CMake ont été améliorées grâce à une réutilisation plus agressive des résultats mis en cache.

• L'ajout de formateurs ("imprimantes élégantes") pour plus de structures de données C++ facilite la lecture de la sortie LLDB.

• LLDB ne fonctionne à présent qu'avec Android 4.1 (niveau d'API 16) et versions ultérieures.

Kotlin

Kotlin mis à niveau vers la version 1.2.30

Android Studio 3.1 inclut la version 1.2.30 de Kotlin.

Le code Kotlin est à présent analysé avec la vérification lint en ligne de commande

La section Exécuter lint à partir de la ligne de commande analyse maintenant vos classes Kotlin.

Pour chaque projet sur lequel vous souhaitez exécuter lint, le dépôt Maven de Google doit être inclus dans le fichier build.gradle de premier niveau. Le dépôt Maven est déjà inclus pour les projets créés dans Android Studio 3.0 et versions ultérieures.

Outils d'optimisation des performances

Exemples de processus C++ natifs avec le Profileur de processeur

Le Profileur de processeur inclut à présent une configuration par défaut pour enregistrer des échantillons de traces des threads natifs de votre application. Vous pouvez utiliser cette configuration en déployant votre application sur un appareil exécutant Android 8.0 (niveau d'API 26) ou version ultérieure, puis en sélectionnant Échantillonné (natif) dans le menu déroulant des configurations d'enregistrement du Profileur de processeur. Ensuite, enregistrez et inspectez une trace comme vous le feriez normalement.

Vous pouvez modifier les paramètres par défaut, tels que l'intervalle d'échantillonnage, en créant une configuration d'enregistrement.

Pour revenir au traçage de vos threads Java, sélectionnez une configuration Échantillonné (Java) ou Instrumenté (Java).

Filtrer les traces du processeur, les résultats d'allocation de mémoire et les empreintes de la mémoire

Le Profileur de processeur et le Profileur de mémoire incluent une fonctionnalité de recherche qui vous permet de filtrer les résultats de l'enregistrement d'une trace de méthode, d'allocations de mémoire ou d'une empreinte de la mémoire.

Pour effectuer une recherche, cliquez sur Filtrer en haut à droite du volet, saisissez votre requête et appuyez sur Entrée.

Conseil : Vous pouvez aussi ouvrir le champ de recherche en appuyant sur Ctrl+F (Commande+F sur Mac).

Dans l'onglet Graphique de type "flamme" du Profileur de processeur, les piles d'appel qui incluent des méthodes liées à votre requête de recherche sont mises en surbrillance et déplacées vers la gauche du graphique.

Pour en savoir plus sur le filtrage par méthode, classe ou nom de package, consultez Enregistrer et inspecter les traces de méthode.

Onglet "Requête" du Profileur de réseau

Le Profileur de réseau inclut à présent un onglet Requête qui fournit des détails sur les requêtes réseau au cours de la chronologie sélectionnée. Dans les versions précédentes, le Profileur de réseau ne fournissait que des informations sur les réponses du réseau.

Vue "Thread" du Profileur de réseau

Après avoir sélectionné une partie de la chronologie dans le Profileur de réseau, vous pouvez sélectionner l'un des onglets suivants pour afficher plus de détails sur l'activité réseau au cours de cette période :

• Vue de connexion : fournit les mêmes informations que les versions précédentes d'Android Studio. Elle présente les fichiers envoyés ou reçus au cours de la partie sélectionnée de la chronologie sur l'ensemble des threads de processeur de votre application. Pour chaque requête, vous pouvez inspecter la taille, le type, l'état et la durée de la transmission.
• Affichage des fils de discussion : affiche l'activité réseau de chacun des fils du processeur de votre application. Cette vue vous permet d'identifier les threads de votre application qui sont responsables de chaque requête réseau.

Outil d'inspection de la mise en page

L'outil d'inspection de la mise en page a obtenu de nouvelles fonctionnalités, y compris certaines auparavant fournies par les outils obsolètes Hierarchy Viewer et Pixel Perfect :

• Boutons de zoom et raccourcis clavier pour parcourir et inspecter les mises en page
• Superposition de la grille de référence
• Possibilité de charger une image de référence et de l'utiliser comme superposition (utile pour comparer votre mise en page avec une maquette d'interface utilisateur)
• Afficher un aperçu de la sous-arborescence pour isoler une vue dans une mise en page complexe

Éditeur de mise en page

La palette de l'éditeur de mise en page a reçu de nombreuses améliorations :

• Réorganisation des catégories pour les vues et les mises en page
• Nouvelle catégorie Courant pour les vues et les mises en page, que vous pouvez ajouter à l'aide d'une commande Favoris
• Amélioration de la recherche de vues et de mises en page
• Nouvelles commandes permettant d'ouvrir la documentation pour un élément spécifique de vue ou de mise en page

Vous pouvez utiliser la nouvelle commande Convertir la vue dans l'arborescence des composants ou l'éditeur de conception pour convertir une vue ou une mise en page en un autre type de vue ou de mise en page.

Vous pouvez à présent créer facilement des contraintes sur les éléments proches de la vue sélectionnée à l'aide du nouveau bouton Créer une connexion dans l'inspecteur de vue en haut de la fenêtre Attributs.

Exécution et exécution instantanée

Le comportement de l'option Utiliser la même sélection pour les futurs lancements de la boîte de dialogue Sélectionner une cible de déploiement est maintenant plus cohérent. Si l'option Utiliser la même sélection est activée, la boîte de dialogue Sélectionner une cible de déploiement ne s'ouvre que la première fois que vous utilisez la commande Exécuter jusqu'à ce que l'appareil sélectionné ne soit plus connecté.

Lorsque vous ciblez un appareil équipé d'Android 8.0 (niveau d'API 26) ou version ultérieure, l'exécution instantanée peut déployer des modifications sur les ressources sans entraîner le redémarrage de l'application. Cela est possible parce que les ressources sont contenues dans un APK divisé.

Émulateur

Pour en savoir plus sur les nouveautés et les modifications apportées à l'émulateur depuis Android Studio 3.0, consultez les notes de version d'Android Emulator fournies de la version 27.0.2 à la version 27.1.12.

Voici les principales améliorations apportées :

• Instantanés de Quick Boot pour enregistrer l'état de l'émulateur et un démarrage plus rapide, avec la possibilité d'utiliser la commande Enregistrer maintenant pour enregistrer un état de démarrage personnalisé.
• Écran d'émulateur sans fenêtre.
• Images système pour Android 8.0 (niveau d'API 26), Android 8.1 (niveau d'API 27) et Preview développeur d'Android P.

Amélioration de l'interface utilisateur et de l'expérience utilisateur

Plus d'info-bulles, de raccourcis clavier et de messages utiles

Nous avons ajouté des info-bulles et des superpositions de messages utiles à de nombreux endroits dans Android Studio.

Pour afficher les raccourcis clavier de nombreuses commandes, positionnez le pointeur de la souris sur un bouton jusqu'à ce que l'info-bulle s'affiche.

Menu Outils > Android supprimé

Le menu Outils > Android a été supprimé. Les commandes qui se trouvaient dans ce menu ont été déplacées.

• De nombreuses commandes ont été déplacées directement dans le menu Outils.
• La commande Synchroniser le projet avec les fichiers Gradle a été déplacée dans le menu Fichier.
• La commande Moniteur d'appareil a été supprimée, comme décrit ci-dessous.

Moniteur d'appareil disponible depuis la ligne de commande

Dans Android Studio 3.1, le moniteur d'appareil n'a pas le même rôle qu'auparavant. Dans de nombreux cas, les fonctionnalités disponibles via le moniteur d'appareil sont à présent fournies par de nouveaux outils améliorés.

Consultez la documentation du moniteur d'appareil pour obtenir des instructions sur l'appel du moniteur d'appareil à partir de la ligne de commande, ainsi que pour en savoir plus sur les outils disponibles via le moniteur d'appareil.

3.0 (octobre 2017)

Android Studio 3.0.0 est une version majeure qui comprend plusieurs nouvelles fonctionnalités et améliorations.

Utilisateurs de macOS : si vous mettez à jour une ancienne version d'Android Studio, une boîte de dialogue d'erreur de mise à jour peut s'afficher avec le message "Des conflits ont été détectés dans la zone d'installation". Ignorez cette erreur et cliquez sur Annuler pour reprendre l'installation.

Plug-in Android pour Gradle 3.0.0

Le nouveau plug-in Android pour Gradle comprend diverses améliorations et nouvelles fonctionnalités, mais il améliore principalement les performances de compilation des projets comportant un grand nombre de modules. Lorsque vous utilisez le nouveau plug-in avec ces projets de grande envergure, vous devez constater ce qui suit :

• Les délais de configuration de compilation sont plus rapides en raison de la nouvelle résolution des dépendances retardées.
• Résolution des dépendances basées sur les variantes uniquement pour les projets et les variantes que vous compilez.
• Des durées de compilation incrémentielles plus courtes lors de l'application de modifications simples au code ou aux ressources.

Cette version inclut également ce qui suit :

• Compatibilité avec Android 8.0.
• Compatibilité avec la compilation d'APK distincts en fonction des ressources linguistiques.
• Compatibilité avec les bibliothèques Java 8 et les fonctionnalités du langage Java 8 (sans le compilateur Jack).
• Compatibilité avec Android Test Support Library 1.0 (Android Test Utility et Android Test Orchestrator).
• Amélioration de la vitesse de compilation de ndk-build et cmake.
• Amélioration de la vitesse de synchronisation de Gradle.
• AAPT2 est à présent activé par défaut.
• L'utilisation de ndkCompile est maintenant plus limitée. À la place, vous devez utiliser CMake ou ndk-build pour compiler le code natif que vous souhaitez empaqueter dans votre APK. Pour en savoir plus, consultez Migrer depuis ndkcompile.

Pour plus d'informations sur les modifications apportées, consultez les notes de version du plug-in Android pour Gradle.

Si vous êtes prêt à passer au nouveau plug-in, consultez Migrer vers le plug-in Android pour Gradle 3.0.0.

Compatibilité avec Kotlin

Comme annoncé au Google I/O 2017, le langage de programmation Kotlin est à présent officiellement compatible avec Android. Ainsi, Android Studio est compatible avec le langage Kotlin pour le développement d'Android.

Vous pouvez intégrer Kotlin à votre projet en convertissant un fichier Java en Kotlin (cliquez sur Code > Convertir un fichier Java en fichier Kotlin) ou en créant un projet compatible avec Kotlin à l'aide de l'assistant "Nouveau projet".

Pour commencer, découvrez comment ajouter Kotlin à votre projet.

Compatibilité des fonctionnalités du langage Java 8

Vous pouvez à présent utiliser certaines fonctionnalités du langage Java 8 et utiliser des bibliothèques créées avec Java 8. Jack n'est plus obligatoire. Vous devez d'abord désactiver Jack pour utiliser la compatibilité améliorée de Java 8 intégrée à la chaîne d'outils par défaut.

Pour mettre à jour votre projet afin qu'il soit compatible avec la nouvelle chaîne d'outils du langage Java 8, mettez à jour la Compatibilité source et la Compatibilité cible sur 1.8 dans la boîte de dialogue Structure du projet (cliquez sur Fichier > Structure du projet). Pour en savoir plus, découvrez comment utiliser les fonctionnalités du langage Java 8.

Profileur Android

Le nouveau Profileur Android remplace l'outil Android Monitor et fournit une nouvelle suite d'outils permettant de mesurer en temps réel l'utilisation du processeur, de la mémoire et du réseau de votre application. Vous pouvez effectuer un traçage de méthode basé sur des exemples pour chronométrer l'exécution de votre code, capturer des empreintes de mémoire, afficher les allocations de mémoire et inspecter les détails des fichiers transmis par le réseau.

Pour l'ouvrir, cliquez sur Vue > Fenêtres d'outil > Profileur Android (ou cliquez sur Profileur Android dans la barre d'outils).

La chronologie des événements en haut de la fenêtre affiche les événements tactiles, les pressions sur les touches et les modifications d'activité. Vous disposez ainsi de plus de contexte pour comprendre les autres événements de performances dans la chronologie.

Dans la chronologie de présentation du Profileur Android, cliquez sur les chronologies PROCESSEUR, MÉMOIRE ou RÉSEAU pour accéder aux outils correspondants du profileur.

Profileur de processeur

Le Profileur de processeur vous permet d'analyser l'utilisation des threads de processeur de votre application en déclenchant un échantillon ou une trace de processeur instrumentée. Vous pouvez ensuite résoudre les problèmes de performances du processeur à l'aide de divers filtres et vues de données.

Pour en savoir plus, consultez le guide du Profileur de processeur.

Profileur de mémoire

Le Profileur de mémoire vous aide à identifier les fuites et les pertes de mémoire qui peuvent entraîner des interruptions, des blocages et même des plantages d'applications. Il affiche un graphique en temps réel de l'utilisation de la mémoire de votre application, vous permet de capturer une empreinte de la mémoire, de forcer la récupération de mémoire et de suivre les allocations de mémoire.

Pour en savoir plus, consultez le guide du Profileur de mémoire.

Profileur de réseau

Le Profileur de réseau vous permet de surveiller l'activité réseau de votre application, d'inspecter la charge utile de chacune de vos requêtes réseau et de créer un lien vers le code qui a généré la requête réseau.

Pour en savoir plus, consultez le guide du Profileur de réseau.

Profilage et débogage APK

Android Studio vous permet à présent de  :profiler et déboguer n'importe quel APK sans avoir à le créer à partir d'un projet Android Studio, tant que l'APK est conçu pour activer le débogage et vous avez accès aux symboles de débogage et aux fichiers source.

Pour commencer, cliquez sur Profiler ou déboguer l'APK sur l'écran d'accueil d'Android Studio. Si vous avez déjà un projet ouvert, cliquez sur Fichier > Profiler ou déboguer l'APK dans la barre de menu. Les fichiers APK non empaquetés s'affichent, mais le code n'est pas décompilé. Ainsi, pour ajouter correctement des points d'arrêt et afficher les traces de la pile, vous devez joindre des fichiers source Java et des symboles de débogage natifs.

Pour en savoir plus, consultez Profiler et déboguer des APK prédéfinis.

Explorateur de fichiers de l'appareil

Le nouvel Explorateur de fichiers de l'appareil vous permet d'inspecter le système de fichiers de votre appareil connecté et de transférer des fichiers entre l'appareil et votre ordinateur. Il remplace l'outil de système de fichiers disponible dans DDMS.

Pour l'ouvrir, cliquez sur Vue > Fenêtres d'outil > Explorateur de fichiers de l'appareil.

Pour en savoir plus, consultez le guide de l'Explorateur de fichiers de l'appareil.

Compatibilité avec les applis instantanées

La nouvelle compatibilité des Applis instantanées Android vous permet de créer des applis instantanées dans votre projet à l'aide de deux nouveaux types de module : les modules Appli instantanée et les modules Fonctionnalité (vous devez installer le module SDK de développement d'applis instantanées).

Android Studio inclut également une nouvelle action de refactorisation modulaire pour vous aider à intégrer les applis instantanées dans un projet existant. Par exemple, si vous souhaitez refactoriser votre projet pour placer certaines classes dans un module de fonctionnalité d'appli instantanée, sélectionnez les classes dans la fenêtre Projet, puis cliquez sur Refactoriser > Modulariser. Dans la boîte de dialogue qui s'affiche, sélectionnez le module auquel les classes doivent accéder, puis cliquez sur OK.

Lorsque vous êtes prêt à tester votre appli instantanée, vous pouvez compiler et exécuter votre module Appli instantanée sur un appareil connecté. Pour ce faire, spécifiez l'URL de l'appli instantanée dans les options de lancement de configuration d'exécution : sélectionnez Exécuter > Modifier les configurations, sélectionnez votre module Appli instantanée, puis définissez l'URL dans Options de lancement.

Pour en savoir plus, consultez Applis instantanées Android.

Modules Android Things

Nouveaux modèles Android Things dans les assistants "Nouveau projet" et "Nouveau module" pour vous aider à commencer à développer pour les appareils IoT sous Android.

Pour en savoir plus, découvrez comment créer un projet Android Things.

Assistant Icônes adaptatives

Image Asset Studio est à présent compatible avec les drawables vectoriels et vous permet de créer des icônes de lanceur adaptatives pour Android 8.0 tout en créant simultanément des icônes traditionnelles (anciennes) pour les appareils plus anciens.

Pour commencer, effectuez un clic droit sur le dossier res dans votre projet, puis cliquez sur Nouveau > Composant Image. Dans la fenêtre Asset Studio, sélectionnez Icônes de lancement (adaptatives et anciennes) comme type d'icône.

Pour en savoir plus, consultez Icônes adaptatives.

Compatibilité avec les ressources de police

Pour prendre en charge les nouvelles ressources de police dans Android 8.0, Android Studio comprend un sélecteur de ressources de police pour faciliter le regroupement des polices dans votre application ou configurer votre projet pour télécharger les polices sur l'appareil (lorsqu'elles sont disponibles). L'éditeur de mise en page peut également prévisualiser les polices dans votre mise en page.

Pour tester les polices téléchargeables, assurez-vous que votre appareil ou votre émulateur exécute les services Google Play v11.2.63 ou version ultérieure. Pour en savoir plus, consultez Polices téléchargeables.

Assistant "Firebase App Indexing"

Firebase Assistant a été mis à jour avec un nouveau tutoriel pour tester l'indexation des applications. Pour ouvrir l'assistant, sélectionnez Outils > Firebase. Sélectionnez ensuite Indexation des applications > Tester l'indexation des applications.

Le tutoriel inclut de nouveaux boutons permettant de tester l'indexation de votre contenu public et personnel :

• À l'étape 2, cliquez sur Prévisualiser les résultats de recherche pour vérifier que vos URL apparaissent dans les résultats de recherche Google.
• À l'étape 3, cliquez sur Rechercher des erreurs pour vérifier que les objets indexables de votre application ont été ajoutés à l'index de contenu personnel.

Assistant "Android App Links"

L'assistant "Android App Links" a été mis à jour avec les nouvelles fonctionnalités suivantes :

• Ajouter des tests d'URL pour chaque mappage d'URL afin de vous assurer que vos filtres d'intent gèrent les URL réelles.

  

  Vous pouvez également définir ces tests d'URL manuellement à l'aide de la balise <tools:validation> décrite ci-dessous.

• Créer un fichier Digital Asset Links avec l'entrée d'objet appropriée pour prendre en charge Google Smart Lock et ajouter la balise asset_statements <meta-data> à votre fichier manifeste.

  

Programme de validation des filtres d'intent d'URL

Android Studio accepte maintenant une balise spéciale dans le fichier manifeste qui vous permet de tester vos URL de filtre d'intent. Ce sont les mêmes balises que l'assistant "App Links" peut créer pour vous.

Pour déclarer une URL de test pour un filtre d'intent, ajoutez un élément <tools:validation> à côté de l'élément <intent-filter> correspondant. Par exemple :

<activity ...>
    <intent-filter>
        ...
    </intent-filter>
    <tools:validation testUrl="https://www.example.com/recipe/1138" />
</activity>

Veillez également à inclure xmlns:tools="http://schemas.android.com/tools" dans la balise <manifest>.

Si l'une des URL de test ne passe pas la définition du filtre d'intent, une erreur lint s'affiche. Une telle erreur vous permet toujours de créer des variantes de débogage, mais elle endommagera vos builds.

Éditeur de mise en page

L'éditeur de mise en page a été mis à jour avec un certain nombre d'améliorations, y compris les suivantes :

• Nouvelles icônes et mise en page de la barre d'outils.
• Mise à jour de la mise en page dans l'arborescence des composants.
• Amélioration des insertions de la vue par glisser-déposer.
• Nouveau panneau d'erreur sous l'éditeur affichant tous les problèmes avec des suggestions de corrections (le cas échéant).
• Diverses améliorations de l'interface utilisateur pour la compilation avec ConstraintLayout, y compris les suivantes :
  • Nouvelle compatibilité avec la création de barrières.
  • Nouvelle compatibilité avec la création de groupes : dans la barre d'outils, sélectionnez Consignes > Ajouter un groupe (nécessite la version ConstraintLayout 1.1.0 bêta 2 ou ultérieure).
  • Nouvelle UI pour créer des chaînes : sélectionnez plusieurs vues, puis effectuez un clic droit et sélectionnez Chaîne.

Outil d'inspection de la mise en page

L'outil d'inspection de la mise en page inclut des améliorations qui facilitent le débogage des problèmes avec les mises en page de votre application, y compris le regroupement des propriétés dans des catégories communes et une nouvelle fonctionnalité de recherche dans les volets Arborescence de vues et Propriétés.

Analyseur d'APK

Vous pouvez à présent utiliser l'analyseur d'APK à partir de la ligne de commande avec l'outil apkanalyzer.

L'analyseur d'APK a également été mis à jour avec les améliorations suivantes :

• Pour les APK compilés avec ProGuard, vous pouvez charger des fichiers de mappage ProGuard qui ajoutent des fonctionnalités à la visionneuse DEX, y compris :
  • Des nœuds en gras pour indiquer que les nœuds ne doivent pas être supprimés lors de la réduction du code.
  • Un bouton pour afficher les nœuds supprimés pendant le processus de réduction.
  • Un bouton qui restaure les noms d'origine des nœuds dans l'arborescence que ProGuard a obscurcis.
• La visionneuse DEX affiche à présent l'impact estimé de la taille de chaque package, classe et méthode.
• De nouvelles options de filtrage en haut pour afficher et masquer des champs et des méthodes.
• Dans l'arborescence, les nœuds qui sont des références non définies dans le fichier DEX apparaissent en italique.

Pour en savoir plus, consultez Analyser votre compilation avec l'analyseur d'APK.

Aperçu du compilateur DEX D8

Android Studio 3.0 inclut un nouveau compilateur DEX facultatif, appelé D8. Il remplacera à terme le compilateur DX, mais vous pouvez choisir d'utiliser le nouveau compilateur D8 dès maintenant.

La compilation DEX a une incidence directe sur la durée de compilation de votre application, la taille de fichier .dex et les performances d'exécution. Par ailleurs, lorsque vous comparez le nouveau compilateur D8 au compilateur DX actuel, D8 compile plus rapidement et génère des fichiers .dex plus petits, tout en ayant des performances d'exécution d'application identiques ou supérieures.

Pour l'essayer, définissez les éléments suivants dans le fichier gradle.properties de votre projet :

android.enableD8=true

Pour en savoir plus, consultez l'article de blog sur le compilateur D8.

Dépôt Maven de Google

Android Studio utilise à présent le dépôt Maven de Google par défaut au lieu de dépendre d'Android SDK Manager pour obtenir des mises à jour pour la bibliothèque Android Support, les services Google Play, Firebase et d'autres dépendances. Cela permet de maintenir plus facilement vos bibliothèques à jour, en particulier lorsque vous utilisez un système d'intégration continue (CI).

Tous les nouveaux projets incluent à présent le dépôt Maven de Google par défaut. Pour mettre à jour votre projet existant, ajoutez google() dans le bloc repositories du fichier build.gradle de premier niveau :

allprojects {
    repositories {
        google()
    }
}

En savoir plus sur le dépôt Maven de Google ici.

Autres modifications

• Le débogage natif avec Android Studio n'est plus compatible avec Windows 32 bits. Nous avons choisi de nous concentrer sur d'autres plates-formes, car très peu de développeurs utilisent cette plate-forme. Si vous utilisez Windows 32 bits et que vous prévoyez de déboguer du code natif, vous devez continuer à utiliser Android Studio 2.3.
• Mise à niveau de l'IDE de base vers IntelliJ 2017.1.2, qui ajoute un certain nombre de nouvelles fonctionnalités des versions 2016.3 et 2017.1., tels que la refactorisation du langage Java 8, les optimisations de paramètres, la mise en surbrillance sémantique, les points d'arrêt déplaçables, les résultats instantanés dans la recherche, etc.
• Ajout de nombreuses nouvelles vérifications lint.
• Consultez également les dernières mises à jour d'Android Emulator.

2.3 (mars 2017)

Android Studio 2.3.0 est avant tout une correction de bug et une version de stabilité, mais il inclut également un certain nombre de nouvelles fonctionnalités.

Nouveau

• Android Studio peut à présent convertir les fichiers PNG, BMP, JPG et GIF statiques au format WebP. WebP est un format de fichier image de Google qui fournit une compression avec pertes (comme JPEG) ainsi qu'une transparence (comme PNG), mais qui peut fournir une meilleure compression que JPEG ou PNG. Pour en savoir plus, consultez la page Convertir des images au format WebP dans Android Studio.
• Le nouvel assistant "App Links" simplifie le processus d'ajout d'Android App Links à votre application via un assistant pas à pas. Les Android App Links sont des URL HTTP qui redirigent les utilisateurs directement vers un contenu spécifique de votre application Android.
• L'éditeur de mise en page est à présent compatible avec deux nouvelles fonctionnalités ConstraintLayout :
  • Définir une taille de vue en fonction d'un format.
  • Créer des groupes linéaires empaquetés, propagés et pondérés avec des chaînes de contraintes.
  Pour en savoir plus, consultez Créer une UI responsive avec ConstraintLayout.
• L'éditeur de mise en page vous permet également de créer une liste d'attributs favoris. Vous n'avez donc plus besoin de cliquer sur Afficher tous les attributs pour accéder aux attributs que vous utilisez le plus.
• Lorsque vous ajoutez une icône Material à l'aide de la boîte de dialogue Importation de vecteurs (Fichier > Nouveau > Élément vectoriel), vous pouvez à présent filtrer la liste des icônes disponibles par catégorie ou par nom d'icône. Pour en savoir plus, consultez Ajouter une icône Material.
• Annotations nouvelles et mises à jour. La nouvelle annotation @RestrictTo pour les méthodes, les classes et les packages vous permet de limiter une API. L'annotation @VisibleForTesting mise à jour dispose maintenant d'un argument otherwise facultatif qui vous permet de définir la visibilité d'une méthode si vous n'avez pas besoin de la rendre visible pour les tests. Lint utilise l'option otherwise pour appliquer la visibilité prévue de la méthode.
• La nouvelle compatibilité de référence lint vous permet d'utiliser un instantané de l'ensemble actuel d'avertissements de votre projet comme référence pour de futures exécutions d'inspection afin que seuls les nouveaux problèmes soient signalés. L'instantané de référence vous permet de commencer à utiliser lint pour faire échouer la compilation de nouveaux problèmes sans avoir à revenir en arrière pour résoudre d'abord tous les problèmes existants.
• Nouvelles vérifications lint, dont les suivantes :
  • Vérifications SDK_INT obsolètes : Android Studio supprime le code obsolète qui vérifie les versions du SDK.
  • Validation Object Animator : lint analyse votre code pour s'assurer que vos appels ObjectAnimator font référence à des méthodes valides avec les signatures appropriées et vérifie que ces méthodes sont annotées avec @Keep pour empêcher ProGuard de les renommer ou de les supprimer pendant les builds.
  • Copie inutile du décorateur d'élément : les anciennes versions de la bibliothèque RecyclerView n'incluaient pas de classe de décorateur de séparateur, mais une classe était fournie comme exemple dans les démonstrations de compatibilité. Les versions récentes de la bibliothèque ont une classe de décorateur de séparateur. Lint recherche l'ancien échantillon et suggère de le remplacer par le nouveau.
  • Fuite de WifiManager : dans les versions antérieures à Android 7.0 (niveau d'API 24), l'initialisation de WifiManager avec Context.getSystemService() peut entraîner une fuite de mémoire si le contexte n'est pas celui de l'application. Lint recherche ces initialisations. S'il ne peut pas déterminer que le contexte est celui de l'application, il vous suggère d'utiliser Context.getApplicationContext() pour obtenir le contexte approprié pour l'initialisation.
  • Préfixe de ressource amélioré : la vérification lint resourcePrefix existante présentait de nombreuses limites. Vous pouvez à présent configurer votre projet avec un préfixe, tel que android { resourcePrefix 'my_lib' }, et lint s'assure que toutes vos ressources utilisent ce préfixe. Vous pouvez utiliser des variantes du nom pour les styles et les thèmes. Par exemple, pour le préfixe my_lib, vous pouvez avoir des thèmes nommés MyLibTheme, myLibAttr, my_lib_layout, etc.
  • Passer à WebP : cette vérification identifie les images de votre projet qui peuvent être converties au format WebP en fonction du paramètre minSdkVersion de votre projet. Un correctif rapide associé peut convertir automatiquement les images, ou vous pouvez convertir manuellement les images au format WebP.
  • WebP non sécurisé : si votre projet comprend déjà des images WebP, cette vérification analyse votre projet pour s'assurer que votre paramètre minSdkVersion est suffisamment élevé pour accepter les images incluses. Pour en savoir plus sur la compatibilité de WebP avec Android et Android Studio, consultez Quels les navigateurs sont compatibles de manière native avec WebP ? et Créer des images WebP à l'aide d'Android Studio.

Modifications

• Un bouton distinct pour appliquer les modifications avec l'exécution instantanée : après avoir déployé votre application, vous devez à présent cliquer sur Appliquer les modifications pour appliquer rapidement les modifications incrémentielles à votre application en cours d'exécution à l'aide de l'exécution instantanée. Les boutons Exécuter et Déboguer sont toujours disponibles lorsque vous souhaitez appliquer vos modifications de manière fiable et forcer le redémarrage de l'application.
  • L'exécution instantanée n'est compatible qu'avec le déploiement de votre application sur un appareil cible équipé d'Android 5.0 (niveau d'API 21) ou version ultérieure.
  • L'exécution instantanée n'est plus désactivée pour les projets qui associent des projets natifs externes à l'aide de CMake ou de ndk-build. Cependant, vous ne pouvez utiliser l'exécution instantanée que pour appliquer des modifications incrémentielles à votre code Java, et non à votre code natif.
  • Les échanges à froid (que vous pouvez forcer pour une application en cours d'exécution en cliquant sur Exécuter ) sont maintenant plus fiables. Forcer un échange à froid résout également le problème où les modifications apportées aux UI de notification et de widget n'étaient pas mises à jour sur l'appareil cible.
  • Inclut des optimisations qui accélèrent le démarrage des applications. Ces optimisations peuvent avoir une incidence sur le profilage. Vous devez donc désactiver l'exécution instantanée temporairement chaque fois que vous profilez votre application.

• Les boutons AVD Manager et SDK Manager sont à présent inclus dans la barre de navigation simplifiée et dans la barre d'outils complète. Pour utiliser la barre de navigation simplifiée, cliquez sur Vue pour ouvrir le menu "Vue", puis assurez-vous que l'option Barre de navigation est sélectionnée et que l'option Barre d'outils n'est pas sélectionnée.

  
• Le débogueur "Hybrid" a été renommé "Dual".
• Dans la boîte de dialogue Configurations d'exécution/de débogage, sous "Valeurs par défaut" dans le volet de gauche, les noms de configuration d'exécution suivants ont été modifiés sans changement de comportement :
  • Le nom JUnit a été remplacé par Android JUnit. Si vous disposez d'un projet utilisant des configurations d'exécution JUnit, ces configurations sont transformées en configurations d'exécution Android JUnit la première fois que vous ouvrez le projet avec Android Studio. Une boîte de dialogue s'affiche pour vous informer du changement de nom.
  • Le nom Tests Android a été remplacé par Tests d'instrumentation Android.
• Le débogueur GPU a été supprimé d'Android Studio depuis la version 2.3. Une version autonome et open source de l'outil est maintenant disponible sur GitHub.
• L'option Exécuter/Déboguer n'est plus disponible lorsque vous effectuez un clic droit sur un script *.gradle build.
• Tous les modèles utilisent à présent ConstraintLayout comme mise en page par défaut.
• La palette "Widgets" de l'éditeur de mise en page a été repensée.

Cette version inclut également un certain nombre de corrections de bugs. Voir toutes les corrections de bugs de la version 2.3.0.

Problème connu : certains fabricants d'appareils empêchent les applications de se lancer automatiquement après leur installation sur l'appareil. Lors du déploiement de votre application sur un appareil physique à l'aide d'Android Studio 2.3, cette restriction rompt le comportement attendu de l'exécution instantanée et génère l'erreur suivante : Error: Not found; no service started. Pour éviter ce problème, utilisez l'émulateur ou activez le lancement automatique de votre application dans les paramètres de votre appareil. La procédure à suivre pour chaque appareil est différente. Nous vous recommandons donc de consulter les instructions fournies par le fabricant. Pour en savoir plus sur ce problème, consultez le problème n° 235879.

2.2 (septembre 2016)

Nouveau

• Nouvel éditeur de mise en page avec des outils conçus sur mesure pour accepter ConstraintLayout.
• Le nouvel outil d'inspection de la mise en page vous permet d'examiner les instantanés de votre hiérarchie de mise en page pendant que votre application s'exécute sur l'émulateur ou sur un appareil.
• Nouvelle fenêtre Assistant pour vous aider à intégrer les services Firebase à votre application.
• Nouvel outil d'analyseur d'APK pour pouvoir inspecter le contenu de votre application empaquetée.
• Nouvel outil Espresso Test Recorder (actuellement en version bêta) pour vous aider à créer des tests d'UI en enregistrant vos propres interactions.
• Nouveau cache de compilation (actuellement expérimental) pour accélérer les performances.
• Nouvelle intégration de compilation C/C++ avec CMake et ndk-build. Compilez et créez du code natif nouveau ou existant dans des bibliothèques empaquetées dans votre APK, et effectuez un débogage à l'aide de lldb. Pour les nouveaux projets, Android Studio utilise CMake par défaut, mais est également compatible avec ndk-build pour les projets existants. Pour savoir comment inclure du code natif dans votre application Android, consultez Ajouter des codes C et C++ à votre projet. Pour savoir comment déboguer du code natif avec lldb, consultez Déboguer le code natif.
• Le nouveau navigateur d'exemples vous permet de rechercher facilement des exemples de code Google Android dans Android Studio pour commencer à développer des applications.
• Nouvelle visionneuse de manifestes fusionnés pour vous aider à diagnostiquer la fusion de votre fichier manifeste avec les dépendances de votre application dans les variantes de compilation du projet.
• La fenêtre Exécuter contient à présent les messages de journal de l'application en cours d'exécution. Notez que vous pouvez configurer l'écran Surveiller logcat, mais pas la fenêtre Exécuter.
• Nouvelles fonctionnalités d'Android Emulator :
  • Ajout des commandes Capteurs virtuels et Mobile > Intensité du signal.
  • Ajout d'une option LTE à la commande Mobile > Type de réseau.
  • Ajout de simulations de balayages verticaux pour faire défiler les menus verticaux avec la molette de la souris.
• Nouvelles fonctionnalités de Configuration d'exécution/de débogage :
  • L'onglet Débogueur des modèles d'application Android et de tests Android contient maintenant plusieurs nouvelles options de débogage avec LLDB.
  • L'onglet Profilage des modèles d'application Android et de tests Android contient à présent une option Capturer les commandes GPU pour activer le traçage GPU. Vous pouvez afficher les traces GPU dans le débogueur GPU (fonctionnalité bêta).
  • Le modèle de tests Android dispose à présent d'une option Matrice des appareils Firebase Test Lab pour la cible de déploiement.
  • Le modèle d'application native est obsolète. Si vous utilisez ce modèle dans un projet, Android Studio le convertit automatiquement en modèle d'application Android.
  • Le modèle d'application Android a été renommé Application Android.
• Amélioration des fonctionnalités d'installation, de configuration, de performances et d'interface utilisateur dans le Débogueur GPU (actuellement en version bêta).
• Android Studio est à présent fourni avec OpenJDK 8. Les projets existants utilisent toujours le JDK spécifié dans Fichier > Structure du projet > Emplacement du SDK. Pour utiliser le nouveau JDK fourni, cliquez sur Fichier > Structure du projet > Emplacement du SDK, puis cochez la case Utiliser le JDK intégré.
• Ajout de menus et boutons d'aide dans l'interface utilisateur pour vous permettre de trouver plus facilement la documentation en ligne.

Modifications

• Mise à jour du codebase de l'IDE d'IntelliJ 15 vers IntelliJ 2016.1.
• L'exécution instantanée nécessite à présent l'installation du SDK de plate-forme correspondant au niveau d'API de l'appareil cible.
• L'exécution instantanée sera automatiquement désactivée si l'utilisateur exécute l'application sous un profil professionnel ou en tant qu'utilisateur secondaire.
• Correction de nombreux problèmes de fiabilité pour l'exécution instantanée où les modifications n'étaient pas déployées ou l'application plantait :
  • Certains composants d'application n'étaient pas déployés dans votre application en cours d'exécution. (Bug n° 213454).
  • L'application plante lorsque l'utilisateur passe d'une session d'exécution instantanée à une session d'exécution non instantanée où une classe sérialisable n'a pas de valeur serialVersionUID définie. (Bug n° 209006)
  • Les changements de style ne sont pas répercutés avec l'exécution instantanée. (Bug n° 210851)
  • La session d'exécution instantanée n'est pas fiable et provoque l'exception FileNotFoundException. (Bug n° 213083)
  • Les modifications apportées aux drawables ne sont pas reflétées tant que la recompilation complète n'est pas effectuée pour KitKat. (Bug n° 21530)
  • Les modifications de ressources ne sont pas reflétées avec l'exécution instantanée lorsque des ensembles de sources personnalisés contiennent des chemins imbriqués. (Bug n° 219145)
  • Le remplacement à chaud ne fonctionne pas si la classe modifiée contient une annotation avec une valeur enum. (Bug n° 209047)
  • Les modifications apportées aux données d'annotation ne sont pas reflétées avec l'exécution instantanée. (Bug n° 210089)
  • L'exécution instantanée ne récupère pas les modifications de code si vous apportez des modifications en dehors de l'IDE. (Bug n° 213205)
  • La session d'exécution instantanée n'est pas fiable en raison d'un jeton de sécurité non concordant. (Bug n° 211989)
  • L'échange à froid échoue pour les appareils qui ne sont pas compatibles avec le mode d'exécution. (Bug n° 210875)
  • Plantage de l'application après le redémarrage de l'exécution instantanée. (Bug n° 219744)
  • NotFoundFoundException a été observé lors du passage de l'exécution instantanée au débogage instantané. (Bug n° 215805)
• Amélioration des performances de synchronisation Gradle dans l'IDE, en particulier pour les projets de grande envergure.
• Amélioration des durées de compilation des builds complets et incrémentiels avec le nouveau code de packaging d'application.
• Amélioration des performances et des fonctionnalités du compilateur Jack, y compris la compatibilité avec les processeurs d'annotations et la conversion en DEX en cours. Pour en savoir plus, consultez les notes de version du plug-in Android pour Gradle 2.2.0.
• Suppression de la propriété AVD Échelle d'AVD Manager.
• Les options de ligne de commande -port et -ports d'Android Emulator indiquent à présent les ports et le numéro de série utilisés par l'instance de l'émulateur, et avertissent en cas de problème avec les valeurs que vous avez fournies.
• Amélioration de la boîte de dialogue Créer une classe et des modèles de fichiers correspondants. Remarque : si vous avez déjà personnalisé les modèles de fichiers AnnotationType, Class, Enum, Interface ou Singleton, vous devez modifier vos modèles pour qu'ils soient conformes aux nouveaux modèles. Sinon, vous ne pourrez pas utiliser ces nouveaux champs de la boîte de dialogue Créer une classe.
• Amélioration de l'interface utilisateur de Vector Asset Studio et ajout de la compatibilité avec les fichiers Adobe Photoshop (PSD).
• Amélioration de l'interface utilisateur d'Image Asset Studio.
• Amélioration du sélecteur de ressources de l'éditeur de thème.
• Correction des fuites de mémoire et réduction de l'utilisation globale de la mémoire dans Android Studio.
• Ajout d'un bouton Arrière-plan dans SDK Manager pour vous permettre de reprendre le travail et d'installer vos packages en arrière-plan.
• Amélioration des fonctionnalités d'accessibilité, y compris la compatibilité avec les lecteurs d'écran et la navigation au clavier.
• Amélioration de l'analyse de code, qui comprend des contrôles de qualité du code pour l'utilisation du langage Java 8 et une analyse plus poussée entre fichiers.
• Modification de plusieurs icônes de la barre d'outils.

2.1 (avril 2016)

Les principales modifications apportées à cette mise à jour sont compatibles avec le développement avec Android N Preview.

La plate-forme Android N est compatible avec les fonctionnalités du langage Java 8, qui nécessitent un nouveau compilateur expérimental appelé Jack. La dernière version de Jack n'est actuellement compatible qu'avec Android Studio 2.1. Si vous souhaitez utiliser les fonctionnalités du langage Java 8, vous devez donc utiliser Android Studio 2.1 pour créer votre application.

Remarque : L'exécution instantanée est désactivée lorsque vous activez le compilateur Jack, car ils ne sont actuellement pas compatibles.

Bien qu'Android Studio 2.1 soit maintenant stable, le compilateur Jack est encore en phase expérimentale et vous devez l'activer avec la propriété jackOptions dans votre fichier build.gradle.

Outre les modifications apportées pour assurer la compatibilité avec le preview N, Android Studio 2.1 inclut des corrections de bugs mineures et les améliorations suivantes :

• Le débogueur C++ compatible avec Java est maintenant activé par défaut lorsque vous utilisez un appareil ou un émulateur N et que vous sélectionnez le mode de débogueur Natif (dans l'onglet Débogueur pour votre configuration d'exécution/de débogage).

Pour accéder à d'autres améliorations, comme la compilation Java incrémentielle et la conversion en DEX, mettez à jour votre plug-in Android pour Gradle vers la version 2.1.0.

2.0 (avril 2016)

Remarque : Si vous développez pour le Preview développeur N, vous devez utiliser Android Studio 2.1 Preview. Android Studio 2.0 ne prend pas en charge toutes les fonctionnalités requises pour cibler le preview N.

Exécution instantanée :

• Android Studio déploie à présent des compilations propres plus rapidement que jamais. De plus, la transmission de modifications de code incrémentielles à l'émulateur ou à un appareil physique est à présent presque instantanée. Examinez vos mises à jour sans redéployer une nouvelle version de débogage ou, dans de nombreux cas, sans redémarrer l'application.
• L'exécution instantanée permet de transmettre les modifications suivantes à une application en cours d'exécution :
  • Modifications apportées à l'implémentation d'une méthode d'instance ou statique existante
  • Modifications apportées à une ressource d'application existante
  • Modifications apportées au code structurel, comme une signature de méthode ou un champ statique (nécessite un appareil cible exécutant le niveau d'API 21 ou supérieur)
• Consultez la documentation pour en savoir plus sur l'exécution instantanée.

  Remarque : L'exécution instantanée n'est disponible que lorsque vous déployez la variante de compilation de débogage, utilisez le plug-in Android pour Gradle 2.0.0 ou version ultérieure et configurez votre fichier build.gradle au niveau du module de votre application pour minSdkVersion 15 ou version ultérieure. Pour optimiser les performances, configurez votre application pour minSdkVersion 21 ou version ultérieure.

Nouveautés de lint :

• Inspection des instructions switch à l'aide d'entiers annotés @IntDef pour vérifier que toutes les constantes sont gérées. Pour ajouter rapidement des instructions manquantes, utilisez le menu déroulant "Action d'intent", puis sélectionnez Ajouter des constantes @IntDef manquantes.
• Indicateurs de tentatives incorrectes d'utilisation de l'interpolation de chaîne pour insérer des numéros de version dans le fichier build.gradle.
• Indicateurs des classes anonymes qui étendent la classe Fragment.
• Indicateurs de code natif dans des emplacements non sécurisés, tels que les dossiers res/ et asset/. Cet indicateur encourage le stockage du code natif dans le dossier libs/, qui est ensuite empaqueté de manière sécurisée dans le dossier data/app-lib/ de l'application au moment de l'installation. AOSP n° 169950
• Indicateurs des appels non sécurisés à Runtime.load() et System.load(). AOSP n° 179980
• Recherchez et supprimez les ressources inutilisées en sélectionnant Refactoriser > Supprimer les ressources inutilisées dans la barre de menu. La détection des ressources inutilisées est maintenant compatible avec les ressources référencées uniquement par les ressources inutilisées, les références dans les fichiers bruts tels que les références d'image .html et les attributs tools:keep et tools:discard utilisés par le réducteur de ressources Gradle, tout en tenant compte des ensembles de sources inactifs (comme les ressources utilisées dans d'autres types de compilation) et en gérant correctement les importations de champs statiques.
• Vérifie que les références d'API implicites sont compatibles avec toutes les plates-formes ciblées par minSdkVersion.
• Indicateurs de l'utilisation incorrecte de RecyclerView et Parcelable.
• Les inspections @IntDef, @IntRange et @Size sont à présent également vérifiées pour varargs et les tableaux int.

Autres améliorations :

• Optimisation pour Android Emulator 2.0, qui est plus rapide que jamais, est compatible avec une plus grande variété d'appareils virtuels et dispose d'une interface utilisateur considérablement améliorée. Pour en savoir plus sur le nouvel émulateur, consultez les notes de version de SDK Tools.
• Améliorations du Gestionnaire d'appareil virtuel Android :
  • Les images système sont à présent classées dans les onglets suivants : Recommandé, x86 et Autre.
  • Sous "Paramètres avancés", vous pouvez activer la compatibilité multicœur et spécifier le nombre de cœurs que l'émulateur peut utiliser.
  • Sous "Paramètres avancés", vous pouvez déterminer le rendu des graphismes sur l'émulateur en sélectionnant l'une des options suivantes :
    • Matériel : utilisez la carte graphique de votre ordinateur pour accélérer le rendu.
    • Logiciel : utilisez le rendu basé sur le logiciel.
    • Auto : laisse l'émulateur décider de la meilleure option. Il s'agit du paramètre par défaut.
• Amélioration des temps de packaging AAPT en spécifiant une cible de déploiement avant la création de l'application. Android Studio peut ainsi empaqueter efficacement les ressources requises par l'appareil spécifié.
• Ajout de l'intégration de Cloud Test Lab pour fournir des tests d'application à la demande avec la commodité et l'évolutivité d'un service cloud. Découvrez comment utiliser Cloud Test Lab avec Android Studio.
• Ajout d'un aperçu du nouveau Débogueur GPU. Pour les applications nécessitant d'importantes capacités de traitement graphique, vous pouvez à présent parcourir visuellement votre code OpenGL ES pour optimiser votre application ou votre jeu.
• Ajout du test d'indexation des applications Google. Ajoutez à vos applications la compatibilité avec les URL, l'indexation des applications et la fonctionnalité de recherche afin de générer plus de trafic vers votre application, d'identifier le contenu le plus utilisé et d'attirer de nouveaux utilisateurs. Testez et validez les URL dans votre application depuis Android Studio. Consultez Compatibilité avec les URL et l'indexation des applications dans Android Studio.
• Mises à niveau depuis la dernière version d'IntelliJ 15, y compris une analyse et des performances améliorées du code. Pour obtenir une description complète des nouvelles fonctionnalités et améliorations, consultez Nouveautés d'IntelliJ.
• La saisie semi-automatique de l'éditeur XML ajoute à présent des guillemets lorsque vous remplissez des attributs. Pour vérifier si cette option est activée, ouvrez la boîte de dialogue Paramètre ou Préférences, accédez à Éditeur > Général > Touches intelligentes, puis cochez la case Ajouter des guillemets pour la valeur d'attribut à la fin de l'attribut. Problème : 195113
• L'éditeur XML prend à présent en charge la saisie semi-automatique du code pour les expressions de liaison de données.

Versions antérieures