Implementieren von SiriKit in Xamarin.iOS

In diesem Artikel werden die Schritte behandelt, die zum Implementieren der SiriKit-Unterstützung in einer Xamarin.iOS-App erforderlich sind.

Neu bei iOS 10 ermöglicht SiriKit eine Xamarin.iOS-App, Dienste bereitzustellen, die für den Benutzer über Siri und die Karten-App auf einem iOS-Gerät zugänglich sind. In diesem Artikel werden die Schritte behandelt, die zum Implementieren der SiriKit-Unterstützung in den Xamarin.iOS-Apps erforderlich sind, indem die erforderlichen Intents-Erweiterungen, Intents-UI-Erweiterungen und Vokabular hinzugefügt werden.

Siri arbeitet mit dem Konzept von Domänen, Gruppen von bekannten Aktionen für verwandte Aufgaben. Jede Interaktion, die die App mit Siri hat, muss wie folgt in eine der bekannten Dienstdomänen fallen:

• Audio- oder Videoanrufe.
• Buchen Sie eine Fahrt.
• Verwalten von Trainingseinheiten.
• Messaging:
• Suchen nach Fotos.
• Senden oder Empfangen von Zahlungen.

Wenn der Benutzer eine Anfrage von Siri unter Einbeziehung eines der Dienste der App-Erweiterung sendet SiriKit die Erweiterung an ein Intent-Objekt , das die Anforderung des Benutzers zusammen mit allen unterstützenden Daten beschreibt. die App-Erweiterung generiert dann das entsprechende Response-Objekt für den angegebenen Intent, der angibt, wie die Erweiterung die Anforderung verarbeiten kann.

In diesem Leitfaden wird ein schnelles Beispiel für die Einbeziehung der SiriKit-Unterstützung in eine vorhandene App dargestellt. Im Sinne dieses Beispiels verwenden wir die gefälschte MonkeyChat-App:

MonkeyChat behält ein eigenes Kontaktbuch der Freunde des Benutzers bei, die jeweils einem Bildschirmnamen zugeordnet sind (z. B. Bobo), und ermöglicht es dem Benutzer, Textchats nach seinem Bildschirmnamen an jeden Freund zu senden.

Erweitern der App mit SiriKit

Wie im Leitfaden "Grundlegendes zu SiriKit-Konzepten" gezeigt, gibt es drei Hauptteile bei der Erweiterung einer App mit SiriKit:

Dazu gehören:

1. Intents Extension – Überprüft die Antworten der Benutzer, bestätigt, dass die App die Anforderung verarbeiten kann und führt die Aufgabe tatsächlich aus, um die Anforderung des Benutzers zu erfüllen.
2. Intents UI Extension - Optional, bietet eine benutzerdefinierte Benutzeroberfläche für die Antworten in der Siri-Umgebung und kann die Benutzeroberfläche und das Branding der Apps in Siri bringen, um die Benutzererfahrung zu verbessern.
3. App – Stellt der App benutzerspezifische Vokabular zur Verfügung, um Siri bei der Arbeit damit zu unterstützen.

Alle diese Elemente und die Schritte zur Aufnahme in die App werden in den folgenden Abschnitten ausführlich behandelt.

Vorbereiten der App

SiriKit basiert jedoch auf Erweiterungen, bevor Sie erweiterungen zur App hinzufügen, gibt es ein paar Dinge, die der Entwickler tun muss, um bei der Einführung von SiriKit zu helfen.

Verschieben von gemeinsamem freigegebenem Code

Zuerst kann der Entwickler einen Teil des gemeinsamen Codes verschieben, der zwischen der App und den Erweiterungen in freigegebene Projekte, portable Klassenbibliotheken (PCLs) oder native Bibliotheken geteilt wird.

Die Erweiterungen müssen alle Aktionen ausführen können, die von der App ausgeführt werden. In Bezug auf die Beispiel-MonkeyChat-App, z. B. das Suchen von Kontakten, das Hinzufügen neuer Kontakte, das Senden von Nachrichten und das Abrufen des Nachrichtenverlaufs.

Durch das Verschieben dieses gemeinsamen Codes in ein freigegebenes Projekt, PCL oder native Bibliothek ist es einfach, diesen Code an einem gemeinsamen Ort zu verwalten und sicherzustellen, dass die Erweiterung und die übergeordnete App einheitliche Funktionen und Funktionen für den Benutzer bereitstellen.

Im Falle der Beispiel-App MonkeyChat werden die Datenmodelle und der Verarbeitungscode wie Netzwerk- und Datenbankzugriff in eine native Bibliothek verschoben.

Gehen Sie folgendermaßen vor:

Visual Studio für Mac

1. Starten Sie Visual Studio für Mac, und öffnen Sie die MonkeyChat-App.

2. Klicken Sie mit der rechten Maustaste auf den Projektmappennamen im Projektmappenblock, und wählen Sie "Neues Projekt hinzufügen>..." aus:

   

3. Wählen Sie die Klassenbibliothek der iOS-Bibliothek>>aus, und klicken Sie auf die Schaltfläche "Weiter":

   

4. Geben Sie MonkeyChatCommon den Namen ein, und klicken Sie auf die Schaltfläche "Erstellen":

   

5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise" der Haupt-App, und wählen Sie "Verweise bearbeiten" aus. Überprüfen Sie das MonkeyChatCommon-Projekt, und klicken Sie auf die Schaltfläche "OK":

   

6. Ziehen Sie im Projektmappen-Explorer den gemeinsamen freigegebenen Code aus der Haupt-App in die native Bibliothek.

