HomeKit in Xamarin.iOS

HomeKit ist das Framework von Apple zum Steuern von Heimautomatisierungs-Geräten. Dieser Artikel führt HomeKit ein und behandelt das Konfigurieren von Testzubehör im HomeKit Accessory Simulator und das Schreiben einer einfachen Xamarin.iOS-App für die Interaktion mit diesen Zubehörteilen.

Apple führte HomeKit in iOS 8 als Möglichkeit ein, mehrere Heimautomatisierungs-Geräte von einer Vielzahl von Anbietern nahtlos in eine einzige, kohärente Einheit zu integrieren. Durch die Förderung eines gemeinsamen Protokolls zum Auffinden, Konfigurieren und Steuern von Heimautomatisierungs-Geräten ermöglicht HomeKit Geräten von nicht verwandten Anbietern, zusammenzuarbeiten, ohne dass die einzelnen Anbieter Anstrengungen koordinieren müssen.

Mit HomeKit können Sie eine Xamarin.iOS-App erstellen, die jedes HomeKit-aktivierte Gerät steuert, ohne vom Anbieter bereitgestellte APIs oder Apps zu verwenden. Mit HomeKit können Sie folgende Aktionen ausführen:

• Entdecken Sie neue HomeKit-aktivierte Heimautomatisierungs-Geräte, und fügen Sie sie einer Datenbank hinzu, die auf allen iOS-Geräten des Benutzers beibehalten wird.
• Einrichten, Konfigurieren, Anzeigen und Steuern aller Geräte in der HomeKit Home Configuration-Datenbank.
• Kommunizieren Sie mit jedem vorkonfigurierten HomeKit-Gerät, und führen Sie sie aus, um einzelne Aktionen auszuführen oder im Konzert zu arbeiten, z. B. das Einschalten aller Lichter in der Küche.

Zusätzlich zur Bereitstellung von Geräten in der Home Configuration-Datenbank für HomeKit-aktivierte Apps bietet HomeKit Zugriff auf Siri-Sprachbefehle. Angesichts einer entsprechend konfigurierten HomeKit-Einrichtung kann der Benutzer Sprachbefehle wie "Siri, die Lichter im Wohnzimmer aktivieren" ausstellen.

Die Home-Konfigurationsdatenbank

HomeKit organisiert alle Automatisierungsgeräte an einem bestimmten Ort in einer Home Collection. Diese Sammlung bietet dem Benutzer die Möglichkeit, seine Heimautomatisierungsgeräte in logisch angeordnete Einheiten mit aussagekräftigen, lesbaren Bezeichnungen zu gruppieren.

Die Home Collection wird in einer Heimkonfigurationsdatenbank gespeichert, die automatisch gesichert und auf allen iOS-Geräten des Benutzers synchronisiert wird. HomeKit stellt die folgenden Klassen zum Arbeiten mit der Home Configuration Database bereit:

• HMHome - Dies ist der Container auf oberster Ebene, der alle Informationen und Konfigurationen für alle Heimautomatisierungsgeräte an einem einzigen physischen Standort (z. B. einen einzelnen Familienwohnsitz) enthält. Der Benutzer hat möglicherweise mehr als einen Wohnsitz, z. B. seine Standard Haus und ein Ferienhaus. Oder sie haben möglicherweise verschiedene "Häuser" auf demselben Grundstück, wie das Standard Haus und ein Gasthaus über die Garage. Auf beide Weise muss mindestens ein HMHome Objekt eingerichtet und gespeichert werden, bevor andere HomeKit-Informationen eingegeben werden können.
• HMRoom - Optional ermöglicht es HMRoom dem Benutzer, bestimmte Räume innerhalb eines Hauses (HMHome) zu definieren, z. B. Küche, Badezimmer, Garage oder Wohnzimmer. Der Benutzer kann alle Heimautomatisierungsgeräte an einem bestimmten Ort in ihrem Haus in eine HMRoom Gruppe setzen und als Einheit darauf reagieren. Fordern Sie beispielsweise Siri auf, die Garagenlichter zu deaktivieren.
• HMAccessory - Dies stellt ein individuelles physisches HomeKit-fähiges Automatisierungsgerät dar, das in der Residenz des Benutzers installiert wurde (z. B. ein smarter Thermometer). Jeder HMAccessory wird einem HMRoom. Wenn der Benutzer keine Räume konfiguriert hat, weist HomeKit Einem speziellen Standardraum Zubehör zu.
• HMService - Stellt einen von einem bestimmten HMAccessoryDienst bereitgestellten Dienst dar, z. B. den Ein-/Aus-Zustand eines Lichts oder seiner Farbe (wenn farbverändernde Farben unterstützt werden). Jeder HMAccessory kann mehr als einen Service haben, z. B. einen Garagentüröffer, der auch ein Licht enthält. Darüber hinaus verfügt ein gegebener Dienst HMAccessory möglicherweise über Dienste, z. B. firmwareupdates, die sich außerhalb der Benutzersteuerung befinden.
• HMZone – Ermöglicht es dem Benutzer, eine Sammlung von HMRoom Objekten in logische Zonen zu gruppieren, z. B. Im Oberen Bereich, Downstairs oder Keller. Wenn dies optional ist, können Interaktionen wie Siri dazu aufgefordert werden, alle Lichtabstränge zu deaktivieren.

Bereitstellen einer HomeKit-App

Aufgrund der Von HomeKit auferlegten Sicherheitsanforderungen muss eine Xamarin.iOS-App, die das HomeKit-Framework verwendet, sowohl im Apple Developer Portal als auch in der Projektdatei Xamarin.iOS ordnungsgemäß konfiguriert sein.

Gehen Sie folgendermaßen vor:

1. Melden Sie sich beim Apple Developer Portal an.

