Qt pour macOS - Déploiement

Ce document décrit comment créer un bundle macOS et s'assurer que l'application trouve les ressources dont elle a besoin lors de son exécution. Nous illustrons ces procédures à l'aide du déploiement de l'application d'exemple Plug & Paint fournie avec le paquet source Qt.

Les programmes d'installation de Qt pour macOS incluent un outil de déploiement qui automatise les procédures décrites ici.

Le bundle

Sous macOS, une application graphique doit être compilée et exécutée à partir d’un bundle, c’est-à-dire une structure de répertoires qui apparaît comme une entité unique lorsqu’on la visualise dans le Finder. Un bundle d’application contient généralement l’exécutable et toutes les ressources dont il a besoin. Voici un aperçu de la structure d’un bundle d’application :

Le bundle offre de nombreux avantages à l’utilisateur :

• Il est facile à installer car il est identifié comme une seule entité.
• Les informations relatives à un bundle sont accessibles depuis le code.

Ce point est spécifique à macOS et dépasse le cadre de ce document. Pour plus d’informations sur les bundles, consultez le site web des développeurs d’Apple.

Pour compiler votre application sous forme de bundle avec CMake, définissez la MACOSX_BUNDLE propriété suivante sur votre cible exécutable :

set_target_properties(plugandpaint PROPERTIES
    MACOSX_BUNDLE TRUE
)

qmake génère automatiquement un bundle pour votre application. Pour désactiver cette fonctionnalité, ajoutez l’instruction suivante au fichier de projet de votre application (.pro) :

CONFIG-=app_bundle

Liaison statique

Si vous souhaitez simplifier les choses et que vous n’avez que quelques fichiers à déployer, vous pouvez compiler votre application avec des bibliothèques liées statiquement.

Compilation statique de Qt

Commencez par installer une version statique de la bibliothèque Qt. N'oubliez pas que vous ne pouvez pas utiliser de plugins et que vous devez compiler les bibliothèques dépendantes (formats d'image, pilotes SQL, etc.) avec la liaison statique.

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

Vous pouvez consulter les différentes options disponibles en exécutant la commande « configure -help ».

Lier l'application à la version statique de Qt

Une fois Qt compilé de manière statique, l’étape suivante consiste à régénérer les fichiers de compilation et à recompiler l’application.

Utilisation de CMake

Veillez à utiliser la commande de wrapper qt_add_executable, qui fournit des fonctionnalités supplémentaires telles que la liaison des plugins Qt dans les compilations statiques de Qt.

Pour compiler pour les plateformes Apple, vous devez définir cmake_minimum_required() sur 3.21.1 ou une version plus récente :

cmake_minimum_required(VERSION 3.21.1)

Accédez au répertoire contenant l'application :

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

Ensuite, définissez la variable ` CMAKE_PREFIX_PATH ` pour qu’elle pointe vers le préfixe de votre installation. Si vous disposez déjà d’une compilation CMake, supprimez le fichier ` CMakeCache.txt `. Puis, relancez CMake :

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

Vous pouvez également utiliser le script pratique qt-cmake, qui définit la variable CMAKE_PREFIX_PATH à votre place.

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

Enfin, accédez à votre répertoire de compilation et exécutez votre système de compilation préféré. Dans cet exemple, nous utilisons Ninja.

cd path/to/build/dir
ninja

À présent, à condition que tout se soit compilé et lié sans erreur, vous devriez disposer d’un bundle plugandpaint.app prêt à être déployé. Essayez d’installer ce bundle sur une machine sous macOS sur laquelle Qt ni aucune application Qt n’est installé.

Utilisation de qmake

Commencez par vous rendre dans le répertoire contenant l’application :

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

Ensuite, exécutez ` qmake ` pour créer un nouveau fichier `makefile` pour l'application, puis effectuez une compilation « clean » pour créer l'exécutable lié de manière statique :

make clean
qmake -config release
make

Vous souhaiterez probablement effectuer la liaison avec les bibliothèques de version finale ; vous pouvez le spécifier lors de l’exécution de ` qmake`. Vous pouvez également tirer parti de la « suppression du code mort » pour réduire encore davantage la taille de votre binaire. Pour ce faire, passez ` LIBS+= -dead_strip ` à ` qmake ` en plus du paramètre ` -config release `.

