How to create a library project in Android Studio and an application project that uses the library project

Question

I wonder why there is no example of stand alone jar project.

In eclipse, we just check "Is Library" box in project setting dialog.
In Android studio, I followed this steps and got a jar file.

1. Create a project.

2. open file in the left project menu.(app/build.gradle): Gradle Scripts > build.gradle(Module: XXX)

3. change one line: apply plugin: 'com.android.application' -> 'apply plugin: com.android.library'

4. remove applicationId in the file: applicationId "com.mycompany.testproject"

5. build project: Build > Rebuild Project

6. then you can get aar file: app > build > outputs > aar folder

7. change aar file extension name into zip

8. unzip, and you can see classes.jar in the folder. rename and use it!

Anyway, I don't know why google makes jar creation so troublesome in android studio.

To create a library:

File > New Module

select Android Library

To use the library add it as a dependancy:

File > Project Structure > Modules > Dependencies

Then add the module (android library) as a module dependency.

Run your project. It will work.

Google’s Gradle Plugin recommended way for configuring your gradle files to build multiple projects has some shortcomings If you have multiple projects depending upon one library project, this post briefly explain Google’s recommended configuration, its shortcomings, and recommend a different way to configure your gradle files to support multi-project setups in Android Studio:

An alternative multiproject setup for android studio

A Different Way :

It turns out there’s a better way to manage multiple projects in Android Studio. The trick is to create separate Android Studio projects for your libraries and to tell gradle that the module for the library that your app depends on is located in the library’s project directory. If you wanted to use this method with the project structure I’ve described above, you would do the following:

1. Create an Android Studio project for the StickyListHeaders library
2. Create an Android Studio project for App2
3. Create an Android Studio project for App1
4. Configure App1 and App2 to build the modules in the StickyListHeaders project.

The 4th step is the hard part, so that’s the only step that I’ll describe in detail. You can reference modules that are external to your project’s directory by adding a project statement in your settings.gradle file and by setting the projectDir property on the ProjectDescriptor object that’s returned by that project statement:

The code one has to put in settings.gradle:

include ':library1'
project(':library1').projectDir = new File('../StickyListHeader/library1')

If you’ve done this correctly, you’ll notice that the modules referenced by your project will show up in the project navigator, even if those modules are external to the project directory:

This allows you to work on library code and app code simultaneously. Version control integration also works just fine when you reference modules externally this way. You can commit and push your modifications to the library code just like you can commit and push modifications to your app code.

This way of setting up multiple projects avoids the difficulties that plague Google’s recommended configuration. Because we are referencing a module that is outside of the project directory we don’t have to make extra copies of the library module for every app that depends on it and we can version our libraries without any sort of git submodule nonsense.

Unfortunately, this other way of setting up multiple projects is very difficult to find. Obviously, its not something you’ll figure out from looking at Google’s guide, and at this point, there’s no way to configure your projects in this way by using the UI of Android Studio.

Check out this link about multi project setups.

Some things to point out, make sure you have your settings.gradle updated to reference both the app and library modules.

settings.gradle: include ':app', ':libraries:lib1', ':libraries:lib2'

Also make sure that the app's build.gradle has the followng:

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

You should have the following structure:

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

The app's build.gradle should use the com.android.application plugin while any libraries' build.gradle should use the com.android.library plugin.

The Android Studio IDE should update if you're able to build from the command line with this setup.

For Intellij IDEA (and Android Studio) each library is a Module. Think of a Module in Android Studio as an equivalent to project in Eclipse. Project in Android Studio is a collection of modules. Modules can be runnable applications or library modules.

So, in order to add a new android library project to you need to create a module of type "Android library". Then add this library module to the dependency list of your main module (Application module).

The simplest way for me to create and reuse a library project:

1. On an opened project file > new > new module (and answer the UI questions)

2. check/or add if in the file settings.gradle: include ':myLibrary'

3. check/or add if in the file build.gradle:

   dependencies { ... compile project(':myLibrary') }

4. To reuse this library module in another project, copy it's folder in the project instead of step 1 and do the steps 2 and 3.

You can also create a new studio application project You can easily change an existing application module to a library module by changing the plugin assignment in the build.gradle file to com.android.library.

apply plugin: 'com.android.application'

android {...}

to

apply plugin: 'com.android.library'

android {...}

more here