HomeKit dans Xamarin.iOS

HomeKit est l’infrastructure d’Apple pour contrôler les appareils d’automatisation à domicile. Cet article présente HomeKit et aborde la configuration des accessoires de test dans le simulateur d’accessoires HomeKit et l’écriture d’une application Xamarin.iOS simple pour interagir avec ces accessoires.

Apple a introduit HomeKit dans iOS 8 comme moyen d’intégrer en toute transparence plusieurs appareils d’automatisation à domicile d’un grand nombre de fournisseurs dans une unité unique et cohérente. En favorisant un protocole commun pour la découverte, la configuration et le contrôle des appareils d’automatisation à domicile, HomeKit permet aux appareils des fournisseurs non liés de travailler ensemble, tous sans que les fournisseurs individuels aient à coordonner les efforts.

Avec HomeKit, vous pouvez créer une application Xamarin.iOS qui contrôle n’importe quel appareil HomeKit activé sans utiliser d’API ou d’applications fournies par le fournisseur. À l’aide de HomeKit, vous pouvez effectuer les opérations suivantes :

• Découvrez les nouveaux appareils HomeKit compatibles home automation et ajoutez-les à une base de données qui persistera sur tous les appareils iOS de l’utilisateur.
• Configurez, configurez, affichez et contrôlez n’importe quel appareil dans la base de données HomeKit Home Configuration.
• Communiquez avec n’importe quel appareil HomeKit préconfiguré et commandez-les pour effectuer des actions individuelles ou travailler en concert, telles que l’activation de toutes les lumières dans la cuisine.

En plus de servir des appareils dans la base de données de configuration d’accueil vers les applications homeKit activées, HomeKit fournit l’accès aux commandes vocales Siri. Étant donné une configuration appropriée de HomeKit, l’utilisateur peut émettre des commandes vocales telles que « Siri, activer les lumières dans le salon ».

Base de données de configuration d’accueil

HomeKit organise tous les appareils d’automatisation dans un emplacement donné dans une collection d’accueil. Cette collection permet à l’utilisateur de regrouper ses appareils d’automatisation domestique en unités organisées logiquement avec des étiquettes explicites lisibles par l’homme.

La collection d’accueil est stockée dans une base de données de configuration d’accueil qui sera automatiquement sauvegardée et synchronisée sur tous les appareils iOS de l’utilisateur. HomeKit fournit les classes suivantes pour l’utilisation de la base de données Home Configuration :

• HMHome - Il s’agit du conteneur de niveau supérieur qui contient toutes les informations et configurations pour tous les appareils d’automatisation domestique dans un emplacement physique unique (par exemple, une résidence familiale unique). L’utilisateur peut avoir plusieurs résidences, telles que sa maison principale et une maison de vacances. Ou ils peuvent avoir différentes « maisons » sur la même propriété, comme la maison principale et une maison d’hôtes sur le garage. Dans les deux cas, au moins un HMHome objet doit être configuré et stocké avant d’entrer d’autres informations HomeKit.
• HMRoom - Facultatif, un HMRoom permet à l’utilisateur de définir des pièces spécifiques à l’intérieur d’une maison (HMHome) comme : Cuisine, Salle de bains, Garage ou Salon. L’utilisateur peut regrouper tous les appareils d’automatisation domestique dans un emplacement spécifique de leur maison et HMRoom agir sur eux en tant qu’unité. Par exemple, demander à Siri de désactiver les lumières du garage.
• HMAccessory - Il s’agit d’un appareil d’automatisation physique avec HomeKit physique qui a été installé dans la résidence de l’utilisateur (par exemple, un thermostat intelligent). Chacun HMAccessory est affecté à un HMRoom. Si l’utilisateur n’a pas configuré de salles, HomeKit attribue des accessoires à une salle par défaut spéciale.
• HMService - Représente un service fourni par un service donné HMAccessory, tel que l’état activé/désactivé d’une lumière ou de sa couleur (si la modification de couleur est prise en charge). Chacun HMAccessory peut avoir plusieurs services, tels qu’un ouverture de porte de garage qui inclut également une lumière. En outre, une donnée HMAccessory peut avoir des services, tels que la mise à jour du microprogramme, qui sont en dehors du contrôle utilisateur.
• HMZone - Permet à l’utilisateur de regrouper une collection d’objets HMRoom en zones logiques, telles que l’étage, le bas ou le sous-sol. Bien que facultatif, cela permet des interactions comme demander à Siri de désactiver toutes les lumières en bas.

