En esta página

Uso de Play Feature Delivery

Ejemplos prácticos del uso de Google Play Feature Delivery en Qt.

Aplicación para cargar mapas con los botones «Cargar mapa», «Cambiar mapa» y «Eliminar mapa»

Este documento describe la funcionalidad del ejemplo de Feature Delivery. El ejemplo utiliza características compatibles a partir de Qt 6.11.
Play Feature Delivery se puede utilizar en versiones anteriores de Qt, pero para crear la aplicación es necesario añadir manualmente el proyecto de Android y copiar los binarios de Qt. Las instrucciones para ello se encuentran en el capítulo «Feature Delivery en versiones anteriores a Qt 6.11».

¿Qué es Feature Delivery?

Play Feature Delivery es una funcionalidad ofrecida por Google que, en esencia, permite a los desarrolladores estructurar sus proyectos de tal forma que la tienda Google Play pueda dividir el contenido de su aplicación en varios paquetes descargables. También ofrece a los desarrolladores control sobre cómo se entrega el contenido a los usuarios. Estos paquetes divididos de software y contenido se envían a la tienda Google Play mediante Android App Bundles (AAB). La documentación para desarrolladores de Google detalla esta función.

Proyecto de ejemplo: «Feature Delivery Map Loader»

Esta sencilla aplicación utiliza Play Feature Delivery para mostrar imágenes al usuario cuando lo solicita. La aplicación se puede modificar fácilmente para crear una aplicación de más de 200 MB con el fin de probar los límites de tamaño de la aplicación y la descarga mediante un módulo de Feature Delivery de gran tamaño.

La aplicación

La aplicación consta de una vista arrastrable y cuatro botones.

  • Al iniciarse, los botones « Load Map » y « Show Map Info » están activados.
  • Al hacer clic en el botón « Show Map Info », simplemente se muestra que no hay información disponible.
  • Load Map Inicia la carga del módulo de funciones:
    1. Aparece una ventana emergente de descarga; desde ella se puede cancelar la descarga.
    2. Cuando finaliza la descarga, la ventana emergente desaparece y
    3. Change Map se activan los botones « Remove Map ».
  • Remove Map El botón solicita la desinstalación del módulo de elementos, desactivando los botones habilitados.
  • Al hacer clic en « Change Map », se abre una vista en la que se puede cambiar el mapa mostrado. En este ejemplo, el módulo de funciones consta únicamente de una imagen de mapa con temática invernal.
Configuración de la carpeta de origen
  • fdwintermapmodule: módulo de funciones
  • fdmaploader: la aplicación principal
  • fdmaploader/storeloader: Interfaz JNI de entrega de elementos
Interfaz de entrega de funciones

La carpeta « fdmaploader/storeloader » contiene la clase de interfaz PlayStoreLoader para la API de entrega de funciones. La API no está completa, pero incluye funciones relevantes para cargar y eliminar módulos de funciones. La carga de módulos se inicia mediante una llamada a PlayStoreLoader::loadModule. El estado del proceso se puede supervisar mediante las señales proporcionadas por PlayStoreLoaderHandler. Se puede obtener un identificador para las llamadas de retorno mediante la función PlayStoreLoader::getHandler. La API de ejemplo también ofrece una forma de comprobar los módulos ya instalados mediante la función ` PlayStoreLoader::getInstalledModules ` y una opción para eliminar los módulos instalados mediante ` PlayStoreLoader::uninstallModules`.

Este ejemplo está diseñado para que un desarrollador pueda añadir fácilmente su propio contenido para probar la entrega de funciones. Para superar el tamaño máximo de paquete de Play Store, se pueden añadir imágenes de mapas (no es necesario que sean imágenes de mapas, pero encajan con la temática del ejemplo) a las carpetas de imágenes en fdmaploader y fdwintermapmodule; además, los nombres de las imágenes deben añadirse al archivo images.qrc.

Detrás de las cámaras

