Qt pour iOS

Qt pour iOS permet de développer 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 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 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) à 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 construites à 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 des versions plus anciennes de macOS.

Désactivation des modifications de comportement

L'utilisation de la dernière version de Xcode et du SDK le plus récent pour compiler votre application présente toutefois une mise en garde : les frameworks système iOS décident parfois d'activer ou non les changements de comportement en fonction du SDK utilisé pour compiler votre application.

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

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 appliquée que si votre application ne dispose d’aucun autre moyen de contourner le problème.

Plateformes cibles

La compilation pour iOS utilise une technique appelée « liaison faible » (weak linking ) 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 d’iOS antérieures à la version du SDK. Lorsque le binaire est exécuté sur une version d’iOS 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 d’iOS 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 d’iOS 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 d’iOS 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 d'un SDK sur les plateformes Apple, consultez 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é 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

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 équipés d’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 d’Xcode, puis d’installer manuellement le composant de plateforme iOS universel :

xcodebuild -downloadPlatform iOS -architectureVariant universal

Pour tester des applications Qt dans le simulateur fourni avec Xcode, cela suffit. Cependant, pour exécuter des applications sur un appareil physique et/ou publier vos applications sur l’App Store, vous devez adhérer au programme Apple Developer Program et configurer des certificats de développeur ainsi que des profils d’approvisionnement.

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

Installation ou compilation de Qt

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

Compilation d'applications à partir de la ligne de commande

Utilisez CMake ou qmake pour définir la manière de compiler votre application iOS. CMake et qmake permettent tous deux de générer un fichier « xcodeproj », qui peut ensuite être chargé et compilé depuis la ligne de commande.

Utilisation de CMake

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

Utilisation du script d'aide « qt-cmake » :

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

À l'aide du fichier « xcodeproj » généré, vous pouvez soit utiliser Xcode pour compiler votre application, soit exécuter la commande « xcodebuild » depuis la ligne de commande. Pour obtenir la 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 la commande « xcodebuild build » en lui transmettant les informations relatives à 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

Commencez par définir la manière de compiler l'application à l'aide de qmake. Utilisez ensuite le fichier xcodeproj généré pour compiler l'application, soit dans Xcode, soit depuis la ligne de commande.

qmake <your-app>.pro

qmake crée un fichier Makefile « wrapper » qui, à son tour, appelle ` xcodebuild` ; vous pouvez donc exécuter ` make ` pour compiler votre application :

make -j8

Notez que vous devez réimporter le projet si sa configuration change, par exemple lors de l'ajout ou de la suppression de fichiers source.

Personnalisation des paramètres du projet Xcode

La variable qmake ` QMAKE_MAC_XCODE_SETTINGS ` 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écution d'applications dans Xcode

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

Compilation et exécution d’applications avec Qt Creator

Vous trouverez des informations sur la configuration et l'exécution des applications Qt pour iOS dans la documentation Qt Creator:

• Qt Creator: Connecter des appareils iOS.

Notez qu'une installation fonctionnelle de Xcode reste nécessaire.

Exemples pour iOS

Dans Qt Creator, vous pouvez consulter des exemples testés sur iOS. Utilisez le mot-clé « ios » pour rechercher des exemples dans le mode « Welcome » (Bienvenue) de Qt Creator. Notez que certaines fonctionnalités de certains exemples peuvent être limitées.

Pour obtenir la liste des exemples dont le fonctionnement est confirmé sur les appareils iOS, consultez la page Exemples Qt pour iOS.

Sujets connexes

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

• Remarques sur la plateforme
• Qt pour iOS - Compilation à partir du code source

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);
}