Construire des projets Qt pour Android à partir de la ligne de commande

Construire avec CMake

Pour construire des projets CMake avec un Qt installé, par exemple, pour Linux, utilisez ce qui suit avec le wrapper qt-cmake:

~/Qt/<qt_version>/android_<abi>/bin/qt-cmake \
    -DANDROID_SDK_ROOT=~/Android/Sdk \
    -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
    -S <source_dir> -B <build_dir> \
    -GNinja

Tout au long de cette page, nous utilisons le chemin du SDK Android pour Linux pour des raisons de simplicité. Cependant, lorsque vous exécutez ces commandes, assurez-vous d'utiliser le chemin correspondant à votre système.

Le SDK Android est généralement installé par Qt Creator ou Android Studio dans les emplacements suivants :

• Linux : ~/Android/Sdk/
• macOS : ~/Bibliothèque/Android/sdk/
• Windows : C :\Users\<UTILISATEUR>\AppData\Local \Android \Sdk \

Construire des paquets multi-ABI avec CMake

Dans Qt 6.11, il existe plusieurs façons de construire un paquetage multi-ABI. Par défaut, seul l'ABI unique appartenant au script qt-cmake est sélectionné. La définition de la variable QT_ANDROID_BUILD_ALL_ABIS à TRUE permet la détection automatique des SDK Qt pour Android disponibles. Le mécanisme de détection suppose l'utilisation de la structure de répertoire par défaut fournie par Qt Online Installer:

~/Qt/<qt_version>:
    android_arm64_v8a
    android_armv7
    android_x86
    android_x86_64

La commande ci-dessous montre la manière la plus simple de construire un paquetage multi-ABI Android en utilisant les SDK Qt pour Android fournis par Qt Online Installer:

~/Qt/<qt_version>/android_<abi>/bin/qt-cmake \
    -DQT_ANDROID_BUILD_ALL_ABIS=TRUE \
    -DANDROID_SDK_ROOT=~/Android/Sdk \
    -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
    -S <source_directory> -B <build_directory>
    -GNinja

En utilisant la variable QT_ANDROID_ABIS, il est possible de personnaliser la liste des ABI pour lesquelles le projet est construit. Les kits de développement Qt pour Android correspondants doivent suivre la structure de répertoire décrite précédemment. La ligne de commande suivante configure un projet pour les ABI arm64-v8a et x86 uniquement :

~/Qt/<qt_version>/android_<abi>/bin/qt-cmake \
    -DQT_ANDROID_ABIS="arm64-v8a;x86" \
    -DANDROID_SDK_ROOT=~/Android/Sdk \
    -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
    -S <source_directory> -B <build_directory>
    -GNinja

Les chemins vers les SDK Qt pour Android qui ne correspondent pas à la structure de répertoire par défaut peuvent être modifiés en utilisant les variables QT_PATH_ANDROID_ABI_<ABI> correspondantes.

L'exemple suivant active la détection automatique des SDK Qt pour Android disponibles et spécifie des chemins personnalisés vers les SDK armeabi-v7a et arm64-v8a:

<qt_for_android_install_path>/bin/qt-cmake \
    -DQT_ANDROID_BUILD_ALL_ABIS=TRUE
    -DQT_PATH_ANDROID_ABI_armeabi-v7a="<Qt/for/armeabi-v7a>" \
    -DQT_PATH_ANDROID_ABI_arm64-v8a="<Qt/for/arm64-v8a>" \
    -DANDROID_SDK_ROOT=~/Android/Sdk \
    -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
    -S <source_directory> -B <build_directory>
    -GNinja

Il est également possible de définir la propriété QT_ANDROID_ABIS target qui spécifie une liste d'ABI pour lesquels la cible exécutable unique est construite. Par exemple :

qt_add_executable(MyApp main.cpp)
set_target_properties(MyApp PROPERTIES QT_ANDROID_ABIS "arm64-v8a;x86")

La cible MyApp sera construite pour armeabi-v7a et arm64-v8a uniquement, même si la variable QT_ANDROID_BUILD_ALL_ABIS ou QT_ANDROID_ABIS est définie.

Création de l'ensemble Android

Une fois le projet configuré, vous pouvez utiliser les cibles CMake suivantes pour créer le paquet d'applications :

cmake --build . --target apk

Ou pour générer l'AAB :

cmake --build . --target aab

Sous le capot, votre code Qt XML est construit et copié dans le répertoire android-build, puis Gradle est utilisé pour construire le code Java et empaqueter l'application.

Signer le paquet Android

Si un APK destiné à être publié est construit, il doit être signé. Pour plus d'informations sur la signature du paquet avec Qt Creator, voir Signer les paquets Android. Sinon, vérifiez les variables CMake QT_ANDROID_SIGN_APK et QT_ANDROID_SIGN_AAB.

Construction d'un fichier AAR (Android Archive)

Une archive Android (AAR ) est un format de bibliothèque Android. Contrairement à un APK ou un AAB, il ne peut pas être exécuté de manière autonome ; il est plutôt destiné à être intégré en tant que dépendance dans une application Android native. C'est la configuration typique lors de l'hébergement de contenu Qt Qml dans une activité native Android.

Pour produire un AAR, définissez votre application Qt avec qt_add_executable comme d'habitude. Les cibles de construction AAR sont créées automatiquement avec les cibles APK et AAB. Construisez tous les paquets AAR d'un projet avec :

cmake --build . --target aar

Pour construire uniquement l'AAR pour une cible spécifique nommée myapp:

cmake --build . --target myapp_make_aar

Construction avec qmake

Vous pouvez continuer à utiliser qmake pour construire des projets d'utilisateurs comme dans Qt 5.