[sign_in_with_apple] Android build.gradle uses legacy DSL — blocks AGP 9 `builtInKotlin` / `newDsl`

[qeepcologne]

Summary

sign_in_with_apple's android/build.gradle still uses the pre-AGP-9 DSL, forcing every consumer on AGP 9 to keep both compatibility flags set:

• android.builtInKotlin=false — because the plugin applies kotlin-android itself, which conflicts with AGP 9's built-in Kotlin support.
• android.newDsl=false — because compileSdkVersion / minSdkVersion / script-style apply plugin: are old DSL.

Both flags are scheduled for removal in a future AGP release (DSL/API migration timeline), so plugin consumers can't move forward until this is fixed.

Environment

• sign_in_with_apple: 8.0.0-spm.1 (current android/build.gradle on master is unchanged too)
• AGP 9.1.1, Gradle 9.5.0-rc-2, Flutter 3.41.6, JDK 21

Current android/build.gradle (excerpt)

Problematic lines marked // <-- ...:

buildscript {
    ext.kotlin_version = '1.7.10'
    dependencies {
        classpath 'com.android.tools.build:gradle:7.4.2'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'                          // <-- blocks android.builtInKotlin=true

android {
    compileSdkVersion 34                                // <-- blocks android.newDsl=true (use `compileSdk`)
    if (project.android.hasProperty("namespace")) {
        namespace 'com.aboutyou.dart_packages.sign_in_with_apple'
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions { jvmTarget = '1.8' }
    sourceSets { main.java.srcDirs += 'src/main/kotlin' }
    defaultConfig {
        minSdkVersion 16                                // <-- blocks android.newDsl=true (use `minSdk`)
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    lint { disable 'InvalidPackage' }
}

Suggested fix — backward-compatible conditional migration

Keeps AGP 7/8 working while letting AGP 9 users drop both compat flags. compileSdk / minSdk (without the Version suffix) work from AGP 7+, so the DSL change is safe. The kotlin-android plugin is only applied when AGP isn't providing Kotlin itself.

group 'com.aboutyou.dart_packages.sign_in_with_apple'
version '1.0-SNAPSHOT'

buildscript {
    ext.kotlin_version = '1.9.0'
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:7.4.2'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

rootProject.allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

apply plugin: 'com.android.library'

// AGP 9 supplies Kotlin via `android.builtInKotlin=true` (default on AGP 9).
// For older AGP or when the flag is explicitly disabled, apply kotlin-android manually.
def builtInKotlin = project.findProperty('android.builtInKotlin')
if (builtInKotlin == null || builtInKotlin.toString() == 'false') {
    apply plugin: 'kotlin-android'
}

android {
    if (project.android.hasProperty("namespace")) {
        namespace 'com.aboutyou.dart_packages.sign_in_with_apple'
    }
    compileSdk 34

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
    sourceSets {
        main.java.srcDirs += 'src/main/kotlin'
    }
    defaultConfig {
        minSdk 21
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    lint {
        disable 'InvalidPackage'
    }
}

dependencies {
    implementation "androidx.browser:browser:1.5.0"
}

Changes vs. current:

• compileSdkVersion 34 → compileSdk 34
• minSdkVersion 16 → minSdk 21 (minSdk 16 is below Flutter's current floor anyway — feel free to keep 16 if wider support is desired)
• Conditional apply plugin: 'kotlin-android' guarded by the android.builtInKotlin property
• kotlin_version bumped 1.7.10 → 1.9.0 (AGP 9 requires Kotlin 1.9+); drop the explicit kotlin-stdlib-jdk7 dep since AGP-provided Kotlin brings its own stdlib

Happy to open a PR if helpful.

[tp]

As of Flutter 3.41, it seems like AGP9 is not (yet) supported, and it warns against us making any changed to accommodate it (for now): https://blog.flutter.dev/whats-new-in-flutter-3-41-302ec140e632

I think we'd need to wait for a future release resolving flutter/flutter#181557, and then push an update (depending on whether or not this will be a breaking change and/or exclusively supports AGP9, we can either opt to support multiple AGP versions or raise the minimum Flutter version to that future release and only support the new setup by then. Let's see what the future brings.)

[qeepcologne]

https://docs.flutter.dev/release/breaking-changes/migrate-to-built-in-kotlin/for-plugin-authors

[tp]

@qeepcologne That one should've been addressed in #486

Anything that not working for you in the latest version?

The issue I mentioned in my previous comment is still open. We need to revisit that (in potentially another breaking change) later.

[qeepcologne]

@tp still warns:
WARNING: Your app uses the following plugins that apply Kotlin Gradle Plugin (KGP): app_settings, device_info_plus, firebase_analytics, firebase_performance, firebase_remote_config, flutter_upgrade_version, in_app_review, package_info_plus, share_plus, sign_in_with_apple

[MirceaX2Mobile]

It happens to me also, do we have some updates regarding this?

[qeepcologne]

@tp Thanks — but #486 didn't actually address this. It was a version bump (Kotlin 1.7.10 → 2.2.20, AGP classpath 7.4.2 → 8.11.1, compileSdk 34 → 36, minSdk 16 → 24, Java 8 → 17), and every line this issue flagged is still there in the released 8.1.0:

apply plugin: 'kotlin-android'        // ← this single line is what produces the KGP warning
android {
    compileSdkVersion 36              // ← blocks android.newDsl=true
    kotlinOptions { jvmTarget = '17' }
    defaultConfig {
        minSdkVersion 24              // ← blocks android.newDsl=true
    }
}

Why this matters now

AGP 9 is no longer hypothetical. Flutter 3.44's own app template ships both compat flags, which is exactly what lets AGP 9 builds work today (packages/flutter_tools/templates/app/android.tmpl/gradle.properties.tmpl):

# This newDsl flag was added by the Flutter template
android.newDsl=false
# This builtInKotlin flag was added by the Flutter template
android.builtInKotlin=false

So AGP 9 + the flags is the default path, and the KGP warning is Flutter telling us which plugins still need migrating. It's reasonable to expect a future release to flip builtInKotlin to true — at which point plugins that unconditionally apply KGP will be a hard failure rather than a warning.

I'm on AGP 9.3.0-rc02 / Flutter 3.44.6 and sign_in_with_apple is still in the warning list.

The fix — backward compatible, keeps AGP 7/8 working

This is the pattern share_plus, device_info_plus and package_info_plus already ship (they've since dropped off the warning list), adapted to Groovy:

// AGP 9 provides Kotlin itself, unless the app opts out via android.builtInKotlin=false.
def agpMajor = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0] as int
def builtInKotlin = providers.gradleProperty("android.builtInKotlin")
        .map { it.toBoolean() }
        .orElse(agpMajor >= 9)
        .get()
if (agpMajor < 9 || !builtInKotlin) {
    apply plugin: 'kotlin-android'
}

// Replaces `android { kotlinOptions { jvmTarget = '17' } }`: that accessor only exists when KGP is applied.
// This configures the same extension whether it came from kotlin-android (AGP 8) or built-in Kotlin (AGP 9).
project.extensions.configure(org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension) {
    compilerOptions {
        jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
    }
}

android {
    compileSdk = 36              // was: compileSdkVersion 36
    namespace 'com.aboutyou.dart_packages.sign_in_with_apple'

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }

    defaultConfig {
        minSdk = 24              // was: minSdkVersion 24
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    lint { disable 'InvalidPackage' }
}

Notes on backward compatibility:

• compileSdk / minSdk (no Version suffix) have existed since AGP 7, so those two changes are safe unconditionally — no version guard needed.
• Reading android.builtInKotlin rather than only checking agpMajor is what keeps it robust: an AGP 9 user who still sets builtInKotlin=false (i.e. everyone on the current Flutter template) keeps KGP applied and keeps building. The plugin only steps aside once that flag flips.
• sourceSets { main.java.srcDirs += 'src/main/kotlin' } can simply be dropped — src/main/kotlin is a default Kotlin source dir under both KGP and AGP 9's built-in Kotlin. (share_plus has the same layout with no sourceSets block.)
• buildscript {} and rootProject.allprojects { repositories {} } can stay as they are; they don't block either flag.

Happy to open a PR with exactly this if it helps.

[CharlieMacnamara]

Hi team, just noting that PR #491 was opened on 2026-07-17 to address this. Is there anything blocking that PR from being merged? My app is currently pinned to AGP 9.x waiting for this.

[tp]

Sorry for the delay on this issue.

We’ll get the fix out early next week 🤞