Qt para macOS - Despliegue

Este documento describe cómo crear un paquete para macOS y asegurarse de que la aplicación encuentra los recursos que necesita en tiempo de ejecución. Demostramos los procedimientos en términos de despliegue de la aplicación de ejemplo Plug & Paint que viene con el paquete fuente de Qt.

Los instaladores de Qt para macOS incluyen una herramienta de despliegue que automatiza los procedimientos descritos aquí.

El paquete

En macOS, una aplicación GUI debe ser construida y ejecutada desde un bundle, que es una estructura de directorios que aparece como una sola entidad cuando se ve en el Finder. Un bundle para una aplicación suele contener el ejecutable y todos los recursos que necesita. A continuación se muestra una instantánea de la estructura de un bundle de una aplicación:

El bundle proporciona muchas ventajas al usuario:

• Es fácil de instalar, ya que se identifica como una entidad única.
• La información sobre un bundle es accesible desde el código.

Esto es específico de macOS y va más allá del alcance de este documento. Para obtener más información sobre los paquetes, consulte el sitio web para desarrolladores de Apple.

Para compilar su aplicación como un paquete con CMake, establezca la propiedad MACOSX_BUNDLE en tu objetivo ejecutable:

set_target_properties(plugandpaint PROPERTIES
    MACOSX_BUNDLE TRUE
)

qmake genera automáticamente un bundle para tu aplicación. Para desactivar esto, añada la siguiente declaración al archivo de proyecto de su aplicación (.pro):

CONFIG-=app_bundle

Enlace estático

Si quieres mantener las cosas simples y sólo tienes unos pocos archivos para desplegar, puedes construir tu aplicación con librerías enlazadas estáticamente.

Construir Qt estáticamente

Empieza instalando una versión estática de la librería Qt. Recuerda que no puedes usar plugins y que debes construir las librerías dependientes como formatos de imagen, controladores SQL, etc. con enlazado estático.

cd /path/to/Qt
./configure -static <other parameters>

Puede comprobar las distintas opciones disponibles ejecutando configure -help.

Vinculación de la aplicación a la versión estática de Qt

Una vez que Qt se ha compilado estáticamente, el siguiente paso es regenerar los archivos de compilación y reconstruir la aplicación.

Usando CMake

Asegúrate de usar el comando wrapper qt_add_executable, que proporciona lógica adicional como enlazar plugins de Qt en construcciones estáticas de Qt.

Para construir para plataformas Apple necesitas configurar cmake_minimum_required() a 3.21.1 o más reciente:

cmake_minimum_required(VERSION 3.21.1)

Vaya al directorio que contiene la aplicación:

cd /path/to/Qt/examples/widgets/tools/plugandpaint/app

A continuación, configure la variable CMAKE_PREFIX_PATH para que apunte al prefijo de su instalación. Si ya tienes una compilación Cmake, borra el archivo CMakeCache.txt. A continuación, vuelva a ejecutar CMake:

cmake -DCMAKE_PREFIX_PATH=path/to/Qt/6.11.0/your_platform -S <source-dir> -B <build-dir> -G Ninja

Alternativamente, utilice el script qt-cmake, que establece la variable CMAKE_PREFIX_PATH por usted.

path/to/Qt/6.11.0/your_platform/bin/qt-cmake -S <source-dir> -B <build-dir> -G Ninja

Por último, vaya a su directorio de compilación y ejecute su sistema de compilación preferido. En este ejemplo, estamos usando Ninja.

cd path/to/build/dir
ninja

Ahora, siempre que todo se haya compilado y enlazado sin errores, deberías tener un paquete plugandpaint.app listo para su despliegue. Pruebe a instalar el paquete en una máquina que ejecute macOS y que no tenga Qt ni ninguna aplicación Qt instalada.

Usando qmake

En primer lugar, vaya al directorio que contiene la aplicación:

cd /path/to/Qt/examples/widgets/tools/plugandpaint/app

A continuación, ejecute qmake para crear un nuevo makefile para la aplicación, y hacer una construcción limpia para crear el ejecutable enlazado estáticamente:

make clean
qmake -config release
make

Probablemente quieras enlazar contra las librerías de lanzamiento, y puedes especificarlo cuando invoques qmake. Puede que quieras aprovechar la "eliminación de código muerto" para reducir aún más el tamaño de tu binario. Puede hacerlo pasando LIBS+= -dead_strip a qmake además del parámetro -config release.

