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

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

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.

1. Clique com o botão direito do mouse no seu projeto e selecione "Abrir configurações do módulo" .

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

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

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

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

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

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

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.

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

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

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.

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

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

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

Existem 2 maneiras:

A primeira maneira

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

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

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

4. 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 开发 中 使用

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

dependencies {
    implementation files('libs/actionbarsherlock.aar')
}

ATUALIZAR O ANDROID STUDIO 3.4

1. Vá para Arquivo -> Estrutura do Projeto

2. Módulos e clique em +

3. Selecione Importar .aar Package

4. Encontre a rota .aar

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

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

7. Verifique o pacote da biblioteca e Ok

8. Verifique a dependência adicionada

9. E a estrutura do projeto como esta

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

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

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

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:

A maneira padrão de importar o arquivo AAR em um aplicativo é fornecida em https://developer.android.com/studio/projects/android-library.html#AddDependency

Clique em Arquivo> Novo> Novo Módulo. Clique em Importar pacote .JAR / .AAR e clique em Avançar. Digite o local do arquivo AAR ou JAR compilado e clique em Concluir.

Consulte o link acima para as próximas etapas.

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.

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

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