Zestaw homekit w środowisku Xamarin.iOS

  • Artykuł

HomeKit to struktura firmy Apple do kontrolowania urządzeń do automatyzacji domu. W tym artykule przedstawiono zestaw HomeKit i opisano konfigurowanie akcesoriów testowych w symulatorze akcesoriów HomeKit i pisanie prostej aplikacji platformy Xamarin.iOS w celu interakcji z tymi akcesoriami.

An example HomeKit enabled App

Firma Apple wprowadziła zestaw HomeKit w systemie iOS 8 jako sposób bezproblemowego integrowania wielu urządzeń automatyzacji domu od różnych dostawców w jedną spójną jednostkę. Poprzez promowanie wspólnego protokołu do odnajdywania, konfigurowania i kontrolowania urządzeń do automatyzacji domu, HomeKit umożliwia urządzeniom od innych dostawców pracę razem, bez konieczności koordynowania wysiłków poszczególnych dostawców.

Za pomocą zestawu HomeKit można utworzyć aplikację platformy Xamarin.iOS, która kontroluje dowolne urządzenie z obsługą zestawu HomeKit bez używania dostarczonych przez dostawcę interfejsów API lub aplikacji. Za pomocą zestawu HomeKit można wykonać następujące czynności:

  • Odkryj nowe urządzenia homeKit z włączoną automatyzacją domową i dodaj je do bazy danych, która będzie utrwalana na wszystkich urządzeniach z systemem iOS użytkownika.
  • Skonfiguruj, skonfiguruj, wyświetl i kontroluj dowolne urządzenie w bazie danych HomeKit Home Configuration Database.
  • Komunikowanie się ze wstępnie skonfigurowanym urządzeniem HomeKit i polecenie ich do wykonywania poszczególnych akcji lub pracy na koncercie, takich jak włączenie wszystkich świateł w kuchni.

Oprócz obsługi urządzeń w bazie danych konfiguracji domowej do aplikacji z obsługą zestawu HomeKit zestaw HomeKit zapewnia dostęp do poleceń głosowych Siri. Biorąc pod uwagę odpowiednio skonfigurowaną konfigurację zestawu HomeKit, użytkownik może wydać polecenia głosowe, takie jak "Siri, włączyć światła w salonie".

Baza danych konfiguracji głównej

Zestaw HomeKit organizuje wszystkie urządzenia automatyzacji w danej lokalizacji w kolekcji głównej. Ta kolekcja umożliwia użytkownikowi grupowanie urządzeń automatyzacji domu w logicznie rozmieszczone jednostki z zrozumiałymi etykietami czytelnymi dla człowieka.

Kolekcja główna jest przechowywana w bazie danych konfiguracji domu, która zostanie automatycznie utworzona i zsynchronizowana na wszystkich urządzeniach z systemem iOS użytkownika. Zestaw HomeKit udostępnia następujące klasy do pracy z bazą danych konfiguracji domu:

  • HMHome — Jest to kontener najwyższego poziomu, który zawiera wszystkie informacje i konfiguracje dla wszystkich urządzeń automatyzacji domu w jednej lokalizacji fizycznej (np. jednej rezydencji rodzinnej). Użytkownik może mieć więcej niż jedną rezydencję, taką jak główny dom i dom wakacyjny. Mogą też mieć różne "domy" na tym samym obiekcie, takie jak dom główny i dom gościnny w garażu. Tak czy inaczej, co najmniej jeden HMHome obiekt musi być skonfigurowany i przechowywany przed wejściem innych informacji HomeKit.
  • HMRoom - Opcjonalnie HMRoom użytkownik może zdefiniować określone pokoje w domu (HMHome), takie jak Kuchnia, Łazienka, Garaż lub Salon. Użytkownik może zgrupować wszystkie urządzenia automatyzacji domu w określonej lokalizacji w ich domu i HMRoom działać na nich jako jednostka. Na przykład prośba Siri o wyłączenie świateł garażowych.
  • HMAccessory — Reprezentuje to indywidualne fizyczne urządzenie automatyzacji z obsługą zestawu HomeKit, które zostało zainstalowane w rezydencji użytkownika (na przykład inteligentne termostaty). Każda z nich HMAccessory jest przypisywana do elementu HMRoom. Jeśli użytkownik nie skonfigurował żadnych pomieszczeń, zestaw HomeKit przypisuje akcesoria do specjalnego domyślnego pokoju.
  • HMService - Reprezentuje usługę dostarczaną przez daną HMAccessoryusługę, taką jak stan włączania/wyłączania światła lub jego koloru (jeśli zmiana koloru jest obsługiwana). Każdy HMAccessory może mieć więcej niż jedną usługę, taką jak otwieracz drzwi garażowych, który zawiera również światło. Ponadto dane HMAccessory mogą mieć usługi, takie jak aktualizacja oprogramowania układowego, które są poza kontrolą użytkownika.
  • HMZone — Umożliwia użytkownikowi grupowanie kolekcji HMRoom obiektów w strefy logiczne, takie jak na górze, na dole lub w piwnicy. Chociaż jest to opcjonalne, pozwala to na interakcje, takie jak prośba Siri o wyłączenie całego światła na dole.

