एंड्रॉइड लाइब्रेरी ग्रैडल रिलीज JAR

Question

मैं android-library प्रोजेक्ट की जार पैकेजिंग कैसे जारी कर सकता हूं?
मुझे पता चला है, class.jar build/bundles/release/classes.jar के तहत स्थित है और मुझे लगता है कि यह सही जार पैकेज है (इसमें *.class फ़ाइलें हैं)।

क्या कुछ आधिकारिक तरीका है, पुस्तकालय को एएआर के बजाय जार के रूप में रिलीज़ करने के लिए?

संपादित
मैं Gradle Maven कलाकृतियों जारी करने के लिए उपयोग करते हैं, और मैं आर पैकेज के साथ जार जारी करने के लिए करना चाहते हैं। तो हस्ताक्षर, md5, प्रकट साथ जार, ...
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 
    } 
} 

task androidJar(type: Jar) { 
    from android.sourceSets.main.java.srcDirs 
} 

का उपयोग कर केवल जावा फ़ाइलें पैकेज होगा पर आधारित है, संकलित नहीं और Android SDK

Answer 1

जबकि के खिलाफ जुड़ा हुआ मैंने सोनाटाइप (या यहां तक ​​कि एक स्थानीय रेपो) को तैनाती के साथ कलाकृतियों को अपलोड करने की कोशिश नहीं की है, वैसे ही मैं उसी समस्या से निपटने की कोशिश करते समय a few weeks ago के साथ आने में कामयाब रहा हूं।

./gradlew jarRelease 

Answer 2

एक और तरीका है के माध्यम से Gradle इस प्रकार है एक पुस्तकालय परियोजना से एक जार उत्पन्न करने के लिए:

अपनी लाइब्रेरी के 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) 

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

तो निम्नलिखित चलाने

हम यहां क्या कर रहे हैं बस एंड्रॉइड ग्रैडल प्लगइन द्वारा उत्पन्न कक्षाओं की प्रतिलिपि बना रहा है। इस फ़ाइल के लिए अपनी बिल्ड निर्देशिका में देखना सुनिश्चित करें और देखें कि इसकी सामग्री आपके इच्छित तरीके से है या नहीं।

फिर makeJar कार्य चलाने के लिए और जिसके परिणामस्वरूप जार पुस्तकालय/निर्माण/libs में होगा/${jarName} .jar

रिलीज के लिए आपके विन्यास के अनुसार वर्ग फ़ाइलों होगा। यदि आप इसे खराब कर रहे हैं, तो जार में फाइलों को खराब कर दिया जाएगा।

Answer 3

सिर्फ इसलिए कि पिछले उत्तर मेरी ज़रूरतों को पूरा नहीं कर रहे थे, इसलिए मैं प्रोजेक्ट क्लास और आर्ल/जार निर्भरताओं के साथ एक जार उत्पन्न करने के लिए अपना मुश्किल संस्करण साझा करता हूं।

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

यह निर्माण प्रकार/जायके का प्रबंधन नहीं करता है लेकिन अनुकूलित किया जा सकता है (यह स्वाद के बिना निर्माण प्रकार रिलीज पर निर्माण करने के लिए बस ठीक है)।

यदि कभी भी आपके पास एक बेहतर या अधिक सुरुचिपूर्ण समाधान है, तो कृपया साझा करें!