AGP9: afterEvaluate { apollo {...} } causing `Unable to load class 'com.android.Version' com.android.Version`

[NickMelnykIronvest]

Version

4.4.1 - 5.0.0-alpha.4

Summary

after updating to AGP9
(built-in kotlin=true AND newDsl=true)
afterEvaluate causing Unable to load class 'com.android.Version' com.android.Version error for apollo { service ... } block

I want to highlight that outside afterEvaluate (or other gradle late lifecycle callbacks) apollo { ... } works without this error. Tested on 4.4.1 and above up to 5.0.0-alpha.4

In my case afterEvaluate is required to gather apollo-related project dependencies (dependOn(...)) for graphql convention plugin to automatically register dependsOn

Before AGP9 apollo is working inside afterEvaluate block
I presume it is due to kotlin jvm module no longer can access android.Version

UPDATE:
I was also trying to substitute contextClassLoader to allows to fetch android.Version.
But it still result in other APG9 related errors.

TEMP WORKAROUND
My apollo convention plugin declared apollo block.
afterEvaluate was needed to get resolved child apollo-related project dependencies block from consumer module, whuch were added as dependsOn(...)

So to mitigate these errors I had to apply my convention plugin as last entry in consumer module's build.gradle.kts (after dependencies block) so when apollo is evaluated dependencies are already known.
was at top plugins {... alias("my-plugin")}; became: at bottom apply(plugin = "my-plugin")
additionally at a top I have to declare another convention plugin with extension to manually configure module that should be treated as dependOn because withPlugin("com.apollographql.apollo") somehow not resolved for every project(dep.path)

Steps to reproduce the behavior

No response

Logs

Unable to load class 'com.android.Version'
com.android.Version

[martinbonnin]

Thanks for sending this! I'm guessing this is the same issue as #6874.

I'm still a bit unsure how come this is happening though. What version of AGP are you using?

[NickMelnykIronvest]

@martinbonnin I've mentioned AGP in the issue description: AGP9. specifically 9.0.1
!!! newDsl=true
!!! buildInKotlin=true

BTW current workaround ( a bit clumpsy):

plugins {
    alias(libs.plugins.convention.kotlin.base.module)
    alias(libs.plugins.convention.graphqlConfig) // part of workaround, declares `apolloServiceConfig` extension
    //alias(libs.plugins.convention.graphql) // works before AGP9: automatically adds dependencies, no `apolloServiceConfig` extension required, i.e. internally configures apollo related project dependencies
}

// part of workaround
apolloServiceConfig {
    dependsOn(projects.dataFeatureB.net)
    dependsOn(projects.commonFeatureAData.net)
}

dependencies {
    api(projects.commonDataSourceNet) // not apollo related
    api(projects.dataFeatureB.net) // apollo related, thus manually added above in apolloServiceConfig
    api(projects.commonFeatureAData.net) // apollo related, thus manually added above in apolloServiceConfig
}

// workaround for AGP9. Previously afterEvaluate { apollo { ... }} was used, but no longer works
// module with child project apollo dependencies must be declared after dependencies block
// to mitigate afterEvaluate.
apply(plugin = libs.plugins.convention.graphql.get().pluginId)

where libs.plugins.convention.graphql:

plugins {
    id("com.apollographql.apollo")
}

dependencies {
    api(project(":network-schema"))
}

apollo {
    service("service") {
        srcDir("src/main/graphql")
        packageName.set("mypackage.network.schema")
        generateApolloMetadata.set(true)

        // 1. Add `:network-schema` as it is declared as dependency above
        dependsOn(project(":network-schema"))

        // 2. For `:net:impl` modules automatically add its abstraction (my project specifics)
        if (project.path.endsWith(":net:impl")) {
            dependsOn(project(project.path.removeSuffix(":impl")))
        }

        // 3. Resolve apollo related consumer's module project dependencies
        extensions
            .findByType<ApolloServiceConfigExtension>()
            ?.dependsOn
            ?.get()
            ?.map { project(it.path) }
            ?.forEach(::dependsOn)
    }
}

where libs.plugins.convention.graphqlConfig:

import extension.ApolloServiceConfigExtension

plugins {
    id("com.apollographql.apollo")
}

project.extensions.create<ApolloServiceConfigExtension>("apolloServiceConfig", objects)

where ApolloServiceConfigExtension:

abstract class ApolloServiceConfigExtension(objects: ObjectFactory) {
    val dependsOn: ListProperty<ProjectDependency> =
        objects.listProperty(ProjectDependency::class.java)

    fun dependsOn(dependency: ProjectDependency) {
        dependsOn.add(dependency)
    }
}

!!!
So as feature request for multi module project please try to configure apollo in a way it automatically configured once all consumer module dependencies are resolved*. Once resolved check app project dependencies that has plugin "com.apollographql.apollo" and automatically add them as dependsOn. Or at least create an option inside service, e.g resolveApolloProjectsDependecies = true/false
*-this is problematic place, because afterEvaluate causing current issues.

!!!!
BTW, additionally to android.Version problem which can be solved with hack by substituting contextClassLoader inside afterEvaluate{...}
there is another issue caused inside afterEvaluate block:

