Partager via

Implémentation de SiriKit dans Xamarin.iOS

  • Article

Cet article décrit les étapes requises pour implémenter la prise en charge de SiriKit dans des applications Xamarin.iOS.

Nouveautés d’iOS 10, SiriKit permet à une application Xamarin.iOS de fournir des services accessibles à l’utilisateur à l’aide de Siri et de l’application Maps sur un appareil iOS. Cet article décrit les étapes requises pour implémenter la prise en charge de SiriKit dans les applications Xamarin.iOS en ajoutant les extensions intents, les extensions d’interface utilisateur intents et le vocabulaire requis.

Siri fonctionne avec le concept de domaines, de groupes d’actions de connaissance pour les tâches associées. Chaque interaction que l’application a avec Siri doit se trouver dans l’un de ses domaines de service connus comme suit :

  • Appel audio ou vidéo.
  • Réservation d’un tour.
  • Gestion des séances d’entraînement.
  • Messagerie.
  • Recherche de photos.
  • Envoi ou réception de paiements.

Lorsque l’utilisateur effectue une demande de Siri impliquant l’un des services de l’extension d’application, SiriKit envoie l’extension à un objet Intent qui décrit la demande de l’utilisateur ainsi que les données de prise en charge. l’extension d’application génère ensuite l’objet Response approprié pour l’intention donnée, en détaillant la façon dont l’extension peut gérer la requête.

Ce guide présente un exemple rapide d’inclusion de la prise en charge de SiriKit dans une application existante. Pour l’amour de cet exemple, nous allons utiliser l’application Fake MonkeyChat :

Icône MonkeyChat

MonkeyChat conserve son propre carnet de contacts des amis de l’utilisateur, chacun associé à un nom d’écran (par exemple Bobo) et permet à l’utilisateur d’envoyer des conversations texte à chaque ami par son nom d’écran.

Extension de l’application avec SiriKit

Comme indiqué dans le guide Understanding SiriKit Concepts, il existe trois parties principales impliquées dans l’extension d’une application avec SiriKit :

Extension de l’application avec le diagramme SiriKit

Il s’agit notamment des paramètres suivants :

  1. Extension Intentions : vérifie les réponses des utilisateurs, confirme que l’application peut gérer la demande et effectue réellement la tâche pour répondre à la demande de l’utilisateur.
  2. L’extension d’interface - utilisateur intentions facultative fournit une interface utilisateur personnalisée aux réponses dans l’environnement Siri et peut apporter l’interface utilisateur et la personnalisation des applications dans Siri pour enrichir l’expérience de l’utilisateur.
  3. Application : fournit à l’application des vocabulaires spécifiques à l’utilisateur pour aider Siri à l’utiliser.

Tous ces éléments et les étapes à inclure dans l’application seront abordés en détail dans les sections ci-dessous.

Préparation de l’application

SiriKit est basé sur les extensions, cependant, avant d’ajouter des extensions à l’application, il existe quelques éléments que le développeur doit faire pour aider à l’adoption de SiriKit.

Déplacement du code partagé commun

Tout d’abord, le développeur peut déplacer certains du code commun qui sera partagé entre l’application et les extensions dans des projets partagés, des bibliothèques de classes portables (PCL) ou des bibliothèques natives.

Les extensions devront être en mesure d’effectuer toutes les opérations que l’application effectue. Dans les termes de l’exemple d’application MonkeyChat, des éléments tels que la recherche de contacts, l’ajout de nouveaux contacts, l’envoi de messages et l’historique des messages.

En déplaçant ce code commun dans un projet partagé, une bibliothèque PCL ou native, il facilite la maintenance de ce code dans un emplacement commun et garantit que l’extension et l’application parente fournissent des expériences et des fonctionnalités uniformes pour l’utilisateur.

Dans le cas de l’exemple d’application MonkeyChat, les modèles de données et le code de traitement, tels que l’accès au réseau et à la base de données, seront déplacés dans une bibliothèque native.

Effectuez les actions suivantes :

  1. Démarrez Visual Studio pour Mac et ouvrez l’application MonkeyChat.

  2. Cliquez avec le bouton droit sur le nom de la solution dans le panneau Solution, puis sélectionnez Ajouter>un nouveau projet... :

    Ajouter un nouveau projet

  3. Sélectionnez bibliothèque de classes de bibliothèque>iOS>, puis cliquez sur le bouton Suivant :

    Sélectionnez Bibliothèque de classes.

  4. Entrez MonkeyChatCommon le nom , puis cliquez sur le bouton Créer :

    Entrez MonkeyChatCommon pour le nom

  5. Cliquez avec le bouton droit sur le dossier Références de l’application principale dans le Explorateur de solutions, puis sélectionnez Modifier les références.... Vérifiez le projet MonkeyChatCommon, puis cliquez sur le bouton OK :

    Vérifier le projet MonkeyChatCommon

  6. Dans le Explorateur de solutions, faites glisser le code partagé commun de l’application principale vers la bibliothèque native.

  7. Dans le cas de MonkeyChat, faites glisser les dossiers DataModels et Processeurs de l’application principale dans la bibliothèque native :

    Dossiers DataModels et Processeurs dans le Explorateur de solutions

Modifiez les fichiers qui ont été déplacés vers la bibliothèque native et modifiez l’espace de noms pour qu’il corresponde à celui de la bibliothèque. Par exemple, passer MonkeyChat à MonkeyChatCommon:

using System;
namespace MonkeyChatCommon
{
    /// <summary>
    /// A message sent from one user to another within a conversation.
    /// </summary>
    public class MonkeyMessage
    {
        public MonkeyMessage ()
        {
        }
        ...
    }
}