Approvisionnement d’une application HomeKit

En raison des exigences de sécurité imposées par HomeKit, une application Xamarin.iOS qui utilise l’infrastructure HomeKit doit être correctement configurée dans le portail des développeurs Apple et dans le fichier projet Xamarin.iOS.

Effectuez les actions suivantes :

1. Connectez-vous au portail des développeurs Apple.

2. Cliquez sur Certificats, identificateurs et profils.

3. Si vous ne l’avez pas encore fait, cliquez sur Identificateurs et créez un ID pour votre application (par exemple com.company.appname), sinon modifiez votre ID existant.

4. Vérifiez que le service HomeKit a été case activée pour l’ID donné :

   

5. Enregistrez vos modifications.

6. Cliquez sur Le développement des profils>d’approvisionnement et créez un profil d’approvisionnement de développement pour votre application :

   

7. Téléchargez et installez le nouveau profil d’approvisionnement ou utilisez Xcode pour télécharger et installer le profil.

8. Modifiez vos options de projet Xamarin.iOS et vérifiez que vous utilisez le profil d’approvisionnement que vous venez de créer :

   

9. Ensuite, modifiez votre fichier Info.plist et vérifiez que vous utilisez l’ID d’application utilisé pour créer le profil d’approvisionnement :

   

10. Enfin, modifiez votre fichier Entitlements.plist et vérifiez que le droit HomeKit a été sélectionné :

    

11. Enregistrez les modifications apportées à tous les fichiers.

Avec ces paramètres en place, l’application est maintenant prête à accéder aux API HomeKit Framework. Pour plus d’informations sur l’approvisionnement, consultez nos guides d’approvisionnement et d’approvisionnement de votre application .

Important

Le test d’une application compatible HomeKit nécessite un appareil iOS réel qui a été correctement approvisionné pour le développement. HomeKit ne peut pas être testé à partir du simulateur iOS.

Simulateur d’accessoires HomeKit

Pour fournir un moyen de tester tous les appareils et services home automation possibles, sans avoir à avoir un appareil physique, Apple a créé le simulateur d’accessoires HomeKit. À l’aide de ce simulateur, vous pouvez configurer et configurer des appareils HomeKit virtuels.

Installation du simulateur

Apple fournit le simulateur d’accessoires HomeKit en tant que téléchargement distinct de Xcode. Vous devrez donc l’installer avant de continuer.

Effectuez les actions suivantes :

1. Dans un navigateur web, visitez Téléchargements pour les développeurs Apple

2. Téléchargez les outils supplémentaires pour Xcode xxx (où xxx est la version de Xcode que vous avez installée) :

   

3. Ouvrez l’image de disque et installez les outils dans votre répertoire Applications .

Une fois le simulateur d’accessoires HomeKit installé, des accessoires virtuels peuvent être créés à des fins de test.

Création d’accessoires virtuels

Pour démarrer le simulateur d’accessoires HomeKit et créer quelques accessoires virtuels, procédez comme suit :

1. Dans le dossier Applications, démarrez le simulateur d’accessoires HomeKit :

   

2. Cliquez sur le + bouton et sélectionnez Nouvel accessoire... :

   

3. Renseignez les informations sur le nouvel accessoire et cliquez sur le bouton Terminer :

   

4. Cliquez sur le bouton Ajouter un service.. et sélectionnez un type de service dans la liste déroulante :

   

5. Indiquez un nom pour le service, puis cliquez sur le bouton Terminer :

   

6. Vous pouvez fournir des caractéristiques facultatives pour un service en cliquant sur le bouton Ajouter des caractéristiques et en configurant les paramètres requis :

   

7. Répétez les étapes ci-dessus pour créer un de chaque type d’appareil home automation virtuel pris en charge par HomeKit.

