Transitive dependencies not resolved for aar library using gradle

Question 1

I have solved my problem by setting transitive attribute for my aar dependency:

compile ('com.somepackage:LIBRARY_NAME:1.0.0@aar'){
    transitive=true
}

Question 2

you should not use "@aar", if use "@" is become "Artifact only notation", if you want to use "@" and want have dependence transitive, you should add "transitive=true"

Question 3

Try this if you are using aar locally:

compile(project(:your-library-name)) {
    transitive=true
}

Question 4

I was having a similar problem and felt I could share the steps of solving the problem.

The basic idea of not being able to use the transitive dependencies while you are publishing your own aar is actually not having the .pom file generated with the expected transitive dependencies.

I was using 'maven-publish' plugin for my android aar dependency to publish it in my own private maven repository. The transitive dependencies were not resolved when my other projects were adding my aar dependency in their build.gradle. Hence here what I did to modify the .pom file while publishing my aar.

An important thing to note here that, the dependencies which you want to have the transitive behavior should be imported using the api in your library project's build.gradle file like the following.

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    api 'com.android.volley:volley:1.0.0'
    api "com.google.code.gson:gson:$globalGsonVersion"
}

Now as I said earlier, I was using maven-publish plugin to publish the aar dependency and hence my publishing task in the gradle looks like the following.

publishing {
    publications {
        mavenAar(MavenPublication) {
            from components.android
        }

        mavenJava(MavenPublication) {
            pom.withXml {
                def dependenciesNode = asNode().appendNode('dependencies')
                // Iterate over the api dependencies (we don't want the test ones), adding a <dependency> node for each
                configurations.api.allDependencies.each {
                    def dependencyNode = dependenciesNode.appendNode('dependency')
                    dependencyNode.appendNode('groupId', it.group)
                    dependencyNode.appendNode('artifactId', it.name)
                    dependencyNode.appendNode('version', it.version)
                }
            }
        }
    }

    repositories {
        maven {
            // Your repository information goes here
        }
    }
}

Hence, I used another mavenJava task to publish the .pom file in my private maven repo so that when the aar file is added as a dependency to some other module, it gets the .pom information and download the transitive dependency.

To complete the answer, this is how you should add the dependency in the build.gradle file for your own published aar to me imported.

api('com.example.masudias:my_lib:1.0.0@aar') {
    transitive = true
}

Question 5

Transitive dependency

transitive means that the consumer(e.g. app) includes a producer and all producer's dependencies(e.g. libraries). It increase build time and can create some issues with dependency versions

By default, Gradle dependency has transitive = true

api ('com.package:library:0.0.1')
//the same
api ('com.package:library:0.0.1') {
    transitive = true
}

When you use @artifact notation it has transitive = false

api ('com.package:library:0.0.1@aar')
//the same
api ('com.package:library:0.0.1@aar') {
    transitive = false
}

Question 6

For me complete publishing solution looks like this:


apply plugin: 'com.github.dcendents.android-maven'

group = GROUP
version = VERSION

// you could move it to env variable or property
def publishFlavorless = true
def firstTask = null

android.libraryVariants.all { variant ->

    if (variant.name.toLowerCase().contains("debug")) {
        // Workaround for https://github.com/gradle/gradle/issues/1487
        if (publishFlavorless && firstTask == null) {
            def bundleTask = tasks["bundle${variant.name.capitalize()}Aar"]
            firstTask = bundleTask
            artifacts {
                archives(firstTask.archivePath) {
                    builtBy firstTask
                    name = project.name
                }
            }
        }
        return
    }

    def bundleTask = tasks["bundle${variant.name.capitalize()}Aar"]

    artifacts {
        archives(bundleTask.archivePath) {
            classifier variant.flavorName
            builtBy bundleTask
            name = project.name
        }
    }
}

install {
    repositories.mavenInstaller {
        // This generates POM.xml with proper parameters
        pom.project {
            name POM_NAME
            artifactId POM_ARTIFACT_ID
            // For aar it is equal to 'aar' with jar transitive dependencies won't work
            packaging POM_PACKAGING
            description POM_DESCRIPTION
        }
    }
}

The transitive = true block is required as well ...

Question 7

AAR file doesn't contain transitive dependencies. So even if use api instead of implementation it wont work.

In our team we had developed a library to use in our applications and we wanted it to be for internal use only. Earlier we used to include whole module that seems to work. Later we decided to move to aar file but we were also facing same issue of classpath not found. After some research we came to know that we can also use local maven repo. We decided to use that.

Here is step by step process

Publishing repo

1.In your Library's root build.gradle file you need to include

id 'com.github.dcendents.android-maven' version '2.0' apply false

2.In you library's module level build.gradle file you need to add

a) In plugins

id 'maven-publish'

b) At bottom of gradle file add

publishing {
    publications {
        release(MavenPublication) {
            groupId = 'com.demo.android'
            artifactId = 'qrcodescanner'
            version = '1.0.0'

            afterEvaluate {
                from components.release
            }
        }
    }
    repositories {
        maven {
            name = "qrcodescanner"
            url = "${project.buildDir}/repo"

        }
    }
}

3.Depends on the name you have given a gradle tasks will be generated you can check using gradlew tasks or by using gradle window at top right corner in android studio, Our was

publishReleasePublicationToQrcodescannerRepository

4.Run it and repo will be generated in given path

gradlew publishReleasePublicationToQrcodescannerRepository

Final step you need to publish it to maven local using

gradlew publishToMavenLocal

if it doesn't work you can try gradlew clean and gradlew build before executing it.

Using local repo

1.You need to add mavenLocal() in root level build.gradle file of your project you wanted to use it in like this before other central repos

allprojects {
    repositories {
        mavenLocal()
        google()
        jcenter()
        maven { url "https://jitpack.io" }
        mavenCentral()
    }
}

Now you need to include your dependency in the project like we do with other dependencies as well

implementation 'com.demo.android:qrcodescanner:1.0.0' keep in mind format should groupdId:artifactId:version

That's it.

References :

Publish Library

Local Maven

Question 8

Simply adding @aar at the end of the dependency is what worked for me.

dependencies {
    implementation 'org.videolan.vlc:libvlc:3.0.13@aar'
}