Encore une fois, à condition que la compilation et la liaison se soient déroulées sans erreur, vous devriez disposer d’un bundle plugandpaint.app prêt à être déployé. Essayez d’installer ce bundle sur une machine sous macOS sur laquelle ni Qt ni aucune application Qt n’est installé.

Vérification des bibliothèques liées

Vous pouvez vérifier à quelles autres bibliothèques votre application est liée à l’aide de la commande otool:

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

Voici à quoi ressemble la sortie pour Plug & Paint lié de manière statique :

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 vous voyez des bibliothèques Qt dans la sortie, cela signifie probablement que vous avez à la fois des bibliothèques Qt dynamiques et statiques installées sur votre machine. L’éditeur de liens privilégie toujours la liaison dynamique à la liaison statique. Si vous souhaitez utiliser uniquement des bibliothèques statiques, vous pouvez soit :

• déplacer vos bibliothèques Qt dynamiques (.dylibs) vers un autre répertoire pendant la liaison de l’application, puis les replacer à leur emplacement d’origine,
• soit modifier le fichier ` Makefile ` et remplacer les lignes de liaison vers les bibliothèques Qt par le chemin absolu vers les bibliothèques statiques.

Par exemple, remplacez ce qui suit :

-lQtGui

par ceci :

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

L’exemple Plug & Paint se compose de plusieurs éléments : l’application principale (Plug & Paint), ainsi que les plugins Basic Tools et Extra Filters. Comme il n’est pas possible de déployer des plugins à l’aide de la méthode de liaison statique, le bundle que nous avons préparé jusqu’à présent est incomplet. L’application s’exécutera, mais les fonctionnalités seront désactivées en raison des plugins manquants. Pour déployer des applications basées sur des plugins, nous devons utiliser l’approche par framework, spécifique à macOS.

Frameworks

Dans cette approche, assurez-vous que le runtime Qt est correctement redistribué avec le bundle de l'application, et que les plugins sont installés au bon emplacement afin que l'application puisse les trouver.

Il existe deux façons de distribuer Qt avec votre application dans le cadre de l’approche des frameworks :

• Un framework privé au sein du bundle de votre application.
• Framework standard (vous pouvez également utiliser les frameworks Qt présents dans le binaire installé).

La première option est recommandée si vous avez compilé Qt d'une manière particulière, ou si vous souhaitez vous assurer que le framework est bien présent. Tout dépend simplement de l'emplacement où vous placez les frameworks Qt.

La deuxième option est recommandée si vous disposez de nombreuses applications Qt et que vous souhaitez qu’elles utilisent un seul framework Qt plutôt que plusieurs versions de celui-ci.

Compiler Qt en tant que frameworks

Nous partons du principe que vous avez déjà installé Qt sous forme de frameworks (ce qui est le comportement par défaut lors de l’installation de Qt) dans le répertoire /path/to/Qt. Pour plus d’informations sur la compilation de Qt sans frameworks, consultez la documentation Qt pour macOS – Problèmes spécifiques.

Lors de l’installation, le nom d’identification des frameworks est défini. Ce nom est utilisé par l’éditeur de liens dynamiques (dyld) pour trouver les bibliothèques de votre application.

Liaison de l'application à Qt en tant que frameworks

Une fois Qt compilé en tant que frameworks, nous pouvons compiler l’application Plug & Paint.

Utilisation de CMake

Pour compiler pour les plateformes Apple, vous devez définir cmake_minimum_required() sur la version 3.21.1 ou une version plus récente :

cmake_minimum_required(VERSION 3.21.1)

Accédez au répertoire contenant l’application :

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

Ensuite, définissez la variable CMAKE_PREFIX_PATH pour qu'elle pointe vers le préfixe de votre installation. Si vous disposez déjà d'une compilation CMake, supprimez le fichier CMakeCache.txt. Puis, relancez CMake :

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

Vous pouvez également utiliser le script pratique qt-cmake, qui définit la variable CMAKE_PREFIX_PATH à votre place.

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