7. Ziehen Sie im Fall von MonkeyChat die Ordner "DataModels " und "Prozessoren " aus der Haupt-App in die native Bibliothek:

   

Visual Studio

1. Starten Sie Visual Studio, und öffnen Sie die MonkeyChat-App.

2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektmappennamen, und wählen Sie "Neues Projekt hinzufügen>... aus.

3. Wählen Sie Visual C#>Shared Project aus, und klicken Sie auf die Schaltfläche "Weiter":

   

4. Geben Sie MonkeyChatCommon den Namen ein, und klicken Sie auf die Schaltfläche "Erstellen".

5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise" der Haupt-App, und wählen Sie "Verweise bearbeiten" aus. Überprüfen Sie das MonkeyChatCommon-Projekt, und klicken Sie auf die Schaltfläche "OK":

   

6. Ziehen Sie im Projektmappen-Explorer den gemeinsamen freigegebenen Code aus der Haupt-App auf das freigegebene Projekt.

7. Ziehen Sie im Fall von MonkeyChat die Ordner "DataModels " und "Prozessoren " aus der Haupt-App in die native Bibliothek.

Bearbeiten Sie alle Dateien, die in die native Bibliothek verschoben wurden, und ändern Sie den Namespace so, dass er mit der der Bibliothek übereinstimmt. Beispiel: Wechseln MonkeyChat zu MonkeyChatCommon:

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

Wechseln Sie als Nächstes zurück zur Haupt-App, und fügen Sie eine using Anweisung für den Namespace der nativen Bibliothek an einer beliebigen Stelle hinzu, in der die App eine der Klassen verwendet, die verschoben wurden:

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

Entwerfen der App für Erweiterungen

In der Regel wird sich eine App für mehrere Intents registrieren, und der Entwickler muss sicherstellen, dass die App für die entsprechende Anzahl von Intent-Erweiterungen entwickelt wird.

In der Situation, in der eine App mehr als eine Absicht erfordert, hat der Entwickler die Möglichkeit, die gesamte Intent-Behandlung in einer Intent-Erweiterung oder das Erstellen einer separaten Intent-Erweiterung für jede Absicht zu platzieren.

Wenn Sie eine separate Intent-Erweiterung für jeden Intent erstellen möchten, könnte der Entwickler eine große Menge an Codebausteinen in jeder Erweiterung duplizieren und einen großen Prozessor- und Arbeitsspeicheraufwand erstellen.

Um zwischen den beiden Optionen zu wählen, überprüfen Sie, ob eines der Intents natürlich zusammengehört. Beispielsweise kann eine App, die Audio- und Videoanrufe getätigt hat, beide Intents in eine einzelne Intent-Erweiterung einschließen, da sie ähnliche Aufgaben verarbeiten und die meisten Codewiederverwendung bereitstellen können.

Erstellen Sie für jede Intent- oder Intent-Gruppe, die nicht in eine vorhandene Gruppe passt, eine neue Intent-Erweiterung in der App-Lösung, um sie zu enthalten.

Festlegen der erforderlichen Berechtigungen

Jede Xamarin.iOS-App, die SiriKit-Integration enthält, muss über die richtigen Berechtigungen verfügen. Wenn der Entwickler diese erforderlichen Berechtigungen nicht ordnungsgemäß festlegt, kann er die App nicht auf realer iOS 10-Hardware (oder höher) installieren oder testen, was auch erforderlich ist, da der iOS 10 Simulator SiriKit nicht unterstützt.

Gehen Sie folgendermaßen vor:

Visual Studio für Mac

1. Doppelklicken Sie auf die Entitlements.plist Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen.

2. Wechseln Sie zur Registerkarte Quelle.

3. Fügen Sie die com.apple.developer.siri Eigenschaft hinzu, legen Sie den Typ auf Boolean und den Wert auf Yes:

   

4. Speichern Sie die Änderungen in der Datei.

5. Doppelklicken Sie im Projektmappen-Explorer auf die Projektdatei, um sie zur Bearbeitung zu öffnen.

6. Wählen Sie "iOS Bundle Signing" aus, und stellen Sie sicher, dass die Entitlements.plist Datei im Feld "Benutzerdefinierte Berechtigungen" ausgewählt ist:

   

7. Klicken Sie auf die Schaltfläche OK, um die Änderungen zu speichern.

Visual Studio

1. Doppelklicken Sie auf die Entitlements.plist Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen.

2. Fügen Sie die com.apple.developer.siri Eigenschaft hinzu, legen Sie den Typ auf Boolean und den Wert auf Yes:

   

3. Speichern Sie die Änderungen in der Datei.

4. Doppelklicken Sie im Projektmappen-Explorer auf die Projektdatei, um sie zur Bearbeitung zu öffnen.

5. Wählen Sie "iOS Bundle Signing" aus, und stellen Sie sicher, dass die Entitlements.plist Datei im Feld "Benutzerdefinierte Berechtigungen" ausgewählt ist.

Wenn Sie fertig sind, sollte die App-Datei Entitlements.plist wie folgt aussehen (in einem externen Editor geöffnet):

<?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>

Ordnungsgemäße Bereitstellung der App

Aufgrund der strengen Sicherheit, die Apple im SiriKit-Framework platziert hat, muss jede Xamarin.iOS-App, die SiriKit implementiert, über die richtige App-ID und Berechtigungen verfügen (siehe Abschnitt oben) und mit einem entsprechenden Bereitstellungsprofil signiert werden.

Gehen Sie auf Ihrem Mac wie folgt vor:

1. Navigieren Sie in einem Webbrowser zu https://developer.apple.com Ihrem Konto, und melden Sie sich an.

