HomeKit no Xamarin.iOS

HomeKit é a estrutura da Apple para controlar dispositivos de automação residencial. Este artigo apresenta o HomeKit e aborda a configuração de acessórios de teste no HomeKit Accessory Simulator e a criação de um aplicativo Xamarin.iOS simples para interagir com esses acessórios.

A Apple introduziu o HomeKit no iOS 8 como uma maneira de integrar perfeitamente vários dispositivos de automação residencial de vários fornecedores em uma única unidade coerente. Ao promover um protocolo comum para descobrir, configurar e controlar dispositivos de automação residencial, o HomeKit permite que dispositivos de fornecedores não relacionados trabalhem juntos, tudo sem que os fornecedores individuais precisem coordenar esforços.

Com o HomeKit, você pode criar um aplicativo Xamarin.iOS que controla qualquer dispositivo habilitado para HomeKit sem usar APIs ou aplicativos fornecidos pelo fornecedor. Usando o HomeKit, você pode fazer o seguinte:

• Descubra novos dispositivos de automação residencial habilitados para HomeKit e adicione-os a um banco de dados que persistirá em todos os dispositivos iOS do usuário.
• Configure, exiba e controle qualquer dispositivo no Banco de Dados de Configuração Inicial do HomeKit.
• Comunique-se com qualquer dispositivo HomeKit pré-configurado e ordene-os para executar ações individuais ou trabalhar em conjunto, como acender todas as luzes da cozinha.

Além de servir dispositivos no Banco de Dados de Configuração Doméstica para aplicativos habilitados para HomeKit, o HomeKit fornece acesso aos comandos de voz da Siri. Dada uma configuração adequada do HomeKit, o usuário pode emitir comandos de voz como "Siri, acenda as luzes da sala de estar".

O banco de dados de configuração inicial

O HomeKit organiza todos os dispositivos de automação em um determinado local em uma Coleção Doméstica. Esta coleção fornece uma maneira para o usuário agrupar seus dispositivos de automação residencial em unidades logicamente organizadas com etiquetas significativas e legíveis por humanos.

A Home Collection é armazenada em um Banco de Dados de Configuração Inicial que será automaticamente copiado e sincronizado em todos os dispositivos iOS do usuário. O HomeKit fornece as seguintes classes para trabalhar com o Banco de Dados de Configuração Inicial:

• HMHome - Este é o contêiner de nível superior que contém todas as informações e configurações para todos os dispositivos de automação residencial em um único local físico (por exemplo, uma residência unifamiliar). O usuário pode ter mais de uma residência, como sua casa principal e uma casa de férias. Ou eles podem ter diferentes "casas" na mesma propriedade, como a casa principal e uma casa de hóspedes sobre a garagem. De qualquer forma, pelo menos um HMHome objeto deve ser configurado e armazenado antes que qualquer outra informação do HomeKit possa ser inserida.
• HMRoom - Embora opcional, a HMRoom permite que o usuário defina cômodos específicos dentro de uma casa (HMHome) como: Cozinha, Banheiro, Garagem ou Sala de Estar. O usuário pode agrupar todos os dispositivos de automação residencial em um local específico em sua casa em um HMRoom e agir sobre eles como uma unidade. Por exemplo, pedir à Siri para desligar as luzes da garagem.
• HMAccessory - Isso representa um dispositivo de automação individual e físico habilitado para HomeKit que foi instalado na residência do usuário (como um termostato inteligente). Cada HMAccessory um é atribuído a um HMRoomarquivo . Se o usuário não tiver configurado nenhuma sala, o HomeKit atribuirá acessórios a uma sala padrão especial.
• HMService - Representa um serviço prestado por um determinado HMAccessory, como o estado liga/desliga de uma luz ou sua cor (se houver suporte para mudança de cor). Cada HMAccessory um pode ter mais de um serviço, como um abridor de porta de garagem que também inclui uma luz. Além disso, um determinado HMAccessory pode ter serviços, como atualização de firmware, que estão fora do controle do usuário.
• HMZone - Permite que o usuário agrupe uma coleção de HMRoom objetos em zonas lógicas, como Upstairs, Downstairs ou Basement. Embora opcional, isso permite interações como pedir à Siri para desligar toda a luz no andar de baixo.

Provisionando um aplicativo HomeKit

