web-dev-qa-db-fra.com

Bibliothèque Android Gradle release JAR

Comment puis-je libérer les emballages JAR du projet Android-library?
J'ai trouvé, classes.jar est situé sous build/bundles/release/classes.jar et je suppose que c'est le package correct Jar (contient les fichiers *.class).

Existe-t-il un moyen officiel de publier la bibliothèque sous le nom de JAR au lieu de AAR?

Modifier
J'utilise Gradle pour libérer les artefacts Maven, et j'aimerais publier JAR avec le package AAR. Alors JAR avec signature, md5, manifeste, ...
basé sur https://chris.banes.me/2013/08/27/pushing-aars-to-maven- centro/

apply plugin: 'maven'
apply plugin: 'signing'

configurations {
    archives {
        extendsFrom configurations.default
    }
}

def sonatypeRepositoryUrl
if (isReleaseBuild()) {
    println 'RELEASE BUILD'
    sonatypeRepositoryUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
} else {
    println 'DEBUG BUILD'
    sonatypeRepositoryUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
}

if(!hasProperty('nexusPassword')) {
    ext.set('nexusPassword', System.console().readPassword("\n\$ Type in password for Sonatype nexus account " + nexusUsername + ": "))
}

if(!signing.hasProperty('password')) {
    ext.set('signing.password', System.console().readPassword("\n\$ Type in GPG key password: "))
}

afterEvaluate { project ->
    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                pom.artifactId = POM_ARTIFACT_ID

                repository(url: sonatypeRepositoryUrl) {
                    authentication(userName: nexusUsername, password: nexusPassword)
                }

                pom.project {
                    name POM_NAME
                    packaging POM_PACKAGING
                    description POM_DESCRIPTION
                    url POM_URL

                    scm {
                        url POM_SCM_URL
                        connection POM_SCM_CONNECTION
                        developerConnection POM_SCM_DEV_CONNECTION
                    }

                    licenses {
                        license {
                            name POM_LICENCE_NAME
                            url POM_LICENCE_URL
                            distribution POM_LICENCE_DIST
                        }
                    }

                    developers {
                        developer {
                            id "loopj"
                            name "James Smith"
                        }
                        developer {
                            id "smarek"
                            name "Marek Sebera"
                        }
                    }
                }
            }
        }
    }

    signing {
        required { isReleaseBuild() && gradle.taskGraph.hasTask("uploadArchives") }
        sign configurations.archives
    }

    task androidJavadocs(type: Javadoc) {
        source = Android.sourceSets.main.Java.srcDirs
    }

    task androidJavadocsJar(type: Jar) {
        classifier = 'javadoc'
        from androidJavadocs.destinationDir
    }

    task androidSourcesJar(type: Jar) {
        classifier = 'sources'
        from Android.sourceSets.main.Java.srcDirs
    }

    artifacts {
        archives androidSourcesJar
        archives androidJavadocsJar
    }
}

en utilisant 

task androidJar(type: Jar) {
    from Android.sourceSets.main.Java.srcDirs
}

ne conditionnera que les fichiers Java, non compilés et liés au sdk Android

javaandroidjargradleaar
64
Marek Sebera

Bien que je n’aie pas essayé de télécharger les artefacts avec un déploiement sur Sonatype (ou même sur un dépôt local), voici ce que j’ai réussi à trouver il y a quelques semaines en essayant de résoudre le même problème.

Android.libraryVariants.all { variant ->
  def name = variant.buildType.name
  if (name.equals(com.Android.builder.core.BuilderConstants.DEBUG)) {
    return; // Skip debug builds.
  }
  def task = project.tasks.create "jar${name.capitalize()}", Jar
  task.dependsOn variant.javaCompile
  task.from variant.javaCompile.destinationDir
  artifacts.add('archives', task);
}

Puis lancez ce qui suit:

./gradlew jarRelease
93
Jake Wharton

Une autre façon de générer un fichier jar à partir d'un projet de bibliothèque via gradle est la suivante:

Dans le build.gradle de votre bibliothèque:

def jarName = 'someJarName.jar'

task clearJar(type: Delete) {
    delete "${project.buildDir}/libs/" + jarName
}

task makeJar(type: Copy) {
    from("${project.buildDir}/intermediates/bundles/release/")
    into("${project.buildDir}/libs/")
    include('classes.jar')
    rename('classes.jar', jarName)
}

makeJar.dependsOn(clearJar, build)

Nous ne faisons que copier le fichier classes.jar généré par le plugin Android Gradle. Assurez-vous de regarder dans votre répertoire de construction pour ce fichier et voir si son contenu est comme vous le souhaitez.

Ensuite, exécutez la tâche makeJar et le jar résultant sera dans library/build/libs/${jarName}. Jar

Le aura les fichiers de classe en fonction de votre configuration pour la publication. Si vous l'obscurcissez, les fichiers contenus dans le pot seront obscurcis.

2
Olinasc

Juste parce que les réponses précédentes ne correspondaient pas à mes besoins, je partage ma version complexe pour générer un jar avec les classes de projet et les dépendances aar/jar.

// A tricky jar operation, we want to generate a jar files that contains only the required classes used.
// Dependencies are in jar and aar, so we need to open the aar to extract the classes and put all at the same level
// (aar is a Zip that contains classes.jar, the latter is a Zip that contains .class files)
task jar(type: Jar) {
    from {
        List<File> allFiles = new ArrayList<>();
        configurations.compile.collect {
            for (File f : zipTree(it).getFiles()) {
                if (f.getName().equals("classes.jar")) {
                    allFiles.addAll(zipTree(f).getAt("asFileTrees").get(0).getDir())
                }
            }
        }
        allFiles.add(new File('build/intermediates/classes/release'))
        allFiles // To return the result inside a lambda
    }
    archiveName( project.ext.appName + '.jar' )
}

Cela ne gère PAS les types/saveurs de build, mais peut être adapté (il est juste correct de construire sur une version de type de construction sans saveur).

Si jamais vous avez une solution plus intelligente ou plus élégante, partagez-la!

0
Kikiwa