Améliorer votre code avec des vérifications lint

En plus de créer des tests pour vous assurer que votre application répond à ses exigences fonctionnelles, il est important d'exécuter le code via l'outil lint pour vous assurer qu'il ne présente aucun problème structurel. L'outil lint vous aide à détecter un code mal structuré qui peut affecter la fiabilité et l'efficacité de vos applications Android et compliquer la gestion du code. Nous vous recommandons vivement de corriger les erreurs que lint détecte avant de publier votre application.

Par exemple, si vos fichiers de ressources XML contiennent des espaces de noms inutilisés, l'espace supplémentaire requis entraîne un traitement inutile. D'autres problèmes structurels, tels que l'utilisation d'éléments obsolètes ou d'appels d'API non compatibles avec les versions d'API cibles, peuvent entraîner une mauvaise exécution du code. lint peut vous aider à résoudre ces problèmes.

Pour améliorer les performances de lint, vous pouvez également ajouter des annotations à votre code.

Présentation

Android Studio fournit un outil d'analyse de code appelé lint qui peut vous aider à identifier et à corriger les problèmes liés à la qualité structurelle de votre code, sans avoir à exécuter l'application ni à écrire de scénarios de test. Chaque problème détecté par l'outil est signalé par un message descriptif avec un niveau de gravité, afin que vous puissiez rapidement prioriser les améliorations critiques à apporter. Vous pouvez également réduire le niveau de gravité d'un problème pour ignorer les problèmes sans rapport avec votre projet ou l'augmenter pour mettre en évidence des problèmes spécifiques.

L'outil lint vérifie que les fichiers sources de votre projet Android ne présentent pas de bugs potentiels et propose des optimisations visant à garantir leur exactitude, leur sécurité, leurs performances, leur facilité d'utilisation, leur accessibilité et leur internationalisation. Lorsque vous utilisez Android Studio, des inspections d'analyse lint et IDE configurées s'exécutent lorsque vous créez votre application. Toutefois, vous pouvez exécuter manuellement des inspections ou exécuter lint à partir de la ligne de commande, comme décrit sur cette page.

L'outil lint intégré vérifie votre code lorsque vous utilisez Android Studio. Vous pouvez consulter les avertissements et les erreurs des deux manières suivantes :

• Sous forme de pop-up dans la fenêtre de l'éditeur. Lorsque lint détecte un problème, il surligne en jaune le code problématique. Pour les problèmes plus graves, il souligne le code en rouge.
• Dans la fenêtre lint Résultats de l'inspection, cliquez sur Code > Inspecter le code.

Remarque:Lorsque votre code est compilé dans Android Studio, des inspections de code IntelliJ supplémentaires sont effectuées pour simplifier l'examen du code. Tenez Android Studio à jour autant que possible pour vous assurer que les dernières règles et inspections lint sont disponibles.

La figure 1 montre comment lint traite les fichiers sources de l'application.

Fichiers sources de l'application

Les fichiers sources sont constitués de fichiers composant votre projet Android, y compris des fichiers Kotlin, Java et XML, des icônes et des fichiers de configuration ProGuard.

Le fichier lint.xml

Un fichier de configuration que vous pouvez utiliser pour spécifier les vérifications lint que vous voulez exclure et pour personnaliser les niveaux de gravité des problèmes.

L'outil lint

Lecteur de code statique que vous pouvez exécuter sur votre projet Android, à partir de la ligne de commande ou dans Android Studio. L'outil lint recherche les problèmes structurels du code qui pourraient affecter la qualité et les performances de votre application Android.

Résultats de la vérification lint