Aprowizowanie aplikacji HomeKit

Ze względu na wymagania dotyczące zabezpieczeń nałożone przez zestaw HomeKit aplikacja platformy Xamarin.iOS korzystająca z platformy HomeKit musi być prawidłowo skonfigurowana zarówno w portalu dla deweloperów firmy Apple, jak i w pliku projektu Xamarin.iOS.

Należy wykonać następujące czynności:

  1. Zaloguj się do portalu dla deweloperów firmy Apple.

  2. Kliknij pozycję Certyfikaty, Identyfikatory i profile.

  3. Jeśli jeszcze tego nie zrobiono, kliknij pozycję Identyfikatory i utwórz identyfikator aplikacji (np. com.company.appname), a następnie edytuj istniejący identyfikator.

  4. Upewnij się, że usługa HomeKit została sprawdzona dla danego identyfikatora:

    Enable the HomeKit service for the given ID

  5. Zapisz zmiany.

  6. Kliknij pozycję Tworzenie profilów> aprowizacji i utwórz nowy profil aprowizacji programowania dla aplikacji:

    Create a new development provisioning profile for the app

  7. Pobierz i zainstaluj nowy profil aprowizacji lub użyj programu Xcode, aby pobrać i zainstalować profil.

  8. Edytuj opcje projektu platformy Xamarin.iOS i upewnij się, że używasz właśnie utworzonego profilu aprowizacji:

    Select provisioning profile just created

  9. Następnie zmodyfikuj plik Info.plist i upewnij się, że używasz identyfikatora aplikacji użytego do utworzenia profilu aprowizacji:

    Set the App ID

  10. Na koniec zmodyfikuj plik Entitlements.plist i upewnij się, że wybrano uprawnienie HomeKit :

    Enable the HomeKit entitlement

  11. Zapisz zmiany we wszystkich plikach.

Po zastosowaniu tych ustawień aplikacja jest teraz gotowa do uzyskiwania dostępu do interfejsów API struktury HomeKit Framework. Aby uzyskać szczegółowe informacje na temat aprowizacji, zobacz przewodniki Device Provisioning and Provisioning Your App (Aprowizowanie urządzeń i aprowizowanie aplikacji ).

Ważne

Testowanie aplikacji z obsługą zestawu HomeKit wymaga rzeczywistego urządzenia z systemem iOS, które zostało prawidłowo aprowizowane na potrzeby programowania. Zestawu HomeKit nie można przetestować z poziomu symulatora systemu iOS.

Symulator akcesoriów HomeKit

Aby umożliwić przetestowanie wszystkich możliwych urządzeń i usług automatyzacji domu, bez konieczności posiadania urządzenia fizycznego, firma Apple utworzyła symulator akcesoriów HomeKit. Za pomocą tego symulatora można skonfigurować i skonfigurować wirtualne urządzenia HomeKit.

Instalowanie symulatora

Firma Apple udostępnia symulator akcesoriów HomeKit jako osobny plik do pobrania z programu Xcode, dlatego należy go zainstalować przed kontynuowaniem.

Należy wykonać następujące czynności:

  1. W przeglądarce internetowej odwiedź stronę Pliki do pobrania dla deweloperów firmy Apple

  2. Pobierz narzędzia dodatkowe dla środowiska Xcode xxx (gdzie xxx jest zainstalowaną wersją programu Xcode):

    Download the Additional Tools for Xcode

  3. Otwórz obraz dysku i zainstaluj narzędzia w katalogu Aplikacje .

Po zainstalowaniu symulatora akcesoriów HomeKit można utworzyć wirtualne akcesoria do testowania.

Tworzenie akcesoriów wirtualnych

Aby uruchomić symulator akcesoriów HomeKit i utworzyć kilka wirtualnych akcesoriów, wykonaj następujące czynności:

  1. W folderze Applications uruchom symulator akcesoriów HomeKit:

    The HomeKit Accessory Simulator

  2. + Kliknij przycisk i wybierz pozycję Nowe akcesorium...:

    Add a new accessory

  3. Wypełnij informacje o nowej metodzie dostępu i kliknij przycisk Zakończ :

    Fill out the information about the new accessory

  4. Kliknij przycisk Dodaj usługę . Wybierz typ usługi z listy rozwijanej:

    Select a service type from the dropdown

  5. Podaj nazwę usługi i kliknij przycisk Zakończ:

    Enter a Name for the service

  6. Możesz podać opcjonalne cechy usługi, klikając przycisk Dodaj charakterystykę i konfigurując wymagane ustawienia:

    Configuring the required settings

  7. Powtórz powyższe kroki, aby utworzyć jeden z każdego typu wirtualnego urządzenia do automatyzacji domu obsługiwanego przez zestaw HomeKit.

