Utilisation de la fonction Play Delivery

Qu'est-ce que la livraison de fonctionnalités ?

Ladocumentation de Google destinée aux développeurs détaille cette fonctionnalité qui permet essentiellement aux développeurs de structurer leurs projets de manière à ce que le magasin Google Play puisse diviser le contenu de leur application en plusieurs paquets téléchargeables. Elle permet également aux développeurs de contrôler la manière dont le contenu est fourni aux utilisateurs. Ces paquets de logiciels et de contenu divisés sont livrés à la boutique Google Play à l'aide d'ensembles d'applications Android (AAB).

Exemple de projet : FDMapLoader

Cette application utilise la livraison de fonctionnalités de jeu pour servir des images à un utilisateur lorsqu'il en fait la demande. L'application peut être facilement modifiée pour créer une application de plus de 200 Mo afin de tester les limites de taille de l'application et le téléchargement à l'aide d'un module de livraison de fonctionnalités de grande taille.

Configuration de la construction

  • fdwintermapmodule: Projet de module de fonctionnalité pour Qt Creator
  • fdmaploader: Projet de l'application principale pour Qt Creator
  • fdmaploader-android-project: Projet Android pour la compilation de l'ensemble d'applications Android.

Compiler FDWintermapModule - Feature Module

Chargez le projet fdwintermapmodule sur Qt Creator, configurez-le pour votre plateforme cible et compilez-le.

Compiler FDMapLoader - Application principale

Chargez le projet fdmaploader sur Qt Creator, configurez-le pour votre plateforme cible, et compilez.

Modifier le projet Android

  • Copiez les fichiers binaires construits (.so) des répertoires de construction du module de fonctionnalité et de l'application principale dans les répertoires de bibliothèque correspondants d'un projet Android. (app/src/main/jniLibs/[target ABI]/ et fdwintermapmodule/src/main/jniLibs/[target ABI]/ respectivement)
  • Copier les autres fichiers modifiés, tels que les fichiers de ressources et les classes Java. (dossiers.../res/... et .../src/main/java/... )
  • Construire le projet Android soit à l'aide d'Android Studio, soit à partir de la ligne de commande en utilisant le wrapper Gradle (./gradlew bundle)
  • Pour les tests, vous pouvez créer des APK à partir d'un bundle et installer une version de test locale sur un appareil à l'aide de bundletool. Bundletool est un outil fourni par Google et nous aborderons son utilisation plus loin dans cette documentation. Pour les tests et la publication, vous pouvez télécharger l'ensemble vers la Google Play Console.

Ajouter votre propre contenu

