Pobrałem kilka źródeł bibliotecznych i chciałbym wyeksportować je jako plik Jar za pomocą Android Studio. Czy istnieje sposób na wyeksportowanie do pliku jar za pomocą Android Studio?

edytować:

Biblioteka, którą chcę wyeksportować jako jar, to biblioteka Androida. Nazywa się „StandOut” i można go pobrać z GitHub. https://github.com/pingpongboss/StandOut

Nie można wyeksportować biblioteki systemu Android jako pliku jar. Możliwe jest jednak wyeksportowanie go do aarpliku. Aarpliki będące nowym formatem binarnym dla bibliotek Androida. Informacje o nich można znaleźć w Google I / O, filmie New Build System .

Najpierw zbuduj bibliotekę w Android Studio lub z wiersza poleceń, wydając gradle buildz katalogu głównego biblioteki.

Spowoduje to, że <yourlibroot>/libs/build/yourlib.aarplik.

Ten plik aar jest binarną reprezentacją biblioteki i można go dodać do projektu zamiast biblioteki jako projekt zależności.

Aby dodać plik aar jako zależność, musisz opublikować go w centrali maven lub w lokalnym repozytorium maven, a następnie odnieść plik aar do pliku projektu gradle.build.

Jednak ten krok jest nieco zawiły. Tutaj znalazłem dobre wyjaśnienie, jak to zrobić:

http://www.flexlabs.org/2013/06/using-local-aar-android-library-packages-in-gradle-builds

Udało mi się zbudować kod źródłowy biblioteki do skompilowanego .jarpliku, używając podejścia z tego rozwiązania: https://stackoverflow.com/a/19037807/1002054

Oto podział tego, co zrobiłem:

1. Pobierz repozytorium bibliotek

W przypadku gdyby była to biblioteka Volley

2. Importuj bibliotekę w Android Studio.

Użyłem Android Studio 0.3.7. Na tym etapie napotkałem pewne problemy, a mianowicie musiałem kopiowaćgradle folder z nowego projektu Androida, zanim mogłem zaimportować kod źródłowy biblioteki Volley, może się to różnić w zależności od używanego kodu źródłowego.

3. Zmodyfikuj build.gradleplik

// If your module is a library project, this is needed
//to properly recognize 'android-library' plugin
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.6.3'
    }
}

apply plugin: 'android-library'

android {
    compileSdkVersion 17
    buildToolsVersion = 17

    sourceSets {
        main  {
            // Here is the path to your source code
            java {
                srcDir 'src'
            }
        }
    }
}

// This is the actual solution, as in https://stackoverflow.com/a/19037807/1002054
task clearJar(type: Delete) {
    delete 'build/libs/myCompiledLibrary.jar'
}

task makeJar(type: Copy) {
    from('build/bundles/release/')
    into('build/libs/')
    include('classes.jar')
    rename ('classes.jar', 'myCompiledLibrary.jar')
}

makeJar.dependsOn(clearJar, build)

4. Uruchom gradlew makeJar polecenie z katalogu głównego projektu.

W moim przypadku musiałem skopiować gradlew.bati gradlepliki z nowego projektu Androida do katalogu głównego projektu biblioteki. Powinieneś znaleźć skompilowany plik biblioteki myCompiledLibrary.jarw build\libskatalogu.

Mam nadzieję, że ktoś uzna to za przydatne.

Edytować:

Caveat

Chociaż to działa, napotkasz zduplikowany wyjątek biblioteczny podczas kompilowania projektu z wieloma modułami, gdzie więcej niż jeden moduł (w tym moduł aplikacji) zależy od tego samego jarpliku (np. Moduły mają własny katalog biblioteki, do którego odwołuje się build.gradledany moduł) .

W przypadku, gdy potrzebujesz użyć jednej biblioteki w więcej niż jednym module, polecam skorzystanie z tego podejścia: Android Gradle build i biblioteka wsparcia

Od wersji Android Studio V1.0 plik jar jest dostępny w następującym linku do projektu:

wersja debugowania: „twoja_aplikacja” \ build \mediates \ bundles \ debug \ classes.jar

wersja wydania: „twoja_aplikacja” \ build \mediates \ bundles \ release \ classes.jar

Plik JAR jest tworzony w procedurze budowania, w GUI Android Studio pochodzi z Build-> Make Project, a z linii CMD jest to „gradlew build”.

Uwzględnij następujące elementy w pliku build.gradle:

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

    task("javadoc${variant.name}", type: Jar) {
        classifier = "javadoc"
        description "Bundles Javadoc into a JAR file for $variant.name."
        from tasks["generate${variant.name}Javadoc"]

    }

    task("jar${variant.name}", type: Jar) {
        description "Bundles compiled .class files into a JAR file for $variant.name."
        dependsOn variant.javaCompile
        from variant.javaCompile.destinationDir
        exclude '**/R.class', '**/R$*.class', '**/R.html', '**/R.*.html'
    }
}

