HomeKit in Xamarin.iOS

HomeKit è il framework apple per controllare i dispositivi di home automation. Questo articolo presenta HomeKit e illustra la configurazione degli accessori di test nel simulatore di accessori HomeKit e la scrittura di una semplice app Xamarin.iOS per interagire con questi accessori.

Apple ha introdotto HomeKit in iOS 8 come modo per integrare facilmente più dispositivi di automazione domestica da un'ampia gamma di fornitori in un'unica unità coerente. Promuovendo un protocollo comune per l'individuazione, la configurazione e il controllo dei dispositivi di home automation, HomeKit consente ai dispositivi di fornitori non correlati di collaborare, senza che i singoli fornitori possano coordinare gli sforzi.

Con HomeKit è possibile creare un'app Xamarin.iOS che controlla qualsiasi dispositivo abilitato per HomeKit senza usare le API o le app fornite dal fornitore. Usando HomeKit, è possibile eseguire le operazioni seguenti:

• Individuare i nuovi dispositivi home automation abilitati per HomeKit e aggiungerli a un database che verrà mantenuto in tutti i dispositivi iOS dell'utente.
• Configurare, visualizzare e controllare qualsiasi dispositivo nel database home configuration di HomeKit.
• Comunicare con qualsiasi dispositivo HomeKit preconfigurato e comandi per eseguire singole azioni o lavorare in concerto, ad esempio accendere tutte le luci in cucina.

Oltre a gestire i dispositivi nelle app abilitate per Home Configuration Database to HomeKit, HomeKit fornisce l'accesso ai comandi vocali di Siri. Data una configurazione di HomeKit configurata in modo appropriato, l'utente può eseguire comandi vocali, ad esempio "Siri, accendere le luci nel salotto".

Database di configurazione home

HomeKit organizza tutti i dispositivi di automazione in una determinata posizione in una raccolta home. Questa raccolta consente all'utente di raggruppare i dispositivi di home automation in unità disposte logicamente con etichette leggibili significative e leggibili.

La raccolta home viene archiviata in un database di configurazione home che verrà eseguito automaticamente il backup e la sincronizzazione in tutti i dispositivi iOS dell'utente. HomeKit fornisce le classi seguenti per l'uso del database di configurazione home:

• HMHome - Si tratta del contenitore di primo livello che contiene tutte le informazioni e le configurazioni per tutti i dispositivi di automazione domestica in un'unica posizione fisica ,ad esempio una singola residenza familiare. L'utente potrebbe avere più di una residenza, ad esempio la propria casa principale e una casa vacanza. Oppure potrebbero avere diverse "case" sulla stessa proprietà, come la casa principale e una guest house sul garage. In entrambi i casi, almeno un HMHome oggetto deve essere configurato e archiviato prima di poter immettere qualsiasi altra informazione HomeKit.
• HMRoom - Mentre facoltativo, un HMRoom consente all'utente di definire stanze specifiche all'interno di una casa (HMHome) come: cucina, bagno, garage o soggiorno. L'utente può raggruppare tutti i dispositivi di automazione domestica in una posizione specifica nella propria casa e agire su di HMRoom essi come unità. Ad esempio, chiedere a Siri di spegnere le luci del garage.
• HMAccessory - Rappresenta un singolo dispositivo di automazione abilitata per HomeKit fisico installato nella residenza dell'utente (ad esempio un termostato intelligente). Ogni HMAccessory oggetto viene assegnato a un oggetto HMRoom. Se l'utente non ha configurato alcuna stanza, HomeKit assegna accessori a una speciale sala predefinita.
• HMService - Rappresenta un servizio fornito da un determinato HMAccessoryoggetto , ad esempio lo stato on/off di una luce o il relativo colore (se è supportata la modifica del colore). Ognuno HMAccessory può avere più di un servizio, ad esempio una porta garage aperta che include anche una luce. Inoltre, un dato potrebbe HMAccessory avere servizi, ad esempio l'aggiornamento del firmware, esterni al controllo dell'utente.
• HMZone - Consente all'utente di raggruppare una raccolta di HMRoom oggetti in zone logiche, ad esempio al piano di sopra, al piano inferiore o al seminterrato. Anche se facoltativo, ciò consente interazioni come chiedere a Siri di spegnere tutte le luci al piano di sotto.

