web-dev-qa-db-fra.com

Comment configurons-nous Android Studio pour qu'il s'exécute sur chaque build?

Il était une fois, en particulier à Eclipse-land, Lint s'exécutait sur toutes les versions. Ainsi, si vous échouiez à la vérification de Lint, vous le découvririez immédiatement. Avec Android Studio (testé sur la version 1.3), Lint ne s'exécute pas par défaut sur une version. Les nouveaux arrivants pourraient commettre des erreurs que Lint vérifierait, mais comme ils ne s'exécutent pas, ils ne font pas T découvrir sur eux.

(IOW, si un test de charpie n'a pas été exécuté dans une forêt, existe-t-il vraiment un test de charpie?)

Les commentaires sur cet article de blog montrent comment faire en sorte que Lint s'exécute dans le cadre d'une construction:

  • Editer la configuration du projet
  • Dans l'onglet Général de la configuration, faites défiler l'écran vers le bas et ouvrez le panneau "Avant le lancement".
  • Dans ce panneau, ajoutez une étape à "Exécuter Gradle Task" nommée lint pour votre module.

Toutefois, cela exécute Lint en ligne de commande, ce qui génère des rapports écrits en XML et HTML sur votre disque dur. Cela fonctionne, mais il serait plus propre d’avoir Android Studio exécute ses contrôles in-IDE Lint, de sorte que les résultats apparaissent dans un panneau IDE.

Existe-t-il un moyen de configurer un build de projet pour effectuer les contrôles Lint in-IDE?

Des points bonus s’il peut être configuré pour uniquement exécuter Lint, et non l’analyse complète effectuée par Analyse> Inspecter le code. Bien que l'analyse complète soit parfois utile, Lint est suffisamment lent, sans parler des autres analyses douteuses utiles effectuées par Android Studio (par exemple, vérification orthographique).

Bien que l’installation de ce logiciel ne soit pas un bon plan pour tous les projets (les analyses Lint sont lentes), pour les nouveaux venus sur Android, cela pourrait être une décision appropriée.

androidandroid-studioandroid-lint
66
CommonsWare

Lint devrait fonctionner dans Android Studio , sauf si vous l'avez configuré pour être off via les lintOptions de votre fichier build.gradle .

Voici la documentation disponible sur http://developer.Android.com/tools/debugging/improving-w-lint.html#studio

Dans Android Studio, les inspections configurées et IDE s'exécutent automatiquement lorsque vous créez votre application. Les inspections IDE sont configurées]). avec les vérifications de la charpie pour exécuter des inspections de code IntelliJ afin de rationaliser la révision du code.

Remarque: Pour afficher et modifier les niveaux de gravité de l'inspection, utilisez le fichier > Paramètres> Paramètres du projet menu pour ouvrir la page Inspection Configuration avec une liste des inspections prises en charge.

Avec Android Studio, vous pouvez également exécuter des inspections de charpie pour une variante de construction spécifique, ou pour toutes les variantes de construction à partir du fichier build.gradle. Ajoutez la propriété lintOptions à la Android paramètres dans le fichier de construction: cet extrait de code d'un fichier de construction Gradle indique comment définir l'option quiet en true et l'option abortOnError en false.

Android {
    lintOptions {
       // set to true to turn off analysis progress reporting by lint
       quiet true
       // if true, stop the gradle build if errors are found
       abortOnError false
       // if true, only report errors
       ignoreWarnings true
       }
       ...
}

Pour exécuter manuellement des inspections dans Android Studio, dans l’application ou dans le menu contextuel, choisissez Analyser> Inspecter le code . La boîte de dialogue Spécifier l'étendue des inspections apparaît pour vous permettre de spécifier l'étendue et le profil d'inspection souhaités.

Voici d'autres options de lint que vous pouvez ajouter à votre bloc lintOptions dans votre fichier build.gradle: http://tools.Android .com/tech-documents/new-build-system/guide-utilisateur # TOC-Lint-support

Voici plus d'informations sur Android lint: http://developer.Android.com/tools/help/lint.html

Auparavant, vous pouviez ajouter des tâches de gradation après certaines actions dans Android studio.

  • Ouvrez l'onglet Gradle sur le côté droit de l'écran
  • Sélectionnez votre tâche

Android Studio Gradle Tab

  • Clic droit sur la tâche
  • Choisissez votre action d'exécution

Android Studio Execution Action

Cela devrait exécuter la tâche une fois son exécution planifiée.

15
Ray Hunter

Créer un profil d'inspection pour Android Lint

  1. Allez dans Fichier -> Paramètres -> Editeur/Inspection
  2. Sélectionnez Gérer -> Copier
  3. Nommez-le "Profil Android Lint" et appuyez sur Entrée.
  4. Ne laissez cochée que Android Règles de charpie sous cet onglet

Android Lint Profile

Maintenant, vous pouvez exécuter une inspection uniquement avec Android Règles de peluchage via Analyse-> Inspecter le code ... en sélectionnant "Profil de peluche Android".

A l’étape suivante, enregistrons la macro (Édition-> Macros-> Démarrer l’enregistrement de macro) avec les étapes suivantes.

  1. Analyse-> Inspecter le code ...
  2. Sélectionnez "Profil Android Lint"
  3. Appuyez sur Entrée (il est important d'utiliser le clavier, car l'enregistreur de macros n'enregistre pas les clics de souris sur cette fenêtre).
  4. Cliquez sur "Run Selected Configuration" (bouton de lecture vert)

Arrêtez l'enregistrement de la macro et donnez-lui le nom "Lint and Run".

La dernière chose à faire est de mapper "Shift + F10" à notre macro. Allez dans Fichier-> Paramètres ...-> Keymap. Retrouvez notre macro et changez le raccourci.

macro keymapping

Des peluches sont maintenant exécutées avant chaque construction lorsque vous appuyez sur Maj + F10 et les résultats apparaissent dans le panneau Android Studio.

Mais cette solution présente un gros inconvénient . Si vous exécutez votre construction en cliquant sur le bouton Exécuter, l'analyse de la charpie ne sera pas exécutée.

Peut-être que cette information sera utile et que quelqu'un fournira une meilleure solution en l'utilisant.

6
Ilya Tretyakov

J'ai déjà réalisé cela auparavant en ajoutant un crochet git pré-Push qui exécuterait automatiquement peluche sur Push et échouerait si les erreurs Lint étaient détectées. Le script de hook pré-Push était stocké dans le référentiel de projet Android) et a été installé automatiquement sur la machine locale d'un utilisateur via gradle.

install-git-hooks.gradle

def hookDest = new File("${rootProject.rootDir}/.git/hooks/pre-Push")
def prePushHook = new File("${rootProject.rootDir}/pre-Push")

task installGitHooksTask(type: Copy) {
    hookDest.delete()
    hookDest << prePushHook.text
}

task gitExecutableHooks() {
    Runtime.getRuntime().exec("chmod -R +x ${hookDest}");
    println "gitExecutableHooks"
}

gitExecutableHooks.dependsOn installGitHooksTask

Que dans votre application build.gradle

apply from: rootProject.file('gradle/install-git-hooks.gradle')

pré-Push

#!/bin/sh
#
# This hook is for Android project git repos.
#
# You can use git config variables to customize this hook.
# -----------------------------------------------------------
# Change hooks.lintTargetDirectory to point at a non . directory
# Change hooks.lintArgs to add any custom lint arguments you prefer

# Get custom info
dirToLint=$(git config hooks.lintTargetDirectory)
lintArgs=$(git config hooks.lintArgs)
projectDir=$(git rev-parse --show-toplevel)
lintReportPath="/app/lint-report.html"

# If user has not defined a preferred directory to lint against, make it .
if [ -z "$dirToLint"]
  then
  dirToLint="."
fi

# Perform lint check
echo "Performing pre-commit lint check of ""$dirToLint"
./gradlew lint
lintStatus=$?

if [ $lintStatus -ne 0 ]
then
  echo "Lint failure, git Push aborted."
  echo "Open ${projectDir}${lintReportPath} in a browser to see Lint Report"
  exit 1
fi

exit $lintStatus
5
Lawrence Martin

Une solution possible (mais difficile à mettre en œuvre) consiste à écrire un plugin IDEA). Vous pouvez éviter cela en téléchargeant le plugin ci-dessous depuis le référentiel ou le code provenant de github. exécutera les actions 'compiler' et 'inspecter le code' séquentiellement.

public class BuildAndLint extends AnAction {
    public void actionPerformed(AnActionEvent e) {
        String[] actions = {"CompileProject", "InspectCode"};
        for(String action: actions) {
            AnAction anAction = ActionManager.getInstance().getAction(action);

            DataContext context = e.getDataContext(); 
            AnActionEvent anActionEvent = new AnActionEvent(null, context, "", anAction.getTemplatePresentation(), ActionManager.getInstance(), 0);

            anAction.actionPerformed(anActionEvent);
        }
    }
}

Le code a été testé et fonctionne dans Android Studio 1.3. Il ouvrira une fenêtre pour sélectionner les éléments à inspecter, plutôt que de tout faire.

Liens

Code source sur github

Construit et Lint Jar

1
Roy Falk