Extensions iOS dans Xamarin.iOS

Vidéo Création d’extensions dans iOS

Les extensions, telles que introduites dans iOS 8, sont spécialisées UIViewControllers qui sont présentées par iOS dans des contextes standard tels que dans le Centre de notifications, en tant que types de clavier personnalisés demandés par l’utilisateur pour effectuer une entrée spécialisée ou d’autres contextes tels que la modification d’une photo où l’extension peut fournir des filtres d’effets spéciaux.

Toutes les extensions sont installées conjointement avec une application conteneur (avec les deux éléments écrits à l’aide des API unifiées 64 bits) et sont activées à partir d’un point d’extension particulier dans une application hôte. Et comme ils seront utilisés comme compléments aux fonctions système existantes, ils doivent être hautes performances, maigres et robustes.

Points d’extension

Type	Description	Point d’extension	Application hôte
Action	Éditeur ou visionneuse spécialisé pour un type de média particulier	com.apple.ui-services	Quelconque
Fournisseur de documents	Permet à l’application d’utiliser un magasin de documents distant	com.apple.fileprovider-ui	Applications utilisant un UIDocumentPickerViewController
Clavier	Claviers alternatifs	com.apple.keyboard-service	Quelconque
Retouche photo	Manipulation et modification de photos	com.apple.photo-editing	éditeur Photos.app
Partager	Partage des données avec des réseaux sociaux, des services de messagerie, etc.	com.apple.share-services	Quelconque
Aujourd’hui	« Widgets » qui s’affichent sur l’écran Aujourd’hui ou le Centre de notifications	com.apple.widget-extensions	Aujourd’hui et Centre de notifications

Des points d’extension supplémentaires ont été ajoutés dans iOS 10 et iOS 12. Vous trouverez le tableau complet de tous les types pris en charge dans le Guide de programmation de l’extension d’application iOS.

Limites

Les extensions ont un certain nombre de limitations, dont certaines sont universelles pour tous les types (par instance, aucun type d’extension ne peut accéder aux caméras ou aux microphones), tandis que d’autres types d’extension peuvent avoir des limitations spécifiques sur leur utilisation (pour instance, les claviers personnalisés ne peuvent pas être utilisés pour les champs de saisie de données sécurisés tels que les mots de passe).

Les limitations universelles sont les suivantes :

• Les infrastructures d’interface utilisateur du kit d’intégrité et du kit d’événements ne sont pas disponibles
• Les extensions ne peuvent pas utiliser les modes d’arrière-plan étendus
• Les extensions ne peuvent pas accéder aux caméras ou microphones de l’appareil (bien qu’elles puissent accéder aux fichiers multimédias existants)
• Les extensions ne peuvent pas recevoir de données Air Drop (bien qu’elles puissent transmettre des données via Air Drop)
• UIActionSheet et UIAlertView ne sont pas disponibles ; les extensions doivent utiliser UIAlertController
• Plusieurs membres d’UIApplication ne sont pas disponibles : UIApplication.SharedApplication, UIApplication.OpenUrl, UIApplication.BeginIgnoringInteractionEvents et UIApplication.EndIgnoringInteractionEvents
• iOS applique une limite d’utilisation de la mémoire de 16 Mo sur les extensions d’aujourd’hui.
• Par défaut, les extensions clavier n’ont pas accès au réseau. Cela affecte le débogage sur l’appareil (la restriction n’est pas appliquée dans le simulateur), car Xamarin.iOS nécessite un accès réseau pour que le débogage fonctionne. Il est possible de demander l’accès réseau en définissant la Requests Open Access valeur dans info.plist du projet sur Yes. Pour plus d’informations sur les limitations de l’extension de clavier, consultez le Guide du clavier personnalisé d’Apple.

Pour connaître les limitations individuelles, consultez le Guide de programmation des extensions d’application d’Apple.

Distribution, installation et exécution d’extensions

