How to put my libraries in front of android.jar by editing build.gradle in Android-Studio

Question

First Here's my Java Build Path in Eclipse:

These four jars 'common.jar,core.jar, framework.jar,layout.jar' are packaged from Android source code, which contains some classes that can't be publicly used by developer.They needn't to be exported because they are for cheat compiler. In Eclipse everything is OK.

Now Ｉ'm trying to import my project to Android-Studio with gradle.I've add the jars to dependencies,However I can't change the compile order of my jars and android jar. I can't put these jars in front of android jar.I'm not familiar with gradle, now the compiler can't find classes in these jars. Any help will be appreciated! Here's my build.gradle:

apply plugin: 'android'    
dependencies {

    compile files('jars/common.jar')
    compile files('jars/core.jar')
    compile files('jars/framework.jar')
    compile files('jars/layout.jar')
    compile fileTree(dir: 'libs', include: '*.jar')
    compile files('jars/animation_nineoldandroids_src.jar')
    compile files('jars/json_simple_src.jar')
    compile files('jars/jsoup-1.7.2-sources.jar')
}

android {

    compileSdkVersion 17
    buildToolsVersion "21.1.1"
    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }

        // Move the tests to tests/java, tests/res, etc...
        instrumentTest.setRoot('tests')

        // Move the build types to build-types/<type>
        // For instance, build-types/debug/java, build-types/debug/AndroidManifest.xml, ...
        // This moves them out of them default location under src/<type>/... which would
        // conflict with src/ being used by the main source set.
        // Adding new build types or product flavors should be accompanied
        // by a similar customization.
        debug.setRoot('build-types/debug')
        release.setRoot('build-types/release')
    }
}

Answer 1

You can't do what you want in Gradle(*), at least for the foreseeable future at the time this is written. A few problems are getting in your way:

• Gradle doesn't do ordering of dependencies in the build classpath the way that Eclipse does, which is what you were doing to put your classes ahead of android.jar. Gradle has the philosophy that you should be explicit about dependencies in your build so what's going on is understandable and repeatable; systems that rely on classpath ordering tend to be subtle and fragile. So what you would need to do is to tell Gradle that your project depends on your custom classes and not android.jar, but the plugin's DSL doesn't give you the means to do that. There's some discussion at http://forums.gradle.org/gradle/topics/classpath_ordering_again and http://www.gradle.org/docs/current/userguide/dependency_management.html
• Another way of looking at it is a reference to android.jar is hardcoded into the Android Gradle plugin, so you can't get at that dependency and replace it with something else.

(*) Having said all that, nothing is impossible -- you could make it work, but you're going to have to hack something together, so it's going to be more trouble-prone than the Eclipse approach, and tougher to maintain in the face of SDK and tooling updates. And when something goes wrong you'll be on your own.

• You could assemble your own custom SDK with your own android.jar.
• You could hack the Android Gradle plugin. This approach would definitely be tough -- the learning curve there is pretty steep, and the code is under heavy development, which would be a maintenance burden as you try to stay up-to-date.

I hesitate to offer much more insight into either of those approaches, partly because I don't know a lot about it and could pretty easily give you bad advice, and partly because I don't want inexperienced developers seeing this to think it's an awesome thing to do. But if you figure it out, it would be very much worthy of writing up, because I've seen this sort of question before, so you're not the only one.

Answer 2

Following script works for me:

allprojects {
    gradle.projectsEvaluated {
       tasks.withType(JavaCompile) {
           options.compilerArgs.add('-Xbootclasspath/p:/mylib.jar')
       }
    }
}

Answer 3

I solved the issue from this post to build application with system libraries :

Supposing you have added system libraries like libframework.jar and libcore.jar in app/libs :

• add Xbootclasspath to your top level build.gradle :

  allprojects {
  
      gradle.projectsEvaluated {
          tasks.withType(JavaCompile) {
              options.compilerArgs.add('-Xbootclasspath/p:app/libs/libframework.jar:app/libs/libcore.jar')
          }
      }
  }
  

• in you app build.gradle, use provided :

  dependencies {
      provided fileTree(include: ['*.jar'], dir: 'libs')
  }
  

• in the same app build.gradle, add a task to put <orderEntry> referring to Android API 25 Platform in the last position in app.iml, this way gradle will take into account your system libs first and Android SDK in last resort :

  preBuild {
  
      doLast {
          def imlFile = file(project.name + ".iml")
          println 'Change ' + project.name + '.iml order'
          try {
              def parsedXml = (new XmlParser()).parse(imlFile)
              def jdkNode = parsedXml.component[1].orderEntry.find { it.'@type' == 'jdk' }
              parsedXml.component[1].remove(jdkNode)
              def sdkString = "Android API " + android.compileSdkVersion.substring("android-".length()) + " Platform"
              new Node(parsedXml.component[1], 'orderEntry', ['type': 'jdk', 'jdkName': sdkString, 'jdkType': 'Android SDK'])
              groovy.xml.XmlUtil.serialize(parsedXml, new FileOutputStream(imlFile))
          } catch (FileNotFoundException e) {
              // nop, iml not found
          }
      }
  }
  

Answer 4

You can do this automatically, just like in Eclipse:

File > Project structure... > (select app in Modules) > (go to Dependencies tab) > reposition with arrows on the right

Another way is to edit the [AppName].iml file in the folder your application is in. What you want to change are the tags at the end of the file. However, Android Studio will rearrange those each time you clean or re-open the project.

Answer 5

1. Make dir (ex: exlibs)
2. Copy your jar file to exlibs dir

3. ..

   dependencies {
           provided files("$projectDir/exlibs/yourlib.jar")
   }
   

Answer 6

I use the following scenario, the perfect solution!

1. Add your XXX.jar to Library
2. Then change the "Scope" to "Provided"

3. Find this in your project .gradle:

   allprojects { repositories { jcenter() } }

4. Change it to:

   allprojects { repositories { jcenter() } gradle.projectsEvaluated { tasks.withType(JavaCompile) { options.compilerArgs.add('-Xbootclasspath/p:app\\libs\\XXX.jar') } } }

5. In YourApplicationName.iml file, adjust the XXX.jar to top, like this

so, it's ok!

Answer 7

Update app/app.iml file order as

<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" exported="" name="common" level="project" />
<orderEntry type="library" exported="" name="framework" level="project" />
<orderEntry type="library" exported="" name="layout" level="project" />
<orderEntry type="jdk" jdkName="Android API 21 Platform" jdkType="Android SDK" />

Answer 8

The simplest solution for me was to replace android.jar with one with the hidden API included. Get android.jar from this project library that provides access to Android hidden API and internal resources and place it to your ASDK platforms folder, to the platform you're compiling against (compileSdkVersion).

I'm sure it works with Eclipse as well ))