diff --git a/src/content/release/breaking-changes/index.md b/src/content/release/breaking-changes/index.md index e137d6087a..b1106c7a26 100644 --- a/src/content/release/breaking-changes/index.md +++ b/src/content/release/breaking-changes/index.md @@ -42,7 +42,7 @@ They're sorted by release and listed in alphabetical order: * [Deprecate `TextInputConnection.setStyle`][] * [`IconData` class marked as `final`][] * [ListTile reports error in debug when wrapped in a colored widget][] -* [Migrating Flutter Android app to Android Gradle Plugin 9.0.0][] +* [Migrating Flutter Android projects to built-in Kotlin][] * [Page transition builders reorganization][] [Changing RawMenuAnchor close order]: /release/breaking-changes/raw-menu-anchor-close-order @@ -51,7 +51,7 @@ They're sorted by release and listed in alphabetical order: [Deprecate `TextInputConnection.setStyle`]: /release/breaking-changes/deprecate-text-input-connection-set-style [`IconData` class marked as `final`]: /release/breaking-changes/icondata-class-marked-final [ListTile reports error in debug when wrapped in a colored widget]: /release/breaking-changes/list-tile-color-warning -[Migrating Flutter Android app to Android Gradle Plugin 9.0.0]: /release/breaking-changes/migrate-to-agp-9 +[Migrating Flutter Android projects to built-in Kotlin]: /release/breaking-changes/migrate-to-built-in-kotlin [Page transition builders reorganization]: /release/breaking-changes/decouple-page-transition-builders diff --git a/src/content/release/breaking-changes/migrate-to-agp-9.md b/src/content/release/breaking-changes/migrate-to-agp-9.md deleted file mode 100644 index 6fefa6b816..0000000000 --- a/src/content/release/breaking-changes/migrate-to-agp-9.md +++ /dev/null @@ -1,179 +0,0 @@ ---- -title: Migrating Flutter Android app to Android Gradle Plugin 9.0.0 -description: >- - How to migrate your Flutter app's Android Gradle files - to build apps with Android Gradle Plugin 9.0.0+. ---- - -:::warning -**Current status:** Please **do not** update your -Flutter app for Android to AGP 9. Flutter apps using plugins -are currently incompatible with AGP 9: [Issue #181383][]. -This support is paused while the Flutter team audits -the migration for backwards compatibility with older versions of AGP. - -If you would still like to migrate to AGP 9, follow the migration guide below. -::: - -## Summary - -To build a Flutter app for Android, the Android Gradle Plugin (AGP) -must be applied. As of AGP 9.0.0, -the following migrations are required to successfully apply AGP 9+. - -First, built-in Kotlin is the new default, meaning any apps -using the `kotlin-android` plugin will not build successfully. -You must migrate from `kotlin-android` to built-in Kotlin. - -Second, AGP 9+ will only use the new AGP DSL interfaces. -This means any old DSL types will not be properly read. -The Flutter team is working on migrating old DSL types -to use the new DSL: [Issue #180137][]. In the meantime, -you can set a Gradle property flag to use the old DSL. - -In a future Flutter release, support will be added for applying AGP 9+. -For now, all projects must be migrated manually. - -To learn more about Android Gradle Plugin, -see the [Android Gradle Plugin docs][AGP block]. - -## Migrate - -These instructions assume you are updating from -an AGP version created before 9.0.0 to an AGP version 9.0.0+. -You should also use the minimum compatible dependency versions -listed in the [Android Gradle Plugin docs][AGP block]. - -### Update the Gradle file - -If your app doesn't apply -the `kotlin-android` plugin (also called Kotlin Gradle Plugin), -then skip to the next step. - -First, find the `kotlin-android` plugin, likely located -in the `plugins` block of the `/android/build.gradle` -or `/android/build.gradle.kts` file. -As an example, consider the `build.gradle.kts` file from -a Flutter app created before this change: - -**Before**: - -```kotlin -plugins { - id("com.android.application") - id("kotlin-android") - // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins. - id("dev.flutter.flutter-gradle-plugin") -} - -android { - // ... - kotlinOptions { - jvmTarget = JavaVersion.VERSION_17.toString() - } - // ... -} - -// ... -``` - -Next, remove the `kotlin-android` plugin and the `kotlinOptions` block: - -```kotlin diff - plugins { - id("com.android.application") -- id("kotlin-android") - // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins. - id("dev.flutter.flutter-gradle-plugin") - } - - android { - // ... -- kotlinOptions { -- jvmTarget = JavaVersion.VERSION_17.toString() -- } - // ... - } -``` - -Replace the `kotlinOptions` block with the following: - -```kotlin diff -+ kotlin { -+ compilerOptions { -+ jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 -+ } -+ } -``` - -Here is how the file will likely end up: - -**After**: - -```kotlin -plugins { - id("com.android.application") - // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins. - id("dev.flutter.flutter-gradle-plugin") -} - -android { - // ... - kotlin { - compilerOptions { - jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 - } - } - // ... -} - -// ... -``` - -### Set the Gradle property flag - -Next, to use the old AGP DSL, set the Gradle property flag -`android.newDsl` to `false` in -your app's `/android/gradle.properties` file. - -```properties diff - org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError - android.useAndroidX=true -+ android.newDsl=false -``` - -### Validate - -Execute `flutter run` to confirm that your app builds and -launches on a connected Android device or emulator. - -## Next steps - -- **Full Support for Plugins:** Full support for plugins on AGP 9 - will be enabled once the team confirms the migration is backwards compatible with - older versions of AGP. - -- **Remove DSL Gradle Property:** Once the Flutter team completes the migration - to the new AGP DSL, remove `android.newDsl=false` from your - `gradle.properties` file. This document will be updated - to reflect that change. - -## References - -Relevant issues: - -- [Issue #175688][]: Audit flutter for compatibility with the AGP 9.0.0 -- [Issue #180137][]: Migrate from old to new AGP DSL -- [Issue #181383][]: Flutter plugins should support AGP 9.0.0 - -The Gradle build files in your app vary based on the Flutter version -used when your app was created. -Consider staying up to date with the latest version -of the build files by periodically running `flutter upgrade` -in your app's directory. - -[AGP block]: {{site.android-dev}}/build/releases/gradle-plugin - -[Issue #175688]: {{site.github}}/flutter/flutter/issues/175688 -[Issue #180137]: {{site.github}}/flutter/flutter/issues/180137 -[Issue #181383]: {{site.github}}/flutter/flutter/issues/181383 diff --git a/src/content/release/breaking-changes/migrate-to-built-in-kotlin/for-app-developers.md b/src/content/release/breaking-changes/migrate-to-built-in-kotlin/for-app-developers.md new file mode 100644 index 0000000000..55132e8cd6 --- /dev/null +++ b/src/content/release/breaking-changes/migrate-to-built-in-kotlin/for-app-developers.md @@ -0,0 +1,357 @@ +--- +title: Built-in Kotlin migration for app developers +description: >- + Migrate Flutter apps to use built-in Kotlin. +--- + +## Migrate + +This guide outlines the migration steps specifically for app developers. + +These instructions assume you are updating from +an AGP version created before 9.0.0 to an AGP version 9.0.0+. +You should also use the minimum compatible dependency versions +listed in the [Android Gradle Plugin docs][AGP block]. + +### Verify flags in properties file + +Flutter sets the default behavior to use the legacy Kotlin Gradle Plugin (KGP) +and the old AGP DSL types to support projects that have not yet migrated. +The Flutter migrator tool automatically adds `android.builtInKotlin=false` +and `android.newDsl=false` to your `gradle.properties` file. + +If these flags are missing from your `gradle.properties` file, +the Flutter tool automatically adds them when you next build or run your app +using `flutter run` or `flutter build apk`. + +Alternatively, building the project using Android Studio tooling also adds +these flags automatically. +Once the process completes, verify that the flags have been added. +For more details, see [Issue #183910]. + +All add-to-app projects must manually add `android.builtInKotlin=false` +and `android.newDsl=false` to the Android host app's `gradle.properties` file. +The Flutter migrator tool cannot run during add-to-app Android host app builds +because the host app is a pure native Android project. + +```properties diff title="/gradle.properties" +# ... ++ android.newDsl=false ++ android.builtInKotlin=false +``` + +:::note +If your app doesn't apply +the `kotlin-android` plugin (also called Kotlin Gradle Plugin), +then you only need to add `android.newDsl=false` and do not need +further migration. +::: + +### Update the Gradle file + +First, find the `kotlin-android` plugin (or the `org.jetbrains.kotlin.android` +plugin). +It is likely located in the `plugins` block of the +`/android/build.gradle` or the +`/android/build.gradle.kts` file. +If you use the legacy `apply` syntax, it will be located in +the Groovy-based `/android/build.gradle` file, as this syntax is +not supported in Kotlin DSL. + +The following examples demonstrate how to migrate a Flutter Android app +and an add-to-app Android host app: + +#### Migrate your Flutter Android app + + + + +**Before**: + +```kotlin title="/android/build.gradle(.kts)" +plugins { + id("com.android.application") + id("kotlin-android") + // ... +} + +android { + // ... + kotlinOptions { + jvmTarget = JavaVersion.VERSION_17.toString() + } + // ... +} + +// ... +``` + +Next, remove the `kotlin-android` plugin and the `kotlinOptions` block: + +```kotlin diff title="/android/build.gradle.kts" + plugins { + id("com.android.application") +- id("kotlin-android") + // ... + } + + android { + // ... +- kotlinOptions { +- jvmTarget = JavaVersion.VERSION_17.toString() +- } + // ... + } +``` + +Add the `kotlin.compilerOptions{}` DSL block with the following: + +```kotlin diff title="/android/build.gradle.kts" ++ kotlin { ++ compilerOptions { ++ jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 ++ } ++ } +``` + +Here is how the file will likely end up: + +**After**: + +```kotlin title="/android/build.gradle(.kts)" +plugins { + id("com.android.application") + // ... +} + +android { + // ... +} + +kotlin { + compilerOptions { + jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 + } +} + +// ... +``` + + + + +**Before**: + +```groovy title="/android/build.gradle" +apply plugin: 'com.android.application' +apply plugin: 'kotlin-android' +// ... + +android { + // ... + kotlinOptions { + jvmTarget = JavaVersion.VERSION_17.toString() + } + // ... +} + +// ... +``` + +Next, remove the `kotlin-android` plugin and the `kotlinOptions` block: + +```groovy diff title="/android/build.gradle" + apply plugin: 'com.android.application' +- apply plugin: 'kotlin-android' +// ... + + android { + // ... +- kotlinOptions { +- jvmTarget = JavaVersion.VERSION_17.toString() +- } + // ... + } +``` +Add the `kotlin.compilerOptions{}` DSL block with the following: + +```groovy diff title="/android/build.gradle" ++ kotlin { ++ compilerOptions { ++ jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 ++ } ++ } +``` + +Here is how the file will likely end up: + +**After**: + +```groovy title="/android/build.gradle" +apply plugin: 'com.android.application' +// ... + +android { + // ... +} + +kotlin { + compilerOptions { + jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 + } +} + +// ... +``` + + + + +#### Migrate your add-to-app Android host app + +Android native apps use the `alias` keyword to apply plugins, +which is incompatible with the legacy `apply()` syntax. +Therefore, only the `plugins {}` block instructions are included. + +**Before**: + +```kotlin title="/android/build.gradle(.kts)" +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) + // ... +} + +android { + // ... + kotlinOptions { + jvmTarget = JavaVersion.VERSION_17.toString() + } + // ... +} + +// ... +``` + +Next, remove the `kotlin-android` plugin and the `kotlinOptions` block: + +```kotlin diff title="/android/build.gradle.kts" + plugins { + alias(libs.plugins.android.application) +- alias(libs.plugins.kotlin.android) + // ... + } + + android { + // ... +- kotlinOptions { +- jvmTarget = JavaVersion.VERSION_17.toString() +- } + // ... + } +``` +Add the `kotlin.compilerOptions{}` DSL block with the following: + +```kotlin diff title="/android/build.gradle.kts" ++ kotlin { ++ compilerOptions { ++ jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 ++ } ++ } +``` + +Here is how the file will likely end up: + +**After**: + +```kotlin title="/android/build.gradle(.kts)" +plugins { + alias(libs.plugins.android.application) + // ... +} + +android { + // ... +} + +kotlin { + compilerOptions { + jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 + } +} + +// ... +``` + +### Validate + +Execute `flutter run` or `flutter build apk` to confirm that +your app builds and launches on a connected Android device or emulator. + +If your app fails to build because you are using an unmigrated Flutter plugin, +follow the instructions below: + +### Report incompatible Kotlin Gradle Plugin usage to plugin authors + +Follow these instructions only if your app uses a Flutter plugin +that has not yet migrated to built-in Kotlin. + +1. Find the repository of the unmigrated Flutter plugin by searching for the + plugin name on [pub.dev](https://pub.dev) or online. +2. Refer to the plugin CHANGELOG to confirm that no existing version + has migrated to built-in Kotlin. +3. Report an issue to the plugin authors, informing them that the Kotlin + Gradle Plugin is incompatible and won't be supported in a future version + of Flutter. + +You can use the following template for the issue: + +**Issue Title:** Migrate Plugin to Built-in Kotlin + +**Issue Body:** +I am using `` in my Flutter app. + +Starting with Android Gradle Plugin (AGP) 9.0, +support for applying the Kotlin Gradle Plugin (KGP) has been removed. +Because this plugin applies KGP, it causes a compilation error +that prevents my app from building. +Here is an example of the error [Issue #181383][]. + +Flutter has temporarily added support to allow KGP +while apps and plugins migrate to AGP 9.0+, +but this support will be removed in a future version of Flutter. + +Please migrate this plugin to use built-in Kotlin to ensure your plugin +users can successfully build their apps in future versions of Flutter. + +Here is the Flutter [migration guide for plugin authors][plugin-migration-guide]. + +Please be respectful and mindful of the plugin repository's rules and code +of conduct when reporting issues and interacting with plugin authors. + +For reference, see the [Flutter Code of Conduct][Code of Conduct]. + +## Next steps + +See the [migration overview](./) for next steps. + +## References + +Relevant issues: + +- [Issue #183910][]: Add Disable Built-in Kotlin and new DSL Migrators +- [Issue #181383][]: Flutter plugins should support AGP 9.0.0 + +The Gradle build files in your app vary based on the Flutter version +used when your app was created. +Consider staying up to date with the latest version +of the build files by periodically running `flutter upgrade` +in your app's directory. + +[AGP block]: {{site.android-dev}}/build/releases/gradle-plugin + +[Issue #183910]: {{site.github}}/flutter/flutter/issues/183910 +[Issue #181383]: {{site.github}}/flutter/flutter/issues/181383 + +[plugin-migration-guide]: {{site.flutter-docs}}/release/breaking-changes/migrate-to-built-in-kotlin/for-plugin-authors +[Code of Conduct]: https://github.com/flutter/flutter/blob/master/CODE_OF_CONDUCT.md diff --git a/src/content/release/breaking-changes/migrate-to-built-in-kotlin/for-plugin-authors.md b/src/content/release/breaking-changes/migrate-to-built-in-kotlin/for-plugin-authors.md new file mode 100644 index 0000000000..230bf1ab51 --- /dev/null +++ b/src/content/release/breaking-changes/migrate-to-built-in-kotlin/for-plugin-authors.md @@ -0,0 +1,224 @@ +--- +title: Built-in Kotlin migration for plugin authors +description: >- + Migrate Flutter plugins to use built-in Kotlin. +--- + +## Migrate your Flutter plugin + +This guide outlines the migration steps specifically for plugin authors. + +### Update the Gradle file + +First, find the `kotlin-android` plugin (or the `org.jetbrains.kotlin.android` +plugin). +It is likely located in the `plugins` block of the +`/build.gradle` or the `/build.gradle.kts` file. +If you use the legacy `apply` syntax, it will be located in +the Groovy-based `/build.gradle` file, as this syntax is +not supported in Kotlin DSL. + +The following examples demonstrate how to migrate a Flutter plugin: + + + + +**Before**: + +```kotlin title="/android/build.gradle(.kts)" +plugins { + id("com.android.library") + id("kotlin-android") + // ... +} + +android { + // ... + kotlinOptions { + jvmTarget = JavaVersion.VERSION_17.toString() + } + // ... +} + +// ... +``` + +Next, remove the `kotlin-android` plugin and the `kotlinOptions` block: + +```kotlin diff title="/android/build.gradle.kts" + plugins { + id("com.android.library") +- id("kotlin-android") + // ... + } + + android { + // ... +- kotlinOptions { +- jvmTarget = JavaVersion.VERSION_17.toString() +- } + // ... + } +``` + +Add the `kotlin.compilerOptions{}` DSL block with the following: + +```kotlin diff title="/android/build.gradle.kts" ++ kotlin { ++ compilerOptions { ++ jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 ++ } ++ } +``` + +Here is how the file will likely end up: + +**After**: + +```kotlin title="/android/build.gradle(.kts)" +plugins { + id("com.android.library") + // ... +} + +android { + // ... +} + +kotlin { + compilerOptions { + jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 + } +} + +// ... +``` + + + + +**Before**: + +```groovy title="/android/build.gradle" +apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' +// ... + +android { + // ... + kotlinOptions { + jvmTarget = JavaVersion.VERSION_17.toString() + } + // ... +} + +// ... +``` + +Next, remove the `kotlin-android` plugin and the `kotlinOptions` block: + +```groovy diff title="/android/build.gradle" + apply plugin: 'com.android.library' +- apply plugin: 'kotlin-android' +// ... + + android { + // ... +- kotlinOptions { +- jvmTarget = JavaVersion.VERSION_17.toString() +- } + // ... + } +``` +Add the `kotlin.compilerOptions{}` DSL block with the following: + +```groovy diff title="/android/build.gradle" ++ kotlin { ++ compilerOptions { ++ jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 ++ } ++ } +``` + +Here is how the file will likely end up: + +**After**: + +```groovy title="/android/build.gradle" +apply plugin: 'com.android.library' +// ... + +android { + // ... +} + +kotlin { + compilerOptions { + jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17 + } +} + +// ... +``` + +### Update the plugin's `pubspec.yaml` + +Using the `kotlin.compilerOptions {}` DSL block requires +a minimum Kotlin Gradle Plugin (KGP) version of 2.0.0. +Beginning with Flutter 3.44, the minimum required KGP version is 2.0.0. +To ensure that apps using your plugin can safely migrate to built-in Kotlin, +you should require a minimum Flutter version of 3.44 for this plugin version. + +Since you are updating the minimum Flutter version, +you must also update the minimum associated Dart version. + +Update the minimum Flutter version and the minimum Dart version: + +```yaml diff title="/pubspec.yaml" +# ... + +environment: +- sdk: ^ ++ sdk: ^3.12.0 +- flutter: ">=" ++ flutter: ">=3.44.0" + +# ... +``` + +Here is how the file will likely end up: + +```yaml title="/pubspec.yaml" +# ... + +environment: + sdk: ^3.12.0 + flutter: ">=3.44.0" + +# ... +``` + +### Update the plugin's `CHANGELOG.md` + +Include your changes in the CHANGELOG of the newly released plugin version: + +```markdown diff title="/CHANGELOG.md" ++ ## + ++ - Updates minimum supported SDK version to Flutter 3.44/Dart 3.12. ++ - Migrates to built-in Kotlin + +// ... +``` + +### Validate + +Execute `flutter run` or `flutter build apk` to confirm that +your plugin example app builds and launches +on a connected Android device or emulator. + +If your plugin example app also applies KGP, +then you will also have to migrate the example app. +Follow the [migration guide for app developers][app-migration-guide] to migrate your example app. + +[app-migration-guide]: {{site.flutter-docs}}/release/breaking-changes/migrate-to-built-in-kotlin/for-app-developers diff --git a/src/content/release/breaking-changes/migrate-to-built-in-kotlin/index.md b/src/content/release/breaking-changes/migrate-to-built-in-kotlin/index.md new file mode 100644 index 0000000000..3a4c165861 --- /dev/null +++ b/src/content/release/breaking-changes/migrate-to-built-in-kotlin/index.md @@ -0,0 +1,80 @@ +--- +title: Migrating Flutter Android projects to built-in Kotlin +description: >- + Update your Flutter Android Gradle files to use built-in Kotlin support. + Essential for migrating projects to Android Gradle Plugin 9.0.0+. +--- + +## Summary + +To build a Flutter app for Android, the Android Gradle Plugin (AGP) +must be applied. As of AGP 9.0.0, +the following migrations are required to successfully use AGP 9.0.0+. + +First, built-in Kotlin is the new default on AGP 9+, meaning any apps +using the `kotlin-android` plugin (also known as the Kotlin Gradle Plugin +or KGP) will not build successfully [Issue #181383][]. +However, the Flutter team has added temporary support for the legacy +Kotlin Gradle Plugin (KGP) in AGP 9.0.0+ [Issue #183909][]. +This allows app and plugin developers to safely build their projects +regardless of their migration state. + +Second, AGP 9.0.0+ will only use the new AGP DSL interfaces. +This means any old DSL types will not be recognized. +The Flutter team is working on migrating old DSL types +to use the new DSL: [Issue #180137][]. +In the meantime, the Flutter team has configured the AGP DSL to be compatible +with the legacy old AGP DSL types [Issue #184838][]. +This ensures app and plugin developers can safely upgrade to AGP 9+. + +To ensure compatibility, all apps and plugins must be manually migrated +from the legacy Kotlin Gradle Plugin (KGP) to built-in Kotlin. +In a future Flutter version, support for applying KGP will be removed +[Issue #184837][]. + +To learn more about Android Gradle Plugin, +see the [Android Gradle Plugin docs][AGP block]. + +## Migrate + +**For app developers:** See the [app developer migration guide][app-migration-guide]. + +**For plugin authors:** See the [plugin author migration guide][plugin-migration-guide]. + +## Next steps + +- **Remove Support for KGP:** In a future version of Flutter, + support for applying KGP will be removed [Issue #184837][]. Developers must + migrate their projects (apps, plugins, host app projects) or they will be + unable to build. + +- **Remove DSL Gradle Property:** Once the Flutter team + completes the migration to the new AGP DSL, + the Flutter team will remove support for the old DSL [Issue #184839][]. + +Relevant issues: + +- [Issue #180137][]: Migrate from old to new AGP DSL +- [Issue #181383][]: Flutter plugins should support AGP 9.0.0 +- [Issue #183909][]: Add support for KGP in AGP+ +- [Issue #184837][]: Remove support for KGP +- [Issue #184838][]: Disable new AGP DSL flag by default +- [Issue #184839][]: Remove support for old AGP DSL types + +The Gradle build files in your app vary based on the Flutter version +used when your app was created. +Consider staying up to date with the latest version +of the build files by periodically running `flutter upgrade` +in your app's directory. + +[AGP block]: {{site.android-dev}}/build/releases/gradle-plugin + +[Issue #180137]: {{site.github}}/flutter/flutter/issues/180137 +[Issue #181383]: {{site.github}}/flutter/flutter/issues/181383 +[Issue #183909]: {{site.github}}/flutter/flutter/issues/183909 +[Issue #184837]: {{site.github}}/flutter/flutter/issues/184837 +[Issue #184838]: {{site.github}}/flutter/flutter/issues/184838 +[Issue #184839]: {{site.github}}/flutter/flutter/issues/184839 + +[app-migration-guide]: {{site.flutter-docs}}/release/breaking-changes/migrate-to-built-in-kotlin/for-app-developers +[plugin-migration-guide]: {{site.flutter-docs}}/release/breaking-changes/migrate-to-built-in-kotlin/for-plugin-authors