Qt pour macOS

Qt pour macOS permet de créer 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 sujets connexes.

Configurations prises en charge

Les versions suivantes de l'environnement de construction et de la plateforme cible d' exécution sont prises en charge par Qt 6.11.

Environnement de construction

L'environnement de construction 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) avec lesquels vous construisez et créez des liens. Ensemble, ces éléments définissent la manière dont votre application est construite.

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

Désactiver les changements de comportement

Une mise en garde concernant l'utilisation de la dernière version de Xcode et du dernier SDK pour construire votre application est que les frameworks du système macOS décideront parfois d'activer ou non les changements de comportement en fonction du SDK avec lequel vous avez construit votre application.

Cette technique permet à Apple de s'assurer que les binaires construits avec des SDK plus anciens continueront à fonctionner sans régression sur les versions plus récentes de macOS.

Par exemple, lorsque le mode sombre a été introduit dans macOS 10.14 Mojave, macOS n'a traité que les applications créées avec le SDK 10.14 comme prenant en charge le mode sombre, et a laissé les applications créées avec les SDK antérieurs avec l'apparence par défaut du mode clair.

Construire avec une version plus ancienne de Xcode, avec un SDK plus ancien, est un moyen de se soustraire à de tels changements de comportement, mais c'est une solution de dernier recours, et ne devrait être appliquée que si votre application n'a pas d'autres moyens de contourner le problème.

Plates-formes cibles

La construction pour macOS utilise une technique appelée " weak linking" qui vous permet de construire votre application avec les en-têtes et les bibliothèques du dernier SDK de la plateforme, tout en permettant à votre application d'être déployée sur des versions de macOS inférieures à la version du SDK. Lorsque le binaire est exécuté sur une version de macOS inférieure à celle du SDK avec lequel il a été construit, Qt vérifie à l'exécution si une fonctionnalité de la plateforme est disponible ou non avant de l'utiliser.

En théorie, cela permettrait d'exécuter votre application sur chaque version de macOS publiée, mais pour des raisons pratiques (et techniques), il y a une limite inférieure à cette gamme, connue comme la cible de déploiement de votre application. Si le binaire est lancé sur une version de macOS inférieure à la cible de déploiement, Qt affichera un message d'erreur et l'application ne fonctionnera pas.

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

Vous n'avez besoin d'augmenter la cible de déploiement que si votre propre code utilise des API qui ont été ajoutées dans une version de macOS supérieure à la version par défaut de Qt, et que vous n'utilisez pas les contrôles de @available pour protéger leur utilisation au moment 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 basé sur le SDK sur les plateformes Apple, voir la documentation pour les développeurs d'Apple.

Architectures

Par défaut, Qtt sera construit pour l'architecture de votre machine de développement - soit x86_64 si vous êtes sur un Mac Intel, soit arm64 si vous êtes sur un Mac Apple Silicon.

Pour compiler pour d'autres architectures, vous pouvez utiliser les variables CMAKE_OSX_ARCHITECTURES et QMAKE_APPLE_DEVICE_ARCHS dans vos fichiers de projet ou sur la ligne de commande. Cela vous permet à la fois d'effectuer une compilation croisée pour une architecture différente et de construire des binaires universels (multi-architectures). Par exemple, pour compiler votre application pour x86_64 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 l'on spécifie les architectures dans un fichier de projet, elles ne doivent pas être citées, 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 pour macOS. Il peut être installé à partir de l'App Store ou téléchargé à partir du site Web des développeurs d'Apple.

Une fois installé, lancez Xcode une fois pour lui permettre d'installer toutes les dépendances nécessaires.

Vérifiez ensuite que le système utilise l'installation correcte 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 aux attentes, choisissez explicitement l'installation de Xcode.

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

Installer ou construire Qt

Pour installer ou compiler Qt, suivez le guide général de démarrage de Qt.

Vous pouvez également suivre Alternative ways of installing Qt for macOS pour obtenir des informations sur l'installation de Qt à partir de Homebrew.

Générer des 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 construire et déboguer votre application à partir de Xcode, vous pouvez demander à ce qu'un projet Xcode soit généré à la place :

cmake ~/src/myapp -GXcode

ou avec qmake :

qmake ~/src/myapp -spec macx-xcode

Déployer des applications sur macOS

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

Pour construire votre application en tant que bundle d'application avec CMake, définissez la propriété MACOSX_BUNDLE sur votre cible exécutable, comme suit :

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

Avec qmake, les bundles sont la valeur par défaut. Définissez CONFIG -= app_bundle dans votre fichier de projet (.pro) pour le désactiver.

Un moyen courant de distribuer 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 dans les programmes d'installation de macOS), peut être utilisé pour créer des paquets autonomes et, éventuellement, une archive .dmg.

Les applications peuvent également être distribuées via le Mac App Store. macdeployqt (bin/macdeployqt) peut être utilisé comme point de départ pour le déploiement dans l'App Store. Pour s'assurer que Qt respecte 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 sur macOS, voir Qt pour macOS - Déploiement.

Sujets connexes

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

• Qt pour macOS - Construction à partir des sources
• Qt pour macOS - Déploiement
• Qt pour macOS - Problèmes spécifiques

Utiliser le code Objective-C dans les applications Qt

Clang, le compilateur utilisé pour les applications sur les plateformes Apple, permet de mélanger le code C++ et Objective-C. Pour activer ce mode, utilisez l'extension .mm pour les fichiers sources 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 Developer Library d'Apple dans vos applications Qt.

Pour exposer une fonctionnalité au reste de votre application, sans avoir à renommer tous vos fichiers source, déclarez les fonctions d'aide dans un en-tête et implémentez la fonctionnalité 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);
}