Qt pour macOS

Qt pour macOS permet de développer des applications pour la gamme d'ordinateurs Mac d'Apple.

Pour développer avec Qt pour macOS, suivez le guide de démarrage, puis explorez les exemples Qt et les rubriques associées.

Configurations prises en charge

Les versions suivantes de l'environnement de compilation et de la plate-forme d'exécution cible sont prises en charge par Qt 6.12.

Environnement de compilation

L'environnement de compilation pour macOS est fourni par l'application Xcode d'Apple, qui comprend à la fois la chaîne d'outils (compilateur, éditeur de liens et autres outils) et le SDK de la plateforme macOS (en-têtes et bibliothèques) à partir desquels vous compilez et liez votre application. Ensemble, ces éléments définissent la manière dont votre application est compilée.

Apple recommande généralement (et, dans le cas de l’App Store, exige) que les applications soient compilées à partir du dernier SDK disponible ; vous devez donc toujours utiliser la dernière version de Xcode proposée par Apple. Cela peut nécessiter une mise à jour de la version de macOS de votre système, car les nouvelles versions de Xcode peuvent ne pas fonctionner sur les anciennes versions de macOS.

Désactivation des modifications de comportement

L'utilisation de la dernière version d'Xcode et du SDK le plus récent pour compiler votre application comporte toutefois une mise en garde : les frameworks système de macOS décident parfois d'activer ou non les changements de comportement en fonction du SDK sur lequel vous avez compilé votre application.

Cette technique permet à Apple de garantir que les binaires créés à partir d’anciens SDK continueront de fonctionner sans régression sur les nouvelles versions de macOS.

Par exemple, lorsque le mode sombre a été introduit dans macOS 10.14 Mojave, macOS ne considérait que les applications développées avec le SDK 10.14 comme prenant en charge le mode sombre, et conservait l’apparence par défaut du mode clair pour les applications développées avec des SDK antérieurs.

Compiler avec une version plus ancienne d’Xcode, à partir d’un SDK plus ancien, est un moyen de contourner ces changements de comportement, mais il s’agit d’une solution de dernier recours qui ne doit être utilisée que si votre application ne dispose d’aucun autre moyen de contourner le problème.

Plateformes cibles

La compilation pour macOS utilise une technique appelée « liaison faible » qui vous permet de compiler votre application à partir des en-têtes et des bibliothèques du dernier SDK de la plateforme, tout en permettant à votre application d’être déployée sur des versions de macOS antérieures à la version du SDK. Lorsque le binaire est exécuté sur une version de macOS antérieure à celle du SDK avec lequel il a été compilé, Qt vérifie au moment de l'exécution si une fonctionnalité de la plateforme est disponible avant de l'utiliser.

En théorie, cela permettrait d’exécuter votre application sur toutes les versions de macOS publiées, mais pour des raisons pratiques (et techniques), il existe une limite inférieure à cette plage, appelée « cible de déploiement » de votre application. Si le binaire est lancé sur une version de macOS antérieure à la cible de déploiement, Qt affichera un message d’erreur et l’application ne s’exécutera pas.

Qt exprime la cible de déploiement via les variables CMAKE_OSX_DEPLOYMENT_TARGET ou QMAKE_MACOSX_DEPLOYMENT_TARGET, qui est par défaut définie sur la cible de déploiement minimale prise en charge par Qt.

Vous ne devez augmenter la cible de déploiement que si votre propre code utilise des API ajoutées dans une version de macOS supérieure à celle définie par défaut par Qt, et si vous n’utilisez pas de vérifications @available pour contrôler leur utilisation lors de l’exécution.

Pour augmenter la cible de déploiement avec CMake :

set(CMAKE_OSX_DEPLOYMENT_TARGET "42.0")

ou avec qmake :

QMAKE_MACOSX_DEPLOYMENT_TARGET = 42.0

Pour plus d’informations sur le développement à partir du SDK sur les plateformes Apple, consultez la documentation pour les développeurs d’Apple.

Architectures

Par défaut, Qt se compile pour l'architecture de votre machine de développement : x86_64 si vous utilisez un Mac Intel, ou arm64 si vous utilisez un Mac Apple Silicon.

Pour compiler pour d’autres architectures, vous pouvez utiliser les variables CMAKE_OSX_ARCHITECTURESQMAKE_APPLE_DEVICE_ARCHS et x86_64 dans vos fichiers de projet ou sur la ligne de commande. Cela vous permet à la fois de réaliser une compilation croisée vers une autre architecture et de générer des binaires universels (multi-architectures). Par exemple, pour compiler votre application à la fois pour et arm64 avec CMake :

cmake ~/src/myapp -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64"

ou avec qmake :

qmake ~/src/myapp QMAKE_APPLE_DEVICE_ARCHS="x86_64 arm64"