2. Klicken Sie auf Zertifikate, Bezeichner und Profile.

3. Wählen Sie Bereitstellungsprofile aus, und wählen Sie App-IDs aus, und klicken Sie dann auf die + Schaltfläche.

4. Geben Sie einen Namen für das neue Profil ein.

5. Geben Sie eine Bundle-ID ein, die der Benennungsempfehlung von Apple folgt.

6. Scrollen Sie nach unten zum Abschnitt "App Services ", wählen Sie SiriKit aus, und klicken Sie auf die Schaltfläche "Weiter ":

   

7. Überprüfen Sie alle Einstellungen, und übermitteln Sie dann die App-ID.

8. Wählen Sie die Entwicklung von Bereitstellungsprofilen> aus, klicken Sie auf die + Schaltfläche, wählen Sie die Apple-ID aus, und klicken Sie dann auf "Weiter".

9. Klicken Sie auf "Alle auswählen", und klicken Sie dann auf "Weiter".

10. Klicken Sie erneut auf " Alles auswählen", und klicken Sie dann auf " Weiter".

11. Geben Sie einen Profilnamen mithilfe der Benennungsvorschläge von Apple ein, und klicken Sie dann auf "Weiter".

12. Starten Sie Xcode.

13. Wählen Sie im Menü "Xcode" " Einstellungen" aus...

14. Wählen Sie "Konten" aus, und klicken Sie dann auf die Schaltfläche "Details anzeigen":

    

15. Klicken Sie in der unteren linken Ecke auf die Schaltfläche "Alle Profile herunterladen":

    

16. Stellen Sie sicher, dass das oben erstellte Bereitstellungsprofil in Xcode installiert wurde.

17. Öffnen Sie das Projekt, um SiriKit-Unterstützung in Visual Studio für Mac hinzuzufügen.

18. Doppelklicken Sie in der Projektmappen-Explorer auf die Info.plist Datei.

19. Stellen Sie sicher, dass der Bündelbezeichner dem im Apple-Entwicklerportal oben erstellten entspricht:

    

20. Wählen Sie im Projektmappen-Explorer das Projekt aus.

21. Klicken Sie mit der rechten Maustaste auf das Projekt, und wählen Sie "Optionen" aus.

22. Wählen Sie "iOS Bundle Signing" und dann das oben erstellte Signaturidentitäts - und Bereitstellungsprofil aus:

    

23. Klicken Sie auf die Schaltfläche OK, um die Änderungen zu speichern.

Wichtig

Das Testen von SiriKit funktioniert nur auf einem echten iOS 10-Hardwaregerät und nicht im iOS 10 Simulator. Wenn Probleme beim Installieren einer SiriKit-aktivierten Xamarin.iOS-App auf realer Hardware auftreten, stellen Sie sicher, dass die erforderlichen Berechtigungen, App-ID, Signatur-ID und Bereitstellungsprofil sowohl im Apple-Entwicklerportal als auch im Visual Studio für Mac ordnungsgemäß konfiguriert wurden.

Anfordern einer Siri-Autorisierung

Bevor die App benutzerspezifische Vokabular hinzufügt oder die Intents-Erweiterungen eine Verbindung mit Siri herstellen, muss sie die Autorisierung des Benutzers für den Zugriff auf Siri anfordert.

Visual Studio für Mac

Bearbeiten Sie die App-Datei Info.plist , wechseln Sie zur Quellansicht , und fügen Sie den NSSiriUsageDescription Schlüssel mit einem Zeichenfolgenwert hinzu, der beschreibt, wie die App Siri verwendet und welche Datentypen gesendet werden. Die MonkeyChat-App könnte z. B. sagen: "MonkeyChat-Kontakte werden an Siri gesendet":

Visual Studio

Bearbeiten Sie die Datei der App Info.plist , und fügen Sie den NSSiriUsageDescription Schlüssel mit einem Zeichenfolgenwert hinzu, der beschreibt, wie die App Siri verwendet und welche Datentypen gesendet werden. Die MonkeyChat-App könnte z. B. sagen: "MonkeyChat-Kontakte werden an Siri gesendet":

Rufen Sie die RequestSiriAuthorization Methode der INPreferences Klasse auf, wenn die App zum ersten Mal gestartet wird. Bearbeiten Sie die AppDelegate.cs Klasse, und stellen Sie sicher, dass die FinishedLaunching Methode wie folgt aussieht:

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

Wenn diese Methode zum ersten Mal aufgerufen wird, wird eine Warnung angezeigt, die den Benutzer auffordert, der App den Zugriff auf Siri zu ermöglichen. Die Meldung, dass der Entwickler der NSSiriUsageDescription obigen Meldung hinzugefügt hat, wird in dieser Warnung angezeigt. Wenn der Benutzer zunächst den Zugriff verweigert, kann er die Einstellungs-App verwenden, um zugriff auf die App zu gewähren.

Jederzeit kann die App die Fähigkeit der App überprüfen, auf Siri zuzugreifen, indem sie die SiriAuthorizationStatus Methode der INPreferences Klasse aufruft.

Lokalisierung und Siri

Auf einem iOS-Gerät kann der Benutzer eine Sprache für Siri auswählen, die sich von der Systemstandardeinstellung unterscheidet. Beim Arbeiten mit lokalisierten Daten muss die App die SiriLanguageCode Methode der INPreferences Klasse verwenden, um den Sprachcode von Siri abzurufen. Zum Beispiel:

var language = INPreferences.SiriLanguageCode();

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