Les extensions sont distribuées à partir d’une application conteneur, qui, à son tour, est envoyée et distribuée via le App Store. La ou les extensions distribuées avec l’application sont installées à ce stade, mais l’utilisateur doit activer chaque extension explicitement. Les différents types d’extensions sont activés de différentes manières ; plusieurs nécessitent que l’utilisateur accède à l’application Paramètres et les active à partir de là. Tandis que d’autres sont activés au point d’utilisation, comme l’activation d’une extension de partage lors de l’envoi d’une photo.

L’application dans laquelle l’extension est utilisée (où l’utilisateur rencontre le point d’extension) est appelée application hôte, car il s’agit de l’application qui héberge l’extension lorsqu’elle s’exécute. L’application qui installe l’extension est l’application conteneur, car il s’agit de l’application qui contenait l’extension lors de son installation.

En règle générale, l’application conteneur décrit l’extension et guide l’utilisateur tout au long du processus de son activation.

Déboguer et publier des versions d’extensions

Les limites de mémoire pour l’exécution des extensions d’application sont considérablement inférieures aux limites de mémoire appliquées à une application de premier plan. Les simulateurs exécutant iOS ont moins de restrictions appliquées aux extensions, et vous pouvez exécuter votre extension sans aucun problème. Toutefois, l’exécution de la même extension sur un appareil peut entraîner des résultats inattendus, notamment le blocage ou l’arrêt agressif de l’extension par le système. Par conséquent, veillez à générer et tester l’extension sur un appareil avant de l’expédier.

Vous devez vous assurer que les paramètres suivants sont appliqués au projet de conteneur et à toutes les extensions référencées :

1. Générez un package d’application dans la configuration release .
2. Dans les paramètres du projet Build iOS , définissez l’option Comportement de l’éditeur de liens sur Lier uniquement les KITS SDK d’infrastructure ou Lier tout.
3. Dans les paramètres du projet Debug iOS , décochez l’option Activer le débogage et Activer le profilage .

Cycle de vie de l’extension

Une extension peut être aussi simple qu’un seul UIViewController ou des extensions plus complexes qui présentent plusieurs écrans d’interface utilisateur. Lorsque l’utilisateur rencontre un point d’extension (par exemple, lors du partage d’une image), il a la possibilité de choisir parmi les extensions inscrites pour ce point d’extension.

S’ils choisissent l’une des extensions de votre application, son UIViewController est instancié et commence le cycle de vie normal du contrôleur d’affichage. Toutefois, contrairement à une application normale, qui est suspendue mais ne se termine généralement pas lorsque l’utilisateur a fini d’interagir avec elle, les extensions sont chargées, exécutées, puis arrêtées à plusieurs reprises.

Les extensions peuvent communiquer avec leurs applications hôtes via un objet NSExtensionContext . Certaines extensions ont des opérations qui reçoivent des rappels asynchrones avec les résultats. Ces rappels seront exécutés sur les threads d’arrière-plan et l’extension doit en tenir compte ; pour instance, en utilisant NSObject.InvokeOnMainThread s’ils souhaitent mettre à jour l’interface utilisateur. Pour plus d’informations, consultez la section Communication avec l’application hôte ci-dessous.

Par défaut, les extensions et leurs applications conteneur ne peuvent pas communiquer, bien qu’elles soient installées ensemble. Dans certains cas, l’application conteneur est essentiellement un conteneur « d’expédition » vide dont l’objectif est servi une fois l’extension installée. Toutefois, si les circonstances l’exigent, l’application conteneur et l’extension peuvent partager des ressources à partir d’une zone commune. En outre, une extension Today peut demander à son application conteneur d’ouvrir une URL. Ce comportement est illustré dans le widget Compte à rebours d’événements.

Création d’une extension

Les extensions (et leurs applications conteneur) doivent être des binaires 64 bits et générées à l’aide des API unifiées Xamarin.iOS. Lors du développement d’une extension, vos solutions contiennent au moins deux projets : l’application conteneur et un projet pour chaque extension que le conteneur fournit.