Devido aos requisitos de segurança impostos pelo HomeKit, um aplicativo Xamarin.iOS que usa a estrutura HomeKit deve ser configurado corretamente no Apple Developer Portal e no arquivo de projeto Xamarin.iOS.

Faça o seguinte:

1. Faça login no Apple Developer Portal.

2. Clique em Certificados, Identificadores e Perfis.

3. Se você ainda não tiver feito isso, clique em Identificadores e crie uma ID para seu aplicativo (por exemplo com.company.appname, ), caso contrário, edite sua ID existente.

4. Verifique se o serviço HomeKit foi verificado para a ID fornecida:

   

5. Salve suas alterações.

6. Clique em Desenvolvimento de perfis>de provisionamento e crie um novo perfil de provisionamento de desenvolvimento para seu aplicativo:

   

7. Baixe e instale o novo perfil de provisionamento ou use o Xcode para baixar e instalar o perfil.

8. Edite suas opções de projeto Xamarin.iOS e verifique se você está usando o perfil de provisionamento que acabou de criar:

   

9. Em seguida, edite o arquivo Info.plist e verifique se você está usando a ID do aplicativo que foi usada para criar o perfil de provisionamento:

   

10. Finalmente, edite seu arquivo Entitlements.plist e verifique se o direito do HomeKit foi selecionado:

    

11. Salve as alterações em todos os arquivos.

Com essas configurações em vigor, o aplicativo agora está pronto para acessar as APIs do HomeKit Framework. Para obter informações detalhadas sobre o provisionamento, consulte nossos guias de provisionamento de dispositivos e provisionamento de seu aplicativo .

O simulador de acessórios HomeKit

Para fornecer uma maneira de testar todos os dispositivos e serviços de automação residencial possíveis, sem precisar ter um dispositivo físico, a Apple criou o HomeKit Accessory Simulator. Usando este simulador, você pode configurar dispositivos HomeKit virtuais.

Instalando o simulador

A Apple fornece o HomeKit Accessory Simulator como um download separado do Xcode, então você precisará instalá-lo antes de continuar.

Faça o seguinte:

1. Em um navegador da Web, visite Downloads para desenvolvedores da Apple

2. Baixe as Ferramentas adicionais para Xcode xxx (onde xxx é a versão do Xcode que você instalou):

   

3. Abra a imagem de disco e instale as ferramentas no diretório Aplicativos .

Com o HomeKit Accessory Simulator instalado, acessórios virtuais podem ser criados para teste.

Criando acessórios virtuais

Para iniciar o HomeKit Accessory Simulator e criar alguns acessórios virtuais, faça o seguinte:

1. Na pasta Aplicativos, inicie o HomeKit Accessory Simulator:

   

2. Clique no + botão e selecione Novo acessório...:

   

3. Preencha as informações sobre o novo acessório e clique no botão Concluir :

   

4. Clique no botão Adicionar serviço e selecione um tipo de serviço na lista suspensa:

   

5. Forneça um Nome para o serviço e clique no botão Concluir:

   

6. Você pode fornecer características opcionais para um serviço clicando no botão Adicionar característica e definindo as configurações necessárias:

   

7. Repita as etapas acima para criar um de cada tipo de dispositivo de automação residencial virtual compatível com o HomeKit.

Com alguns exemplos de acessórios virtuais do HomeKit criados e configurados, agora você pode consumir e controlar esses dispositivos a partir do seu aplicativo Xamarin.iOS.

Configurando o arquivo Info.plist

Novo para o iOS 10 (e superior), o desenvolvedor precisará adicionar a NSHomeKitUsageDescription chave ao arquivo do Info.plist aplicativo e fornecer uma cadeia de caracteres declarando por que o aplicativo deseja acessar o banco de dados HomeKit do usuário. Essa cadeia de caracteres será apresentada ao usuário na primeira vez que ele executar o aplicativo:

Para definir essa chave, faça o seguinte:

1. Clique duas vezes no Info.plist arquivo no Gerenciador de Soluções para abri-lo para edição.

2. Na parte inferior da tela, alterne para o modo de exibição Origem .

3. Adicione uma nova entrada à lista.

4. Na lista suspensa, selecione Privacidade - Descrição de uso do HomeKit:

   

5. Insira uma descrição do motivo pelo qual o aplicativo deseja acessar o banco de dados HomeKit do usuário:

   