2. Klicken Sie auf Zertifikate, Bezeichner und Profile.

3. Wenn Sie dies noch nicht getan haben, klicken Sie auf Bezeichner , und erstellen Sie eine ID für Ihre App (z. B. com.company.appname), sonst bearbeiten Sie Ihre vorhandene ID.

4. Stellen Sie sicher, dass der HomeKit-Dienst auf die angegebene ID überprüft wurde:

   

5. Speichern Sie die Änderungen.

6. Klicken Sie auf die Entwicklung von Bereitstellungsprofilen>, und erstellen Sie ein neues Entwicklungsbereitstellungsprofil für Ihre App:

   

7. Laden Sie entweder das neue Bereitstellungsprofil herunter, und installieren Sie es mit Xcode, um das Profil herunterzuladen und zu installieren.

8. Bearbeiten Sie Ihre Xamarin.iOS-Projektoptionen, und stellen Sie sicher, dass Sie das soeben erstellte Bereitstellungsprofil verwenden:

   

9. Bearbeiten Sie als Nächstes Ihre Info.plist-Datei , und stellen Sie sicher, dass Sie die App-ID verwenden, die zum Erstellen des Bereitstellungsprofils verwendet wurde:

   

10. Bearbeiten Sie schließlich die Datei "Entitlements.plist ", und stellen Sie sicher, dass die HomeKit-Berechtigung ausgewählt wurde:

    

11. Speichern Sie die Änderungen an allen Dateien.

Mit diesen Einstellungen ist die Anwendung jetzt bereit, auf die HomeKit Framework-APIs zuzugreifen. Ausführliche Informationen zur Bereitstellung finden Sie in unseren Leitfäden zur Gerätebereitstellung und -bereitstellung.

Wichtig

Das Testen einer aktivierten HomeKit-App erfordert ein echtes iOS-Gerät, das für die Entwicklung ordnungsgemäß bereitgestellt wurde. HomeKit kann nicht vom iOS-Simulator getestet werden.

Der HomeKit-Zubehörsimulator

Um eine Möglichkeit zu bieten, alle möglichen Heimautomatisierungs-Geräte und -Dienste zu testen, ohne über ein physisches Gerät verfügen zu müssen, hat Apple den HomeKit Accessory Simulator erstellt. Mit diesem Simulator können Sie virtuelle HomeKit-Geräte einrichten und konfigurieren.

Installieren des Simulators

Apple stellt den HomeKit Accessory Simulator als separaten Download von Xcode bereit, daher müssen Sie ihn installieren, bevor Sie fortfahren.

Gehen Sie folgendermaßen vor:

1. Besuchen Sie in einem Webbrowser Downloads für Apple-Entwickler

2. Laden Sie die zusätzlichen Tools für Xcode xxx herunter (wobei xxx die Version von Xcode ist, die Sie installiert haben):

   

3. Öffnen Sie das Datenträgerimage, und installieren Sie die Tools in Ihrem Anwendungsverzeichnis .

Mit dem installierten HomeKit Accessory Simulator können virtuelles Zubehör zum Testen erstellt werden.

Erstellen virtueller Zubehörteile

Gehen Sie wie folgt vor, um den HomeKit Accessory Simulator zu starten und ein paar virtuelles Zubehör zu erstellen:

1. Starten Sie im Ordner "Anwendungen" den HomeKit Accessory Simulator:

   

2. Klicken Sie auf die + Schaltfläche, und wählen Sie "Neues Zubehör" aus ...:

   

3. Füllen Sie die Informationen zum neuen Zubehör aus, und klicken Sie auf die Schaltfläche "Fertig stellen ":

   

4. Klicken Sie auf die Schaltfläche "Dienst hinzufügen" , und wählen Sie einen Diensttyp aus der Dropdownliste aus:

   

5. Geben Sie einen Namen für den Dienst ein, und klicken Sie auf die Schaltfläche "Fertig stellen ":

   

6. Sie können optionale Merkmale für einen Dienst bereitstellen, indem Sie auf die Schaltfläche "Merkmal hinzufügen" klicken und die erforderlichen Einstellungen konfigurieren:

   

7. Wiederholen Sie die obigen Schritte, um einen der einzelnen Typen von Geräten für die Automatisierung virtueller Heimgeräte zu erstellen, die HomeKit unterstützt.

Mit einem Beispiel für virtuelles HomeKit-Zubehör, das erstellt und konfiguriert wurde, können Sie diese Geräte jetzt von Ihrer Xamarin.iOS-App nutzen und steuern.

Konfigurieren der Info.plist-Datei

Neu für iOS 10 (und höher) muss der Entwickler den NSHomeKitUsageDescription Schlüssel zur App-Datei Info.plist hinzufügen und eine Zeichenfolge bereitstellen, die angibt, warum die App auf die HomeKit-Datenbank des Benutzers zugreifen möchte. Diese Zeichenfolge wird dem Benutzer beim ersten Ausführen der App angezeigt:

Gehen Sie wie folgt vor, um diesen Schlüssel festzulegen:

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

2. Wechseln Sie unten auf dem Bildschirm zur Quellansicht .

3. Fügen Sie der Liste einen neuen Eintrag hinzu.

4. Wählen Sie in der Dropdownliste "Privacy - HomeKit Usage Description" aus:

   

5. Geben Sie eine Beschreibung ein, warum die App auf die HomeKit-Datenbank des Benutzers zugreifen möchte:

   

6. Speichern Sie die Änderungen in der Datei.

Wichtig

Wenn der NSHomeKitUsageDescription Schlüssel in der Info.plist Datei nicht festgelegt wird, tritt bei der Ausführung in iOS 10 (oder höher) automatisch ein Fehler auf (das System wird vom System zur Laufzeit geschlossen) fehl.

