Développement IA

Avant la sortie de l’iPhone pliable, quelles API iOS 27 modifier en premier ? (2026)

La session WWDC26 numéro 278 demande déjà de revoir le cycle de vie Scene, les références à UIScreen.main et les décisions de mise en page fondées sur le type d’appareil dans la présentation officielle d’Apple. Le gagnant, pour une équipe qui prépare sa version d’automne, est donc la migration des API iOS 27 dès maintenant : il faut commencer par UIScene, puis les références d’écran, ensuite les choix de largeur et d’orientation, et enfin les changements de taille continus. Il ne faut pas attendre l’annonce d’un iPhone pliable, ni appeler ou deviner un champ interne tel que foldState.

Cette démarche concerne les mainteneurs UIKit qui conservent encore un ancien cycle de vie AppDelegate, les applications mixtes UIKit et SwiftUI qui déduisent la mise en page de userInterfaceIdiom, ainsi que les responsables techniques chargés de sécuriser la livraison avant l’automne. Les travaux strictement liés à une forme matérielle non confirmée peuvent attendre ; les adaptations fondées sur l’espace disponible, elles, sont déjà justifiées par les comportements publics d’iOS 27.

Dernière mise à jour le 20 août 2026 ; les exigences d’API et la méthode de test ont été vérifiées à partir de la session WWDC26 et des notes de version officielles de Xcode 27. Toute nouvelle bêta, version candidate, invitation officielle ou documentation matérielle doit déclencher une nouvelle vérification.

Point de départ : séparer l’API publique de la rumeur matérielle

La décision de migration ne dépend pas du nom commercial, de la diagonale ou du prix d’un éventuel appareil pliable. Ces éléments ne sont pas confirmés par Apple, pas plus que l’identité publique de champs comme foldState ou angleDegrees. Ils ne doivent donc apparaître ni dans les conditions de compilation, ni dans les modèles métier, ni dans les tests de compatibilité.

La base certaine est différente : une application iPhone peut devoir s’afficher dans une fenêtre dont la largeur change, notamment dans iPhone Mirroring et dans des environnements iPad. Une interface qui associe automatiquement « iPhone » à une largeur étroite risque alors de conserver une colonne unique dans un espace large, de couper un panneau vidéo ou de placer un menu au-dessus du contenu. La migration des API iOS 27 doit partir de la géométrie réellement disponible, non d’une hypothèse sur le futur matériel.

Les recherches initiales doivent couvrir les familles suivantes :

  • application(_:didFinishLaunchingWithOptions:) et les autres points d’entrée encore centralisés dans AppDelegate ;
  • UIScreen.main, y compris dans les utilitaires de capture, de rendu, de cache et de génération de miniature ;
  • userInterfaceIdiom, lorsqu’il sert à choisir une colonne, une densité ou un menu ;
  • interfaceOrientation, lorsqu’il contrôle directement les contraintes ;
  • les constantes de largeur, hauteur, ratio ou taille de vignette ;
  • les clés de cache qui ne distinguent pas la taille utile du conteneur ;
  • les contrôleurs présentés comme s’ils appartenaient toujours à un écran unique.

Un registre de migration doit associer chaque occurrence à une page, un composant et un comportement attendu. Cette étape révèle souvent que l’écran visible n’est pas le seul problème : une miniature vidéo calculée avec la taille de l’écran principal peut rester déformée alors que la vue principale s’adapte correctement.

Première étape : installer le socle UIScene

Migration d’un ancien projet UIKit

Le cycle de vie UIScene n’est pas une simple formalité de démarrage. Il fournit le contexte dont les étapes suivantes ont besoin : fenêtre active, scène concernée, géométrie de cette scène et possibilité de gérer plusieurs espaces indépendants. La documentation de UIWindowScene doit servir de référence pour vérifier les responsabilités effectivement prises en charge par le SDK utilisé.