Provisioning di un'app HomeKit

A causa dei requisiti di sicurezza imposti da HomeKit, un'app Xamarin.iOS che usa il framework HomeKit deve essere configurata correttamente sia nel portale per sviluppatori Apple che nel file di progetto Xamarin.iOS.

Effettua le operazioni seguenti:

1. Accedere al portale per sviluppatori Apple.

2. Fare clic su Certificati, Identificatori e profili.

3. Se non è già stato fatto, fare clic su Identificatori e creare un ID per l'app ( ad esempio com.company.appname), altrimenti modificare l'ID esistente.

4. Verificare che il servizio HomeKit sia stato controllato per l'ID specificato:

   

5. Salva le modifiche.

6. Fare clic su Sviluppo profili> di provisioning e creare un nuovo profilo di provisioning di sviluppo per l'app:

   

7. Scaricare e installare il nuovo profilo di provisioning o usare Xcode per scaricare e installare il profilo.

8. Modificare le opzioni del progetto Xamarin.iOS e assicurarsi di usare il profilo di provisioning appena creato:

   

9. Modificare quindi il file Info.plist e assicurarsi di usare l'ID app usato per creare il profilo di provisioning:

   

10. Infine, modificare il file Entitlements.plist e assicurarsi che sia stato selezionato il diritto HomeKit :

    

11. Salvare le modifiche apportate a tutti i file.

Con queste impostazioni sul posto, l'applicazione è ora pronta per accedere alle API HomeKit Framework. Per informazioni dettagliate sul provisioning, vedere le guide Device Provisioning e Provisioning dell'app .

Importante

Il test di un'app abilitata per HomeKit richiede un dispositivo iOS reale di cui è stato eseguito correttamente il provisioning per lo sviluppo. HomeKit non può essere testato dal simulatore iOS.

Il simulatore di accessori HomeKit

Per fornire un modo per testare tutti i possibili dispositivi e servizi di home automation, senza dover disporre di un dispositivo fisico, Apple ha creato il simulatore di accessori HomeKit. Usando questo simulatore, è possibile configurare e configurare i dispositivi HomeKit virtuali.

Installazione del simulatore

Apple fornisce il simulatore di accessori HomeKit come download separato da Xcode, quindi sarà necessario installarlo prima di continuare.

Effettua le operazioni seguenti:

1. In un Web browser visitare Download per sviluppatori Apple

2. Scaricare gli strumenti aggiuntivi per Xcode xxx (dove xxx è la versione di Xcode installata):

   

3. Aprire l'immagine del disco e installare gli strumenti nella directory Applicazioni .

Con il simulatore di accessori HomeKit installato, è possibile creare accessori virtuali per i test.

Creazione di accessori virtuali

Per avviare il simulatore di accessori HomeKit e creare alcuni accessori virtuali, eseguire le operazioni seguenti:

1. Dalla cartella Applicazioni avviare il simulatore di accessori HomeKit:

   

2. Fare clic sul + pulsante e selezionare Nuovo accessorio...:

   

3. Compilare le informazioni sul nuovo accessorio e fare clic sul pulsante Fine :

   

4. Fare clic sul pulsante Aggiungi servizio . e selezionare un tipo di servizio nell'elenco a discesa:

   

5. Specificare un nome per il servizio e fare clic sul pulsante Fine :

   

6. È possibile fornire caratteristiche facoltative per un servizio facendo clic sul pulsante Aggiungi caratteristica e configurando le impostazioni necessarie:

   

7. Ripetere i passaggi precedenti per creare uno di ogni tipo di dispositivo di automazione domestica virtuale supportato da HomeKit.