Exigences du projet d’application conteneur

L’application conteneur utilisée pour installer l’extension a les exigences suivantes :

• Il doit conserver une référence au projet d’extension.
• Il doit s’agir d’une application complète (doit être en mesure de lancer et de s’exécuter correctement), même si elle ne fait rien de plus que de fournir un moyen d’installer une extension.
• Il doit avoir un identificateur de bundle qui est la base de l’identificateur de bundle du projet d’extension (voir la section ci-dessous pour plus d’informations).

Configuration requise pour le projet d’extension

En outre, le projet de l’extension a les exigences suivantes :

• Il doit avoir un identificateur de bundle qui commence par l’identificateur de bundle de son application conteneur. Par exemple, si l’application conteneur a un identificateur de bundle de com.myCompany.ContainerApp, l’identificateur de l’extension peut être com.myCompany.ContainerApp.MyExtension:

  

• Il doit définir la clé NSExtensionPointIdentifier, avec une valeur appropriée (par com.apple.widget-extension exemple, pour un widget Centre de notifications aujourd’hui ), dans son Info.plist fichier.

• Il doit également définir laNSExtensionMainStoryboard clé ou la NSExtensionPrincipalClass clé dans son Info.plist fichier avec une valeur appropriée :

  • Utilisez la NSExtensionMainStoryboard clé pour spécifier le nom du Storyboard qui présente l’interface utilisateur main pour l’extension (moins .storyboard). Par exemple, Main pour le Main.storyboard fichier .
  • Utilisez la NSExtensionPrincipalClass clé pour spécifier la classe qui sera initialisée au démarrage de l’extension. La valeur doit correspondre à la valeur Register de votre UIViewController:

  

Des types spécifiques d’extensions peuvent avoir des exigences supplémentaires. Par instance, la classe principale d’une extension Today ou notification Center doit implémenter INCWidgetProviding.

Important

Si vous démarrez votre projet à l’aide de l’un des modèles d’extensions fournis par Visual Studio pour Mac, la plupart (sinon toutes) ces exigences seront fournies et remplies automatiquement par le modèle.

Procédure pas à pas

Dans la procédure pas à pas suivante, vous allez créer un exemple de widget Aujourd’hui qui calcule le jour et le nombre de jours restant dans l’année :

Création de la solution

Pour créer la solution requise, procédez comme suit :

1. Tout d’abord, créez un projet d’application iOS à affichage unique , puis cliquez sur le bouton Suivant :

   

2. Appelez le projet TodayContainer et cliquez sur le bouton Suivant :

   

3. Vérifiez le nom du projet et le nom de la solution , puis cliquez sur le bouton Créer pour créer la solution :

   

4. Ensuite, dans le Explorateur de solutions, cliquez avec le bouton droit sur la solution et ajoutez un nouveau projet d’extension iOS à partir du modèle Extension d’aujourd’hui :

   

5. Appelez le projet DaysRemaining et cliquez sur le bouton Suivant :

   

6. Passez en revue le projet, puis cliquez sur le bouton Créer pour le créer :

   

La solution résultante doit maintenant avoir deux projets, comme illustré ici :

Création de l’interface utilisateur de l’extension

Ensuite, vous devez concevoir l’interface pour votre widget Aujourd’hui . Cela peut être effectué à l’aide d’un Storyboard ou en créant l’interface utilisateur dans le code. Les deux méthodes seront décrites ci-dessous en détail.

Utilisation de storyboards

Pour générer l’interface utilisateur avec un Storyboard, procédez comme suit :

1. Dans le Explorateur de solutions, double-cliquez sur le fichier du projet d’extension pour l’ouvrir Main.storyboard pour le modifier :

   

2. Sélectionnez l’étiquette qui a été automatiquement ajoutée à l’interface utilisateur par modèle et donnez-lui le NomTodayMessage sous l’onglet Widget du Explorer Propriétés :

   