6. Salve as alterações no arquivo.

Conectando-se ao HomeKit

Para se comunicar com o HomeKit, seu aplicativo Xamarin.iOS precisa primeiro instanciar uma instância da HMHomeManager classe. O Home Manager é o ponto de entrada central no HomeKit e é responsável por fornecer uma lista de casas disponíveis, atualizar e manter essa lista e retornar a Página Inicial Principal do usuário.

O HMHome objeto contém todas as informações sobre uma casa, incluindo quaisquer salas, grupos ou zonas que ele possa conter, juntamente com quaisquer acessórios de automação residencial que tenham sido instalados. Antes que qualquer operação possa ser executada no HomeKit, pelo menos uma HMHome deve ser criada e atribuída como a Página Inicial Principal.

Seu aplicativo é responsável por verificar se uma Página Inicial Principal existe e criar e atribuir uma, se não existir.

Adicionando um Home Manager

Para adicionar o reconhecimento do HomeKit a um aplicativo Xamarin.iOS, edite o arquivo AppDelegate.cs para editá-lo e torná-lo semelhante ao seguinte:

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 o aplicativo for executado pela primeira vez, o usuário será perguntado se deseja permitir que ele acesse suas informações do HomeKit:

Se o usuário responder OK, então o aplicativo será capaz de trabalhar com seus acessórios HomeKit, caso contrário, não e quaisquer chamadas para HomeKit falharão com um erro.

Com o Home Manager no lugar, em seguida, o aplicativo precisará ver se uma Página Inicial Principal foi configurada e, se não, fornecer uma maneira para o usuário criar e atribuir uma.

Acessando a Página Inicial Principal

Como dito acima, uma Página Inicial Primária deve ser criada e configurada antes que o HomeKit esteja disponível e é responsabilidade do aplicativo fornecer uma maneira para o usuário criar e atribuir uma Página Inicial Principal, caso ainda não exista.

Quando seu aplicativo é iniciado ou retorna do segundo plano, ele precisa monitorar o DidUpdateHomesHMHomeManager evento da classe para verificar a existência de uma Página Inicial Primária. Se um não existir, ele deve fornecer uma interface para o usuário criar um.

O código a seguir pode ser adicionado a um controlador de exibição para verificar a Página Inicial Primária:

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 o Home Manager fizer uma conexão com o HomeKit, o DidUpdateHomes evento será disparado, todas as casas existentes serão carregadas na coleção de casas do gerente e a Casa Primária será carregada, se disponível.

Adicionando uma Página Inicial Principal

Se a PrimaryHome propriedade do for null posterior a HMHomeManager um DidUpdateHomes evento, você precisará fornecer uma maneira para o usuário criar e atribuir uma Página Inicial Principal antes de continuar.

Normalmente, o aplicativo apresentará um formulário para o usuário nomear uma nova casa que, em seguida, é passada para o Home Manager para configurar como a Página Inicial Principal. Para o aplicativo de exemplo HomeKitIntro , uma exibição modal foi criada no Xcode Interface Builder e chamada pelo AddHomeSegue segue a partir da interface principal do aplicativo.

Ele fornece um campo de texto para o usuário inserir um nome para a nova casa e um botão para adicionar a página inicial. Quando o usuário toca no botão Adicionar Página Inicial , o código a seguir chama o Home Manager para adicionar a página inicial:

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

O AddHome método tentará criar uma nova casa e retorná-la à rotina de retorno de chamada dada. Se a error propriedade não nullfor , ocorreu um erro e ele deve ser apresentado ao usuário. Os erros mais comuns são causados por um nome residencial não exclusivo ou pelo Home Manager não ser capaz de se comunicar com o HomeKit.

Se a casa foi criada com êxito, você precisará chamar o UpdatePrimaryHome método para definir a nova casa como a Página Inicial Principal. Novamente, se a error propriedade não nullfor , ocorreu um erro e ele deve ser apresentado ao usuário.

Você também deve monitorar os eventos e DidRemoveHome o Home Manager e DidAddHome atualizar a interface do usuário do aplicativo, conforme necessário.

Encontrando novos acessórios

Depois que uma Casa Principal tiver sido definida ou carregada a partir do Home Manager, seu aplicativo Xamarin.iOS poderá ligar para o HMAccessoryBrowser para encontrar novos acessórios de automação residencial e adicioná-los a uma casa.

