Como incluir manualmente o pacote aar externo usando o novo Gradle Android Build System

406

Eu tenho experimentado o novo sistema de compilação Android e me deparei com um pequeno problema. Compilei meu próprio pacote aar de ActionBarSherlock, que chamei de 'actionbarsherlock.aar'. O que estou tentando fazer é realmente usar este aar para criar meu APK final. Se eu incluir toda a biblioteca ActionBarSherlock como um módulo da biblioteca android no meu projeto principal usando o projeto de compilação (': actionbarsherlock'), sou capaz de criar com êxito sem problemas.

Mas o meu problema é que eu quero fornecer essa dependência como um pacote de arquivos aar MANUALMENTE apenas se eu fosse um JAR, não consigo descobrir como incluí-lo corretamente no meu projeto. Eu tentei usar a configuração de compilação, mas isso não parece funcionar. Eu continuo recebendo, não consigo encontrar o símbolo durante a compilação, o que me diz que o pacote classes.jar do aar não está sendo incluído no caminho de classe.

Alguém sabe da sintaxe para incluir manualmente um pacote aar como um arquivo?

build.gradle

buildscript {

 repositories {
     mavenCentral()
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:0.4'
  }
}
apply plugin: 'android'

repositories {
   mavenCentral()
}
dependencies {
    compile files('libs/actionbarsherlock.aar')
}

android {
    compileSdkVersion 15
    buildToolsVersion "17.0"
}

EDIT: Portanto, a resposta é que não há suporte no momento. Aqui está o problema, se você quiser acompanhá-lo.

EDIT: Atualmente, como isso ainda não é suportado diretamente, a melhor alternativa parece ser a solução proposta em @RanWakshlak

EDIT: Também mais simples, usando a sintaxe proposta por @VipulShah

Miguel Lavigne
fonte
Considere a resposta de Vipul Shah: ela finalmente funcionou para mim, sem o repositório maven local, a partir do Android Studio 0.5.8.
Shkschneider
Dê uma olhada na minha pergunta e responda aqui stackoverflow.com/a/31662782/746347
mixel
Se você estiver usando o Gradle 3.0.0 ou superior, esta configuração simples do Gradle funcionou para mim: stackoverflow.com/questions/29081429/…
user1506104

Respostas:

670

Siga as etapas abaixo para fazê-lo funcionar (eu testei no Android Studio 2.2)

Digamos que você tenha mantido o arquivo aar na pasta libs. (suponha que o nome do arquivo seja cards.aar)

no aplicativo, build.gradleespecifique a seguir e clique em sincronizar projeto com arquivos Gradle. Abra o nível de Projeto build.gradle e adicione flatDir{dirs 'libs'}como fez abaixo

allprojects {
   repositories {
      jcenter()
      flatDir {
        dirs 'libs'
      }
   }
}

e agora abra o arquivo build.grdle no nível do aplicativo e adicione o .aararquivo

    dependencies {
       compile(name:'cards', ext:'aar')
}

Se tudo correr bem, você verá que a entrada da biblioteca é feita em build -> exploded-aar

Observe também que se você estiver importando um arquivo .aar de outro projeto que possui dependências, também será necessário incluí-las no build.gradle.

Vipul Shah
fonte
5
@VipulShah, onde está localizado o diretório libs?
StuStirling
2
Talvez seja aconselhável colocar modificações no módulo de aplicativo 'build.gradle' e não na pasta superior 'build.gradle'.
precisa saber é o seguinte
4
encontrado resposta à minha pergunta acima: em vez do compileadd dependência duas dependências debugCompile(name:'cards-debug', ext:'aar')ereleaseCompile(name:'cards-release', ext:'aar')
Iftah
2
Não se confunda com o código de exemplo. O primeiro bloco com allprojects {...}vai para o arquivo gradle de nível "projeto" e a segunda parte com dependencies {...}deve ir para o arquivo gradle de nível "app".
Kirill Karmazin
8
Atualize a sua resposta: AVISO: A configuração 'compilar' é obsoleta e foi substituída por 'implementação' e 'api'. Ele será removido no final de 2018. Para obter mais informações, consulte: d.android.com/r/tools/update-dependency-configurations.html
B-GangsteR
248
  1. Clique com o botão direito do mouse no seu projeto e selecione "Abrir configurações do módulo" .