De nuevo, siempre que todo haya compilado y enlazado sin errores, deberías tener un bundle plugandpaint.app listo para su despliegue. Prueba a instalar el paquete en una máquina que ejecute macOS y que no tenga Qt ni ninguna aplicación Qt instalada.

Comprobación de las bibliotecas enlazadas

Puedes comprobar con qué otras bibliotecas está enlazada tu aplicación usando otool:

otool -L plugandpaint.app/Contents/MacOs/plugandpaint

Este es el resultado para Plug & Paint enlazado estáticamente:

plugandpaint.app/Contents/MacOS/plugandpaint:
/System/Library/Frameworks/Carbon.framework/Versions/A/Carbon
        (compatibility version 2.0.0, current version 128.0.0)
/System/Library/Frameworks/QuickTime.framework/Versions/A/QuickTime
        (compatibility version 1.0.0, current version 10.0.0)
/usr/lib/libz.1.dylib
        (compatibility version 1.0.0, current version 1.2.3)
/System/Library/Frameworks/ApplicationServices.framework/Versions/A/ApplicationServices
        (compatibility version 1.0.0, current version 22.0.0)
/usr/lib/libstdc++.6.dylib
        (compatibility version 7.0.0, current version 7.3.0)
/usr/lib/libgcc_s.1.dylib
        (compatibility version 1.0.0, current version 1.0.0)
/usr/lib/libmx.A.dylib
        (compatibility version 1.0.0, current version 92.0.0)
/usr/lib/libSystem.B.dylib
        (compatibility version 1.0.0, current version 88.0.0)

Si ves bibliotecas Qt en la salida, probablemente significa que tienes tanto bibliotecas dinámicas como estáticas Qt instaladas en tu máquina. El enlazador siempre elige el enlazado dinámico sobre el estático. Si quieres usar sólo librerías estáticas, puedes

• mover tus librerías dinámicas Qt (.dylibs) a otro directorio mientras enlazas la aplicación y luego volver a moverlas,
• o editar el Makefile y reemplazar las líneas de enlace para las librerías Qt con la ruta absoluta a las librerías estáticas.

Por ejemplo, sustituya

-lQtGui

por esto:

/where/static/qt/lib/is/libQtGui.a

El ejemplo Plug & Paint consta de varios componentes: El núcleo de la aplicación(Plug & Paint), y los plugins Basic Tools y Extra Filters. Como no podemos desplegar plugins utilizando el enfoque de enlace estático, el paquete que hemos preparado hasta ahora está incompleto. La aplicación se ejecutará, pero la funcionalidad estará deshabilitada debido a los plugins que faltan. Para desplegar aplicaciones basadas en plugins debemos utilizar el enfoque de framework, que es específico de macOS.

Frameworks

En este enfoque, hay que asegurarse de que el tiempo de ejecución de Qt se redistribuye correctamente con el paquete de la aplicación, y de que los plugins se instalan en la ubicación correcta para que la aplicación los encuentre.

Hay dos maneras de distribuir Qt con su aplicación en el enfoque de frameworks:

• Framework privado dentro del paquete de la aplicación.
• Framework estándar (alternativamente usar los frameworks de Qt en el binario instalado).

La primera opción es buena si tienes Qt construido de una manera especial, o quieres asegurarte de que el framework está ahí. Todo se reduce a dónde colocar los frameworks Qt.

La segunda opción es buena si tienes muchas aplicaciones Qt y quieres que usen un único framework Qt en lugar de múltiples versiones del mismo.

Construyendo Qt como Frameworks

Asumimos que ya ha instalado Qt como frameworks, que es el valor por defecto al instalar Qt, en el directorio /ruta/a/Qt. Para más información sobre cómo construir Qt sin Frameworks, visita la documentación Qt para macOS - Cuestiones específicas.

Al instalar, se establece el nombre de identificación de los frameworks. Este nombre es utilizado por el enlazador dinámico (dyld) para encontrar las bibliotecas para su aplicación.

Enlazar la aplicación con Qt como frameworks

Después de construir Qt como frameworks, podemos construir la aplicación Plug & Paint.

Usando CMake

Para construir para plataformas Apple necesitas configurar cmake_minimum_required() a 3.21.1 o más reciente:

cmake_minimum_required(VERSION 3.21.1)

Entra en el directorio que contiene la aplicación:

cd /path/to/Qt/examples/widgets/tools/plugandpaint/app