Avec certains exemples d’accessoires HomeKit virtuels créés et configurés, vous pouvez désormais consommer et contrôler ces appareils à partir de votre application Xamarin.iOS.

Configuration du fichier Info.plist

Nouveautés pour iOS 10 (et plus), le développeur doit ajouter la NSHomeKitUsageDescription clé au fichier de Info.plist l’application et fournir une chaîne indiquant pourquoi l’application souhaite accéder à la base de données HomeKit de l’utilisateur. Cette chaîne sera présentée à l’utilisateur la première fois qu’il exécute l’application :

Pour définir cette clé, procédez comme suit :

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

2. En bas de l’écran, basculez vers la vue Source .

3. Ajoutez une nouvelle entrée à la liste.

4. Dans la liste déroulante, sélectionnez Confidentialité - HomeKit Usage Description :

   

5. Entrez une description pour la raison pour laquelle l’application souhaite accéder à la base de données HomeKit de l’utilisateur :

   

6. Enregistrez les modifications du fichier.

Important

L’échec de la définition de la NSHomeKitUsageDescription clé dans le Info.plist fichier entraîne l’échec silencieux de l’application (fermé par le système au moment de l’exécution) sans erreur lors de l’exécution dans iOS 10 (ou supérieur).

Connecter ing à HomeKit

Pour communiquer avec HomeKit, votre application Xamarin.iOS doit d’abord instancier une instance de la HMHomeManager classe. Home Manager est le point d’entrée central dans HomeKit et est chargé de fournir une liste de maisons disponibles, de mettre à jour et de maintenir cette liste et de retourner la maison principale de l’utilisateur.

L’objet HMHome contient toutes les informations relatives à une maison donnée, y compris les salles, groupes ou zones qu’il peut contenir, ainsi que tous les accessoires d’automatisation à domicile installés. Avant que toutes les opérations puissent être effectuées dans HomeKit, au moins une HMHome doit être créée et affectée en tant qu’accueil principal.

Votre application est chargée de case activée si une maison principale existe et en crée et en attribue un si ce n’est pas le cas.

Ajout d’un gestionnaire d’accueil

Pour ajouter la sensibilisation à HomeKit à une application Xamarin.iOS, modifiez le fichier AppDelegate.cs pour le modifier et faites-le ressembler à ce qui suit :

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

Lorsque l’application est exécutée pour la première fois, l’utilisateur est invité à lui demander s’il souhaite l’autoriser à accéder à ses informations HomeKit :

Si l’utilisateur répond OK, l’application sera en mesure de travailler avec ses accessoires HomeKit sinon, elle ne sera pas et les appels à HomeKit échouent avec une erreur.

Avec le Gestionnaire d’accueil en place, l’application doit ensuite voir si une maison principale a été configurée, et si ce n’est pas le cas, fournir un moyen à l’utilisateur de créer et d’en affecter un.

Accès à la base de données principale

Comme indiqué ci-dessus, une maison principale doit être créée et configurée avant que HomeKit soit disponible et qu’il incombe à l’application de fournir un moyen à l’utilisateur de créer et d’affecter une maison principale si elle n’existe pas déjà.

Lorsque votre application démarre ou retourne d’abord à partir de l’arrière-plan, elle doit surveiller l’événement DidUpdateHomes de la HMHomeManager classe pour case activée pour l’existence d’une maison principale. S’il n’existe pas, il doit fournir une interface permettant à l’utilisateur de en créer une.

Le code suivant peut être ajouté à un contrôleur de vue pour case activée pour la base de données principale :

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

Lorsque le Gestionnaire d’accueil établit une connexion à HomeKit, l’événement DidUpdateHomes est déclenché, toutes les maisons existantes seront chargées dans la collection de maisons du responsable et la maison principale sera chargée, le cas échéant.

Ajout d’une maison principale

Si la PrimaryHome propriété de l’objet HMHomeManager est null après un DidUpdateHomes événement, vous devez fournir un moyen à l’utilisateur de créer et d’affecter une maison principale avant de continuer.