Dans une application UIKit classique, le déplacement se fait par domaines fonctionnels :

  • conserver dans AppDelegate la configuration globale, l’initialisation des services et les événements réellement propres à l’application ;
  • déplacer la création de la fenêtre et du contrôleur racine dans SceneDelegate ;
  • traiter la connexion d’une scène dans scene(_:willConnectTo:options:) ;
  • déplacer l’ouverture d’URL et les activités utilisateur vers les callbacks de scène adaptés ;
  • revoir la restauration d’état afin qu’elle soit attachée à la scène concernée ;
  • supprimer les hypothèses selon lesquelles une seule fenêtre représente toute l’application.

Un modèle minimal peut ressembler à ceci :

func scene(
    _ scene: UIScene,
    willConnectTo session: UISceneSession,
    options connectionOptions: UIScene.ConnectionOptions
) {
    guard let windowScene = scene as? UIWindowScene else { return }

    let window = UIWindow(windowScene: windowScene)
    window.rootViewController = makeRootViewController()
    self.window = window
    window.makeKeyAndVisible()
}

Ce code ne constitue pas une solution de mise en page ; il établit seulement le contexte correct. Les URLs, les notifications et la restauration doivent ensuite être testées séparément. Une migration incomplète peut donner une application qui démarre normalement, mais qui perd une URL reçue dans une deuxième scène ou restaure un état dans la mauvaise fenêtre.

Preuve de fin de phase

La phase est terminée lorsque le lancement à froid, la reprise, l’ouverture d’un lien, la restauration d’état et la création d’une nouvelle scène sont vérifiés avec le SDK récent, sans accès global utilisé uniquement pour retrouver la fenêtre. Pour les équipes qui doivent maintenir plusieurs versions de Xcode, il est préférable d’isoler ce changement dans un commit indépendant ; un retour arrière doit pouvoir restaurer le cycle de vie sans annuler les travaux de layout.

Deuxième étape : remplacer les références globales à l’écran

Pourquoi UIScreen.main devient un mauvais raccourci

UIScreen.main décrit un écran global, alors que la question utile est souvent locale : quelle fenêtre contient cette vue, quelle zone est réellement disponible et quel espace de coordonnées doit recevoir le dessin ? La documentation officielle de UIScreen permet de distinguer l’objet écran des informations propres à une fenêtre ou à une vue.

Il faut classer chaque appel avant de le modifier, car un remplacement mécanique par une autre API reproduirait le même défaut :

  • pour une information sur l’écran associé, partir du UIWindowScene de la fenêtre active ;
  • pour la densité ou certains traits d’environnement, lire le traitCollection du composant concerné ;
  • pour la taille de mise en page, utiliser les bounds de la vue ou du conteneur ;
  • pour une capture, une miniature ou un rendu, transmettre explicitement la taille cible plutôt que consulter un écran global ;
  • pour un affichage externe, gérer la scène et l’écran correspondants au lieu de réutiliser la valeur principale.

Un accès contextuel peut être obtenu à partir d’une vue :

guard let windowScene = view.window?.windowScene else { return }

let availableBounds = view.bounds
let scale = view.traitCollection.displayScale

La taille de view.bounds ne doit toutefois pas être confondue avec la zone sûre, les marges du conteneur ou la surface réellement allouée à un enfant. Dans une interface audio ou vidéo, cette distinction est essentielle : le ratio de la vidéo, la taille du panneau de contrôle et la zone de sous-titrage ne répondent pas nécessairement à la même contrainte.

Contrôle des outils invisibles

Le responsable de la migration doit rechercher les appels indirects, notamment dans les générateurs d’images, les caches, les services de composition et les extensions. Une clé de cache fondée uniquement sur « téléphone » ou « tablette » peut servir une miniature conçue pour une ancienne largeur. De même, une fonction de dessin qui prend UIScreen.main.bounds peut produire une image trop grande, puis la réduire avec une interpolation visible.

Les coordonnées doivent rester cohérentes entre la scène, la fenêtre et la vue. Lorsque plusieurs espaces sont impliqués, la documentation sur l’espace de coordonnées de UIWindowScene fournit le cadre nécessaire pour vérifier les conversions, les superpositions et les éléments positionnés au-dessus d’une vidéo.

Troisième étape : transformer les branches d’appareil en décisions d’espace

Remplacer userInterfaceIdiom dans la mise en page

