Qt para macOS: implementación
Este documento describe cómo crear un paquete para macOS y asegurarse de que la aplicación encuentre los recursos que necesita en tiempo de ejecución. Mostramos los procedimientos mediante la implementación de la aplicación de ejemplo Plug & Paint que se incluye con el paquete fuente de Qt.
Los instaladores de Qt para macOS incluyen una herramienta de implementación que automatiza los procedimientos descritos aquí.
El paquete
En macOS, una aplicación con interfaz gráfica de usuario debe compilarse y ejecutarse desde un paquete, que es una estructura de directorios que aparece como una única entidad cuando se visualiza en el Finder. Un paquete de 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 paquete de aplicación:

El paquete ofrece numerosas ventajas al usuario:
- Es fácil de instalar, ya que se identifica como una única entidad.
- Se puede acceder a la información sobre un paquete desde el código.
Esto es específico de macOS y queda fuera del alcance de este documento. Para obtener más información sobre los paquetes, consulta el sitio web para desarrolladores de Apple.
Para compilar tu aplicación como un paquete con CMake, configura la MACOSX_BUNDLE propiedad en tu objetivo ejecutable:
set_target_properties(plugandpaint PROPERTIES
MACOSX_BUNDLE TRUE
)qmake genera automáticamente un paquete para su aplicación. Para desactivar esta opción, añada la siguiente instrucción al archivo de proyecto de su aplicación (.pro):
CONFIG-=app_bundleEnlazado estático
Si quieres simplificar las cosas y solo tienes unos pocos archivos que implementar, puedes compilar tu aplicación con bibliotecas enlazadas estáticamente.
Compilación estática de Qt
Empieza por instalar una versión estática de la biblioteca Qt. Recuerda que no podrás utilizar complementos y que deberás compilar las bibliotecas dependientes, como los formatos de imagen, los controladores SQL, etc., con enlace estático.
cd /path/to/Qt
./configure -static <other parameters>Puedes consultar las distintas opciones disponibles ejecutando configure -help.
Enlazando la aplicación a la versión estática de Qt
Una vez compilado Qt de forma estática, el siguiente paso es regenerar los archivos de compilación y volver a compilar la aplicación.
Uso de CMake
Asegúrate de utilizar el comando envoltorio qt_add_executable, que proporciona lógica adicional, como la vinculación de complementos de Qt en compilaciones estáticas de Qt.
Para compilar para plataformas de Apple, debes establecer cmake_minimum_required() en 3.21.1 o una versión posterior:
cmake_minimum_required(VERSION 3.21.1)Accede al directorio que contiene la aplicación:
cd /path/to/Qt/examples/widgets/tools/plugandpaint/appA continuación, configura la variable ` CMAKE_PREFIX_PATH ` para que apunte a tu prefijo de instalación. Si ya tienes una compilación de CMake, elimina el archivo ` CMakeCache.txt `. Después, vuelve a ejecutar CMake:
cmake -DCMAKE_PREFIX_PATH=path/to/Qt/6.12.0/your_platform -S <source-dir> -B <build-dir> -G NinjaComo alternativa, utiliza el script de ayuda qt-cmake, que configura la variable CMAKE_PREFIX_PATH por ti.
path/to/Qt/6.12.0/your_platform/bin/qt-cmake -S <source-dir> -B <build-dir> -G NinjaPor último, ve al directorio de compilación y ejecuta tu sistema de compilación preferido. En este ejemplo, utilizamos Ninja.
cd path/to/build/dir
ninjaAhora, siempre que todo se haya compilado y enlazado sin errores, deberías tener un paquete plugandpaint.app listo para su implementación. Intenta instalar el paquete en un equipo con macOS que no tenga instalado Qt ni ninguna aplicación de Qt.
Uso de qmake
En primer lugar, ve al directorio que contiene la aplicación:
cd /path/to/Qt/examples/widgets/tools/plugandpaint/appA continuación, ejecuta qmake para crear un nuevo archivo makefile para la aplicación y realiza una compilación limpia para crear el ejecutable enlazado estáticamente:
make clean
qmake -config release
makeProbablemente querrás vincularlo con las bibliotecas de versión final, y puedes especificarlo al ejecutar ` qmake`. Quizás te interese aprovechar la «eliminación de código muerto» para reducir aún más el tamaño de tu binario. Puedes hacerlo pasando ` LIBS+= -dead_strip ` a ` qmake `, además del parámetro ` -config release `.
De nuevo, siempre que todo se haya compilado y enlazado sin errores, deberías tener un paquete plugandpaint.app listo para su implementación. Intenta instalar el paquete en un equipo con macOS que no tenga instalado Qt ni ninguna aplicación de Qt.
Comprobación de las bibliotecas enlazadas
Puedes comprobar a qué otras bibliotecas está enlazada tu aplicación utilizando el comando otool:
otool -L plugandpaint.app/Contents/MacOs/plugandpaintEste es el aspecto que tiene la salida para Plug & Paint enlazado de forma estática:
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 de Qt en el resultado, probablemente significa que tienes instaladas en tu equipo tanto bibliotecas dinámicas como estáticas de Qt. El enlazador siempre da prioridad a la vinculación dinámica frente a la estática. Si quieres utilizar únicamente bibliotecas estáticas, puedes:
- trasladar las bibliotecas dinámicas de Qt (
.dylibs) a otro directorio mientras enlazas la aplicación y, a continuación, volver a colocarlas en su sitio, - o editar el archivo `
Makefile` y sustituir las líneas de enlace de las bibliotecas Qt por la ruta absoluta a las bibliotecas estáticas.
Por ejemplo, sustituye lo siguiente:
-lQtGuipor esto:
/where/static/qt/lib/is/libQtGui.aEl ejemplo «Plug & Paint» consta de varios componentes: la aplicación principal (Plug & Paint) y los complementos «Basic Tools » y «Extra Filters ». Como no podemos implementar complementos 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á desactivada debido a la falta de complementos. Para implementar aplicaciones basadas en complementos, debemos utilizar el enfoque de marcos de trabajo, que es específico de macOS.
Frameworks
En este enfoque, asegúrate de que el tiempo de ejecución de Qt se redistribuya correctamente con el paquete de la aplicación y de que los complementos se instalen en la ubicación correcta para que la aplicación pueda encontrarlos.
Hay dos formas de distribuir Qt con tu aplicación en el enfoque de marcos:
- Marco privado dentro del paquete de su aplicación.
- Marco estándar (como alternativa, utiliza los marcos de Qt del binario instalado).
La primera opción es adecuada si tienes Qt compilado de una forma especial o si quieres asegurarte de que el marco esté presente. Todo se reduce a dónde coloques los marcos de Qt.
La segunda opción es adecuada si tienes muchas aplicaciones Qt y quieres que utilicen un único marco de trabajo Qt en lugar de varias versiones del mismo.
Compilación de Qt como marcos
Suponemos que ya tienes instalado Qt como marcos de trabajo —que es la opción predeterminada al instalar Qt— en el directorio /path/to/Qt. Para obtener más información sobre cómo compilar Qt sin marcos de trabajo, consulta la documentación «Qt para macOS: problemas específicos ».
Durante la instalación, se establece el nombre de identificación de los marcos. El enlazador dinámico (dyld) utiliza este nombre para encontrar las bibliotecas de tu aplicación.
Enlazado de la aplicación a Qt como marcos
Tras compilar Qt como marcos, podemos compilar la aplicación Plug & Paint.
Uso de CMake
Para compilar para plataformas de Apple, es necesario establecer ` cmake_minimum_required() ` en 3.21.1 o una versión posterior:
cmake_minimum_required(VERSION 3.21.1)Accede al directorio que contiene la aplicación:
cd /path/to/Qt/examples/widgets/tools/plugandpaint/appA continuación, configura la variable ` CMAKE_PREFIX_PATH ` para que apunte a tu prefijo de instalación. Si ya tienes una compilación de CMake, elimina el archivo ` CMakeCache.txt `. Después, vuelve a ejecutar CMake:
cmake -DCMAKE_PREFIX_PATH=path/to/Qt/6.12.0/your_platform -S <source-dir> -B <build-dir> -G NinjaComo alternativa, utiliza el script de ayuda qt-cmake, que configura la variable CMAKE_PREFIX_PATH por ti.
path/to/Qt/6.12.0/your_platform/bin/qt-cmake -S <source-dir> -B <build-dir> -G NinjaPor último, ve al directorio de compilación y ejecuta tu sistema de compilación preferido. En este ejemplo, utilizamos Ninja.
cd path/to/build/dir
ninjaAhora, siempre que todo se haya compilado y enlazado sin errores, deberías tener un paquete plugandpaint.app listo para su implementación. Intenta instalar el paquete en un equipo con macOS que no tenga instalado Qt ni ninguna aplicación de Qt.
Uso de qmake
En primer lugar, accede al directorio que contiene la aplicación:
cd /path/to/Qt/examples/widgets/tools/plugandpaint/appEjecuta qmake para crear un nuevo archivo makefile para la aplicación y realiza una compilación limpia para crear el ejecutable enlazado dinámicamente:
make clean
qmake -config release
makeEsto compila la aplicación principal. Utiliza lo siguiente para compilar los complementos:
cd ../plugandpaint/plugins
make clean
qmake -config release
makeAhora ejecuta « otool » para los marcos de trabajo de Qt, por ejemplo, Qt GUI:
Obtendrás el siguiente resultado:
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)En el caso de los marcos de trabajo de Qt, la primera línea (es decir, « 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 marco de trabajo que utiliza el enlazador dinámico (dyld).
Sin embargo, al implementar la aplicación, es posible que los usuarios no tengan los marcos de trabajo de Qt instalados en la ubicación especificada. Por ese motivo, debes proporcionar los marcos de trabajo en una ubicación acordada o almacenarlos en el paquete. Independientemente de la solución que elijas, debes asegurarte de que los marcos devuelvan el nombre de identificación adecuado para sí mismos y de que la aplicación busque estos nombres. Afortunadamente, 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 » está destinado a bibliotecas y marcos de trabajo, y nos permite especificar un nuevo nombre de identificación. Utilizamos el modo « -change » para cambiar las rutas en la aplicación.
Probemos esto copiando los marcos de trabajo de Qt en el paquete de Plug & Paint. Al consultar la salida de otool para el paquete, vemos que debemos copiar tanto los marcos de trabajo QtCore como los QtGui en el paquete. Supondremos que nos encontramos en el directorio donde compilamos el paquete.
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/FrameworksEn primer lugar, creamos un directorio Frameworks dentro del paquete. Esto sigue la convención de las aplicaciones de macOS. A continuación, copiamos los marcos de trabajo en el nuevo directorio. Como los marcos de trabajo 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/QtGuiA continuación, ejecutamos ` install_name_tool ` para establecer los nombres de identificación de los marcos. El primer argumento tras ` -id ` es el nuevo nombre, y el segundo argumento es el marco al que queremos cambiar el nombre. El texto ` @executable_path ` es una variable especial ` dyld ` que indica a ` dyld ` que comience a buscar en la ubicación donde se encuentra el ejecutable. Los nuevos nombres especifican que estos marcos se encuentran en el directorio situado 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/plugandpaintAhora, el enlazador dinámico sabe dónde buscar « QtCore » y « QtGui ». Debemos asegurarnos de que la aplicación también sepa dónde encontrar la biblioteca, utilizando el modo « -change » de « install_name_tool ». Básicamente, esto se reduce a una sustitución de cadenas, para hacer coincidir los nombres de identificación que hemos establecido anteriormente con los de los marcos de trabajo.
Por último, el marco QtGui depende de QtCore, por lo que debemos acordarnos de cambiar la referencia a 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/QtGuiTras esto, volvemos a ejecutar « otool » y comprobamos que la aplicación puede encontrar las bibliotecas.
Los complementos del ejemplo Plug & Paint lo hacen interesante. Los pasos básicos que debemos seguir con los complementos son:
- colocar los complementos dentro del paquete,
- ejecutar el comando `
install_name_tool` para comprobar si los complementos están utilizando la biblioteca correcta, - y asegurarnos de que la aplicación sepa dónde buscar los complementos.
Podemos colocar los complementos en cualquier lugar del paquete, pero la mejor ubicación es dentro de «Contents/Plugins». Cuando creamos los complementos de Plug & Paint, según la variable « DESTDIR » de su archivo « .pro », los archivos « .dylib » de los complementos se encuentran en el subdirectorio « plugins », dentro del directorio « plugandpaint ». Solo tenemos que mover este directorio a la ubicación correcta.
mv plugins plugandpaint.app/ContentsPor ejemplo, si ejecutamos otool en el archivo .dylib del complemento Basic Tools, obtenemos 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)Así podemos ver que el complemento está vinculado a los marcos de trabajo de Qt con los que se compiló. Como queremos que los complementos utilicen el marco de trabajo del paquete de la aplicación, los modificamos de la misma forma que hicimos con la aplicación. Por ejemplo, para el complemento «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.dylibTambién debemos modificar el código de tools/plugandpaint/mainwindow.cpp para que sea cdUp() y así garantizar que la aplicación encuentre los complementos. Añade el siguiente código al archivo mainwindow.cpp:
#elif defined(Q_OS_MACOS)
if (pluginsDir.dirName() == "MacOS") {
pluginsDir.cdUp();
}
#endif![]() | El código adicional de tools/plugandpaint/mainwindow.cpp también nos permite ver los complementos en el Finder, tal y como se muestra en la imagen.También podemos añadir complementos que amplíen Qt, por ejemplo, controladores SQL o formatos de imagen. Solo tenemos que seguir la estructura de directorios descrita en la documentación de los complementos y asegurarnos de que se incluyen en el archivo « QCoreApplication::libraryPaths » (). Hagámoslo rápidamente con los formatos de imagen, siguiendo el procedimiento descrito anteriormente. Copia los complementos de Qt Image Formats en el paquete: Utiliza Actualiza el código fuente de En primer lugar, le indicamos a la aplicación que busque complementos únicamente en este directorio. En nuestro caso, queremos que la aplicación busque solo aquellos complementos que distribuimos con el paquete. Si formáramos parte de una instalación de Qt más amplia, podríamos haber utilizado QCoreApplication::addLibraryPath() en su lugar. |
Advertencia: Al implementar los complementos, realizamos cambios en el código fuente y eso restablece los nombres de identificación predeterminados cuando se vuelve a compilar la aplicación. Por lo tanto, debes repetir el proceso para que tu aplicación se vincule a los marcos de trabajo de Qt correctos del paquete utilizando install_name_tool.
Ahora deberías poder trasladar la aplicación a otro equipo con macOS y ejecutarla sin tener Qt instalado. Como alternativa, puedes mover los marcos que se encuentran fuera del paquete a otro directorio y comprobar si la aplicación sigue funcionando.
Si almacenas los marcos de trabajo en otra ubicación fuera del paquete, la técnica para vincular la aplicación es similar; debes asegurarte de que tanto la aplicación como los marcos de trabajo coincidan en dónde buscar las bibliotecas de Qt y los complementos.
Creación del paquete de la aplicación
Una vez que hayas terminado de vincular tu aplicación a Qt, ya sea de forma estática o como marcos de trabajo, la aplicación estará lista para su distribución. Para obtener más información, consulta el sitio web de Apple Developer.
Aunque el proceso de implementación de una aplicación presenta algunos escollos, una vez que conozcas los distintos aspectos a tener en cuenta, podrás crear fácilmente paquetes que todos tus usuarios de macOS disfrutarán.
Dependencias de la aplicación
Complementos de Qt
Todas las aplicaciones de Qt GUI requieren un complemento que implemente la capa de abstracción de la plataforma Qt (QPA) en Qt. Para macOS, el nombre del complemento de la plataforma es libqcocoa.dylib. Este archivo debe encontrarse en un subdirectorio específico (por defecto, platforms) dentro del directorio de distribución. Como alternativa, es posible ajustar la ruta de búsqueda que utiliza Qt para encontrar sus complementos, tal y como se describe a continuación.
Tu aplicación también puede depender de uno o varios complementos de Qt, como el complemento del formato de imagen JPEG o un complemento de controlador SQL. Asegúrate de distribuir junto con tu aplicación cualquier complemento de Qt que necesites. Al igual que el complemento de plataforma, cada tipo de complemento debe estar ubicado en un subdirectorio específico (como imageformats o sqldrivers) dentro de tu directorio de distribución.
La ruta de búsqueda de los complementos de Qt (así como algunas otras rutas) está codificada de forma fija en la biblioteca QtCore. Por defecto, la primera ruta de búsqueda de complementos estará codificada como /path/to/Qt/plugins. Sin embargo, el uso de rutas predeterminadas presenta ciertas desventajas. Por ejemplo, es posible que no existan en el equipo de destino. Por lo tanto, debes comprobar varias alternativas para asegurarte de que se encuentren los complementos de Qt:
- Utilizar `
qt.conf`. Este es el método recomendado, ya que ofrece la mayor flexibilidad. - Utilizar QApplication::addLibraryPath() o QApplication::setLibraryPaths().
- Utilizar una utilidad de instalación de terceros para modificar las rutas fijas de la biblioteca QtCore.
El documento «Cómo crear complementos de Qt » describe los aspectos a los que hay que prestar atención a la hora de compilar e implementar complementos para aplicaciones Qt.
Bibliotecas adicionales
Puedes comprobar a qué bibliotecas está enlazada tu aplicación utilizando otool. Ejecuta este comando con la ruta de la aplicación como argumento:
otool -L MyApp.app/Contents/MacOS/MyAppRara vez es necesario redistribuir las bibliotecas específicas del compilador junto con la aplicación. Sin embargo, existen varias formas de implementar aplicaciones, ya que Qt se puede configurar, compilar e instalar de diversas maneras en macOS. Por lo general, tus objetivos te ayudarán a determinar cómo vas a implementar la aplicación. Las últimas secciones describen algunos aspectos que debes tener en cuenta a la hora de implementar tu aplicación.
La herramienta de implementación para macOS
La herramienta de implementación para macOS se encuentra en QTDIR/bin/macdeployqt. Está diseñada para automatizar el proceso de creación de un paquete de aplicación listo para su implementación que contenga las bibliotecas de Qt como marcos privados.
La herramienta de implementación para macOS también implementa los complementos de Qt, de acuerdo con las siguientes reglas (a menos que se utilice la opción -no-plugins ):
- El complemento de plataforma siempre se implementa.
- No se implementan las versiones de depuración de los complementos.
- Los complementos de diseño no se instalan.
- Los complementos de formato de imagen siempre se instalan, excepto el complemento de formato de imagen SVG, que solo se instala si la aplicación utiliza el Qt SVG módulo.
- Los complementos del motor de iconos siempre se implementan.
- El complemento de soporte de impresión siempre se implementa.
- Los complementos de controladores SQL se implementan si la aplicación utiliza el Qt SQL módulo.
- El complemento de accesibilidad siempre se implementa.
- El complemento de estilo siempre se implementa.
Importante: Si decides no utilizar la herramienta de implementación para Mac, debes asegurarte de que tu paquete de implementación incluya estos complementos.
Para incluir una biblioteca de terceros en el paquete de la aplicación, copia la biblioteca en el paquete manualmente, una vez creado este.
macdeployqt Admite las siguientes opciones:
| Opción | Descripción |
|---|---|
-verbose=<0-3> | 0 = sin salida, 1 = error/advertencia (por defecto), 2 = normal, 3 = depuración |
-no-plugins | Omitir la implementación del complemento |
-dmg | Crear una imagen de disco .dmg |
-no-strip | No ejecutar «strip» en los binarios |
-use-debug-libs | Implementar con versiones de depuración de los marcos y complementos (implica « -no-strip ») |
-executable=<path> | Permitir que el ejecutable indicado también utilice los marcos de trabajo implementados |
-qmldir=<path> | Implementar las importaciones utilizadas por los archivos .qml en la ruta indicada |
-qmlimport=<path> | Añade la ruta indicada a las ubicaciones de búsqueda de importaciones de QML |
-always-overwrite | Copiar los archivos aunque el archivo de destino ya exista |
-codesign=<ident> | Ejecutar codesign con la identidad indicada en todos los ejecutables. Por defecto, se utiliza la firma ad hoc (-codesign=-). |
-no-codesign | Desactivar la firma de código |
-hardened-runtime | Habilitar Hardened Runtime al firmar el código |
-timestamp | Incluir una marca de tiempo segura al firmar el código (requiere conexión a Internet) |
-sign-for-notarization=<ident> | Activa las opciones necesarias para la certificación notarial (requiere conexión a Internet). Las opciones activadas son « -hardened-runtime », « -timestamp » y -codesign=<ident> |
-appstore-compliant | Omitir la implementación de componentes que utilicen una API privada |
-libpath=<path> | Añadir la ruta indicada a la ruta de búsqueda de bibliotecas |
-fs=<filesystem> | Establecer el sistema de archivos utilizado para la imagen de disco .dmg (por defecto, HFS+) |
Nota: macOS High Sierra introdujo el nuevo sistema de archivos de Apple (APFS). Las versiones anteriores de macOS no pueden leer archivos .dmg formateados con APFS. De forma predeterminada, « macdeployqt » utiliza el sistema de archivos HFS+ más antiguo para garantizar la compatibilidad con todas las versiones de macOS compatibles actualmente con Qt. Utiliza la opción « -fs » para especificar un sistema de archivos diferente.
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 de « .dmg » abierto) creada con « -dmg » se basa en la ruta de acceso a la aplicación en el momento de ejecutar « macdeployqt ». Por ejemplo, consideremos el siguiente comando que crea una imagen de disco para una aplicación de Qt Quick:
macdeployqt /Users/foo/myapp-build/MyApp.app -qmldir=/Users/foo/myapp/qml -dmgEl nombre del volumen resultante será:
/Users/foo/myapp-build/MyApp.appPara asegurarte de que el nombre del volumen solo contenga el nombre de la aplicación y no la ruta de acceso en el equipo de implementación, ejecuta macdeployqt en el mismo directorio:
cd /Users/foo/myapp-build
macdeployqt MyApp.app -qmldir=/Users/foo/myapp/qml -dmgEl nombre del volumen resultante será entonces:
MyApp.appDerechos
Al firmar, macdeployqt utilizará automáticamente el primer archivo .entitlements que encuentre en el subdirectorio Contents/Resources/ del paquete de la aplicación, si existe. Para evitar errores, asegúrate de que haya como máximo un archivo .entitlements en esta carpeta.
© 2026 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.