Vous pouvez consulter les résultats de lint dans la console ou dans la fenêtre Inspection Results (Résultats d'inspection) d'Android Studio. Si vous exécutez lint à partir de la ligne de commande, les résultats sont écrits dans le dossier build/. Pour en savoir plus, consultez la section sur l'exécution manuelle des inspections.

Exécuter lint depuis la ligne de commande

Si vous utilisez Android Studio ou Gradle, utilisez le wrapper Gradle pour appeler la tâche lint pour votre projet en saisissant l'une des commandes suivantes à partir du répertoire racine de votre projet:

Remarque:Gardez le plug-in Android Gradle aussi à jour que possible pour utiliser les dernières règles lint.

• Sous Windows :

  gradlew lint
  

• Sous Linux ou macOS :

  ./gradlew lint
  

Un résultat semblable aux lignes suivantes doit s'afficher :

> Task :app:lintDebug
Wrote HTML report to file:<path-to-project>/app/build/reports/lint-results-debug.html

Lorsque lint effectue ses vérifications, il fournit les chemins d'accès aux versions XML et HTML du rapport lint. Vous pouvez ensuite accéder au rapport HTML et l'ouvrir dans votre navigateur, comme illustré dans la figure 2.

Si votre projet comprend des variantes de compilation, lint ne vérifie que la variante par défaut. Si vous souhaitez exécuter lint sur une autre variante, vous devez mettre le nom de la variante en majuscules et y ajouter le préfixe lint.

./gradlew lintRelease

Remarque:Lint n'est pas exécuté automatiquement lors de la compilation. Nous vous recommandons vivement d'exécuter explicitement lint dans le cadre d'un build d'intégration continue afin de voir les dernières vérifications lint lorsque vous créez votre code source existant.

Pour en savoir plus sur l'exécution de tâches Gradle à partir de la ligne de commande, consultez l'article Créer une application à partir de la ligne de commande.

Exécuter lint à l'aide de l'outil autonome

Si vous n'utilisez pas Android Studio ou Gradle, installez les outils de ligne de commande du SDK Android pour utiliser l'outil lint autonome. Localisez l'outil lint à l'emplacement android_sdk/cmdline-tools/version/bin/lint.

Remarque:Si vous essayez d'exécuter l'outil autonome sur un projet Gradle, une erreur s'affiche. Vous devez toujours utiliser gradle lint (sous Windows) ou ./gradlew lint (sous macOS ou Linux) pour exécuter lint sur un projet Gradle.

Pour exécuter lint sur une liste de fichiers dans un répertoire de projet, utilisez la commande suivante :

lint [flags] <project directory>

Vous pouvez par exemple exécuter la commande suivante pour analyser les fichiers du répertoire myproject et de ses sous-répertoires. L'ID de problème MissingPrefix indique à lint de rechercher uniquement les attributs XML qui ne comportent pas le préfixe de l'espace de noms Android.

lint --check MissingPrefix myproject 

Pour consulter la liste complète des options et des arguments de ligne de commande pris en charge par l'outil, utilisez la commande suivante :

lint --help

L'exemple suivant montre le résultat de la console lorsque la commande lint s'exécute sur un projet appelé Earthquake:

$ lint Earthquake

Scanning Earthquake: ...............................................................................................................................
Scanning Earthquake (Phase 2): .......
AndroidManifest.xml:23: Warning: <uses-sdk> tag appears after <application> tag [ManifestOrder]
  <uses-sdk android:minSdkVersion="7" />
  ^
AndroidManifest.xml:23: Warning: <uses-sdk> tag should specify a target API level (the highest verified version; when running on later versions, compatibility behaviors may be enabled) with android:targetSdkVersion="?" [UsesMinSdkAttributes]
  <uses-sdk android:minSdkVersion="7" />
  ^
res/layout/preferences.xml: Warning: The resource R.layout.preferences appears to be unused [UnusedResources]
res: Warning: Missing density variation folders in res: drawable-xhdpi [IconMissingDensityFolder]
0 errors, 4 warnings

L'exemple de sortie liste quatre avertissements et aucune erreur.

Deux avertissements concernent le fichier AndroidManifest.xml du projet:

• ManifestOrder
• UsesMinSdkAttributes

Un avertissement concerne le répertoire res : IconMissingDensityFolder.

Configurer lint pour supprimer les avertissements

Par défaut, lorsque vous exécutez une analyse lint, l'outil vérifie tous les problèmes compatibles avec lint. Vous pouvez également limiter les problèmes, de sorte que lint vérifie uniquement ces problèmes et leur attribue un niveau de gravité. Vous pouvez par exemple désactiver la vérification lint pour des problèmes spécifiques qui ne sont pas pertinents pour votre projet. Vous pouvez aussi configurer lint pour signaler les problèmes non critiques à un niveau de gravité inférieur.

Les niveaux de gravité sont les suivants:

• enable
• disable ou ignore
• informational
• warning
• error
• fatal

Vous pouvez configurer la vérification lint pour différents niveaux :

• Global (intégralité du projet)
• Module de projet
• Module de production
• Module de test
• Fichiers ouverts
• Hiérarchie des classes
• Champs d'application du système de contrôle des versions

Configurer le fichier lint

Vous pouvez spécifier vos préférences de vérification lint dans le fichier lint.xml. Si vous créez ce fichier manuellement, placez-le dans le répertoire racine de votre projet Android.

Le fichier lint.xml consiste en une balise parente <lint> englobante qui contient un ou plusieurs éléments enfants <issue>. lint définit une valeur d'attribut id unique pour chaque <issue>:

<?xml version="1.0" encoding="UTF-8"?>
<lint>
    <!-- list of issues to configure -->
</lint>

Pour modifier le niveau de gravité d'un problème ou désactiver la vérification lint pour le problème, définissez l'attribut de gravité dans la balise <issue>.

Conseil : Pour obtenir la liste complète des problèmes pris en charge par lint et des ID de problème correspondants, exécutez la commande lint --list.

Exemple de fichier lint.xml

L'exemple suivant présente le contenu d'un fichier lint.xml:

<?xml version="1.0" encoding="UTF-8"?>
<lint>
    <!-- Disable the IconMissingDensityFolder check in this project -->
    <issue id="IconMissingDensityFolder" severity="ignore" />

    <!-- Ignore the ObsoleteLayoutParam issue in the specified files -->
    <issue id="ObsoleteLayoutParam">
        <ignore path="res/layout/activation.xml" />
        <ignore path="res/layout-xlarge/activation.xml" />
    </issue>

    <!-- Ignore the UselessLeaf issue in the specified file -->
    <issue id="UselessLeaf">
        <ignore path="res/layout/main.xml" />
    </issue>

    <!-- Change the severity of hardcoded strings to "error" -->
    <issue id="HardcodedText" severity="error" />
</lint>

Cet exemple montre comment différents types de problèmes sont signalés. La vérification IconMissingDensityFolder est complètement désactivée, et la vérification ObsoleteLayoutParam n'est désactivée que dans les fichiers spécifiés dans les déclarations <ignore ... /> incluses.

Configurer la vérification lint pour les fichiers source Kotlin, Java et XML

Vous pouvez désactiver la vérification lint pour vos fichiers sources Kotlin, Java et XML dans la boîte de dialogue Preferences (Préférences) :

1. Sélectionnez File > Settings (Fichier > Paramètres) sous Windows ou Android Studio > Preferences (Android Studio > Préférences) sous macOS ou Linux.
2. Sélectionnez Éditeur > Inspections.
3. Pour désactiver la fonctionnalité, désélectionnez le fichier source approprié.

Vous pouvez les définir pour l'IDE ou pour des projets individuels en sélectionnant le profil approprié.

Configurer la vérification lint en Java ou Kotlin

Pour désactiver la vérification lint pour une classe ou une méthode spécifique de votre projet Android, ajoutez l'annotation @SuppressLint à ce code.

L'exemple suivant montre comment désactiver la vérification lint pour le problème NewApi dans la méthode onCreate. L'outil lint continue de rechercher le problème NewApi dans d'autres méthodes de cette classe.

@SuppressLint("NewApi")
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.main)