Hinzufügen von benutzerspezifischem Vokabular

Das benutzerspezifische Vokabular wird Wörter oder Ausdrücke bereitstellen, die für einzelne Benutzer der App einzigartig sind. Diese werden zur Laufzeit über die Haupt-App (nicht die App-Erweiterungen) als sortierte Gruppe von Ausdrücken bereitgestellt, die in einer wichtigsten Nutzungspriorität für die Benutzer sortiert sind, wobei die wichtigsten Begriffe am Anfang der Liste stehen.

Benutzerspezifisches Vokabular muss zu einer der folgenden Kategorien gehören:

• Kontaktnamen (die nicht vom Kontakteframework verwaltet werden).
• Fototags.
• Fotoalbumnamen.
• Trainingsnamen.

Wenn Sie Terminologie auswählen, die als benutzerdefiniertes Vokabular registriert werden soll, wählen Sie nur Ausdrücke aus, die von jemanden, der nicht mit der App vertraut ist, falsch verstanden werden. Registrieren Sie niemals allgemeine Begriffe wie "Mein Training" oder "Mein Album". Die MonkeyChat-App registriert beispielsweise die Spitznamen, die jedem Kontakt im Adressbuch des Benutzers zugeordnet sind.

Die App stellt das benutzerspezifische Vokabular bereit, indem die SetVocabularyStrings Methode der INVocabulary Klasse aufgerufen und eine NSOrderedSet Sammlung aus der Haupt-App übergeben wird. Die App sollte die RemoveAllVocabularyStrings Methode immer zuerst aufrufen, um vorhandene Ausdrücke zu entfernen, bevor neue hinzugefügt werden. Zum Beispiel:

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

Dieser Code kann wie folgt aufgerufen werden:

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

Wichtig

Siri behandelt benutzerdefinierte Vokabular als Hinweise und wird so viel Terminologie wie möglich integrieren. Der Platz für benutzerdefinierte Vokabular beschränkt sich jedoch darauf, nur die Terminologie zu registrieren, die möglicherweise verwirrend sein kann, sodass die Gesamtzahl der registrierten Begriffe auf ein Minimum beschränkt ist.

Weitere Informationen finden Sie in unserer Benutzerspezifischen Vokabularreferenz und in der Benutzerdefinierten Vokabularreferenz von Apple.

Hinzufügen von App-spezifischem Vokabular

Das App-spezifische Vokabular definiert die spezifischen Wörter und Ausdrücke, die allen Benutzern der App bekannt sind, z. B. Fahrzeugtypen oder Trainingsnamen. Da diese Teil der Anwendung sind, werden sie als Teil des Haupt-App-Bündels in einer AppIntentVocabulary.plist Datei definiert. Darüber hinaus sollten diese Wörter und Ausdrücke lokalisiert werden.

App-Spezifische Vokabularbegriffe müssen zu einer der folgenden Kategorien gehören:

• Fahroptionen.
• Trainingsnamen.

Die App-spezifische Vokabulardatei enthält zwei Schlüssel auf Stammebene:

• ParameterVocabulariesErforderlich – Definiert die benutzerdefinierten Ausdrücke und Intent-Parameter der App, auf die sie angewendet werden.
• IntentPhrasesOptional - Enthält Beispielausdrücke mithilfe der benutzerdefinierten Ausdrücke, die in der ParameterVocabularies.

Jeder Eintrag in der ParameterVocabularies Zeichenfolge muss eine ID-Zeichenfolge, einen Ausdruck und den Intent angeben, für den der Ausdruck gilt. Darüber hinaus kann ein einzelner Ausdruck auf mehrere Intents angewendet werden.

Eine vollständige Liste der zulässigen Werte und der erforderlichen Dateistruktur finden Sie in der Referenz zum App-Vokabulardateiformat von Apple.

Gehen Sie wie folgt vor, um dem App-Projekt eine AppIntentVocabulary.plist Datei hinzuzufügen:

Visual Studio für Mac

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und wählen Sie "Neue Datei hinzufügen>" aus...>iOS:

   

2. Doppelklicken Sie auf die AppIntentVocabulary.plist Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen.

3. Klicken Sie auf die + Taste, um einen Schlüssel hinzuzufügen, legen Sie den Namen ParameterVocabularies und den Typ auf :Array

   

4. Erweitern ParameterVocabularies Und klicken Sie auf die + Schaltfläche, und legen Sie den Typ auf :Dictionary

   

5. Klicken Sie auf die + Schaltfläche, um einen neuen Schlüssel hinzuzufügen, legen Sie den Namen ParameterNames und den Typ auf Array:

   

6. Klicken Sie auf die + Schaltfläche, um einen neuen Schlüssel mit dem Typ und String dem Wert als einen der verfügbaren Parameternamen hinzuzufügen. Beispiel: INStartWorkoutIntent.workoutName:

   

7. Fügen Sie den ParameterVocabulary ParameterVocabularies Schlüssel mit dem Typ von Array:

   

8. Hinzufügen eines neuen Schlüssels mit dem Typ von Dictionary:

   

9. Fügen Sie den VocabularyItemIdentifier Schlüssel mit dem Typ des String Ausdrucks hinzu, und geben Sie eine eindeutige ID für den Ausdruck an:

   

10. Fügen Sie den VocabularyItemSynonyms Schlüssel mit dem Typ von Array:

    

11. Hinzufügen eines neuen Schlüssels mit dem Typ von Dictionary:

    

12. Fügen Sie den VocabularyItemPhrase Schlüssel mit dem Typ und String dem Ausdruck hinzu, den die App definiert:

    