Ensuite, revenez à l’application principale et ajoutez une using instruction pour l’espace de noms de la bibliothèque native partout où l’application utilise l’une des classes qui ont été déplacées :

using System;
using System.Collections.Generic;
using UIKit;
using Foundation;
using CoreGraphics;
using MonkeyChatCommon;

namespace MonkeyChat
{
    public partial class MasterViewController : UITableViewController
    {
        public DetailViewController DetailViewController { get; set; }

        DataSource dataSource;
        ...
    }
}

Architecture de l’application pour les extensions

En règle générale, une application s’inscrit à plusieurs intentions et le développeur doit s’assurer que l’application est conçue pour le nombre approprié d’extensions d’intention.

Dans le cas où une application nécessite plusieurs intentions, le développeur a la possibilité de placer toute sa gestion de l’intention dans une extension d’intention ou de créer une extension d’intention distincte pour chaque intention.

Si vous choisissez de créer une extension d’intention distincte pour chaque intention, le développeur peut finir par dupliquer une grande quantité de code réutilisable dans chaque extension et créer une grande quantité de surcharge de processeur et de mémoire.

Pour vous aider à choisir entre les deux options, voir si l’une des intentions appartient naturellement ensemble. Par exemple, une application qui a effectué des appels audio et vidéo peut souhaiter inclure ces deux intentions dans une seule extension d’intention, car elles gèrent des tâches similaires et peuvent fournir la réutilisation du code la plus grande.

Pour toute intention ou groupe d’intentions qui ne s’intègrent pas à un groupe existant, créez une extension d’intention dans la solution de l’application pour les contenir.

Définition des droits requis

Toute application Xamarin.iOS qui inclut l’intégration de SiriKit doit avoir les droits appropriés définis. Si le développeur ne définit pas correctement ces droits requis, il ne pourra pas installer ou tester l’application sur du matériel iOS 10 (ou supérieur), ce qui est également nécessaire, car le simulateur iOS 10 ne prend pas en charge SiriKit.

Effectuez les actions suivantes :

  1. Double-cliquez sur le Entitlements.plist fichier dans le Explorateur de solutions pour l’ouvrir pour modification.

  2. Basculez vers l’onglet Source.

  3. Ajoutez la propriété, définissez le com.apple.developer.siri type sur Boolean et la valeur sur Yes:

    Ajouter la propriété com.apple.developer.siri

  4. Enregistrez les modifications du fichier.

  5. Double-cliquez sur le fichier projet dans le Explorateur de solutions pour l’ouvrir pour modification.

  6. Sélectionnez La signature de bundle iOS et vérifiez que le Entitlements.plist fichier est sélectionné dans le champ Droits personnalisés :

    Sélectionnez le fichier Entitlements.plist dans le champ Droits personnalisés

  7. Cliquez sur le bouton OK pour enregistrer les changements.

Une fois terminé, le fichier de l’application Entitlements.plist doit ressembler à ce qui suit (ouvert dans un éditeur externe) :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.developer.siri</key>
    <true/>
</dict>
</plist>

Approvisionnement correct de l’application

En raison de la sécurité stricte que Apple a placée autour de l’infrastructure SiriKit, toute application Xamarin.iOS qui implémente SiriKit doit avoir l’ID et les droits d’application appropriés (voir la section ci-dessus) et doit être signé avec un profil d’approvisionnement approprié.

Procédez comme suit sur votre Mac :

  1. Dans un navigateur web, accédez à https://developer.apple.com votre compte et connectez-vous.

  2. Cliquez sur Certificats, identificateurs et profils.

  3. Sélectionnez Profils d’approvisionnement, puis sélectionnez ID d’application, puis cliquez sur le + bouton.

  4. Entrez un nom pour le nouveau profil.

  5. Entrez un ID d’offre groupée suivant la recommandation d’affectation de noms d’Apple.

  6. Faites défiler jusqu’à la section App Services , sélectionnez SiriKit , puis cliquez sur le bouton Continuer :

    Sélectionner SiriKit

  7. Vérifiez tous les paramètres, puis envoyez l’ID d’application.

  8. Sélectionnez Développement des profils>d’approvisionnement, cliquez sur le + bouton, sélectionnez l’ID Apple, puis cliquez sur Continuer.

  9. Cliquez sur Sélectionner tout, puis sur Continuer.

  10. Cliquez à nouveau sur Sélectionner tout , puis sur Continuer.

  11. Entrez un nom de profil à l’aide des suggestions d’affectation de noms d’Apple, puis cliquez sur Continuer.

  12. Démarrez Xcode.

  13. Dans le menu Xcode, sélectionnez Préférences...

  14. Sélectionnez Comptes, puis cliquez sur le bouton Afficher les détails... :

    Sélection de Comptes

  15. Cliquez sur le bouton Télécharger tous les profils dans le coin inférieur gauche :

    Télécharger tous les profils

  16. Vérifiez que le profil d’approvisionnement créé ci-dessus a été installé dans Xcode.

  17. Ouvrez le projet pour ajouter la prise en charge de SiriKit dans Visual Studio pour Mac.

  18. Double-cliquez sur le Info.plist fichier dans le Explorateur de solutions.

  19. Vérifiez que l’identificateur de bundle correspond à celui créé dans le portail des développeurs d’Apple ci-dessus :

    Identificateur de bundle

  20. Dans le Explorateur de solutions, sélectionnez le projet.

  21. Cliquez avec le bouton droit sur le projet et sélectionnez Options.

  22. Sélectionnez la signature de bundle iOS, sélectionnez l’identité de signature et le profil d’approvisionnement créés ci-dessus :

    Sélectionner le profil d’identité et d’approvisionnement de signature

  23. Cliquez sur le bouton OK pour enregistrer les changements.