Verbinden ing to HomeKit

Um mit HomeKit zu kommunizieren, muss Ihre Xamarin.iOS-App zuerst eine Instanz der HMHomeManager Klasse instanziieren. Der Home Manager ist der zentrale Einstiegspunkt in HomeKit und ist dafür verantwortlich, eine Liste der verfügbaren Häuser bereitzustellen, diese Liste zu aktualisieren und Standard enthalten und die primäre Startseite des Benutzers zurückzugeben.

Das HMHome Objekt enthält alle Informationen zu einem Zuhause, einschließlich aller Räume, Gruppen oder Zonen, die es enthalten kann, zusammen mit allen installierten Heimautomatisierungs-Zubehör. Bevor Vorgänge in HomeKit ausgeführt werden können, muss mindestens eine HMHome als primäre Startseite erstellt und zugewiesen werden.

Ihre App ist dafür verantwortlich, zu überprüfen, ob ein primäres Starthaus vorhanden ist, und eine zu erstellen und zuzuweisen, wenn dies nicht der Fall ist.

Hinzufügen eines Home Managers

Wenn Sie einer Xamarin.iOS-App HomeKit-Sensibilisierung hinzufügen möchten, bearbeiten Sie die AppDelegate.cs Datei, um sie zu bearbeiten und so wie folgt aussehen zu lassen:

using HomeKit;
...

public HMHomeManager HomeManager { get; set; }
...

public override void FinishedLaunching (UIApplication application)
{
    // Attach to the Home Manager
    HomeManager = new HMHomeManager ();
    Console.WriteLine ("{0} Home(s) defined in the Home Manager", HomeManager.Homes.Count());

    // Wire-up Home Manager Events
    HomeManager.DidAddHome += (sender, e) => {
        Console.WriteLine("Manager Added Home: {0}",e.Home);
    };

    HomeManager.DidRemoveHome += (sender, e) => {
        Console.WriteLine("Manager Removed Home: {0}",e.Home);
    };
    HomeManager.DidUpdateHomes += (sender, e) => {
        Console.WriteLine("Manager Updated Homes");
    };
    HomeManager.DidUpdatePrimaryHome += (sender, e) => {
        Console.WriteLine("Manager Updated Primary Home");
    };
}

Wenn die Anwendung zum ersten Mal ausgeführt wird, wird der Benutzer gefragt, ob er den Zugriff auf seine HomeKit-Informationen zulassen möchte:

Wenn der Benutzer AUF OK antwortt, kann die Anwendung mit ihrem HomeKit-Zubehör arbeiten, andernfalls tritt kein Fehler auf, und alle Aufrufe von HomeKit treten mit einem Fehler auf.

Nachdem der Home Manager eingerichtet wurde, muss die Anwendung als Nächstes überprüfen, ob ein primäres Starthaus konfiguriert wurde, und wenn nicht, eine Möglichkeit zum Erstellen und Zuweisen des Benutzers bereitstellen.

Zugreifen auf das primäre Starthaus

Wie oben erwähnt, muss ein primäres Start-Objekt erstellt und konfiguriert werden, bevor HomeKit verfügbar ist, und es liegt in der Verantwortung der App, dem Benutzer eine Möglichkeit zum Erstellen und Zuweisen eines primären Heims bereitzustellen, wenn noch keines vorhanden ist.

Wenn Ihre App zum ersten Mal aus dem Hintergrund gestartet oder zurückgegeben wird, muss das Ereignis der HMHomeManager Klasse überwacht DidUpdateHomes werden, um zu überprüfen, ob ein primäres Start-Element vorhanden ist. Wenn eine nicht vorhanden ist, sollte sie eine Benutzeroberfläche bereitstellen, über die der Benutzer eins erstellen kann.

Der folgende Code kann einem Ansichtscontroller hinzugefügt werden, um nach der primären Startseite zu suchen:

using HomeKit;
...

public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}
...

// Wireup events
ThisApp.HomeManager.DidUpdateHomes += (sender, e) => {

    // Was a primary home found?
    if (ThisApp.HomeManager.PrimaryHome == null) {
        // Ask user to add a home
        PerformSegue("AddHomeSegue",this);
    }
};

Wenn der Home Manager eine Verbindung mit HomeKit macht, wird das DidUpdateHomes Ereignis ausgelöst, alle vorhandenen Häuser werden in die Sammlung der Häuser des Vorgesetzten geladen, und das primäre Zuhause wird geladen, falls verfügbar.

Hinzufügen einer primären Startseite

Wenn die PrimaryHome Eigenschaft des HMHomeManagernull Ereignisses nach einem DidUpdateHomes Ereignis liegt, müssen Sie dem Benutzer eine Möglichkeit zum Erstellen und Zuweisen einer primären Startseite bereitstellen, bevor Sie fortfahren.

In der Regel zeigt die App ein Formular an, in dem der Benutzer eine neue Startseite benennen kann, die dann an den Home Manager übergeben wird, um es als primäre Startseite einzurichten. Für die HomeKitIntro-Beispiel-App wurde eine modale Ansicht im Xcode-Schnittstellen-Generator erstellt und von der AddHomeSegue Segue aus der Standard Schnittstelle der App aufgerufen.

Es stellt ein Textfeld bereit, mit dem der Benutzer einen Namen für die neue Startseite und eine Schaltfläche eingeben kann, um die Startseite hinzuzufügen. Wenn der Benutzer auf die Schaltfläche "Start hinzufügen" tippt, ruft der folgende Code den Home Manager auf, um die Startseite hinzuzufügen:

// Add new home to HomeKit
ThisApp.HomeManager.AddHome(HomeName.Text,(home,error) =>{
    // Did an error occur
    if (error!=null) {
        // Yes, inform user
        AlertView.PresentOKAlert("Add Home Error",string.Format("Error adding {0}: {1}",HomeName.Text,error.LocalizedDescription),this);
        return;
    }

    // Make the primary house
    ThisApp.HomeManager.UpdatePrimaryHome(home,(err) => {
        // Error?
        if (err!=null) {
            // Inform user of error
            AlertView.PresentOKAlert("Add Home Error",string.Format("Unable to make this the primary home: {0}",err.LocalizedDescription),this);
            return ;
        }
    });

    // Close the window when the home is created
    DismissViewController(true,null);
});

Die AddHome Methode versucht, eine neue Startseite zu erstellen und an die angegebene Rückrufroutine zurückzugeben. Wenn die error Eigenschaft nicht nullvorhanden ist, ist ein Fehler aufgetreten und sollte dem Benutzer angezeigt werden. Die häufigsten Fehler werden entweder durch einen nicht eindeutigen Startnamen oder den Home Manager verursacht, der nicht mit HomeKit kommunizieren kann.

Wenn das Starthaus erfolgreich erstellt wurde, müssen Sie die UpdatePrimaryHome Methode aufrufen, um das neue Zuhause als primäres Zuhause festzulegen. Wenn die error Eigenschaft nicht nullist, ist ein Fehler aufgetreten, und er sollte dem Benutzer angezeigt werden.

Sie sollten auch die Home Manager-Ereignisse DidAddHome und DidRemoveHome -Ereignisse überwachen und die Benutzeroberfläche der App nach Bedarf aktualisieren.

Wichtig

Die AlertView.PresentOKAlert im obigen Beispielcode verwendete Methode ist eine Hilfsklasse in der HomeKitIntro-Anwendung, die das Arbeiten mit iOS-Benachrichtigungen erleichtert.

Neues Zubehör finden

Nachdem ein primäres Zuhause definiert oder aus dem Home Manager geladen wurde, kann Ihre Xamarin.iOS-App die HMAccessoryBrowser aufrufen, um jedes neue Heimautomatisierungs-Zubehör zu finden und sie zu einem Zuhause hinzuzufügen.

Rufen Sie die StartSearchingForNewAccessories Methode auf, um nach neuem Zubehör und der StopSearchingForNewAccessories Methode zu suchen, wenn Sie fertig sind.

Wichtig

StartSearchingForNewAccessories sollte nicht länger ausgeführt werden, da sich dies negativ auf die Akkulaufzeit und leistung des iOS-Geräts auswirkt. Apple schlägt vor, nach einer Minute zu anrufen StopSearchingForNewAccessories oder nur zu suchen, wenn dem Benutzer die Benutzeroberfläche "Zubehör suchen" angezeigt wird.

Das DidFindNewAccessory Ereignis wird aufgerufen, wenn neues Zubehör entdeckt wird und sie der DiscoveredAccessories Liste im Zubehörbrowser hinzugefügt werden.

Die DiscoveredAccessories Liste enthält eine Sammlung von HMAccessory Objekten, die ein HomeKit-aktiviertes Heimautomatisierungs-Gerät und seine verfügbaren Dienste definieren, z. B. Leuchten oder Garagentürsteuerung.

Sobald das neue Zubehör gefunden wurde, sollte es dem Benutzer präsentiert werden, damit er es auswählen und zu hause hinzufügen kann. Beispiel:

Rufen Sie die AddAccessory Methode auf, um das ausgewählte Zubehör zur Sammlung der Startseite hinzuzufügen. Zum Beispiel:

// Add the requested accessory to the home
ThisApp.HomeManager.PrimaryHome.AddAccessory (_controller.AccessoryBrowser.DiscoveredAccessories [indexPath.Row], (err) => {
    // Did an error occur
    if (err !=null) {
        // Inform user of error
        AlertView.PresentOKAlert("Add Accessory Error",err.LocalizedDescription,_controller);
    }
});

Wenn die err Eigenschaft nicht nullvorhanden ist, ist ein Fehler aufgetreten und sollte dem Benutzer angezeigt werden. Andernfalls wird der Benutzer aufgefordert, den Setupcode für das hinzuzufügende Gerät einzugeben:

Im HomeKit Accessory Simulator finden Sie diese Nummer im Feld "Setup Code ":

Für echtes HomeKit-Zubehör wird der Setupcode entweder auf einem Etikett auf dem Gerät selbst, auf der Produktbox oder im Benutzerhandbuch des Zubehörs gedruckt.

Sie sollten das Ereignis des Zubehörbrowsers DidRemoveNewAccessory überwachen und die Benutzeroberfläche aktualisieren, um ein Zubehör aus der verfügbaren Liste zu entfernen, sobald der Benutzer es zu seiner Home Collection hinzugefügt hat.

Arbeiten mit Zubehör

Sobald ein Primäres Haus eingerichtet und Zubehör hinzugefügt wurde, können Sie eine Liste der Zubehörteile (und optional Räume) präsentieren, mit denen der Benutzer zusammenarbeiten kann.

Das HMRoom Objekt enthält alle Informationen über einen bestimmten Raum und alle Zubehörteile, die zu ihm gehören. Räume können optional in einer oder mehreren Zonen organisiert werden. A HMZone enthält alle Informationen über eine bestimmte Zone und alle Räume, die zu ihm gehören.

Im Sinne dieses Beispiels behalten wir die Dinge einfach und arbeiten direkt mit dem Zubehör eines Hauses, anstatt sie in Räume oder Zonen zu organisieren.

Das HMHome Objekt enthält eine Liste der zugewiesenen Zubehörteile, die dem Benutzer in seiner Accessories Eigenschaft angezeigt werden können. Zum Beispiel:

Hier kann der Benutzer ein bestimmtes Zubehör auswählen und mit den von ihm bereitgestellten Diensten arbeiten.

