Saltar al contenido principal

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.

  1. Abre tu proyecto Android en Android Studio.

  2. Ve a File > New > New Project.... Se muestra el diálogo New Project.

  3. Haz clic en Flutter.

  4. Si se te solicita que proporciones la ruta de tu SDK de Flutter, hazlo y haz clic en Next.

  5. Completa la configuración de tu módulo Flutter.

    • Si tienes un proyecto existente:

      1. Para elegir un proyecto existente, haz clic en ... a la derecha de la casilla Project location.
      2. Navega al directorio de tu proyecto Flutter.
      3. Haz clic en Open.
    • Si necesitas crear un nuevo proyecto Flutter:

      1. Completa el diálogo de configuración.
      2. En el menú Project type, selecciona Module.
  6. 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 { }.

MyApp/app/build.gradle
groovy
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:

  1. Elimina el bloque repositories en todos los archivos build.gradle de tu aplicación.

    groovy
    // Remove the following block, starting on the next line
        repositories {
            google()
            mavenCentral()
        }
    // ...to the previous line
    
  2. Añade el bloque dependencyResolutionManagement que se muestra en este paso al archivo settings.gradle.

settings.gradle.kts
kotlin
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")
    }
}
settings.gradle
groovy
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.

  1. 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.

  2. 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:

settings.gradle.kts
kotlin
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")
    }
}
settings.gradle
groovy
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.

MyApp/app/build.gradle.kts
kotlin
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.

MyApp/app/build.gradle.kts
kotlin
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:

MyApp/settings.gradle.kts
kotlin
// 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:

MyApp/settings.gradle
groovy
// 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:

MyApp/app/build.gradle
groovy
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.