Android Bibliothek Gradle Release JAR

Question

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

Gibt es einen offiziellen Weg, Bibliothek als JAR anstelle von AAR freizugeben? zusammen mit AAR Paket

bearbeiten
Ich benutze Gradle Maven Artefakte zu lösen, und ich möchte JAR veröffentlichen. So JAR mit Unterschrift, md5, manifestieren, ...
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 
} 

nur Java-Dateien verpacken, nicht kompiliert und gelinkt gegen android sdk

Answer 1

Während Ich habe nicht versucht, die Artefakte mit einer Bereitstellung auf Sonatype (oder sogar einem lokalen Repo) hochzuladen, hier ist, was ich geschafft habe, mit a few weeks ago zu kommen, wenn ich versuche, das gleiche Problem anzugehen.

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

laufen dann wie folgt vor:

./gradlew jarRelease 

Answer 2

Eine weitere Möglichkeit, ein Glas aus einer Bibliothek-Projekt zu generieren durch gradle wie folgt:

In Ihrer Bibliothek build.gradle:

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 machen, ist nur das clases.jar kopieren, das vom Android Gradle Plugin erstellt wurde. Stellen Sie sicher, dass Sie in Ihr Build-Verzeichnis für diese Datei schauen und sehen Sie, ob der Inhalt so ist, wie Sie es möchten.

Dann laufen die makeJar Aufgabe und das resultierende Glas wird in der Bibliothek/build/libs sein/${jarName} .jar

Die die Klassendateien nach der Konfiguration für die Freigabe haben. Wenn Sie es verschleiern, werden die Dateien im Jar verschleiert.

Answer 3

Nur weil die vorherigen Antworten nicht meinen Anforderungen entsprachen, teile ich meine knifflige Version, um ein Jar mit den Projektklassen und den aar/jar Abhängigkeiten zu generieren.

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

Diese nicht gelingt, den Build-Typen/Aromen, sondern kann angepasst werden (es auf Build-Typ-Release ohne Geschmack bauen nur ok).

Wenn Sie jemals eine klügere oder elegantere Lösung haben, teilen Sie sie bitte!