userInterfaceIdiom peut rester utile pour une fonctionnalité réellement dépendante de la classe d’appareil, d’une capacité ou d’un comportement système. En revanche, il ne doit plus décider seul d’un nombre de colonnes, de la présence d’un menu latéral ou de la densité du contenu. Un appareil identifié comme téléphone peut désormais présenter une surface suffisamment large pour une interface à deux panneaux, tandis qu’un environnement identifié comme tablette peut offrir un conteneur réduit.

La décision doit s’appuyer sur une hiérarchie stable :

  • la taille disponible du conteneur ;
  • les classes de taille et les traits de la vue ;
  • la largeur minimale nécessaire au contenu ;
  • la place réservée aux commandes, aux marges et aux éléments auxiliaires ;
  • le besoin fonctionnel de conserver ou non plusieurs panneaux visibles.

Une règle de layout peut ainsi être formulée sans mentionner un appareil : si la largeur du conteneur permet de conserver la liste, le contenu principal et les contrôles sans réduire la zone interactive sous leur seuil de conception, afficher deux colonnes ; sinon, revenir à une navigation empilée. Les seuils utilisés doivent être documentés par composant, plutôt que disséminés dans des comparaisons difficiles à maintenir.

Distinguer orientation et espace

Une orientation est une donnée fonctionnelle pour une caméra, un capteur de mouvement, un jeu ou un mode de capture. Elle n’est pas automatiquement une instruction de placement. Une branche comme « paysage égal deux colonnes » doit donc être réexaminée : une fenêtre large en orientation portrait peut convenir à une composition dense, tandis qu’une fenêtre paysage étroite peut exiger une pile verticale.

Pour une application SwiftUI et UIKit, le contrat doit être défini à la frontière du composant. Le conteneur UIKit transmet une largeur utile, une hauteur utile et les traits pertinents ; la vue SwiftUI décide ensuite de son affichage à partir de cet espace. L’inverse est également possible, mais deux systèmes ne doivent pas recalculer indépendamment le mode « téléphone » ou « tablette ». Sinon, le parent affiche deux colonnes tandis que l’enfant conserve une largeur de téléphone et tronque son contenu.

Cette réécriture répond directement au problème des applications déformées après un redimensionnement dans iPhone Mirroring : la correction ne consiste pas à ajouter une condition pour le miroir, mais à retirer l’hypothèse selon laquelle la catégorie d’appareil prédit la géométrie.

Quatrième étape : traiter les changements de taille continus

Contraintes et collections

Une fenêtre redimensionnable ne passe pas seulement d’un état final à un autre. Pendant une interaction, les contraintes, les layouts de collection, les positions d’éléments flottants et les surfaces de rendu peuvent recevoir une suite de dimensions intermédiaires. Chaque composant doit donc déclarer ce qui doit être recalculé et ce qui peut rester stable.

Les contrôles à examiner comprennent :

  • les contraintes activées ou désactivées lorsque le nombre de colonnes change ;
  • les UICollectionViewLayout qui conservent une taille d’item obsolète ;
  • les caches de dessin ou de masque qui utilisent une ancienne largeur ;
  • les lecteurs audio et vidéo dont le cadre ou le ratio n’est pas invalidé ;
  • les feuilles, menus et popovers dont la position ne suit plus le conteneur ;
  • les annotations et calques qui restent attachés à une ancienne conversion de coordonnées.

Pour les changements de traits, la logique peut être regroupée dans les points de mise à jour prévus par UIKit, au lieu d’être répartie dans plusieurs callbacks. Pour la géométrie de scène, il faut écouter le changement pertinent de la scène et comparer l’ancienne zone à la nouvelle. Le recalcul doit être idempotent : recevoir deux fois la même géométrie ne doit pas recréer inutilement les données coûteuses.

Éviter le travail lourd à chaque variation

Le redimensionnement interactif ne justifie pas de relancer à chaque événement l’export d’une vidéo, la reconstruction complète d’un modèle audio ou le téléchargement d’une ressource. La vue peut recalculer immédiatement les contraintes légères, tandis que les opérations lourdes sont différées, regroupées ou annulées lorsqu’une nouvelle taille arrive.

