Xamarin.iOS'ta HealthKit

Health Kit, kullanıcının sistem durumuyla ilgili bilgileri için güvenli bir veri deposu sağlar. Health Kit uygulamaları, kullanıcının açık izniyle bu veri deposuna okuma ve yazma yapabilir ve ilgili veriler eklendiğinde bildirim alabilir. Uygulamalar verileri sunabilir veya kullanıcılar tüm verilerinin bir panosunu görüntülemek için Apple'ın sağlanan Sistem Durumu uygulamasını kullanabilir.

Sağlıkla ilgili veriler çok hassas ve kritik olduğundan, Sağlık Seti ölçü birimleri ve kaydedilen bilgi türüyle (örneğin, kan şekeri düzeyi veya kalp hızı) açık bir ilişkilendirme ile kesin bir şekilde yazılır. Ayrıca, Health Kit uygulamalarının açık yetkilendirmeler kullanması, belirli bilgi türlerine erişim istemesi ve kullanıcının uygulamaya bu tür veriler için açıkça erişim vermesi gerekir.

Bu makale şunları tanıtır:

• Uygulama sağlama ve Sistem Durumu Seti veritabanına erişmek için kullanıcı izni isteme de dahil olmak üzere Health Kit'in güvenlik gereksinimleri;
• Verileri yanlış uygulama veya yanlış yorumlama olasılığını en aza indiren Health Kit'in tür sistemi;
• Paylaşılan, sistem genelindeki Health Kit veri deposuna yazma.

Bu makalede veritabanını sorgulama, ölçü birimleri arasında dönüştürme veya yeni veri bildirimleri alma gibi daha gelişmiş konular ele alınmaz.

Bu makalede, kullanıcının kalp atış hızını kaydetmek için örnek bir uygulama oluşturacağız:

Gereksinimler

Bu makalede sunulan adımları tamamlamak için aşağıdakiler gereklidir:

• Xcode 7 ve iOS 8 (veya üzeri) – Apple'ın en son Xcode ve iOS API'lerinin geliştiricinin bilgisayarına yüklenmesi ve yapılandırılması gerekir.
• Mac için Visual Studio veya Visual Studio – Mac için Visual Studio'ın en son sürümü geliştiricinin bilgisayarına yüklenip yapılandırılmalıdır.
• iOS 8 (veya üzeri) Cihaz – Test için iOS 8 veya üzerinin en son sürümünü çalıştıran bir iOS cihazı.

Önemli

Health Kit, iOS 8'de tanıtıldı. Şu anda, Sistem Durumu Seti iOS simülatöründe kullanılamaz ve hata ayıklama için fiziksel bir iOS cihazına bağlantı gerekir.

Sistem Durumu Seti Uygulaması Oluşturma ve Sağlama

Bir Xamarin iOS 8 uygulamasının HealthKit API'sini kullanabilmesi için doğru şekilde yapılandırılması ve sağlanması gerekir. Bu bölümde, Xamarin Uygulamanızı düzgün bir şekilde ayarlamak için gereken adımlar ele alınacaktır.

Health Kit uygulamaları şunları gerektirir:

• Açık bir Uygulama Kimliği.
• Bu açık Uygulama Kimliği ve Sistem Durumu Seti izinleriyle ilişkilendirilmiş bir Sağlama Profili.
• Entitlements.plist türüne Boolean ayarlanmış Yesbir com.apple.developer.healthkit özelliği olan bir.
• Info.plistUIRequiredDeviceCapabilities anahtarı değeriyle Stringhealthkitbir giriş içeren bir .
• ayrıca Info.plist uygun gizlilik açıklaması girdilerine de sahip olmalıdır: String uygulama veri yazacaksa anahtar NSHealthUpdateUsageDescription için bir açıklama ve uygulama Health Kit verilerini okuyacaksa anahtar NSHealthShareUsageDescription için bir String açıklama.

