I have a sample project, with the following setup:

  + Pure Java Lib
  + Android Test Lib
  + Android Test Project

Where the 'Test Project' is dependent on the 'Test Lib', and the last depends on the 'Pure Java Lib' Compiling the project and launching this setup works just fine.

I'm now thinking about importing my previous Eclipse workspace and work with Android studio, the problem is the project setup is different, and I would like to keep it this way.

for example if to use the previous example:

  + Android Test Lib
  + Android Test Project

/Some Other folder (another repository for example)
  + Pure Java Lib

I've tried many configurations, but I didn't find a way to reference a project outside the scope of the parent folder ('root' in the example case).

In many platforms/modules you can use the '..' to move up in the folders but this didn't work for me, perhaps I've used it wrong.

Does anyone know how this can be achieved with Gradle?


I'll try to be more generic:


  /Project A
    + Module 1 - Pure Java
    + Module 2 - Android Test Lib
    + Module 3 - Android Test Project

  /Project B
    + Module 1 - Pure Java
    + Module 2 - Pure Java
    + Module 3 - Pure Java

I would like to use Module 1 of project B, in project A.

UPDATE: 09-03-19

I saw this now and I must update... after almost 6 years, today I am wiser, and I can definitely say the problem was me misunderstanding the concept of "Source of truth".

While having one ref to a library is a nice to have concept.. and may seem like the a "Source of truth", the REAL "Source of truth" would be the version of the code each project is using of that library, cause the library by itself has versions.. many versions an the "Source of truth" is relative to the project which is using the library.

The correct way would be to use what most developers do not like, and that is git submodules, and yes duplicate the sources in each project cause most chances each project uses a different version of the code.

You would need however to aim for all of your projects to use the latest and greatest version of all your libraries.. which is a challenge by itself

The reason this is the right way to develop a project with library sources is that this scales... you can have hundreds of project each with its own library configuration.

Solution 1

Assuming that Some Other Folder is a gradle project you could add something like the following to your settings.gradle file:

include ':module1'
project(':module1').projectDir = new File(settingsDir, '../Project B/Module 1')

Solution 2

You have to put in your file settings.gradle this lines:

include ':module2'
project(':module2').projectDir = new File(settingsDir, '../Project 2/Module2')

Then you have to add in your builde.gradle (Module: app) in the dependencies tree, this line:

implementation project(':module2')

or go into the Project Structure > app > Dependencies, click on Add, choose 3 Module Dependencies and select your module

Solution 3

With Gradle 1.10 (don't know what other versions this will be valid for) this is what I came up with based on a response given here

I have an api library project, a common library project and the main app project. Each is a stand-alone development project and the two libraries are meant to be shared between multiple apps.

In settings.gradle for the common project:

def apiLibDir = file('../android-api/android-api-lib')
def rootProjectDescriptor = settings.rootProject
settings.createProjectDescriptor(rootProjectDescriptor, 'android-api-lib', apiLibDir)
include ':android-api-lib'

Then in the main app project settings.gradle:

def apiLibDir = file('../android-libs/android-api/android-api-lib')
def rootProjectDescriptor = settings.rootProject
settings.createProjectDescriptor(rootProjectDescriptor, 'android-api-lib', apiLibDir)
include ':android-api-lib'

def commonLibDir = file('../android-libs/android-common/android-common-lib')
settings.createProjectDescriptor(rootProjectDescriptor, 'android-common-lib', commonLibDir)
include ':android-common-lib'

In each of the respective build.gradle files you just reference them by the name you gave them in the settings.createProjectDescriptor like you would any other project dependancy:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile project(':android-api-lib')
    compile project(':android-common-lib')

This seems to work. It didn't even throw an error for multiple DEX files defining the api library, I suspect because it was all part of the same build process and Gradle was smart enough to figure it all out.

Solution 4

Right click on project - Select "Open Module Settings" - Select "Modules" in left pane - Click on "+" symbol on top - Choose "Import Module".

After importing Module. You need to add it as a dependency for your current project.

Keep "Modules" Selected in left pane and click on your project - Now Go in dependencies tab and click on "+" symbol that is located at bottom - Choose third option "Module Dependencies" and if you have imported your project correctly, it will show you the all available module that can be added as a dependency to your current project.

Solution 5

I re-ask this question in a way which entails the original posters' intentions at How do we reference custom Android and Java Libraries living outside the directory of our Main Android Project?

There I answer my own question. At core my answer uses @Ethan's (the author of the chosen answer in the current thread) gradle coding insight. But my answer also navigates some other gotchas and provides a detailed step by step example.

Solution 6

As Ethan said, if you add this to your settings.gradle, it will add an external project to Android Studio (in this example, it's in the parent folder):


Then, to add it as a dependency of one of your projects, just add it in the build.gradle of that project as another dependency like this (you can also do it graphically as in here):

compile project(':../ProjectB/:module1')