Następnie możesz wykonać gradle za pomocą:, ./gradlew clean javadocRelease jarReleasektóry zbuduje twój Jar, a także jar javadoc do build/libs/folderu.

EDYCJA: Z Androidem Gradle Tools 1.10. + Pobieranie katalogu Android SDK jest inne niż wcześniej. Musisz zmienić następujące (dzięki Vishal!):

android.sdkDirectory 

zamiast

android.plugin.sdkDirectory

Udało mi się wyeksportować plik jar w Android Studio, korzystając z tego samouczka: https://www.youtube.com/watch?v=1i4I-Nph-Cw „Jak wyeksportować jar z Android Studio”

Zaktualizowałem moją odpowiedź, aby zawierała wszystkie kroki eksportu JAR w Android Studio:

1) Utwórz projekt aplikacji na Androida, przejdź do app-> build.gradle

2) Zmień następujące elementy w tym pliku:

• modyfikuj zastosuj wtyczkę: „com.android.application”, aby zastosować wtyczkę: „com.android.library”

• usuń następujące elementy: applicationId, versionCode i versionName

• Dodaj następujący kod:

// Task to delete old jar
task deleteOldJar(type: Delete){
   delete 'release/AndroidPlugin2.jar'
}

// task to export contents as jar
task exportJar(type: Copy) {
    from ('build/intermediates/bundles/release/')
    into ('release/')
    include ('classes.jar')
    rename('classes.jar', 'AndroidPlugin2.jar')
}
exportJar.dependsOn(deleteOldJar, build)

3) Nie zapomnij kliknąć Synchronizuj teraz w tym pliku (w prawym górnym rogu lub użyj przycisku synchronizacji).

4) Kliknij zakładkę Gradle (zwykle w środku po prawej) i przewiń w dół do exportjar

5) Gdy zobaczysz komunikat o pomyślnym utworzeniu w oknie uruchamiania, za pomocą normalnego eksploratora plików przejdź do wyeksportowanego jar, używając ścieżki: C: \ Users \ name \ AndroidStudioProjects \ ProjectName \ app \ release , powinieneś zobaczyć w tym katalogu swój plik jar.

Powodzenia :)

Oto kolejna, nieco inna odpowiedź z kilkoma ulepszeniami.

Ten kod usuwa plik .jar z pliku .aar. Osobiście daje mi to nieco większą pewność, że bity wysyłane za pośrednictwem .jar są takie same, jak te wysyłane przez .aar. Oznacza to również, że jeśli używasz ProGuard, plik wyjściowy zostanie zaciemniony zgodnie z potrzebami.

Dodałem również super zadanie "makeJar", które tworzy słoiki dla wszystkich wariantów kompilacji.

task(makeJar) << {
    // Empty. We'll add dependencies for this task below
}

// Generate jar creation tasks for all build variants
android.libraryVariants.all { variant ->
    String taskName = "makeJar${variant.name.capitalize()}"

    // Create a jar by extracting it from the assembled .aar
    // This ensures that products distributed via .aar and .jar exactly the same bits
    task (taskName, type: Copy) {
        String archiveName = "${project.name}-${variant.name}"
        String outputDir = "${buildDir.getPath()}/outputs"

        dependsOn "assemble${variant.name.capitalize()}"
        from(zipTree("${outputDir}/aar/${archiveName}.aar"))
        into("${outputDir}/jar/")
        include('classes.jar')
        rename ('classes.jar', "${archiveName}-${variant.mergedFlavor.versionName}.jar")
    }

    makeJar.dependsOn tasks[taskName]
}

Zaciekawiony czytelnik starałem się określić poprawne zmienne i parametry używane przez wtyczkę com.android.library do nazywania plików .aar. W końcu znalazłem je w projekcie Android Open Source tutaj .

Możemy wyeksportować plik jar dla projektu biblioteki Androida bez plików zasobów przez Android Studio. Jest to również wymóg tego, co ostatnio spotkałem.

1. Skonfiguruj plik build.gradle

    // Task to delete old jar

    task clearJar(type: Delete){
       delete 'release/lunademo.jar'
    }

    // task to export contents as jar
    task makeJar(type: Copy) {
       from ('build/intermediates/bundles/release/')
       into ('build/libs/')
       include ('classes.jar')
       rename('classes.jar', 'lunademo.jar')
    }
    makeJar.dependsOn(clearJar, build)

2. Uruchom gradlew makeJar w katalogu głównym projektu

Jeśli masz szczęście, zobaczysz swoje biblioteki w katalogu dir jako build / libs /.

==================================================== ==========

Jeśli napotkasz problem jako „Wyjątek limitu czasu gniazda” w wierszu poleceń, jak poniżej,

Możesz wykonać te kroki, aby otworzyć okno Gradle w prawej części i kliknąć „makeJar” w Android Studio w ten sposób,

Następnie przejdź do katalogu build / libs, zobaczysz swój plik jar.

Mam nadzieję, że jest to pomocne dla ciebie.

Powodzenia @.@

Luna