Con alcuni accessori HomeKit virtuali di esempio creati e configurati, è ora possibile usare e controllare questi dispositivi dall'app Xamarin.iOS.

Configurazione del file Info.plist

Novità per iOS 10 (e versioni successive), lo sviluppatore dovrà aggiungere la NSHomeKitUsageDescription chiave al file dell'app Info.plist e fornire una stringa che dichiara il motivo per cui l'app vuole accedere al database HomeKit dell'utente. Questa stringa verrà presentata all'utente la prima volta che esegue l'app:

Per impostare questa chiave, eseguire le operazioni seguenti:

1. Fare doppio clic sul Info.plist file nel Esplora soluzioni per aprirlo per la modifica.

2. Nella parte inferiore della schermata passare alla visualizzazione Origine .

3. Aggiungere una nuova voce all'elenco.

4. Nell'elenco a discesa selezionare Privacy - HomeKit Usage Description (Privacy - HomeKit Usage Description):

   

5. Immettere una descrizione per il motivo per cui l'app vuole accedere al database HomeKit dell'utente:

   

6. Salvare le modifiche apportate al file.

Importante

Se non si imposta la NSHomeKitUsageDescription chiave nel Info.plist file, l'app avrà esito negativo in modo invisibile all'utente (chiusa dal sistema in fase di esecuzione) senza errori durante l'esecuzione in iOS 10 (o versione successiva).

Connessione ing in HomeKit

Per comunicare con HomeKit, l'app Xamarin.iOS deve prima creare un'istanza della HMHomeManager classe . Home Manager è il punto di ingresso centrale in HomeKit ed è responsabile della fornitura di un elenco di case disponibili, aggiornamento e gestione di tale elenco e restituzione della home page primaria dell'utente.

L'oggetto HMHome contiene tutte le informazioni relative a una casa che include stanze, gruppi o zone che possono contenere, insieme a tutti gli accessori di automazione domestica installati. Prima che tutte le operazioni possano essere eseguite in HomeKit, almeno una HMHome deve essere creata e assegnata come Home primaria.

L'app è responsabile del controllo dell'esistenza di una home page primaria e della creazione e dell'assegnazione di una home se non esiste.

Aggiunta di un home manager

Per aggiungere riconoscimento HomeKit a un'app Xamarin.iOS, modificare il file AppDelegate.cs per modificarlo e renderlo simile al seguente:

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

Quando l'applicazione viene eseguita per la prima volta, all'utente verrà chiesto se vuole consentire l'accesso alle informazioni di HomeKit:

Se l'utente risponde OK, l'applicazione sarà in grado di lavorare con gli accessori HomeKit altrimenti non sarà e qualsiasi chiamata a HomeKit avrà esito negativo con un errore.

Con Home Manager sul posto, successivamente l'applicazione dovrà verificare se è stata configurata una Home primaria e, in caso contrario, fornire un modo per l'utente di crearne e assegnarne uno.

Accesso alla home page primaria

Come indicato in precedenza, è necessario creare e configurare una Home primaria prima che HomeKit sia disponibile ed è responsabilità dell'app fornire un modo per consentire all'utente di creare e assegnare una Home primaria, se non esiste già.

Quando l'app viene avviata o restituita per la prima volta dallo sfondo, deve monitorare l'evento DidUpdateHomes della HMHomeManager classe per verificare l'esistenza di una Home primaria. Se non esiste, deve fornire un'interfaccia per l'utente per crearne una.

È possibile aggiungere il codice seguente a un controller di visualizzazione per verificare la presenza della home page primaria:

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

Quando Home Manager stabilisce una connessione a HomeKit, l'evento DidUpdateHomes verrà generato, tutte le case esistenti verranno caricate nella raccolta di case del manager e la Home primaria verrà caricata, se disponibile.

Aggiunta di una home page primaria

Se la PrimaryHome proprietà di HMHomeManager è null dopo un DidUpdateHomes evento, è necessario fornire un modo per consentire all'utente di creare e assegnare una Home primaria prima di continuare.