Important

Le test de SiriKit fonctionne uniquement sur un appareil matériel iOS 10 réel et non dans le simulateur iOS 10. Si vous rencontrez des problèmes lors de l’installation d’une application Xamarin.iOS compatible avec SiriKit sur du matériel réel, vérifiez que les droits requis, l’ID d’application, l’identificateur de signature et le profil d’approvisionnement ont été correctement configurés dans le portail des développeurs d’Apple et Visual Studio pour Mac.

Demande d’autorisation Siri

Avant que l’application ajoute un vocabulaire spécifique à l’utilisateur ou que les extensions d’intentions se connectent à Siri, elle doit demander l’autorisation de l’utilisateur pour accéder à Siri.

Modifiez le fichier de Info.plist l’application, basculez vers la vue Source et ajoutez la NSSiriUsageDescription clé avec une valeur de chaîne décrivant comment l’application utilisera Siri et quels types de données seront envoyés. Par exemple, l’application MonkeyChat peut dire « Les contacts MonkeyChat seront envoyés à Siri » :

NSSiriUsageDescription dans l’éditeur Info.plist

Appelez la RequestSiriAuthorization méthode de la INPreferences classe au démarrage de l’application. Modifiez la AppDelegate.cs classe et faites en sorte que la FinishedLaunching méthode ressemble à ce qui suit :

using Intents;
...

public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
{

    // Request access to Siri
    INPreferences.RequestSiriAuthorization ((INSiriAuthorizationStatus status) => {
        // Respond to returned status
        switch (status) {
        case INSiriAuthorizationStatus.Authorized:
            break;
        case INSiriAuthorizationStatus.Denied:
            break;
        case INSiriAuthorizationStatus.NotDetermined:
            break;
        case INSiriAuthorizationStatus.Restricted:
            break;
        }
    });

    return true;
}

La première fois que cette méthode est appelée, une alerte s’affiche en invitant l’utilisateur à autoriser l’application à accéder à Siri. Le message ajouté au NSSiriUsageDescription développeur ci-dessus s’affiche dans cette alerte. Si l’utilisateur refuse initialement l’accès, il peut utiliser l’application Paramètres pour accorder l’accès à l’application.

À tout moment, l’application peut vérifier la capacité de l’application à accéder à Siri en appelant la SiriAuthorizationStatus méthode de la INPreferences classe.

Localisation et Siri

Sur un appareil iOS, l’utilisateur peut sélectionner une langue pour Siri différente, puis la valeur par défaut du système. Lorsque vous utilisez des données localisées, l’application doit utiliser la SiriLanguageCode méthode de la INPreferences classe pour obtenir le code de langue de Siri. Par exemple :

var language = INPreferences.SiriLanguageCode();

// Take action based on language
if (language == "en-US") {
    // Do something...
}

Ajout d’un vocabulaire spécifique à l’utilisateur

Le vocabulaire spécifique de l’utilisateur va fournir des mots ou des expressions uniques à des utilisateurs individuels de l’application. Ceux-ci seront fournis lors de l’exécution à partir de l’application principale (et non les extensions d’application) en tant qu’ensemble ordonné de termes, classés dans une priorité d’utilisation la plus importante pour les utilisateurs, avec les termes les plus importants au début de la liste.

Le vocabulaire spécifique à l’utilisateur doit appartenir à l’une des catégories suivantes :

  • Noms de contacts (qui ne sont pas gérés par l’infrastructure Contacts).
  • Balises photo.
  • Noms des albums photo.
  • Noms d’entraînement.

Lors de la sélection de la terminologie pour s’inscrire en tant que vocabulaire personnalisé, choisissez uniquement des termes qui peuvent être mal compris par quelqu’un qui n’est pas familiarisé avec l’application. N’inscrivez jamais les termes courants tels que « Mon entraînement » ou « Mon album ». Par exemple, l’application MonkeyChat inscrit les surnoms associés à chaque contact dans le carnet d’adresses de l’utilisateur.

L’application fournit le vocabulaire spécifique utilisateur en appelant la SetVocabularyStrings méthode de la INVocabulary classe et en passant une NSOrderedSet collection à partir de l’application principale. L’application doit d’abord appeler la RemoveAllVocabularyStrings méthode pour supprimer les termes existants avant d’en ajouter de nouveaux. Par exemple :

using System;
using System.Linq;
using System.Collections.Generic;
using Foundation;
using Intents;

namespace MonkeyChatCommon
{
    public class MonkeyAddressBook : NSObject
    {
        #region Computed Properties
        public List<MonkeyContact> Contacts { get; set; } = new List<MonkeyContact> ();
        #endregion

        #region Constructors
        public MonkeyAddressBook ()
        {
        }
        #endregion

        #region Public Methods
        public NSOrderedSet<NSString> ContactNicknames ()
        {
            var nicknames = new NSMutableOrderedSet<NSString> ();

            // Sort contacts by the last time used
            var query = Contacts.OrderBy (contact => contact.LastCalledOn);

            // Assemble ordered list of nicknames by most used to least
            foreach (MonkeyContact contact in query) {
                nicknames.Add (new NSString (contact.ScreenName));
            }

            // Return names
            return new NSOrderedSet<NSString> (nicknames.AsSet ());
        }

        // This method MUST only be called on a background thread!
        public void UpdateUserSpecificVocabulary ()
        {
            // Clear any existing vocabulary
            INVocabulary.SharedVocabulary.RemoveAllVocabularyStrings ();

            // Register new vocabulary
            INVocabulary.SharedVocabulary.SetVocabularyStrings (ContactNicknames (), INVocabularyStringType.ContactName);
        }
        #endregion
    }
}