3. Enregistrez les modifications apportées au Storyboard.

Utilisation du code

Pour générer l’interface utilisateur dans le code, procédez comme suit :

1. Dans le Explorateur de solutions, sélectionnez le projet DaysRemaining, ajoutez une nouvelle classe et appelez-la CodeBasedViewController:

   

2. Là encore, dans le Explorateur de solutions, double-cliquez sur le fichier de l’extension pour l’ouvrir Info.plist pour le modifier :

   

3. Sélectionnez l’affichage source (en bas de l’écran) et ouvrez le NSExtension nœud :

   

4. Supprimez la NSExtensionMainStoryboard clé et ajoutez un NSExtensionPrincipalClass avec la valeur CodeBasedViewController:

   

5. Enregistrez vos modifications.

Ensuite, modifiez le CodeBasedViewController.cs fichier et faites-le ressembler à ce qui suit :

using System;
using Foundation;
using UIKit;
using NotificationCenter;
using CoreGraphics;

namespace DaysRemaining
{
  [Register("CodeBasedViewController")]
  public class CodeBasedViewController : UIViewController, INCWidgetProviding
  {
    public CodeBasedViewController ()
    {
    }

    public override void ViewDidLoad ()
    {
      base.ViewDidLoad ();

      // Add label to view
      var TodayMessage = new UILabel (new CGRect (0, 0, View.Frame.Width, View.Frame.Height)) {
        TextAlignment = UITextAlignment.Center
      };

      View.AddSubview (TodayMessage);

      // Insert code to power extension here...

    }
  }
}

Notez que le correspond à [Register("CodeBasedViewController")] la valeur que vous avez spécifiée pour ce NSExtensionPrincipalClass qui précède.

Codage de l’extension

Une fois l’interface utilisateur créée, ouvrez le TodayViewController.csCodeBasedViewController.cs fichier ou (en fonction de la méthode utilisée pour créer l’interface utilisateur ci-dessus), modifiez la méthode ViewDidLoad et faites-la ressembler à ce qui suit :

public override void ViewDidLoad ()
{
  base.ViewDidLoad ();

  // Calculate the values
  var dayOfYear = DateTime.Now.DayOfYear;
  var leapYearExtra = DateTime.IsLeapYear (DateTime.Now.Year) ? 1 : 0;
  var daysRemaining = 365 + leapYearExtra - dayOfYear;

  // Display the message
  if (daysRemaining == 1) {
    TodayMessage.Text = String.Format ("Today is day {0}. There is one day remaining in the year.", dayOfYear);
  } else {
    TodayMessage.Text = String.Format ("Today is day {0}. There are {1} days remaining in the year.", dayOfYear, daysRemaining);
  }
}

Si vous utilisez la méthode d’interface utilisateur basée sur le code, remplacez le // Insert code to power extension here... commentaire par le nouveau code ci-dessus. Après avoir appelé l’implémentation de base (et inséré une étiquette pour la version basée sur le code), ce code effectue un calcul simple pour obtenir le jour de l’année et le nombre de jours restants. Ensuite, il affiche le message dans l’étiquette (TodayMessage) que vous avez créée dans la conception de l’interface utilisateur.

Notez à quel point ce processus est similaire au processus normal d’écriture d’une application. Une extension a le même cycle de UIViewController vie qu’un contrôleur d’affichage dans une application, sauf que les extensions n’ont pas de modes d’arrière-plan et ne sont pas suspendues lorsque l’utilisateur a terminé de les utiliser. Au lieu de cela, les extensions sont initialisées et désaffectées à plusieurs reprises en fonction des besoins.

Création de l’interface utilisateur de l’application conteneur

Pour cette procédure pas à pas, l’application conteneur est simplement utilisée comme méthode d’expédition et d’installation de l’extension et ne fournit aucune fonctionnalité propre. Modifiez le fichier de Main.storyboard TodayContainer et ajoutez du texte définissant la fonction de l’extension et comment l’installer :