Caused by: java.lang.RuntimeException: It is too late to add actions as the callbacks already executed.
Did you try to call onVariants from the old variant API
'applicationVariants' for instance? You can instead call onVariants
directly from the androidComponents DSL block.
	at com.android.build.api.extension.impl.OperationsRegistrar.addPublicOperation(OperationsRegistrar.kt:54)
	at com.android.build.api.extension.impl.AndroidComponentsExtensionImpl.onVariants(AndroidComponentsExtensionImpl.kt:83)
	at com.apollographql.apollo.gradle.Agp9.onComponent(Agp9.kt:71)
	at com.apollographql.apollo.gradle.internal.DefaultDirectoryConnection.connectToAndroidVariants(DefaultDirectoryConnection.kt:65)
	at com.apollographql.apollo.gradle.internal.DefaultApolloExtension.defaultOutputDirAction$lambda$0(DefaultApolloExtension.kt:829)
	at com.apollographql.apollo.gradle.internal.DefaultApolloExtension.registerService(DefaultApolloExtension.kt:786)
	at com.apollographql.apollo.gradle.internal.DefaultApolloExtension.service(DefaultApolloExtension.kt:308)
	at Graphql_convention_gradle$4$1.execute(graphql-convention.gradle.kts:42)

[NickMelnykIronvest]

Thanks for sending this! I'm guessing this is the same issue as #6874.

I'm still a bit unsure how come this is happening though. What version of AGP are you using?

#6876 (comment)

[martinbonnin]

Thanks for all the details. I'll try to reproduce from there and post an update. If you had a reproducer on your end, that'll save some time.

[martinbonnin]

I'm suspecting this has to do with some Gradle classloader magic. Do you have both Android Gradle Plugin and Apollo Gradle Plugin in your build-logic/build.gradle.kts file?

dependencies {
  implementation("com.apollographql.apollo:apollo-gradle-plugin:5.0.0-alpha.4")
  implementation("com.android.tools.build:gradle:9.0.1")
}

[martinbonnin]

I can reproduce there: https://github.com/martinbonnin/reproducers/tree/main/android-version

[martinbonnin]

Fix for the com.android.Version issue is there: #6877

Regarding afterEvaluate {}, you should try to avoid it as much as possible. For AGP, you can try using finalizeDsl instead. But I would try to avoid that as well.

If that's any easier, you can register your the apollo dependencies using the standards Gradle dependencies:

apollo {
    service("foo") {
        packageName.set("com.example")
        generateApolloMetadata.set(true)
    }
}

dependencies {
    add("apolloFoo", projects.dataFeatureB.net)
}

There should generally be no need for afterEvaluate {}

If you don't control where the apollo {} block is called (but you should), you can always do something like this:

configurations.configureEach {
  if (name == "apolloFoo") {
    dependencies.add(projects.dataFeatureB.net)
  }
}

Hope this helps!

[NickMelnykIronvest]

I'm suspecting this has to do with some Gradle classloader magic. Do you have both Android Gradle Plugin and Apollo Gradle Plugin in your build-logic/build.gradle.kts file?

dependencies {
implementation("com.apollographql.apollo:apollo-gradle-plugin:5.0.0-alpha.4")
implementation("com.android.tools.build:gradle:9.0.1")
}

Yes

libs.versions.toml

conventionPluginDependencies = [
    "android-gradle-plugin",
    "apollo-graphql-gradle-plugin",
    ... // others
]

[NickMelnykIronvest]

Fix for the com.android.Version issue is there: #6877

Regarding afterEvaluate {}, you should try to avoid it as much as possible. For AGP, you can try using finalizeDsl instead. But I would try to avoid that as well.

If that's any easier, you can register your the apollo dependencies using the standards Gradle dependencies:

apollo {
service("foo") {
packageName.set("com.example")
generateApolloMetadata.set(true)
}
}

dependencies {
add("apolloFoo", projects.dataFeatureB.net)
}
There should generally be no need for afterEvaluate {}

If you don't control where the apollo {} block is called (but you should), you can always do something like this:

configurations.configureEach {
if (name == "apolloFoo") {
dependencies.add(projects.dataFeatureB.net)
}
}
Hope this helps!

yes, I have constant name for service, the apolloFoo should do the tricj

[NickMelnykIronvest]

Fix for the com.android.Version issue is there: #6877

Regarding afterEvaluate {}, you should try to avoid it as much as possible. For AGP, you can try using finalizeDsl instead. But I would try to avoid that as well.

If that's any easier, you can register your the apollo dependencies using the standards Gradle dependencies:

apollo {
service("foo") {
packageName.set("com.example")
generateApolloMetadata.set(true)
}
}

dependencies {
add("apolloFoo", projects.dataFeatureB.net)
}
There should generally be no need for afterEvaluate {}

If you don't control where the apollo {} block is called (but you should), you can always do something like this:

configurations.configureEach {
if (name == "apolloFoo") {
dependencies.add(projects.dataFeatureB.net)
}
}
Hope this helps!

My only question is: why this is not specified anywhere in documentation somewhere in advanced or multi-module project sections?
Previously in apollo3 there were smth like apolloMetadata(...)
So please consider adding this recipe (add("apolloFoo", projectDep) it in documentation

[martinbonnin]

Will do!

[martinbonnin]

@NickMelnykIronvest I've updated the docs in #6879.

Unless there's anything else you want me to dive into, I'll close this issue.