Avec ce code en place, il peut être appelé comme suit :

using System;
using System.Threading;
using UIKit;
using MonkeyChatCommon;
using Intents;

namespace MonkeyChat
{
    public partial class ViewController : UIViewController
    {
        #region AppDelegate Access
        public AppDelegate ThisApp {
            get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
        }
        #endregion

        #region Constructors
        protected ViewController (IntPtr handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic.
        }
        #endregion

        #region Override Methods
        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();

            // Do we have access to Siri?
            if (INPreferences.SiriAuthorizationStatus == INSiriAuthorizationStatus.Authorized) {
                // Yes, update Siri's vocabulary
                new Thread (() => {
                    Thread.CurrentThread.IsBackground = true;
                    ThisApp.AddressBook.UpdateUserSpecificVocabulary ();
                }).Start ();
            }
        }

        public override void DidReceiveMemoryWarning ()
        {
            base.DidReceiveMemoryWarning ();
            // Release any cached data, images, etc that aren't in use.
        }
        #endregion
    }
}

Important

Siri traite le vocabulaire personnalisé comme des indicateurs et incorporera autant de terminologie que possible. Toutefois, l’espace pour le vocabulaire personnalisé est limité, ce qui signifie qu’il est important d’inscrire uniquement la terminologie susceptible d’être déroutante, en conservant au minimum le nombre total de termes inscrits.

Pour plus d’informations, consultez notre référence de vocabulaire spécifique à l’utilisateur et la référence de vocabulaire personnalisé d’Apple.

Ajout d’un vocabulaire spécifique à l’application

Le vocabulaire spécifique de l’application définit les mots et expressions spécifiques qui seront connus de tous les utilisateurs de l’application, tels que les types de véhicules ou les noms d’entraînement. Étant donné qu’elles font partie de l’application, elles sont définies dans un AppIntentVocabulary.plist fichier dans le cadre du groupe d’applications principal. En outre, ces mots et expressions doivent être localisés.

Les termes de vocabulaire spécifiques à l’application doivent appartenir à l’une des catégories suivantes :

  • Options de trajet.
  • Noms d’entraînement.

Le fichier de vocabulaire spécifique à l’application contient deux clés de niveau racine :

  • ParameterVocabulariesObligatoire : définit les termes personnalisés et les paramètres d’intention de l’application auxquels ils s’appliquent.
  • IntentPhrasesFacultatif : contient des exemples d’expressions utilisant les termes personnalisés définis dans le ParameterVocabularies.

Chaque entrée du ParameterVocabularies fichier doit spécifier une chaîne d’ID, un terme et l’intention auxquelles le terme s’applique. En outre, un seul terme peut s’appliquer à plusieurs intentions.

Pour obtenir la liste complète des valeurs acceptables et de la structure de fichiers requise, consultez la référence du format de fichier de vocabulaire d’application d’Apple.

Pour ajouter un AppIntentVocabulary.plist fichier au projet d’application, procédez comme suit :

  1. Cliquez avec le bouton droit sur le nom du projet dans le Explorateur de solutions, puis sélectionnez Ajouter>un nouveau fichier...>iOS :

    Ajouter une liste de propriétés

  2. Double-cliquez sur le AppIntentVocabulary.plist fichier dans le Explorateur de solutions pour l’ouvrir pour modification.

  3. Cliquez sur la + touche pour ajouter une clé, définissez le nom ParameterVocabularies et le type sur Array:

    Définir le nom sur ParameterVocabularies et le type sur array

  4. Développez et cliquez sur le bouton et définissez ParameterVocabularies le type sur Dictionary:+

    Définir le type sur dictionnaire

  5. Cliquez sur la + touche pour ajouter une nouvelle clé, définissez le nom ParameterNames sur et le type sur Array:

    Définir le nom sur ParameterNames et le type sur array

  6. Cliquez sur la + touche pour ajouter une nouvelle clé avec le type et String la valeur comme l’un des noms de paramètres disponibles. Par exemple, INStartWorkoutIntent.workoutName:

    La clé INStartWorkoutIntent.workoutName

  7. Ajoutez la ParameterVocabulary clé à la ParameterVocabularies clé avec le type de Array:

    Ajoutez la clé ParameterVocabulary à la clé ParameterVocabularies avec le type de tableau

  8. Ajoutez une nouvelle clé avec le type de Dictionary:

    Ajoutez une nouvelle clé avec le type de dictionnaire dans Visual Studio pour Mac.

  9. Ajoutez la VocabularyItemIdentifier clé avec le type et String spécifiez un ID unique pour le terme :

    Ajoutez la clé VocabularyItemIdentifier avec le type de chaîne et spécifiez un ID unique

  10. Ajoutez la VocabularyItemSynonyms clé avec le type de Array:

    Ajouter la clé VocabularyItemSynonyms avec le type de tableau

  11. Ajoutez une nouvelle clé avec le type de Dictionary:

    Ajoutez une autre nouvelle clé avec le type de dictionnaire dans Visual Studio pour Mac.

  12. Ajoutez la VocabularyItemPhrase clé avec le type de String l’application et le terme défini par l’application :

    Ajoutez la clé VocabularyItemPhrase avec le type de chaîne et le terme défini par l’application

  13. Ajoutez la VocabularyItemPronunciation clé avec le type et String la prononciation phonétique du terme :

    Ajoutez la clé VocabularyItemPrononciation avec le type de chaîne et la prononciation phonétique du terme

  14. Ajoutez la VocabularyItemExamples clé avec le type de Array:

    Ajouter la clé VocabularyItemExamples avec le type de tableau

  15. Ajoutez quelques String clés avec des exemples d’utilisations du terme :

    Ajoutez quelques clés string avec des exemples d’utilisations du terme dans Visual Studio pour Mac.

  16. Répétez les étapes ci-dessus pour tous les autres termes personnalisés que l’application doit définir.

  17. Réduisez la ParameterVocabularies clé.

  18. Ajoutez la IntentPhrases clé avec le type de Array:

    Ajouter la clé IntentPhrases avec le type de tableau

  19. Ajoutez une nouvelle clé avec le type de Dictionary:

    Ajoutez une nouvelle clé supplémentaire avec le type de dictionnaire dans Visual Studio pour Mac.

  20. Ajoutez la IntentName clé avec le type et String l’intention pour l’exemple :

    Ajouter la clé IntentName avec le type de chaîne et d’intention pour l’exemple

  21. Ajoutez la IntentExamples clé avec le type de Array:

    Ajouter la clé IntentExamples avec le type de tableau

  22. Ajoutez quelques String clés avec des exemples d’utilisations du terme :

    Ajoutez quelques clés String supplémentaires avec des exemples d’utilisations du terme dans Visual Studio pour Mac.

  23. Répétez les étapes ci-dessus pour toutes les intentions dont l’application a besoin pour fournir des exemples d’utilisation.