El módulo API consta de dos partes: la interfaz Qt (PlayStoreLoader y PlayStoreLoaderHandler) y las clases Java que gestionan las llamadas a las interfaces de instalación dividida de Android: Google Split Install Interfaces. La interfaz Qt funciona principalmente como un canal de paso para las clases Java. La interfaz Qt simplifica la API de tal manera que, cuando se carga el módulo de funciones, las clases y los oyentes de Google SplitCompat y SplitInstall se crean y se liberan automáticamente. En este ejemplo se han omitido algunas partes de las API, como deferredInstall y la compatibilidad con idiomas.
Qt creates and builds package suitable for Google Play deployment using qt6_add_android_dynamic_features when it is defined CMakeLists.

qt6_add_android_dynamic_features(${target_name}
    FEATURE_TARGETS fdwintermapmodule)

La función de CMake ` qt6_add_android_dynamic_features ` añade la biblioteca dinámica específica como característica dinámica para el destino de la aplicación de Android. Requiere que esté habilitada la variable `QT_ANDROID_GRADLE_MULTI_MODULE`. Esto se puede hacer bien como indicador en tiempo de compilación, bien configurándolo en el archivo `CMakeLists`. La carpeta donde se encuentra la parte Java de la interfaz se añade a la compilación mediante ` qt_add_android_dynamic_feature_java_source_dir`.

En la aplicación de ejemplo, los módulos se cargan mediante la interfaz ` storeloader `. Las funciones ` PlayStoreLoader ` de Qt XML y la clase ` PlayStoreLoaderHandler ` actúan como intermediarios entre el código de ejemplo y Java.

void PlayStoreLoader::loadModule(const QString& callId,
    const QString&moduleName)
{
    if (callId.isEmpty()|| moduleName.isEmpty())
        return;
    if (!loaderInstance->registerNatives())
        return;
    if (!loaderInstance->loader().isValid()) {
        qCritical("StoreLoader not constructed");
       return;
    }
    loaderInstance->loader().callMethod<void>("installModuleFromStore", moduleName, callId);
}

Las clases de Java gestionan las llamadas a la API de Split Install.

        m_splitInstallManager.startInstall(request)
                .addOnSuccessListener(sessionId -> {
                    PlayStoreLoaderListener listener = m_listeners.get(callId);
                    if (listener != null)
                        listener.setSessionId(sessionId);
                })
Creación de binarios

Mediante la línea de comandos se puede compilar un paquete AAB que se pueda probar localmente.

Crea un directorio de compilación y accede a él, que debe estar en el mismo nivel que el directorio de origen:

mkdir build-feature-delivery/ ; cd build-feature-delivery/

Configuración:

path-to-qt-version/path-to-abi/bin/qt-cmake -GNinja -B . -S ../feature-delivery/ -DQT_USE_TARGET_ANDROID_BUILD_DIR=ON -DCMAKE_BUILD_TYPE=Debug

Compilar:

ninja aab
Pruebas

El AAB compilado se puede probar localmente utilizando bundletool con el parámetro --local-testing. Android: Documentación de Bundletool El comando `bundletool build-apks ` crea un archivo APK que luego se puede instalar en un dispositivo o emulador con el comando ` install-apks `.

Comandos de Bundletool utilizados

Generar archivos APK a partir de un paquete:

bundletool build-apks --bundle=/path/to/bundle.aab --output=/path/to/apk/package.apks --local-testing

Instalar la aplicación en el dispositivo:

bundletool install-apks --apks=/path/to/apk/package.apks
Publicación en Play Store

Para poder subir el paquete AAB creado a Google Play Store, es necesario firmarlo. Para ello, se puede utilizar jarsigner. A continuación se muestra un ejemplo de comando de jarsigner para firmar el paquete AAB. Consulta la documentación de Android: Jarsigner.

jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256 -keystore [path-to-keystore-file].keystore [path-to-aab-file].aab [alias]

Implementación de la función en versiones anteriores a Qt 6.11