Pour une interface de montage vidéo, par exemple, la position des commandes et la surface d’aperçu doivent suivre rapidement la fenêtre, mais la génération d’une nouvelle miniature haute résolution peut attendre la stabilisation. Pour un outil de design, les repères peuvent être recalculés pendant le mouvement, alors qu’un rendu final destiné à l’export ne doit être produit qu’après confirmation de la taille.

Validation des formes intermédiaires

Le test ne doit pas se limiter à une fenêtre étroite et une fenêtre large. Il faut parcourir une largeur réduite, une largeur confortable, une forme presque carrée et un redimensionnement continu. Les critères observables sont plus utiles qu’un simple « l’application ne plante pas » :

  • aucun texte essentiel n’est coupé ;
  • aucune commande ne recouvre une autre zone interactive ;
  • aucun cache ne conserve un ratio ancien ;
  • aucune collection ne présente des cellules superposées ;
  • aucun popover ne sort du conteneur ;
  • la vidéo, l’audio et les contrôles gardent une relation cohérente ;
  • l’état de navigation reste intact après la variation.

Cinquième étape : organiser la validation dans Device Hub

Tests Xcode 27 et Previews

Device Hub doit servir à reproduire plusieurs rapports de fenêtre avant de mobiliser les appareils réels. Les notes de version de Xcode 27 doivent être relues à chaque mise à jour du SDK, car le comportement des outils de test peut évoluer avec les versions bêta.

L’ordre recommandé est le suivant :

  • compiler avec le SDK cible et traiter les avertissements liés au cycle de vie ;
  • lancer l’application avec une fenêtre étroite, puis large ;
  • modifier la largeur pendant que la navigation, une vidéo ou une feuille est active ;
  • répéter le parcours dans Previews pour les composants isolés ;
  • vérifier les scènes multiples et les URLs reçues pendant qu’une scène est déjà ouverte ;
  • comparer les résultats visuels avec les captures de référence ;
  • consigner pour chaque régression la géométrie, la scène, le composant et le commit concerné.

Les Previews accélèrent la vérification des composants, mais elles ne remplacent pas le comportement complet de la scène. Elles ne prouvent pas non plus qu’une caméra, un capteur, un affichage externe ou une fonction de miroir se comportera correctement.

Vérification sur iPhone Mirroring et iPad

La seconde boucle doit utiliser un appareil réel pour iPhone Mirroring et un iPad, car le transport d’entrée, la composition de fenêtre et certaines capacités matérielles ne sont pas entièrement représentés par un environnement simulé. L’équipe doit conserver les mêmes scénarios : ouverture d’un lien, passage d’un écran à deux colonnes, lecture média, affichage d’un menu, rotation lorsqu’elle a une signification fonctionnelle, puis redimensionnement.

Il est prudent de séparer les commits en trois unités réversibles : migration du cycle de vie, remplacement des dépendances globales, puis adaptation des layouts et invalidations. Un défaut découvert dans le rendu vidéo ne doit pas contraindre l’équipe à annuler une correction fiable de UIScene. Cette séparation simplifie également le retour à la version stable si une bêta modifie un comportement.

Les équipes qui doivent isoler une version récente de Xcode peuvent consulter le centre d’aide Mac de KuzCloud pour préparer un environnement distinct. Une fois les besoins définis, la console KuzCloud permet de vérifier l’organisation pratique des environnements accessibles à l’équipe, sans mélanger l’outil de test et le poste de production.

Checklist de migration par dépendance

  • [ ] Recenser AppDelegate, UIScreen.main, userInterfaceIdiom, interfaceOrientation et les constantes de dimensions.
  • [ ] Associer chaque occurrence à une scène, une fenêtre, une vue ou un service technique.
  • [ ] Déplacer la création de fenêtre, les URLs et la restauration d’état vers le cycle de vie UIScene approprié.
  • [ ] Tester le lancement à froid, la reprise, la nouvelle scène et la restauration avec le SDK récent.
  • [ ] Classer chaque usage de UIScreen.main avant de choisir une API de remplacement.
  • [ ] Utiliser le UIWindowScene pour le contexte d’écran, les traits pour l’échelle et les bounds pour la mise en page.
  • [ ] Rechercher les références cachées dans les caches, miniatures, exports audio ou vidéo et outils de dessin.
  • [ ] Remplacer les branches de layout fondées uniquement sur le type d’appareil ou l’orientation.
  • [ ] Définir les décisions de colonnes et de densité à partir de l’espace réellement disponible.
  • [ ] Harmoniser le contrat de géométrie entre UIKit et SwiftUI.
  • [ ] Invalider contraintes, collections, calques, médias et popovers pendant les variations de taille.
  • [ ] Vérifier les largeurs étroites, larges, presque carrées et les redimensionnements continus dans Device Hub.
  • [ ] Rejouer les scénarios sur iPhone Mirroring et iPad réel.
  • [ ] Conserver des commits séparés pour pouvoir annuler une seule famille de changements.
  • [ ] Après une annonce officielle, ajouter uniquement les formes matérielles et tailles documentées par Apple.