Abrir configurações do módulo

  1. Clique no botão "+" no canto superior esquerdo da janela para adicionar um novo módulo.

Adicionar novo módulo

  1. Selecione "Importar pacote .JAR ou .AAR" e clique no botão "Avançar" .

AAR de importação

  1. Encontre o arquivo AAR usando o botão de reticências "..." ao lado do campo "Nome do arquivo".

Localizar arquivo AAR

  1. Mantenha o módulo do aplicativo selecionado e clique no painel Dependências para adicionar o novo módulo como uma dependência.

Painel Dependências

  1. Use o botão "+" da tela de dependências e selecione "Dependência do módulo" .

Adicionar dependência de módulo

  1. Selecione o módulo e clique em "OK" .

Escolha o módulo

Oliver Kranz
fonte
4
Melhor resposta, lembre-se disso depois de fazer o Alt+Bprojeto limpo e reconstruir. Android Studio por que você é doloroso! Eu gostaria de ter o NetBeans IDE como Android Developer Platform
java acm
@ Oliver Você é demais!
ankit purwar
Você é o melhor!
Codezombie #
2
Não é a melhor idéia para criar um novo módulo de cada vez que você quiser apenas adicionar alguns aarlib ao seu projeto
Kirill Karmazin
Você é demais meu amigo. !! Um brinde a isso.
Timothy Macharia
112

Você pode fazer referência a um arquivo aar de um repositório. Um maven é uma opção, mas existe uma solução mais simples: coloque o arquivo aar no diretório libs e adicione um repositório de diretórios.

    repositories {
      mavenCentral()
      flatDir {
        dirs 'libs'
      }
    }

Em seguida, faça referência à biblioteca na seção de dependência:

  dependencies {
        implementation 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
}

Você pode conferir a publicação no blog Min'an para obter mais informações.

Ran Wakshlak
fonte
11
Isso funciona muito bem e é melhor do que as respostas aceitas / com classificação mais alta porque é mais simples e posso incluí-lo no controle de versão sem adicionar o arquivo ao repositório local de desenvolvedores de cada desenvolvedor (se eu tiver que fazer isso, por que usar Gradle em primeiro lugar ?) Obrigado!
ajpolt
@ajpolt Provavelmente, é recomendável configurar um servidor de repositório (para deps proprietários) para que você não precise colocá-lo em máquinas de desenvolvimento ou na pasta lib do seu projeto. Se você só tem uma dependência, jogá-lo fora em um maven estruturado repositório de código do Google (como um repo temp)
Lo-Tan
4
O ponto mais importante a ser observado nesta resposta é mencionar '@aar' no final da dependência.
Atharva
Suponho que isso não funcionará mais com o plug-in gradle mais recente: stackoverflow.com/questions/60878599/…
David
Essa é a única resposta que inclui a forma mais simples, com toda a sintaxe moderna, inclusive implementationetc. Isso é copiar e colar a solução. Muitas novas votações recebidas porque o Android Build Gradle Plugin 4.0.0 agora gera um erro em vez de ignorar caminhos .aar quebrados
Patrick
51

A abordagem abaixo funciona com o estúdio Android mais recente (> v0.8.x):

  • Salve o aararquivo na libspasta do módulo de aplicativo (por exemplo <project>/<app>/libs/myaar.aar:)

  • Adicione o seguinte a build.gradle da pasta do módulo "app" (não a raiz do projeto build.gradle). Observe o nome na linha de compilação, é myaar @ aar não myaar.aar.

    dependencies {
        compile 'package.name.of.your.aar:myaar@aar'
    }
    
    repositories{
        flatDir{
            dirs 'libs'
        }
    }
  • Clique Tools -> Android -> Sync Project with Gradle Files

ashoke
fonte
3
Funciona perfeitamente no AS 1.0
Pablo Johnson
11
No caso de alguém precisa dele, se Gradle funciona ok, mas você ainda não pode ver as classes, reiniciar Android estúdio ...
htafoya
11
Essa solução funciona muito bem no AS2.2 - o gradle é incrivelmente exigente na sintaxe dos arquivos AAR que parece.
Jim Andreas
Atualize ou exclua, a compilação foi descontinuada e também existe esse problema: stackoverflow.com/questions/60878599/…
David
49