Enregistrez les modifications apportées au Storyboard.

Test de l’extension

Pour tester votre extension dans le simulateur iOS, exécutez l’application TodayContainer . La vue main du conteneur s’affiche :

Ensuite, appuyez sur le bouton Accueil dans le simulateur, balayez vers le bas en haut de l’écran pour ouvrir le Centre de notifications, sélectionnez l’onglet Aujourd’hui , puis cliquez sur le bouton Modifier :

Ajoutez l’extension DaysRemaining à la vue Aujourd’hui , puis cliquez sur le bouton Terminé :

Le nouveau widget sera ajouté à la vue Aujourd’hui et les résultats seront affichés :

Communication avec l’application hôte

L’exemple d’extension Today que vous avez créé ci-dessus ne communique pas avec son application hôte (l’écran Aujourd’hui ). Si c’était le cas, il utiliserait la propriété ExtensionContext des TodayViewController classes ou CodeBasedViewController .

Pour les extensions qui recevront des données de leurs applications hôtes, les données sont sous la forme d’un tableau d’objets NSExtensionItem stockés dans la propriété InputItems de l’ExtensionContext de l’extension UIViewController.

D’autres extensions, telles que les extensions de retouche photo, peuvent faire la distinction entre l’utilisateur qui termine ou annule l’utilisation. Cela sera signalé à l’application hôte via les méthodes CompleteRequest et CancelRequest de la propriété ExtensionContext .

Pour plus d’informations, consultez le Guide de programmation de l’extension d’application d’Apple.

Communication avec l’application parente

Un App Group est un groupe qui permet à différentes applications (ou à une application et ses extensions) d’accéder à un emplacement partagé du stockage de fichiers. Vous pouvez utiliser des App Groups pour les données suivantes, par exemple :

• Paramètres de l’Apple Watch.
• NSUserDefaults partagés.
• Fichiers partagés.

Pour plus d’informations, consultez la section Groupes d’applications de notre documentation Utilisation des fonctionnalités .

MobileCoreServices

Lorsque vous utilisez des extensions, utilisez un identificateur de type uniforme (UTI) pour créer et manipuler des données échangées entre l’application, d’autres applications et/ou services.

La MobileCoreServices.UTType classe statique définit les propriétés d’assistance suivantes liées aux définitions d’Apple kUTType... :