Comparaison des environnements de validation

Le choix de l’environnement dépend moins de la rumeur matérielle que de la capacité à reproduire plusieurs versions d’outils et à conserver des résultats comparables. Les équipes doivent éviter de remplacer un poste stable par une bêta sans stratégie de retour.

Option Atout pour cette migration Limite à anticiper Décision recommandée
Mac de développement existant Accès immédiat au projet, aux appareils et aux périphériques locaux Conflit possible entre Xcode stable, SDK récent et extensions de l’équipe Convient si deux environnements peuvent être isolés
Mac séparé dédié aux tests Sépare les builds de migration des livraisons courantes Demande une organisation matérielle et des accès distincts Adapté à une équipe qui teste en parallèle
Mac loué avec KuzCloud Permet de réserver un environnement temporaire pour une phase de migration ou de régression Ne remplace pas les tests nécessitant un périphérique physique particulier Pertinent lorsque le besoin est limité à la préparation et aux essais de fenêtre
Simulateur et Device Hub seuls Accélèrent les variations de taille et les contrôles répétitifs Ne prouvent pas le comportement complet d’iPhone Mirroring, de l’iPad réel ou des capteurs À utiliser en première boucle, jamais comme unique preuve de livraison

Un Mac déjà saturé présente trois défauts concrets dans ce contexte : il oblige à alterner entre les versions de Xcode, il augmente le risque de tester avec le mauvais SDK et il rend plus difficile la reproduction d’une régression pendant qu’un autre membre de l’équipe modifie le projet. Une location KuzCloud peut offrir une séparation plus propre pour une période de migration, tandis qu’un achat local reste préférable pour une charge durable, des périphériques physiques ou un usage quotidien intensif. La comparaison doit donc porter sur la durée du chantier, la nécessité d’un matériel connecté et le degré d’isolement attendu, plutôt que sur la seule disponibilité d’un appareil pliable.

Si l’équipe a besoin d’un environnement temporaire pour maintenir Xcode 27 à côté de la version stable, elle peut consulter les possibilités de Mac distant KuzCloud et choisir une organisation proportionnée au calendrier de validation. Cette approche est particulièrement adaptée à une phase de préversion, à une campagne de non-régression ou à une montée en charge ponctuelle ; elle est moins pertinente lorsqu’un poste doit conserver en permanence des interfaces physiques, des cartes de capture ou des appareils locaux.

La bonne stratégie est donc de livrer maintenant les changements qui reposent sur des API publiques, de conserver une preuve de test par géométrie et de traiter l’annonce matérielle comme une extension de couverture. Lorsque l’iPhone pliable sera officiellement documenté, l’application pourra ajouter des scénarios précis sans réécrire son architecture : une interface conçue autour de l’espace disponible absorbera cette étape avec moins de risques qu’un ensemble de branches codées sur un type d’appareil supposé.

Pour les équipes qui veulent limiter l’interruption du poste principal pendant cette migration, une solution de test temporaire peut servir à isoler Xcode 27, à condition de réserver les validations dépendantes d’un appareil ou d’un périphérique physique au matériel réellement requis.

Préparez vos applications iOS 27 avec KuzCloud

Accédez à des Mac à distance pour adapter progressivement vos interfaces aux fenêtres redimensionnables et aux nouvelles contraintes d’espace.

Centralisez vos environnements de développement et de test afin de vérifier vos migrations d’API avec davantage de régularité.