Important

L’inscription AppIntentVocabulary.plist auprès de Siri sur les appareils de test pendant le développement peut prendre un certain temps pour que Siri incorpore le vocabulaire personnalisé. Par conséquent, le testeur doit attendre plusieurs minutes avant de tenter de tester le vocabulaire spécifique à l’application lorsqu’il a été mis à jour.

Pour plus d’informations, consultez notre référence de vocabulaire spécifique à l’application et les informations de référence sur la spécification de vocabulaire personnalisé d’Apple.

Ajout d’une extension intentions

Maintenant que l’application a été prête à adopter SiriKit, le développeur devra ajouter une (ou plusieurs) extensions d’intentions à la solution pour gérer les intentions requises pour l’intégration de Siri.

Pour chaque extension Intentions requise, procédez comme suit :

  • Ajoutez un projet d’extension Intents à la solution d’application Xamarin.iOS.
  • Configurez le fichier d’extension Info.plist Intents.
  • Modifiez la classe principale Intents Extension.

Pour plus d’informations, consultez notre référence sur l’extension Intentions et la référence sur la création de l’extension Intentions d’Apple.

Création de l’extension

Pour ajouter une extension Intents à la solution, procédez comme suit :

  1. Cliquez avec le bouton droit sur le nom de la solution dans le panneau Solution, puis sélectionnez Ajouter>un nouveau projet....

  2. Dans la boîte de dialogue, sélectionnez Extension d’intention des extensions>iOS>, puis cliquez sur le bouton Suivant :

    Sélectionner l’extension d’intention

  3. Entrez ensuite un nom pour l’extension d’intention, puis cliquez sur le bouton Suivant :

    Entrez un nom pour l’extension d’intention.

  4. Enfin, cliquez sur le bouton Créer pour ajouter l’extension d’intention à la solution d’applications :

    Ajoutez l’extension d’intention à la solution d’applications.

  5. Dans le Explorateur de solutions, cliquez avec le bouton droit sur le dossier Références de l’extension d’intention nouvellement créée. Vérifiez le nom du projet de bibliothèque de code partagé commun (que l’application a créée ci-dessus) et cliquez sur le bouton OK :

    Sélectionnez le nom du projet de bibliothèque de code partagé commun.

Répétez ces étapes pour le nombre d’extensions d’intention (en fonction de la section Architecture de l’application pour extensions ci-dessus) dont l’application aura besoin.

Configuration de Info.plist

Pour chacune des extensions Intents ajoutées à la solution de l’application, vous devez configurer les Info.plist fichiers pour qu’elles fonctionnent avec l’application.

Tout comme n’importe quelle extension d’application classique, l’application aura les clés existantes de NSExtension et NSExtensionAttributes. Pour une extension Intents, il existe deux nouveaux attributs qui doivent être configurés :

Deux nouveaux attributs qui doivent être configurés

  • IntentsSupported : est requis et se compose d’un tableau de noms de classes d’intention que l’application souhaite prendre en charge à partir de l’extension d’intention.
  • IntentsRestrictedWhileLocked : clé facultative pour l’application afin de spécifier le comportement de l’écran de verrouillage de l’extension. Il se compose d’un tableau de noms de classes d’intention que l’application souhaite que l’utilisateur puisse utiliser à partir de l’extension d’intention.

Pour configurer le fichier de l’extension Info.plist d’intention, double-cliquez dessus dans le Explorateur de solutions pour l’ouvrir pour modification. Ensuite, basculez vers la vue Source, puis développez les clés et NSExtensionAttributes les NSExtension clés dans l’éditeur :

Développez la IntentsSupported clé et ajoutez le nom de n’importe quelle classe d’intention prise en charge par cette extension. Pour l’exemple d’application MonkeyChat, elle prend en charge les INSendMessageIntentpoints suivants :

Si l’application exige éventuellement que l’utilisateur soit connecté à l’appareil pour utiliser une intention donnée, développez la IntentRestrictedWhileLocked clé et ajoutez les noms de classes des intentions qui ont un accès restreint. Pour l’exemple d’application MonkeyChat, l’utilisateur doit être connecté pour envoyer un message de conversation afin que nous ayons ajouté INSendMessageIntent:

Pour obtenir la liste complète des domaines d’intention disponibles, consultez la référence des domaines d’intention d’Apple.