Las versiones anteriores a Qt 6.11 no admiten la generación de paquetes compatibles con Google Play Store. Si no puedes utilizar una versión de Qt 6.11 o posterior, existe una forma de utilizar la entrega de funciones de Google Play, pero requiere la creación manual del proyecto de Android y la copia de los binarios de Qt en él. El resto del documento contiene instrucciones sobre cómo hacerlo. Es posible que las instrucciones no sean compatibles al 100 % con todos los entornos, pero deberían ofrecer buenas pistas para lograr una implementación satisfactoria de Feature Delivery. Se recomienda utilizar el ejemplo como base.

Módulo de funciones

Los módulos de funciones se compilan como bibliotecas normales.

  • Utiliza Qt Creator para crear una biblioteca compartida de C++.
  • Implementa las funciones y añade recursos.
  • Compila para crear binarios .so.

Feature Delivery gestiona las bibliotecas de C++ como si fueran bibliotecas compartidas normales, que pueden estar disponibles o no en tiempo de ejecución. Antes de realizar llamadas a una biblioteca, es necesario comprobar su disponibilidad.

Aplicación principal (Qt)
  • Utiliza Qt Creator para crear una aplicación (aquí se ha utilizado la plantilla de proyecto «Qt Quick »).
  • Implementa el acceso a la biblioteca de Feature Delivery. La clase central de la biblioteca Java de Google Play Feature Delivery es Android: SplitInstallManager.
  • Los archivos de plantilla de Android se pueden crear utilizando el botón «Create Templates» (Crear plantillas) en QtCreator Projects -> Build&Run -> [target ABI] -> Build Steps -> Build Android APK. Las plantillas se crean en la carpeta «android» del proyecto.
  • Añade archivos Java a la carpeta « .../android/src/java/[package...] » y las rutas de los archivos a « CMakeLists.txt »:
    qt_add_executable...
    ...[path]/[java-filename.java]
    ...
  • En el ejemplo, se ha creado una clase Java para gestionar las llamadas y las devoluciones de llamada. A continuación, se accedería a la clase Java desde Qt mediante JNI. Android: La sección «Solicitar un módulo bajo demanda» de la documentación de Android ofrece una descripción sencilla de cómo solicitar un módulo.
  • Al añadir archivos Java en la carpeta «android» del proyecto, se debe añadir la propiedad QT_ANDROID_PACKAGE_SOURCE_DIR a CMakeLists.txt:
    ...
    set_property(TARGET appFDMainApp APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR
                 ${CMAKE_CURRENT_SOURCE_DIR}/android)
    ...
  • Además, la aplicación principal build.gradle debe tener dependencias para la API de la función: en el bloque de dependencias, sustituye
    implementation 'androidx.core:core:1.13.1'

    por

    implementation("com.google.android.play:feature-delivery:2.1.0")
  • Implementa el acceso a la biblioteca proporcionada por el módulo de funciones. Dado que el módulo de funciones puede estar disponible o no para la aplicación principal, los módulos no se enlazan en tiempo de compilación y las llamadas al módulo deben resolverse en tiempo de ejecución. Ejemplo:
    QString MapLoader::loadMapInfo()
    {
        QScopedPointer<QString> resultStr;
        typedef void* (*LoadMapInfoFunc)();
        //Comprobar si existe la biblioteca wintermap
        mWintermapLibrary.setFileName("fdwintermapmodule");
        if (!mWintermapLibrary.load()) {
            qWarning() << Q_FUNC_INFO << "Failed to load library";
           return QString();
        }
        LoadMapInfoFunc loadMapInfo = ( LoadMapInfoFunc) mWintermapLibrary.resolve("loadMapInfo");
        if (loadMapInfo) {
            void* result = loadMapInfo();
            resultStr.reset(static_cast<QString*>(result));
        } else
            qWarning() << Q_FUNC_INFO << "Function loadMapInfo not loaded";
    
       return *resultStr.data();
    }
  • Implementa la interfaz de usuario y el resto de elementos necesarios de la aplicación principal.
Módulo de funcionalidades (Qt)
  • Utiliza Qt Creator para crear una aplicación (se ha utilizado la plantilla de proyecto «Biblioteca Qt C++»).
  • Implementa las funcionalidades que ofrece el módulo.
Proyecto de Android (Android)