En règle générale, l’application présente un formulaire permettant à l’utilisateur de nommer une nouvelle maison qui est ensuite transmise au Gestionnaire d’accueil pour la configuration en tant qu’accueil principal. Pour l’exemple d’application HomeKitIntro , une vue modale a été créée dans Xcode Interface Builder et appelée par le AddHomeSegue segue à partir de l’interface principale de l’application.

Il fournit un champ de texte pour que l’utilisateur entre un nom pour la nouvelle maison et un bouton permettant d’ajouter la maison. Lorsque l’utilisateur appuie sur le bouton Ajouter une page d’accueil , le code suivant appelle le Gestionnaire d’accueil pour ajouter la page d’accueil :

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

La AddHome méthode tentera de créer une nouvelle maison et la retournera à la routine de rappel donnée. Si la error propriété n’est pas null, une erreur s’est produite et elle doit être présentée à l’utilisateur. Les erreurs les plus courantes sont causées par un nom d’accueil non unique ou par le gestionnaire d’accueil qui ne peut pas communiquer avec HomeKit.

Si la maison a été créée avec succès, vous devez appeler la UpdatePrimaryHome méthode pour définir la nouvelle maison en tant que foyer principal. Là encore, si la error propriété n’est pas null, une erreur s’est produite et elle doit être présentée à l’utilisateur.

Vous devez également surveiller les événements et DidRemoveHome les événements du DidAddHome Gestionnaire d’accueil et mettre à jour l’interface utilisateur de l’application en fonction des besoins.

Important

La AlertView.PresentOKAlert méthode utilisée dans l’exemple de code ci-dessus est une classe d’assistance dans l’application HomeKitIntro qui facilite l’utilisation des alertes iOS.

Recherche de nouveaux accessoires

Une fois qu’une maison principale a été définie ou chargée à partir du Gestionnaire d’accueil, votre application Xamarin.iOS peut appeler pour HMAccessoryBrowser trouver les nouveaux accessoires d’automatisation à domicile et les ajouter à une maison.

Appelez la StartSearchingForNewAccessories méthode pour commencer à rechercher de nouveaux accessoires et la StopSearchingForNewAccessories méthode lorsque vous avez terminé.

Important

StartSearchingForNewAccessories ne doit pas être laissé en cours d’exécution pendant de longues périodes, car il affectera négativement la durée de vie de la batterie et les performances de l’appareil iOS. Apple suggère d’appeler StopSearchingForNewAccessories après une minute ou de rechercher uniquement lorsque l’interface utilisateur d’accessoire de recherche est présentée à l’utilisateur.

L’événement DidFindNewAccessory sera appelé lorsque de nouveaux accessoires sont découverts et ils seront ajoutés à la DiscoveredAccessories liste dans l’Explorateur d’accessoires.

La DiscoveredAccessories liste contient une collection d’objets HMAccessory qui définissent un appareil home automation activé pour HomeKit et ses services disponibles, tels que les lumières ou le contrôle de porte de garage.

Une fois que le nouvel accessoire a été trouvé, il doit être présenté à l’utilisateur et ainsi il peut le sélectionner et l’ajouter à une maison. Exemple :

Appelez la AddAccessory méthode pour ajouter l’accessoire sélectionné à la collection de la maison. Par exemple :

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

Si la err propriété n’est pas null, une erreur s’est produite et elle doit être présentée à l’utilisateur. Dans le cas contraire, l’utilisateur sera invité à entrer le code d’installation de l’appareil à ajouter :

Dans le simulateur d’accessoires HomeKit, vous trouverez ce numéro sous le champ Code d’installation :

Pour les accessoires HomeKit réels, le code d’installation sera imprimé sur une étiquette sur l’appareil lui-même, sur la boîte de produit ou dans le manuel de l’utilisateur de l’accessoire.

Vous devez surveiller l’événement de l’explorateur d’accessoires DidRemoveNewAccessory et mettre à jour l’interface utilisateur pour supprimer un accessoire de la liste disponible une fois que l’utilisateur l’a ajouté à sa collection d’accueil.

Utilisation des accessoires

Une fois qu’une maison principale a été établie et des accessoires ont été ajoutés à celui-ci, vous pouvez présenter une liste d’accessoires (et éventuellement des chambres) pour que l’utilisateur fonctionne avec.