Configuration de la classe principale

Ensuite, le développeur devra configurer la classe principale qui joue le rôle de point d’entrée principal pour l’extension d’intention dans Siri. Il doit s’agir d’une sous-classe INExtension dont la IINIntentHandler conformité au délégué est conforme. Par exemple :

using System;
using System.Collections.Generic;

using Foundation;
using Intents;

namespace MonkeyChatIntents
{
    [Register ("IntentHandler")]
    public class IntentHandler : INExtension, IINSendMessageIntentHandling, IINSearchForMessagesIntentHandling, IINSetMessageAttributeIntentHandling
    {
        #region Constructors
        protected IntentHandler (IntPtr handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic.
        }
        #endregion

        #region Override Methods
        public override NSObject GetHandler (INIntent intent)
        {
            // This is the default implementation.  If you want different objects to handle different intents,
            // you can override this and return the handler you want for that particular intent.

            return this;
        }
        #endregion
        ...
    }
}

Il existe une méthode solitaire que l’application doit implémenter sur la classe principale Intent Extension, la GetHandler méthode. Cette méthode est passée à une intention par SiriKit et l’application doit retourner un gestionnaire d’intention qui correspond au type de l’intention donnée.

Étant donné que l’exemple d’application MonkeyChat ne gère qu’une seule intention, elle se retourne dans la GetHandler méthode. Si l’extension a géré plusieurs intentions, le développeur ajoute une classe pour chaque type d’intention et retourne une instance ici en fonction de la Intent méthode passée.

Gestion de l’étape de résolution

L’étape de résolution est l’emplacement où l’extension d’intention clarifiera et validera les paramètres transmis à partir de Siri et qui ont été définis par le biais de la conversation de l’utilisateur.

Pour chaque paramètre envoyé à partir de Siri, il existe une Resolve méthode. L’application doit implémenter cette méthode pour chaque paramètre que l’application peut avoir besoin de l’aide de Siri pour obtenir la réponse correcte de l’utilisateur.

Dans le cas de l’exemple d’application MonkeyChat, l’extension d’intention nécessite un ou plusieurs destinataires pour envoyer le message. Pour chaque destinataire de la liste, l’extension doit effectuer une recherche de contact qui peut avoir les résultats suivants :

  • Exactement un contact correspondant est trouvé.
  • Deux contacts correspondants ou plus sont trouvés.
  • Aucun contact correspondant n’est trouvé.

En outre, MonkeyChat nécessite du contenu pour le corps du message. Si l’utilisateur n’a pas fourni cette option, Siri doit inviter l’utilisateur à entrer le contenu.

L’extension d’intention doit gérer correctement chacun de ces cas.

[Export ("resolveRecipientsForSearchForMessages:withCompletion:")]
public void ResolveRecipients (INSendMessageIntent intent, Action<INPersonResolutionResult []> completion)
{
    var recipients = intent.Recipients;
    // If no recipients were provided we'll need to prompt for a value.
    if (recipients.Length == 0) {
        completion (new INPersonResolutionResult [] { (INPersonResolutionResult)INPersonResolutionResult.NeedsValue });
        return;
    }

    var resolutionResults = new List<INPersonResolutionResult> ();

    foreach (var recipient in recipients) {
        var matchingContacts = new INPerson [] { recipient }; // Implement your contact matching logic here to create an array of matching contacts
        if (matchingContacts.Length > 1) {
            // We need Siri's help to ask user to pick one from the matches.
            resolutionResults.Add (INPersonResolutionResult.GetDisambiguation (matchingContacts));
        } else if (matchingContacts.Length == 1) {
            // We have exactly one matching contact
            resolutionResults.Add (INPersonResolutionResult.GetSuccess (recipient));
        } else {
            // We have no contacts matching the description provided
            resolutionResults.Add ((INPersonResolutionResult)INPersonResolutionResult.Unsupported);
        }
    }

    completion (resolutionResults.ToArray ());
}

[Export ("resolveContentForSendMessage:withCompletion:")]
public void ResolveContent (INSendMessageIntent intent, Action<INStringResolutionResult> completion)
{
    var text = intent.Content;
    if (!string.IsNullOrEmpty (text))
        completion (INStringResolutionResult.GetSuccess (text));
    else
        completion ((INStringResolutionResult)INStringResolutionResult.NeedsValue);
}

Pour plus d’informations, consultez notre référence sur la phase de résolution et les informations de référence sur la résolution et la gestion des intentions d’Apple.

Gestion de l’étape de confirmation

L’étape de confirmation est l’emplacement où l’extension d’intention vérifie qu’elle contient toutes les informations pour répondre à la demande de l’utilisateur. L’application souhaite envoyer une confirmation avec tous les détails de prise en charge de ce qui est sur le point d’arriver à Siri afin qu’elle puisse être confirmée avec l’utilisateur qu’il s’agit de l’action prévue.

[Export ("confirmSendMessage:completion:")]
public void ConfirmSendMessage (INSendMessageIntent intent, Action<INSendMessageIntentResponse> completion)
{
    // Verify user is authenticated and the app is ready to send a message.
    ...

    var userActivity = new NSUserActivity (nameof (INSendMessageIntent));
    var response = new INSendMessageIntentResponse (INSendMessageIntentResponseCode.Ready, userActivity);
    completion (response);
}

Pour plus d’informations, consultez notre référence sur l’étape de confirmation.

Traitement de l’intention

Il s’agit du point où l’extension d’intention effectue réellement la tâche pour remplir la demande de l’utilisateur et transmettre les résultats à Siri afin que l’utilisateur puisse être informé.