• kUTTypeAlembic - Alembic
• kUTTypeAliasFile - AliasFile
• kUTTypeAliasRecord - AliasRecord
• kUTTypeAppleICNS - AppleICNS
• kUTTypeAppleProtectedMPEG4Audio - AppleProtectedMPEG4Audio
• kUTTypeAppleProtectedMPEG4Video - AppleProtectedMPEG4Video
• kUTTypeAppleScript - AppleScript
• kUTTypeApplication - Application
• kUTTypeApplicationBundle - ApplicationBundle
• kUTTypeApplicationFile - ApplicationFile
• kUTTypeArchive - Archive
• kUTTypeAssemblyLanguageSource - AssemblyLanguageSource
• kUTTypeAudio - Audio
• kUTTypeAudioInterchangeFileFormat - AudioInterchangeFileFormat
• kUTTypeAudiovisualContent - AudiovisualContent
• kUTTypeAVIMovie - AVIMovie
• kUTTypeBinaryPropertyList - BinaryPropertyList
• kUTTypeBMP - BMP
• kUTTypeBookmark - Bookmark
• kUTTypeBundle - Bundle
• kUTTypeBzip2Archive - Bzip2Archive
• kUTTypeCalendarEvent - CalendarEvent
• kUTTypeCHeader - CHeader
• kUTTypeCommaSeparatedText - CommaSeparatedText
• kUTTypeCompositeContent - CompositeContent
• kUTTypeConformsToKey - ConformsToKey
• kUTTypeContact - Contact
• kUTTypeContent - Content
• kUTTypeCPlusPlusHeader - CPlusPlusHeader
• kUTTypeCPlusPlusSource - CPlusPlusSource
• kUTTypeCSource - CSource
• kUTTypeData - Database
• kUTTypeDelimitedText - DelimitedText
• kUTTypeDescriptionKey - DescriptionKey
• kUTTypeDirectory - Directory
• kUTTypeDiskImage - DiskImage
• kUTTypeElectronicPublication - ElectronicPublication
• kUTTypeEmailMessage - EmailMessage
• kUTTypeExecutable - Executable
• kUTExportedTypeDeclarationsKey - ExportedTypeDeclarationsKey
• kUTTypeFileURL - FileURL
• kUTTypeFlatRTFD - FlatRTFD
• kUTTypeFolder - Folder
• kUTTypeFont - Font
• kUTTypeFramework - Framework
• kUTTypeGIF - GIF
• kUTTypeGNUZipArchive - GNUZipArchive
• kUTTypeHTML - HTML
• kUTTypeICO - ICO
• kUTTypeIconFileKey - IconFileKey
• kUTTypeIdentifierKey - IdentifierKey
• kUTTypeImage - Image
• kUTImportedTypeDeclarationsKey - ImportedTypeDeclarationsKey
• kUTTypeInkText - InkText
• kUTTypeInternetLocation - InternetLocation
• kUTTypeItem - Item
• kUTTypeJavaArchive - JavaArchive
• kUTTypeJavaClass - JavaClass
• kUTTypeJavaScript - JavaScript
• kUTTypeJavaSource - JavaSource
• kUTTypeJPEG - JPEG
• kUTTypeJPEG2000 - JPEG2000
• kUTTypeJSON - JSON
• kUTType3dObject - k3dObject
• kUTTypeLivePhoto - LivePhoto
• kUTTypeLog - Log
• kUTTypeM3UPlaylist - M3UPlaylist
• kUTTypeMessage - Message
• kUTTypeMIDIAudio - MIDIAudio
• kUTTypeMountPoint - MountPoint
• kUTTypeMovie - Movie
• kUTTypeMP3 - MP3
• kUTTypeMPEG - MPEG
• kUTTypeMPEG2TransportStream - MPEG2TransportStream
• kUTTypeMPEG2Video - MPEG2Video
• kUTTypeMPEG4 - MPEG4
• kUTTypeMPEG4Audio - MPEG4Audio
• kUTTypeObjectiveCPlusPlusSource - ObjectiveCPlusPlusSource
• kUTTypeObjectiveCSource - ObjectiveCSource
• kUTTypeOSAScript - OSAScript
• kUTTypeOSAScriptBundle - OSAScriptBundle
• kUTTypePackage - Package
• kUTTypePDF - PDF
• kUTTypePerlScript - PerlScript
• kUTTypePHPScript - PHPScript
• kUTTypePICT - PICT
• kUTTypePKCS12 - PKCS12
• kUTTypePlainText - PlainText
• kUTTypePlaylist - Playlist
• kUTTypePluginBundle - PluginBundle
• kUTTypePNG - PNG
• kUTTypePolygon - Polygon
• kUTTypePresentation - Presentation
• kUTTypePropertyList - PropertyList
• kUTTypePythonScript - PythonScript
• kUTTypeQuickLookGenerator - QuickLookGenerator
• kUTTypeQuickTimeImage - QuickTimeImage
• kUTTypeQuickTimeMovie - QuickTimeMovie
• kUTTypeRawImage - RawImage
• kUTTypeReferenceURLKey - ReferenceURLKey
• kUTTypeResolvable - Resolvable
• kUTTypeRTF - RTF
• kUTTypeRTFD - RTFD
• kUTTypeRubyScript - RubyScript
• kUTTypeScalableVectorGraphics - ScalableVectorGraphics
• kUTTypeScript - Script
• kUTTypeShellScript - ShellScript
• kUTTypeSourceCode - SourceCode
• kUTTypeSpotlightImporter - SpotlightImporter
• kUTTypeSpreadsheet - Spreadsheet
• kUTTypeStereolithography - Stereolithography
• kUTTypeSwiftSource - SwiftSource
• kUTTypeSymLink - SymLink
• kUTTypeSystemPreferencesPane - SystemPreferencesPane
• kUTTypeTabSeparatedText - TabSeparatedText
• kUTTagClassFilenameExtension - TagClassFilenameExtension
• kUTTagClassMIMEType - TagClassMIMEType
• kUTTypeTagSpecificationKey - TagSpecificationKey
• kUTTypeText - Text
• kUTType3DContent - ThreeDContent
• kUTTypeTIFF - TIFF
• kUTTypeToDoItem - ToDoItem
• kUTTypeTXNTextAndMultimediaData - TXNTextAndMultimediaData
• kUTTypeUniversalSceneDescription - UniversalSceneDescription
• kUTTypeUnixExecutable - UnixExecutable
• kUTTypeURL - URL
• kUTTypeURLBookmarkData - URLBookmarkData
• kUTTypeUTF16ExternalPlainText - UTF16ExternalPlainText
• kUTTypeUTF16PlainText - UTF16PlainText
• kUTTypeUTF8PlainText - UTF8PlainText
• kUTTypeUTF8TabSeparatedText - UTF8TabSeparatedText
• kUTTypeVCard - VCard
• kUTTypeVersionKey - VersionKey
• kUTTypeVideo - Video
• kUTTypeVolume - Volume
• kUTTypeWaveformAudio - WaveformAudio
• kUTTypeWebArchive - WebArchive
• kUTTypeWindowsExecutable - WindowsExecutable
• kUTTypeX509Certificate - X509Certificate
• kUTTypeXML - XML
• kUTTypeXMLPropertyList - XMLPropertyList
• kUTTypeXPCService - XPCService
• kUTTypeZipArchive - ZipArchive