antes (padrão)

implementation fileTree(include: ['*.jar'], dir: 'libs')

basta adicionar '*.aar'na includematriz.

implementation fileTree(include: ['*.jar', '*.aar'], dir: 'libs')

funciona bem no Android Studio 3.x.

se você quiser ignorar alguma biblioteca? faça assim.

implementation fileTree(include: ['*.jar', '*.aar'], exclude: 'test_aar*', dir: 'libs')
debugImplementation files('libs/test_aar-debug.aar')
releaseImplementation files('libs/test_aar-release.aar')
Changhoon
fonte
2
Embora esse código possa responder à pergunta, fornecer um contexto adicional a respeito de como e / ou por que ele resolve o problema melhoraria o valor a longo prazo da resposta.
Alexander Alexander
11
Funcionando bem, este é o caminho a percorrer se a biblioteca for simples. Mas é um problema aqui: você precisa importar toda a biblioteca importada no seu arquivo aar para fazê-lo funcionar. A importação do arquivo aar não é propagada usando esse método.
7118 Tobliug
Ou, ainda mais simples:implementation fileTree(include: ['*.?ar'], dir: 'libs')
friederbluemle
@friederbluemle Em vez de mais simples, diria mais curto e, ao mesmo tempo, inespecífico, teoricamente.
David
21

Acabei de ter sucesso!

  1. Copie o arquivo mylib-0.1.aar na pasta libs /

  2. Adicione estas linhas na parte inferior do build.gradle (deve ser app, não projeto):

    repositories {
       flatDir {
           dirs 'libs'
       }
    }
    dependencies {
        compile 'com.example.lib:mylib:0.1@aar'
    }
  3. Por enquanto, tudo bem. Aí vem o ponto mais importante:

Gradle precisa acessar a rede para dependências, a menos que o modo offline esteja ativado.

Certifique-se de ter ativado o trabalho off-line através da caixa de seleção em Estruturas de projeto / Gradle

- OU -

Defina as configurações de proxy para acessar a rede.

Para definir as configurações de proxy, você deve modificar o arquivo gradle.properties do projeto , configurando http e https separadamente, como abaixo:

systemProp.http.proxyHost=proxy.example.com
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=user
systemProp.http.proxyPassword=pass
systemProp.http.nonProxyHosts=localhost
systemProp.http.auth.ntlm.domain=example <for NT auth>

systemProp.https.proxyHost=proxy.example.com
systemProp.https.proxyPort=8080
systemProp.https.proxyUser=user
systemProp.https.proxyPassword=pass
systemProp.https.nonProxyHosts=localhost
systemProp.https.auth.ntlm.domain=example <for NT auth>

Espero que isso funcione.

Orhun D.
fonte
Atualize ou exclua, a compilação está obsoleta e também existe esse problema: stackoverflow.com/questions/60878599/…
David
20

Atualmente, não há suporte para a referência a um arquivo .aar local (conforme confirmado por Xavier Ducrochet)

O que você pode fazer é configurar um repositório Maven local (muito mais simples do que parece) e fazer referência ao .aar a partir daí.

Eu escrevi um post do blog detalhando como fazê-lo funcionar aqui:

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

Artiom Chilaru
fonte
Não consegui fazê-lo funcionar quando o artefato é um instantâneo, alguma ideia do porquê?
tbruyelle
Você conseguiu isso trabalhando apenas com o Eclipse ou com o Android studio? Com o eclipse, "gradle eclipse" adiciona o arquivo aar ao caminho de classe, mas o eclipse não reconhece classes nele.
andrej_k
Verifique esta pergunta stackoverflow.com/questions/20911665/... se depois de seguir o tutorial seu arquivo .aar local não é encontrado (em Gradle 1.9 ou superior)
Maragues
Atualize ou exclua, esta resposta está obsoleta.
David
19

Você pode adicionar várias aardependências com apenas algumas linhas de código.

Adicione flatDirrepositório local :

repositories {
    flatDir {
        dirs 'libs'
    }
} 

Adicione todos os diretórios aarin libsà compileconfiguração de dependência:

fileTree(dir: 'libs', include: '**/*.aar')
        .each { File file ->
    dependencies.add("compile", [name: file.name.lastIndexOf('.').with { it != -1 ? file.name[0..<it] : file.name }, ext: 'aar'])
}
mixel
fonte
Isso funcionou, mas como colocar uma verificação, se a dependência já foi adicionada como uma dependência automatizada, então eu não quero que o arquivo aar precise ser adicionado, PS: Estou usando isso para escrever um plugin que adiciona automaticamente meu aar ao projeto android e acrescenta dependência em build.gradle
Adi
@Adi Se você já possui uma dependência independente, não coloque o aar correspondente na libspasta.
Mixel
Obrigado pela resposta. Como mencionei, a adição de aar às bibliotecas é automatizada por um plug-in do Android studio que está sendo desenvolvido. Então, quero saber se a dependência que o plug-in adiciona ao arquivo build.gradle já foi adicionada anteriormente.
Adi
Eu não tenho resposta agora. Eu acho que é melhor criar uma pergunta separada.
mixel
15

Infelizmente, nenhuma das soluções aqui funcionou para mim (eu recebo dependências não resolvidas). O que finalmente funcionou e é a maneira mais fácil do IMHO: Destaque o nome do projeto no Android Studio e, em seguida, Arquivo -> Novo módulo -> Importar pacote JAR ou AAR. O crédito vai para a solução neste post

Nonos
fonte
11
Note-se que o Android Studio é excepcionalmente vago em seu assistente de importação. Quando eles afirmam "Nome do arquivo" em uma das etapas, o que eles realmente estão pedindo é o caminho do arquivo ... Espero que esta mensagem salve outras pessoas de uma dor de cabeça.
21816 Tukajo
13

Existem 2 maneiras:

A primeira maneira

  1. Abra seu Android Studio e navegue até a Create New ModulejanelaFile -> New -> New Module

insira a descrição da imagem aqui

  1. Selecione o Import .JAR/.AAR Packageitem e clique no Nextbotão

  2. Adicione uma dependência no build.gradlearquivo que pertence ao seu appmódulo.

    dependencies {
        ...
        implementation project(path: ':your aar lib name')
    }

Isso é tudo.

O segundo caminho

  1. Crie uma pasta no libsdiretório, como aars.

  2. Coloque seu aar lib na pasta aars.

  3. Adicione o snippet de código

repositories {
    flatDir {
        dirs 'libs/aars'
    }
}

no seu build.gradlearquivo pertence ao módulo do aplicativo.

  1. Adicione uma dependência no build.gradlearquivo que pertence ao seu appmódulo.
dependencies {
    ...
    implementation (name:'your aar lib name', ext:'aar')
}

Isso é tudo.

Se você sabe ler chinês, pode consultar o blog 是 是 AAR 文件 以及 如何 在 Android 开发 中 使用

shusheng007
fonte
esta resposta foi realmente útil para mim
Csábi
Quando seguidas pela primeira vez, as classes dentro do arquivo aar não são detectadas no projeto principal, precisamos adicionar alguma configuração extra?
Kiran
Atualize ou exclua, as primeiras respostas já foram postadas e a segunda "compilação" foi preterida.
David
12

Com o Android Studio 3.4 e Gradle 5, você pode simplesmente fazer assim

dependencies {
    implementation files('libs/actionbarsherlock.aar')
}
m0skit0
fonte
11
Esta é a melhor resposta. A dependência é explícita e muito simples.
Nikmoon 26/01
11
Concordou que esta é a melhor resposta. Trabalhou instantaneamente, foi perfeito para adicionar dependências .aar a uma biblioteca React Native.
Josh Baker
11
Isso gera um erro começando com o plug-in gradle 4: stackoverflow.com/questions/60878599/…
David
@ David Obrigado pelo relatório, vou tentar testá-lo o mais rápido possível.
m0skit0
10

ATUALIZAR O ANDROID STUDIO 3.4

  1. Vá para Arquivo -> Estrutura do Projeto

insira a descrição da imagem aqui

  1. Módulos e clique em +

insira a descrição da imagem aqui

  1. Selecione Importar .aar Package

insira a descrição da imagem aqui

  1. Encontre a rota .aar

insira a descrição da imagem aqui

  1. Concluir e aplicar e verifique se o pacote foi adicionado

insira a descrição da imagem aqui

  1. Agora no módulo do aplicativo, clique em + e Dependência do módulo