A continuación, establece la variable CMAKE_PREFIX_PATH para que apunte al prefijo de tu instalación. Si ya tienes una compilación Cmake, borra el archivo CMakeCache.txt. A continuación, vuelva a ejecutar CMake:

cmake -DCMAKE_PREFIX_PATH=path/to/Qt/6.11.0/your_platform -S <source-dir> -B <build-dir> -G Ninja

Alternativamente, utilice el script qt-cmake, que establece la variable CMAKE_PREFIX_PATH por usted.

path/to/Qt/6.11.0/your_platform/bin/qt-cmake -S <source-dir> -B <build-dir> -G Ninja

Por último, vaya a su directorio de compilación y ejecute su sistema de compilación preferido. En este ejemplo, estamos usando Ninja.

cd path/to/build/dir
ninja

Ahora, siempre que todo se haya compilado y enlazado sin errores, deberías tener un paquete plugandpaint.app listo para su despliegue. Pruebe a instalar el paquete en una máquina que ejecute macOS y que no tenga Qt ni ninguna aplicación Qt instalada.

Usando qmake

En primer lugar, vaya al directorio que contiene la aplicación:

cd /path/to/Qt/examples/widgets/tools/plugandpaint/app

Ejecutar qmake para crear un nuevo makefile para la aplicación, y hacer una construcción limpia para crear el ejecutable enlazado dinámicamente:

make clean
qmake -config release
make

Esto construye el núcleo de la aplicación. Usa lo siguiente para construir los plugins:

cd ../plugandpaint/plugins
make clean
qmake -config release
make

Ahora ejecuta el otool para los frameworks Qt, por ejemplo Qt Gui:

otool -L QtGui.framework/QtGui

Obtendrás la siguiente salida:

QtGui.framework/QtGui:
/path/to/Qt/lib/QtGui.framework/Versions/4.0/QtGui
        (compatibility version 4.0.0, current version 4.0.1)
/System/Library/Frameworks/Carbon.framework/Versions/A/Carbon
        (compatibility version 2.0.0, current version 128.0.0)
/System/Library/Frameworks/QuickTime.framework/Versions/A/QuickTime
        (compatibility version 1.0.0, current version 10.0.0)
/path/to/Qt/QtCore.framework/Versions/4.0/QtCore
        (compatibility version 4.0.0, current version 4.0.1)
/usr/lib/libz.1.dylib
        (compatibility version 1.0.0, current version 1.2.3)
/System/Library/Frameworks/ApplicationServices.framework/Versions/A/ApplicationServices
        (compatibility version 1.0.0, current version 22.0.0)
/usr/lib/libstdc++.6.dylib
        (compatibility version 7.0.0, current version 7.3.0)
/usr/lib/libgcc_s.1.dylib
        (compatibility version 1.0.0, current version 1.0.0)
/usr/lib/libmx.A.dylib
        (compatibility version 1.0.0, current version 92.0.0)
/usr/lib/libSystem.B.dylib
        (compatibility version 1.0.0, current version 88.0.0)

Para los frameworks Qt, la primera línea (i.e. path/to/Qt/lib/QtGui.framework/Versions/4/QtGui (compatibility version 4.0.0, current version 4.0.1)) se convierte en el nombre de identificación del framework que es usado por el enlazador dinámico (dyld).

Pero cuando estés desplegando la aplicación, puede que tus usuarios no tengan los frameworks Qt instalados en la ubicación especificada. Por esa razón, debes proporcionar los frameworks en una ubicación acordada, o almacenar los frameworks en el bundle. Independientemente de la solución que elijas, debes asegurarte de que los frameworks devuelven el nombre de identificación adecuado para sí mismos, y que la aplicación busca estos nombres. Por suerte, podemos controlar esto con la herramienta de línea de comandos install_name_tool.

install_name_tool funciona en dos modos, -id y -change. El modo -id es para bibliotecas y frameworks, y nos permite especificar un nuevo nombre de identificación. Usamos el modo -change para cambiar las rutas en la aplicación.

Probemos esto copiando los frameworks Qt en el paquete Plug & Paint. Mirando en otool's output for the bundle, podemos ver que debemos copiar ambos frameworks QtCore y QtGui en el bundle. Asumiremos que estamos en el directorio donde construimos el bundle.

mkdir plugandpaint.app/Contents/Frameworks
cp -R /path/to/Qt/lib/QtCore.framework
        plugandpaint.app/Contents/Frameworks
cp -R /path/to/Qt/lib/QtGui.framework
       plugandpaint.app/Contents/Frameworks