Chame o StartSearchingForNewAccessories método para começar a procurar novos acessórios e o StopSearchingForNewAccessories método quando terminar.

O DidFindNewAccessory evento será chamado quando novos acessórios forem descobertos e eles serão adicionados à DiscoveredAccessories lista no Navegador de Acessórios.

A DiscoveredAccessories lista conterá uma coleção de objetos que definem um dispositivo de automação residencial habilitado para HomeKit e seus serviços disponíveis, como luzes ou controle de porta de HMAccessory garagem.

Uma vez que o novo acessório foi encontrado, ele deve ser apresentado ao usuário e assim ele pode selecioná-lo e adicioná-lo a uma casa. Exemplo:

Chame o AddAccessory método para adicionar o acessório selecionado à coleção da casa. Por exemplo:

// 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 a err propriedade não nullfor , ocorreu um erro e ele deve ser apresentado ao usuário. Caso contrário, o usuário será solicitado a inserir o código de configuração para o dispositivo adicionar:

No HomeKit Accessory Simulator este número pode ser encontrado no campo Código de configuração:

Para acessórios HomeKit reais, o código de configuração será impresso em uma etiqueta no próprio dispositivo, na caixa do produto ou no manual do usuário do acessório.

Você deve monitorar o evento do DidRemoveNewAccessory Navegador de Acessórios e atualizar a interface do usuário para remover um acessório da lista disponível depois que o usuário o adicionar à sua Coleção Doméstica.

Trabalhando com acessórios

Uma vez que uma Casa Primária e foram estabelecidas e acessórios foram adicionados a ela, você pode apresentar uma lista de acessórios (e opcionalmente salas) para o usuário trabalhar.

O HMRoom objeto contém todas as informações sobre uma determinada sala e quaisquer acessórios que pertencem a ela. Os quartos podem, opcionalmente, ser organizados em uma ou mais zonas. A HMZone contém todas as informações sobre uma determinada zona e todos os quartos que pertencem a ela.

Por causa deste exemplo, vamos manter as coisas simples e trabalhar com os acessórios de uma casa diretamente, em vez de organizá-los em quartos ou zonas.

O HMHome objeto contém uma lista de acessórios atribuídos que podem ser apresentados ao usuário em sua Accessories propriedade. Por exemplo:

Formulário aqui, o usuário pode selecionar um determinado acessório e trabalhar com os serviços que ele fornece.

Trabalhando com serviços

Quando o usuário interage com um determinado dispositivo de automação residencial habilitado para HomeKit, geralmente é por meio dos serviços que ele fornece. A Services propriedade da HMAccessory classe contém uma coleção de HMService objetos que definem os serviços que um dispositivo oferece.

Os serviços são coisas como luzes, termostatos, abridores de portas de garagem, interruptores ou fechaduras. Alguns dispositivos (como um abridor de porta de garagem) fornecerão mais de um serviço, como uma luz e a capacidade de abrir ou fechar uma porta.

Além dos serviços específicos que um determinado acessório fornece, cada acessório contém um Information Service que define propriedades como seu Nome, Fabricante, Modelo e Número de Série.

Tipos de Serviço de Acessórios

Os seguintes tipos de serviço estão disponíveis através do HMServiceType enum:

• AccessoryInformation - Fornece informações sobre o dispositivo de automação residencial fornecido (acessório).
• AirQualitySensor - Define um sensor de qualidade do ar.
• Bateria - Define o estado da bateria de um acessório.
• CarbonDioxideSensor - Define um sensor de dióxido de carbono.
• CarbonMonoxideSensor - define um sensor de monóxido de carbono.
• ContactSensor - Define um sensor de contato (como uma janela sendo aberta ou fechada).
• Porta - Define um sensor de estado da porta (como aberto ou fechado).
• Ventilador - Define um ventilador controlado remotamente.
• GarageDoorOpener - Define um abridor de porta de garagem.
• HumiditySensor - Define um sensor de umidade.
• LeakSensor - Define um sensor de vazamento (como para um aquecedor de água quente ou máquina de lavar).
• LightBulb - Define uma luz autônoma ou uma luz que faz parte de outro acessório (como um abridor de porta de garagem).
• LightSensor - Define um sensor de luz.
• LockManagement - Define um serviço que gerencia uma fechadura de porta automatizada.
• LockMechanism - Define uma fechadura controlada remotamente (como uma fechadura de porta).
• MotionSensor - Define um sensor de movimento.
• OccupancySensor - Define um sensor de ocupação.
• Tomada - Define uma tomada de parede controlada remotamente.
• SecuritySystem - Define um sistema de segurança doméstica.
• StatefulProgrammableSwitch - Define um comutador programável que permanece em um determinado estado depois de acionado (como um interruptor de inversão).
• StatelessProgrammableSwitch - Define um comutador programável que retorna ao seu estado inicial após ser acionado (como um botão de pressão).
• SmokeSensor - Define um sensor de fumaça.
• Interruptor - Define um interruptor liga/desliga como um interruptor de parede padrão.
• TemperatureSensor - Define um sensor de temperatura.
• Termostato - Define um termostato inteligente usado para controlar um sistema HVAC.
• Janela - Define uma janela automatizada que pode ser aberta ou fechada remotamente.
• WindowCovering - Define um revestimento de janela controlado remotamente, como persianas que podem ser abertas ou fechadas.

