View in English

  • Global Nav Open Menu Global Nav Close Menu
  • Apple Developer
Search
Cancel
  • Apple Developer
  • News
  • Discover
  • Design
  • Develop
  • Distribute
  • Support
  • Account
Only search within “”

Quick Links

5 Quick Links

Vidéos

Ouvrir le menu Fermer le menu
  • Collections
  • Sujets
  • Toutes les vidéos
  • À propos

Retour à WWDC25

  • À propos
  • Résumé
  • Transcription
  • Code
  • Découvrez les Outils d’écriture

    Les Outils d'écriture permettent de relire, réécrire et transformer du texte directement dans votre app. Découvrez des techniques avancées pour personnaliser les outils d'écriture pour votre app. Explorez les options de mise en forme et leur fonctionnement avec l'édition de texte enrichi. Si vous disposez d'un moteur de texte personnalisé, découvrez comment intégrer en toute transparence l'expérience complète des Outils d'écriture, afin de permettre des modifications directement dans la vue de texte.

    Chapitres

    • 0:00 - Introduction
    • 0:46 - Nouveautés
    • 2:21 - Personnaliser les vues de texte natives
    • 4:00 - Mise en forme de texte enrichi
    • 7:41 - Moteurs de texte personnalisé
    • 16:58 - Étapes suivantes

    Ressources

    • Enhancing your custom text engine with Writing Tools
    • Writing Tools
      • Vidéo HD
      • Vidéo SD

    Vidéos connexes

    WWDC24

    • Get started with Writing Tools
  • Rechercher dans cette vidéo…

    Bonjour et bienvenue dans « Découvrez les Outils d’écriture ». Je m’appelle Dongyuan. Je travaille sur la saisie de texte et l’internationalisation. L’an dernier, nous vous avons présenté les Outils d’écriture et montré comment les intégrer à votre app. Aujourd’hui, nous allons discuter de sujets plus avancés. Je vais vous présenter les nouveautés des Outils d’écriture, les moyens de personnaliser cette expérience dans les vues de texte natives, les méthodes pour que les Outils d’écriture fonctionnent de manière transparente avec du texte enrichi et, enfin, les moyens d’intégrer les Outils d’écriture si votre app dispose d’un moteur de texte personnalisé. C’est parti ! Les Outils d’écriture permettent de trouver les mots justes en réécrivant, en révisant et en résumant du texte directement dans les vues de texte. Nous avons ajouté de nombreuses nouvelles fonctionnalités aux Outils d’écriture. Grâce à l’intégration de ChatGPT, vous pouvez générer du contenu sur tous les sujets sur lesquels vous souhaitez écrire, ou créer des images avec une simple invite.

    Les Outils d’écriture sont désormais disponibles sur visionOS. Ils fonctionnent à peu près partout, y compris dans Mail, Notes et dans les apps que vous créez.

    Sur iOS, iPadOS et macOS 26, après avoir décrit les modifications à apporter au texte, vous pouvez désormais saisir une demande de suivi.

    Par exemple, vous pouvez demander de rendre le texte plus chaleureux, plus familier ou plus motivant.

    Les Outils d’écriture sont disponibles sous forme de Raccourcis pour vous permettre d’améliorer vos flux de travail avec Apple Intelligence. Des Outils tels que la relecture, la réécriture et le résumé peuvent désormais être utilisés de manière automatisée.

    Nous avons ajouté des API pour aider votre app à prendre en charge les Outils d’écriture. Vous pouvez désormais accéder au bouton par défaut de la barre d’outils et aux éléments de menu standard, demander aux Outils d’écriture de renvoyer les intents de présentation pour le texte enrichi, ou intégrer le puissant coordinateur des Outils d’écriture dans votre moteur de texte personnalisé. Nous examinerons ultérieurement les nouvelles options de résultat et l’API de coordination.

    Ensuite, passons à la façon de personnaliser les Outils d’écriture dans les vues de texte natives fournies par le système.

    La vidéo sur les Outils d’écriture de l’an dernier couvre les bases. Pour les vues de texte natives, les Outils d’écriture sont automatiquement pris en charge. Vous pouvez profiter des méthodes de cycle de vie pour réagir aux opérations des Outils d’écriture, telles que l’interruption de la synchronisation, personnaliser votre vue de texte afin d’utiliser un comportement limité ou complet des Outils d’écriture, spécifier des plages pendant lesquelles vous ne souhaitez pas que les Outils d’écriture réécrivent, ou utiliser les options de résultat pour gérer la prise en charge du texte enrichi, des listes ou des tableaux. L’an dernier, les options de résultat étaient nommées « Options d’entrée autorisées ». Elles ont été renommées en « Options de résultat des Outils d’écriture » pour plus de clarté.

    Bien que les Outils d’écriture soient disponibles lorsque vous sélectionnez du texte, si votre app contient beaucoup de texte, ajoutez un bouton à la barre d’outils, comme nous l’avons fait pour Notes et Mail.

    Pour ce faire, utilisez UIBarButtonItem dans UIKit ou NSToolbarItem dans AppKit.

    Dans le menu contextuel, les éléments Outils d’écriture sont insérés automatiquement. Si vous disposez d’une implémentation de menu personnalisée ou souhaitez déplacer les éléments Outils d’écriture, vous pouvez définir automaticallyInsertsWritingToolsItems sur false et utiliser l’API writingToolsItems pour obtenir les éléments standard. Nous avons mis à jour les options Relecture, Réécriture et Résumé dans le menu. L’utilisation de l’API vous garantit de profiter de toutes les mises à jour gratuitement.

    Passons maintenant à la mise en forme.

    Les apps offrent de nombreux types de vues de texte. Certaines vues de texte ne prennent pas en charge le texte enrichi, comme le champ de recherche de Finder. Certaines vues de texte prennent en charge le texte enrichi, comme TextEdit.

    Certaines vues de texte prennent en charge les styles sémantiques, comme Notes. Ici, vous pouvez spécifier des paragraphes avec différents styles sémantiques, tels que titre, sous-titre ou bloc de citation. Par exemple, dans Notes, le résultat des Outils d’écriture peut utiliser des en-têtes, des tableaux et des listes natifs de Notes. Pour indiquer aux Outils d’écriture le type de texte pris en charge par votre vue de texte, utilisez les options de résultat des Outils d’écriture. Pour les vues de texte brut, utilisez l’option de résultat plainText. Les Outils d’écriture utilisent toujours NSAttributedString pour communiquer avec votre vue de texte, mais vous pouvez ignorer en toute sécurité tous les attributs qui s’y trouvent. Pour les vues de texte enrichi, comme celui de TextEdit, utilisez l’option de résultat richText, avec ou sans les options de liste et de tableau, selon que votre vue de texte prend en charge les listes et les tableaux. Les Outils d’écriture peuvent ajouter des attributs d’affichage tels que gras ou italique à la chaîne attribuée.

    Les apps ayant une connaissance spécialisée des formats sémantiques comme Notes peuvent utiliser l’option richText avec la nouvelle option presentationIntent. Les Outils d’écriture utilisent NSAttributedString avec les intents de présentation pour communiquer avec votre vue de texte.

    Vous vous demandez peut-être quelle est la différence entre les attributs d’affichage et les intents de présentation.

    Dans l’exemple TextEdit, les Outils d’écriture produisent du texte enrichi à l’aide d’attributs d’affichage tels que gras ou italique, et envoient la chaîne attribuée à la vue de texte. Ces attributs ne portent que des informations stylistiques telles que des tailles de police concrètes, mais pas d’informations de style sémantique. En revanche, Notes essaie d’utiliser pleinement les styles sémantiques natifs, tels que les en-têtes. Bien que les Outils d’écriture aient généré le même texte en dessous, nous ajoutons à la place des intents de présentation à la chaîne attribuée. Notes peut ensuite convertir les intents de présentation en styles sémantiques internes. À partir de cet exemple, vous pouvez voir que la partie en-têtes n’est qu’une intent d’en-tête sans attributs de police concrets.

    Notez que même si .presentationIntent est spécifié dans les options de résultat, les Outils d’écriture peuvent toujours ajouter des attributs d’affichage à la chaîne attribuée, car certains styles ne peuvent pas être représentés par des intents de présentation. Dans cet exemple, les Outils d’écriture utilisent à la fois une intent de présentation accentuée et un attribut d’affichage barré pour représenter le texte « crucial and deleted » dans la capture d’écran.

    Pour résumer, en mode d’intent de présentation, nous fournirons des styles dans le formulaire d’intent de présentation dans la mesure du possible. Cela inclut des éléments tels que des listes, des tableaux et des blocs de code.

    Les attributs d’affichage peuvent toujours être utilisés pour des attributs tels que soulignement, indice et exposant. Enfin, les intents de présentation n’ont pas de style par défaut. Votre app est responsable de la conversion des intents de présentation en attributs d’affichage ou en styles internes.

    Pour que les Outils d’écriture comprennent mieux la sémantique de votre texte, une fois que vous avez adopté l’option d’intent de présentation, vous pouvez remplacer la méthode requestContexts pour votre vue de texte et fournir, dans la mesure du possible, un contexte avec des intents de présentation.

    Enfin, même si vous disposez d’un moteur de texte entièrement personnalisé, nous avons la solution qui vous convient !

    Vous pouvez profiter gratuitement de l’expérience de base des Outils d’écriture, tant que votre moteur de texte a adopté des protocoles d’édition de texte courants. Sur iOS, il s’agit d’UITextInteraction ou d’UITextSelectionDisplayInteraction avec UIEditMenuInteraction. Sur macOS, votre vue de texte doit adopter NSServicesMenuRequestor pour profiter des Outils d’écriture, ainsi que de la prise en charge des fonctionnalités du menu Services. Pour plus de détails sur l’adoption de base, consultez la session WWDC24.

    Pour aller plus loin, vous pouvez implémenter l’expérience complète des Outils d’écriture. Les Outils d’écriture peuvent ainsi réécrire le texte, fournir une animation et afficher les modifications de relecture directement en ligne. Nous avons ajouté les API de coordination des Outils d’écriture pour les moteurs de texte personnalisés.

    Le coordinateur des Outils d’écriture gère les interactions entre votre vue et les Outils d’écriture.

    Vous attachez un coordinateur à votre vue et créez un délégué pour implémenter les méthodes WritingToolsCoordinatorDelegate. Le délégué prépare le contexte sur lequel les Outils d’écriture doivent travailler, incorpore les modifications, fournit des objets de prévisualisation à utiliser pendant les animations, fournit les coordonnées des Outils d’écriture pour dessiner des marques de relecture et répond aux modifications d’état. Pour rendre tout cela plus concret, voici une démonstration rapide.

    Ceci est un moteur de texte personnalisé construit à l’aide de TextKit 2. Comme vous pouvez le constater, nous avons déjà implémenté des protocoles d’édition de texte courants, tels que NSTextInputClient et NSServicesMenuRequestor.

    Si je crée et exécute l’app, je profite de la prise en charge gratuite des Outils d’écriture de base. Tous les résultats s’affichent dans une sous-fenêtre. Je peux faire une réécriture, par exemple.

    Et remplacez ou copiez le résultat.

    À présent, implémentons la prise en charge complète des Outils d’écriture.

    Dans DocumentView, je vais ajouter des propriétés d’instance nécessaires lors d’une séance Outils d’écriture, initialiser un objet NSWritingToolsCoordinator, définir le délégué sur « self » et l’affecter à une NSView. Je dois également appeler cela « configureWritingTools » dans « init ».

    Bien sûr, il se plaint que DocumentView n’est pas conforme à « NSWritingToolsCoordinator.Delegate ».

    Faisons glisser un fichier qui implémente toutes les méthodes de délégation, dans une extension DocumentView. Vous constatez qu’il prépare le contexte, effectue le remplacement et la sélection de texte, renvoie des zones de délimitation pour la relecture, génère des aperçus pour les animations, etc.

    Passons à la compilation et à l’exécution de l’app.

    Si je réécris le texte, vous voyez l’animation, tandis que le changement de texte s’applique directement dans la vue de texte.

    Et si je relis, vous voyez les soulignements ajoutés par les Outils d’écriture.

    Je peux également cliquer sur les suggestions individuelles pour afficher les changements.

    Détaillons maintenant chacune de ces étapes.

    La première chose à faire est de créer un coordinateur et de l’attacher à une vue. Le coordinateur des Outils d’écriture est une UIInteraction dans UIKit, et vous l’attachez à votre UIView comme les autres UIInteractions. Dans AppKit, il s’agit d’une propriété d’instance sur NSView. Une fois que vous avez un coordinateur, vous pouvez définir le comportement et les options de résultat de vos Outils d’écriture préférés.

    Passons maintenant aux méthodes de délégué. Tout d’abord, les Outils d’écriture ont besoin d’un contexte pour le texte actuel. Un contexte se compose d’un morceau de texte sous forme de NSAttributedString et d’une plage de sélection. Vous devez au minimum inclure la sélection de texte actuelle dans la chaîne attribuée. Vous pouvez également inclure le paragraphe avant et après la sélection, ce qui permet aux Outils d’écriture de mieux comprendre le contexte autour du texte. Définissez la plage sur la sélection actuelle, en fonction de context.attributedString. Si rien n’est sélectionné, renvoyez le document entier comme contexte et définissez la plage à l’emplacement du curseur. Cela permet aux Outils d’écriture de travailler sur l’ensemble du document, si rien n’a été sélectionné spécifiquement. C’est ainsi que vous fournissez le contexte. Ici, je montre AppKit, mais à moins de le souligner spécifiquement, vous pouvez supposer que UIWritingToolsCoordinator et NSWritingToolsCoordinator se comportent de la même façon. Les méthodes de délégué sont asynchrones, car les grandes vues de texte peuvent mettre du temps à traiter le stockage de texte sous-jacent. Dans le corps de la fonction, préparez le texte et la plage en fonction du paramètre « scope ». La plupart du temps, vous ne devez renvoyer qu’un seul contexte. Pour les vues de texte sophistiquées dans lesquelles le texte de plusieurs stockages de texte peut être sélectionné en même temps, le coordinateur prend également en charge plusieurs contextes.

    Après avoir évalué le texte de votre vue, les Outils d’écriture proposent des modifications à apporter à votre objet délégué. Dans cette méthode de remplacement de délégué de texte, incorporez la modification dans le stockage de texte de votre vue. Les Outils d’écriture utilisent cette méthode pour chaque modification distincte et plusieurs fois avec des valeurs de plage différentes pour le même objet de contexte. Une fois le traitement terminé, les Outils d’écriture peuvent demander au délégué de mettre à jour la plage de texte sélectionnée.

    Pour animer le texte pendant le traitement des Outils d’écriture, le coordinateur demande des images de prévisualisation pour certaines plages de texte.

    La vue de texte doit renvoyer des aperçus en affichant le texte sur un arrière-plan clair. Lors des animations, les Outils d’écriture appliquent les effets visuels aux images d’aperçu fournies plutôt qu’au texte lui-même. Sur macOS, cela se fait via deux méthodes de délégué. La première méthode de délégué prend un tableau. Vous devez renvoyer au moins un aperçu pour toute la plage. Vous pouvez également renvoyer un aperçu par ligne pour une animation plus fluide.

    Sur iOS, UIKit utilise UITargetedPreview au lieu de NSTextPreview, et une seule méthode de délégué est utilisée.

    Avant et après l’animation à proprement parler, les Outils d’écriture utilisent les méthodes prepareFor et finish. Pour préparer l’animation de texte, masquez la plage de texte spécifique de la vue de texte. Une fois l’animation terminée, affichez de nouveau la plage de texte spécifique.

    Pour la révision, les Outils d’écriture affichent un soulignement pour les plages de texte ayant été modifiées. Les Outils d’écriture réagissent également aux événements de clic dans les plages de texte pour afficher la fenêtre contextuelle de relecture en ligne.

    Pour afficher les marques de relecture, le coordinateur demande au délégué de renvoyer les chemins de Bézier soulignées pour les plages individuelles. Les Outils d’écriture ont également besoin du chemin de Bézier de délimitation pour répondre aux événements de clic ou de touche.

    Enfin, vous pouvez implémenter la méthode facultative writingToolsCoordinator:willChangeToState:completion: pour répondre aux modifications d’état. Vous pouvez effectuer une fusion d’annulation, arrêter la synchronisation ou empêcher la modification, en fonction de votre implémentation de la vue de texte. À l’inverse, vous devez informer le coordinateur des modifications externes via updateRange:withText, pour vous assurer que les opérations des Outils d’écriture sont synchronisées avec le texte le plus récent. Utilisez updateForReflowedText pour informer les Outils d’écriture des modifications apportées à la mise en page de votre vue. Lorsque vous utilisez cette méthode, les Outils d’écriture demandent de nouveaux aperçus, des marques de relecture et d’autres informations qui dépendent de la mise en page.

    Nous avons vu comment intégrer l’ensemble de l’expérience des Outils d’écriture à votre puissant moteur de texte personnalisé. Nous avons également publié le projet que j’ai montré plus tôt sous forme d’exemple de code. Consultez l’exemple de code et la documentation complète sur le coordinateur des Outils d’écriture pour en savoir plus.

    Voilà qui conclut la séance. Et ensuite ? Essayez les nouvelles fonctionnalités des Outils d’écriture. Par exemple, les ajustements de suivi après avoir décrit vos modifications. Ou les Outils d’écriture de Vision Pro et de l’app Raccourcis.

    Ajoutez un bouton dans la barre d’outils si votre app contient beaucoup de texte.

    Jouez avec les options de mise en forme pour permettre aux Outils d’écriture de lire et d’écrire les styles sémantiques, tels que les titres, les sous-titres et les blocs de code.

    Si vous disposez déjà d’un puissant moteur de texte, augmentez sa puissance avec l’expérience complète des Outils d’écriture.

    Consultez également « Get started with Writing Tools » de l’an dernier et l’exemple de code des Outils d’écriture ci-dessous pour voir comment fonctionne le coordinateur des Outils d’écriture en action. Merci de votre attention !

    • 11:46 - Attach a coordinator to the view (UIKit)

      // Attach a coordinator to the view
      // UIKit
      
      func configureWritingTools() {
          guard UIWritingToolsCoordinator.isWritingToolsAvailable else { return }
      
          let coordinator = UIWritingToolsCoordinator(delegate: self)
          addInteraction(coordinator)
      }
    • 12:02 - Attach a coordinator to the view (AppKit)

      // Attach a coordinator to the view
      // AppKit
      
      func configureWritingTools() {
          guard NSWritingToolsCoordinator.isWritingToolsAvailable else { return }
             
          let coordinator = NSWritingToolsCoordinator(delegate: self)
      
          coordinator.preferredBehavior = .complete
          coordinator.preferredResultOptions = [.richText, .list]
          writingToolsCoordinator = coordinator
      }
    • 13:06 - Prepare the context

      // Prepare the context
      
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              requestsContextsFor scope: NSWritingToolsCoordinator.ContextScope,
              completion: @escaping ([NSWritingToolsCoordinator.Context]) -> Void) {
      
          var contexts = [NSWritingToolsCoordinator.Context]()
                      
          switch scope {
          case .userSelection:
              let context = getContextObjectForSelection()
              contexts.append(context)
              break
              // other cases…
          }
              
          // Save references to the contexts for later delegate calls.
          storeContexts(contexts)
          completion(contexts)
      }
    • 13:48 - Respond to text changes from Writing Tools and update selected range

      // Respond to text changes from Writing Tools
      
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              replace range: NSRange,
              in context: NSWritingToolsCoordinator.Context,
              proposedText replacementText: NSAttributedString,
              reason: NSWritingToolsCoordinator.TextReplacementReason,
              animationParameters: NSWritingToolsCoordinator.AnimationParameters?,
              completion: @escaping (NSAttributedString?) -> Void) {
      }
      
      // Update selected range
      
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              select ranges: [NSValue],
              in context: NSWritingToolsCoordinator.Context,
              completion: @escaping () -> Void) {
      }
    • 14:41 - Generate preview for animation (AppKit)

      // Generate preview for animation (macOS)
      
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              requestsPreviewFor textAnimation: NSWritingToolsCoordinator.TextAnimation,
              of range: NSRange,
              in context: NSWritingToolsCoordinator.Context,
              completion: @escaping ([NSTextPreview]?) -> Void) {
      }
          
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              requestsPreviewFor rect: NSRect,
              in context: NSWritingToolsCoordinator.Context,
              completion: @escaping (NSTextPreview?) -> Void) {
      }
    • 14:58 - Generate preview for animation (UIKit)

      // Generate preview for animation (iOS)
      
      func writingToolsCoordinator(_ writingToolsCoordinator: UIWritingToolsCoordinator,
              requestsPreviewFor textAnimation: UIWritingToolsCoordinator.TextAnimation,
              of range: NSRange,
              in context: UIWritingToolsCoordinator.Context,
              completion: @escaping (UITargetedPreview?) -> Void) {
      }
    • 15:08 - Delegate callbacks before and after animation

      // Generate preview for animation
      
      func writingToolsCoordinator(
          _ writingToolsCoordinator: NSWritingToolsCoordinator,
          prepareFor textAnimation: NSWritingToolsCoordinator.TextAnimation,
          for range: NSRange,
          in context: NSWritingToolsCoordinator.Context,
          completion: @escaping () -> Void) {
      
          // Hide the specific range of text from the text view
      }
      
      func writingToolsCoordinator(
          _ writingToolsCoordinator: NSWritingToolsCoordinator,
          finish textAnimation: NSWritingToolsCoordinator.TextAnimation,
          for range: NSRange,
          in context: NSWritingToolsCoordinator.Context,
          completion: @escaping () -> Void) {
      
          // Show the specific range of text again
      }
    • 15:39 - Delegate callbacks to show proofreading marks

      // Create proofreading marks
      
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              requestsUnderlinePathsFor range: NSRange,
              in context: NSWritingToolsCoordinator.Context,
              completion: @escaping ([NSBezierPath]) -> Void) {
      }
      
      func writingToolsCoordinator(_ writingToolsCoordinator: NSWritingToolsCoordinator,
              requestsBoundingBezierPathsFor range: NSRange,
              in context: NSWritingToolsCoordinator.Context,
              completion: @escaping ([NSBezierPath]) -> Void) {
      }
    • 0:00 - Introduction
    • Dans cette vidéo, nous passerons en revue les nouveautés des Outils d’écriture, la façon dont vous pouvez personnaliser l’expérience de votre app, prendre en charge le texte enrichi et intégrer le tout à des moteurs de texte personnalisés.

    • 0:46 - Nouveautés
    • Les Outils d’écriture prennent désormais en charge l’intégration avec ChatGPT, visionOS, les demandes de suivi pour faire des ajustements de ton et l’automatisation à l’aide de Raccourcis. Les Outils d’écriture fournissent également de nouvelles API pour vous aider à les intégrer à votre app.

    • 2:21 - Personnaliser les vues de texte natives
    • Si votre app utilise des vues de texte natives, les Outils d’écriture sont automatiquement pris en charge. Vous pouvez personnaliser davantage l’expérience en adoptant des méthodes de cycle de vie pour réagir à des opérations telles que la pause de la synchronisation, la spécification de plages ignorées dans le texte, l’ajout d’un bouton à la barre d’outils ou la personnalisation de menus contextuels.

    • 4:00 - Mise en forme de texte enrichi
    • Les Outils d’écriture prennent désormais en charge le texte enrichi avec les styles sémantiques. Si votre app prend en charge les intents de présentation telles que les titres, les sous-titres, les citations, les tableaux et les listes, vous pouvez communiquer ces informations aux Outils d’écriture. Les Outils d’écriture fourniront, dans la mesure du possible, des résultats en utilisant des styles dans l’intent de présentation pris en charge par votre app.

    • 7:41 - Moteurs de texte personnalisé
    • Si votre app utilise un moteur de texte personnalisé, vous pouvez désormais activer une expérience entièrement intégrée avec les Outils d’écriture. L’expérience de base des Outils d’écriture fonctionne automatiquement, à condition que vous adoptiez des protocoles d’édition de texte courants. L’expérience complète des Outils d’écriture permet à ces derniers de réécrire le texte directement sur place, de fournir des animations et d’afficher les corrections apportées intralignes. Pour une expérience complète, utilisez la nouvelle API de coordinateur des Outils d’écriture afin de les intégrer à votre moteur de texte personnalisé.

    • 16:58 - Étapes suivantes
    • Découvrez les nouvelles fonctionnalités des Outils d’écriture et profitez de la personnalisation et de la prise en charge du texte enrichi dans votre app. Si vous disposez d’un moteur de texte personnalisé, activez l’expérience complète des Outils d’écriture en adoptant l’API de coordinateur.