@SuppressLint("NewApi")
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

Vous pouvez faire de même avec n'importe quel composable. L'extrait de code suivant montre comment désactiver les vérifications NewApi sur n'importe quel composable.

  @SuppressLint("NewApi")
  @Composable
  fun MyComposable{
    ...
  }
  

L'exemple suivant montre comment désactiver la vérification lint pour le problème ParserError dans la classe FeedProvider :

@SuppressLint("ParserError")
class FeedProvider : ContentProvider() {

@SuppressLint("ParserError")
public class FeedProvider extends ContentProvider {

Pour supprimer la vérification de tous les problèmes lint dans le fichier, utilisez le mot clé all:

@SuppressLint("all")

@SuppressLint("all")

Vous pouvez utiliser la même annotation pour supprimer les vérifications lint sur n'importe quelle fonction Composable.

Configurer la vérification lint dans XML

Utilisez l'attribut tools:ignore pour désactiver la vérification lint pour des sections spécifiques de vos fichiers XML. Placez la valeur de l'espace de noms suivante dans le fichier lint.xml afin que l'outil lint reconnaisse l'attribut :

namespace xmlns:tools="http://schemas.android.com/tools"

L'exemple suivant montre comment désactiver la vérification lint pour le problème UnusedResources dans un élément <LinearLayout> d'un fichier de mise en page XML. Les éléments enfants de l'élément parent dans lequel l'attribut ignore est déclaré héritent de cet attribut. Dans cet exemple, la vérification lint est également désactivée pour l'élément enfant <TextView>:

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:ignore="UnusedResources" >