IOS uygulaması sağlama hakkında daha fazla bilgi edinmek için Xamarin'in Başlarken serisindeki Cihaz Sağlama makalesinde Geliştirici Sertifikaları, Uygulama Kimlikleri, Sağlama Profilleri ve Uygulama Yetkilendirmeleri arasındaki ilişki açıklanır.

Açık Uygulama Kimliği ve Sağlama Profili

Açık bir Uygulama Kimliği ve uygun Sağlama Profili oluşturma işlemi Apple'ın iOS Geliştirme Merkezi içinde gerçekleştirilir.

Geçerli Uygulama Kimlikleriniz, Geliştirme Merkezi Sertifikalar, Tanımlayıcılar ve Profiller bölümünde listelenir. Bu listede genellikle, Uygulama Kimliği Adı'nın*herhangi bir sayıda sonekle birlikte kullanılabileceğini belirten kimlik - değerleri gösterilir. Bu tür Joker Uygulama Kimlikleri Sistem Durumu Seti ile kullanılamaz.

Açık bir Uygulama Kimliği oluşturmak için sağ üstteki düğmeye tıklayarak + sizi iOS Uygulama Kimliğini Kaydet sayfasına götürün:

Yukarıdaki görüntüde gösterildiği gibi, uygulama açıklaması oluşturduktan sonra, uygulamanız için bir kimlik oluşturmak için Açık Uygulama Kimliği bölümünü kullanın. Uygulama Hizmetleri bölümünde, Hizmetleri Etkinleştir bölümünde Sistem Durumu Seti'niişaretleyin.

İşiniz bittiğinde, Uygulama Kimliğini hesabınıza kaydetmek için Devam düğmesine basın. Sertifikalar, Tanımlayıcılar ve Profiller sayfasına geri dönersiniz. Sizi geçerli sağlama profillerinizin listesine götürmek için Sağlama Profilleri'ne tıklayın ve sağ üst köşedeki düğmeye tıklayarak + iOS Sağlama Profili Ekle sayfasına gidin. iOS Uygulama Geliştirme seçeneğini belirleyin ve Uygulama Kimliği Seç sayfasına ulaşmak için Devam'atıklayın. Burada, daha önce belirttiğiniz açık Uygulama Kimliğini seçin:

Devam'a tıklayın ve kalan ekranlarda çalışın; burada Geliştirici Sertifikalarınızı, Cihazlarınızı ve bu Sağlama Profili için bir Ad belirtin:

Oluştur'a tıklayın ve profilinizin oluşturulmasını bekleyin. Dosyayı indirin ve Xcode'a yüklemek için çift tıklayın. Xcode > Tercihleri > Hesapları > Görünüm Ayrıntıları altında yüklemesini onaylayabilirsiniz... Yeni yüklenen sağlama profilinizi görmeniz ve Yetkilendirmeler satırında Health Kit simgesi ve diğer özel hizmetlere sahip olması gerekir:

Uygulama Kimliği ve Sağlama Profilini Xamarin.iOS Uygulamanızla İlişkilendirme

Açıklandığı gibi uygun bir Sağlama Profili oluşturup yükledikten sonra, normalde Mac için Visual Studio veya Visual Studio'da bir çözüm oluşturmanın zamanı geldi. Health Kit erişimi tüm iOS C# veya F# projelerine sağlanır.

El ile bir Xamarin iOS 8 projesi oluşturma işleminde izlenmek yerine, bu makaleye ekli örnek uygulamayı açın (önceden oluşturulmuş görsel taslak ve kod içerir). Örnek uygulamayı Health Kit özellikli Sağlama Profilinizle ilişkilendirmek için Çözüm Bölmesi'nde Projenize sağ tıklayın ve Seçenekler iletişim kutusunu açın. iOS Uygulama paneline geçin ve daha önce uygulamanın Paket Tanımlayıcısı olarak oluşturduğunuz açık Uygulama Kimliğini girin:

Şimdi iOS Paket İmzalama paneline geçin. Yakın zamanda yüklenen Sağlama Profiliniz, açık Uygulama Kimliği ile ilişkilendirildiğinde artık Sağlama Profili olarak kullanılabilir:

Sağlama Profili kullanılamıyorsa, iOS Uygulama panelinde paket tanımlayıcısınıiOS Geliştirme Merkezi belirtilene ve Sağlama Profili'ninyüklü olup olmadığını (Xcode > Tercihleri > Hesapları > Ayrıntıları Görüntüle...) iki kez denetleyin.

Sistem Durumu Seti etkin Sağlama Profili seçildiğinde, Tamam'a tıklayarak Proje Seçenekleri iletişim kutusunu kapatın.

Entitlements.plist ve Info.plist Değerleri

Örnek uygulama bir Entitlements.plist dosya (Sistem Durumu Seti özellikli uygulamalar için gereklidir) içerir ve her Proje Şablonuna dahil değildir. Projeniz yetkilendirme içermiyorsa, projenize sağ tıklayın, el ile eklemek için Dosya Yeni Dosya... iOS > Yetkilendirmeleri.plist öğesini seçin>. >

Sonuç olarak, aşağıdaki anahtar ve değer çiftinize Entitlements.plist sahip olmanız gerekir:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.developer.HealthKit</key>
    <true/>
</dict>
</plist>

Benzer şekilde, Info.plist uygulama için değerinin healthkit anahtarla UIRequiredDeviceCapabilities ilişkilendirilmiş olması gerekir:

<key>UIRequiredDeviceCapabilities</key>
<array>
<string>armv7</string>
    <string>healthkit</string>
</array>

Bu makalede sağlanan örnek uygulama, tüm gerekli anahtarları içeren önceden yapılandırılmış Entitlements.plist bir uygulama içerir.

Programlama Sistem Durumu Seti

Health Kit veri deposu, uygulamalar arasında paylaşılan özel, kullanıcıya özgü bir veri deposudur. Sistem durumu bilgileri çok hassas olduğundan, kullanıcının veri erişimine izin vermek için olumlu adımlar atması gerekir. Bu erişim kısmi (yazma ama okumama, bazı veri türleri için erişim, diğerleri için değil vb.) olabilir ve herhangi bir zamanda iptal edilebilir. Sağlık Seti uygulamaları, birçok kullanıcının sağlıkla ilgili bilgilerini depolama konusunda tereddütlü olacağı anlayışıyla savunma amaçlı yazılmalıdır.

Health Kit verileri Apple'ın belirtilen türleriyle sınırlıdır. Bu türler kesinlikle tanımlanmıştır: kan grubu gibi bazıları, Apple tarafından sağlanan bir numaralandırmanın belirli değerleriyle sınırlıdırken, diğerleri bir büyüklüğü bir ölçü birimiyle (gram, kalori ve litre gibi) birleştirir. Uyumlu bir ölçü birimini paylaşan veriler bile kendileriyle ayırt edilirHKObjectType; örneğin, tür sistemi, her ikisi de ölçü birimini kullansa HKUnit.Count bile bir alana değer depolamaya HKQuantityTypeIdentifier.NumberOfTimesFallen yönelik hatalı bir HKQuantityTypeIdentifier.FlightsClimbed girişim yakalar.

Health Kit veri deposundaki tarihlenebilen türlerin tümü alt sınıflarıdır HKObjectType. HKCharacteristicType nesneler Biyolojik Cinsiyet, Kan Grubu ve Doğum Tarihi depolar. Ancak daha yaygın olarak, HKSampleType belirli bir zamanda veya belirli bir süre içinde örneklenen verileri temsil eden nesnelerdir.

HKSampleType soyut olup dört somut alt sınıfı vardır. Şu anda yalnızca bir veri türü HKCategoryType vardır ve bu da Uyku Analizi'dir. Health Kit'teki verilerin büyük çoğunluğu türündedir HKQuantityType ve verilerini tanıdık Fabrika tasarım deseni kullanılarak oluşturulan nesnelerde HKQuantitySample depolar:

HKQuantityType türleri ile HKQuantityTypeIdentifier.ActiveEnergyBurnedHKQuantityTypeIdentifier.StepCountarasında değişir.

