Déployer des applications QML

Les documents QML sont chargés et exécutés par le QML Runtime. Celui-ci comprend le moteur Declarative UI ainsi que les types QML intégrés et les modules d'extension. Le moteur d'exécution QML permet également d'accéder à des types et modules QML tiers.

Les applications qui utilisent QML doivent invoquer le moteur d'exécution QML pour exécuter les documents QML. Vous pouvez le faire en créant un QQuickView ou un QQmlEngine, comme décrit ci-dessous. En outre, le paquetage Declarative UI comprend l'outil qml, qui charge les fichiers .qml. Cet outil est utile pour développer et tester le code QML sans avoir à écrire une application C++ pour charger le moteur d'exécution QML.

Le déploiement d'applications avec Qt Creator

Qt Creator permet de déployer et d'empaqueter des applications QML sur différentes plateformes. Pour les appareils mobiles, Qt Creator peut directement regrouper les applications dans les formats de paquetage des plates-formes respectives, tels que APK.

Lorsque vous exécutez vos applications sur la plateforme cible, votre application doit accéder à l'emplacement des bibliothèques QML. Si vous utilisez qmake, la variable d'environnement QT_INSTALL_QML indique l'emplacement des bibliothèques. Les programmes d'installation de Qt QML installent les bibliothèques QML dans le répertoire : <version>/<compiler>/qml.

Mise en cache de QML

Le moteur d'exécution QML charge les documents QML en les analysant et en générant un code d'octets. La plupart du temps, le document n'a pas changé depuis la dernière fois qu'il a été chargé. Pour accélérer ce processus de chargement, le moteur d'exécution QML maintient un fichier cache pour chaque document QML. Ce fichier cache contient le code d'octets compilé et une représentation binaire de la structure du document QML. En outre, lorsque plusieurs applications utilisent le même document QML, la mémoire nécessaire au code est partagée entre les processus d'application. Les fichiers de cache sont chargés via l'appel système mmap() sur les systèmes d'exploitation compatibles POSIX ou CreateFileMapping() sur Windows, ce qui permet de réaliser d'importantes économies de mémoire.

Chaque fois que vous chargez un document QML modifié, le cache est automatiquement recréé. Les fichiers de cache sont situés dans un sous-répertoire de QStandardPaths::CacheLocation portant le nom "qmlcache". L'extension du fichier est .qmlc pour les documents QML et .jsc pour les modules JavaScript importés.

Compilation anticipée

La mise en cache automatique des documents QML compilés dans des fichiers cache permet d'accélérer considérablement le temps de chargement des applications. Toutefois, la création initiale des fichiers cache peut encore prendre du temps, surtout lorsque l'application est lancée pour la toute première fois. Pour éviter cette étape initiale et fournir des temps de démarrage plus rapides dès le début, le système de compilation de Qt Compiler vous permet d'effectuer l'étape de compilation des fichiers QML à l'avance, lors de la compilation des parties C++ de votre application.

L'un des avantages de la compilation anticipée est qu'en cas d'erreurs de syntaxe dans vos documents QML, vous en êtes informé au moment de la compilation de l'application plutôt qu'au moment de l'exécution, lorsque le fichier est chargé.

Cela se produit automatiquement si vous utilisez l'API CMake QML Module, pour qmake voir la section ci-dessous.

qmake

Lorsque vous utilisez qmake, afin de déployer votre application avec des fichiers QML compilés à l'avance, vous devez organiser les fichiers et le système de compilation d'une manière spécifique :

• Tous les documents QML (y compris les fichiers JavaScript) doivent être inclus en tant que ressources via le système de ressources de Qt.
• Votre application doit charger les documents QML via le schéma d'URL qrc:///.
• Vous pouvez activer la compilation anticipée à l'aide de la directive CONFIG+=qtquickcompiler.

Prototypage avec QML Scene

Le paquet Declarative UI comprend un outil QML Runtime, qml, qui charge et affiche des documents QML. Cet outil est utile pendant la phase de développement de l'application pour prototyper des applications basées sur QML sans avoir à écrire vos propres applications C++ pour invoquer le runtime QML.

Initialisation de QML Runtime dans les applications

Pour exécuter une application qui utilise QML, votre application doit invoquer le moteur d'exécution QML. Pour ce faire, vous devez écrire une application Qt C++ qui charge le site QQmlEngine en procédant de l'une des manières suivantes :

• en chargeant le fichier QML par l'intermédiaire d'une instance QQuickView.
• en créant une instance QQmlEngine et en chargeant les fichiers QML avec QQmlComponent.

