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

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

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

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".

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

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

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 .

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,

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

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

Espero que seja útil para você.

Boa sorte @.@

Luna