Kullanıcıdan İzin İsteme

Son kullanıcıların bir uygulamanın Health Kit verilerini okumasına veya yazmasına izin vermek için olumlu adımlar atması gerekir. Bu, iOS 8 cihazlarında önceden yüklenmiş olarak gelen Health uygulaması aracılığıyla yapılır. Bir Sistem Durumu Seti uygulaması ilk kez çalıştırıldığında, kullanıcıya sistem denetiminde bir Sistem Durumu Erişimi iletişim kutusu sunulur:

Daha sonra kullanıcı, Sistem Durumu uygulamasının Kaynaklar iletişim kutusunu kullanarak izinleri değiştirebilir:

Sistem durumu bilgileri son derece hassas olduğundan, uygulama geliştiricilerin uygulama çalışırken izinlerin reddedileceği ve değiştirileceği beklentisiyle programlarını savunmalı bir şekilde yazmaları gerekir. En yaygın deyim yönteminde UIApplicationDelegate.OnActivated izin istemek ve ardından kullanıcı arabirimini uygun şekilde değiştirmektir.

İzinler İzlenecek Yol

Health Kit tarafından sağlanan projenizde dosyayı açın AppDelegate.cs . dosyasının üst kısmındaki öğesini kullanarak HealthKitdeyimine dikkat edin.

Aşağıdaki kod Sistem Durumu Seti izinleriyle ilgilidir:

private HKHealthStore healthKitStore = new HKHealthStore ();

public override void OnActivated (UIApplication application)
{
        base.OnActivated(application);
        ValidateAuthorization ();
}

private void ValidateAuthorization ()
{
        var heartRateId = HKQuantityTypeIdentifierKey.HeartRate;
        var heartRateType = HKObjectType.GetQuantityType (heartRateId);
        var typesToWrite = new NSSet (new [] { heartRateType });
        var typesToRead = new NSSet ();
        healthKitStore.RequestAuthorizationToShare (
                typesToWrite, 
                typesToRead, 
                ReactToHealthCarePermissions);
}

void ReactToHealthCarePermissions (bool success, NSError error)
{
        var access = healthKitStore.GetAuthorizationStatus (HKObjectType.GetQuantityType (HKQuantityTypeIdentifierKey.HeartRate));
        if (access.HasFlag (HKAuthorizationStatus.SharingAuthorized)) {
                HeartRateModel.Instance.Enabled = true;
        } else {
                HeartRateModel.Instance.Enabled = false;
        }
}

Bu yöntemlerdeki tüm kodlar içinde OnActivatedsatır içinde yapılabilir, ancak örnek uygulama amaçlarını daha net hale getirmek için ayrı yöntemler kullanır: ValidateAuthorization() yazılan belirli türlere erişim istemek için gerekli adımları içerir (ve uygulama istenirse okunur) ve ReactToHealthCarePermissions() kullanıcı Health.app izinler iletişim kutusuyla etkileşime geçtikten sonra etkinleştirilen bir geri çağırmadır.

görevi ValidateAuthorization() , uygulamanın bu verileri güncelleştirmek için yazacağı ve yetkilendirme istediği kümeyi HKObjectTypes oluşturmaktır. Örnek uygulamada anahtarına HKObjectTypeKHQuantityTypeIdentifierKey.HeartRateyöneliktir. Bu tür kümesine eklenirken, typesToWriteküme typesToRead boş bırakılır. Bu kümeler ve geri çağırma başvurusu ReactToHealthCarePermissions() öğesine HKHealthStore.RequestAuthorizationToShare()geçirilir.

Geri ReactToHealthCarePermissions() arama, kullanıcı izinler iletişim kutusuyla etkileşime geçtikten ve iki bilgi parçası geçirildikten sonra çağrılır: bool kullanıcı izinler iletişim kutusuyla etkileşime geçtiğinde kullanılacak true bir değer ve null değilse, izinler iletişim kutusunun sunulmasıyla ilişkili bir tür hata olduğunu gösteren bir NSError değer.