13. Fügen Sie den VocabularyItemPronunciation Schlüssel mit dem Typ des String Begriffs und der phonetischen Aussprache des Begriffs hinzu:

    

14. Fügen Sie den VocabularyItemExamples Schlüssel mit dem Typ von Array:

    

15. Fügen Sie einige String Schlüssel mit Beispielverwendungen für den Ausdruck hinzu:

    

16. Wiederholen Sie die vorstehenden Schritte für alle anderen benutzerdefinierten Ausdrücke, die die App definieren muss.

17. Reduzieren Sie die ParameterVocabularies Taste.

18. Fügen Sie den IntentPhrases Schlüssel mit dem Typ von Array:

    

19. Hinzufügen eines neuen Schlüssels mit dem Typ von Dictionary:

    

20. Fügen Sie den IntentName Schlüssel mit dem Typ von String und der Absicht für das Beispiel hinzu:

    

21. Fügen Sie den IntentExamples Schlüssel mit dem Typ von Array:

    

22. Fügen Sie einige String Schlüssel mit Beispielverwendungen für den Ausdruck hinzu:

    

23. Wiederholen Sie die obigen Schritte für alle Absichten, die die App benötigen, um beispiel für die Verwendung anzugeben.

Visual Studio

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und wählen Sie "Neues Element hinzufügen>" aus... > Apple > Property List > Info.plist:

   

2. Doppelklicken Sie auf die AppIntentVocabulary.plist Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen.

3. Klicken Sie auf die + Taste, um einen Schlüssel hinzuzufügen, legen Sie den Namen ParameterVocabularies und den Typ auf :Array

   

4. Erweitern ParameterVocabularies Und klicken Sie auf die + Schaltfläche, und legen Sie den Typ auf :Dictionary

   

5. Klicken Sie auf die + Schaltfläche, um einen neuen Schlüssel hinzuzufügen, legen Sie den Namen ParameterNames und den Typ auf Array:

   

6. Klicken Sie auf die + Schaltfläche, um einen neuen Schlüssel mit dem Typ und String dem Wert als einen der verfügbaren Parameternamen hinzuzufügen. Beispiel: INStartWorkoutIntent.workoutName:

   

7. Fügen Sie den ParameterVocabulary ParameterVocabularies Schlüssel mit dem Typ von Array:

   

8. Hinzufügen eines neuen Schlüssels mit dem Typ von Dictionary:

   

9. Fügen Sie den VocabularyItemIdentifier Schlüssel mit dem Typ des String Ausdrucks hinzu, und geben Sie eine eindeutige ID für den Ausdruck an:

   

10. Fügen Sie den VocabularyItemSynonyms Schlüssel mit dem Typ von Array:

    

11. Hinzufügen eines neuen Schlüssels mit dem Typ von Dictionary:

    

12. Fügen Sie den VocabularyItemPhrase Schlüssel mit dem Typ und String dem Ausdruck hinzu, den die App definiert:

    

13. Fügen Sie den VocabularyItemPronunciation Schlüssel mit dem Typ des String Begriffs und der phonetischen Aussprache des Begriffs hinzu:

    

14. Fügen Sie den VocabularyItemExamples Schlüssel mit dem Typ von Array:

    

15. Fügen Sie einige String Schlüssel mit Beispielverwendungen für den Ausdruck hinzu:

    

16. Wiederholen Sie die vorstehenden Schritte für alle anderen benutzerdefinierten Ausdrücke, die die App definieren muss.

17. Reduzieren Sie die ParameterVocabularies Taste.

18. Fügen Sie den IntentPhrases Schlüssel mit dem Typ von Array:

    

19. Hinzufügen eines neuen Schlüssels mit dem Typ von Dictionary:

    

20. Fügen Sie den IntentName Schlüssel mit dem Typ von String und der Absicht für das Beispiel hinzu:

    

21. Fügen Sie den IntentExamples Schlüssel mit dem Typ von Array:

    

22. Fügen Sie einige String Schlüssel mit Beispielverwendungen für den Ausdruck hinzu:

    

23. Wiederholen Sie die obigen Schritte für alle Absichten, die die App benötigen, um beispiel für die Verwendung anzugeben.

Wichtig

Die AppIntentVocabulary.plist Wird während der Entwicklung bei Siri auf den Testgeräten registriert und es kann einige Zeit dauern, bis Siri das benutzerdefinierte Vokabular integriert. Daher muss der Tester mehrere Minuten warten, bevor versucht wird, das App-spezifische Vokabular zu testen, wenn es aktualisiert wurde.

Weitere Informationen finden Sie in unserer App-spezifischen Vokabularreferenz und der Benutzerdefinierten Vokabularreferenz von Apple.

Hinzufügen einer Intents-Erweiterung

Nachdem die App bereit war, SiriKit zu übernehmen, muss der Entwickler der Lösung eine (oder mehrere) Intents-Erweiterungen hinzufügen, um die für die Siri-Integration erforderlichen Intents zu behandeln.

Gehen Sie für jede erforderliche Intents-Erweiterung wie folgt vor:

• Fügen Sie der Xamarin.iOS-App-Lösung ein Intents-Erweiterungsprojekt hinzu.
• Konfigurieren Sie die Intents-Erweiterungsdatei Info.plist .
• Ändern Sie die Hauptklasse "Intents Extension".

Weitere Informationen finden Sie in unserer Intents-Erweiterungsreferenz und apples Creating the Intents Extension Reference.

Erstellen der Erweiterung

Gehen Sie wie folgt vor, um der Lösung eine Intents-Erweiterung hinzuzufügen:

Visual Studio für Mac

