Introduction

This warning appears in Android Gradle Plugin projects that interact with native CMake or ndk-build tasks through the old Variant API. The short version is that variant.getExternalNativeBuildTasks() eagerly realizes tasks, while variant.getExternalNativeBuildProviders() returns TaskProvider objects that fit Gradle's lazy configuration model.

Why the API Changed

Modern Gradle plugins try to avoid configuring every task up front. Eager task access slows configuration, makes builds harder to optimize, and conflicts with configuration avoidance. That is why AGP gradually replaced task-returning APIs with provider-returning APIs.

The old pattern gives you actual task instances immediately:

1android.applicationVariants.all { variant ->
2    variant.getExternalNativeBuildTasks().each { task ->
3        task.doLast {
4            println("Finished native build for ${variant.name}")
5        }
6    }
7}

The new pattern gives you providers, which you configure lazily:

1android.applicationVariants.all { variant ->
2    variant.getExternalNativeBuildProviders().each { provider ->
3        provider.configure { task ->
4            task.doLast {
5                println("Finished native build for ${variant.name}")
6            }
7        }
8    }
9}

That small change matters because the provider version lets Gradle postpone task realization until it is actually needed.

What a TaskProvider Buys You

A TaskProvider is not just indirection for its own sake. It allows Gradle to wire dependencies and configuration without forcing every task to exist immediately. In large Android projects, that improves configuration time and reduces the amount of work done for builds that do not even touch native code.

So the migration is not cosmetic. It is part of the same broader shift behind APIs such as tasks.register(...) replacing tasks.create(...).

Kotlin DSL Example

If you are writing plugin logic in Kotlin DSL or inside a custom Gradle plugin, the same rule applies:

1android.applicationVariants.all { variant ->
2    variant.externalNativeBuildProviders.forEach { provider ->
3        provider.configure {
4            doLast {
5                println("Finished native build for ${variant.name}")
6            }
7        }
8    }
9}

The important point is that you configure the provider instead of calling .get() too early. Calling .get() immediately defeats most of the benefit and can bring the eager behavior back.

When the Warning Is Not Your Fault

Sometimes you see this warning even though your own build script never calls getExternalNativeBuildTasks(). In that case, the source can be:

• a third-party Gradle plugin
• older build logic in buildSrc
• legacy Groovy script fragments copied from an old project

That is why the fix is not always in the line Gradle highlights. Search your build logic for the deprecated method name. If it is not present, a plugin dependency may be the actual caller.

Consider the Newer Android Components APIs

If you are doing deeper AGP customization, the long-term direction is the newer androidComponents APIs rather than adding more logic to the old variant collections. You do not need to rewrite everything at once just to remove this warning, but it is worth recognizing that provider-based task access is part of a larger migration path in AGP.

For a narrow fix, replacing task instances with providers is enough. For broader modernization, move variant logic toward the current component APIs when practical.

Common Pitfalls

• Replacing the method name but then calling .get() immediately, which restores eager task realization.
• Assuming the warning comes from the shown build file when it may come from a plugin.
• Mixing old Variant API patterns with new Gradle task-registration patterns inconsistently.
• Treating the deprecation as harmless forever instead of updating build logic while the migration is still small.
• Forgetting that projects without native builds may return an empty provider collection.

Summary

• 'getExternalNativeBuildTasks() is deprecated because it eagerly realizes tasks.'
• 'getExternalNativeBuildProviders() aligns with Gradle's lazy configuration model.'
• Configure the returned TaskProvider objects instead of forcing them immediately.
• If you do not call the old method yourself, a plugin or shared build script may be responsible.
• Provider-based task access is part of the larger AGP move toward modern Gradle APIs.