Cet exemple est conçu pour que les développeurs puissent facilement ajouter leur propre contenu afin de tester la livraison de fonctionnalités. Pour dépasser la taille maximale du paquet Play Store, des images de carte (il n'est pas nécessaire qu'il s'agisse d'images de carte, mais cela correspond au thème de l'exemple) peuvent être ajoutées au dossier images dans FDMapLoader et FDWintermapModule, les noms d'image doivent également être ajoutés au fichier images.qrc.

Créez votre propre

Les sections suivantes décrivent comment créer votre propre projet qui utilise la livraison de fonctionnalités de jeu. Il est conseillé d'utiliser l'exemple comme base. Dans le projet, Qt 6.7.2 a été utilisé.

Module de fonctionnalité

La livraison de fonctionnalités traite les bibliothèques C++ comme des bibliothèques partagées normales qui peuvent ou non être disponibles au moment de l'exécution. Avant d'appeler une bibliothèque, il faut en vérifier la disponibilité.

  • Utilisez Qt Creator pour créer une bibliothèque partagée C++.
  • Mettez en œuvre des fonctionnalités et ajoutez des ressources.
  • Construire pour créer des binaires .so.

Application principale (Qt)

  • Utiliser Qt Creator pour créer une application (le modèle de projetQt Quick a été utilisé ici).
  • Mettre en œuvre l'accès à la bibliothèque Feature Delivery. La classe centrale de la bibliothèque Java Google Play Feature Delivery est SplitInstallManager.
  • Les fichiers modèles Android peuvent être créés en utilisant le bouton "Create Templates" sur QtCreator Projects -> Build&Run -> [target ABI] -> Build Steps -> Build Android APK. Les modèles sont créés dans le dossier "android" du projet.
  • Ajoutez les fichiers Java au dossier .../android/src/java/[package...] et les chemins d'accès aux fichiers à CMakeLists.txt:
    qt_add_executable...
    ...[path]/[java-filename.java]
    ...
  • Dans l'exemple, une classe Java a été créée pour gérer les appels et les rappels. La classe Java est ensuite accessible depuis Qt à l'aide de JNI. La documentation d'Android contient une description simple de la manière de demander un module.
  • Lors de l'ajout de fichiers Java dans le dossier android du projet, la propriété QT_ANDROID_PACKAGE_SOURCE_DIR doit être ajoutée à l'adresse CMakeLists.txt:
    ...
    set_property(TARGET appFDMainApp APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR
                 ${CMAKE_CURRENT_SOURCE_DIR}/android)
    ...
  • De plus, l'application principale build.gradle doit avoir des dépendances pour la fonctionnalité API : dans le bloc des dépendances, remplacez
    implementation 'androidx.core:core:1.13.1'

    par

    implementation("com.google.android.play:feature-delivery:2.1.0")
  • Mettre en œuvre l'accès à la bibliothèque fournie par le module de fonctionnalité. Comme le module de fonctionnalité peut ou non être disponible pour l'application principale, les modules ne sont pas liés au moment de la construction et les appels au module doivent être résolus au moment de l'exécution. Exemple :
    typedef void* (*LoadModuleRulesFunc)();
    LoadModuleRulesFunc loadModuleRules =
        (LoadModuleRulesFunc) mFDModuleLibrary.resolve("loadModuleRules");
    if (loadModuleRules) {
        void* result = loadModuleRules();
        QScopedPointer<QString> resultStr{static_cast<QString*>(result)};
    }
  • Mettre en œuvre l'interface utilisateur et les autres parties requises de l'application principale.

Module de fonctionnalité (Qt)

  • Utiliser Qt Creator pour créer une application (le modèle de projet de la bibliothèque Qt C++ a été utilisé).
  • Implémenter les fonctionnalités offertes par le module.

Projet Android (Android)

La création d'un projet pour construire un paquet d'applications Android pour la livraison de fonctionnalités est basée sur la documentation d'Android, principalement :

Créer un projet Android manuellement ou à l'aide d'Android Studio (en utilisant le modèle 'No Activity'). Le projet est modifié de manière à contenir un projet de premier niveau et deux sous-projets, app et feature-module. Le modèle Android Studio crée le sous-projet app et le feature-module peut être ajouté en utilisant le modèle File -> New -> New Module.

Le projet modèle nécessite plusieurs modifications :

  • Ajouter le plugin de livraison de fonctionnalités au niveau 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
    }
  • Ajouter le module de fonctionnalités à settings.gradle, modifier rootProject.name si nécessaire :
    ...
    rootProject.name = "name-of-the-root-project"
    include(:app)
    include(:name-of-the-feature-module)

app - Sous-projet

  • Le projet Android nécessite les binaires Qt du projet Main App :
    • Copier les bibliothèques natives dans Qt build : [build directory]/android-build/libs/[target ABI] vers app/src/main/jniLibs/[target ABI]
    • Copier les bocaux dans [build directory]/android-build/libs/ vers app/libs/
  • À partir de la compilation Qt, le contenu des dossiers res, AndroidManifest.xml et local.properties est également copié dans les emplacements respectifs du projet Android.
  • Ajoutez le fichier feature_names.xml au dossier app/src/main/res/values contenant une chaîne pour le module de fonctionnalité :
    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="feature_module_name">name-of-the-feature-module-here</string>
    </resources>
  • Ajoutez le fichier keep.xml au dossier app/src/main/res/raw contenant :
    <?xml version="1.0" encoding="utf-8"?>
    <resources xmlns:tools="http://schemas.android.com/tools"
        tools:keep="@string/feature_module_winter_map"
        tools:discard="" />