La creación de un proyecto para compilar un paquete de aplicación de Android para Feature Delivery se basa en la documentación de Android, principalmente:

Crea un proyecto de Android manualmente o mediante Android Studio (utilizando la plantilla «No Activity»). El proyecto se modifica para que contenga un proyecto de nivel superior y dos subproyectos: app y feature-module. La plantilla de Android Studio crea el subproyecto app, y el feature-module se puede añadir utilizando la plantill File -> New -> New Module.

El proyecto de la plantilla requiere varias modificaciones:

  • Añade el complemento Feature Delivery al nivel principal build.gradle:
    plugins {
        id 'com.android.application' version '8.5.2' apply false
        id 'com.android.dynamic-feature' version '8.5.2' apply false
        id 'com.android.library' version '8.5.2' apply false
    }
  • Añade el módulo de la función a settings.gradle y, si es necesario, cambia rootProject.name:
    ...
    rootProject.name = "name-of-the-root-project"
    include(:app)
    include(:name-of-the-feature-module)
app - Subproyecto
  • El proyecto de Android necesita los binarios de Qt del proyecto de la aplicación principal:
    • Copia las bibliotecas nativas de la compilación de Qt: [build directory]/android-build/libs/[target ABI] a app/src/main/jniLibs/[target ABI]
    • Copiar los archivos JAR de [build directory]/android-build/libs/ a app/libs/
  • Desde la compilación de Qt, también se copian los contenidos de la carpeta « res », « AndroidManifest.xml » y « local.properties » a sus respectivas ubicaciones en el proyecto de Android.
  • Añade el archivo feature_names.xml a la carpeta app/src/main/res/values, que contiene una cadena para el módulo de características:
    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="feature_module_name">name-of-the-feature-module-here</string>
    </resources>
  • Añade el archivo « keep.xml » a la carpeta « app/src/main/res/raw », que contenga:
    <?xml version="1.0" encoding="utf-8"?>
    <resources xmlns:tools="http://schemas.android.com/tools"
        tools:keep="@string/feature_module_winter_map"
        tools:discard="" />
Modificaciones en los archivos de compilación del subproyecto de la aplicación

Los archivos de compilación copiados al proyecto de Android necesitan algunas modificaciones.

app - Subproyecto
build.gradle
  • Elimina los bloques « buildScript » y « repositories ».
  • El bloque «Android» del archivo « build.gradle » de la aplicación principal requiere algunas modificaciones:
    • defaultConfig
    • packagingOptions
    • dynamicFeatures
    • sourceSets
    • aaptOptions
    • dependencies
android {
...
  defaultConfig {
  ...
    applicationId "your-project-name-here"
  ...
  }
  packagingOptions.jniLibs.useLegacyPackaging true

  dynamicFeatures = [":your-dynamic-feature-name-here"]

  sourceSets {
    main {
      manifest.srcFile 'src/main/AndroidManifest.xml'
      java.srcDirs = [qtAndroidDir + '/src', 'src', 'java']
      aidl.srcDirs = [qtAndroidDir + '/src', 'src', 'aidl']
      res.srcDirs = [qtAndroidDir + '/res', 'res']
      resources.srcDirs = ['resources']
      renderscript.srcDirs = ['src']
      assets.srcDirs = ['assets']
      jniLibs.srcDirs = ['src/main/jniLibs/']
    }
  }

  // Do not compress Qt binary resources file
  aaptOptions {
    noCompress 'rcc'
  }
...
}

dependencies {
...
  implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
  implementation 'com.google.android.play:feature-delivery:2.1.0'
  implementation libs.material
...
}

Añade también la configuración de firma al bloque «android»:

android {
...
  signingConfigs {
    release {
      storeFile file("/absolute/path/to/the/keystore.jks")
      storePassword "myStorePassword"
      keyAlias "myKeyAlias"
      keyPassword "myKeyPassword"
    }
  }
  buildTypes {
    release {
      signingConfig signingConfigs.release
      ...
    }
  }
...
}
gradle.properties

Qt ha añadido variables de proyecto a gradle.properties. Cambia el valor de androidPackageName si es necesario.

