CODEWITHSUNDEEP
androidandroid-studiogradleandroid-gradle-plugin
WZY
WZY

Reputation: 241

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

First Here's my Java Build Path in Eclipse: enter image description here

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

Upvotes: 14

Views: 17368

Answers (11)

wjploop
wjploop

Reputation: 259

seems the*.impl file path had changed, you need to change

def imlFile = file(project.name + ".iml")

with

def imlFile = file(".." + File.separator + ".idea" + File.separator + "modules" + File.separator + project.name + File.separator + rootProject.name + "." + project.name + ".iml")

Upvotes: 0

Rico
Rico

Reputation: 370

That's really easy! And you DO NOT need to modify build.gradle in your project any more!

Step 1: Backup your original android.jar in Android-SDK directory (e.g. your app compileSdkVersion=30 in build.gradle, and the corresponding path is "~/Library/Android/sdk/platforms/android-30" on the MacOS).

Step 2: Rename your custom framework.jar(*) to "android.jar" and copy it to your Android-SDK directory, against the original one.

Step 3: Sync gradle if needed, then you can use the @hide function what you want without red error reported.

(*) If you would not like to take your time to clone AOSP and compile it, you'd better download it on Github: https://github.com/anggrayudi/android-hidden-api

Good luck~

Upvotes: 0

Oliver Scott
Oliver Scott

Reputation: 61

A updated and somewhat more future-proof answer (since bootclasspath compilerargs have been changing in more recent JDKs):

  • Supposing you have taken system libraries like framework.jar and libcore.jar from aosp intermediates (generated when building aosp) and added them into a folder (such as system_libs) in your project, add the libraries to the compile classpath in build.gradle:
dependencies {
    compileOnly fileTree(dir: 'system_libs', include: ['*.jar'])
}

gradle.projectsEvaluated {
    tasks.withType(JavaCompile) {
        options.bootstrapClasspath = files(
            new File("./system_libs/framework.jar").path,
            new File("./system_libs/libcore.jar").path
        )
    }
}

  • Add a task to put referring to the Android API Platform in the last position in app.iml, this way gradle will take into account your system libs first and Android SDK last:

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

Based on @Bertrand's answer

Upvotes: 4

Bertrand Martel
Bertrand Martel

Reputation: 45352

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

Upvotes: 10

Mixaz
Mixaz

Reputation: 4178

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

Upvotes: 0

Lava Sangeetham
Lava Sangeetham

Reputation: 3281

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" />

Upvotes: 0

Hryg
Hryg

Reputation: 1

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!

Upvotes: 0

McKendo
McKendo

Reputation: 26

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

  3. ..

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

Upvotes: 0

Jason Zhao
Jason Zhao

Reputation: 111

Following script works for me:

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

Upvotes: 11

Scott Barta
Scott Barta

Reputation: 80010

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.

Upvotes: 12

Kelevandos
Kelevandos

Reputation: 7082

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.

Upvotes: 0

Related Questions