Primero creamos un directorio Frameworks dentro del bundle. Esto sigue la convención de aplicaciones de macOS. A continuación, copiamos los frameworks en el nuevo directorio. Como los frameworks contienen enlaces simbólicos, utilizamos la opción -R.

install_name_tool -id @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore
       plugandpaint.app/Contents/Frameworks/QtCore.framework/Versions/4.0/QtCore
install_name_tool -id @executable_path/../Frameworks/QtGui.framework/Versions/4.0/QtGui
       plugandpaint.app/Contents/Frameworks/QtGui.framework/Versions/4.0/QtGui

A continuación, ejecutamos install_name_tool para establecer los nombres de identificación de los frameworks. El primer argumento después de -id es el nuevo nombre, y el segundo argumento es el framework que queremos renombrar. El texto @executable_path es una variable especial de dyld que indica a dyld que empiece a buscar dónde se encuentra el ejecutable. Los nuevos nombres especifican que estos frameworks se encuentran en el directorio directamente debajo del directorio Frameworks.

install_name_tool -change path/to/Qt/lib/QtCore.framework/Versions/4.0/QtCore
        @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore
        plugandpaint.app/Contents/MacOs/plugandpaint
install_name_tool -change path/to/qt/lib/QtGui.framework/Versions/4.0/QtGui
        @executable_path/../Frameworks/QtGui.framework/Versions/4.0/QtGui
        plugandpaint.app/Contents/MacOs/plugandpaint

Ahora, el enlazador dinámico sabe dónde buscar QtCore y QtGui. Debemos asegurarnos de que la aplicación también sabe dónde encontrar la biblioteca, utilizando el modo install_name_tool's -change. Esto se reduce básicamente a la sustitución de cadenas, para que coincidan los nombres de identificación que establecimos anteriormente con los frameworks.

Finalmente, el framework QtGui depende de QtCore, así que debemos recordar cambiar la referencia para QtGui:

install_name_tool -change path/to/Qt/lib/QtCore.framework/Versions/4.0/QtCore
        @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore
        plugandpaint.app/Contents/Frameworks/QtGui.framework/Versions/4.0/QtGui

Después de esto, ejecutamos de nuevo otool y vemos que la aplicación puede encontrar las librerías.

Los plugins del ejemplo Plug & Paint lo hacen interesante. Los pasos básicos que debemos seguir con los plugins son:

• poner los plugins dentro del bundle,
• ejecutar el install_name_tool para comprobar si los plugins están usando la librería correcta,
• y asegurarse de que la aplicación sabe dónde buscar los plugins.

Podemos poner los plugins donde queramos en el bundle, pero la mejor ubicación es ponerlos en Contents/Plugins. Cuando construimos los plugins Plug & Paint, basándonos en la variable DESTDIR de su archivo .pro, los archivos .dylib de los plugins están en el subdirectorio plugins bajo el directorio plugandpaint. Sólo tenemos que mover este directorio a la ubicación correcta.

mv plugins plugandpaint.app/Contents

Por ejemplo, si ejecutamos otool en el archivo .dylib del plugin Basic Tools, obtendremos la siguiente información.

libpnp_basictools.dylib:
libpnp_basictools.dylib
       (compatibility version 0.0.0, current version 0.0.0)
/path/to/Qt/lib/QtGui.framework/Versions/4.0/QtGui
       (compatibility version 4.0.0, current version 4.0.1)
/System/Library/Frameworks/Carbon.framework/Versions/A/Carbon
       (compatibility version 2.0.0, current version 128.0.0)
/System/Library/Frameworks/QuickTime.framework/Versions/A/QuickTime
       (compatibility version 1.0.0, current version 10.0.0)
/path/to/Qt/lib/QtCore.framework/Versions/4.0/QtCore
       (compatibility version 4.0.0, current version 4.0.1)
/usr/lib/libz.1.dylib
       (compatibility version 1.0.0, current version 1.2.3)
/System/Library/Frameworks/ApplicationServices.framework/Versions/A/ApplicationServices
       (compatibility version 1.0.0, current version 22.0.0)
/usr/lib/libstdc++.6.dylib
       (compatibility version 7.0.0, current version 7.3.0)
/usr/lib/libgcc_s.1.dylib
       (compatibility version 1.0.0, current version 1.0.0)
/usr/lib/libmx.A.dylib
       (compatibility version 1.0.0, current version 92.0.0)
