Adicionar arquivos .aar locais à compilação Gradle usando "flatDirs" não está funcionando

Estou ciente desta pergunta: Adicionando arquivos .aar locais à minha compilação gradle, mas a solução não funciona para mim.

Tentei adicionar esta declaração ao nível superior do meu build.gradlearquivo:

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

Também coloquei o slidingmenu.aararquivo /libse o referenciei na dependenciesseção: compile 'com.slidingmenu.lib:slidingmenu:1.0.0@aar'mas não funcionou.

Eu tentei compile files('libs/slidingmenu.aar')também, mas sem sorte.

o que estou perdendo? Alguma ideia?

PS Android Studio 0.8.2

Com base na resposta de Josiah, eis como eu consegui que ela funcionasse.

Seguindo suas instruções (em edição) ( Arquivo -> Novo -> Novo módulo -> Importar .JAR / .AAR ) e importe seu .AAR.

Em seguida, no seu projeto build.gradle (não no nível superior, em 'app'), adicione o seguinte (na seção de dependências):

dependencies {
    compile project(':Name-Of-Your-Project')
}

Nota O nome do seu projeto deve corresponder ao nome da pasta que foi adicionada após a importação do arquivo AAR (no mesmo nível que app/.idea da pasta do nível superior). Ou, dito de outra maneira ...

Minha aplicação
  .idéia
  aplicativo
  build.gradle (aqui é onde adicionar o projeto de compilação (': ProjectName') à seção de dependência)
  ProjectName (adicionado automaticamente após a importação, correspondendo ao nome do seu arquivo aar)
  Construir
  gradle
  etc

Isso funcionou para mim executando o Android Studio 0.8.0. Não se esqueça de sincronizar o gradle (usando o botão da barra de ferramentas ou em Arquivo-> Sincronizar ) depois de fazer isso.

(Obrigado a Josiah por me fazer seguir na direção certa)