Exibindo informações de serviço

Depois de carregar um HMAccessory você pode consultar os objetos individuais HNService que ele fornece e exibir essas informações para o usuário:

Você deve sempre verificar a Reachable propriedade de um HMAccessory antes de tentar trabalhar com ele. Um acessório pode estar inacessível, o usuário não estiver dentro do alcance do dispositivo ou se ele tiver sido desconectado.

Uma vez selecionado um serviço, o usuário pode visualizar ou modificar uma ou mais características desse serviço para monitorar ou controlar um determinado dispositivo de automação residencial.

Trabalhando com características

Cada HMService objeto pode conter uma coleção de HMCharacteristic objetos que podem fornecer informações sobre o estado do serviço (como uma porta sendo aberta ou fechada) ou permitir que o usuário ajuste um estado (como definir a cor de uma luz).

HMCharacteristic não apenas fornece informações sobre uma característica e seu estado, mas também fornece métodos para trabalhar com o estado por meio de metadados característicos (HMCharacteristisMetadata). Esses metadados podem fornecer propriedades (como intervalos de valores mínimos e máximos) que são úteis ao exibir informações para o usuário ou permitir que ele modifique estados.

O HMCharacteristicType enum fornece um conjunto de valores de metadados característicos que podem ser definidos ou modificados da seguinte maneira:

• AdminOnlyAccess
• AirParticulateDensity
• AirParticulateSize
• Qualidade do ar
• AudioFeedback
• BatteryLevel
• Brilho
• Dióxido de carbonoDetectado
• Nível de dióxido de carbono
• CarbonDioxidePeakLevel
• Monóxido de CarbonoDetectado
• Nível de Monóxido de Carbono
• CarbonMonoxidePeakLevel
• Estado de Carregamento
• ContactState
• CoolingThreshold
• CurrentDoorState
• CurrentHeatingCooling
• CurrentHorizontalTilt
• CurrentLightLevel
• CurrentLockMechanismState
• Posição Atual
• CurrentRelativeHumidity
• CurrentSecuritySystemState
• CurrentTemperature
• CurrentVerticalTilt
• FirmwareVersion
• HardwareVersion
• AquecimentoCoolingStatus
• Limite de aquecimento
• Posição de Retenção
• Matiz
• Identificar
• InputEvent
• Vazamento detectado
• LockManagementAutoSecureTimeout
• LockManagementControlPoint
• LockMechanismLastKnownAction
• Logs
• Fabricante
• Modelo
• MotionDetected
• Nome
• ObstruçãoDetectada
• OcupaçãoDetectada
• OutletInUse
• OutputState
• PositionState
• PowerState
• RotaDireção
• Velocidade de Rotação
• Saturação
• SerialNumber
• FumaçaDetectado
• SoftwareVersion
• StatusAtivo
• StatusFault
• StatusJammed
• StatusLowBattery
• StatusAdulterado
• TargetDoorState
• TargetHeatingResfriamento
• TargetHorizontalTilt
• TargetLockMechanismState
• Posição-alvo
• TargetRelativeHumidity
• TargetSecuritySystemState
• TargetTemperature
• TargetVerticalTilt
• TemperaturaUnidades
• Versão

Trabalhando com o valor de uma característica