Önemli

Bu işlevin bağımsız değişkenleri hakkında net olmak için: başarı ve hata parametreleri kullanıcının Health Kit verilerine erişim izni verip vermediğini göstermez! Yalnızca kullanıcıya verilere erişim izni verme fırsatı verildiğini gösterir.

Uygulamanın verilere HKHealthStore.GetAuthorizationStatus() erişimi olup olmadığını onaylamak için kullanılır ve iletir HKQuantityTypeIdentifierKey.HeartRate. Döndürülen duruma bağlı olarak, uygulama veri girme özelliğini etkinleştirir veya devre dışı bırakır. Erişim reddiyle başa çıkmak için standart bir kullanıcı deneyimi yoktur ve birçok olası seçenek vardır. Örnek uygulamada durum, ilgili olayları oluşturan tekil bir HeartRateModel nesnede ayarlanır.

Model, Görünüm ve Denetleyici

Tekil HeartRateModel nesneyi gözden geçirmek için dosyasını açın HeartRateModel.cs :

using System;
using HealthKit;
using Foundation;

namespace HKWork
{
        public class GenericEventArgs<T> : EventArgs
        {
                public T Value { get; protected set; }
                public DateTime Time { get; protected set; }

                public GenericEventArgs (T value)
                {
                        this.Value = value;
                        Time = DateTime.Now;
                }
        }

        public delegate void GenericEventHandler<T> (object sender,GenericEventArgs<T> args);

        public sealed class HeartRateModel : NSObject
        {
                private static volatile HeartRateModel singleton;
                private static object syncRoot = new Object ();

                private HeartRateModel ()
                {
                }

                public static HeartRateModel Instance {
                        get {
                                //Double-check lazy initialization
                                if (singleton == null) {
                                        lock (syncRoot) {
                                                if (singleton == null) {
                                                        singleton = new HeartRateModel ();
                                                }
                                        }
                                }

                                return singleton;
                        }
                }

                private bool enabled = false;

                public event GenericEventHandler<bool> EnabledChanged;
                public event GenericEventHandler<String> ErrorMessageChanged;
                public event GenericEventHandler<Double> HeartRateStored;

                public bool Enabled { 
                        get { return enabled; }
                        set {
                                if (enabled != value) {
                                        enabled = value;
                                        InvokeOnMainThread(() => EnabledChanged (this, new GenericEventArgs<bool>(value)));
                                }
                        }
                }

                public void PermissionsError(string msg)
                {
                        Enabled = false;
                        InvokeOnMainThread(() => ErrorMessageChanged (this, new GenericEventArgs<string>(msg)));
                }

                //Converts its argument into a strongly-typed quantity representing the value in beats-per-minute
                public HKQuantity HeartRateInBeatsPerMinute(ushort beatsPerMinute)
                {
                        var heartRateUnitType = HKUnit.Count.UnitDividedBy (HKUnit.Minute);
                        var quantity = HKQuantity.FromQuantity (heartRateUnitType, beatsPerMinute);

                        return quantity;
                }
                        
                public void StoreHeartRate(HKQuantity quantity)
                {
                        var bpm = HKUnit.Count.UnitDividedBy (HKUnit.Minute);
                        //Confirm that the value passed in is of a valid type (can be converted to beats-per-minute)
                        if (! quantity.IsCompatible(bpm))
                        {
                                InvokeOnMainThread(() => ErrorMessageChanged(this, new GenericEventArgs<string> ("Units must be compatible with BPM")));
                        }

                        var heartRateId = HKQuantityTypeIdentifierKey.HeartRate;
                        var heartRateQuantityType = HKQuantityType.GetQuantityType (heartRateId);
                        var heartRateSample = HKQuantitySample.FromType (heartRateQuantityType, quantity, new NSDate (), new NSDate (), new HKMetadata());

                        using (var healthKitStore = new HKHealthStore ()) {
                                healthKitStore.SaveObject (heartRateSample, (success, error) => {
                                        InvokeOnMainThread (() => {
                                                if (success) {
                                                        HeartRateStored(this, new GenericEventArgs<Double>(quantity.GetDoubleValue(bpm)));
                                                } else {
                                                        ErrorMessageChanged(this, new GenericEventArgs<string>("Save failed"));
                                                }
                                                if (error != null) {
                                                        //If there's some kind of error, disable 
                                                        Enabled = false;
                                                        ErrorMessageChanged (this, new GenericEventArgs<string>(error.ToString()));
                                                }
                                        });
                                });
                        }
                }
        }
}

