web-dev-qa-db-fra.com

Générer des JavaDocs avec Android Plugin Gradle

Comment puis-je générer des JavaDocs pour un projet Android en utilisant le nouveau système de construction Gradle?

Voici ce que j'ai trouvé, mais cela ne fonctionne pas.

task generateJavadoc(type: Javadoc) {
    source = Android.sourceSets.main.Java.srcDirs
    ext.cp = Android.libraryVariants.collect { variant ->
        variant.javaCompile.classpath.files
    }
    classpath = files(ext.cp) 
}

Le problème principal est que je n'obtiens pas le fichier Android.jar approprié sur le chemin de classe, donc certains des liens dans les JavaDocs ne sont pas résolus. Je dois trouver un moyen d'obtenir tous les pots nécessaires sur le chemin de classe.

Un autre problème avec l'approche que j'ai adoptée est qu'elle recueille les chemins de classe pour toutes les variantes de build, plutôt que d'en sélectionner une.

androidgradlejavadocandroid-gradle
45
Matt Accola

La solution sur laquelle j'ai fini par m'installer est la suivante:

Android.libraryVariants.all { variant ->

    task("generate${variant.name}Javadoc", type: Javadoc) {
        description "Generates Javadoc for $variant.name."
        source = variant.javaCompile.source
        ext.androidJar = "${Android.plugin.sdkDirectory}/platforms/${Android.compileSdkVersion}/Android.jar"
        classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)
    }

}

Xavier Ducrohet a confirmé que c'est la façon de le faire (avec des mises en garde) sur le groupe adt-dev, https://groups.google.com/forum/#!searchin/adt-dev/javadoc/adt-dev/seRizEn8ICA/bafEvUl6mzsJ .

11
Matt Accola

Pour Android plugin gradle 1.1.2+ (com.Android.tools.build:gradle:1.1.2+)

libraryVariants - ne fonctionne plus

tilisez:

task javadoc(type: Javadoc) {
    source = Android.sourceSets.main.Java.srcDirs
    classpath += project.files(Android.getBootClasspath().join(File.pathSeparator))
    destinationDir = file("../javadoc/")
    failOnError false
}

destinationDir = file ("../ javadoc /") - localiser javadocs à la racine du répertoire du projet (de cette manière, le plugin jenkins javadoc pourrait le trouver et l'afficher dans le panneau Document spécial)

failOnError false - pour supprimer les avertissements qui peuvent provoquer un échec de build sur jenkins

35
Flinbor

Gradle 1.11 - Plugin Gradle .10.

Remplacer Android.plugin.sdkDirectory par Android.sdkDirectory

Android.libraryVariants.all { variant ->
    task("generate${variant.name}Javadoc", type: Javadoc) {
        description "Generates Javadoc for $variant.name."
        source = variant.javaCompile.source
        ext.androidJar = "${Android.sdkDirectory}/platforms/${Android.compileSdkVersion}/Android.jar"
        classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)
        options.links("http://docs.Oracle.com/javase/7/docs/api/");
        options.links("http://d.Android.com/reference/");
        exclude '**/BuildConfig.Java'
        exclude '**/R.Java'
    }
}
24
flav

Avec Android gradle tools 1.10. + Obtenir le répertoire Android SDK est différent qu'auparavant. Vous devez modifier ce qui suit:

Android.sdkDirectory

au lieu de

Android.plugin.sdkDirectory

Voici la solution complète au problème:

Android.applicationVariants.all { variant ->

    task("generate${variant.name.capitalize()}Javadoc", type: Javadoc) {
        title = "Documentation for Android $Android.defaultConfig.versionName b$Android.defaultConfig.versionCode"
        destinationDir = new File("${project.getProjectDir()}/doc/compiled/", variant.baseName)
        source = variant.javaCompile.source

        ext.androidJar = "${Android.sdkDirectory}/platforms/${Android.compileSdkVersion}/Android.jar"
        classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)

        description "Generates Javadoc for $variant.name."

        options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PRIVATE
        options.links("http://docs.Oracle.com/javase/7/docs/api/");
        options.links("http://developer.Android.com/reference/");
        exclude '**/BuildConfig.Java'
        exclude '**/R.Java'
    }
}
9
Julian Pieles

Les pots Android semblent être dans la propriété Android.plugin.runtimeJarList. Cependant, il n'est documenté nulle part, il peut donc se casser à tout moment.

J'ai affiné votre solution pour travailler sur plusieurs variantes de build:

Android.applicationVariants.all { variant ->
    def name = variant.name
    task "javadoc$name"(type: Javadoc) {
        description = "Generates javadoc for build $name"
        destinationDir = new File(destinationDir, variant.baseName)
        source = files(variant.javaCompile.source)
        classpath = files(Android.plugin.runtimeJarList, variant.javaCompile.classpath)
        exclude '**/R.html', '**/R.*.html'
    }
}

Il n'est généralement pas logique de faire un javadoc uniquement sur la branche principale, car vous pouvez vous fier à certaines choses des saveurs du produit. Même le débogage par rapport à la version peut présenter des différences. Vous pouvez bien sûr choisir une variante par défaut à utiliser. Vous pourriez donc faire quelque chose comme,

task javadoc(dependsOn: javadocDebug)
8
thatsmydoing

Voici une version mise à jour qui fonctionnait en 2014:

Android.libraryVariants.all { variant ->
    def name = variant.buildType.name

    if (name.equalsIgnoreCase("debug")) {
        return; // Skip debug builds.
    }
    task("javadoc${variant.name.capitalize()}", type: Javadoc) {
        description "Generates Javadoc for $variant.name."
        source = variant.javaCompile.source
        ext.androidJar = files(plugins.findPlugin("com.Android.library").getBootClasspath())
        classpath = files(variant.javaCompile.classpath.files) + ext.androidJar
        exclude '**/internal/**'
        failOnError false
    }

    task("bundleJavadoc${variant.name.capitalize()}", type: Jar) {
        description "Bundles Javadoc into Zip for $variant.name."
        classifier = "javadoc"
        from tasks["javadoc${variant.name.capitalize()}"]
    }
}
4
volkersfreunde

J'ai créé un plugin open source pour cela. Référentiel GitHub

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "gradle.plugin.com.vanniktech:gradle-Android-javadoc-plugin:0.2.1"
    }
}

Ajoutez cette ligne dans votre build.gradle 

apply plugin: "com.vanniktech.Android.javadoc"

Ensuite, exécutez simplement l'une des opérations suivantes:

./gradlew generateDebugJavadoc
./gradlew generateReleaseJavadoc

La documentation Java se trouve dans module/javaDoc/

3
Niklas

J'ai trouvé que cette solution fonctionne sur le plugin Gradle 1.3.1 si vous avez des saveurs de produits différentes.

Cela créera des tâches Gradle pour générer Javadoc pour chaque version de produit et type de build. Par exemple, si le nom du module est app et que vous avez une saveur de produit production et dev et des types de construction debug et release, vous aurez les tâches Gradle suivantes:

  • : app: generateDevDebugJavadoc
  • : app: generateDevReleaseJavadoc
  • : app: generateProductionDebugJavadoc
  • : app: generateProductionReleaseJavadoc

app/build.gradle

Android {

    // ...

    applicationVariants.all { variant ->
        // create tasks to generate Javadocs
        task("generate${variant.name.capitalize()}Javadoc", type: Javadoc) {
            source = variant.javaCompile.source
            classpath += project.files(Android.getBootClasspath().join(File.pathSeparator))

            // choose the destination that works best for you here
            // I chose this particular directory because Jenkins pulls reports 
            // from this directory already if you need to have the output 
            // folder be parameterized for the build variant, use
            // "build/outputs/docs/javadoc-${variant.name}/" instead and it'll 
            // be in `javadoc-productionRelease` for example
            destinationDir = file("build/outputs/docs/javadoc/")

            // the name that will appear in the docs
            title = rootProject.name

            // you will probably get errors from using the @annotations and 
            // the support library, so just turn off failing for errors
            failOnError false    
        }
    }

    // ...

}
2
Phazor

Un de plus

 Android.libraryVariants.all {variant -> 
 If (variant.name.equals ('release')) 
 Task ("generateJavadoc", tapez: Javadoc) {
 description "Générer Javadoc" 
 source = Android.sourceSets.main.Java.srcDirs 
 // println '=== source ===' 
 // source. collecter {relativePath (it)} .sort (). each {println it} 
 ext.androidJar = "$ {Android.sdkDirectory}/plates-formes/$ {Android.compileSdkVersion} /Android.jar" 
 classpath = fichiers (variant.javaCompile.classpath.files) + fichiers (ext.androidJar) 
 // println '=== classpath ===' 
 // classpath.collect {relativePath (it)} .sort (). chacun {println it} 
} 
}

Utilisation:

gradle generateJavadoc

0
mc.dev