Po utworzeniu i skonfigurowaniu przykładowych wirtualnych akcesoriów HomeKit można teraz korzystać z tych urządzeń i kontrolować je z poziomu aplikacji Xamarin.iOS.

Konfigurowanie pliku Info.plist

Nowy dla systemu iOS 10 (i nowszych) deweloper będzie musiał dodać NSHomeKitUsageDescription klucz do pliku aplikacji Info.plist i podać ciąg deklarujący, dlaczego aplikacja chce uzyskać dostęp do bazy danych HomeKit użytkownika. Ten ciąg zostanie wyświetlony użytkownikowi przy pierwszym uruchomieniu aplikacji:

The HomeKit permission dialog

Aby ustawić ten klucz, wykonaj następujące czynności:

  1. Info.plist Kliknij dwukrotnie plik w Eksplorator rozwiązań, aby otworzyć go do edycji.

  2. W dolnej części ekranu przejdź do widoku Źródło .

  3. Dodaj nowy wpis do listy.

  4. Z listy rozwijanej wybierz pozycję Prywatność — HomeKit Usage Description:

    Select Privacy - HomeKit Usage Description

  5. Wprowadź opis, dlaczego aplikacja chce uzyskać dostęp do bazy danych HomeKit użytkownika:

    Enter a description

  6. Zapisz zmiany w pliku.

Ważne

Błąd ustawienia NSHomeKitUsageDescription klucza w Info.plist pliku spowoduje, że aplikacja w trybie dyskretnym kończy się niepowodzeniem (jest zamykana przez system w czasie wykonywania) bez błędu podczas uruchamiania w systemie iOS 10 (lub nowszym).

Połączenie do zestawu HomeKit

Aby komunikować się z zestawem HomeKit, aplikacja Xamarin.iOS musi najpierw utworzyć wystąpienie HMHomeManager klasy. Menedżer domu jest centralnym punktem wejścia do HomeKit i jest odpowiedzialny za dostarczanie listy dostępnych domów, aktualizowanie i utrzymywanie tej listy i zwracanie głównej strony użytkownika.

Obiekt HMHome zawiera wszystkie informacje o domu, w tym wszelkie pokoje, grupy lub strefy, które mogą zawierać, wraz z dowolnymi akcesoriami do automatyzacji domu, które zostały zainstalowane. Aby można było wykonać jakiekolwiek operacje w zestawie HomeKit, co najmniej jeden HMHome musi zostać utworzony i przypisany jako strona główna podstawowa.

Twoja aplikacja jest odpowiedzialna za sprawdzenie, czy istnieje strona główna podstawowa, oraz czy istnieje i przypisze ją, jeśli nie.

Dodawanie menedżera strony głównej

Aby dodać rozpoznawanie zestawu HomeKit do aplikacji platformy Xamarin.iOS, zmodyfikuj plik AppDelegate.cs, aby go edytować, i ustaw go tak:

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

Gdy aplikacja zostanie uruchomiona po raz pierwszy, użytkownik zostanie poproszony, czy chce zezwolić mu na dostęp do informacji homekit:

The user will be asked if they want to allow it to access their HomeKit information

Jeśli użytkownik odpowie OK, aplikacja będzie mogła pracować z akcesoriami HomeKit, w przeciwnym razie nie i żadne wywołania zestawu HomeKit nie powiedzą się z powodu błędu.

Po utworzeniu Menedżera domu aplikacja będzie musiała sprawdzić, czy skonfigurowano stronę główną, a jeśli nie, zapewnić użytkownikowi sposób tworzenia i przypisywania.

Uzyskiwanie dostępu do głównej strony głównej

Jak wspomniano powyżej, główny dom podstawowy musi zostać utworzony i skonfigurowany przed udostępnieniem zestawu HomeKit i jest to odpowiedzialność aplikacji za zapewnienie użytkownikowi sposobu tworzenia i przypisywania głównej strony głównej, jeśli jeszcze nie istnieje.

Po pierwszym uruchomieniu lub powrocie aplikacji z tła należy monitorować DidUpdateHomes zdarzenie HMHomeManager klasy, aby sprawdzić istnienie głównej strony głównej. Jeśli taki nie istnieje, powinien podać interfejs dla użytkownika, aby go utworzyć.