L’objet HMRoom contient toutes les informations relatives à une pièce donnée et à tous les accessoires qui lui appartiennent. Les chambres peuvent éventuellement être organisées en une ou plusieurs zones. Un HMZone contient toutes les informations relatives à une zone donnée et à toutes les salles qui lui appartiennent.

Pour l’amour de cet exemple, nous allons garder les choses simples et travailler avec les accessoires d’une maison directement, au lieu de les organiser dans des salles ou des zones.

L’objet HMHome contient une liste d’accessoires attribués qui peuvent être présentés à l’utilisateur dans sa Accessories propriété. Par exemple :

Formulaire ici, l’utilisateur peut sélectionner un accessoire donné et travailler avec les services qu’il fournit.

Utilisation des services

Lorsque l’utilisateur interagit avec un appareil Home Automation activé pour HomeKit donné, il s’agit généralement des services qu’il fournit. La Services propriété de la HMAccessory classe contient une collection d’objets HMService qui définissent les services offerts par un appareil.

Les services sont des éléments tels que les lumières, les thermostats, les ouvertures de porte de garage, les commutateurs ou les verrous. Certains appareils (comme un openeur de porte de garage) fournissent plusieurs services, tels qu’une lumière et la possibilité d’ouvrir ou de fermer une porte.

En plus des services spécifiques fournis par un accessoire donné, chaque accessoire contient un Information Service élément qui définit des propriétés telles que son nom, son fabricant, son modèle et son numéro de série.

Types de services accessoires

Les types de service suivants sont disponibles via l’énumération HMServiceType :

• Information sur les accessoires - Fournit des informations sur l’appareil d’automatisation à domicile (accessoire) donné.
• AirQualitySensor : définit un capteur de qualité de l’air.
• Batterie : définit l’état de la batterie d’un accessoire.
• CarbonDioxideSensor : définit un capteur de dioxyde de carbone.
• CarbonMonoxideSensor : définit un capteur de monoxyde de carbone.
• ContactSensor : définit un capteur de contact (par exemple, une fenêtre ouverte ou fermée).
• Porte : définit un capteur d’état de porte (par exemple, ouvert ou fermé).
• Ventilateur : définit un ventilateur contrôlé à distance.
• GarageDoorOpener - Définit un openeur de porte de garage.
• HumiditySensor : définit un capteur d’humidité.
• LeakSensor : définit un capteur de fuite (comme pour un chauffe-eau chaud ou une machine à laver).
• LightBulb - Définit une lumière autonome ou une lumière qui fait partie d’un autre accessoire (comme un ouverture de porte de garage).
• LightSensor : définit un capteur de lumière.
• LockManagement : définit un service qui gère un verrou de porte automatisé.
• LockMechanism - Définit un verrou contrôlé à distance (comme un verrou de porte).
• MotionSensor : définit un capteur de mouvement.
• OccupationSensor : définit un capteur d’occupation.
• Sortie : définit une prise de mur contrôlée à distance.
• SecuritySystem : définit un système de sécurité domestique.
• StatefulProgrammableSwitch : définit un commutateur programmable qui reste dans un état donné une fois déclenché (comme un commutateur de retournement).
• StatelessProgrammableSwitch : définit un commutateur programmable qui revient à son état initial après avoir été déclenché (comme un bouton push).
• SmokeSensor : définit un capteur de fumée.
• Commutateur : définit un commutateur activé/désactivé comme un commutateur de mur standard.
• TemperatureSensor : définit un capteur de température.
• Thermostat : définit un thermostat intelligent utilisé pour contrôler un système HVAC.
• Fenêtre : définit une fenêtre automatisée qui peut être ouverte ou fermée à distance.
• WindowCovering : définit une fenêtre contrôlée à distance, comme les blinds qui peuvent être ouverts ou fermés.

Affichage des informations de service

Une fois que vous avez chargé un HMAccessory objet, vous pouvez interroger les objets individuels HNService qu’il fournit et afficher ces informations à l’utilisateur :

Vous devez toujours case activée la Reachable propriété d’un HMAccessory avant de tenter de l’utiliser. Un accessoire peut être inaccessible à l’utilisateur n’est pas dans la plage de l’appareil ou s’il a été déconnecté.