public void HandleSendMessage (INSendMessageIntent intent, Action<INSendMessageIntentResponse> completion)
{
    // Implement the application logic to send a message here.
    ...

    var userActivity = new NSUserActivity (nameof (INSendMessageIntent));
    var response = new INSendMessageIntentResponse (INSendMessageIntentResponseCode.Success, userActivity);
    completion (response);
}

public void HandleSearchForMessages (INSearchForMessagesIntent intent, Action<INSearchForMessagesIntentResponse> completion)
{
    // Implement the application logic to find a message that matches the information in the intent.
    ...

    var userActivity = new NSUserActivity (nameof (INSearchForMessagesIntent));
    var response = new INSearchForMessagesIntentResponse (INSearchForMessagesIntentResponseCode.Success, userActivity);

    // Initialize with found message's attributes
    var sender = new INPerson (new INPersonHandle ("sarah@example.com", INPersonHandleType.EmailAddress), null, "Sarah", null, null, null);
    var recipient = new INPerson (new INPersonHandle ("+1-415-555-5555", INPersonHandleType.PhoneNumber), null, "John", null, null, null);
    var message = new INMessage ("identifier", "I am so excited about SiriKit!", NSDate.Now, sender, new INPerson [] { recipient });
    response.Messages = new INMessage [] { message };
    completion (response);
}

public void HandleSetMessageAttribute (INSetMessageAttributeIntent intent, Action<INSetMessageAttributeIntentResponse> completion)
{
    // Implement the application logic to set the message attribute here.
    ...

    var userActivity = new NSUserActivity (nameof (INSetMessageAttributeIntent));
    var response = new INSetMessageAttributeIntentResponse (INSetMessageAttributeIntentResponseCode.Success, userActivity);
    completion (response);
}

Pour plus d’informations, consultez notre référence sur l’étape de gestion.

Ajout d’une extension d’interface utilisateur intents

L’extension d’interface utilisateur Intentions facultative présente l’opportunité de mettre l’interface utilisateur et la personnalisation de l’application dans l’expérience Siri et de rendre les utilisateurs connectés à l’application. Avec cette extension, l’application peut apporter la marque ainsi que des informations visuelles et d’autres informations dans la transcription.

Exemple de sortie de l’extension d’interface utilisateur Intents

Tout comme l’extension Intents, le développeur effectue l’étape suivante pour l’extension d’interface utilisateur intents :

  • Ajoutez un projet d’extension d’interface utilisateur Intents à la solution d’application Xamarin.iOS.
  • Configurez le fichier d’extension de l’interface Info.plist utilisateur Intents.
  • Modifiez la classe principale de l’extension d’interface utilisateur Intents.

Pour plus d’informations, consultez notre référence sur l’extension d’interface utilisateur Intentions et la référence d’Apple sur la fourniture d’une référence d’interface personnalisée.

Création de l’extension

Pour ajouter une extension d’interface utilisateur Intents à la solution, procédez comme suit :

  1. Cliquez avec le bouton droit sur le nom de la solution dans le panneau Solution, puis sélectionnez Ajouter>un nouveau projet....

  2. Dans la boîte de dialogue, sélectionnez Extension de l’interface utilisateur de l’intention des extensions>iOS>, puis cliquez sur le bouton Suivant :

    Sélectionner l’extension de l’interface utilisateur de l’intention

  3. Entrez ensuite un nom pour l’extension d’intention, puis cliquez sur le bouton Suivant :

    Entrez un nom pour l’extension d’intention dans Visual Studio pour Mac.

  4. Enfin, cliquez sur le bouton Créer pour ajouter l’extension d’intention à la solution d’applications :

    Ajoutez l’extension d’intention à la solution d’applications dans Visual Studio pour Mac.

  5. Dans le Explorateur de solutions, cliquez avec le bouton droit sur le dossier Références de l’extension d’intention nouvellement créée. Vérifiez le nom du projet de bibliothèque de code partagé commun (que l’application a créée ci-dessus) et cliquez sur le bouton OK :

    Sélectionnez le nom du projet de bibliothèque de code partagé commun dans Visual Studio pour Mac.

Configuration de Info.plist

Configurez le fichier de Info.plist l’extension d’interface utilisateur Intents pour qu’il fonctionne avec l’application.

Tout comme n’importe quelle extension d’application classique, l’application aura les clés existantes de NSExtension et NSExtensionAttributes. Pour une extension Intents, il existe un nouvel attribut qui doit être configuré :

Nouvel attribut qui doit être configuré

IntentsSupported est requis et se compose d’un tableau de noms de classes d’intention que l’application souhaite prendre en charge à partir de l’extension d’intention.

Pour configurer le fichier de Info.plist l’extension d’interface utilisateur d’intention, double-cliquez dessus dans le Explorateur de solutions pour l’ouvrir pour modification. Ensuite, basculez vers la vue Source, puis développez les clés et NSExtensionAttributes les NSExtension clés dans l’éditeur :

Clés NSExtension et NSExtensionAttributes dans l’éditeur.

Développez la IntentsSupported clé et ajoutez le nom de n’importe quelle classe d’intention prise en charge par cette extension. Pour l’exemple d’application MonkeyChat, elle prend en charge les INSendMessageIntentpoints suivants :

Pour obtenir la liste complète des domaines d’intention disponibles, consultez la référence des domaines d’intention d’Apple.

Configuration de la classe principale

Configurez la classe principale qui joue le rôle de point d’entrée principal pour l’extension d’interface utilisateur intention dans Siri. Il doit s’agir d’une sous-classe dont UIViewController la conformité est conforme à l’interface IINUIHostedViewController . Par exemple :

using System;
using Foundation;
using CoreGraphics;
using Intents;
using IntentsUI;
using UIKit;

