Despliegue de aplicaciones QML

Los documentos QML se cargan y ejecutan mediante el motor QML Runtime. Esto incluye el motor Declarative UI junto con los tipos QML incorporados y los módulos plugin. El tiempo de ejecución de QML también proporciona acceso a tipos y módulos QML de terceros.

Las aplicaciones que utilizan QML deben invocar el tiempo de ejecución de QML para ejecutar documentos QML. Puede hacerlo creando un QQuickView o un QQmlEngine, como se describe a continuación. Además, el paquete Declarative UI incluye la herramienta qml, que carga archivos .qml. Esta herramienta es útil para desarrollar y probar código QML sin tener que escribir una aplicación C++ para cargar el tiempo de ejecución QML.

Despliegue de aplicaciones con Qt Creator

Qt Creator despliega y empaqueta aplicaciones QML en varias plataformas. Para dispositivos móviles, Qt Creator puede empaquetar directamente las aplicaciones en los formatos de paquete de la plataforma correspondiente, como APK.

Cuando ejecutas tus aplicaciones en la plataforma de destino, tu aplicación necesita acceder a la ubicación de las bibliotecas QML. Si utilizas qmake, la variable de entorno QT_INSTALL_QML apunta a la ubicación de las bibliotecas. Los instaladores de Qt instalan las librerías QML en: <version>/<compiler>/qml directorio.

Almacenamiento en caché de QML

El QML Runtime carga los documentos QML analizándolos y generando código de bytes. La mayoría de las veces, el documento no ha cambiado desde la última vez que se cargó. Para acelerar este proceso de carga, el motor de ejecución de QML mantiene un archivo de caché para cada documento QML. Este archivo caché contiene el código de bytes compilado y una representación binaria de la estructura del documento QML. Además, cuando varias aplicaciones utilizan el mismo documento QML, la memoria necesaria para el código se comparte entre los procesos de la aplicación. Los archivos de caché se cargan mediante la llamada al sistema mmap() en los sistemas operativos compatibles con POSIX o CreateFileMapping() en Windows, lo que supone un importante ahorro de memoria.

Cada vez que se carga un documento QML modificado, la caché se vuelve a crear automáticamente. Los archivos de caché se encuentran en un subdirectorio de QStandardPaths::CacheLocation con el nombre "qmlcache". La extensión del archivo es .qmlc para los documentos QML y .jsc para los módulos JavaScript importados.

Compilación anticipada

El almacenamiento automático en caché de los documentos QML compilados en archivos de caché acelera considerablemente el tiempo de carga de la aplicación. Sin embargo, la creación inicial de los archivos de caché puede llevar tiempo, especialmente cuando la aplicación se inicia por primera vez. Para evitar ese paso inicial y proporcionar tiempos de arranque más rápidos desde el principio, el sistema de compilación de Qt permite realizar el paso de compilación de los archivos QML con antelación, al compilar las partes C++ de la aplicación.

Una ventaja de la compilación anticipada es que, en caso de errores de sintaxis en tus documentos QML, se te notificará en el momento de la compilación de la aplicación en lugar de en el momento de la ejecución, cuando se cargue el archivo.

Esto ocurrirá automáticamente si utilizas la API CMake QML Module, para qmake ver la sección de abajo.

qmake

Cuando se utiliza qmake, con el fin de desplegar su aplicación con archivos QML compilados de antemano, debe organizar los archivos y el sistema de construcción de una manera específica:

• Todos los documentos QML (incluidos los archivos JavaScript) deben incluirse como recursos a través del sistema de recursos de Qt.
• Su aplicación debe cargar los documentos QML a través del esquema de URL qrc:///.
• Puede activar la compilación Ahead-of-Time mediante la directiva CONFIG+=qtquickcompiler.

Creación de prototipos con QML Scene

El paquete Declarative UI incluye una herramienta QML Runtime, qml, que carga y muestra documentos QML. Esto resulta útil durante la fase de desarrollo de la aplicación para crear prototipos de aplicaciones basadas en QML sin tener que escribir sus propias aplicaciones C++ para invocar el tiempo de ejecución de QML.