Do kontrolera widoku można dodać następujący kod w celu sprawdzenia głównej strony głównej:

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

Gdy Menedżer domu nawiązuje połączenie z HomeKit, DidUpdateHomes wydarzenie zostanie wyzwolone, wszystkie istniejące domy zostaną załadowane do kolekcji menedżerów domów, a dom podstawowy zostanie załadowany, jeśli jest dostępny.

Dodawanie głównej strony głównej

PrimaryHome Jeśli właściwość HMHomeManager obiektu znajduje null się po DidUpdateHomes zdarzeniu, musisz zapewnić użytkownikowi sposób tworzenia i przypisywania głównej strony głównej przed kontynuowaniem.

Zazwyczaj aplikacja będzie przedstawiać użytkownikowi formularz z nazwą nowego domu, który następnie jest przekazywany do Menedżera domu w celu skonfigurowania go jako głównego domu. W przypadku przykładowej aplikacji HomeKitIntro w narzędziu Xcode Interface Builder został utworzony widok modalny i wywoływany przez AddHomeSegue segue z głównego interfejsu aplikacji.

Udostępnia pole tekstowe dla użytkownika, aby wprowadzić nazwę nowego domu i przycisk dodawania strony głównej. Gdy użytkownik naciągnie przycisk Dodaj główną, następujący kod wywołuje Menedżera strony głównej w celu dodania strony głównej:

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

Metoda podejmie próbę utworzenia AddHome nowego domu i zwróci ją do danej procedury wywołania zwrotnego. error Jeśli właściwość nie nullma wartości , wystąpił błąd i powinien zostać wyświetlony użytkownikowi. Najbardziej typowe błędy są spowodowane przez nienależącą do unikatowej nazwy głównej lub Menedżera domu, który nie może komunikować się z zestawem HomeKit.

Jeśli strona główna została utworzona pomyślnie, należy wywołać metodę UpdatePrimaryHome , aby ustawić nowy dom jako dom podstawowy. Ponownie, jeśli error właściwość nie nullma wartości , wystąpił błąd i powinien zostać wyświetlony użytkownikowi.

Należy również monitorować zdarzenia i DidRemoveHome zdarzenia menedżera DidAddHome macierzystego oraz aktualizować interfejs użytkownika aplikacji zgodnie z potrzebami.

Ważne

Metoda użyta AlertView.PresentOKAlert w powyższym przykładowym kodzie jest klasą pomocnika w aplikacji HomeKitIntro, która ułatwia pracę z alertami systemu iOS.

Znajdowanie nowych akcesoriów

Po zdefiniowaniu lub załadowaniu głównej strony głównej z Menedżera domu aplikacja Xamarin.iOS może wywołać HMAccessoryBrowser aplikację , aby znaleźć nowe akcesoria do automatyzacji domu i dodać je do domu.

Wywołaj metodę , StartSearchingForNewAccessories aby rozpocząć wyszukiwanie nowych akcesoriów i metodę po zakończeniu StopSearchingForNewAccessories .

Ważne

StartSearchingForNewAccessories nie powinny być uruchomione przez długi czas, ponieważ negatywnie wpłynie to zarówno na żywotność baterii, jak i wydajność urządzenia z systemem iOS. Firma Apple sugeruje wywołanie StopSearchingForNewAccessories po minucie lub tylko po wyświetleniu użytkownikowi interfejsu użytkownika wyszukiwania akcesoriów.

Wydarzenie DidFindNewAccessory będzie wywoływane po odnalezieniu nowych akcesoriów i zostaną dodane do DiscoveredAccessories listy w przeglądarce dostępu.

Lista DiscoveredAccessories będzie zawierać kolekcję HMAccessory obiektów, które definiują urządzenie homekit z włączoną automatyzacją domu i jego dostępne usługi, takie jak światła lub sterowanie drzwiami garażowymi.

Po znalezieniu nowej metody dostępu należy ją przedstawić użytkownikowi, aby mógł go wybrać i dodać do domu. Przykład:

Finding a new accessory

Wywołaj metodę , AddAccessory aby dodać wybrane akcesorium do kolekcji domu. Na przykład:

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

err Jeśli właściwość nie nullma wartości , wystąpił błąd i powinien zostać wyświetlony użytkownikowi. W przeciwnym razie użytkownik zostanie poproszony o wprowadzenie kodu konfiguracji urządzenia w celu dodania:

Enter the setup code for the device to add

W symulatorze akcesoriów HomeKit ten numer można znaleźć w polu Kod instalacji:

The Setup Code field in the HomeKit Accessory Simulator

W przypadku rzeczywistych akcesoriów HomeKit kod konfiguracji zostanie wydrukowany na etykiecie na samym urządzeniu, w pudełku produktu lub w podręczniku użytkownika akcesoriów.