/usr/lib/libSystem.B.dylib
       (compatibility version 1.0.0, current version 88.0.0)

Entonces podemos ver que el plugin enlaza con los frameworks Qt con los que fue construido. Como queremos que los plugins usen el framework en el paquete de la aplicación, los cambiamos de la misma forma que hicimos para la aplicación. Por ejemplo para el plugin Basic Tools:

install_name_tool -change /path/to/Qt/lib/QtCore.framework/Versions/4.0/QtCore
        @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore
        plugandpaint.app/Contents/plugins/libpnp_basictools.dylib
install_name_tool -change /path/to/Qt/lib/QtGui.framework/Versions/4.0/QtGui
        @executable_path/../Frameworks/QtGui.framework/Versions/4.0/QtGui
        plugandpaint.app/Contents/plugins/libpnp_basictools.dylib

También debemos modificar el código en tools/plugandpaint/mainwindow.cpp a cdUp() para asegurar que la aplicación encuentra los plugins. Añade el siguiente código al archivo mainwindow.cpp:

#elif defined(Q_OS_MAC)
if (pluginsDir.dirName() == "MacOS") {
    pluginsDir.cdUp();
}
#endif

El código adicional en tools/plugandpaint/mainwindow.cpp también nos permite ver los plugins en el Finder, como se muestra en la imagen. También podemos añadir plugins extendiendo Qt, por ejemplo añadiendo controladores SQL o formatos de imagen. Sólo tenemos que seguir la estructura de directorios indicada en la documentación de los plugins, y asegurarnos de que están incluidos en QCoreApplication::libraryPaths(). Hagámoslo rápidamente con los formatos de imagen, siguiendo el procedimiento descrito anteriormente. Copia los plugins de formato de imagen de Qt en el bundle: cp -R /path/to/Qt/plugins/imageformats pluginandpaint.app/Contents/plugins Usa install_name_tool para enlazar los plugins a los frameworks del bundle: install_name_tool -change /path/to/Qt/lib/QtGui.framework/Versions/4.0/QtGui @executable_path/../Frameworks/QtGui.framework/Versions/4.0/QtGui plugandpaint.app/Contents/plugins/imageformats/libqjpeg.dylib install_name_tool -change /path/to/Qt/lib/QtCore.framework/Versions/4.0/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/4.0/QtCore plugandpaint.app/Contents/plugins/imageformats/libqjpeg.dylib Actualiza el código fuente en tools/plugandpaint/main.cpp para buscar los nuevos plugins. Después de construir el QApplication, añadimos el siguiente código: QDir dir(QCoreApplication::applicationDirPath()); dir.cdUp(); dir.cd("plugins"); QCoreApplication::setLibraryPaths(QStringList(dir.absolutePath())); Primero, le decimos a la aplicación que sólo busque plugins en este directorio. En nuestro caso, queremos que la aplicación busque sólo los plugins que distribuimos con el paquete. Si fuéramos parte de una instalación Qt más grande podríamos haber usado QCoreApplication::addLibraryPath() en su lugar.

Ahora deberías ser capaz de mover la aplicación a otra máquina macOS y ejecutarla sin Qt instalado. Alternativamente, puedes mover tus frameworks que viven fuera del bundle a otro directorio y ver si la aplicación aún se ejecuta.

Si almacenas los frameworks en otra ubicación fuera del bundle, la técnica de enlazar tu aplicación es similar; debes asegurarte de que la aplicación y los frameworks están de acuerdo en dónde buscar las librerías Qt así como los plugins.

Creación del paquete de la aplicación

Cuando hayas terminado de enlazar tu aplicación a Qt, ya sea estáticamente o como frameworks, la aplicación estará lista para ser distribuida. Para más información, consulte el sitio web para desarrolladores de Apple.

Aunque el proceso de distribución de una aplicación tiene algunos escollos, una vez que conozcas los distintos aspectos podrás crear fácilmente paquetes que disfrutarán todos tus usuarios de macOS.

Dependencias de la aplicación

Plugins Qt

Todas las aplicaciones Qt GUI requieren un plugin que implemente la capa Qt Platform Abstraction (QPA) en Qt. Para macOS, el nombre del plugin de plataforma es libqcocoa.dylib. Este archivo debe estar ubicado dentro de un subdirectorio específico (por defecto, platforms) bajo tu directorio de distribución. Alternativamente, es posible ajustar la ruta de búsqueda que Qt utiliza para encontrar sus plugins, como se describe a continuación.