Arbeiten mit Diensten

Wenn der Benutzer mit einem bestimmten HomeKit-aktivierten Heimautomatisierungs-Gerät interagiert, erfolgt dies in der Regel über die von ihm bereitgestellten Dienste. Die Services Eigenschaft der HMAccessory Klasse enthält eine Auflistung von HMService Objekten, die die Dienste definieren, die ein Gerät anbietet.

Dienstleistungen sind Dinge wie Lichter, Thermometer, Garagentüröffner, Schalter oder Sperren. Einige Geräte (z. B. ein Garagentüröffer) bieten mehr als einen Dienst, z. B. ein Licht und die Möglichkeit, eine Tür zu öffnen oder zu schließen.

Zusätzlich zu den spezifischen Diensten, die ein bestimmtes Zubehör bereitstellt, enthält jedes Zubehör eine Information Service Eigenschaft, die Eigenschaften wie Name, Hersteller, Modell und Seriennummer definiert.

Zubehördiensttypen

Die folgenden Diensttypen sind über die HMServiceType Enumeration verfügbar:

• AccessoryInformation – Stellt Informationen über das angegebene Heimautomatisierungs-Gerät (Zubehör) bereit.
• AirQualitySensor – Definiert einen Luftqualitätssensor.
• Akku – Definiert den Zustand der Batterie eines Zubehörs.
• CarbonDioxideSensor - Definiert einen Kohlendioxidsensor.
• CarbonMonoxidsensor - Definiert einen Kohlenstoffmonoxidsensor.
• ContactSensor – Definiert einen Kontaktsensor (z. B. ein geöffnetes oder geschlossenes Fenster).
• Tür – Definiert einen Türzustandssensor (z. B. geöffnet oder geschlossen).
• Lüfter – Definiert einen ferngesteuerten Lüfter .
• GarageDoorOpener - Definiert einen Garagentüröffner .
• Luftfeuchtigkeitssensor – Definiert einen Feuchtigkeitssensor.
• LeakSensor - Definiert einen Lecksensor (z. B. für einen Warmwasserbereiter oder eine Waschmaschine).
• LightBulb - Definiert ein eigenständiges Licht oder ein Licht, das Teil eines anderen Zubehörs ist (z. B. ein Garagentüröffer).
• LightSensor – Definiert einen Lichtsensor.
• LockManagement – Definiert einen Dienst, der eine automatisierte Türsperre verwaltet.
• LockMechanism – Definiert eine ferngesteuerte Sperre (z. B. eine Türsperre).
• MotionSensor – Definiert einen Bewegungssensor.
• Belegungssensor – Definiert einen Belegungssensor.
• Steckdose – Definiert eine ferngesteuerte Wandsteckdose.
• SecuritySystem – Definiert ein Home Security System.
• StatefulProgrammableSwitch – Definiert einen programmierbaren Schalter Standard, der in einem "Give"-Zustand einmal ausgelöst wird (z. B. ein Flipschalter).
• StatelessProgrammableSwitch – Definiert einen programmierbaren Schalter, der nach dem Auslösen in den Anfangszustand zurückkehrt (z. B. eine Knopfdruck).
• SmokeSensor – Definiert einen Rauchsensor.
• Schalter – Definiert einen Ein-/Aus-Schalter wie einen Standardwandschalter.
• TemperatureSensor – Definiert einen Temperatursensor.
• Thermometer – Definiert einen intelligenten Thermometer, der zur Steuerung eines HLK-Systems verwendet wird.
• Window – Definiert ein automatisiertes Fenster, das remote geöffnet oder geschlossen werden kann.
• WindowCovering : Definiert eine ferngesteuerte Fensterabdeckung, z. B. Blinde, die geöffnet oder geschlossen werden können.

Anzeigen von Dienstinformationen

Nachdem Sie ein HMAccessory Objekt geladen haben, können Sie die darin bereitgestellten einzelnen HNService Objekte abfragen und diese Informationen dem Benutzer anzeigen:

Sie sollten die Reachable Eigenschaft einer HMAccessory Datei immer überprüfen, bevor Sie versuchen, damit zu arbeiten. Ein Zubehör kann nicht erreichbar sein, wenn sich der Benutzer nicht im Bereich des Geräts befindet oder wenn es nicht angeschlossen wurde.

Nachdem ein Dienst ausgewählt wurde, kann der Benutzer ein oder mehrere Merkmale dieses Diensts anzeigen oder ändern, um ein bestimmtes Heimautomatisierungsgerät zu überwachen oder zu steuern.

Arbeiten mit Merkmalen

Jedes HMService Objekt kann eine Auflistung von HMCharacteristic Objekten enthalten, die entweder Informationen zum Dienststatus bereitstellen können (z. B. eine Tür, die geöffnet oder geschlossen wird) oder dem Benutzer das Anpassen eines Zustands ermöglichen (z. B. das Festlegen der Farbe eines Lichts).

HMCharacteristic Stellt nicht nur Informationen zu einem Merkmal und seinem Zustand bereit, sondern bietet auch Methoden zum Arbeiten mit dem Zustand über charakteristische Metadaten (HMCharacteristisMetadata). Diese Metadaten können Eigenschaften (z. B. minimale und maximalwertige Bereiche) bereitstellen, die beim Anzeigen von Informationen für den Benutzer nützlich sind oder die Änderung des Status zulassen.

Die HMCharacteristicType Enumeration enthält eine Reihe von Eigenschaftsmetadatenwerten, die wie folgt definiert oder geändert werden können:

• AdminOnlyAccess
• AirParticulateDensity
• AirParticulateSize
• AirQuality
• AudioFeedback
• BatteryLevel
• Helligkeit
• Kohlenstoffdioxid erkannt
• CarbonDioxideLevel
• CarbonDioxidePeakLevel
• Kohlenmonoxid erkannt
• CarbonMonoxideLevel
• CarbonMonoxidePeakLevel
• ChargingState
• ContactState
• CoolingThreshold
• CurrentDoorState
• CurrentHeatingCooling
• CurrentHorizontalTilt
• CurrentLightLevel
• CurrentLockMechanismState
• CurrentPosition
• CurrentRelativeHumidity
• CurrentSecuritySystemState
• CurrentTemperature
• CurrentVerticalTilt
• FirmwareVersion
• HardwareVersion
• HeatingCoolingStatus
• HeizungThreshold
• HoldPosition
• Farbton
• Ermitteln
• InputEvent
• Leck erkannt
• LockManagementAutoSecureTimeout
• LockManagementControlPoint
• LockMechanismLastKnownAction
• Protokolle
• Hersteller
• Modell
• Bewegung erkannt
• Name
• Hindernisse erkannt
• Belegung erkannt
• OutletInUse
• OutputState
• PositionState
• PowerState
• RotationDirection
• RotationSpeed
• Sättigung
• SerialNumber
• Rauch erkannt
• SoftwareVersion
• StatusActive
• StatusFault
• StatusJammed
• StatusLowBattery
• StatusTampered
• TargetDoorState
• TargetHeatingCooling
• TargetHorizontalTilt
• TargetLockMechanismState
• TargetPosition
• TargetRelativeHumidity
• TargetSecuritySystemState
• TargetTemperature
• TargetVerticalTilt
• TemperatureUnits
• Version

Arbeiten mit dem Wert eines Merkmals

Rufen Sie die ReadValue Methode der HMCharacteristic Klasse auf, um sicherzustellen, dass Die App über den neuesten Zustand eines bestimmten Merkmals verfügt. Wenn die err Eigenschaft nicht nullvorhanden ist, ist ein Fehler aufgetreten, und er kann dem Benutzer angezeigt werden.

Die Eigenschaft des Merkmals Value enthält den aktuellen Zustand des angegebenen Merkmals als ein NSObject, und als solche kann nicht direkt in C# bearbeitet werden.

Um den Wert zu lesen, wurde der HomeKitIntro-Beispielanwendung die folgende Hilfsklasse hinzugefügt:

using System;
using Foundation;
using System.Globalization;
using CoreGraphics;

namespace HomeKitIntro
{
    /// <summary>
    /// NS object converter is a helper class that helps to convert NSObjects into
    /// C# objects
    /// </summary>
    public static class NSObjectConverter
    {
        #region Static Methods
        /// <summary>
        /// Converts to an object.
        /// </summary>
        /// <returns>The object.</returns>
        /// <param name="nsO">Ns o.</param>
        /// <param name="targetType">Target type.</param>
        public static Object ToObject (NSObject nsO, Type targetType)
        {
            if (nsO is NSString) {
                return nsO.ToString ();
            }

            if (nsO is NSDate) {
                var nsDate = (NSDate)nsO;
                return DateTime.SpecifyKind ((DateTime)nsDate, DateTimeKind.Unspecified);
            }

            if (nsO is NSDecimalNumber) {
                return decimal.Parse (nsO.ToString (), CultureInfo.InvariantCulture);
            }

            if (nsO is NSNumber) {
                var x = (NSNumber)nsO;

                switch (Type.GetTypeCode (targetType)) {
                case TypeCode.Boolean:
                    return x.BoolValue;
                case TypeCode.Char:
                    return Convert.ToChar (x.ByteValue);
                case TypeCode.SByte:
                    return x.SByteValue;
                case TypeCode.Byte:
                    return x.ByteValue;
                case TypeCode.Int16:
                    return x.Int16Value;
                case TypeCode.UInt16:
                    return x.UInt16Value;
                case TypeCode.Int32:
                    return x.Int32Value;
                case TypeCode.UInt32:
                    return x.UInt32Value;
                case TypeCode.Int64:
                    return x.Int64Value;
                case TypeCode.UInt64:
                    return x.UInt64Value;
                case TypeCode.Single:
                    return x.FloatValue;
                case TypeCode.Double:
                    return x.DoubleValue;
                }
            }

            if (nsO is NSValue) {
                var v = (NSValue)nsO;

                if (targetType == typeof(IntPtr)) {
                    return v.PointerValue;
                }

                if (targetType == typeof(CGSize)) {
                    return v.SizeFValue;
                }

                if (targetType == typeof(CGRect)) {
                    return v.RectangleFValue;
                }

                if (targetType == typeof(CGPoint)) {
                    return v.PointFValue;
                }
            }

            return nsO;
        }

        /// <summary>
        /// Convert to string
        /// </summary>
        /// <returns>The string.</returns>
        /// <param name="nsO">Ns o.</param>
        public static string ToString(NSObject nsO) {
            return (string)ToObject (nsO, typeof(string));
        }

        /// <summary>
        /// Convert to date time
        /// </summary>
        /// <returns>The date time.</returns>
        /// <param name="nsO">Ns o.</param>
        public static DateTime ToDateTime(NSObject nsO){
            return (DateTime)ToObject (nsO, typeof(DateTime));
        }

        /// <summary>
        /// Convert to decimal number
        /// </summary>
        /// <returns>The decimal.</returns>
        /// <param name="nsO">Ns o.</param>
        public static decimal ToDecimal(NSObject nsO){
            return (decimal)ToObject (nsO, typeof(decimal));
        }

        /// <summary>
        /// Convert to boolean
        /// </summary>
        /// <returns><c>true</c>, if bool was toed, <c>false</c> otherwise.</returns>
        /// <param name="nsO">Ns o.</param>
        public static bool ToBool(NSObject nsO){
            return (bool)ToObject (nsO, typeof(bool));
        }

