How to manually include external aar package using Gradle for Android

Please follow below steps to get it working ( I have tested it up to Android Studio 2.2)

Lets say you have kept aar file in libs folder. ( assume file name is cards.aar )

then in app build.gradle specify following and click sync project with Gradle files. Open Project level build.gradle and add flatDir{dirs 'libs'} like did below

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

and now open app level build.grdle file and add .aar file

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

If everything goes well you will see library entry is made in build -> exploded-aar

Also note that if you are importing a .aar file from another project that has dependencies you'll need to include these in your build.gradle, too.

---

Right click on your project and select "Open Module Settings".

https://i.stack.imgur.com/bu5D2.png

Click the "+" button in the top left corner of window to add a new module.

https://i.stack.imgur.com/oEH90.png

Select "Import .JAR or .AAR Package" and click the "Next" button.

https://i.stack.imgur.com/Cmj8E.png

Find the AAR file using the ellipsis button "..." beside the "File name" field.

https://i.stack.imgur.com/DOoXM.png

Keep the app's module selected and click on the Dependencies pane to add the new module as a dependency.

https://i.stack.imgur.com/OjTOp.png

Use the "+" button of the dependencies screen and select "Module dependency".

https://i.stack.imgur.com/AO0eg.png

Select the module and click "OK".

https://i.stack.imgur.com/26yRA.png

EDIT: Module dependency in screenshot 6 has been removed in Android Studio 4.1. As an alternative add the module dependency to the build.gradle.

dependencies {
    implementation project(':your_module')
}

EDIT: The user interface and the work flow have been changed a lot in Android Studio 4.2. The process to add a dependency is very well explained in an official documentation now: Adding dependencies with the Project Structure Dialog

---

You can reference an aar file from a repository. A maven is an option, but there is a simpler solution: put the aar file in your libs directory and add a directory repository.

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

Then reference the library in the dependency section:

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

You can check out Min'an blog post for more info.

---

before(default)

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

just add '*.aar' in include array.

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

it works well on Android Studio 3.x.

if you want ignore some library? do like this.

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

---

The below approach works with Android studio v0.8.x:

Save the aar file under app module's libs folder (eg: //libs/myaar.aar)

Add the below to build.gradle of your "app" module folder (not your project root build.gradle). Note the name in compile line, it is myaar@aar not myaar.aar. dependencies { compile 'package.name.of.your.aar:myaar@aar' } repositories{ flatDir{ dirs 'libs' } }

Click Tools -> Android -> Sync Project with Gradle Files

---

With Android Studio 3.4 and Gradle 5 you can simply do it like this

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

---

Add below line in app level build.gradle

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

Change Project structure from Android to Project.

Navigaate to app->libs as below

https://i.stack.imgur.com/ofBSB.png

Then paste "aar" in libs folder.

Click on File at top left of android studio and click "Sync Project with Gradle Files" as below.

https://i.stack.imgur.com/o1XeX.png

That's it.

---

Currently referencing a local .aar file is not supported (as confirmed by Xavier Ducrochet)

What you can do instead is set up a local Maven repository (much more simple than it sounds) and reference the .aar from there.

I've written a blogpost detailing how to get it working here:

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

---

I've just succeeded!

Copy the mylib-0.1.aar file into the libs/ folder Add these lines to the bottom of build.gradle (should be app, not project): repositories { flatDir { dirs 'libs' } } dependencies { compile 'com.example.lib:mylib:0.1@aar' } So far so good. Here comes the most important point:

Gradle needs to access the network for dependencies unless offline mode is enabled.

Make sure that you have enabled Offline work via the checkbox in Project Structures/Gradle

-- OR --

Configure the proxy settings in order to access the network.

To configure the proxy settings you have to modify the project's gradle.properties file, configuring http and https separately as below:

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>

Hope this works.

---

There are 2 ways:

The first way

Open your Android Studio and navigate to the Create New Module window by File -> New -> New Module

https://i.stack.imgur.com/7xWVm.jpg

Select the Import .JAR/.AAR Package item and click the Next button Add a dependency in the build.gradle file that belongs to your app module.

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

That's all.

The second way

Create a folder in libs directory, such as aars. Put your aar lib into the aars folder. Add the code snippet

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

into your build.gradle file belongs to the app module.

Add a dependency in the build.gradle file that belongs to your app module.

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

That's all.

If you can read Chinese, you can check the blog 什么是AAR文件以及如何在Android开发中使用

---