    <TextView
        android:text="@string/auto_update_prompt" />
</LinearLayout>

Pour désactiver plusieurs problèmes, répertoriez-les dans une chaîne séparée par des virgules. Exemple :

tools:ignore="NewApi,StringFormatInvalid"

Pour supprimer la vérification de tous les problèmes lint dans l'élément XML, utilisez le mot clé all:

tools:ignore="all"

Configurer les options lint avec Gradle

Le plug-in Android Gradle vous permet de configurer certaines options lint, telles que les vérifications à exécuter ou à ignorer, à l'aide du bloc lint{} dans votre fichier build.gradle au niveau du module.

L'extrait de code suivant présente certaines des propriétés que vous pouvez configurer:

android {
    ...
    lint {
        // Turns off checks for the issue IDs you specify.
        disable += "TypographyFractions" + "TypographyQuotes"
        // Turns on checks for the issue IDs you specify. These checks are in
        // addition to the default lint checks.
        enable += "RtlHardcoded" + "RtlCompat" + "RtlEnabled"
        // To enable checks for only a subset of issue IDs and ignore all others,
        // list the issue IDs with the 'check' property instead. This property overrides
        // any issue IDs you enable or disable using the properties above.
        checkOnly += "NewApi" + "InlinedApi"
        // If set to true, turns off analysis progress reporting by lint.
        quiet = true
        // If set to true (default), stops the build if errors are found.
        abortOnError = false
        // If set to true, lint only reports errors.
        ignoreWarnings = true
        // If set to true, lint also checks all dependencies as part of its analysis.
        // Recommended for projects consisting of an app with library dependencies.
        checkDependencies = true
    }
}
...

android {
    ...
    lint {
        // Turns off checks for the issue IDs you specify.
        disable 'TypographyFractions','TypographyQuotes'
        // Turns on checks for the issue IDs you specify. These checks are in
        // addition to the default lint checks.
        enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'
        // To enable checks for only a subset of issue IDs and ignore all others,
        // list the issue IDs with the 'check' property instead. This property overrides
        // any issue IDs you enable or disable using the properties above.
        checkOnly 'NewApi', 'InlinedApi'
        // If set to true, turns off analysis progress reporting by lint.
        quiet true
        // If set to true (default), stops the build if errors are found.
        abortOnError false
        // If set to true, lint only reports errors.
        ignoreWarnings true
        // If set to true, lint also checks all dependencies as part of its analysis.
        // Recommended for projects consisting of an app with library dependencies.
        checkDependencies true
    }
}
...

Créer une référence d'avertissements

Vous pouvez prendre un instantané de l'ensemble d'avertissements actuel de votre projet, puis l'utiliser comme référence pour les 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 sans avoir à revenir en arrière pour pouvoir résoudre tous les problèmes existants.

Pour créer un instantané de référence, modifiez le fichier build.gradle de votre projet comme suit:

android {
    lint {
        baseline = file("lint-baseline.xml")
    }
}

android {
    lintOptions {
        baseline file("lint-baseline.xml")
    }
}

Lorsque vous ajoutez cette ligne pour la première fois, le fichier lint-baseline.xml est créé pour établir votre référence. Ensuite, les outils ne lisent que le fichier pour déterminer la référence. Si vous souhaitez créer une référence, supprimez manuellement le fichier et exécutez à nouveau lint pour le recréer.

Exécutez ensuite lint depuis l'IDE en sélectionnant Code > Inspecter le code ou depuis la ligne de commande comme indiqué ci-dessous. Le résultat imprime l'emplacement du fichier lint-baseline.xml. L'emplacement du fichier pour votre configuration peut être différent de celui affiché ici:

$ ./gradlew lintDebug -Dlint.baselines.continue=true
...
Wrote XML report to file:///app/lint-baseline.xml
Created baseline file /app/lint-baseline.xml

L'exécution de lint enregistre tous les problèmes actuels dans le fichier lint-baseline.xml. L'ensemble de problèmes actuels est désigné sous le nom de référence. Vous pouvez contrôler le fichier lint-baseline.xml dans le contrôle des versions si vous souhaitez le partager avec d'autres utilisateurs.

Personnaliser la référence

Si vous ne souhaitez ajouter que certains types de problèmes à la référence, spécifiez les problèmes à ajouter en modifiant le fichier build.gradle de votre projet comme suit:

android {
    lint {
        checkOnly += "NewApi" + "HandlerLeak"
        baseline = file("lint-baseline.xml")
    }
}

android {
    lintOptions {
        checkOnly 'NewApi', 'HandlerLeak'
        baseline file("lint-baseline.xml")
    }
}

Si vous ajoutez de nouveaux avertissements au codebase après avoir créé la référence, lint ne présente que les nouveaux bugs.

Avertissement de référence

Lorsqu'une référence est active, vous recevez un avertissement vous informant qu'un ou plusieurs problèmes ont été filtrés, car ils sont listés dans la référence. Cet avertissement vous permet de vous rappeler que vous avez configuré une référence et que vous devez résoudre tous les problèmes à un moment donné.

Cet avertissement informatif permet également de suivre les problèmes qui ne sont plus signalés. Ces informations vous indiquent si vous avez réellement résolu les problèmes, vous permettant ainsi de recréer la référence pour éviter qu'une erreur ne se produise à nouveau et passe inaperçue.

Remarque : Les références sont activées lorsque vous exécutez des inspections en mode de traitement par lot dans l'IDE, mais elles sont ignorées pour les vérifications dans l'éditeur exécutées en arrière-plan lorsque vous modifiez un fichier. En effet, les références sont conçues pour les cas où un codebase comporte un grand nombre d'avertissements existants, mais que vous souhaitez résoudre les problèmes localement lorsque vous modifiez le code.

Exécuter des inspections manuellement

Pour exécuter manuellement des vérifications lint et d'autres inspections IDE configurées, sélectionnez Code > Inspecter le code. Les résultats de l'inspection s'affichent dans la fenêtre Résultats de l'inspection.

Définir le champ d'application et le profil d'inspection

Sélectionnez les fichiers que vous souhaitez analyser (champ d'application de l'inspection) et les inspections que vous souhaitez exécuter (profil d'inspection), comme suit:

1. Dans la vue Android, ouvrez votre projet et sélectionnez le projet, le dossier ou le fichier que vous souhaitez analyser.
2. Dans la barre de menu, sélectionnez Code > Inspecter le code.

3. Dans la boîte de dialogue Spécifier le champ d'application de l'inspection, vérifiez les paramètres.

   

   Les options affichées dans la boîte de dialogue Spécifier l'étendue de l'inspection varient selon que vous avez sélectionné un projet, un dossier ou un fichier:

   • Lorsque vous sélectionnez un projet, un fichier ou un répertoire, la boîte de dialogue Spécifier l'étendue de l'inspection affiche le chemin d'accès au projet, au fichier ou au répertoire que vous avez sélectionné.
   • Lorsque vous sélectionnez plusieurs projets, fichiers ou répertoires, la boîte de dialogue Spécifier l'étendue de l'inspection affiche une case d'option cochée pour les fichiers sélectionnés.

   Pour modifier les éléments à inspecter, sélectionnez l'une des autres cases d'option. Consultez la boîte de dialogue Spécifier le champ d'application de l'inspection pour obtenir une description de tous les champs possibles dans la boîte de dialogue Spécifier le champ d'application de l'inspection.

4. Sous Profil d'inspection, sélectionnez le profil que vous souhaitez utiliser.

5. Cliquez sur OK pour exécuter l'inspection.

   La figure 4 montre les résultats de la vérification lint et d'autres inspections IDE ainsi que les données concernant l'exécution du code d'inspection:

   

6. Dans le volet Résultats de l'inspection, affichez les résultats de l'inspection en développant et en sélectionnant des catégories, des types ou des problèmes d'erreur.

   Le volet Rapport d'inspection affiche le rapport d'inspection pour la catégorie, le type ou le problème d'erreur sélectionné dans le volet Résultats de l'inspection, ainsi que le nom et l'emplacement de l'erreur. Le cas échéant, le rapport d'inspection affiche d'autres informations, par exemple un résumé du problème, pour vous aider à le résoudre.

7. Dans l'arborescence du volet Résultats de l'inspection, effectuez un clic droit sur une catégorie, un type ou un problème pour afficher le menu contextuel.

   Selon le contexte, vous pouvez:

   • Accédez à la source.
   • Excluez et incluez les éléments sélectionnés.
   • Résoudre les problèmes
   • Modifiez les paramètres.
   • Gérer les alertes d'inspection
   • Relancez une inspection.

Pour obtenir une description des boutons de la barre d'outils, des éléments du menu contextuel et des champs du rapport d'inspection, consultez l'article Fenêtre de l'outil "Résultats de l'inspection".

Utiliser un champ d'application personnalisé

Utilisez l'un des champs d'application personnalisés fournis dans Android Studio, comme suit:

1. Dans la boîte de dialogue Spécifier l'étendue de l'inspection, sélectionnez Champ d'application personnalisé.

2. Cliquez sur la liste Champ d'application personnalisé pour afficher vos options:

   

   • Tous les lieux:tous les fichiers.
   • Fichiers du projet:tous les fichiers du projet actuel.
   • Fichiers sources du projet:uniquement les fichiers sources du projet actuel.
   • Fichiers de production du projet : uniquement les fichiers de production du projet actuel.
   • Fichiers de test du projet : uniquement les fichiers de test du projet actuel.
   • Scratches et consoles:uniquement les fichiers de scratch et les consoles que vous avez ouverts dans le projet actuel.
   • Fichiers consultés récemment:uniquement les fichiers consultés récemment dans le projet actuel.
   • Fichier actuel : uniquement le fichier actuel de votre projet. S'affiche lorsqu'un fichier ou un dossier est sélectionné.
   • Répertoire sélectionné:uniquement le dossier actuel de votre projet. S'affiche lorsqu'un dossier est sélectionné.
   • Hiérarchie des classes:lorsque vous sélectionnez cette option, puis cliquez sur OK, une boîte de dialogue contenant toutes les classes du projet actuel s'affiche. Dans la boîte de dialogue, utilisez le champ Rechercher par nom pour filtrer et sélectionner les classes à inspecter. Si vous ne filtrez pas la liste des classes, l'inspection du code inspecte toutes les classes.

Si vous avez configuré un système de contrôle des versions pour le projet, vous pouvez également limiter la recherche aux seuls fichiers modifiés.

3. Cliquez sur OK.

Créer un champ d'application personnalisé

Lorsque vous souhaitez inspecter une sélection de fichiers et de répertoires qui ne sont couverts par aucun des champs d'application personnalisés disponibles, vous pouvez créer un champ d'application personnalisé:

1. Dans la boîte de dialogue Spécifier l'étendue de l'inspection, sélectionnez Champ d'application personnalisé.

2. Cliquez sur les trois points après la liste Champ d'application personnalisé.

   

   La boîte de dialogue Champs d'application s'affiche.

   

3. Cliquez sur le bouton  en haut à gauche de la boîte de dialogue pour définir un nouveau champ d'application.
4. Dans la liste Ajouter un champ d'application qui s'affiche, sélectionnez Local.

   Les champs d'application locaux et partagés sont utilisées dans le projet pour la fonctionnalité Inspecter le code. Un champ d'application partagé peut également être utilisé avec d'autres fonctionnalités de projet associées à un champ d'application. Par exemple, lorsque vous cliquez surModifier les paramètres pour modifier les paramètres de Trouver des utilisations, la boîte de dialogue qui s'affiche alors contient un champ Champ d'application dans lequel vous pouvez sélectionner un champ d'application partagé.

   

5. Attribuez un nom au champ d'application, puis cliquez sur OK.

   Le volet de droite de la boîte de dialogue Champs d'application contient des options vous permettant de définir le champ d'application personnalisé.

6. Dans la liste, sélectionnez Projet.

   La liste des projets disponibles s'affiche.

   Remarque : Vous pouvez créer une portée personnalisée pour les projets ou les packages. La procédure est la même.

7. Développez les dossiers du projet, sélectionnez ceux que vous souhaitez ajouter au champ d'application personnalisé, puis indiquez s'ils doivent être inclus ou exclus.

   

   • Inclure: permet d'inclure ce dossier et ses fichiers, mais aucun de ses sous-dossiers.
   • Inclure de manière récursive: permet d'inclure ce dossier et ses fichiers, ainsi que ses sous-dossiers et les fichiers qu'ils contiennent.
   • Exclure: permet d'exclure ce dossier et ses fichiers, mais aucun de ses sous-dossiers.
   • Exclure de manière récursive: permet d'exclure ce dossier et ses fichiers, ainsi que ses sous-dossiers et les fichiers qu'ils contiennent.

   La figure 10 montre que le dossier main est inclus et que les dossiers java et res sont inclus de manière récursive. Le bleu indique un dossier partiellement inclus, et le vert des dossiers et des fichiers inclus de manière récursive.

   

   • Si vous sélectionnez le dossier java et cliquez sur Exclure de manière récursive, le dossier java, avec tous ses dossiers et fichiers, n'est plus mis en surbrillance en vert.
   • Si vous sélectionnez le fichier MainActivity.kt en vert et que vous cliquez sur Exclure, MainActivity.kt n'est plus mis en surbrillance en vert, mais tous les autres éléments dans le dossier java restent en vert.
8. Cliquez sur OK. Le champ d'application personnalisé apparaît en bas de la liste.

Examiner et modifier les profils d'inspection

Android Studio propose une sélection de profils d'inspection lint et autres mis à jour via les mises à jour Android. Vous pouvez utiliser ces profils tels quels ou en modifier le nom, la description, le niveau de gravité et les champs d'application. Vous pouvez également activer et désactiver des groupes de profils entiers ou des profils individuels au sein d'un groupe.

Pour accéder aux paramètres Inspections:

1. Sélectionnez File > Settings (Fichier > Paramètres). (sous Windows) ou Android Studio > Préférences (sous macOS ou Linux).
2. Sélectionnez Éditeur > Inspections.

3. Le volet Inspections affiche la liste des inspections prises en charge et leur description.

   

4. Sélectionnez la liste Profile (Profil) pour basculer entre les inspections Default (Paramètres par défaut) (Android Studio) et Project Default (Paramètres du projet par défaut) (le projet actif).

   Pour en savoir plus, consultez la page Gérer les profils d'IntelliJ.

5. Dans la liste Inspections du volet de gauche, sélectionnez une catégorie de profil de niveau supérieur ou développez un groupe et sélectionnez un profil spécifique.

   Lorsque vous sélectionnez une catégorie de profil, vous pouvez modifier toutes les inspections de cette catégorie comme une seule inspection.

6. Sélectionnez la liste Afficher les actions du schéma pour copier, renommer, ajouter des descriptions, exporter et importer des inspections.
7. Lorsque vous avez terminé, cliquez sur OK.