In genere l'app presenterà un modulo per l'utente per denominare una nuova home page che viene quindi passata a Home Manager per configurare come Home principale. Per l'app di esempio HomeKitIntro , è stata creata una visualizzazione modale in Xcode Interface Builder e chiamata da AddHomeSegue segue dall'interfaccia principale dell'app.

Fornisce un campo di testo per l'utente per immettere un nome per la nuova home page e un pulsante per aggiungere la home page. Quando l'utente tocca il pulsante Aggiungi home , il codice seguente chiama Home Manager per aggiungere la home page:

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

Il AddHome metodo tenterà di creare una nuova home page e di restituirlo alla routine di callback specificata. Se la error proprietà non nullè , si è verificato un errore e deve essere presentato all'utente. Gli errori più comuni sono causati da un nome home non univoco o da Home Manager non in grado di comunicare con HomeKit.

Se la casa è stata creata correttamente, è necessario chiamare il UpdatePrimaryHome metodo per impostare la nuova home page come Home primaria. Anche in questo caso, se la error proprietà non nullè , si è verificato un errore e deve essere presentata all'utente.

È anche necessario monitorare gli eventi e DidRemoveHome gli eventi di DidAddHome Home Manager e aggiornare l'interfaccia utente dell'app in base alle esigenze.

Importante

Il AlertView.PresentOKAlert metodo usato nel codice di esempio precedente è una classe helper nell'applicazione HomeKitIntro che semplifica l'uso degli avvisi iOS.

Ricerca di nuovi accessori

Dopo aver definito o caricato una Home primaria da Home Manager, l'app Xamarin.iOS può chiamare per HMAccessoryBrowser trovare eventuali nuovi accessori di automazione home e aggiungerli a una casa.

Chiamare il StartSearchingForNewAccessories metodo per iniziare a cercare nuovi accessori e il metodo al StopSearchingForNewAccessories termine.

Importante

StartSearchingForNewAccessories non deve essere lasciato in esecuzione per lunghi periodi di tempo perché influirà negativamente sia sulla durata della batteria che sulle prestazioni del dispositivo iOS. Apple suggerisce di chiamare StopSearchingForNewAccessories dopo un minuto o solo la ricerca quando l'interfaccia utente trova accessorio viene presentata all'utente.

L'evento DidFindNewAccessory verrà chiamato quando vengono individuati nuovi accessori e verranno aggiunti all'elenco DiscoveredAccessories nel Browser accessori.

L'elenco DiscoveredAccessories conterrà una raccolta di HMAccessory oggetti che definiscono un dispositivo home automation abilitato per HomeKit e i relativi servizi disponibili, ad esempio luci o controllo porta garage.

Una volta trovato il nuovo accessorio, dovrebbe essere presentato all'utente e quindi può selezionarlo e aggiungerlo a una casa. Esempio:

Chiama il AddAccessory metodo per aggiungere l'accessorio selezionato alla raccolta della casa. Ad esempio:

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

Se la err proprietà non nullè , si è verificato un errore e deve essere presentato all'utente. In caso contrario, all'utente verrà chiesto di immettere il codice di installazione per il dispositivo da aggiungere:

Nel simulatore di accessori HomeKit questo numero è disponibile nel campo Codice di installazione:

Per gli accessori HomeKit reali, il codice di installazione verrà stampato su un'etichetta sul dispositivo stesso, nella scatola del prodotto o nel manuale dell'utente dell'accessorio.

Devi monitorare l'evento del DidRemoveNewAccessory Browser accessorio e aggiornare l'interfaccia utente per rimuovere un accessorio dall'elenco disponibile dopo che l'utente l'ha aggiunto alla home collection.

Uso degli accessori

Una volta che è stata stabilita una casa primaria e gli accessori sono stati aggiunti a esso, è possibile presentare un elenco di accessori (e facoltativamente stanze) per l'utente a lavorare con.

