it-swarm.com.de

Android Library Gradle veröffentlicht JAR

Wie kann ich die Jar-Verpackung von Android-library project freigeben?
Ich habe festgestellt, classes.jar befindet sich unter build/bundles/release/classes.jar und ich nehme an, das ist das richtige Jar-Paket (enthält *.class-Dateien).

Gibt es einen offiziellen Weg, Bibliothek als JAR anstelle von AAR zu veröffentlichen?

Bearbeiten
Ich benutze Gradle, um Maven-Artefakte zu veröffentlichen, und ich möchte JAR zusammen mit dem AAR-Paket freigeben. Also JAR mit Unterschrift, MD5, Manifest, ...
basierend auf https://chris.banes.me/2013/08/27/pushing-aars-to-maven-central/

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
    }
}

mit 

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

packt nur Java-Dateien, die nicht mit Android-SDK kompiliert und verknüpft sind

64
Marek Sebera

Ich habe zwar noch nicht versucht, die Artefakte mit einer Bereitstellung auf Sonatype (oder sogar auf ein lokales Repo) hochzuladen, aber hier habe ich vor ein paar Wochen gefunden, als ich versuchte, das gleiche Problem zu lösen.

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);
}

Führen Sie dann Folgendes aus:

./gradlew jarRelease
93
Jake Wharton

Eine weitere Möglichkeit zum Erstellen eines Glases aus einem Bibliotheksprojekt durch Gradle ist wie folgt:

Im build.gradle Ihrer Bibliothek:

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)

Was wir hier tun, ist das Kopieren der Klassen, die vom Android Gradle-Plugin generiert wurden. Achten Sie darauf, dass Sie in Ihrem Build-Verzeichnis nach dieser Datei suchen und prüfen, ob der Inhalt Ihren Wünschen entspricht.

Führen Sie dann die makeJar-Task aus, und das resultierende jar befindet sich in library/build/libs/${jarName}. Jar

Die Klassendateien werden entsprechend Ihrer Konfiguration für die Veröffentlichung erstellt. Wenn Sie es verschleiern, werden die Dateien im Glas verschleiert.

2
Olinasc

Nur weil die vorherigen Antworten nicht meinen Bedürfnissen entsprachen, teile ich meine knifflige Version, um ein Glas mit den Projektklassen und den Aar/Jar-Abhängigkeiten zu erzeugen.

// 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' )
}

Dies verwaltet NICHT die Build-Typen/Flavors, kann aber angepasst werden (es ist nur in Ordnung, auf Build-Release ohne Flavour aufzubauen).

Wenn Sie jemals eine intelligentere oder elegantere Lösung haben, teilen Sie diese bitte!

0
Kikiwa