İlk bölüm, genel olaylar ve işleyiciler oluşturmak için ortak koddur. Sınıfın HeartRateModel ilk bölümü, iş parçacığı güvenli tekil bir nesne oluşturmak için de ortaktır.

HeartRateModel Ardından 3 olayı kullanıma sunar:

• EnabledChanged - Kalp atış hızı depolamanın etkinleştirildiğini veya devre dışı bırakıldığını gösterir (depolamanın başlangıçta devre dışı bırakıldığını unutmayın).
• ErrorMessageChanged - Bu örnek uygulama için çok basit bir hata işleme modelimiz var: son hataya sahip bir dize.
• HeartRateStored - Kalp atış hızı Sağlık Seti veritabanında depolandığında yükseltilir.

Bu olaylar her tetiklendiğinde, abonelerin kullanıcı arabirimini güncelleştirmesine olanak tanıyan aracılığıyla NSObject.InvokeOnMainThread()yapıldığını unutmayın. Alternatif olarak, olaylar arka plan iş parçacıklarında ortaya çıkarıldığı ve uyumluluğun işleyicilerine bırakılabilmesini sağlama sorumluluğu olarak belgelenebilir. İzin isteği gibi işlevlerin çoğu zaman uyumsuz olduğundan ve ana olmayan iş parçacıklarında geri çağırmalarını yürüttüğünden, sistem durumu seti uygulamalarında iş parçacığı konuları önemlidir.

içindeki Heath Kit'e HeartRateModel özgü kod ve StoreHeartRate()işlevlerindedirHeartRateInBeatsPerMinute().

HeartRateInBeatsPerMinute() bağımsız değişkenini kesin türü belirlenmiş bir Health Kit'e HKQuantitydönüştürür. Miktarın türü, ile belirtilen HKQuantityTypeIdentifierKey.HeartRate ve miktarın HKUnit.Count birimleri tarafından bölünür HKUnit.Minute (başka bir deyişle, birim dakika başına atılır).

StoreHeartRate() işlevi bir HKQuantity alır (örnek uygulamada, tarafından HeartRateInBeatsPerMinute() oluşturulan bir). Verilerini doğrulamak için, nesnesinin HKQuantity.IsCompatible() birimleri bağımsız değişkendeki birimlere dönüştürülebilirse döndüren true yöntemini kullanır. Miktar bununla HeartRateInBeatsPerMinute() oluşturulduysa, açıkça döndürürtrue, ancak miktar örneğin Saat Başına Beats olarak oluşturulduysa da döndürülecektirtrue. Daha yaygın olarak, HKQuantity.IsCompatible() kullanıcının veya cihazın bir ölçü sisteminde (örneğin emperyal birimler) giriş yapıp görüntüleyebileceği ancak başka bir sistemde (ölçüm birimleri gibi) depolanabileceği kütle, mesafe ve enerjiyi doğrulamak için kullanılabilir.

Miktarın uyumluluğu doğrulandıktan sonra, HKQuantitySample.FromType() fabrika yöntemi güçlü türe heartRateSample sahip bir nesne oluşturmak için kullanılır. HKSample nesnelerin başlangıç ve bitiş tarihi vardır; anlık okumalar için bu değerlerin örnekteki değerlerle aynı olması gerekir. Örnek ayrıca bağımsız değişkeninde herhangi bir anahtar-değer verisi HKMetadata ayarlamaz, ancak algılayıcı konumunu belirtmek için aşağıdaki kod gibi bir kod kullanılabilir:

var hkm = new HKMetadata();
hkm.HeartRateSensorLocation = HKHeartRateSensorLocation.Chest;

heartRateSample oluşturulduktan sonra kod, using bloğuyla veritabanına yeni bir bağlantı oluşturur. Bu blok içinde HKHealthStore.SaveObject() yöntemi, veritabanına zaman uyumsuz yazma işlemini dener. Lambda ifadesine yapılan sonuç çağrısı, HeartRateStored veya ErrorMessageChangedilgili olayları tetikler.

Model programlandıklarına göre denetleyicinin modelin durumunu nasıl yansıttığını görmenin zamanı geldi. HKWorkViewController.cs dosyasını açın. Oluşturucu tekliyi HeartRateModel olay işleme yöntemlerine bağlar (yine, bu lambda ifadeleriyle satır içi olarak yapılabilir, ancak ayrı yöntemler amacı biraz daha belirgin hale getirir):

public HKWorkViewController (IntPtr handle) : base (handle)
{
     HeartRateModel.Instance.EnabledChanged += OnEnabledChanged;
     HeartRateModel.Instance.ErrorMessageChanged += OnErrorMessageChanged;
     HeartRateModel.Instance.HeartRateStored += OnHeartBeatStored;
}

İlgili işleyiciler şunlardır:

void OnEnabledChanged (object sender, GenericEventArgs<bool> args)
{
        StoreData.Enabled = args.Value;
        PermissionsLabel.Text = args.Value ? "Ready to record" : "Not authorized to store data.";
        PermissionsLabel.SizeToFit ();
}

void OnErrorMessageChanged (object sender, GenericEventArgs<string> args)
{
        PermissionsLabel.Text = args.Value;
}

void OnHeartBeatStored (object sender, GenericEventArgs<double> args)
{
        PermissionsLabel.Text = String.Format ("Stored {0} BPM", args.Value);
}

Açıkçası, tek denetleyicili bir uygulamada, ayrı bir model nesnesi oluşturulmasını ve denetim akışı için olayların kullanılmasını önlemek mümkün olabilir, ancak model nesnelerinin kullanımı gerçek dünya uygulamaları için daha uygundur.

Örnek uygulamayı çalıştırma

iOS Simülatörü Health Kit'i desteklemez. Hata ayıklama, iOS 8 çalıştıran bir fiziksel cihazda yapılmalıdır.

Sisteminize düzgün şekilde sağlanan bir iOS 8 geliştirme cihazı takın. Mac için Visual Studio dağıtım hedefi olarak seçin ve menüden Hata Ayıklamayı Çalıştır'ı > seçin.

Önemli

Sağlamayla ilgili hatalar bu noktada ortaya çıkacaktır. Hataları gidermek için yukarıdaki Sistem Durumu Seti Uygulaması Oluşturma ve Sağlama bölümünü gözden geçirin. Bileşenler şunlardır:

• iOS Geliştirme Merkezi - Açık Uygulama Kimliği ve Sistem Durumu Seti etkin Sağlama Profili.
• Proje Seçenekleri - Paket Tanımlayıcısı (açık Uygulama Kimliği) ve Sağlama Profili.
• Kaynak kodu - Entitlements.plist & Info.plist

Sağlamaların düzgün ayarlandığını varsayarsak uygulamanız başlatılır. Yöntemine OnActivated ulaştığında, Sistem Durumu Seti yetkilendirmesi isteyecektir. bu durum işletim sistemi tarafından ilk kez karşılaştığında, kullanıcınıza aşağıdaki iletişim kutusu gösterilir:

Uygulamanızın Kalp Atış Hızı verilerini güncelleştirmesini sağladığınızda uygulamanız yeniden görünür. Geri ReactToHealthCarePermissions çağırma zaman uyumsuz olarak etkinleştirilir. Bu, özelliğin HeartRateModel’sEnabled değişmesine neden olur ve bu da olayı tetikler EnabledChanged ve bu da olay işleyicisinin HKPermissionsViewController.OnEnabledChanged() çalışmasına neden olur ve bu da düğmeyi StoreData etkinleştirir. Aşağıdaki diyagramda sıra gösterilmektedir:

Kaydet düğmesine basın. Bu, işleyicinin StoreData_TouchUpInside() çalışmasına neden olur ve bu da metin alanının değerini heartRate ayrıştırmaya çalışır, daha önce tartışılan HeartRateModel.HeartRateInBeatsPerMinute() işlev aracılığıyla a'ya HKQuantity dönüştürülür ve bu miktarı öğesine HeartRateModel.StoreHeartRate()geçirir. Daha önce açıklandığı gibi, bu işlem verileri depolamaya çalışır ve bir HeartRateStored veya ErrorMessageChanged olayı tetikler.

Cihazınızda Giriş düğmesine çift tıklayın ve Sistem Durumu uygulamasını açın. Kaynaklar sekmesine tıkladığınızda örnek uygulamanın listelendiğini görürsünüz. Bunu seçin ve kalp atış hızı verilerini güncelleştirme iznini geri verin. Giriş düğmesine çift tıklayın ve uygulamanıza geri dönün. Bir kez daha ReactToHealthCarePermissions() çağrılır, ancak bu kez erişim reddedildiğinden StoreData düğmesi devre dışı bırakılır (bunun zaman uyumsuz olarak gerçekleştiğini ve kullanıcı arabirimindeki değişikliğin son kullanıcı tarafından görülebileceğini unutmayın).

İleri Düzey Konular

Health Kit veritabanından veri okumak, veri yazmaya çok benzer: Biri erişmeye çalıştığı veri türlerini belirtir, yetkilendirme ister ve bu yetkilendirme verilirse, veriler kullanılabilir ve uyumlu ölçü birimlerine otomatik dönüştürme yapılır.

İlgili veriler güncelleştirildiğinde güncelleştirmeler gerçekleştiren koşul tabanlı sorgulara ve sorgulara olanak tanıyan bir dizi daha karmaşık sorgu işlevi vardır.

Health Kit uygulamaları geliştiricileri, Apple'ın Uygulama İnceleme Yönergeleri'nin Health Kit bölümünü gözden geçirmelidir.

Güvenlik ve tür sistemi modelleri anlaşıldıktan sonra, paylaşılan Health Kit veritabanında verileri depolamak ve okumak oldukça basittir. Health Kit'in içindeki işlevlerin çoğu zaman uyumsuz olarak çalışır ve uygulama geliştiricilerin programlarını uygun şekilde yazması gerekir.

Bu makalenin yazıldığından itibaren, şu anda Android veya Windows Telefon'da Health Kit ile eşdeğer bir değer yoktur.

Özet

Bu makalede, Health Kit'in uygulamaların sistem durumuyla ilgili bilgileri depolamasına, almasına ve paylaşmasına nasıl olanak sağladığını ve aynı zamanda kullanıcının bu veriler üzerinde erişim ve denetim sahibi olmasına olanak tanıyan standart bir Sistem Durumu uygulaması sağladığını gördük.

Ayrıca, Sağlık Seti'ni kullanan gizlilik, güvenlik ve veri bütünlüğünün sistem durumuyla ilgili bilgi ve uygulamalarla ilgili endişeleri nasıl geçersiz kılıp uygulama yönetimi (sağlama), kodlama (Health Kit'in tür sistemi) ve kullanıcı deneyimindeki (sistem iletişim kutuları ve Sistem durumu uygulaması aracılığıyla izinlerin kullanıcı denetimi) karmaşıklığıyla başa çıkabilmesi gerektiğini gördük.

Son olarak, Health Kit deposuna sinyal verileri yazan ve zaman uyumsuz olarak algılayan bir tasarıma sahip olan örnek uygulamayı kullanarak Health Kit'in basit bir uygulamasına göz attık.

İlişkili Bağlantılar

• iOS 8’e Giriş