Une fois qu’un service a été sélectionné, l’utilisateur peut afficher ou modifier une ou plusieurs caractéristiques de ce service pour surveiller ou contrôler un appareil home automation donné.

Utilisation des caractéristiques

Chaque HMService objet peut contenir une collection d’objets HMCharacteristic qui peuvent fournir des informations sur l’état du service (comme une porte ouverte ou fermée) ou autoriser l’utilisateur à ajuster un état (par exemple, définir la couleur d’une lumière).

HMCharacteristic fournit non seulement des informations sur une caractéristique et son état, mais fournit également des méthodes d’utilisation de l’état via des métadonnées caractéristiques (HMCharacteristisMetadata). Ces métadonnées peuvent fournir des propriétés (telles que des plages de valeurs minimales et maximales) utiles lors de l’affichage d’informations à l’utilisateur ou leur permettant de modifier des états.

L’énumération HMCharacteristicType fournit un ensemble de valeurs de métadonnées caractéristiques qui peuvent être définies ou modifiées comme suit :

• Administration OnlyAccess
• AirParticulateDensity
• AirParticulateSize
• AirQuality
• AudioFeedback
• BatteryLevel
• Luminosité
• CarbonDioxideDetected
• CarbonDioxideLevel
• CarbonDioxidePeakLevel
• CarbonMonoxideDetected
• CarbonMonoxideLevel
• CarbonMonoxidePeakLevel
• ChargingState
• ContactState
• CoolingThreshold
• CurrentDoorState
• CurrentHeatingCooling
• CurrentHorizontalTilt
• CurrentLightLevel
• CurrentLockMechanismState
• CurrentPosition
• CurrentRelativeHumidity
• CurrentSecuritySystemState
• CurrentTemperature
• CurrentVerticalTilt
• FirmwareVersion
• HardwareVersion
• HeatingCoolingStatus
• HeatingThreshold
• HoldPosition
• Teinte
• Identification
• InputEvent
• LeakDetected
• LockManagementAutoSecureTimeout
• LockManagementControlPoint
• LockMechanismLastKnownAction
• Journaux d’activité
• Fabricant
• Modèle
• MotionDetected
• Nom
• ObstructionDetected
• OccupationDetected
• OutletInUse
• OutputState
• PositionState
• PowerState
• RotationDirection
• RotationSpeed
• Saturation
• SerialNumber
• SmokeDetected
• SoftwareVersion
• StatusActive
• StatusFault
• StatusJammed
• StatusLowBattery
• StatusTampered
• TargetDoorState
• TargetHeatingCooling
• TargetHorizontalTilt
• TargetLockMechanismState
• TargetPosition
• TargetRelativeHumidity
• TargetSecuritySystemState
• TargetTemperature
• TargetVerticalTilt
• TemperatureUnits
• Version

Utilisation de la valeur d’une caractéristique

Pour vous assurer que votre application a le dernier état d’une caractéristique donnée, appelez la ReadValue méthode de la HMCharacteristic classe. Si la err propriété n’est pas null, une erreur s’est produite et elle peut ou non être présentée à l’utilisateur.

La propriété de la caractéristique contient l’état Value actuel de la caractéristique donnée en tant que NSObject, et, par conséquent, ne peut pas être utilisé directement en C#.

Pour lire la valeur, la classe d’assistance suivante a été ajoutée à l’exemple d’application HomeKitIntro :

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

Il NSObjectConverter est utilisé chaque fois que l’application doit lire l’état actuel d’une caractéristique. Par exemple :

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

La ligne ci-dessus convertit la valeur en une float qui peut ensuite être utilisée dans le code Xamarin C#.

Pour modifier un HMCharacteristic, appelez sa WriteValue méthode et encapsulez la nouvelle valeur dans un NSObject.FromObject appel. Par exemple :

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

Si la err propriété n’est pas null, une erreur s’est produite et doit être présentée à l’utilisateur.

Test des modifications de valeurs caractéristiques

Lors de l’utilisation HMCharacteristics et des accessoires simulés, les modifications apportées à la Value propriété peuvent être surveillées à l’intérieur du simulateur d’accessoires HomeKit.