Su aplicación también puede depender de uno o más plugins de Qt, como el plugin de formato de imagen JPEG o un plugin de controlador SQL. Asegúrese de distribuir cualquier plugin Qt que necesite con su aplicación. De forma similar al plugin de plataforma, cada tipo de plugin debe estar ubicado dentro de un subdirectorio específico (como imageformats o sqldrivers) en su directorio de distribución.

La ruta de búsqueda de los plugins de Qt (así como algunas otras rutas) está codificada en la biblioteca QtCore. Por defecto, la primera ruta de búsqueda de plugins estará codificada como /path/to/Qt/plugins. Pero usar rutas predeterminadas tiene ciertas desventajas. Por ejemplo, puede que no existan en la máquina de destino. Así que debes comprobar varias alternativas para asegurarte de que se encuentran los plugins de Qt:

• Utilizando qt.conf. Este es el enfoque recomendado ya que proporciona la mayor flexibilidad.
• Usando QApplication::addLibraryPath() o QApplication::setLibraryPaths().
• Utilizando una utilidad de instalación de terceros para cambiar las rutas codificadas en la biblioteca QtCore.

El documento How to Create Qt Plugins (Cómo crear plugins Qt ) describe los aspectos a los que hay que prestar atención cuando se crean y despliegan plugins para aplicaciones Qt.

Bibliotecas adicionales

Puede comprobar con qué bibliotecas está enlazando su aplicación utilizando otool. Ejecútelo con la ruta de la aplicación como argumento:

otool -L MyApp.app/Contents/MacOS/MyApp

Las librerías específicas del compilador raramente tienen que ser redistribuidas con tu aplicación. Pero hay varias maneras de desplegar aplicaciones, como Qt puede ser configurado, construido e instalado de varias maneras en macOS. Típicamente tus objetivos ayudan a determinar cómo vas a desplegar la aplicación. Las últimas secciones describen algunas cosas que debes tener en cuenta al desplegar tu aplicación.

La herramienta de despliegue de macOS

La herramienta de despliegue de macOS se encuentra en QTDIR/bin/macdeployqt. Está diseñada para automatizar el proceso de creación de un paquete de aplicación desplegable que contenga bibliotecas Qt como frameworks privados.

La herramienta de despliegue de macOS también despliega los plugins de Qt, de acuerdo con las siguientes reglas (a menos que se utilice la opción -no-plugins ):

• El plugin de plataforma siempre se despliega.
• Las versiones de depuración de los plugins no se despliegan.
• Los plugins de diseño no se despliegan.
• Los plugins de formato de imagen se despliegan siempre, excepto el plugin de formato de imagen SVG que sólo se despliega si la aplicación utiliza el módulo Qt SVG módulo.
• Los plugins del motor de iconos están siempre desplegados.
• El plugin de soporte de impresión se despliega siempre.
• Los plugins del controlador SQL se despliegan si la aplicación utiliza el módulo Qt SQL módulo.
• El plugin de accesibilidad se despliega siempre.
• El plugin de estilo se despliega siempre.

Para incluir una biblioteca de terceros en el paquete de la aplicación, copie la biblioteca en el paquete manualmente, después de crear el paquete.

macdeployqt admite las siguientes opciones:

Nombre del volumen

El nombre del volumen de una imagen de disco (el texto que aparece en el título de la ventana de un archivo .dmg abierto) creado con -dmg se basa en la ruta a la aplicación cuando se ejecuta macdeployqt. Por ejemplo, considere el siguiente comando que crea una imagen de disco para una aplicación Qt Quick:

macdeployqt /Users/foo/myapp-build/MyApp.app -qmldir=/Users/foo/myapp/qml -dmg

El nombre del volumen resultante será:

/Users/foo/myapp-build/MyApp.app

Para asegurarse de que el nombre del volumen sólo contiene el nombre de la aplicación y no la ruta en la máquina de despliegue, ejecute macdeployqt en el mismo directorio:

cd /Users/foo/myapp-build
macdeployqt MyApp.app -qmldir=/Users/foo/myapp/qml -dmg

El nombre del volumen resultante será:

MyApp.app

Derechos

Al firmar, macdeployqt utilizará automáticamente el primer archivo .entitlements que encuentre en el subdirectorio Contents/Resources/ del paquete de la aplicación, si está presente. Para evitar errores, asegúrese de que hay como máximo un archivo .entitlements en esta carpeta.