Lorsque vous spécifiez les architectures dans un fichier de projet, celles-ci ne doivent pas être placées entre guillemets, par exemple :

TEMPLATE = app
SOURCES = main.cpp
QMAKE_APPLE_DEVICE_ARCHS = x86_64 arm64

Prise en charge des sous-architectures sur les Mac Intel

Outre l'architecture de base x86_64, Qt prend également en charge la sous-architecture x86_64h (« Haswell »), qui améliore les performances sur les Mac Intel.

Pour commencer

Installation de Xcode

Xcode est indispensable pour développer avec Qt sur macOS. Il peut être installé depuis l'App Store ou téléchargé depuis le site web des développeurs d'Apple.

Une fois installé, veuillez lancer Xcode une fois afin qu'il installe toutes les dépendances nécessaires.

Vérifiez ensuite que le système utilise bien la bonne installation de Xcode à l'aide de l'outil « xcode-select ».

$ xcode-select -print-path
/Applications/Xcode.app/Contents/Developer

Si le résultat ne correspond pas à ce qui est attendu, sélectionnez explicitement l'installation de Xcode.

$ sudo xcode-select --switch /Applications/Xcode.app

Installation ou compilation de Qt

Pour installer ou compiler Qt, suivez le guide général de prise en main de Qt.

Vous pouvez également consulter la section « Autres méthodes d'installation de Qt sous macOS » pour savoir comment installer Qt à partir de Homebrew.

Génération de fichiers de projet Xcode

Par défaut, CMake et qmake génèrent des fichiers de projet au format Makefile. Si vous préférez compiler et déboguer votre application depuis Xcode, vous pouvez demander qu'un projet Xcode soit généré à la place :

cmake ~/src/myapp -GXcode

ou avec qmake :

qmake ~/src/myapp -spec macx-xcode

Déploiement d'applications sur macOS

Les applications macOS sont généralement déployées sous forme de paquets d'application autonomes. Le paquet d'application contient l'exécutable de l'application ainsi que les dépendances telles que les bibliothèques Qt, les plugins, les traductions et autres ressources dont vous pourriez avoir besoin. Les bibliothèques tierces comme Qt ne sont généralement pas installées à l'échelle du système ; chaque application fournit sa propre copie.

Pour compiler votre application sous forme de paquet d’application avec CMake, définissez la MACOSX_BUNDLE propriété de votre cible exécutable comme suit :

qt_add_executable(MyApp)
if(APPLE)
    set_target_properties(MyApp PROPERTIES MACOSX_BUNDLE TRUE)
endif()

Avec qmake, les ensembles d'applications sont activés par défaut. Définissez « CONFIG -= app_bundle » dans votre fichier de projet (.pro) pour les désactiver.

Une méthode courante de distribution des applications consiste à fournir une image disque compressée (fichier .dmg) que l’utilisateur peut monter dans le Finder. L’outil de déploiement, macdeployqt (disponible à partir des programmes d’installation macOS), peut être utilisé pour créer des bundles autonomes et, si vous le souhaitez, également créer une archive .dmg.

Les applications peuvent également être distribuées via le Mac App Store. macdeployqt (bin/macdeployqt) peut servir de point de départ pour le déploiement sur l’App Store. Pour garantir la conformité de Qt avec les règles du bac à sable de l’App Store, Qt doit être configuré avec l’argument -feature-appstore-compliant.

Pour plus de détails sur le déploiement sous macOS, consultez la section Qt pour macOS - Déploiement.

Sujets connexes

Les rubriques suivantes fournissent plus de détails sur Qt pour macOS :

• Qt pour macOS - Compilation à partir du code source
• Qt pour macOS - Déploiement
• Qt pour macOS - Problèmes spécifiques

Utilisation de code Objective-C dans les applications Qt

Clang, le compilateur utilisé pour les applications sur les plateformes Apple, permet de mélanger du code C++ et Objective-C. Pour activer ce mode, utilisez l'extension « .mm » pour les fichiers source concernés et ajoutez-les à votre projet comme d'habitude.

Avec CMake :

target_sources(myapp PRIVATE objc_code.mm)

Avec qmake :

SOURCES += objc_code.mm

Vous pouvez alors utiliser les frameworks Objective-C de la bibliothèque pour développeurs d'Apple dans vos applications Qt.

Pour exposer ces fonctionnalités au reste de votre application, sans avoir à renommer tous vos fichiers source, déclarez des fonctions d'aide dans un fichier d'en-tête, puis implémentez ces fonctionnalités dans un fichier source Objective-C++ :

// objc_code.h
QString localizedHostName();

// objc_code.mm
#include <Foundation/NSHost.h>
QString localizedHostName()
{
    return QString::fromNSString(NSHost.currentHost.localizedName);
}