Inicialización de QML Runtime en las aplicaciones

Para ejecutar una aplicación que utiliza QML, la aplicación debe invocar el tiempo de ejecución de QML. Esto se hace escribiendo una aplicación Qt C++ que cargue el QQmlEngine mediante:

• Cargando el archivo QML a través de una instancia de QQuickView.
• Creando una instancia QQmlEngine y cargando los archivos QML con QQmlComponent.

Inicializando con QQuickView

QQuickView es una clase basada en QWindow que puede cargar archivos QML. Por ejemplo, si hay un archivo QML, application.qml, se verá así:

import QtQuick

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

Se puede cargar en el archivo main.cpp de una aplicación Qt de la siguiente manera:

#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();
}

Esto crea una vista basada en QWindow que muestra el contenido de application.qml.

Construir archivos

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

QT += quick

Crear un QQmlEngine directamente

Si application.qml no tiene ningún componente gráfico, o si se prefiere evitar QQuickView por otras razones, se puede construir directamente QQmlEngine en su lugar. En este caso, application.qml se carga como una instancia de QQmlComponent en lugar de colocarse en una vista:

#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 no va a utilizar ningún elemento gráfico de Qt Quick, puede sustituir QGuiApplication por QCoreApplication en el código anterior. De esta forma, puedes utilizar QML como lenguaje sin dependencias del módulo Qt GUI módulo.

Uso del sistema de recursos de Qt con QML

El sistema de recursos Qt permite almacenar archivos de recursos como archivos binarios en el ejecutable de una aplicación. El sistema de recursos Qt se utiliza para la aplicación QML, ya que permite hacer referencia a los archivos QML y a otros recursos -como imágenes y archivos de sonido- mediante el esquema URI del sistema de recursos, en lugar de mediante rutas relativas o absolutas a los recursos del sistema de archivos.

La API de módulos QML de CMake coloca automáticamente los archivos QML en el sistema de recursos. Para acceder a ellos, cargue su archivo QML principal como recurso o como URL con el esquema qrc. La ruta en el sistema de recursos donde se colocan sus archivos QML se puede encontrar mediante la concatenación de:

• el RESOURCE_PREFIX que has pasado a qt_add_qml_module.
• /qt/qml, si no ha pasado RESOURCE_PREFIX a qt_add_qml_module y la política QTP0001 está establecida en NEW.
• /, si no ha pasado RESOURCE_PREFIX a qt_add_qml_module y la política de QTP0001 es not se establece en NEW.
• Si no ha pasado NO_RESOURCE_TARGET_PATH a qt_add_qml_module: el URI que ha pasado a qt_add_qml_module con puntos sustituidos por barras.

Por ejemplo, un módulo llamado My.Own.Module se coloca en:

• :/qt/qml/My/Own/Module/ si ha especificado /qt/qml como RESOURCE_PREFIX, o no ha pasado RESOURCE_PREFIX y la política QTP0001 se establece en NEW.
• :/My/Own/Module/ si ha especificado / como RESOURCE_PREFIX, o no ha pasado RESOURCE_PREFIX y la política QTP0001 no está establecida en NEW. }
• :/Some/Prefix/My/Own/Module/ si ha especificado Some/Prefix/ como RESOURCE_PREFIX
• :/ si ha especificado NO_RESOURCE_TARGET_PATH

Una vez hecho esto, todos los archivos especificados por rutas relativas en QML se cargan desde el sistema de recursos. El uso del sistema de recursos es completamente transparente para la capa QML; esto significa que todo el código QML debe referirse a los archivos de recursos utilizando rutas relativas y no debe utilizar el esquema qrc. Este esquema sólo debe utilizarse desde código C++ para referirse a archivos de recursos.

Información relacionada

• Desplegando Aplicaciones Qt
• Qt Creator: Ejecutar en muchas plataformas
• Exponer Atributos de Tipos C++ a QML
• El sistema de recursos Qt