Należy monitorować zdarzenie przeglądarki DidRemoveNewAccessory dostępu i zaktualizować interfejs użytkownika, aby usunąć akcesorium z dostępnej listy po dodaniu go do kolekcji głównej przez użytkownika.

Praca z akcesoriami

Po dodaniu do niego podstawowego domu i akcesoriów można przedstawić listę akcesoriów (i opcjonalnie pokoje) dla użytkownika do pracy.

Obiekt HMRoom zawiera wszystkie informacje o danym pomieszczeniu i wszelkie akcesoria, które do niego należą. Pokoje mogą być opcjonalnie zorganizowane w co najmniej jedną strefę. Obiekt HMZone zawiera wszystkie informacje o danej strefie i wszystkich pokojach, które do niej należą.

W tym przykładzie będziemy trzymać rzeczy proste i pracować z akcesoriami domu bezpośrednio, zamiast organizować je w pokojach lub strefach.

Obiekt HMHome zawiera listę przypisanych metod dostępu, które można przedstawić użytkownikowi we właściwości Accessories . Na przykład:

An example accessory

W tym miejscu użytkownik może wybrać daną metodę dostępu i pracować z usługami, które udostępnia.

Praca z usługami

Gdy użytkownik wchodzi w interakcję z danym urządzeniem homeKit z włączoną automatyzacją domową, zwykle korzysta z usług, które udostępnia. Właściwość ServicesHMAccessory klasy zawiera kolekcję HMService obiektów, które definiują usługi, które oferują urządzenie.

Usługi to takie rzeczy jak światła, termostaty, otwieracze drzwi garażowych, przełączniki lub zamki. Niektóre urządzenia (takie jak otwieracz drzwi garażowych) zapewniają więcej niż jedną usługę, taką jak światło i możliwość otwierania lub zamykania drzwi.

Oprócz określonych usług zapewnianych przez daną metodę dostępu każda metoda dostępu zawiera Information Service właściwości, takie jak nazwa, producent, model i numer seryjny.

Typy usług dostępu

Następujące typy usług są dostępne za pośrednictwem wyliczenia HMServiceType :

  • AccessoryInformation — zawiera informacje o danym urządzeniu automatyzacji domu (akcesorium).
  • AirQualitySensor — definiuje czujnik jakości powietrza.
  • Bateria — definiuje stan baterii akcesoriów.
  • CarbonDioxideSensor — definiuje czujnik dwutlenku węgla.
  • CarbonMonoxideSensor — definiuje czujnik tlenku węgla.
  • ContactSensor — definiuje czujnik kontaktowy (taki jak otwarte lub zamknięte okno).
  • Drzwi — definiuje czujnik stanu drzwi (np. otwarty lub zamknięty).
  • Wentylator — definiuje wentylator sterowany zdalnie.
  • GarageDoorOpener — definiuje otwieracz drzwi garażowych.
  • HumiditySensor — definiuje czujnik wilgotności.
  • LeakSensor — definiuje czujnik wycieku (na przykład w przypadku podgrzewacza wody gorącej lub pralki).
  • LightBulb — definiuje autonomiczne światło lub światło, które jest częścią innej akcesorium (jak otwieracz drzwi garażowych).
  • LightSensor — definiuje czujnik światła.
  • LockManagement — definiuje usługę zarządzającą automatycznym blokowaniem drzwi.
  • LockMechanism — definiuje zdalną blokadę (np. blokadę drzwi).
  • MotionSensor — definiuje czujnik ruchu.
  • OccupancySensor — definiuje czujnik zajętości.
  • Wylot — definiuje zdalnie sterowany wylot ściany.
  • SecuritySystem — definiuje system zabezpieczeń domu.
  • StatefulProgrammableSwitch — definiuje programowalny przełącznik, który pozostaje w stanie danej po wyzwoleniu (na przykład przełącznik przerzucania).
  • StatelessProgrammableSwitch — definiuje programowalny przełącznik, który powraca do stanu początkowego po wyzwoleniu (na przykład przycisku naciśnięcia).
  • SmokeSensor — definiuje czujnik dymu.
  • Przełącznik — definiuje przełącznik włączony/wyłączony, taki jak standardowy przełącznik ścienny.
  • TemperatureSensor — definiuje czujnik temperatury.
  • Termostat — definiuje inteligentny termostat używany do sterowania systemem HVAC.
  • Okno — definiuje automatyczne okno, które można zdalnie otworzyć lub zamknąć.
  • WindowCovering — definiuje zdalnie sterowane osłony okien, takie jak rolety, które można otworzyć lub zamknąć.

Wyświetlanie informacji o usłudze

Po załadowaniu obiektu HMAccessory można wykonać zapytanie dotyczące poszczególnych HNService obiektów, które udostępnia, i wyświetlić te informacje użytkownikowi:

Displaying Service Information

Przed podjęciem próby pracy należy zawsze sprawdzić Reachable właściwość obiektu HMAccessory . Akcesorium może nie być osiągalne, jeśli użytkownik nie znajduje się w zakresie urządzenia lub jeśli został odłączony.

Po wybraniu usługi użytkownik może wyświetlić lub zmodyfikować co najmniej jedną charakterystykę tej usługi w celu monitorowania lub kontrolowania danego urządzenia automatyzacji domowej.

Praca z cechami

Każdy HMService obiekt może zawierać kolekcję HMCharacteristic obiektów, które mogą dostarczać informacje o stanie usługi (na przykład otwarcie lub zamknięcie drzwi) lub zezwolić użytkownikowi na dostosowanie stanu (na przykład ustawienie koloru światła).

HMCharacteristic nie tylko udostępnia informacje o cechach i jego stanie, ale także udostępnia metody pracy ze stanem za pośrednictwem metadanych charakterystycznych (HMCharacteristisMetadata). Te metadane mogą udostępniać właściwości (takie jak minimalne i maksymalne zakresy wartości), które są przydatne podczas wyświetlania informacji użytkownikowi lub zezwalania im na modyfikowanie stanów.

Wyliczenie HMCharacteristicType zawiera zestaw wartości metadanych charakterystycznych, które można zdefiniować lub zmodyfikować w następujący sposób:

  • Administracja OnlyAccess
  • AirParticulateDensity
  • AirParticulateSize
  • AirQuality
  • AudioFeedback
  • BatteryLevel
  • Jasność
  • CarbonDioxideDetected
  • CarbonDioxideLevel
  • CarbonDioxidePeakLevel
  • CarbonMonoxideDetected
  • CarbonMonoxideLevel
  • CarbonMonoxidePeakLevel
  • ChargingState
  • Contactstate
  • CoolingThreshold
  • CurrentDoorState
  • CurrentHeatingCooling
  • CurrentHorizontalTilt
  • CurrentLightLevel
  • CurrentLockMechanismState
  • CurrentPosition
  • CurrentRelativeHumidity
  • CurrentSecuritySystemState
  • CurrentTemperature
  • CurrentVerticalTilt
  • FirmwareVersion
  • HardwareVersion
  • HeatingCoolingStatus
  • HeatingThreshold
  • HoldPosition
  • Hue
  • Określ
  • InputEvent
  • LeakDetected
  • LockManagementAutoSecureTimeout
  • LockManagementControlPoint
  • LockMechanismLastKnownAction
  • Dzienniki
  • Producent
  • Model
  • MotionDetected
  • Nazwisko
  • ObstrukcjaDetected
  • OccupancyDetected
  • OutletInUse
  • OutputState
  • PositionState
  • PowerState
  • RotationDirection
  • ObrótSpeed
  • Nasycenie
  • SerialNumber
  • SmokeDetected
  • SoftwareVersion
  • StanAktywne
  • StatusFault
  • StanJammed
  • StatusLowBattery
  • StanTampered
  • TargetDoorState
  • TargetHeoling
  • TargetHorizontalTilt
  • TargetLockMechanismState
  • Położenie docelowe
  • TargetRelativeHumidity
  • TargetSecuritySystemState
  • TargetTemperature
  • TargetVerticalTilt
  • TemperatureUnits
  • Wersja

Praca z wartością właściwości

Aby upewnić się, że aplikacja ma najnowszy stan danej charakterystyki, wywołaj ReadValue metodę HMCharacteristic klasy. err Jeśli właściwość nie nullma wartości , wystąpił błąd i może być wyświetlany użytkownikowi lub może nie zostać wyświetlony.

Właściwość Właściwości Właściwości Value zawiera bieżący stan danej charakterystyki jako NSObject, a w związku z tym nie można pracować bezpośrednio w języku C#.

Aby odczytać wartość, do przykładowej aplikacji HomeKitIntro dodano następującą klasę pomocnika:

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

Parametr NSObjectConverter jest używany za każdym razem, gdy aplikacja musi odczytać bieżący stan charakterystyki. Na przykład:

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

Powyższy wiersz konwertuje wartość na wartość float , która może być następnie używana w kodzie Xamarin C#.

Aby zmodyfikować metodę , wywołaj metodę HMCharacteristicWriteValue i opakuj nową wartość w wywołaniuNSObject.FromObject. Na przykład:

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

err Jeśli właściwość nie nullma wartości , wystąpił błąd i powinien zostać wyświetlony użytkownikowi.

Zmiany wartości właściwości testowania

