Estou usando o AndroidStudio e tenho este projeto conforme mostrado:

O que está dentro do círculo azul é myLib. myLib também precisa usar uma lib externa que está dentro do círculo vermelho e um pacote apache (círculo verde).

Então, quero fazer com que tudo isso se torne um único .jar, para que possa usá-lo em outros projetos.

Um guia passo a passo seria muito apreciado, sou um iniciante no mundo dos desenvolvedores.

Obrigado!

• Abra build.gradle para projeto de biblioteca

• Escreva duas tarefas em build.gradle - deleteJar e createJar e adicione a regra createJar.dependsOn (deleteJar, build)

O código acima:

task deleteJar(type: Delete) {
    delete 'libs/jars/logmanagementlib.jar'
}           

task createJar(type: Copy) {
    from('build/intermediates/bundles/release/')
    into('libs/jars/')
    include('classes.jar')
    rename('classes.jar', 'logmanagementlib.jar')
}

createJar.dependsOn(deleteJar, build)

• Expanda o painel gradle da direita e abra todas as tarefas em sua biblioteca-> outros. Você verá duas novas tarefas lá - createJar e deleteJar

• Clique duas vezes em createJar

• Assim que a tarefa for executada com sucesso, obtenha o jar gerado no caminho mencionado na tarefa createJar, ou seja, libs / xxxx.jar

• copie o jar recém-gerado para a pasta lib do seu projeto necessário -> clique com o botão direito -> selecione "adicionar como biblioteca"

Se você configurar o código como um módulo Java simples no Gradle, será realmente fácil fazer com que o Gradle forneça um arquivo jar com o conteúdo. Esse arquivo jar terá apenas o seu código, não as outras bibliotecas Apache das quais depende. Eu recomendo distribuí-lo dessa forma; é um pouco estranho agrupar dependências dentro de sua biblioteca, e é mais normal que os usuários dessas bibliotecas tenham que incluir essas dependências por conta própria (porque caso contrário, há colisões desses projetos já estão vinculando cópias da biblioteca, talvez de versões diferentes ) Além do mais, você evita possíveis problemas de licenciamento em torno da redistribuição do código de outras pessoas se publicasse sua biblioteca.

Pegue o código que também precisa ser compilado em um jar e mova-o para um módulo Java simples separado no Android Studio:

1. Menu Arquivo > Novo Módulo ... > Biblioteca Java
2. Configure a biblioteca, o nome do pacote Java e os nomes das classes no assistente. (Se você não quiser criar uma classe para você, você pode simplesmente excluí-la assim que o módulo for criado)
3. Em seu código Android, configure uma dependência no novo módulo para que ele possa usar o código em sua nova biblioteca:
4. Arquivo > Estrutura do projeto > Módulos > (seu módulo Android) > Dependências > + > Dependência do módulo . Veja a imagem abaixo:
5. Escolha o seu módulo na lista da caixa de diálogo exibida:

Esperançosamente, seu projeto deve estar sendo construído normalmente agora. Depois de fazer uma construção, um arquivo jar para sua biblioteca Java será colocado no diretório build / libs no diretório do seu módulo. Se você deseja construir o arquivo jar manualmente, pode executar sua tarefa de arquivo jar a partir da janela do Gradle:

No IDE do Android Studio, acesse a " barra Executar Anything ":

CTRL+ CTRL+ gradle CreateFullJarRelease+ENTER

Depois disso, você encontrará seu artefato nesta pasta em seu projeto
Build > Intermediates > Full_jar > Release > CreateFullJarRelease > full.jar

OU

O Gradle já tem um Taskpara isso, no menu lateral do gradle, abaixo da otherpasta.

Em seguida, role para baixo createFullJarReleasee clique nele.

Depois disso, você encontrará seu artefato nesta pasta em seu projeto

Build > Intermediates > Full_jar > Release > CreateFullJarRelease > full.jar

Basta adicioná-lo ao build.gradle do módulo java. Incluirá bibliotecas dependentes no arquivo.

mainClassName = "com.company.application.Main"

jar {
  manifest { 
    attributes "Main-Class": "$mainClassName"
  }  

  from {
    configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
  }
}

Isso resultará no arquivo [module_name] / build / libs / [module_name] .jar.

O arquivo .jar será gerado automaticamente quando você compilar / executar seu aplicativo.

Você pode encontrar seu arquivo class.jar em root_folder / app / build / intermediates / bundles / debug

1. Acesse a guia Gradle no Android Studio e selecione o projeto de biblioteca.

2. Em seguida, vá para Tarefas

3. Em seguida, vá para outro

4. Clique duas vezes em bundleReleaseaar

Você pode encontrar seus .aararquivos emyour_module/build/outputs/aar/your-release.aar

a maneira que encontrei foi encontrar a saída do compilador do projeto (estrutura do projeto> projeto). em seguida, encontre a pasta compilada do módulo que deseja transformar em jar, compacte-a com zip e altere a extensão da saída de zip para jar.

task deleteJar(type: Delete) {
    delete 'libs/mylibrary.jar'
}           

task exportjar(type: Copy) {
    from('build/intermediates/compile_library_classes/release/')
    into('libs/')
    include('classes.jar')
    rename('classes.jar', 'mylibrary.jar')
}

exportjar.dependsOn(deleteJar, build)

Se você executar uma tarefa gradle no AndroidStudio ^[mais]

assembleRelease 
//or
bundleReleaseAar

ou via terminal

./gradlew <moduleName>:assembleRelease
//or
./gradlew <moduleName>:bundleReleaseAar

então você será capaz de encontrar .aarem

<project_path>/build/outputs/aar/<module_name>.aar
//if you do not see it try to remove this folder and repeat the command

.aarO arquivo (Biblioteca Android) consiste em um arquivo .jar(Biblioteca Java) e recursos Android adicionais. .aararquivo é um arquivo zip com aar extensão que é por isso que você pode substituir .aarcom .zipou correr

unzip "<path_to/module_name>.aar"