Agregar archivos .aar locales a la construcción de Gradle usando "flatDirs" no funciona

Soy consciente de esta pregunta: Agregar archivos .aar locales a mi compilación gradle pero la solución no funciona para mí.

Traté de agregar esta declaración al nivel superior de mi build.gradle archivo:

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

También he puesto el slidingmenu.aar archivo /libsy lo hice referencia en la dependenciessección: compile 'com.slidingmenu.lib:slidingmenu:1.0.0@aar'pero no funcionó en absoluto.

Lo intenté compile files('libs/slidingmenu.aar')también pero sin suerte.

¿Qué me estoy perdiendo? ¿Algunas ideas?

PS Android Studio 0.8.2

Sobre la base de la respuesta de Josías, así es como lo hice funcionar.

Siguiendo sus instrucciones (bajo editar) ( Archivo -> Nuevo-> Nuevo Módulo -> Importar .JAR / .AAR ) e importe su .AAR.

Luego, en su proyecto build.gradle (no el de nivel superior, el que está debajo de 'aplicación') agregue lo siguiente (en la sección de dependencias):

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

Nota Name-Of-Your-Project debe coincidir con el nombre de la carpeta que se agregó después de importar el archivo AAR (en el mismo nivel que app/.ideaen la carpeta de nivel superior). O para decirlo de otra manera ...

Mi aplicación
  .idea
  aplicación
  build.gradle (aquí es donde agregar el proyecto de compilación (': ProjectName') a la sección de dependencia)
  ProjectName (agregado automáticamente después de la importación, coincidiendo con el nombre de su archivo aar)
  construir
  gradle
  etc.

Esto funcionó para mí con Android Studio 0.8.0. No olvides sincronizar gradle (usando el botón de la barra de herramientas o en Archivo-> Sincronizar ) después de hacer esto.

(Gracias a Josiah por ayudarme a ir en la dirección correcta)

(Nota: antes de esto intenté agregarlo a la carpeta libs, tratando de manipular el nivel superior build.gradley el nivel de la aplicación build.gradle, pero nada de eso funcionó para mis archivos aars; los jar funcionarán bien, pero no los archivos aar)

Actualización : como @ amram99 mencionó, el problema se ha solucionado a partir del lanzamiento de Android Studio v1.3.

Probado y verificado con las siguientes especificaciones

• Android Studio v1.3
• Gradle Plugin v1.2.3
• Gradle v2.4

Lo que funciona ahora

• Ahora puede importar un archivo aar local a través de la opción Archivo> Nuevo> Nuevo módulo> Importar paquete .JAR / .AAR en Android Studio v1.3

• Sin embargo, la respuesta a continuación es verdadera y efectiva independientemente de los cambios de Android Studio, ya que esto se basa en scripts de gradle.

Respuesta anterior: en una actualización reciente, la gente de Android rompió la inclusión de archivos aar locales a través de la opción de agregar nuevo módulo del menú de Android Studio. Verifica el problema enumera aquí. Independientemente de cualquier cosa que entre y salga de la lista de características de IDE, el siguiente método funciona cuando se trata de trabajar con archivos aar locales. (Probado hoy):

Coloque el archivo aar en el directorio libs (créelo si es necesario), luego agregue el siguiente código en su build.gradle:

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

Editar: La forma correcta (actualmente) de usar un archivo AAR local como dependencia de compilación es usar el asistente de importación de módulos (Archivo | Nuevo módulo | Importar .JAR o paquete .AAR) que agregará automáticamente el .aar como módulo de biblioteca en tu proyecto

Vieja respuesta

Prueba esto:

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

...

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

Tengo esto trabajando en Android Studio 2.1. Tengo un módulo llamado "Native_Ads" que se comparte entre varios proyectos.

Primero, creé un directorio en mi módulo Native_ads con el nombre 'aars' y luego puse el archivo aar allí.

Estructura de directorios:

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

Luego, los otros cambios:

Archivo Gradle de nivel superior:

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

Archivo build.gradle del módulo de aplicación: - sin cambios

Archivo Settings.gradle (para incluir el módulo):

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

Archivo Gradle para el módulo Native_Ads:

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

Eso es. Limpiar y construir.

La forma más fácil ahora es agregarlo como un módulo

Esto creará un nuevo módulo que contiene el archivo aar, por lo que solo debe incluir ese módulo como una dependencia después

Esta es mi estructura y cómo resuelvo esto:

MyProject / app / libs / mylib-1.0.0.aar

MyProject / app / myModulesFolder / myLibXYZ

En build.gradle

desde Project / app / myModulesFolder / myLibXYZ

He puesto esto:

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

Hecho y funcionando bien, mi submódulo XYZ depende de una biblioteca del módulo principal.

Puedes hacerlo de esta manera. Tiene que ir en formato maven:

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

Y luego su AAR debe ir en una estructura de carpetas para una identificación de grupo "com.example":

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

Luego referencia como dependencia:

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

¿Dónde versionestá la versión de su archivo aar (es decir, 3.0, etc.)

Para cualquiera que tenga este problema a partir de Android Studio 1.4, lo hice funcionar creando un módulo dentro del proyecto que contiene 2 cosas.

1. build.gradle con los siguientes contenidos:

   configurations.create("default")

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

2. el archivo aar (en este ejemplo 'facebook-android-sdk-4.7.0.aar')

Luego incluya la nueva biblioteca como una dependencia del módulo. Ahora puede usar un aar construido sin incluir las fuentes dentro del proyecto.

Crédito a Facebook por este truco. Encontré la solución al integrar el SDK de Android en un proyecto.

En mi caso, ¡ninguna de las respuestas anteriores funcionó! ya que tenía diferentes productos y sabores simplemente agregandorepositories{ flatDir{ dirs 'libs' } }

¡no funcionó! Terminé especificando la ubicación exacta del directorio libs :

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

}

Supongo que uno debería introducir FlatDirs como este cuando hay diferentes ProductFlavors en build.gradle

En mi caso, solo pongo el archivo aar en libs y agrego

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

en build.gradle y funciona. Creo que es similar con la dependencia generada por defecto:

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

Esta línea incluye todos aary jararchivos de la libscarpeta:

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

Agregue a continuación en el proyecto de implementación del archivo gradle de la aplicación (ruta: ': nombre del proyecto')

Si ya usa Kotlin Gradle DSL, la alternativa a usarlo de esta manera:

Aquí está mi estructura de proyecto

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

Mi app/build.gradle.kts

1. Usando un enfoque simple con 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 el mismo enfoque, como buscar desde el repositorio maven local / remoto con 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")
}

Se groupnecesitaba, debido a su obligatorio (no opcional / tiene valor predeterminado) en kotlin implementation, ver a continuación:

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

Descargo de responsabilidad: la diferencia con el flatDirsenfoque n. ° 1 y n. ° 2, todavía no sé mucho, es posible que desee editar / comentar esta respuesta.

Referencias

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