1. Klicken Sie mit der rechten Maustaste auf den Projektmappennamen im Projektmappenblock, und wählen Sie "Neues Projekt hinzufügen... hinzufügen>" aus.

2. Wählen Sie im Dialogfeld die Absichtserweiterung für iOS-Erweiterungen>>aus, und klicken Sie auf die Schaltfläche "Weiter":

   

3. Geben Sie als Nächstes einen Namen für die Intent-Erweiterung ein, und klicken Sie auf die Schaltfläche "Weiter":

   

4. Klicken Sie schließlich auf die Schaltfläche "Erstellen ", um der App-Lösung die Intent-Erweiterung hinzuzufügen:

   

5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise" der neu erstellten Intent-Erweiterung. Überprüfen Sie den Namen des gemeinsamen freigegebenen Codebibliotheksprojekts (das die oben erstellte App) und klicken Sie auf die Schaltfläche "OK ":

   

Visual Studio

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektmappennamen, und wählen Sie "Neues Projekt hinzufügen>" aus.

2. Wählen Sie im Dialogfeld visual C# > iOS Extensions > Intent Extension aus, und klicken Sie auf die Schaltfläche "Weiter ":

   

3. Geben Sie als Nächstes einen Namen für die Intent-Erweiterung ein, und klicken Sie auf die Schaltfläche "OK ".

4. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise" der neu erstellten Intents-Erweiterung, und wählen Sie "Verweis hinzufügen" > aus. Überprüfen Sie den Namen des gemeinsamen freigegebenen Codebibliotheksprojekts (das die oben erstellte App) und klicken Sie auf die Schaltfläche "OK ":

   

Wiederholen Sie diese Schritte für die Anzahl der Intent-Erweiterungen (basierend auf der Architektur des Abschnitts "App für Erweiterungen ").

Konfigurieren der Info.plist

Für jede der Intents-Erweiterungen, die der Lösung der App hinzugefügt wurden, muss in den Info.plist Dateien für die Arbeit mit der App konfiguriert werden.

Genau wie jede typische App-Erweiterung verfügt die App über die vorhandenen Schlüssel und NSExtension NSExtensionAttributes. Für eine Intents-Erweiterung gibt es zwei neue Attribute, die konfiguriert werden müssen:

• IntentsSupported – Ist erforderlich und besteht aus einem Array von Intent-Klassennamen, die die App von der Intent-Erweiterung unterstützen möchte.
• IntentsRestrictedWhileLocked – Ist ein optionaler Schlüssel für die App, um das Verhalten des Sperrbildschirms der Erweiterung anzugeben. Es besteht aus einem Array von Intent-Klassennamen, die von der App verlangt werden soll, dass der Benutzer über die Intent-Erweiterung angemeldet ist.

Um die Datei der Intent-Erweiterung Info.plist zu konfigurieren, doppelklicken Sie auf die Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen. Wechseln Sie als Nächstes zur Quellansicht , und erweitern Sie die NSExtension NSExtensionAttributes Tasten im Editor:

Visual Studio für Mac

Visual Studio

Erweitern Sie den IntentsSupported Schlüssel, und fügen Sie den Namen einer beliebigen Intent-Klasse hinzu, die diese Erweiterung unterstützt. Für die Beispiel-MonkeyChat-App unterstützt sie folgendes INSendMessageIntent:

Visual Studio für Mac

Visual Studio

Wenn die App optional erfordert, dass der Benutzer auf dem Gerät angemeldet ist, um eine bestimmte Absicht zu verwenden, erweitern Sie den IntentRestrictedWhileLocked Schlüssel, und fügen Sie die Klassennamen der Intents hinzu, die eingeschränkten Zugriff haben. Für die Beispiel-MonkeyChat-App muss der Benutzer angemeldet sein, um eine Chatnachricht zu senden, damit wir folgendes hinzugefügt INSendMessageIntenthaben:

Visual Studio für Mac

Visual Studio

Eine vollständige Liste der verfügbaren Intent-Domänen finden Sie in der Apple Intent Domains Reference.

Konfigurieren der Hauptklasse

Als Nächstes muss der Entwickler die Hauptklasse konfigurieren, die als Haupteinstiegspunkt für die Intent-Erweiterung in Siri fungiert. Es muss eine Unterklasse sein, deren INExtension Übereinstimmung mit der IINIntentHandler Stellvertretung besteht. Zum Beispiel:

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
        ...
    }
}

Es gibt eine einzelne Methode, die die App in der Hauptklasse intent Extension implementieren muss, die GetHandler Methode. Diese Methode wird von SiriKit an Intent übergeben, und die App muss einen Intent-Handler zurückgeben, der dem Typ des angegebenen Intent entspricht.

Da die Beispiel-MonkeyChat-App nur eine Absicht behandelt, wird sie in der GetHandler Methode zurückgegeben. Wenn die Erweiterung mehrere Absichten behandelt hat, würde der Entwickler eine Klasse für jeden Intent-Typ hinzufügen und eine Instanz hier basierend auf der Intent an die Methode übergebenen zurückgeben.

Behandeln der Auflösungsphase

In der Auflösungsphase wird die Intent-Erweiterung Parameter klären und überprüfen, die von Siri übergeben wurden und über die Unterhaltung des Benutzers festgelegt wurden.

Für jeden Parameter, der von Siri gesendet wird, gibt es eine Resolve Methode. Die App muss diese Methode für jeden Parameter implementieren, den die App möglicherweise benötigt, um die richtige Antwort vom Benutzer zu erhalten.