Modifications des fichiers de construction du sous-projet app

Les fichiers de construction copiés dans le projet Android nécessitent quelques modifications.

app - Sous-projet

build.gradle
  • Suppression des blocs buildScript et repositories.
  • Le bloc Android dans l'application principale build.gradle nécessite quelques modifications :
    • 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
...
}

Ajouter également la configuration de la signature au bloc Android :

android {
...
  signingConfigs {
    release {
      store

      \code
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 XML a ajouté des variables de projet à gradle.properties. Changez la valeur de androidPackageName si nécessaire.

AndroidManifest.xml
  • Supprimez package:
    ...
    <manifest
    ...
      android:package... <--remove
    ...
    >
    ...
  • Modifier label et android.app.lib_name si nécessaire :
    ...
    <application ...
      android:label=" ...
      <activity ... >
        <meta-data android:name="android.app.lib_name" android:value=" ...
        />
    ...

feature-module - Sous-projet

Les modules d'application et de fonctionnalité sont créés en tant que sous-projets du projet Android de premier niveau. La structure des dossiers et des fichiers est similaire à celle du sous-projet app.

  • Les binaires du module fonctionnel provenant de la compilation de Qt sont copiés dans le dossier "feature-module". [name-of-feature-module]/src/main/jniLibs/
  • Comme dans l'application principale, le dossier src/main/res/ doit contenir les dossiers xml et values contenant respectivement qtprovider_paths.xml et libs.xml. Les deux fichiers peuvent être copiés à partir du projet d'application.
  • Si le dossier src/main/res/ contient des dossiers drawable ou mipmap et que la fonctionnalité n'en a pas besoin, ils peuvent être supprimés.
  • Dans le module de fonctionnalité, src/main/res/values ne doit pas contenir le champ app_name. Dans les projets simples où strings.xml n'est pas nécessaire pour d'autres utilisations, il peut être supprimé.
  • libs.xml contient uniquement le nom du module de fonctionnalité :
    ...
        <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 est ajouté au répertoire 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>
  • Le module de fonctionnalité build.gradle est assez similaire à celui du projet app, avec quelques changements. Voici un exemple tiré du projet example :
    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 {
            resConfig "en"
            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/']
           }
        }
    
        tasks.withType(JavaCompile) {
            options.incremental = true
        }
    
        compileOptions {
            sourceCompatibility JavaVersion.VERSION_1_8
            targetCompatibility JavaVersion.VERSION_1_8
        }
    
        lintOptions {
            abortOnError false
        }
    
        // Do not compress Qt binary resources file
        aaptOptions {
            noCompress 'rcc'
        }
    }
  • gradle.properties Ce fichier peut être copié à partir du sous-projet app, en remplaçant le androidPackageName par le package feature module.

Construction et déploiement

Le bundle AAB peut être construit à partir de la ligne de commande en utilisant le wrapper gradle : ./gradlew bundle L'AAB produit sera dans le dossier build/outputs/bundle/release (ou debug). L'AAB peut ensuite être copié sur le Google Play Store et publié pour être testé. Les tests peuvent également être effectués localement en utilisant bundletool avec le paramètre --local-testing. Documentation de Bundletool

Commandes de Bundletool utilisées

  • Générer des APK:s à partir d'un bundle :
    bundletool build-apks --bundle=/path/to/bundle.aab --output=/path/to/apk/package.apks --local-testing
  • Installer l'application sur l'appareil :
    bundletool install-apks --apks=/path/to/apk/package.apks

© 2025 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.