Podczas pracy z akcesoriami HMCharacteristics symulowanymi i symulowanymi modyfikacje Value właściwości można monitorować wewnątrz symulatora akcesoriów HomeKit.

W przypadku aplikacji HomeKitIntro działającej na rzeczywistym sprzęcie urządzenia z systemem iOS zmiany wartości właściwości powinny być widoczne niemal natychmiast w symulatorze akcesoriów HomeKit. Na przykład zmiana stanu światła w aplikacji systemu iOS:

Changing the state of a light in an iOS app

Należy zmienić stan światła w symulatorze akcesoriów HomeKit. Jeśli wartość nie ulegnie zmianie, sprawdź stan komunikatu o błędzie podczas pisania nowych wartości charakterystycznych i upewnij się, że akcesorium jest nadal osiągalne.

Zaawansowane funkcje zestawu HomeKit

W tym artykule omówiono podstawowe funkcje wymagane do pracy z akcesoriami HomeKit w aplikacji platformy Xamarin.iOS. Istnieje jednak kilka zaawansowanych funkcji zestawu HomeKit, które nie zostały omówione w tym wprowadzeniu:

  • Pokoje — akcesoria z obsługą zestawu HomeKit można opcjonalnie zorganizować w pokojach przez użytkownika końcowego. Dzięki temu zestaw HomeKit może prezentować akcesoria w sposób łatwy do zrozumienia i pracy z użytkownikiem. Aby uzyskać więcej informacji na temat tworzenia i obsługi pomieszczeń, zobacz dokumentację HMRoom firmy Apple.
  • Strefy — pokoje mogą być opcjonalnie zorganizowane w strefy przez użytkownika końcowego. Strefa odnosi się do kolekcji pomieszczeń, które użytkownik może traktować jako pojedynczą jednostkę. Na przykład: Na piętrze, Na dole lub Piwnica. Dzięki temu zestaw HomeKit może prezentować i pracować z akcesoriami w sposób, który ma sens dla użytkownika końcowego. Aby uzyskać więcej informacji na temat tworzenia i utrzymywania stref, zobacz dokumentację HMZone firmy Apple.
  • Akcje i zestawy akcji — akcje modyfikują charakterystykę usługi dostępu i można je zgrupować w zestawy. Zestawy akcji działają jako skrypty, aby kontrolować grupę akcesoriów i koordynować ich działania. Na przykład skrypt "Watch TV" może zamknąć rolety, przyciemnić światła i włączyć telewizor i jego system dźwiękowy. Aby uzyskać więcej informacji na temat tworzenia i obsługi akcji i zestawów akcji, zobacz dokumentację HMAction i HMActionSet firmy Apple.
  • Wyzwalacze — wyzwalacz może aktywować co najmniej jeden zestaw akcji po spełnieniu określonego zestawu warunków. Na przykład włącz światło portowe i zablokuj wszystkie drzwi zewnętrzne, gdy zaciemni się na zewnątrz. Aby uzyskać więcej informacji na temat tworzenia i utrzymywania wyzwalaczy, zobacz dokumentację HMTrigger firmy Apple.

Ponieważ te funkcje korzystają z tych samych technik przedstawionych powyżej, powinny one być łatwe do zaimplementowania, postępując zgodnie z podręcznikiem HomeKitDeveloper firmy Apple, wytycznymi dotyczącymi interfejsu użytkownika zestawu HomeKit i dokumentacją struktury HomeKit.

Wytyczne dotyczące przeglądu aplikacji HomeKit

Przed przesłaniem aplikacji Xamarin.iOS z obsługą zestawu HomeKit do programu iTunes Połączenie do wydania w sklepie iTunes App Store upewnij się, że przestrzegasz wytycznych firmy Apple dotyczących aplikacji z obsługą zestawu HomeKit:

  • Głównym celem aplikacji musi być automatyzacja domowa w przypadku korzystania ze struktury HomeKit.
  • Tekst marketingowy aplikacji musi powiadamiać użytkowników, że jest używany zestaw HomeKit i musi podać zasady ochrony prywatności.
  • Zbieranie informacji o użytkowniku lub używanie zestawu HomeKit do reklam jest ściśle zabronione.

Aby zapoznać się z pełnymi wytycznymi dotyczącymi przeglądu, zobacz Wskazówki dotyczące przeglądu sklepu App Store firmy Apple.

Co nowego w systemie iOS 9

