Qt pour iOS

Qt for iOS permet de créer des applications pour les appareils iPhone et iPad d'Apple, ainsi que pour l'Apple Vision Pro.

Pour développer avec Qt pour iOS, suivez le guide de démarrage, puis explorez les exemples pour iOS 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 iOS 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 iOS (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 iOS 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 d'iOS.

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 iOS utilise une technique appelée " weak linking" qui vous permet de construire votre application avec les en-têtes et les bibliothèques de la dernière plateforme SDK, tout en permettant à votre application d'être déployée sur des versions d'iOS inférieures à la version SDK. Lorsque le binaire est exécuté sur une version d'iOS inférieure au 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 toutes les versions iOS publiées, mais pour des raisons pratiques (et techniques), il existe une limite inférieure à cette plage, connue sous le nom de cible de déploiement de votre application. Si le binaire est lancé sur une version d'iOS 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 d'iOS 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.

Pour commencer

Installation de Xcode

Xcode est indispensable pour développer avec Qt pour iOS. 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

L'architecture des bibliothèques du simulateur Qt pour iOS est x86_64, ce qui signifie que le simulateur iOS doit s'exécuter sous Rosetta sur les Mac Apple Silicon. Dans Xcode 26 et les versions ultérieures, cela nécessite de supprimer le composant de plateforme iOS installé par défaut dans les paramètres de Xcode, puis d'installer manuellement le composant de plateforme iOS universel :

xcodebuild -downloadPlatform iOS -architectureVariant universal

Pour tester les applications Qt Test dans le simulateur fourni avec Xcode, c'est tout ce dont vous avez besoin. Cependant, pour exécuter des applications sur un appareil physique et/ou publier vos applications dans l'App Store, vous devez adhérer au programme Apple Developer Program et configurer des certificats de développeur et des profils de provisionnement.

Avant de créer des applications Qt Test, vous devez vérifier que Xcode est correctement configuré, par exemple en exécutant l'un des modèles d'application Xcode standard sur votre appareil.

Installer ou créer Qt

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

Création d'applications à partir de la ligne de commande

Utilisez CMake ou qmake pour définir comment construire votre application iOS. CMake et qmake peuvent tous deux générer un fichier xcodeproj, qui peut ensuite être chargé et construit à partir de la ligne de commande.

Utilisation de CMake

Le script de commodité qt-cmake situé dans <Qt-dir>/<version>/ios/bin/ se chargera de configurer la chaîne d'outils et les architectures correctes pour vous.

Utilisation du script de commodité qt-cmake:

<Qt-dir>/<version>/ios/bin/qt-cmake <source-dir>

En utilisant le fichier xcodeproj généré, vous pouvez soit utiliser Xcode pour construire votre application, soit exécuter xcodebuild à partir de la ligne de commande. Pour obtenir une liste des cibles et des schémas disponibles pour votre application, exécutez la commande suivante :

xcodebuild -list -project <your-app>.xcodeproj

Ensuite, exécutez xcodebuild build en indiquant les détails de votre application :

xcodebuild build -allowProvisioningUpdates -project <your-app>.xcodeproj -scheme <your-scheme> -configuration Debug -destination "generic/platform=iOS" -destination-timeout 1 ENABLE_ONLY_ACTIVE_RESOURCES=NO

Utilisation de qmake

Tout d'abord, définissez comment construire l'application à l'aide de qmake. Ensuite, utilisez le fichier xcodeproj généré pour construire l'application, soit dans Xcode, soit à partir de la ligne de commande.

qmake <your-app>.pro

qmake crée un Makefile enveloppant qui appelle à son tour xcodebuild, de sorte que vous pouvez exécuter make pour construire votre application :

make -j8

Notez que vous devez réimporter le projet si sa configuration change, par exemple, lorsque vous ajoutez ou supprimez des fichiers sources.

Personnaliser les paramètres du projet Xcode

La variable QMAKE_MAC_XCODE_SETTINGS qmake peut être utilisée pour personnaliser les paramètres de Xcode, par exemple :

development_team.name = DEVELOPMENT_TEAM
development_team.value = <your-team-id>
QMAKE_MAC_XCODE_SETTINGS += development_team

D'autres variables qmake sont également utiles :

QMAKE_TARGET_BUNDLE_PREFIX = com.<your-company>
QMAKE_BUNDLE = <your-app>

Exécuter des applications dans Xcode

Les projets Xcode générés par qmake et CMake permettent d'exécuter l'application sur les appareils iOS et dans le simulateur iOS.

Construire et exécuter des applications avec Qt Creator

Vous trouverez des informations sur la manière de configurer et d'exécuter des applications Qt pour iOS dans la documentation Qt Creator:

• Qt Creator:Connecter les appareils iOS.

Notez que cela nécessite toujours une installation fonctionnelle de Xcode.

Exemples pour iOS

Sur Qt Creator, des exemples testés sur iOS peuvent être recherchés. Utilisez le mot-clé ios pour rechercher des exemples dans le mode d'accueil Qt Creator. Notez que certains exemples peuvent avoir des fonctionnalités limitées.

Pour une liste d'exemples connus pour fonctionner sur les appareils iOS, visitez Qt for iOS Examples.

Sujets connexes

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

• Notes sur la plate-forme
• Qt pour iOS - Construction à partir des sources

Utilisation du 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 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 sources, 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);
}