Im Fall der Beispiel-MonkeyChat-App erfordert die Intent-Erweiterung einen oder mehrere Empfänger, an die die Nachricht gesendet werden soll. Für jeden Empfänger in der Liste muss die Erweiterung eine Kontaktsuche ausführen, die das folgende Ergebnis haben kann:

• Genau ein übereinstimmenden Kontakt wird gefunden.
• Es werden zwei oder mehr übereinstimmende Kontakte gefunden.
• Es wurden keine übereinstimmenden Kontakte gefunden.

Darüber hinaus erfordert MonkeyChat Inhalte für den Textkörper der Nachricht. Wenn der Benutzer dies nicht angegeben hat, muss Siri den Benutzer zur Eingabe des Inhalts auffordern.

Die Intent-Erweiterung muss jeden dieser Fälle ordnungsgemäß behandeln.

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

Weitere Informationen finden Sie in unserer Referenz zur Auflösungsphase und zur Lösung und Verarbeitung von Intents von Apple.

Behandeln der Bestätigungsphase

In der Phase "Bestätigen" überprüft die Intent-Erweiterung, ob sie alle Informationen enthält, um die Anforderung des Benutzers zu erfüllen. Die App möchte eine Bestätigung senden, um alle unterstützenden Details darüber zu erhalten, was mit Siri passiert, damit sie mit dem Benutzer bestätigt werden kann, dass dies die beabsichtigte Aktion ist.

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

Weitere Informationen finden Sie in unserer Referenz zur Bestätigungsphase.

Verarbeiten der Absicht

Dies ist der Punkt, an dem die Intent-Erweiterung tatsächlich die Aufgabe ausführt, die Anforderung des Benutzers zu erfüllen und die Ergebnisse zurück an Siri zu übergeben, damit der Benutzer informiert werden kann.

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

Weitere Informationen finden Sie in unserer Referenz zur Handle-Phase.

Hinzufügen einer Intents-UI-Erweiterung

Die optionale Intents UI-Erweiterung bietet die Möglichkeit, die Benutzeroberfläche und das Branding der App in die Siri-Erfahrung zu bringen und den Benutzern das Gefühl zu geben, mit der App verbunden zu sein. Mit dieser Erweiterung kann die App die Marke sowie visuelle und andere Informationen in die Transkription bringen.

Genau wie die Intents-Erweiterung führt der Entwickler den folgenden Schritt für die Intents-UI-Erweiterung aus:

• Fügen Sie der Xamarin.iOS-App-Lösung ein Intents-UI-Erweiterungsprojekt hinzu.
• Konfigurieren Sie die Intents-UI-Erweiterungsdatei Info.plist .
• Ändern Sie die Hauptklasse der Intents-UI-Erweiterung.

Weitere Informationen finden Sie in unserer Intents-UI-Erweiterungsreferenz und apples Bereitstellen einer benutzerdefinierten Schnittstellenreferenz.

Erstellen der Erweiterung

Gehen Sie wie folgt vor, um der Lösung eine Intents-UI-Erweiterung hinzuzufügen:

Visual Studio für Mac

1. Klicken Sie mit der rechten Maustaste auf den Projektmappennamen im Projektmappenblock, und wählen Sie "Neues Projekt hinzufügen... hinzufügen>" aus.

2. Wählen Sie im Dialogfeld die Ui-Erweiterung für iOS-Erweiterungen>>aus, und klicken Sie auf die Schaltfläche "Weiter":

   

3. Geben Sie als Nächstes einen Namen für die Intent-Erweiterung ein, und klicken Sie auf die Schaltfläche "Weiter":

   

4. Klicken Sie schließlich auf die Schaltfläche "Erstellen ", um der App-Lösung die Intent-Erweiterung hinzuzufügen:

   

5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise" der neu erstellten Intent-Erweiterung. Überprüfen Sie den Namen des gemeinsamen freigegebenen Codebibliotheksprojekts (das die oben erstellte App) und klicken Sie auf die Schaltfläche "OK ":

   

Visual Studio

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektmappennamen, und wählen Sie "Neues Projekt hinzufügen">aus...
2. Wählen Sie im Dialogfeld die Ui-Erweiterung für iOS-Erweiterungen>>aus, und klicken Sie auf die Schaltfläche "Weiter".
3. Geben Sie als Nächstes einen Namen für die Intent-Erweiterung ein, und klicken Sie auf die Schaltfläche "OK ".
4. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise" der neu erstellten Intent-Erweiterung. Überprüfen Sie den Namen des gemeinsamen freigegebenen Codebibliotheksprojekts (das die oben erstellte App) und klicken Sie auf die Schaltfläche "OK ".

Konfigurieren der Info.plist

Konfigurieren Sie die Datei der Intents-UI-Erweiterung Info.plist für die Arbeit mit der App.

Genau wie jede typische App-Erweiterung verfügt die App über die vorhandenen Schlüssel und NSExtension NSExtensionAttributes. Für eine Intents-Erweiterung gibt es ein neues Attribut, das konfiguriert werden muss:

IntentsSupported ist erforderlich und besteht aus einem Array von Intent-Klassennamen, die von der App von der Intent-Erweiterung unterstützt werden sollen.

Visual Studio für Mac

Um die Datei der Intent-UI-Erweiterung Info.plist zu konfigurieren, doppelklicken Sie auf die Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen. Wechseln Sie als Nächstes zur Quellansicht , und erweitern Sie die NSExtension NSExtensionAttributes Tasten im Editor:

Visual Studio

