Update for Android Studio 1.0

Since Android Studio 1.0 was released (and a lot of versions between v1.0 and one of the firsts from the time of my previous answer) some things has changed.

My description is focused on adding external library project by hand via Gradle files (for better understanding the process). If you want to add a library via Android Studio creator just check the answer below with visual guide (there are some differences between Android Studio 1.0 and those from screenshots, but the process is very similar).

Before you start adding a library to your project by hand, consider adding the external dependency. It won’t mess in your project structure. Almost every well-known Android library is available in a Maven repository and its installation takes only one line of code in the app/build.gradle file:

dependencies {
     compile 'com.jakewharton:butterknife:6.0.0'
}

Adding the library

Here is the full process of adding external Android library to our project:

1. Create a new project via Android Studio creator. I named it HelloWorld.
2. Here is the original project structure created by Android Studio:

HelloWorld/
      app/
           - build.gradle  // local Gradle configuration (for app only)
           ...
      - build.gradle // Global Gradle configuration (for whole project)
      - settings.gradle
      - gradle.properties
      ...

3. In the root directory (HelloWorld/), create new folder: /libs in which we’ll place our external libraries (this step is not required - only for keeping a cleaner project structure).
4. Paste your library in the newly created /libs folder. In this example I used PagerSlidingTabStrip library (just download ZIP from GitHub, rename library directory to „PagerSlidingTabStrip" and copy it). Here is the new structure of our project:

HelloWorld/
      app/
           - build.gradle  // Local Gradle configuration (for app only)
           ...
      libs/
           PagerSlidingTabStrip/
                - build.gradle // Local Gradle configuration (for library only)
      - build.gradle // Global Gradle configuration (for whole project)
      - settings.gradle
      - gradle.properties
      ...

5. Edit settings.gradle by adding your library to include. If you use a custom path like I did, you have also to define the project directory for our library. A whole settings.gradle should look like below:

   include ':app', ':PagerSlidingTabStrip'
   project(':PagerSlidingTabStrip').projectDir = new File('libs/PagerSlidingTabStrip')
   

5.1 If you face "Default Configuration" error, then try this instead of step 5,

    include ':app'
    include ':libs:PagerSlidingTabStrip'

6. In app/build.gradle add our library project as an dependency:

   dependencies {
       compile fileTree(dir: 'libs', include: ['*.jar'])
       compile 'com.android.support:appcompat-v7:21.0.3'
       compile project(":PagerSlidingTabStrip")
   }
   

6.1. If you followed step 5.1, then follow this instead of 6,

    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
        compile 'com.android.support:appcompat-v7:21.0.3'

        compile project(":libs:PagerSlidingTabStrip")
    }

7. If your library project doesn’t have build.gradle file you have to create it manually. Here is example of that file:

       apply plugin: 'com.android.library'
   
       dependencies {
           compile 'com.android.support:support-v4:21.0.3'
       }
   
       android {
           compileSdkVersion 21
           buildToolsVersion "21.1.2"
   
           defaultConfig {
               minSdkVersion 14
               targetSdkVersion 21
           }
   
           sourceSets {
               main {
                   manifest.srcFile 'AndroidManifest.xml'
                   java.srcDirs = ['src']
                   res.srcDirs = ['res']
               }
           }
       }
   

8. Additionally you can create a global configuration for your project which will contain SDK versions and build tools version for every module to keep consistency. Just edit gradle.properties file and add lines:

   ANDROID_BUILD_MIN_SDK_VERSION=14
   ANDROID_BUILD_TARGET_SDK_VERSION=21
   ANDROID_BUILD_TOOLS_VERSION=21.1.3
   ANDROID_BUILD_SDK_VERSION=21
   

   Now you can use it in your build.gradle files (in app and libraries modules) like below:

   //...
   android {
       compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION)
       buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION
   
       defaultConfig {
           minSdkVersion Integer.parseInt(project.ANDROID_BUILD_MIN_SDK_VERSION)
           targetSdkVersion Integer.parseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION)
       }
   }
   //...
   

9. That’s all. Just click‚ synchronise the project with the Gradle’ icon . Your library should be available in your project.

Google I/O 2013 - The New Android SDK Build System is a great presentation about building Android apps with Gradle Build System: As Xavier Ducrohet said:

Android Studio is all about editing, and debugging and profiling. It's not about building any more.

At the beginning it may be little bit confusing (especially for those, who works with Eclipse and have never seen the ant - like me ;) ), but at the end Gradle gives us some great opportunities and it worth to learn this build system.

Here is the visual guide:

Update for Android Studio 0.8.2:

In Android Studio 0.8.2, go to Project Structure -> under Modules just hit the plus button and select Import Existing Project and import actionbarsherlock. Then synchronise your Gradle files.

If you face the error

Error: The SDK Build Tools revision (xx.x.x) is too low. Minimum required is yy.y.y

just open the build.gradle file in actionbarsherlock directory and update the buildToolsVersion to the suggested one.

android {
  compileSdkVersion 19
  buildToolsVersion 'yy.y.y'

Menu File -> Project Structure...:

Module -> Import Module

After importing the library module, select your project module and add the dependency:

And then select the imported module:

Use menu File -> Project Structure -> Modules.

I started using it today. It is a bit different.

For Sherlock, maybe you want to delete their test directory, or add the junit.jar file to the classpath.

To import the library using gradle, you can have to add it to the dependencies section of your build.gradle (the module's one).

E.g.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.1.0'
    compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
}

Android Studio is changing.

There exist a section named "Open module settings" if you right-click on a module folder in the project section of Android Studio (I'm using the version 0.2.10).

I have just found an easier way (rather than writing directly into the .gradle files).

This is for Android Studio 1.1.0.

1. Menu File -> New Module...:

   

   Click on "Import Existing Project".

2. Select the desired library and the desired module.

3. Click finish. Android Studio will import the library into your project. It will sync gradle files.

4. Add the imported module to your project's dependencies.

   Right click on the app folder -> Open Module settings -> go to the dependencies tab -> Click on the '+' button -> click on Module Dependency.

   The library module will be then added to the project's dependencies.

   

5. ???

6. Profit

You can do this easily. Go to menu File -> New -> Import Module...:

Browse for the directory which contains the module. Click Finish:

Go to Project Structure and add Module Dependency:

Note: If you receive an SDK error, update that one.

Editing library dependencies through the GUI is not advisable as that doesn't write those changes to your build.gradle file. So your project will not build from the command-line. We should edit the build.gradle file directly as follows.

For instance, given to following structure:

MyProject/

• app/
• libraries/
  • lib1/
  • lib2/

We can identify three projects. Gradle will reference them with the following names:

1. :app
2. :libraries:lib1
3. :libraries:lib2

The :app project is likely to depend on the libraries, and this is done by declaring the following dependencies:

dependencies {
    compile project(':libraries:lib1')
}

Android Studio 3.0

Just add the library name to the dependencies block of your app's build.gradle file.

dependencies {
    // ...
    implementation 'com.example:some-library:1.0.0'
}

Note that you should use implementation rather than compile now. This is new with Android Studio 3.0. See this Q&A for an explanation of the difference.

Open the build gradle module app file and add your dependency. If you download the library, just import and build as gradle.

Otherwise add repositories in side gradle module app:

repositories {
        maven { url 'http://clinker.47deg.com/nexus/content/groups/public' }
}

The first repositories will download the library for you.

And compile the downloaded library:

 compile ('com.fortysevendeg.swipelistview:swipelistview:1.0-SNAPSHOT@aar') {
        transitive = true
    }

If you are creating a library, you just need to import the project as import new module.

For Android Studio:

Click on Build.gradle (module: app).

And add for

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile files('libs/commons-io-2.4.jar')
}

and in your directory "app", create a directory, "libs". Add the file yourfile.jar:

Finally, compile the Gradle Files:

I would consider Dependencies, Android Libraries and Multi-project setup necessary reading. Please take a few minutes to do so.

Particularly, in the case of a non-jar library project, read the following snippet from above source:

Gradle projects can also depend on other gradle projects by using a multi-project setup. A multi-project setup usually works by having all the projects as sub folders of a given root project.

For instance, given to following structure:

MyProject/
 + app/
 + libraries/
    + lib1/
    + lib2/

We can identify 3 projects. Gradle will reference them with the following name:

:app
:libraries:lib1
:libraries:lib2

Each projects will have its own build.gradle declaring how it gets built. Additionally, there will be a file called settings.gradle at the root declaring the projects. This gives the following structure:

MyProject/
 | settings.gradle
 + app/
    | build.gradle
 + libraries/
    + lib1/
       | build.gradle
    + lib2/
       | build.gradle

The content of settings.gradle is very simple:

include ':app', ':libraries:lib1', ':libraries:lib2'

This defines which folder is actually a Gradle project.

The :app project is likely to depend on the libraries, and this is done by declaring the following dependencies:

dependencies {
    compile project(':libraries:lib1')
}

Kindly note that there was little or no use of Android Studio GUI to make this happen.

I am currently using git submodules to link the nested library to the actual library git repo to avoid a dependency mess.