        /// <summary>
        /// Convert to character
        /// </summary>
        /// <returns>The char.</returns>
        /// <param name="nsO">Ns o.</param>
        public static char ToChar(NSObject nsO){
            return (char)ToObject (nsO, typeof(char));
        }

        /// <summary>
        /// Convert to integer
        /// </summary>
        /// <returns>The int.</returns>
        /// <param name="nsO">Ns o.</param>
        public static int ToInt(NSObject nsO){
            return (int)ToObject (nsO, typeof(int));
        }

        /// <summary>
        /// Convert to float
        /// </summary>
        /// <returns>The float.</returns>
        /// <param name="nsO">Ns o.</param>
        public static float ToFloat(NSObject nsO){
            return (float)ToObject (nsO, typeof(float));
        }

        /// <summary>
        /// Converts to double
        /// </summary>
        /// <returns>The double.</returns>
        /// <param name="nsO">Ns o.</param>
        public static double ToDouble(NSObject nsO){
            return (double)ToObject (nsO, typeof(double));
        }
        #endregion
    }
}

Die NSObjectConverter Wird verwendet, wenn die Anwendung den aktuellen Zustand eines Merkmals lesen muss. Beispiel:

var value = NSObjectConverter.ToFloat (characteristic.Value);

Die obige Zeile wandelt den Wert in einen float Wert um, der dann im Xamarin C#-Code verwendet werden kann.

Rufen Sie zum Ändern einer HMCharacteristicMethode den WriteValue neuen Wert in einem NSObject.FromObject Aufruf auf, und umschließen Sie den neuen Wert. Beispiel:

Characteristic.WriteValue(NSObject.FromObject(value),(err) =>{
    // Was there an error?
    if (err!=null) {
        // Yes, inform user
        AlertView.PresentOKAlert("Update Error",err.LocalizedDescription,Controller);
    }
});

Wenn die err Eigenschaft nicht nullvorhanden ist, ist ein Fehler aufgetreten und sollte dem Benutzer angezeigt werden.

Testen von Merkmalswertänderungen

Beim Arbeiten mit HMCharacteristics und simulierten Zubehör können Änderungen an der Value Eigenschaft im HomeKit Accessory Simulator überwacht werden.

Wenn die HomeKitIntro-App auf realer iOS-Gerätehardware ausgeführt wird, sollten Änderungen am Wert eines Merkmals fast sofort im HomeKit Accessory Simulator angezeigt werden. Ändern sie beispielsweise den Zustand eines Lichts in der iOS-App:

Sollte den Zustand des Lichts im HomeKit Accessory Simulator ändern. Wenn sich der Wert nicht ändert, überprüfen Sie den Status der Fehlermeldung beim Schreiben neuer Merkmalswerte, und stellen Sie sicher, dass das Zubehör weiterhin erreichbar ist.

Erweiterte HomeKit-Features

In diesem Artikel wurden die grundlegenden Features behandelt, die für die Arbeit mit HomeKit-Zubehör in einer Xamarin.iOS-App erforderlich sind. Es gibt jedoch mehrere erweiterte Features von HomeKit, die in dieser Einführung nicht behandelt werden:

• Räume - HomeKit-fähiges Zubehör kann optional vom Endbenutzer in Räume organisiert werden. Auf diese Weise kann HomeKit Zubehör auf eine Weise präsentieren, die dem Benutzer leicht verständlich und zusammenarbeiten kann. Weitere Informationen zum Erstellen und Standard Haltung von Räumen finden Sie in der HMRoom-Dokumentation von Apple.
• Zonen – Räume können optional vom Endbenutzer in Zonen organisiert werden. Eine Zone bezieht sich auf eine Sammlung von Räumen, die der Benutzer als einzelne Einheit behandeln kann. Beispiel: Im Erdgeschoss, Untergeschoss oder Keller. Dies ermöglicht es HomeKit, Zubehör auf eine Weise zu präsentieren und mit Zubehör zu arbeiten, die für den Endbenutzer sinnvoll ist. Weitere Informationen zum Erstellen und Standard Beibehalten von Zonen finden Sie in der HMZone-Dokumentation von Apple.
• Aktionen und Aktionssätze – Aktionen ändern die Eigenschaften des Zubehördiensts und können in Gruppen gruppiert werden. Aktionssätze dienen als Skripts zum Steuern einer Gruppe von Zubehör und koordinieren deren Aktionen. Beispielsweise könnte ein Skript "Watch TV" die Blinde schließen, die Lichter abblenden und das Fernsehen und dessen Soundsystem einschalten. Weitere Informationen zum Erstellen und Standard Nachtragen von Aktionen und Aktionssätzen finden Sie in der Dokumentation zu HMAction und HMActionSet von Apple.
• Trigger – Ein Trigger kann einen oder mehrere Aktionssätze aktivieren, wenn eine bestimmte Gruppe von Bedingungen erfüllt wurde. Aktivieren Sie z. B. das Portchlicht und sperren Sie alle externen Türen, wenn sie dunkel draußen sind. Weitere Informationen zum Erstellen und Standard Halt von Triggern finden Sie in der HMTrigger-Dokumentation von Apple.

Da diese Features dieselben oben vorgestellten Techniken verwenden, sollten sie einfach zu implementieren sein, indem Sie apples HomeKitDeveloper Guide, HomeKit User Interface Guidelines und HomeKit Framework Reference folgen.

Richtlinien für homeKit-App-Überprüfungen

Bevor Sie eine HomeKit-aktivierte Xamarin.iOS-App an iTunes Verbinden für die Veröffentlichung im iTunes App Store übermitteln, stellen Sie sicher, dass Sie die Richtlinien von Apple für homeKit-aktivierte Apps befolgen:

• Der hauptzweck der App muss die Hausautomatisierung sein, wenn das HomeKit-Framework verwendet wird.
• Der Marketingtext der App muss Benutzer darüber informieren, dass HomeKit verwendet wird, und sie müssen eine Datenschutzrichtlinie bereitstellen.
• Das Sammeln von Benutzerinformationen oder die Verwendung von HomeKit für Werbung ist streng verboten.

Die vollständigen Überprüfungsrichtlinien finden Sie in den App Store-Überprüfungsrichtlinien von Apple.

Neuerungen in iOS 9

Apple hat die folgenden Änderungen und Ergänzungen an HomeKit für iOS 9 vorgenommen:

• Verwalten vorhandener Objekte – Wenn ein vorhandenes Zubehör geändert wird, informiert Der Home Manager (HMHomeManager) Sie über das spezifische Element, das geändert wurde.
• Persistent Identifiers – Alle relevanten HomeKit-Klassen enthalten jetzt eine UniqueIdentifier Eigenschaft, um ein bestimmtes Element in homeKit-aktivierten Apps (oder Instanzen derselben App) eindeutig zu identifizieren.
• Benutzerverwaltung – Ein integrierter Ansichtscontroller wurde hinzugefügt, um Benutzerverwaltung über Benutzer bereitzustellen, die Zugriff auf die HomeKit-Geräte in der Startseite des primären Benutzers haben.
• Benutzerfunktionen – HomeKit-Benutzer verfügen jetzt über eine Reihe von Berechtigungen, die steuern, welche Funktionen sie in HomeKit- und HomeKit-aktiviertem Zubehör verwenden können. Ihre App sollte dem aktuellen Benutzer nur relevante Funktionen anzeigen. Beispielsweise sollten nur Administratoren in der Lage sein, andere Benutzer Standard zu Standard.
• Vordefinierte Szenen – Vordefinierte Szenen wurden für vier allgemeine Ereignisse erstellt, die für den durchschnittlichen HomeKit-Benutzer auftreten: Get Up, Leave, Return, Go to Bed. Diese vordefinierten Szenen können nicht von zu Hause gelöscht werden.
• Szenen und Siri - Siri hat tiefere Unterstützung für Szenen in iOS 9 und kann den Namen jeder Szene erkennen, die in HomeKit definiert ist. Ein Benutzer kann eine Szene einfach ausführen, indem er seinen Namen zu Siri spricht.
• Zubehörkategorien – Eine Reihe vordefinierter Kategorien wurde allen Zubehörkategorien hinzugefügt und hilft dabei, den Typ des Zubehörs zu identifizieren, das zu einem Home hinzugefügt oder in Ihrer App bearbeitet wurde. Diese neuen Kategorien sind während der Zubehöreinrichtung verfügbar.
• Apple Watch Support - HomeKit ist jetzt für watchOS verfügbar, und die Apple Watch kann HomeKit-aktivierte Geräte ohne i Telefon in der Nähe der Uhr steuern. HomeKit für watchOS unterstützt die folgenden Funktionen: Anzeigen von Häusern, Steuern von Zubehör und Ausführen von Szenen.
• Neuer Ereignistriggertyp – Zusätzlich zu den in iOS 8 unterstützten Timertyptriggern unterstützt iOS 9 jetzt Ereignistrigger basierend auf Zubehörstatus (z. B. Sensordaten) oder Geolocation. Ereignistrigger werden verwendet NSPredicates , um Bedingungen für die Ausführung festzulegen.
• Remotezugriff – Mit Remotezugriff kann der Benutzer jetzt sein HomeKit-aktiviertes HomeKit-Zubehör steuern, wenn er sich an einem Remotestandort vom Haus entfernt befindet. In iOS 8 wurde dies nur unterstützt, wenn der Benutzer ein Apple TV der 3. Generation zu Hause hatte. In iOS 9 wird diese Einschränkung aufgehoben und der Remotezugriff wird über iCloud und das HomeKit Accessory Protocol (HAP) unterstützt.
• Neue Bluetooth Low Energy (BLE)-Fähigkeiten - HomeKit unterstützt jetzt mehr Zubehörtypen, die über das Bluetooth Low Energy (BLE)-Protokoll kommunizieren können. Mithilfe von HAP Secure Tunneling kann ein HomeKit-Zubehör ein weiteres Bluetooth-Zubehör über WLAN verfügbar machen (wenn es außerhalb des Bluetooth-Bereichs liegt). In iOS 9 haben BLE-Zubehör vollständige Unterstützung für Benachrichtigungen und Metadaten.
• Neue Zubehörkategorien - Apple hat die folgenden neuen Zubehörkategorien in iOS 9 hinzugefügt: Fensterabdeckungen, motorisierte Türen und Fenster, Alarmsysteme, Sensoren und programmierbare Schalter.

Weitere Informationen zu den neuen Features von HomeKit in iOS 9 finden Sie im HomeKit-Video von Apples HomeKit Index und What's New in HomeKit.For more information about the new features of HomeKit in iOS 9, please see Apple es HomeKit Index and What's New in HomeKit video.

Zusammenfassung

In diesem Artikel wurde das HomeKit HomeKit-Heimautomatisierungs-Framework von Apple eingeführt. Es zeigte, wie Sie Testgeräte mit dem HomeKit Accessory Simulator einrichten und konfigurieren und wie Sie eine einfache Xamarin.iOS-App erstellen, um geräte mit HomeKit zu ermitteln, zu kommunizieren und zu steuern.

Verwandte Links

• Neuigkeiten in iOS 9.0
• HomeKitDeveloper Guide
• Richtlinien für homeKit-Benutzeroberfläche
• HomeKit Framework-Referenz