(Nota: antes disso, tentei adicioná-lo à pasta libs, tentando manipular o nível superior build.gradlee o nível do aplicativo build.gradle, mas nada disso funcionou nos meus arquivos aars - os jar's funcionarão bem, mas não nos arquivos aar)

Atualização : como o @ amram99 mencionou, o problema foi corrigido a partir do lançamento do Android Studio v1.3.

Testado e verificado com as especificações abaixo

• Android Studio v1.3
• gradle plugin v1.2.3
• Gradle v2.4

O que funciona agora

• Agora você pode importar um arquivo aar local através da opção Arquivo> Novo> Novo módulo> Importar pacote .JAR / .AAR no Android Studio v1.3

• No entanto, a resposta abaixo é verdadeira e eficaz, independentemente das alterações do Android Studio, pois ela se baseia em scripts gradle.

Resposta antiga: Em uma atualização recente, as pessoas no Android interromperam a inclusão de arquivos locais do AAR por meio da opção de menu Adicionar novo módulo do Android Studio. Verifique o problema listado aqui. Independentemente de tudo o que entra e sai da lista de recursos do IDE, o método abaixo funciona quando se trata de trabalhar com arquivos aar locais (testado hoje):

Coloque o arquivo aar no diretório libs (crie-o se necessário) e adicione o seguinte código em seu build.gradle:

dependencies {
   compile(name:'nameOfYourAARFileWithoutExtension', ext:'aar')
 }
repositories{
      flatDir{
              dirs 'libs'
       }
 }

Editar: A maneira correta (atualmente) de usar um arquivo AAR local como uma dependência de compilação é usar o assistente de importação de módulo (Arquivo | Novo Módulo | Importar pacote .JAR ou .AAR) que adicionará automaticamente o .aar como um módulo de biblioteca no seu projecto.

Resposta antiga

Tente o seguinte:

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

...

compile(name:'slidingmenu', ext:'aar')

Eu consegui isso trabalhando no Android Studio 2.1. Eu tenho um módulo chamado "Native_Ads", que é compartilhado em vários projetos.

Primeiro, criei um diretório no meu módulo Native_ads com o nome 'aars' e depois coloquei o arquivo aar lá.

Estrutura de diretório:

libs/
aars/    <-- newly created
src/
build.gradle
etc

Então, as outras mudanças:

Arquivo Gradle de nível superior:

allprojects {
    repositories {
        jcenter()
        // For module with aar file in it
        flatDir {
            dirs project(':Native_Ads').file('aars')
        }
    }
}

Arquivo build.gradle do módulo de aplicativo: - sem alterações

Arquivo Settings.gradle (para incluir o módulo):

include ':app'
include 'Native_Ads'
project(':Native_Ads').projectDir = new File(rootProject.projectDir, '../path/to/Native_Ads')

Arquivo Gradle para o módulo Native_Ads:

repositories {
    jcenter()
    flatDir {
        dirs 'aars'
    }
}
dependencies {
    compile(name:'aar_file_name_without_aar_extension', ext:'aar')
}

É isso aí. Limpe e construa.

A maneira mais fácil agora é adicioná-lo como um módulo

Isso criará um novo módulo contendo o arquivo aar, então você só precisará incluir esse módulo como uma dependência posteriormente

Esta é a minha estrutura e como eu resolvo isso:

MyProject / app / libs / mylib-1.0.0.aar

MyProject / app / myModulesFolder / myLibXYZ

No build.gradle

em Project / app / myModulesFolder / myLibXYZ

Eu coloquei isso:

repositories {
   flatDir {
    dirs 'libs', '../../libs'
  }
}
compile (name: 'mylib-1.0.0', ext: 'aar')

Feito e funcionando bem, meu submódulo XYZ depende de alguma biblioteca do módulo principal.

Você pode fazer assim. Precisa ir no formato maven:

repositories {
  maven { url uri('folderName')}
}

E então seu AAR precisa entrar em uma estrutura de pastas para um ID de grupo "com.example":

folderName/
  com/
    example/
       verion/
          myaar-version.aar

Em seguida, faça referência como uma dependência:

compile 'com.example:myaar:version@aar'

Onde versionestá a versão do seu arquivo aar (por exemplo, 3.0, etc)

Para quem tem esse problema no Android Studio 1.4, consegui que ele funcionasse criando um módulo no projeto que contém duas coisas.

1. build.gradle com o seguinte conteúdo:

   configurations.create("default")

   artifacts.add("default", file('facebook-android-sdk-4.7.0.aar'))

2. o arquivo aar (neste exemplo 'facebook-android-sdk-4.7.0.aar')

Em seguida, inclua a nova biblioteca como uma dependência do módulo. Agora você pode usar um aar construído sem incluir as fontes no projeto.

Crédito para o Facebook por este hack. Encontrei a solução ao integrar o SDK do Android em um projeto.

No meu caso, nenhuma das respostas acima funcionou! desde que eu tinha diferentes productFlavors apenas adicionandorepositories{ flatDir{ dirs 'libs' } }

não funcionou! Acabei especificando a localização exata do diretório libs :

repositories{
flatDir{
    dirs 'src/main/libs'
}

}

Acho que deve-se apresentar flatDirs como este quando houver diferentes productFlavors no build.gradle

No meu caso, eu apenas coloquei o arquivo aar em libs e adicionei

dependencies { ... api fileTree(dir: 'libs', include: ['*.aar']) ... }

no build.gradle e funciona. Eu acho que é semelhante com a dependência gerada padrão:

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

Esta linha inclui todo aare jararquivos da libspasta:

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

Adicione abaixo no projeto de implementação do arquivo gradle do aplicativo (caminho: ': nome do projeto')

Se você já usa o DSL Kotlin Gradle, a alternativa é usá-lo desta maneira:

Aqui está a estrutura do meu projeto

|-root
|----- app
|--------- libs // I choose to store the aar here
|-------------- my-libs-01.aar
|-------------- my-libs-02.jar
|--------- build.gradle.kts // app module gradle
|----- common-libs // another aar folder/directory
|----------------- common-libs-01.aar
|----------------- common-libs-02.jar
|----- build.gradle.kts // root gradle

Minhas app/build.gradle.kts

1. Usando uma abordagem simples com fileTree

// android related config above omitted...

dependencies {
    // you can do this to include everything in the both directory
    // Inside ./root/common-libs & ./root/app/libs
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
    implementation(fileTree(mapOf("dir" to "../common-libs", "include" to listOf("*.jar", "*.aar"))))
}

2. Usando a mesma abordagem, como buscar no repositório maven local / remoto com flatDirs

// android related config above omitted...

repositories {
    flatDir {
        dirs = mutableSetOf(File("libs"), File("../common-libs") 
    }
}

dependencies {
   implementation(group = "", name = "my-libs-01", ext = "aar")
   implementation(group = "", name = "my-libs-02", ext = "jar")

   implementation(group = "", name = "common-libs-01", ext = "aar")
   implementation(group = "", name = "common-libs-02", ext = "jar")
}

A groupera necessária, devido à sua obrigatória (não / opcional possui valor padrão) em Kotlin implementation, veja abaixo:

// Filename: ReleaseImplementationConfigurationAccessors.kt
package org.gradle.kotlin.dsl

fun DependencyHandler.`releaseImplementation`(
    group: String,
    name: String,
    version: String? = null,
    configuration: String? = null,
    classifier: String? = null,
    ext: String? = null,
    dependencyConfiguration: Action<ExternalModuleDependency>? = null
)

Isenção de responsabilidade: a diferença usando a flatDirsabordagem no.1 e no.2, ainda não sei muito, você pode querer editar / comentar esta resposta.

Referências:

1. https://stackoverflow.com/a/56828958/3763032
2. https://github.com/gradle/gradle/issues/9272