Integrar un módulo Flutter en tu proyecto Android
Aprende cómo integrar un módulo Flutter en tu proyecto Android existente.
Flutter se puede embeber en tu aplicación Android existente de forma gradual, como un subproyecto de código fuente de Gradle o como archivos AAR.
El flujo de integración se puede realizar utilizando el IDE Android Studio con el plugin de Flutter o de forma manual.
Integrar tu módulo Flutter
#Integrar con Android Studio
#El IDE Android Studio puede ayudarte a integrar tu módulo Flutter. Al usar Android Studio, puedes editar tanto tu código de Android como el de Flutter en el mismo IDE.
También puedes utilizar las funciones del plugin de IntelliJ Flutter como el autocompletado de código Dart, hot reload y el widget inspector.
Para compilar tu aplicación, el plugin de Android Studio configura tu proyecto Android para añadir tu módulo Flutter como una dependencia.
Abre tu proyecto Android en Android Studio.
-
Ve a File > New > New Project.... Se muestra el diálogo New Project.
Haz clic en Flutter.
-
Si se te solicita que proporciones la ruta de tu SDK de Flutter, hazlo y haz clic en Next.
-
Completa la configuración de tu módulo Flutter.
Si tienes un proyecto existente:
- Para elegir un proyecto existente, haz clic en ... a la derecha de la casilla Project location.
- Navega al directorio de tu proyecto Flutter.
- Haz clic en Open.
Si necesitas crear un nuevo proyecto Flutter:
- Completa el diálogo de configuración.
- En el menú Project type, selecciona Module.
Haz clic en Finish.
Integrar sin Android Studio
#Para integrar un módulo Flutter con una aplicación Android existente de forma manual, sin utilizar el plugin de Android Studio de Flutter, sigue estos pasos:
Crear un módulo Flutter
#Asumiendo que tienes una aplicación Android existente en
some/path/MyApp, y que deseas que tu proyecto de Flutter
esté en el mismo nivel, haz lo siguiente:
cd some/path/
flutter create -t module --org com.example flutter_module
Esto crea un proyecto de módulo Flutter en some/path/flutter_module/
con algo de código Dart para comenzar y una subcarpeta oculta
.android/. La carpeta .android contiene un
proyecto Android que puede ayudarte tanto a ejecutar una versión independiente
básica de tu módulo Flutter con flutter run como a servir
de envoltura para ayudar a preparar el módulo Flutter como una biblioteca
Android embebible.
Requisito de versión de Java
#Flutter requiere que tu proyecto declare compatibilidad con Java 17 o posterior.
Antes de intentar conectar tu proyecto de módulo Flutter a tu aplicación
Android anfitriona, asegúrate de que tu aplicación Android
anfitriona declare la siguiente compatibilidad de origen dentro del
archivo build.gradle de tu aplicación, bajo el bloque android { }.
android {
// ...
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17 // The minimum value
targetCompatibility = JavaVersion.VERSION_17 // The minimum value
}
// ...
}
Centralizar la configuración del repositorio
#A partir de Gradle 7, Android recomienda utilizar declaraciones de repositorio
centralizadas en settings.gradle en lugar de declaraciones a nivel
de proyecto o módulo en los archivos build.gradle.
Antes de intentar conectar tu proyecto de módulo Flutter a tu aplicación Android anfitriona, realiza los siguientes cambios en tu aplicación anfitriona:
-
Elimina el bloque
repositoriesen todos los archivosbuild.gradlede tu aplicación.groovy// Remove the following block, starting on the next line repositories { google() mavenCentral() } // ...to the previous line -
Añade el bloque
dependencyResolutionManagementque se muestra en este paso al archivosettings.gradle.
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.PREFER_SETTINGS)
val storageUrl: String = System.getenv("FLUTTER_STORAGE_BASE_URL") ?: "https://storage.googleapis.com"
repositories {
google()
mavenCentral()
maven("$storageUrl/download.flutter.io")
}
}
dependencyResolutionManagement {
repositoriesMode = RepositoriesMode.PREFER_SETTINGS
String storageUrl = System.env.FLUTTER_STORAGE_BASE_URL ?: "https://storage.googleapis.com"
repositories {
google()
mavenCentral()
maven {
url = uri("$storageUrl/download.flutter.io")
}
}
}
Añadir el módulo Flutter como una dependencia
#Añade el módulo Flutter como una dependencia de tu aplicación existente en Gradle. Puedes lograr esto de dos maneras.
-
Android archive El mecanismo AAR crea archivos AAR de Android genéricos como intermediarios que empaquetan tu módulo Flutter. Esto es conveniente cuando los compiladores de tu aplicación no desean tener instalado el SDK de Flutter. Sin embargo, añade un paso de compilación adicional si compilas con frecuencia.
-
Código fuente del módulo El mecanismo de subproyecto de código fuente es un proceso de compilación conveniente de un solo clic, pero requiere el SDK de Flutter. Este es el mecanismo utilizado por el plugin del IDE Android Studio.
Depender del Android Archive (AAR)
#Esta opción empaqueta tu biblioteca de Flutter como un repositorio Maven local genérico compuesto por artefactos AAR y POM. Esta opción permite a tu equipo compilar la aplicación anfitriona sin instalar el SDK de Flutter. Luego puedes distribuir los artefactos desde un repositorio local o remoto.
Supongamos que compilaste un módulo Flutter en
some/path/flutter_module, y luego ejecutas:
cd some/path/flutter_module
flutter build aar
Luego, sigue las instrucciones en pantalla para realizar la integración.
Específicamente, este comando crea (por defecto en todos los modos debug/profile/release) un repositorio local, con los siguientes archivos:
-
build/host/outputs/repo
com
example
flutter_module
flutter_release
1.0
- flutter_release-1.0.aar
- flutter_release-1.0.aar.md5
- flutter_release-1.0.aar.sha1
- flutter_release-1.0.pom
- flutter_release-1.0.pom.md5
- flutter_release-1.0.pom.sha1
- maven-metadata.xml
- maven-metadata.xml.md5
- maven-metadata.xml.sha1
flutter_profile
- …
flutter_debug
- …
Para depender del AAR, la aplicación anfitriona debe ser capaz de encontrar estos archivos.
Para hacer eso, edita settings.gradle in tu aplicación anfitriona
para que incluya el repositorio local y la dependencia:
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.PREFER_SETTINGS)
repositories {
google()
mavenCentral()
maven("https://storage.googleapis.com/download.flutter.io")
maven(url = "<some/path/flutter_module>/build/host/outputs/repo")
}
}
dependencyResolutionManagement {
repositoriesMode = RepositoriesMode.PREFER_SETTINGS
repositories {
google()
mavenCentral()
// Add the new repositories starting on the next line...
maven {
url = uri("<some/path/flutter_module>/build/host/outputs/repo")
// This is relative to the location of the build.gradle file
// if using a relative path.
}
maven {
url = uri("https://storage.googleapis.com/download.flutter.io")
}
// ...to before this line
}
}
Proyecto Android basado en Kotlin DSL
#Después de una compilación aar de un proyecto Android basado en Kotlin DSL,
sigue estos pasos para añadir el flutter_module.
Incluye el módulo Flutter como una dependencia en
el archivo app/build.gradle de la aplicación anfitriona.
android {
buildTypes {
release {
...
}
debug {
...
}
create("profile") {
initWith(getByName("debug"))
}
}
dependencies {
// ...
debugImplementation("com.example.flutter_module:flutter_debug:1.0")
releaseImplementation("com.example.flutter_module:flutter_release:1.0")
add("profileImplementation", "com.example.flutter_module:flutter_profile:1.0")
}
Añade la configuración de dependencia personalizada profileImplementation al final
del mismo archivo build.gradle a nivel de aplicación.
configurations {
getByName("profileImplementation") {
}
}
Depender del código fuente del módulo
#Esta opción habilita una compilación en un solo paso tanto para tu proyecto Android como para tu proyecto Flutter. Esta opción es conveniente cuando trabajas en ambas partes simultáneamente e iteras rápidamente, pero tu equipo debe instalar el SDK de Flutter para compilar la aplicación anfitriona.
Actualizando settings.gradle
#
Incluye el módulo Flutter como un subproyecto en el archivo de la aplicación anfitriona
settings.gradle. Este ejemplo asume que flutter_module
y MyApp
existen en el mismo directorio
Si estás usando Kotlin, aplica los siguientes cambios:
// Include the host app project. Assumed existing content.
include(":app")
// Replace "flutter_module" with whatever package_name you supplied when you ran:
// `$ flutter create -t module [package_name]
val filePath = settingsDir.parentFile.toString() + "/flutter_module/.android/include_flutter.groovy"
apply(from = File(filePath))
Si estás usando Groovy, aplica los siguientes cambios:
// Include the host app project.
include(":app") // assumed existing content
setBinding(new Binding([gradle: this])) // new
def filePath = settingsDir.parentFile.toString() + "/flutter_module/.android/include_flutter.groovy" // new
apply from: filePath // new
La vinculación y la evaluación del script permiten que el módulo Flutter
se incluya a sí mismo (como :flutter) y cualquier
plugin de Flutter utilizado por el módulo (como :package_info y :video_player)
en el contexto de evaluación de tu settings.gradle.
Actualizando app/build.gradle
#
Introduce una dependencia de implementation en el módulo Flutter
desde tu aplicación:
dependencies {
implementation(project(":flutter"))
}
Tu aplicación ahora incluye el módulo Flutter como una dependencia.
Continúa con la guía de Añadir una pantalla de Flutter a una aplicación Android.
A menos que se indique lo contrario, la documentación de este sitio refleja Flutter 3.44.0. Página actualizada por última vez el 2026-05-05. Ver código fuente oreportar un problema.