Avec l’application HomeKitIntro s’exécutant sur un matériel d’appareil iOS réel, les modifications apportées à la valeur d’une caractéristique doivent être visibles presque instantanément dans le simulateur d’accessoires HomeKit. Par exemple, en modifiant l’état d’une lumière dans l’application iOS :

Doit changer l’état de la lumière dans le simulateur d’accessoires HomeKit. Si la valeur ne change pas, case activée l’état du message d’erreur lors de l’écriture de nouvelles valeurs caractéristiques et assurez-vous que l’accessoire est toujours accessible.

Fonctionnalités avancées de HomeKit

Cet article a abordé les fonctionnalités de base requises pour l’utilisation des accessoires HomeKit dans une application Xamarin.iOS. Toutefois, il existe plusieurs fonctionnalités avancées de HomeKit qui ne sont pas abordées dans cette introduction :

• Salles - Les accessoires compatibles HomeKit peuvent éventuellement être organisés en salles par l’utilisateur final. Cela permet à HomeKit de présenter des accessoires d’une manière facile pour l’utilisateur à comprendre et à travailler avec. Pour plus d’informations sur la création et la maintenance des salles, consultez la documentation hmRoom d’Apple.
• Zones : les salles peuvent éventuellement être organisées en zones par l’utilisateur final. Une zone fait référence à une collection de salles que l’utilisateur peut traiter comme une unité unique. Par exemple : En haut, en bas ou sous-sol. Là encore, cela permet à HomeKit de présenter et d’utiliser des accessoires d’une manière qui est logique pour l’utilisateur final. Pour plus d’informations sur la création et la maintenance de zones, consultez la documentation HMZone d’Apple.
• Actions et jeux d’actions : les actions modifient les caractéristiques du service accessoire et peuvent être regroupées en ensembles. Les jeux d’actions agissent en tant que scripts pour contrôler un groupe d’accessoires et coordonner leurs actions. Par exemple, un script « Regarder la télévision » peut fermer les blinds, faire sombrer les lumières et activer la télévision et son système sonore. Pour plus d’informations sur la création et la maintenance des actions et des jeux d’actions, consultez la documentation hmAction et HMActionSet d’Apple.
• Déclencheurs : un déclencheur peut activer un ou plusieurs ensembles d’actions quand un ensemble donné de conditions a été rempli. Par exemple, activez la lumière de porture et verrouillez toutes les portes externes lorsqu’elles sont sombres à l’extérieur. Pour plus d’informations sur la création et la maintenance des déclencheurs, consultez la documentation HMTrigger d’Apple.

Étant donné que ces fonctionnalités utilisent les mêmes techniques présentées ci-dessus, elles doivent être faciles à implémenter en suivant le Guide HomeKitDeveloper d’Apple, les instructions relatives à l’interface utilisateur HomeKit et les informations de référence sur l’infrastructure HomeKit.

Instructions de révision des applications HomeKit

Avant de soumettre une application Xamarin.iOS compatible avec HomeKit à iTunes Connecter pour la publication dans l’App Store iTunes, veillez à suivre les instructions d’Apple pour les applications compatibles HomeKit :

• L’objectif principal de l’application doit être l’automatisation à domicile si vous utilisez l’infrastructure HomeKit.
• Le texte marketing de l’application doit informer les utilisateurs que HomeKit est utilisé et qu’ils doivent fournir une politique de confidentialité.
• La collecte d’informations utilisateur ou l’utilisation de HomeKit pour la publicité est strictement interdite.

Pour obtenir les instructions de révision complètes, consultez les instructions de révision de l’App Store d’Apple.

Nouveautés d’iOS 9

Apple a apporté les modifications et ajouts suivants à HomeKit pour iOS 9 :

