Cómo incluir manualmente el paquete aar externo usando el nuevo sistema de compilación Android Gradle

He estado experimentando con el nuevo sistema de compilación de Android y me he encontrado con un pequeño problema. He compilado mi propio paquete aar de ActionBarSherlock al que he llamado 'actionbarsherlock.aar'. Lo que intento hacer es usar este aar para construir mi APK final. Si incluyo toda la biblioteca ActionBarSherlock como un módulo de biblioteca de Android en mi proyecto principal usando el proyecto de compilación (': actionbarsherlock'), puedo construir con éxito sin ningún problema.

Pero mi problema es que quiero proporcionar esa dependencia como un paquete de archivos aar MANUALMENTE solo si quisiera un JAR, entonces parece que no puedo entender cómo incluirlo adecuadamente en mi proyecto. Intenté usar la configuración de compilación pero parece que esto no funciona. Sigo obteniendo símbolos que no pueden encontrar durante la compilación, lo que me dice que el class.jar del paquete aar no se incluye en el classpath.

¿Alguien sabe de la sintaxis para incluir manualmente un paquete aar como archivo?

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

EDITAR: Entonces la respuesta es que actualmente no es compatible, aquí está el problema si desea rastrearlo.

EDITAR: actualmente ya que esto todavía no es compatible directamente, la mejor alternativa parece ser la solución propuesta de @RanWakshlak

EDITAR: también más simple mediante el uso de la sintaxis propuesta por @VipulShah

Siga los pasos a continuación para que funcione (lo he probado hasta Android Studio 2.2)

Digamos que ha mantenido un archivo aar en la carpeta libs. (suponga que el nombre del archivo es cards.aar)

luego, en la aplicación, build.gradleespecifique lo siguiente y haga clic en sincronizar proyecto con archivos Gradle. Abra Project level build.gradle y agregue flatDir{dirs 'libs'}como lo hizo a continuación

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

y ahora abra el archivo build.grdle de nivel de aplicación y agregue el .aararchivo

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

Si todo va bien, verá que la entrada de la biblioteca se realiza en build -> exploded-aar

También tenga en cuenta que si está importando un archivo .aar de otro proyecto que tiene dependencias, también deberá incluirlos en su build.gradle.

1. Haga clic derecho en su proyecto y seleccione "Abrir configuración del módulo" .

2. Haga clic en el botón "+" en la esquina superior izquierda de la ventana para agregar un nuevo módulo.

3. Seleccione "Importar paquete .JAR o .AAR" y haga clic en el botón "Siguiente" .

4. Busque el archivo AAR con el botón de puntos suspensivos "..." al lado del campo "Nombre de archivo".

5. Mantenga el módulo de la aplicación seleccionado y haga clic en el panel Dependencias para agregar el nuevo módulo como dependencia.

6. Use el botón "+" de la pantalla de dependencias y seleccione "Dependencia del módulo" .

7. Seleccione el módulo y haga clic en "Aceptar" .

Puede hacer referencia a un archivo aar desde un repositorio. Un maven es una opción, pero hay una solución más simple: coloque el archivo aar en su directorio libs y agregue un repositorio de directorios.

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

Luego haga referencia a la biblioteca en la sección de dependencia:

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

Puede consultar la publicación del blog de Min'an para obtener más información.

El siguiente enfoque funciona con el último estudio de Android (> v0.8.x):

• Guarde el aararchivo con el módulo de aplicación libsde carpeta (por ejemplo: <project>/<app>/libs/myaar.aar)

• Agregue lo siguiente a build.gradle de la carpeta del módulo "aplicación" (no la raíz del proyecto build.gradle). Tenga en cuenta el nombre en la línea de compilación, es myaar @ aar no myaar.aar.

  dependencies {
      compile 'package.name.of.your.aar:myaar@aar'
  }
  
  repositories{
      flatDir{
          dirs 'libs'
      }
  }

• Hacer clic Tools -> Android -> Sync Project with Gradle Files

antes (predeterminado)

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

solo agregue '*.aar'en la includematriz.

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

funciona bien en Android Studio 3.x.

si quieres ignorar alguna biblioteca? hazlo así.

implementation fileTree(include: ['*.jar', '*.aar'], exclude: 'test_aar*', dir: 'libs')
debugImplementation files('libs/test_aar-debug.aar')
releaseImplementation files('libs/test_aar-release.aar')

¡Acabo de tener éxito!

1. Copie el archivo mylib-0.1.aar en la carpeta libs /

2. Agregue estas líneas al final de build.gradle (debe ser una aplicación, no un proyecto):

   repositories {
      flatDir {
          dirs 'libs'
      }
   }
   dependencies {
       compile 'com.example.lib:mylib:0.1@aar'
   }

3. Hasta aquí todo bien. Aquí viene el punto más importante:

Gradle necesita acceder a la red para las dependencias a menos que el modo fuera de línea esté habilitado.

Asegúrese de haber habilitado el trabajo sin conexión a través de la casilla de verificación en Project Structures / Gradle

- O -

Configure los ajustes del proxy para acceder a la red.

Para configurar los ajustes del proxy, debe modificar los valores del proyecto. archivo gradle.properties , configurando http y https por separado como se muestra a continuación:

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 esto funcione.