namespace MonkeyChatIntentsUI
{
    public partial class IntentViewController : UIViewController, IINUIHostedViewControlling
    {
        #region Constructors
        protected IntentViewController (IntPtr handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic.
        }
        #endregion

        #region Override Methods
        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();

            // Do any required interface initialization here.
        }

        public override void DidReceiveMemoryWarning ()
        {
            // Releases the view if it doesn't have a superview.
            base.DidReceiveMemoryWarning ();

            // Release any cached data, images, etc that aren't in use.
        }
        #endregion

        #region Public Methods
        [Export ("configureWithInteraction:context:completion:")]
        public void Configure (INInteraction interaction, INUIHostedViewContext context, Action<CGSize> completion)
        {
            // Do configuration here, including preparing views and calculating a desired size for presentation.

            if (completion != null)
                completion (DesiredSize ());
        }

        [Export ("desiredSize:")]
        public CGSize DesiredSize ()
        {
            return ExtensionContext.GetHostedViewMaximumAllowedSize ();
        }
        #endregion
    }
}

Siri transmet une INInteraction instance de classe à la Configure méthode de l’instance à l’intérieur UIViewController de l’extension d’interface utilisateur intention.

L’objet INInteraction fournit trois éléments clés d’informations à l’extension :

  1. Objet Intent en cours de traitement.
  2. Objet Intent Response à partir des méthodes et Handle de l’extension Confirm d’intention.
  3. État d’interaction qui définit l’état de l’interaction entre l’application et Siri.

L’instance UIViewController est la classe de principe pour l’interaction avec Siri et, parce qu’elle hérite de UIViewController, elle a accès à toutes les fonctionnalités de UIKit.

Lorsque Siri appelle la Configure méthode de celle-ci UIViewController , elle passe dans un contexte d’affichage indiquant que le contrôleur de vue sera hébergé dans une carte Siri Snippit ou Cartes.

Siri transmet également un gestionnaire d’achèvement que l’application doit retourner la taille souhaitée de l’affichage une fois l’application terminée sa configuration.

Concevoir l’interface utilisateur dans le Concepteur iOS

Disposition de l’interface utilisateur de l’extension d’interface utilisateur intents dans le concepteur iOS. Double-cliquez sur le fichier de MainInterface.storyboard l’extension dans le Explorateur de solutions pour l’ouvrir pour modification. Faites glisser tous les éléments d’interface utilisateur requis pour générer l’interface utilisateur et enregistrer les modifications.

Important

Bien qu’il soit possible d’ajouter des éléments interactifs tels que UIButtons ou UITextFields à l’extension d’interface utilisateur d’intention UIViewController, ceux-ci sont strictement interdits en tant qu’interface utilisateur intention dans une interface utilisateur non interactive et l’utilisateur ne pourra pas interagir avec eux.

Connecter l’interface utilisateur

Avec l’interface utilisateur de l’extension Intents UI créée dans le Concepteur iOS, modifiez la UIViewController sous-classe et remplacez la Configure méthode comme suit :

[Export ("configureWithInteraction:context:completion:")]
public void Configure (INInteraction interaction, INUIHostedViewContext context, Action<CGSize> completion)
{
    // Do configuration here, including preparing views and calculating a desired size for presentation.
    ...

    // Return desired size
    if (completion != null)
        completion (DesiredSize ());
}

[Export ("desiredSize:")]
public CGSize DesiredSize ()
{
    return ExtensionContext.GetHostedViewMaximumAllowedSize ();
}

Substitution de l’interface utilisateur Siri par défaut

L’extension d’interface utilisateur Intentions s’affiche toujours avec d’autres contenus Siri tels que l’icône d’application et le nom en haut de l’interface utilisateur ou, en fonction de l’intention, des boutons (comme Envoyer ou Annuler) peuvent s’afficher en bas.

Il existe quelques instances où l’application peut remplacer les informations affichées par Siri à l’utilisateur par défaut, telles que la messagerie ou les mappages où l’application peut remplacer l’expérience par défaut par un utilisateur adapté à l’application.

Si l’extension intentions de l’interface utilisateur doit remplacer les éléments de l’interface utilisateur Siri par défaut, la UIViewController sous-classe doit implémenter l’interface IINUIHostedViewSiriProviding et choisir d’afficher un élément d’interface particulier.

Ajoutez le code suivant à la UIViewController sous-classe pour indiquer à Siri que l’extension d’interface utilisateur intention affiche déjà le contenu du message :

public bool DisplaysMessage {
    get {return true;}
}

À propos de l’installation

Apple suggère que le développeur prenne en compte les considérations suivantes lors de la conception et de l’implémentation des extensions de l’interface utilisateur intention :

  • Être conscient de l’utilisation de la mémoire : étant donné que les extensions de l’interface utilisateur d’intention sont temporaires et affichées seulement pendant une courte période, le système impose des contraintes de mémoire plus strictes que celles utilisées avec une application complète.
  • Tenez compte des tailles minimales et maximales d’affichage : vérifiez que les extensions de l’interface utilisateur de l’intention sont correctes sur chaque type d’appareil iOS, taille et orientation. En outre, la taille souhaitée que l’application renvoie à Siri peut ne pas être en mesure d’accorder.
  • Utilisez à nouveau des modèles de disposition flexibles et adaptatifs pour vous assurer que l’interface utilisateur est idéale sur chaque appareil.

Résumé

Cet article a abordé SiriKit et montré comment il peut être ajouté aux applications Xamarin.iOS pour fournir des services accessibles à l’utilisateur à l’aide de Siri et de l’application Maps sur un appareil iOS.