AndroidManifest.xml
  • Elimina package:
    ...
    <manifest
    ...
      android:package... <--remove
    ...
    >
    ...
  • Modifica label y android.app.lib_name si es necesario:
    ...
    <application ...
      android:label=" ...
      <activity ... >
        <meta-data android:name="android.app.lib_name" android:value=" ...
        />
    ...
módulo de funciones - Subproyecto

Los módulos de aplicación y de funciones se crean como subproyectos del proyecto de Android de nivel superior. La estructura de carpetas y archivos es similar a la del subproyecto de la aplicación.

  • Los binarios del módulo de funciones procedentes de la compilación de Qt se copian en la carpeta [name-of-feature-module]/src/main/jniLibs/
  • Al igual que en la aplicación principal, la carpeta « src/main/res/ » debe contener las carpetas « xml » y « values », que a su vez contienen « qtprovider_paths.xml » y « libs.xml », respectivamente. Ambos archivos se pueden copiar desde el proyecto de la aplicación.
  • Si la carpeta « src/main/res/ » contiene carpetas «drawable» o «mipmap» y la función no las requiere, pueden eliminarse.
  • En el módulo de la función, el archivo « src/main/res/values » no debe contener el campo « app_name ». En proyectos sencillos en los que el archivo «strings.xml» no sea necesario para otros fines, se puede eliminar.
  • libs.xml contiene únicamente el nombre del módulo de la función:
    ...
        <array name="load_local_libs">
            <item>name-of-the-feature-module-here</item>
        </array>
    
        <string name="static_init_classes"></string>
        <string name="use_local_qt_libs">0</string>
        <string name="bundle_local_qt_libs">0</string>
    ...
  • AndroidManifest.xml se añade al directorio « src/main/ »:
    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:dist="http://schemas.android.com/apk/distribution">
    
        <dist:module
            dist:instant="false"
            dist:title="@string/feature_module_title_string">
            <dist:delivery>
                <dist:on-demand />
            </dist:delivery>
            <dist:fusing dist:include="false" />
        </dist:module>
        <!-- This feature module does contain code. -->
        <application android:hasCode="true"/>
    </manifest>
  • El archivo « build.gradle » del módulo de características es bastante similar al del proyecto de la aplicación, con algunos cambios. He aquí un ejemplo:
    plugins {
        id 'com.android.dynamic-feature'
    }
    
    dependencies {
        implementation project(':app')
        implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
        implementation 'com.google.android.play:feature-delivery:2.1.0'
    }
    
    android {
    
        namespace = androidPackageName
        compileSdk = androidCompileSdkVersion
        ndkVersion androidNdkVersion
    
        // Extract native libraries from the APK
        packagingOptions.jniLibs.useLegacyPackaging true
    
        defaultConfig {
            minSdkVersion qtMinSdkVersion
            targetSdkVersion qtTargetSdkVersion
        }
    
        sourceSets {
            main {
                manifest.srcFile 'src/main/AndroidManifest.xml'
                resources.srcDirs = ['resources']
                renderscript.srcDirs = ['src']
                assets.srcDirs = ['assets']
                jniLibs.srcDirs = ['src/main/jniLibs/']
           }
        }
    
        compileOptions {
            sourceCompatibility JavaVersion.VERSION_17
            targetCompatibility JavaVersion.VERSION_17
        }
    
        // Do not compress Qt binary resources file
        aaptOptions {
            noCompress 'rcc'
        }
    }
  • gradle.properties El archivo se puede copiar desde el subproyecto de la aplicación; cambia « androidPackageName » por el paquete del módulo de la función.
Compilación e implementación

El paquete AAB se puede compilar desde la línea de comandos utilizando el envoltorio de Gradle: ` ./gradlew bundle`. El AAB generado se encontrará en la carpeta ` build/outputs/bundle/release ` (o ` debug`). A continuación, el AAB se puede copiar a Google Play Store y publicar para su prueba. Las pruebas también se pueden realizar localmente utilizando ` bundletool ` con el parámetro ` --local-testing `.

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.