Actualmente no se admite la referencia a un archivo .aar local (como lo confirmó Xavier Ducrochet)

Lo que puede hacer en su lugar es configurar un repositorio local de Maven (mucho más simple de lo que parece) y hacer referencia al .aar desde allí.

He escrito una publicación de blog que detalla cómo hacer que funcione aquí:

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

Puede agregar múltiples aardependencias con solo unas pocas líneas de código.

Agregar flatDirrepositorio local :

repositories {
    flatDir {
        dirs 'libs'
    }
} 

Añadir todos aaren el libsdirectorio de compileconfiguración de la dependencia:

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

Desafortunadamente, ninguna de las soluciones aquí funcionó para mí (obtengo dependencias sin resolver). Lo que finalmente funcionó y es la forma más fácil en mi humilde opinión es: resaltar el nombre del proyecto desde Android Studio y luego Archivo -> Nuevo módulo -> Importar paquete JAR o AAR. El crédito va a la solución en esta publicación

Hay 2 formas:

La primera forma

1. Abra su Android Studio y navegue hasta la Create New ModuleventanaFile -> New -> New Module

2. Seleccione el Import .JAR/.AAR Packageelemento y haga clic en el Nextbotón

3. Agregue una dependencia en el build.gradlearchivo que pertenece a su appmódulo.

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

Eso es todo.

La segunda forma

1. Cree una carpeta en el libsdirectorio, como aars.

2. Pon tu lib aar en la carpeta aars.

3. Agregue el fragmento de código

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

en su build.gradlearchivo pertenece al módulo de la aplicación.

4. Agregue una dependencia en el build.gradlearchivo que pertenece a su appmódulo.

dependencies {
    ...
    implementation (name:'your aar lib name', ext:'aar')
}

Eso es todo.

Si puede leer chino, puede consultar el blog 什么 是 AAR 文件 以及 如何 在 Android 开发 中 使用

Con Android Studio 3.4 y Gradle 5 simplemente puedes hacerlo así

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

ACTUALIZAR EL ESTUDIO DE ANDROID 3.4

1. Vaya a Archivo -> Estructura del proyecto

2. Módulos y haga clic en +

3. Seleccione Importar paquete .aar

4. Encuentra la ruta .aar

5. Termine y aplique , luego verifique si se agregó el paquete

6. Ahora en el módulo de la aplicación, haga clic en + y Dependencia del módulo

7. Verifique el paquete de la biblioteca y Ok

8. Verificar la dependencia agregada

9. Y la estructura del proyecto como esta

También he tenido este problema. Este informe de problema: https://code.google.com/p/android/issues/detail?id=55863 parece sugerir que no se admite la referencia directa al archivo .AAR.

Quizás la alternativa por ahora es definir la biblioteca actionbarsherlock como una biblioteca Gradle en el directorio principal de su proyecto y hacer referencia en consecuencia.

La sintaxis se define aquí http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library

Encontré esta solución en el rastreador de problemas de Android: https://code.google.com/p/android/issues/detail?id=55863#c21

El truco (no una solución) es aislar sus archivos .aar en un subproyecto y agregar sus bibliotecas como artefactos:

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

Más información: Handling-transitive-dependencies-for-local-artifacts-jars-and-aar

En mi caso, tengo algunas dependencias en mi biblioteca y cuando creo una aardesde allí fallé, debido a las dependencias perdidas, por lo que mi solución es agregar todas las dependencias de mi biblioteca con un arrarchivo.

Entonces mi nivel de proyecto se build.gradleve así:

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) entonces:

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

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

Intenté todas las soluciones aquí, pero ninguna funciona, luego me di cuenta de que cometí un error, puse la .aarcarpeta incorrecta, como puede ver a continuación, pensé que debería ponerla en la carpeta raíz, así que creé una libscarpeta allí (1 en la imagen ), pero dentro de la carpeta de la aplicación, ya hay un libs, debe poner en segundo lugar libs, espero que esto ayude a aquellos que tienen el mismo problema que el mío:

La forma estándar de importar un archivo AAR en una aplicación se encuentra en https://developer.android.com/studio/projects/android-library.html#AddDependency

Haga clic en Archivo> Nuevo> Nuevo módulo. Haga clic en Importar paquete .JAR / .AAR y luego haga clic en Siguiente. Ingrese la ubicación del archivo AAR o JAR compilado y luego haga clic en Finalizar.

Consulte el enlace de arriba para los próximos pasos.

Solo para simplificar la respuesta

Si el archivo .aar está presente localmente, inclúyalo
compile project(':project_directory')en dependencias de build.gradle de su proyecto.

Si el archivo .aar está presente en remoto, compile 'com.*********.sdk:project_directory:0.0.1@aar'inclúyalo en dependencias de build.gradle de su proyecto.

En mi caso, solo trabajo cuando agrego "proyecto" para compilar:

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


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

puedes hacer algo como esto:

1. Coloque sus bibliotecas locales (con extensión: .jar, .aar, ...) en la carpeta 'libs' (u otra si lo desea).

2. En build.gradle (nivel de aplicación), agregue esta línea a las dependencias

   implementación fileTree (incluye: ['* .jar', '* .aar'], dir: 'libs')