Firma Apple wprowadziła następujące zmiany i dodatki do zestawu HomeKit dla systemu iOS 9:

  • Obsługa istniejących obiektów — jeśli istniejąca akcesorium zostanie zmodyfikowana, Menedżer główny (HMHomeManager) poinformuje Cię o określonym elemencie, który został zmodyfikowany.
  • Identyfikatory trwałe — wszystkie odpowiednie klasy HomeKit zawierają teraz właściwość umożliwiającą UniqueIdentifier unikatowe zidentyfikowanie danego elementu w aplikacjach z obsługą zestawu HomeKit (lub wystąpień tej samej aplikacji).
  • Zarządzanie użytkownikami — dodano wbudowany kontroler widoku umożliwiający zarządzanie użytkownikami za pośrednictwem użytkowników, którzy mają dostęp do urządzeń HomeKit w domu użytkownika podstawowego.
  • Możliwości użytkownika — użytkownicy zestawu HomeKit mają teraz zestaw uprawnień, które kontrolują funkcje, których mogą używać w akcesoriach z obsługą zestawów HomeKit i HomeKit. Aplikacja powinna wyświetlać tylko odpowiednie możliwości dla bieżącego użytkownika. Na przykład tylko administratorzy powinni mieć możliwość obsługi innych użytkowników.
  • Wstępnie zdefiniowane sceny — wstępnie zdefiniowane sceny zostały utworzone dla czterech typowych zdarzeń występujących dla przeciętnego użytkownika Zestawu HomeKit: Get Up, Leave, Return, Go to Bed. Nie można usunąć tych wstępnie zdefiniowanych scen z domu.
  • Sceny i Siri — Siri ma głębszą obsługę scen w systemie iOS 9 i może rozpoznać nazwę dowolnej sceny zdefiniowanej w zestawie HomeKit. Użytkownik może wykonać scenę po prostu, mówiąc swoją nazwę siri.
  • Kategorie akcesoriów — zestaw wstępnie zdefiniowanych kategorii został dodany do wszystkich akcesoriów i pomaga zidentyfikować typ akcesoriów dodawanych do strony głównej lub pracował z poziomu aplikacji. Te nowe kategorie są dostępne podczas konfigurowania akcesoriów.
  • Obsługa zegarka Apple Watch — zestaw HomeKit jest teraz dostępny dla urządzeń z systemem watchOS, a zegarek Apple Watch będzie mógł kontrolować urządzenia z obsługą zestawu HomeKit bez urządzenia i Telefon zbliża się do zegarka. Zestaw HomeKit dla systemu watchOS obsługuje następujące możliwości: wyświetlanie domów, kontrolowanie akcesoriów i wykonywanie scen.
  • Nowy typ wyzwalacza zdarzeń — oprócz wyzwalaczy typu czasomierza obsługiwanych w systemie iOS 8 system iOS 9 obsługuje teraz wyzwalacze zdarzeń na podstawie stanu dostępu (np. danych czujnika) lub geolokalizacji. Wyzwalacze zdarzeń służą NSPredicates do ustawiania warunków ich wykonywania.
  • Dostęp zdalny — za pomocą dostępu zdalnego użytkownik może teraz kontrolować swoje akcesoria HomeKit z włączoną automatyzacją domową, gdy znajdują się z dala od domu w lokalizacji zdalnej. W systemie iOS 8 jest to obsługiwane tylko wtedy, gdy użytkownik miał urządzenie Apple TV drugiej generacji w domu. W systemie iOS 9 to ograniczenie zostało zniesione, a dostęp zdalny jest obsługiwany za pośrednictwem usług iCloud i HomeKit Accessory Protocol (HAP).
  • Nowe możliwości technologii Bluetooth Low Energy (BLE) — zestaw HomeKit obsługuje teraz więcej typów akcesoriów, które mogą komunikować się za pośrednictwem protokołu Bluetooth Low Energy (BLE). Za pomocą bezpiecznego tunelowania HAP akcesorium HomeKit może uwidocznić inną metodę dostępu Bluetooth przez sieć Wi-Fi (jeśli jest poza zasięgiem Bluetooth). W systemie iOS 9 akcesoria BLE mają pełną obsługę powiadomień i metadanych.
  • Nowe kategorie akcesoriów — Firma Apple dodała następujące nowe kategorie akcesoriów w systemie iOS 9: osłony okien, drzwi motoryzowane i windows, systemy alarmowe, czujniki i przełączniki programowalne.

Aby uzyskać więcej informacji na temat nowych funkcji zestawu HomeKit w systemie iOS 9, zobacz artykuł Apple HomeKit Index (Indeks HomeKit firmy Apple) i What's New in HomeKit (Co nowego w zestawie HomeKit).

Podsumowanie

Ten artykuł wprowadził platformę automatyzacji domu HomeKit firmy Apple. Pokazano w nim, jak skonfigurować i skonfigurować urządzenia testowe przy użyciu symulatora akcesoriów HomeKit oraz jak utworzyć prostą aplikację platformy Xamarin.iOS do odnajdywania, komunikowania się z urządzeniami automatyzacji domowej i sterowania nimi przy użyciu zestawu HomeKit.