Voir l’exemple suivant :

using MobileCoreServices;
...

NSItemProvider itemProvider = new NSItemProvider ();
itemProvider.LoadItem(UTType.PropertyList ,null, (item, err) => {
    if (err == null) {
        NSDictionary results = (NSDictionary )item;
        NSString baseURI =
results.ObjectForKey("NSExtensionJavaScriptPreprocessingResultsKey");
    }
});

Pour plus d’informations, consultez la section Groupes d’applications de notre documentation Utilisation des fonctionnalités .

Précautions et considérations

Les extensions ont beaucoup moins de mémoire disponible que les applications. Ils sont censés fonctionner rapidement et avec une intrusion minimale pour l’utilisateur et l’application dans laquelle ils sont hébergés. Toutefois, une extension doit également fournir une fonction distincte et utile à l’application consommatrice avec une interface utilisateur de marque qui permet à l’utilisateur d’identifier l’application développeur ou conteneur de l’extension à laquelle il appartient.

Compte tenu de ces exigences strictes, vous ne devez déployer que les extensions qui ont été testées et optimisées pour les performances et la consommation de mémoire.

Résumé

Ce document a couvert les extensions, ce qu’elles sont, le type de points d’extension et les limitations connues imposées à une extension par iOS. Il a abordé la création, la distribution, l’installation et l’exécution d’extensions et le cycle de vie de l’extension. Il a fourni une procédure pas à pas de création d’un widget Aujourd’hui simple montrant deux façons de créer l’interface utilisateur du widget à l’aide de storyboards ou de code. Il a montré comment tester une extension dans le simulateur iOS. Enfin, il a brièvement abordé la communication avec l’application hôte et quelques précautions et considérations à prendre lors du développement d’une extension.

Liens connexes

• ContainerApp (exemple)
• Création d’extensions dans Xamarin.iOS (vidéo)
• Optimiser l’efficacité et les performances d’une extension d’application iOS