L'oggetto HMRoom contiene tutte le informazioni relative a una determinata stanza e a tutti gli accessori che lo appartengono. Le camere possono essere organizzate facoltativamente in una o più zone. Un HMZone oggetto contiene tutte le informazioni relative a una determinata zona e a tutte le stanze che lo appartengono.

Ai fini di questo esempio, le cose saranno semplici e lavoreranno direttamente con gli accessori di una casa, invece di organizzarli in stanze o zone.

L'oggetto HMHome contiene un elenco di accessori assegnati che possono essere presentati all'utente nella relativa Accessories proprietà. Ad esempio:

Modulo qui, l'utente può selezionare un determinato accessorio e lavorare con i servizi forniti.

Uso dei servizi

Quando l'utente interagisce con un determinato dispositivo home automation abilitato per HomeKit, è in genere tramite i servizi forniti. La Services proprietà della HMAccessory classe contiene una raccolta di HMService oggetti che definiscono i servizi offerti da un dispositivo.

I servizi sono cose come luci, termostati, porte garage, interruttori o serrature. Alcuni dispositivi (come una porta del garage aperto) forniranno più di un servizio, ad esempio una luce e la possibilità di aprire o chiudere una porta.

Oltre ai servizi specifici forniti da un determinato accessorio, ogni accessorio contiene un oggetto Information Service che definisce proprietà quali nome, produttore, modello e numero di serie.

Tipi di servizio accessori

I tipi di servizio seguenti sono disponibili tramite l'enumerazione HMServiceType :

• AccessoryInformation : fornisce informazioni sul dispositivo di automazione home (accessorio) specificato.
• AirQualitySensor : definisce un sensore di qualità dell'aria.
• Batteria : definisce lo stato della batteria di un accessorio.
• CarbonDioxideSensor : definisce un sensore di anidride carbonica.
• CarbonMonoxideSensor : definisce un sensore monossido di carbonio.
• ContactSensor : definisce un sensore di contatto, ad esempio una finestra aperta o chiusa.
• Porta : definisce un sensore di stato della porta(ad esempio aperto o chiuso).
• Ventola : definisce una ventola controllata da remoto.
• GarageDoorOpener : definisce un apribile porta garage.
• HumiditySensor : definisce un sensore di umidità.
• LeakSensor : definisce un sensore di perdita (ad esempio per un riscaldamento o una lavatrice).
• LightBulb : definisce una luce autonoma o una luce che fa parte di un altro accessorio (ad esempio una porta del garage aperta).
• LightSensor : definisce un sensore di luce.
• LockManagement : definisce un servizio che gestisce un blocco automatico delle porte.
• LockMechanism : definisce un blocco controllato da remoto (ad esempio una serratura della porta).
• MotionSensor : definisce un sensore di movimento.
• OccupancySensor : definisce un sensore di occupazione.
• Presa: definisce una presa da parete controllata da remoto.
• SecuritySystem : definisce un sistema di sicurezza principale.
• StatefulProgrammableSwitch : definisce un commutatore programmabile che rimane in uno stato di assegnare una volta attivato (ad esempio un interruttore di scorrimento).
• StatelessProgrammableSwitch : definisce un commutatore programmabile che torna allo stato iniziale dopo l'attivazione (ad esempio un pulsante di pressione).
• SmokeSensor : definisce un sensore di fumo.
• Interruttore : definisce un interruttore on/off come un commutatore a parete standard.
• TemperatureSensor : definisce un sensore di temperatura.
• Termostato : definisce un termostato intelligente usato per controllare un sistema HVAC.
• Finestra : definisce una finestra automatizzata che può essere aperta o chiusa in remoto.
• WindowCovering : definisce una finestra controllata da remoto, ad esempio le cieche che possono essere aperte o chiuse.

Visualizzazione delle informazioni sul servizio

Dopo aver caricato un oggetto HMAccessory , è possibile eseguire una query sui singoli HNService oggetti forniti e visualizzare tali informazioni all'utente:

È consigliabile controllare sempre la Reachable proprietà di un oggetto HMAccessory prima di provare a usarla. Un accessorio può non essere raggiungibile dall'utente non rientra nell'intervallo del dispositivo o se è stato scollegato.

Dopo aver selezionato un servizio, l'utente può visualizzare o modificare una o più caratteristiche del servizio per monitorare o controllare un determinato dispositivo di automazione domestica.

Utilizzo delle caratteristiche

Ogni HMService oggetto può contenere una raccolta di HMCharacteristic oggetti che possono fornire informazioni sullo stato del servizio (ad esempio una porta aperta o chiusa) o consentire all'utente di regolare uno stato ,ad esempio impostando il colore di una luce.

HMCharacteristic non solo fornisce informazioni su una caratteristica e il relativo stato, ma fornisce anche metodi per lavorare con lo stato tramite metadati caratteristica (HMCharacteristisMetadata). Questi metadati possono fornire proprietà (ad esempio intervalli di valori minimi e massimi) utili quando si visualizzano informazioni all'utente o consentono loro di modificare gli stati.

L'enumerazione HMCharacteristicType fornisce un set di valori di metadati caratteristica che possono essere definiti o modificati nel modo seguente:

• Amministrazione OnlyAccess
• AirParticulateDensity
• AirParticulateSize
• AirQuality
• AudioFeedback
• BatteryLevel
• Luminosità
• CarbonDioxideDetected
• CarbonDioxideLevel
• CarbonDioxidePeakLevel
• CarbonMonoxideDetected
• CarbonMonoxideLevel
• CarbonMonoxidePeakLevel
• ChargeState
• ContactType
• CoolingThreshold
• CurrentDoorState
• CurrentHeatingCooling
• CurrentHorizontalTilt
• CurrentLightLevel
• CurrentLockMechanismState
• CurrentPosition
• CurrentRelative Aggregatedity
• CurrentSecuritySystemState
• CurrentTemperature
• CurrentVerticalTilt
• FirmwareVersion
• HardwareVersion
• HeatingCoolingStatus
• HeatingThreshold
• HoldPosition
• Hue
• Identificazione
• InputEvent
• LeakDetected
• LockManagementAutoSecureTimeout
• LockManagementControlPoint
• LockMechanismLastKnownAction
• Registri
• Produttore
• Modello
• MotionDetected
• Nome
• OstruzioneDetected
• OccupancyDetected
• OutletInUse
• OutputState
• PositionState
• PowerState
• RotationDirection
• RotationSpeed
• Saturazione
• SerialNumber
• SmokeDetected
• SoftwareVersion
• StatusActive
• StatusFault
• StatusJammed
• StatusLowBattery
• StatusTampered
• TargetDoorState
• TargetHeatingCooling
• TargetHorizontalTilt
• TargetLockMechanismState
• TargetPosition
• TargetRelativeScsidity
• TargetSecuritySystemState
• TargetTemperature
• TargetVerticalTilt
• TemperatureUnits
• Versione

Utilizzo del valore di una caratteristica

Per assicurarsi che l'app abbia lo stato più recente di una determinata caratteristica, chiamare il ReadValue metodo della HMCharacteristic classe . Se la err proprietà non nullè , si è verificato un errore e potrebbe essere visualizzato o meno all'utente.

La proprietà Di caratteristica Value contiene lo stato corrente della caratteristica specificata come NSObjecte, di conseguenza, non può essere usata direttamente in C#.

Per leggere il valore, la classe helper seguente è stata aggiunta all'applicazione di esempio 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
    }
}

Viene NSObjectConverter usato ogni volta che l'applicazione deve leggere lo stato corrente di una caratteristica. Ad esempio:

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

La riga precedente converte il valore in un float oggetto che può quindi essere usato nel codice C# di Xamarin.

Per modificare un HMCharacteristicoggetto , chiamare il WriteValue relativo metodo ed eseguire il wrapping del nuovo valore in una NSObject.FromObject chiamata. Ad esempio:

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

Se la err proprietà non nullè , si è verificato un errore e deve essere presentato all'utente.

