Como exportar biblioteca para Jar no Android Studio?

84

Baixei algumas fontes da biblioteca e gostaria de exportá-las como um arquivo Jar usando o Android Studio. Existe uma maneira de exportar para arquivo jar usando o Android Studio?

editar:

A biblioteca que desejo exportar como jar é uma biblioteca Android. É chamado de "StandOut" e pode ser baixado do GitHub. https://github.com/pingpongboss/StandOut

android  android-studio 
— Sage Pourpre
fonte
Forneça mais detalhes sobre a biblioteca que deseja exportar
— gamag
Editei minha pergunta com os detalhes da biblioteca Android.
— Sage Pourpre

Respostas:

85

Não é possível exportar uma biblioteca Android como um arquivo jar. É possível, entretanto, exportá-lo como aararquivo. Aararquivos sendo o novo formato binário para bibliotecas Android. Há informações sobre eles no Google I / O, o vídeo do New Build System .

Primeiro, crie a biblioteca no Android Studio ou a partir da linha de comando emitida gradle buildpelo diretório raiz da sua biblioteca.

Isso resultará em <yourlibroot>/libs/build/yourlib.aararquivo.

Este arquivo aar é uma representação binária de sua biblioteca e pode ser adicionado ao seu projeto em vez da biblioteca como um projeto de dependência.

Para adicionar o arquivo aar como uma dependência, você deve publicá-lo no maven central ou em seu repositório maven local e, em seguida, consultar o arquivo aar no arquivo do seu projeto gradle.build.

No entanto, esta etapa é um pouco complicada. Encontrei uma boa explicação de como fazer isso aqui:

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

— Alexander Kulyakhtin
fonte
2
também ter android-library dependendo de outra android-library pode quebrar as coisas.
— Loïc Faure-Lacroix
A pasta res será incluída no arquivo aar?
— Bagusflyer
veja a resposta de @ Wallmart_Hobo abaixo, é possível e posso confirmar que o jar exportado funciona bem em um projeto de aplicativo Android Eclipse.
— Pelota de
2
Encontrei meu arquivo aar incluído neste link: lib \ build \ outputs \ aar
— Simon
— TeeTracker de
44

Consegui construir um código-fonte de biblioteca para o .jararquivo compilado , usando a abordagem desta solução: https://stackoverflow.com/a/19037807/1002054

Aqui está o detalhamento do que eu fiz:

1. Fazer check-out do repositório da biblioteca

Em maio, era uma biblioteca de Volley

2. Importar biblioteca no Android Studio.

Usei o Android Studio 0.3.7. Eu encontrei alguns problemas durante essa etapa, ou seja, tive que copiar a gradlepasta do novo projeto Android antes de poder importar o código-fonte da biblioteca Volley. Isso pode variar dependendo do código-fonte que você usa.

3. Modifique seu build.gradlearquivo

// 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. Corra gradlew makeJar comando a partir da raiz do projeto.

I meu caso eu tive que copiar gradlew.bate gradlearquivos de novo projeto android no meu raiz do projeto biblioteca. Você deve encontrar seu arquivo de biblioteca compiladomyCompiledLibrary.jar no build\libsdiretório.

Espero que alguém ache isso útil.

Editar:

Embargo

Embora isso funcione, você encontrará exceção de biblioteca duplicada ao compilar um projeto com vários módulos, onde mais de um módulo (incluindo o módulo de aplicativo) depende do mesmo jararquivo (por exemplo, os módulos têm o próprio diretório de biblioteca, que é referenciado embuild.gradle determinado módulo) .

No caso de você precisar usar uma única biblioteca em mais de um módulo, eu recomendaria usar esta abordagem: Android gradle build e a biblioteca de suporte

— 7hny
fonte
Descobri que não há como incluir o res dentro do frasco. Isso é possível?
— Bagusflyer
7
Em versões recentes do Android Studio requer uma mudança: a linha deve ser `from ('build / intermediates / bundles / release /')`
— Greg Ennis
@GregEnnis ya, mas no meu caso é criar um jar com meu nome de mobule e o jar real está dentro desse jar. Extraí o jar criado com meu nome de módulo, como module_name.jar.
— pyus13
6
@bagusflyer, se você deseja uma respasta, um arquivo AAR é exatamente isso - um arquivo JAR com ressuporte para pasta.
— Martin Konecny
como aplicar o proguard para gerar este jar?
— Amrut Bidri
37

Desde o Android Studio V1.0, o arquivo jar está disponível no seguinte link de projeto:

debug ver: "your_app" \ build \ intermediates \ bundles \ debug \ classes.jar

versão de lançamento: "your_app" \ build \ intermediates \ bundles \ release \ classes.jar

O arquivo JAR é criado no procedimento de construção, na GUI do Android Studio é de Build-> Make Project e da linha CMD é "gradlew build".