You can add multiple aar dependencies with just few lines of code.

Add local flatDir repository:

repositories {
    flatDir {
        dirs 'libs'
    }
} 

Add every aar in libs directory to compile dependency configuration:

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

---

Unfortunately none of the solutions here worked for me (I get unresolved dependencies). What finally worked and is the easiest way IMHO is: Highlight the project name from Android Studio then File -> New Module -> Import JAR or AAR Package. Credit goes to the solution in this post

---

If you use Gradle Kotlin DSL, you need to add a file in your module directory.

For example: libs/someAndroidArchive.aar

After just write this in your module build.gradle.kts in the dependency block:

implementation(files("libs/someAndroidArchive.aar"))

---

UPDATE ANDROID STUDIO 3.4

Go to File -> Project Structure

https://i.stack.imgur.com/tGcEY.jpg

Modules and click on +

https://i.stack.imgur.com/AA7mw.png

Select Import .aar Package

https://i.stack.imgur.com/jdEce.png

Find the .aar route

https://i.stack.imgur.com/aU4if.png

Finish and Apply, then verify if package is added

https://i.stack.imgur.com/JHbDa.png

Now in the app module, click on + and Module Dependency

https://i.stack.imgur.com/NVACg.png

Check the library package and Ok

https://i.stack.imgur.com/3gJRh.png

Verify the added dependency

https://i.stack.imgur.com/06fQW.png

And the project structure like this

https://i.stack.imgur.com/ZJeEz.png

---

To manually import AAR files with Android Studio Arctic Fox

https://i.stack.imgur.com/zruFE.png

https://i.stack.imgur.com/tzvjt.png

https://i.stack.imgur.com/NwUj9.png

DONE!

---

I've also had this problem. This issue report: https://code.google.com/p/android/issues/detail?id=55863 seems to suggest that directly referencing the .AAR file is not supported.

Perhaps the alternative for now is to define the actionbarsherlock library as a Gradle library under the parent directory of your project and reference accordingly.

The syntax is defined here http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library

---

In my case I have some depencies in my library and when I create an aar from it I failed, because of missed depencies, so my solution is to add all depencies from my lib with an arr file.

So my project level build.gradle looks so:

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

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

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

---

The standard way to import AAR file in an application is given in https://developer.android.com/studio/projects/android-library.html#AddDependency

Click File > New > New Module. Click Import .JAR/.AAR Package then click Next. Enter the location of the compiled AAR or JAR file then click Finish.

Please refer the link above for next steps.

---

I found this workaround in the Android issue tracker: https://code.google.com/p/android/issues/detail?id=55863#c21

The trick (not a fix) is to isolating your .aar files into a subproject and adding your libs as artifacts:

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

More info: Handling-transitive-dependencies-for-local-artifacts-jars-and-aar

---

I tried all solution here but none is working, then I realise I made a mistake, I put the .aar in wrong folder, as you can see below, I thought I should put in root folder, so I created a libs folder there (1 in picture), but inside the app folder, there is already a libs, you should put in second libs, hope this help those who has same issue as mine:

https://i.stack.imgur.com/EmYPR.png

---

There is 1 more way to do this.

Usually the .aar file is not supposed to be directly used like we use a .jar and hence the solutions mentioned above to mention it in libs folder and declaring in gradle can be avoided.

Step 1: Unpack the .aar file (You can do this by renaming its extension from ".aar" to ".zip")

Step 2: You will most probably find the .jar file in the folder after extraction. Copy this .jar file and paste it in your module/libs folder

Step 3: That's it, now sync your project and you should be able to access all classes/methods/ properties from that .jar . You don't need to mention about it's path/name/existence in any gradle file, this is because the gradle build system always looks out for files existing in libs folder while building the project

---

Just to simplify the answer

If .aar file is locally present then include
compile project(':project_directory') in dependencies of build.gradle of your project.

If .aar file present at remote then include compile 'com.*********.sdk:project_directory:0.0.1@aar' in dependencies of build.gradle of your project.

---

you can do something like this:

Put your local libraries (with extension: .jar, .aar, ...) into 'libs' Folder (or another if you want). In build.gradle (app level), add this line into dependences implementation fileTree(include: ['*.jar', '*.aar'], dir: 'libs')

---

For me, this was an issue with how Android Studio environment was configured.

When I updated the File -> Project Structure -> JDK Location to a later Java version (jdk1.8.0_192.jdk - for me), everything started working.

---

In my case just work when i add "project" to compile:

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


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

---