Um die Datei der Intent-UI-Erweiterung Info.plist zu konfigurieren, doppelklicken Sie auf die Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen. Erweitern Sie die NSExtension Tasten und NSExtensionAttributes Tasten im Editor:

Erweitern Sie den IntentsSupported Schlüssel, und fügen Sie den Namen einer beliebigen Intent-Klasse hinzu, die diese Erweiterung unterstützt. Für die Beispiel-MonkeyChat-App unterstützt sie folgendes INSendMessageIntent:

Visual Studio für Mac

Visual Studio

Eine vollständige Liste der verfügbaren Intent-Domänen finden Sie in der Apple Intent Domains Reference.

Konfigurieren der Hauptklasse

Konfigurieren Sie die Hauptklasse, die als Haupteinstiegspunkt für die Intent-UI-Erweiterung in Siri fungiert. Es muss eine Unterklasse sein, der UIViewController der IINUIHostedViewController Schnittstelle entspricht. Zum Beispiel:

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 übergibt eine INInteraction Klasseninstanz an die Configure Methode der UIViewController Instanz innerhalb der Intent-UI-Erweiterung.

Das INInteraction Objekt stellt drei wichtige Informationen für die Erweiterung bereit:

1. Das Intent-Objekt, das verarbeitet wird.
2. Das Intent Response -Objekt aus den Confirm Und Handle Methoden der Intent-Erweiterung.
3. Der Interaktionsstatus, der den Zustand der Interaktion zwischen der App und Siri definiert.

Die UIViewController Instanz ist die Prinzipklasse für die Interaktion mit Siri und da sie von erbt UIViewController, hat sie Zugriff auf alle Features von UIKit.

Wenn Siri die Configure Methode des UIViewController Aufrufs in einem Ansichtskontext aufruft, der besagt, dass der Ansichtscontroller entweder in einer Siri Snippit- oder Kartenkarte gehostet wird.

Siri übergibt auch einen Abschlusshandler, den die App benötigt, um die gewünschte Größe der Ansicht zurückzugeben, sobald die App die Konfiguration abgeschlossen hat.

Entwerfen der Benutzeroberfläche im iOS-Designer

Layout the Intents UI Extension's user interface in the iOS Designer. Doppelklicken Sie auf die Datei der Erweiterung MainInterface.storyboard in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen. Ziehen Sie alle erforderlichen UI-Elemente, um die Benutzeroberfläche zu erstellen und die Änderungen zu speichern.

Wichtig

Obwohl es möglich ist, interaktive Elemente wie UIButtons oder UITextFields der Intent-UI-Erweiterung UIViewControllerhinzuzufügen, sind diese streng verboten, da die Intent-Benutzeroberfläche nicht interaktiv ist und der Benutzer nicht mit ihnen interagieren kann.

Verkabeln der Benutzeroberfläche

Bearbeiten Sie mit der Benutzeroberfläche der Intents-UI-Erweiterung, die im iOS-Designer erstellt wurde, die UIViewController Unterklasse, und überschreiben Sie die Configure Methode wie folgt:

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

Überschreiben der Standardmäßigen Siri-Benutzeroberfläche

Die Intents-UI-Erweiterung wird immer zusammen mit anderen Siri-Inhalten wie dem App-Symbol und dem Namen oben auf der Benutzeroberfläche angezeigt oder, basierend auf der Absicht, Schaltflächen (wie "Senden" oder "Abbrechen") unten angezeigt.

Es gibt einige Instanzen, in denen die App die Informationen ersetzen kann, die Siri standardmäßig für den Benutzer anzeigt, z. B. Nachrichten oder Karten, in denen die App die Standardoberfläche durch eine für die App zugeschnittene ersetzen kann.

Wenn die Intents-UI-Erweiterung Elemente der standardmäßigen Siri-Benutzeroberfläche außer Kraft setzen muss, muss die UIViewController Unterklasse die IINUIHostedViewSiriProviding Schnittstelle implementieren und sich für die Anzeige eines bestimmten Schnittstellenelements entscheiden.

Fügen Sie der UIViewController Unterklasse den folgenden Code hinzu, um Siri mitzuteilen, dass die Intent-UI-Erweiterung bereits den Nachrichteninhalt anzeigt:

public bool DisplaysMessage {
    get {return true;}
}

Überlegungen

Apple schlägt vor, dass der Entwickler beim Entwerfen und Implementieren der Intent-UI-Erweiterungen die folgenden Überlegungen berücksichtigt:

• Bewusste Speicherauslastung – Da Intent-UI-Erweiterungen vorübergehend und nur für kurze Zeit angezeigt werden, erzwingt das System engere Speichereinschränkungen als bei einer vollständigen App.
• Berücksichtigen Sie mindeste und maximale Ansichtsgrößen – Stellen Sie sicher, dass die Intent-UI-Erweiterungen für jeden iOS-Gerätetyp, jede Größe und Ausrichtung gut aussehen. Darüber hinaus kann die gewünschte Größe, die die App zurück an Siri sendet, möglicherweise nicht gewährt werden.
• Verwenden Sie flexible und adaptive Layoutmuster – wieder, um sicherzustellen, dass die Benutzeroberfläche auf jedem Gerät hervorragend aussieht.

Zusammenfassung

In diesem Artikel wurde SiriKit behandelt und gezeigt, wie es den Xamarin.iOS-Apps hinzugefügt werden kann, um Dienste bereitzustellen, die für den Benutzer mithilfe von Siri und der Karten-App auf einem iOS-Gerät zugänglich sind.

Verwandte Links

• SiriKit-Programmierhandbuch
• Intents Framework-Referenz
• Intents UI Framework-Referenz
• Intent Domains Reference