Developer Footer

  • Vidéos
  • WWDC25
  • Découvrez les Outils d’écriture
  • Open Menu Close Menu
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    Open Menu Close Menu
    • Swift
    • SwiftUI
    • Swift Playground
    • TestFlight
    • Xcode
    • Xcode Cloud
    • Icon Composer
    • SF Symbols
    Open Menu Close Menu
    • Accessibility
    • Accessories
    • App Store
    • Audio & Video
    • Augmented Reality
    • Business
    • Design
    • Distribution
    • Education
    • Fonts
    • Games
    • Health & Fitness
    • In-App Purchase
    • Localization
    • Maps & Location
    • Machine Learning & AI
    • Open Source
    • Security
    • Safari & Web
    Open Menu Close Menu
    • Documentation
    • Sample Code
    • Tutorials
    • Downloads
    • Forums
    • Videos
    Open Menu Close Menu
    • Support Articles
    • Contact Us
    • Bug Reporting
    • System Status
    Open Menu Close Menu
    • Apple Developer
    • App Store Connect
    • Certificates, IDs, & Profiles
    • Feedback Assistant
    Open Menu Close Menu
    • Apple Developer Program
    • Apple Developer Enterprise Program
    • App Store Small Business Program
    • MFi Program
    • News Partner Program
    • Video Partner Program
    • Security Bounty Program
    • Security Research Device Program
    Open Menu Close Menu
    • Meet with Apple
    • Apple Developer Centers
    • App Store Awards
    • Apple Design Awards
    • Apple Developer Academies
    • WWDC
    Get the Apple Developer app.
    Copyright © 2025 Apple Inc. All rights reserved.
    Terms of Use Privacy Policy Agreements and Guidelines