Test delle modifiche dei valori delle caratteristiche

Quando si lavora con HMCharacteristics e accessori simulati, le modifiche apportate alla Value proprietà possono essere monitorate all'interno del simulatore accessorio HomeKit.

Con l'app HomeKitIntro in esecuzione su hardware dispositivo iOS reale, le modifiche apportate al valore di una caratteristica dovrebbero essere visualizzate quasi immediatamente nel simulatore di accessori HomeKit. Ad esempio, modificando lo stato di una luce nell'app iOS:

Dovrebbe cambiare lo stato della luce nel simulatore accessorio HomeKit. Se il valore non cambia, controllare lo stato del messaggio di errore quando si scrivono nuovi valori di caratteristica e assicurarsi che l'accessorio sia ancora raggiungibile.

Funzionalità avanzate di HomeKit

Questo articolo ha illustrato le funzionalità di base necessarie per l'uso degli accessori HomeKit in un'app Xamarin.iOS. Tuttavia, esistono diverse funzionalità avanzate di HomeKit che non sono trattate in questa introduzione:

• Rooms - Gli accessori abilitati per HomeKit possono facoltativamente essere organizzati in stanze dall'utente finale. Questo consente a HomeKit di presentare accessori in modo semplice per l'utente di comprendere e lavorare con. Per altre informazioni sulla creazione e la gestione delle sale, vedere la documentazione di HMRoom di Apple.
• Zone: le sale possono essere organizzate facoltativamente in zone dall'utente finale. Una zona fa riferimento a una raccolta di sale che l'utente può considerare come una singola unità. Ad esempio: al piano di sopra, al piano di sotto o al seminterrato. Anche in questo caso, homekit può presentare e lavorare con accessori in modo che abbia senso per l'utente finale. Per altre informazioni sulla creazione e la gestione delle zone, vedere la documentazione di HMZone di Apple.
• Azioni e set di azioni: le azioni modificano le caratteristiche del servizio accessorio e possono essere raggruppate in set. I set di azioni fungono da script per controllare un gruppo di accessori e coordinare le azioni. Ad esempio, uno script "Watch TV" potrebbe chiudere le cieche, spegnere le luci e accendere la televisione e il suo sistema audio. Per altre informazioni sulla creazione e la gestione di azioni e set di azioni, vedere la documentazione di HMAction e HMActionSet di Apple.
• Trigger: un trigger può attivare uno o più set di azioni quando è stato soddisfatto un determinato set di condizioni. Ad esempio, accendere la luce portch e bloccare tutte le porte esterne quando diventa buio all'esterno. Per altre informazioni sulla creazione e la gestione dei trigger, vedere la documentazione di HMTrigger di Apple.

Poiché queste funzionalità usano le stesse tecniche presentate in precedenza, dovrebbero essere facili da implementare seguendo la Guida HomeKitDeveloper di Apple, le linee guida dell'interfaccia utente HomeKit e le informazioni di riferimento sul framework HomeKit.

Linee guida per la revisione delle app HomeKit

Prima di inviare un'app Xamarin.iOS abilitata per HomeKit a iTunes Connessione per il rilascio in iTunes App Store, assicurarsi di seguire le linee guida di Apple per le app abilitate per HomeKit:

• Lo scopo principale dell'app deve essere l'automazione domestica se si usa il framework HomeKit.
• Il testo di marketing dell'app deve informare gli utenti che HomeKit è in uso e devono fornire un'informativa sulla privacy.
• La raccolta di informazioni utente o l'uso di HomeKit per la pubblicità è strettamente vietata.

Per le linee guida per la revisione completa, vedi Le linee guida per la revisione dell'App Store di Apple.

Novità di iOS 9

Apple ha apportato le modifiche e le aggiunte seguenti a HomeKit per iOS 9:

• Mantenimento degli oggetti esistenti: se viene modificato un accessorio esistente, Home Manager (HMHomeManager) informerà l'utente dell'elemento specifico che è stato modificato.
• Identificatori permanenti: tutte le classi HomeKit pertinenti ora includono una UniqueIdentifier proprietà per identificare in modo univoco un determinato elemento nelle app abilitate per HomeKit (o istanze della stessa app).
• Gestione utenti: è stato aggiunto un controller di visualizzazione predefinito per fornire la gestione degli utenti sugli utenti che hanno accesso ai dispositivi HomeKit nella home page dell'utente primario.
• Funzionalità utente: gli utenti di HomeKit hanno ora un set di privilegi che controllano le funzioni che possono usare negli accessori abilitati per HomeKit e HomeKit. L'app deve visualizzare solo le funzionalità pertinenti per l'utente corrente. Ad esempio, solo gli amministratori devono essere in grado di gestire altri utenti.
• Scene predefinite: sono state create scene predefinite per quattro eventi comuni che si verificano per l'utente HomeKit medio: Get Up, Leave, Return, Go to Bed. Queste scene predefinite non possono essere eliminate da una casa.
• Scene e Siri: Siri offre un supporto più approfondito per le scene in iOS 9 e può riconoscere il nome di qualsiasi scena definita in HomeKit. Un utente può eseguire una scena semplicemente parlandone il nome con Siri.
• Categorie accessori: un set di categorie predefinite è stato aggiunto a tutti gli accessori e consente di identificare il tipo di accessorio aggiunto a una Home o lavorato dall'interno dell'app. Queste nuove categorie sono disponibili durante la configurazione accessorio.
• Supporto di Apple Watch: HomeKit è ora disponibile per watchOS e Apple Watch sarà in grado di controllare i dispositivi abilitati per HomeKit senza un i Telefono essere vicino all'orologio. HomeKit per watchOS supporta le funzionalità seguenti: Visualizzazione di case, accessori di controllo e esecuzione di scene.
• Nuovo tipo di trigger di evento: oltre ai trigger di tipo timer supportati in iOS 8, iOS 9 supporta ora i trigger di evento in base allo stato accessorio (ad esempio i dati del sensore) o alla georilevazione. I trigger di evento usano NSPredicates per impostare le condizioni per l'esecuzione.
• Accesso remoto: con Accesso remoto, l'utente è ora in grado di controllare il proprio HomeKit abilitato accessori per l'automazione home quando si trovano lontano dalla casa in una posizione remota. In iOS 8 questo è stato supportato solo se l'utente aveva un Apple TV di terza generazione nella casa. In iOS 9 questa limitazione viene revocata e l'accesso remoto è supportato tramite iCloud e il protocollo HAP (HomeKit Accessory Protocol).
• Nuove capacità Bluetooth Low Energy (BLE): HomeKit ora supporta più tipi di accessori che possono comunicare tramite il protocollo Bluetooth Low Energy (BLE). Usando il tunneling sicuro HAP, un accessorio HomeKit può esporre un altro accessorio Bluetooth tramite Wi-Fi (se non è compreso nell'intervallo Bluetooth). In iOS 9 gli accessori BLE supportano completamente le notifiche e i metadati.
• Nuove categorie di accessori - Apple ha aggiunto le nuove categorie di accessori seguenti in iOS 9: copertura finestre, porte e finestre motorizzate, sistemi di allarme, sensori e commutatori programmabili.

Per altre informazioni sulle nuove funzionalità di HomeKit in iOS 9, vedi l'indice HomeKit di Apple e il video Novità di HomeKit in HomeKit.

Riepilogo

Questo articolo ha introdotto il framework home automation homekit di Apple. Ha illustrato come configurare e configurare i dispositivi di test usando il simulatore di accessori HomeKit e come creare una semplice app Xamarin.iOS per individuare, comunicare e controllare i dispositivi di home automation usando HomeKit.

Collegamenti correlati

• Novità di iOS 9.0
• Guida a HomeKitDeveloper
• Linee guida per l'interfaccia utente di HomeKit
• Informazioni di riferimento sul framework HomeKit