Para garantir que seu aplicativo tenha o estado mais recente de uma determinada característica, chame HMCharacteristic o ReadValue método da classe. Se a err propriedade não nullfor , ocorreu um erro e ele pode ou não ser apresentado ao usuário.

A propriedade Characteristic contém Value o estado atual da característica dada como um NSObject, e como tal não pode ser trabalhada diretamente em C#.

Para ler o valor, a seguinte classe auxiliar foi adicionada ao aplicativo de exemplo 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
    }
}

O NSObjectConverter é usado sempre que o aplicativo precisa ler o estado atual de uma característica. Por exemplo:

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

A linha acima converte o valor em um float que pode ser usado no código Xamarin C#.

Para modificar um HMCharacteristic, chame seu WriteValue método e encapsular o novo valor em uma NSObject.FromObject chamada. Por exemplo:

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

Se a err propriedade não nullfor , ocorreu um erro que deve ser apresentado ao usuário.

Testando alterações de valor de característica

Ao trabalhar com HMCharacteristics acessórios e simulados, as modificações na Value propriedade podem ser monitoradas dentro do Simulador de Acessórios HomeKit.

Com o aplicativo HomeKitIntro em execução no hardware real do dispositivo iOS, as alterações no valor de uma característica devem ser vistas quase instantaneamente no HomeKit Accessory Simulator. Por exemplo, alterar o estado de uma luz no aplicativo iOS:

Deve alterar o estado da luz no HomeKit Accessory Simulator. Se o valor não for alterado, verifique o estado da mensagem de erro ao gravar novos valores de característica e verifique se o acessório ainda está acessível.

Recursos avançados do HomeKit

Este artigo abordou os recursos básicos necessários para trabalhar com acessórios HomeKit em um aplicativo Xamarin.iOS. No entanto, existem vários recursos avançados do HomeKit que não são abordados nesta introdução:

• Salas - Os acessórios habilitados para HomeKit podem, opcionalmente, ser organizados em salas pelo usuário final. Isso permite que o HomeKit apresente acessórios de uma maneira fácil para o usuário entender e trabalhar. Para obter mais informações sobre como criar e manter salas, consulte a documentação do HMRoom da Apple.
• Zonas - As salas podem, opcionalmente, ser organizadas em zonas pelo usuário final. Uma zona refere-se a uma coleção de salas que o usuário pode tratar como uma única unidade. Por exemplo: Andar de cima, andar de baixo ou porão. Novamente, isso permite que o HomeKit apresente e trabalhe com acessórios de uma forma que faça sentido para o usuário final. Para obter mais informações sobre como criar e manter zonas, consulte a documentação do HMZone da Apple.
• Ações e conjuntos de ações - As ações modificam as características do serviço acessório e podem ser agrupadas em conjuntos. Os Conjuntos de Ações atuam como scripts para controlar um grupo de acessórios e coordenar suas ações. Por exemplo, um script "Assistir TV" pode fechar as persianas, diminuir as luzes e ligar a televisão e seu sistema de som. Para obter mais informações sobre como criar e manter ações e conjuntos de ações, consulte a documentação HMAction e HMActionSet da Apple.
• Gatilhos - Um gatilho pode ativar um ou mais Conjuntos de Ações quando um determinado conjunto de condições for atendido. Por exemplo, acenda a luz da varanda e tranque todas as portas externas quando escurecer do lado de fora. Para obter mais informações sobre como criar e manter gatilhos, consulte a documentação do HMTrigger da Apple.

Como esses recursos usam as mesmas técnicas apresentadas acima, eles devem ser fáceis de implementar seguindo o Guia do desenvolvedor do HomeKit, as diretrizes da interface do usuário do HomeKit e a Referência do HomeKit Framework.

Diretrizes de revisão do aplicativo HomeKit

Antes de enviar um aplicativo Xamarin.iOS habilitado para HomeKit para o iTunes Connect para lançamento na iTunes App Store, certifique-se de seguir as diretrizes da Apple para aplicativos habilitados para HomeKit:

• O objetivo principal do aplicativo deve ser a automação residencial se estiver usando a estrutura HomeKit.
• O texto de marketing do aplicativo deve notificar os usuários de que o HomeKit está sendo usado e eles devem fornecer uma política de privacidade.
• A coleta de informações do usuário ou o uso do HomeKit para publicidade são estritamente proibidos.