Initialisation avec QQuickView

QQuickView est une classe basée sur QWindow qui peut charger des fichiers QML. Par exemple, s'il existe un fichier QML, application.qml, il se présentera comme suit :

import QtQuick

Rectangle { width: 100; height: 100; color: "red" }

Il peut être chargé dans le fichier main.cpp d'une application Qt comme suit :

#include <QGuiApplication>
#include <QQuickView>

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);

    QQuickView view;
    view.setSource(QUrl::fromLocalFile("application.qml"));
    view.show();

    return app.exec();
}

Cela crée une vue basée sur QWindow qui affiche le contenu de application.qml.

Création de fichiers

find_package(Qt6 REQUIRED COMPONENTS Quick)
target_link_libraries(mytarget PRIVATE Qt6::Quick)

QT += quick

Créer un QQmlEngine directement

Si application.qml n'a pas de composants graphiques, ou s'il est préférable d'éviter QQuickView pour d'autres raisons, QQmlEngine peut être construit directement. Dans ce cas, application.qml est chargé en tant qu'instance de QQmlComponent au lieu d'être placé dans une vue :

#include <QGuiApplication>
#include <QQmlEngine>
#include <QQmlContext>
#include <QQmlComponent>

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);

    QQmlEngine engine;
    QQmlContext *objectContext = new QQmlContext(engine.rootContext());

    QQmlComponent component(&engine, "application.qml");
    QObject *object = component.create(objectContext);

    // ... delete object and objectContext when necessary

    return app.exec();
}

Si vous n'utilisez aucun élément graphique de Qt Quick, vous pouvez remplacer QGuiApplication par QCoreApplication dans le code ci-dessus. De cette manière, vous pouvez utiliser QML en tant que langage sans dépendre du module Qt GUI module.

Utilisation du système de ressources Qt avec QML

Le système de ressources Qt permet de stocker des fichiers de ressources sous forme de fichiers binaires dans l'exécutable d'une application. Le système de ressources Qt est utilisé pour les applications QML car il permet de faire référence aux fichiers QML et à d'autres ressources - telles que les images et les fichiers son - par le biais du schéma URI du système de ressources plutôt que par des chemins relatifs ou absolus vers les ressources du système de fichiers.

L'API du module QML de CMake place automatiquement vos fichiers QML dans le système de ressources. Pour y accéder, chargez votre fichier QML principal en tant que ressource ou en tant qu'URL avec le schéma qrc. Le chemin dans le système de ressources où vos fichiers QML sont placés peut être trouvé en concaténant :

• le RESOURCE_PREFIX que vous avez passé à qt_add_qml_module.
• /qt/qmlsi vous n'avez pas passé RESOURCE_PREFIX à qt_add_qml_module et que la politique QTP0001 est définie sur NEW.
• /Si vous n'avez pas passé RESOURCE_PREFIX à qt_add_qml_module et que la politique de QTP0001 est not fixée à NEW.
• Si vous n'avez pas passé NO_RESOURCE_TARGET_PATH à qt_add_qml_module: le URI que vous avez passé à qt_add_qml_module avec des points remplacés par des barres obliques.

Par exemple, un module appelé My.Own.Module est placé à l'adresse :

• :/qt/qml/My/Own/Module/ si vous avez spécifié /qt/qml comme RESOURCE_PREFIX, ou si vous n'avez pas transmis RESOURCE_PREFIX et que la politique de QTP0001 est définie sur NEW.
• :/My/Own/Module/ si vous avez spécifié / comme RESOURCE_PREFIX, ou si vous n'avez pas réussi RESOURCE_PREFIX et que la politique QTP0001 n' est pas définie sur NEW. }
• :/Some/Prefix/My/Own/Module/ si vous avez spécifié Some/Prefix/ comme RESOURCE_PREFIX
• :/ si vous avez spécifié NO_RESOURCE_TARGET_PATH

Une fois cette opération effectuée, tous les fichiers spécifiés par des chemins relatifs dans QML sont chargés à partir du système de ressources. L'utilisation du système de ressources est totalement transparente pour la couche QML ; cela signifie que tout le code QML doit se référer aux fichiers de ressources en utilisant des chemins relatifs et ne doit pas utiliser le schéma qrc. Ce schéma ne doit être utilisé que dans le code C++ pour faire référence aux fichiers de ressources.

Informations connexes

• Déploiement des applications Qt
• Qt Creator: Exécuter sur de nombreuses plateformes
• Exposer les attributs des types C++ à QML
• Le système de ressources Qt