• Maintenance des objets existants : si un accessoire existant est modifié, le Gestionnaire d’accueil (HMHomeManager) vous informe de l’élément spécifique qui a été modifié.
• Identificateurs persistants : toutes les classes HomeKit pertinentes incluent désormais une propriété permettant d’identifier UniqueIdentifier de manière unique un élément donné dans les applications compatibles HomeKit (ou les instances de la même application).
• Gestion des utilisateurs : ajout d’un contrôleur de vue intégré pour fournir la gestion des utilisateurs sur les utilisateurs qui ont accès aux appareils HomeKit dans la maison de l’utilisateur principal.
• Fonctionnalités utilisateur : les utilisateurs HomeKit disposent désormais d’un ensemble de privilèges qui contrôlent les fonctions qu’ils sont en mesure d’utiliser dans les accessoires HomeKit et HomeKit activés. Votre application ne doit afficher que les fonctionnalités pertinentes pour l’utilisateur actuel. Par exemple, seuls les administrateurs doivent pouvoir gérer d’autres utilisateurs.
• Scènes prédéfinies : des scènes prédéfinies ont été créées pour quatre événements courants qui se produisent pour l’utilisateur HomeKit moyen : Get Up, Leave, Return, Go to Bed. Ces scènes prédéfinies ne peuvent pas être supprimées d’une maison.
• Scènes et Siri - Siri prend plus en charge Les scènes dans iOS 9 et peut reconnaître le nom de n’importe quelle scène définie dans HomeKit. Un utilisateur peut exécuter une scène simplement en parlant son nom à Siri.
• Catégories d’accessoires : un ensemble de catégories prédéfinies a été ajouté à tous les accessoires et permet d’identifier le type d’accessoire ajouté à une maison ou travaillé à partir de votre application. Ces nouvelles catégories sont disponibles lors de la configuration de l’accessoire.
• Support Apple Watch - HomeKit est désormais disponible pour watchOS et Apple Watch sera en mesure de contrôler les appareils HomeKit activés sans i Téléphone être près de la montre. HomeKit pour watchOS prend en charge les fonctionnalités suivantes : affichage des maisons, contrôle des accessoires et exécution de scènes.
• Nouveau type de déclencheur d’événement : en plus des déclencheurs de type minuteur pris en charge dans iOS 8, iOS 9 prend désormais en charge les déclencheurs d’événements basés sur l’état accessoire (par exemple, les données du capteur) ou la géolocalisation. Les déclencheurs d’événements utilisent NSPredicates pour définir des conditions pour leur exécution.
• Accès à distance : avec accès à distance, l’utilisateur est désormais en mesure de contrôler ses accessoires Home Automation activés pour HomeKit lorsqu’il est absent de la maison à un emplacement distant. Dans iOS 8, cela n’a été pris en charge que si l’utilisateur avait une apple TV de 3e génération dans la maison. Dans iOS 9, cette limitation est levée et l’accès à distance est pris en charge via iCloud et le protocole HAP (HomeKit Accessory Protocol).
• Nouvelles capacités Bluetooth Low Energy (BLE) - HomeKit prend désormais en charge d’autres types d’accessoires qui peuvent communiquer via le protocole Bluetooth Low Energy (BLE). À l’aide du tunneling sécurisé HAP, un accessoire HomeKit peut exposer un autre accessoire Bluetooth via le Wi-Fi (s’il est hors de portée Bluetooth). Dans iOS 9, les accessoires BLE prennent entièrement en charge les notifications et les métadonnées.
• Nouvelles catégories d’accessoires - Apple a ajouté les nouvelles catégories d’accessoires suivantes dans iOS 9 : couvertures de fenêtres, portes motorisées et fenêtres, systèmes d’alarme, capteurs et commutateurs programmables.

Pour plus d’informations sur les nouvelles fonctionnalités de HomeKit dans iOS 9, consultez l’index HomeKit d’Apple et les nouveautés de la vidéo HomeKit.

Résumé

Cet article a introduit l’infrastructure home automation HomeKit d’Apple. Il a montré comment configurer et configurer des appareils de test à l’aide du simulateur d’accessoires HomeKit et comment créer une application Xamarin.iOS simple pour découvrir, communiquer avec et contrôler les appareils home automation à l’aide de HomeKit.

Liens associés

• Nouveautés d’iOS 9.0
• HomeKitDeveloper Guide
• Instructions relatives à l’interface utilisateur HomeKit
• Informations de référence sur l’infrastructure HomeKit