Para obter as diretrizes de revisão completas, consulte as Diretrizes de revisão da App Store da Apple.

O que há de novo no iOS 9

A Apple fez as seguintes alterações e adições ao HomeKit para iOS 9:

• Mantendo objetos existentes - Se um acessório existente for modificado, o Gerenciador inicial (HMHomeManager) informará o item específico que foi modificado.
• Identificadores persistentes - Todas as classes relevantes do HomeKit agora incluem uma UniqueIdentifier propriedade para identificar exclusivamente um determinado item em aplicativos habilitados para HomeKit (ou instâncias do mesmo aplicativo).
• Gerenciamento de usuários - Adicionado um controlador de exibição interno para fornecer gerenciamento de usuários sobre usuários que têm acesso aos dispositivos HomeKit na casa do usuário principal.
• Recursos do usuário - Os usuários do HomeKit agora têm um conjunto de privilégios que controlam quais funções eles podem usar nos acessórios habilitados para HomeKit e HomeKit. Seu aplicativo só deve exibir recursos relevantes para o usuário atual. Por exemplo, apenas um administrador deve ser capaz de manter outros usuários.
• Cenas predefinidas - Cenas predefinidas foram criadas para quatro eventos comuns que ocorrem para o usuário médio do HomeKit: Levantar, Sair, Voltar, Ir para a cama. Essas cenas predefinidas não podem ser excluídas de uma casa.
• Cenas e Siri - A Siri tem suporte mais profundo para Cenas no iOS 9 e pode reconhecer o nome de qualquer Cena definida no HomeKit. Um usuário pode executar uma cena simplesmente falando seu nome para a Siri.
• Categorias de acessórios - Um conjunto de categorias predefinidas foi adicionado a todos os Acessórios e ajuda a identificar o tipo de acessório que está sendo adicionado a uma Página Inicial ou trabalhado em seu aplicativo. Essas novas categorias estão disponíveis durante a configuração do Acessório.
• Suporte do Apple Watch - O HomeKit já está disponível para watchOS e o Apple Watch poderá controlar dispositivos habilitados para HomeKit sem que um iPhone esteja perto do relógio. O HomeKit para watchOS suporta os seguintes recursos: Visualização de casas, Controle de acessórios e Execução de cenas.
• Novo tipo de gatilho de evento - Além dos gatilhos de tipo de timer suportados no iOS 8, o iOS 9 agora suporta gatilhos de evento com base no estado do acessório (como dados do sensor) ou geolocalização. Os gatilhos de eventos são usados NSPredicates para definir condições para sua execução.
• Acesso Remoto - Com o Acesso Remoto, o usuário agora pode controlar seus Acessórios de Automação Residencial habilitados para HomeKit quando estiver fora de casa em um local remoto. No iOS 8, isso só era suportado se o usuário tivesse uma Apple TV de 3ª geração em casa. No iOS 9, essa limitação é suspensa e o acesso remoto é suportado por meio do iCloud e do HomeKit Accessory Protocol (HAP).
• Novas habilidades Bluetooth Low Energy (BLE) - O HomeKit agora suporta mais tipos de acessórios que podem se comunicar por meio do protocolo Bluetooth Low Energy (BLE). Usando o HAP Secure Tunneling, um Acessório HomeKit pode expor outro Acessório Bluetooth por Wi-Fi (se estiver fora do alcance do Bluetooth). No iOS 9, os Acessórios BLE têm suporte completo para notificações e metadados.
• Novas categorias de acessórios - A Apple adicionou as seguintes novas categorias de acessórios no iOS 9: revestimentos de janelas, portas e janelas motorizadas, sistemas de alarme, sensores e interruptores programáveis.

Para obter mais informações sobre os novos recursos do HomeKit no iOS 9, consulte o Índice do HomeKit da Apple e o vídeo O que há de novo no HomeKit.

Resumo

Este artigo apresentou a estrutura de automação residencial HomeKit da Apple. Ele mostrou como instalar e configurar dispositivos de teste usando o HomeKit Accessory Simulator e como criar um aplicativo Xamarin.iOS simples para descobrir, se comunicar e controlar dispositivos de automação residencial usando o HomeKit.

Links relacionados

• O que há de novo no iOS 9.0
• HomeKitGuia do desenvolvedor
• Diretrizes da interface do usuário do HomeKit
• Referência do HomeKit Framework