Enfin, accédez à votre répertoire de compilation et exécutez votre système de compilation préféré. Dans cet exemple, nous utilisons Ninja.

cd path/to/build/dir
ninja

À présent, à condition que tout se soit compilé et lié sans erreur, vous devriez disposer d’un bundle plugandpaint.app prêt à être déployé. Essayez d’installer ce bundle sur une machine sous macOS sur laquelle Qt ni aucune application Qt n’est installé.

Utilisation de qmake

Commencez par vous rendre dans le répertoire contenant l'application :

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

Exécutez ` qmake ` pour créer un nouveau fichier makefile pour l’application, puis effectuez une compilation « clean » pour créer l’exécutable lié dynamiquement :

make clean
qmake -config release
make

Cela permet de compiler l’application principale. Utilisez la commande suivante pour compiler les plugins :

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

Exécutez maintenant la commande « otool » pour les frameworks Qt, par exemple Qt GUI :

otool -L QtGui.framework/QtGui

Vous obtiendrez le résultat suivant :

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)

Pour les frameworks Qt, la première ligne (c'est-à-dire « path/to/Qt/lib/QtGui.framework/Versions/4/QtGui (compatibility version 4.0.0, current version 4.0.1) ») devient le nom d'identification du framework utilisé par l'éditeur de liens dynamiques (dyld).

Cependant, lors du déploiement de l’application, il se peut que vos utilisateurs n’aient pas les bibliothèques Qt installées à l’emplacement spécifié. C’est pourquoi vous devez soit fournir les bibliothèques à un emplacement convenu, soit les inclure dans le bundle. Quelle que soit la solution choisie, vous devez vous assurer que les bibliothèques renvoient le nom d’identification qui leur correspond et que l’application recherche ces noms. Heureusement, nous pouvons contrôler cela à l’aide de l’outil en ligne de commande install_name_tool.

install_name_tool fonctionne selon deux modes : « -id » et « -change ». Le mode « -id » est destiné aux bibliothèques et aux frameworks, et nous permet de spécifier un nouveau nom d’identification. Nous utilisons le mode « -change » pour modifier les chemins d’accès dans l’application.

Testons cela en copiant les frameworks Qt dans le bundle Plug & Paint. En consultant la sortie de la commande otool pour ce bundle, nous constatons que nous devons copier à la fois les frameworks QtCore et QtGui dans le bundle. Nous partons du principe que nous nous trouvons dans le répertoire où nous avons créé le 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

Nous commençons par créer un répertoire Frameworks à l’intérieur du bundle. Cela respecte la convention des applications macOS. Nous copions ensuite les frameworks dans ce nouveau répertoire. Comme les frameworks contiennent des liens symboliques, nous utilisons l’option -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

Nous exécutons ensuite la commande ` install_name_tool ` pour définir les noms d’identification des frameworks. Le premier argument après ` -id ` correspond au nouveau nom, et le second argument désigne le framework que nous souhaitons renommer. La chaîne ` @executable_path ` est une variable spéciale ` dyld ` qui indique à ` dyld ` où commencer à rechercher l’exécutable. Les nouveaux noms précisent que ces frameworks se trouvent dans le répertoire situé directement sous le répertoire ` 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

Désormais, l'éditeur de liens dynamique sait où chercher QtCore et QtGui. Nous devons nous assurer que l'application sache également où trouver la bibliothèque, en utilisant le mode « -change » de install_name_tool. Cela revient essentiellement à remplacer des chaînes de caractères, afin de faire correspondre les noms d'identification que nous avons définis précédemment aux frameworks.

Enfin, le framework QtGui dépend de QtCore; nous devons donc penser à modifier la référence pour 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

Après cela, nous relançons « otool » et constatons que l’application parvient à trouver les bibliothèques.

Les plugins de l'exemple Plug & Paint rendent le tout particulièrement intéressant. Les étapes de base à suivre avec les plugins sont les suivantes :

• placer les plugins dans le bundle,
• lancer la commande ` install_name_tool ` pour vérifier que les plugins utilisent bien la bonne bibliothèque,
• et s'assurer que l'application sait où trouver les plugins.

Nous pouvons placer les plugins où bon nous semble dans le bundle, mais le meilleur emplacement est le répertoire Contents/Plugins. Lorsque nous avons créé les plugins Plug & Paint, d’après la variable DESTDIR de leur fichier .pro, les fichiers .dylib des plugins se trouvaient dans le sous-répertoire plugins, situé dans le répertoire plugandpaint. Il suffit de déplacer ce répertoire vers l’emplacement approprié.

mv plugins plugandpaint.app/Contents

Par exemple, si l'on exécute la commande « otool » sur le fichier ` .dylib ` du plugin « Basic Tools », on obtient les informations suivantes.

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)

Nous pouvons alors constater que le plugin est lié aux bibliothèques Qt avec lesquelles il a été compilé. Comme nous souhaitons que les plugins utilisent les bibliothèques contenues dans le bundle de l’application, nous les modifions de la même manière que nous l’avons fait pour l’application. Par exemple, pour le 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

Nous devons également modifier le code dans ` tools/plugandpaint/mainwindow.cpp ` pour qu’il appelle ` cdUp()` afin de garantir que l’application trouve les plugins. Ajoutez le code suivant au fichier ` mainwindow.cpp ` :

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

Le code supplémentaire ajouté à tools/plugandpaint/mainwindow.cpp nous permet également d'afficher les plugins dans le Finder, comme le montre l’image. Nous pouvons également ajouter des plugins étendant Qt, par exemple des pilotes SQL ou des formats d’image. Il suffit de respecter la structure de répertoires indiquée dans la documentation des plugins et de s’assurer qu’ils sont inclus dans le fichier QCoreApplication::libraryPaths(). Faisons-le rapidement avec les formats d’image, en suivant la procédure décrite précédemment. Copiez les plugins de formats d’image de Qt dans le bundle : cp -R /path/to/Qt/plugins/imageformats pluginandpaint.app/Contents/plugins Utilisez ` install_name_tool ` pour lier les plugins aux frameworks du 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 Mettez à jour le code source de tools/plugandpaint/main.cpp afin qu’il recherche les nouveaux plugins. Après avoir créé l’ QApplication, ajoutez le code suivant : QDir dir(QCoreApplication::applicationDirPath()); dir.cdUp(); dir.cd("plugins"); QCoreApplication::setLibraryPaths(QStringList(dir.absolutePath())); Tout d’abord, nous indiquons à l’application de rechercher les plugins uniquement dans ce répertoire. Dans notre cas, nous souhaitons que l’application ne recherche que les plugins que nous distribuons avec le bundle. Si nous faisions partie d’une installation Qt plus vaste, nous aurions pu utiliser QCoreApplication::addLibraryPath() à la place.

Vous devriez désormais pouvoir déplacer l’application vers une autre machine macOS et l’exécuter sans que Qt soit installé. Vous pouvez également déplacer vos frameworks situés en dehors du bundle vers un autre répertoire et vérifier si l’application fonctionne toujours.

Si vous stockez les frameworks à un autre emplacement en dehors du bundle, la procédure de liaison de votre application est similaire ; vous devez vous assurer que l’application et les frameworks s’accordent sur l’emplacement où rechercher les bibliothèques Qt ainsi que les plugins.

Création du paquet d'application

Une fois que vous avez terminé de lier votre application à Qt, que ce soit de manière statique ou sous forme de frameworks, l'application est prête à être distribuée. Pour plus d'informations, consultez le site web Apple Developer.

Bien que le processus de déploiement d’une application comporte quelques pièges, une fois que vous maîtrisez les différents enjeux, vous pouvez facilement créer des paquets qui plairont à tous vos utilisateurs macOS.

Dépendances de l'application

Plug-ins Qt

Toutes les applications Qt GUI nécessitent un plugin qui implémente la couche Qt Platform Abstraction (QPA) dans Qt. Sous macOS, le nom du plugin de plateforme est libqcocoa.dylib. Ce fichier doit se trouver dans un sous-répertoire spécifique (par défaut, platforms) sous votre répertoire de distribution. Il est également possible de modifier le chemin de recherche utilisé par Qt pour trouver ses plugins, comme décrit ci-dessous.

Votre application peut également dépendre d’un ou plusieurs plugins Qt, tels que le plugin pour le format d’image JPEG ou un plugin de pilote SQL. Veillez à distribuer tous les plugins Qt dont vous avez besoin avec votre application. À l’instar du plugin de plateforme, chaque type de plugin doit se trouver dans un sous-répertoire spécifique (tel que imageformats ou sqldrivers) de votre répertoire de distribution.

Le chemin de recherche des plugins Qt (ainsi que quelques autres chemins) est codé en dur dans la bibliothèque QtCore. Par défaut, le premier chemin de recherche des plugins sera codé en dur sous la forme /path/to/Qt/plugins. Cependant, l'utilisation de chemins prédéfinis présente certains inconvénients. Par exemple, ils peuvent ne pas exister sur la machine cible. Vous devez donc vérifier différentes alternatives pour vous assurer que les plugins Qt sont bien trouvés :

• Utiliser ` qt.conf`. C'est l'approche recommandée, car elle offre la plus grande flexibilité.
• Utiliser ` QApplication::addLibraryPath()` ou ` QApplication::setLibraryPaths()`.
• Utiliser un utilitaire d’installation tiers pour modifier les chemins d’accès codés en dur dans la bibliothèque ` QtCore `.

Le document « Comment créer des plugins Qt » présente les points auxquels vous devez prêter attention lors de la compilation et du déploiement de plugins pour les applications Qt.

Bibliothèques supplémentaires

Vous pouvez vérifier quelles bibliothèques sont liées à votre application à l'aide de la commande ` otool`. Exécutez cette commande en lui passant le chemin d'accès à l'application comme argument :

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

Les bibliothèques spécifiques au compilateur doivent rarement être redistribuées avec votre application. Il existe toutefois plusieurs façons de déployer des applications, car Qt peut être configuré, compilé et installé de différentes manières sous macOS. En général, ce sont vos objectifs qui déterminent la manière dont vous allez déployer l’application. Les dernières sections décrivent quelques points à prendre en compte lors du déploiement de votre application.

L'outil de déploiement macOS

L'outil de déploiement macOS est disponible à l'adresse QTDIR/bin/macdeployqt. Il est conçu pour automatiser le processus de création d'un ensemble d'applications déployable contenant les bibliothèques Qt sous forme de frameworks privés.

L'outil de déploiement macOS déploie également les plugins Qt, selon les règles suivantes (sauf si l'option -no-plugins est utilisée) :

• Le plugin de plateforme est toujours déployé.
• Les versions de débogage des plugins ne sont pas déployées.
• Les plugins de conception ne sont pas déployés.
• Les plugins de format d'image sont toujours déployés, à l'exception du plugin de format d'image SVG qui n'est déployé que si l'application utilise le Qt SVG module.
• Les plugins du moteur d’icônes sont toujours déployés.
• Le plugin de prise en charge de l'impression est toujours déployé.
• Les plugins de pilotes SQL sont déployés si l'application utilise le Qt SQL module.
• Le plugin d’accessibilité est toujours déployé.
• Le plugin de style est toujours déployé.

Pour inclure une bibliothèque tierce dans le bundle de l’application, copiez-la manuellement dans le bundle une fois celui-ci créé.

macdeployqt prend en charge les options suivantes :

Nom du volume

Le nom de volume d’une image disque (le texte affiché dans le titre de la fenêtre d’un fichier « .dmg » ouvert) créée avec l’option « -dmg » est basé sur le chemin d’accès à l’application au moment de l’exécution de la commande « macdeployqt ». Prenons par exemple la commande suivante qui crée une image disque pour l’application « Qt Quick » :

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

Le nom du volume obtenu sera :

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

Pour vous assurer que le nom du volume ne contient que le nom de l’application et non le chemin d’accès sur la machine de déploiement, exécutez la commande « macdeployqt » dans le même répertoire :

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

Le nom du volume obtenu sera alors :

MyApp.app

Droits

Lors de la signature, macdeployqt utilisera automatiquement le premier fichier .entitlements qu’il trouvera dans le sous-répertoire Contents/Resources/ du bundle de l’application, s’il existe. Pour éviter toute erreur, assurez-vous qu’il n’y ait qu’un seul fichier .entitlements dans ce dossier.