— Avi Levin
fonte
3
receberás todas as minhas internets para esta resposta
— m02ph3u5
1
Encontrado, em Build Variants, temos que escolher Build Variant para ser 'release'. Mas agora o classes.jar não está presente na pasta de lançamento!
— Aparajith Sairam
1
@AparajithSairam como você construiu seu JAR, linha de comando ou gui?
— Avi Levin de
1
@AparajithSairam, encontrei algo na GUI, mas é relevante apenas para compilações de arquivos APK. após selecionar a variante de construção relevante, pressione o ícone verde "reproduzir". ele executará um comando gradle de montagem de plano de fundo que criará o arquivo. Para um arquivo JAR no CMD, você terá que executar gradlew assembleDebug ou Release ou qualquer tipo que você tenha. Depois disso, o JAR estaria disponível no seguinte local: your_app "\ build \ intermediates \ bundles \" falvor "\ classes.jar você pode ver todos os seus comandos de montagem usando" gradlew tasks "
— Avi Levin
1
Votei em outra resposta há mais de um ano. Dane-se esse negócio. Isso é bolo! Obrigado!!
— Kevin
31

Inclua o seguinte em 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'
    }
}

Você pode então executar o gradle com: ./gradlew clean javadocRelease jarReleaseque irá construir seu Jar e também um jar javadoc na build/libs/pasta.

EDITAR: Com o Android Gradle Tools 1.10. + Obter o diretório SDK do Android é diferente do anterior. Você tem que alterar o seguinte (obrigado Vishal!):

android.sdkDirectory

ao invés de

android.plugin.sdkDirectory
— Andrey
fonte
Ótima resposta, isso funcionou perfeitamente para mim. Você também pode adicionar um destino gradle no android studio para executar a tarefa jarDebug que criará o jar utilizável (eu testei isso em um projeto eclipse e também funciona bem).
— Pelota de
8
Por que o "novo" sistema de compilação do Android o torna tão feio :(.
— Martin Konecny
Até agora, essa é a única resposta que funcionou. Muito obrigado @Walmart_Hobo
— Drew em
Ótima solução para gerar um arquivo JAR! É possível incluir os recursos também?
— Gaëtan
12

Consegui exportar um arquivo jar no Android Studio usando este tutorial: https://www.youtube.com/watch?v=1i4I-Nph-Cw "How To Export Jar From Android Studio"

Atualizei minha resposta para incluir todas as etapas para exportar um JAR no Android Studio:

1) Crie um projeto de aplicativo Android, vá para app-> build.gradle

2) Altere o seguinte neste arquivo:

  • modifique o plugin de aplicação: 'com.android.application' para aplicar o plugin: 'com.android.library'

  • remova o seguinte: applicationId, versionCode e versionName

  • Adicione o seguinte código:

// 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) Não se esqueça de clicar em sincronizar agora neste arquivo (canto superior direito ou usar o botão de sincronização).

4) Clique na guia Gradle (geralmente no meio à direita) e role para baixo para exportar

5) Depois de ver a mensagem de construção bem - sucedida na janela de execução, usando o explorador de arquivos normal, vá para o jar exportado usando o caminho: C: \ Users \ name \ AndroidStudioProjects \ ProjectName \ app \ release, você deve ver neste diretório seu arquivo jar.

Boa sorte :)

— RMDev
fonte
1
A etapa 2 é crítica. Ninguém mais menciona isso. Obrigado, isso funcionou para mim!
— pookie de
9

Aqui está outra resposta ligeiramente diferente com algumas melhorias.

Este código retira o .jar do .aar. Pessoalmente, isso me dá um pouco mais de confiança de que os bits enviados via .jar são os mesmos que os enviados via .aar. Isso também significa que, se você estiver usando o ProGuard, o jar de saída será ofuscado conforme desejado.

Eu também adicionei uma tarefa super "makeJar", que cria jars para todas as variantes de construção.

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

Para o leitor curioso, lutei para determinar as variáveis ​​e parâmetros corretos que o plug-in com.android.library usa para nomear arquivos .aar. Eu finalmente os encontrei no Android Open Source Project aqui .

— David
fonte
4

Podemos exportar um arquivo jar para um projeto de biblioteca Android sem arquivos de recursos do Android Studio. Também é requisito o que conheci recentemente.

1. Configure seu arquivo 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. Execute gradlew makeJar na raiz do projeto

Você verá suas bibliotecas em dir como build / libs / se tiver sorte.

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

Se você encontrou o problema de "exceção de tempo limite de soquete" na linha de comando abaixo,

insira a descrição da imagem aqui

Você pode seguir estas etapas para abrir a janela do Gradle na parte certa e clicar em "makeJar" no Android Studio assim,

insira a descrição da imagem aqui

insira a descrição da imagem aqui

Em seguida, vá para o diretório build / libs, você verá seu arquivo jar.

Espero que seja útil para você.

Boa sorte @.@

Luna

— Luna Kong
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.