insira a descrição da imagem aqui

  1. Verifique o pacote da biblioteca e Ok

insira a descrição da imagem aqui

  1. Verifique a dependência adicionada

insira a descrição da imagem aqui

  1. E a estrutura do projeto como esta

insira a descrição da imagem aqui

Álvaro Agüero
fonte
11
esta é a 17ª resposta que li que finalmente adicionou dependência .. eeh
Taras Matsyk 11/11/19
6

Eu também tive esse problema. Este relatório de problema: https://code.google.com/p/android/issues/detail?id=55863 parece sugerir que a referência direta ao arquivo .AAR não é suportada.

Talvez a alternativa, por enquanto, seja definir a biblioteca actionbarsherlock como uma biblioteca Gradle no diretório pai do seu projeto e referenciá-la adequadamente.

A sintaxe é definida aqui http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library


fonte
Obrigado pela referência ao problema. Sim, eu sei como fazer isso funcionar usando a Biblioteca Android Gradle, mas essa opção não é realmente ideal para o projeto em que estou trabalhando, mas sim!
Miguel Lavigne
3

Encontrei esta solução alternativa no rastreador de problemas do Android: https://code.google.com/p/android/issues/detail?id=55863#c21

O truque (não uma correção) é isolar seus arquivos .aar em um subprojeto e adicionar suas bibliotecas como artefatos:

configurations.create("default")
artifacts.add("default", file('somelib.jar'))
artifacts.add("default", file('someaar.aar'))

Mais informações: Manipulação de dependências transitivas para artefatos locais-jarros-e-aar

jiparis
fonte
Está certo, e aqui está o exemplo: em github.com/textileio/notes/commit/… , compile project(':mobile')em android / app / build.gradle, configurations.maybeCreate("default")em android / mobile / build.gradle, include ':mobile'em android / settings.gradle
Li Zheng
3

No meu caso, tenho algumas representações na minha biblioteca e quando crio uma aardelas falhei, devido às representações perdidas, portanto, minha solução é adicionar todas as representações da minha biblioteca com um arrarquivo.

Portanto, o nível do meu projeto build.gradleé assim:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.2'
    }
}

allprojects {
    repositories {
        mavenCentral()
        //add it to be able to add depency to aar-files from libs folder in build.gradle(yoursAppModule)
        flatDir {
            dirs 'libs'
        }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

build.gradle(modile app) tão:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        applicationId "com.example.sampleapp"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    //your project depencies
    ...
    //add lib via aar-depency
    compile(name: 'aarLibFileNameHere', ext: 'aar')
    //add all its internal depencies, as arr don't have it
    ...
}

e biblioteca build.gradle:

apply plugin: 'com.android.library'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    //here goes library projects dependencies, which you must include
    //in yours build.gradle(modile app) too
    ...
}
mohax
fonte
3

Eu tentei todas as soluções aqui, mas nenhuma está funcionando, então percebo que cometi um erro, coloquei a .aarpasta errada, como você pode ver abaixo, pensei em colocar na pasta raiz, então criei uma libspasta lá (1 na foto ), mas dentro da pasta do aplicativo, já existe um libs, você deve colocar em segundo libs, espero que ajude aqueles que têm o mesmo problema que o meu:

insira a descrição da imagem aqui

GMsoF
fonte
2

Apenas para simplificar a resposta

Se o arquivo .aar estiver presente localmente, inclua
compile project(':project_directory')nas dependências do build.gradle do seu projeto.

Se o arquivo .aar estiver presente no controle remoto, inclua compile 'com.*********.sdk:project_directory:0.0.1@aar'nas dependências do build.gradle do seu projeto.

anupam_kamble
fonte
0

No meu caso, basta trabalhar quando adiciono "projeto" para compilar:

repositories {
    mavenCentral()
    flatDir {
        dirs 'libs'
    }
}


dependencies {
   compile project('com.x.x:x:1.0.0')
}
josedlujan
fonte
0

você pode fazer algo assim:

  1. Coloque suas bibliotecas locais (com a extensão: .jar, .aar, ...) na pasta 'libs' (ou outra, se desejar).

  2. No build.gradle (nível do aplicativo), inclua esta linha nas dependências

    fileTree de implementação (incluem: ['* .jar', '* .aar'], dir: 'libs')

nguyencse
fonte