HealthKit in Xamarin.iOS

Health Kit fornisce un archivio dati sicuro per le informazioni correlate all'integrità dell'utente. Le app di Health Kit possono, con l'autorizzazione esplicita dell'utente, leggere e scrivere in questo archivio dati e ricevere notifiche quando vengono aggiunti dati pertinenti. Le app possono presentare i dati oppure l'utente può usare l'app Integrità fornita da Apple per visualizzare un dashboard di tutti i dati.

Poiché i dati relativi alla salute sono così sensibili e cruciali, Health Kit è fortemente tipizzato, con unità di misura e un'associazione esplicita con il tipo di informazioni registrate (ad esempio, livello di glucosio nel sangue o frequenza cardiaca). Inoltre, le app di Health Kit devono usare diritti espliciti, devono richiedere l'accesso ai tipi specifici di informazioni e l'utente deve concedere esplicitamente all'app l'accesso a tali tipi di dati.

Questo articolo presenta:

• Requisiti di sicurezza di Health Kit, tra cui il provisioning delle applicazioni e la richiesta dell'autorizzazione utente per accedere al database di Health Kit;
• Sistema di tipi di Health Kit, che riduce al minimo la possibilità di applicazione errata o di interpretazione errata dei dati;
• Scrittura nell'archivio dati di Health Kit condiviso e a livello di sistema.

Questo articolo non illustra argomenti più avanzati, ad esempio l'esecuzione di query sul database, la conversione tra unità di misura o la ricezione di notifiche di nuovi dati.

In questo articolo verrà creata un'applicazione di esempio per registrare la frequenza cardiaca dell'utente:

Requisiti

Per completare i passaggi presentati in questo articolo, è necessario quanto segue:

• Xcode 7 e iOS 8 (o versione successiva): le API Xcode e iOS più recenti di Apple devono essere installate e configurate nel computer dello sviluppatore.
• Visual Studio per Mac o Visual Studio: la versione più recente di Visual Studio per Mac deve essere installata e configurata nel computer dello sviluppatore.
• Dispositivo iOS 8 (o versione successiva): un dispositivo iOS che esegue la versione più recente di iOS 8 o versione successiva per i test.

Importante

Health Kit è stato introdotto in iOS 8. Attualmente Health Kit non è disponibile nel simulatore iOS e il debug richiede la connessione a un dispositivo iOS fisico.

Creazione e provisioning di un'app health kit

Prima che un'applicazione Xamarin iOS 8 possa usare l'API HealthKit, deve essere configurata ed eseguita correttamente il provisioning. Questa sezione illustra i passaggi necessari per configurare correttamente l'applicazione Xamarin.

Le app di Health Kit richiedono:

• ID app esplicito.
• Profilo di provisioning associato all'ID app esplicito e alle autorizzazioni di Health Kit.
• Oggetto Entitlements.plist con una com.apple.developer.healthkit proprietà di tipo Boolean impostato su Yes.
• Oggetto Info.plist la cui UIRequiredDeviceCapabilities chiave contiene una voce con il String valore healthkit.
• Deve Info.plist anche avere voci appropriate di spiegazione della privacy: una String spiegazione per la chiave NSHealthUpdateUsageDescription se l'app scriverà i dati e una String spiegazione per la chiave NSHealthShareUsageDescription se l'app leggerà i dati di Health Kit.

Per altre informazioni sul provisioning di un'app iOS, l'articolo Device Provisioning nella serie introduttiva di Xamarin descrive la relazione tra certificati per sviluppatori, ID app, profili di provisioning e entitlement delle app.

ID app esplicito e profilo di provisioning

La creazione di un ID app esplicito e un profilo di provisioning appropriato viene eseguita all'interno di iOS Dev Center di Apple.

Gli ID app correnti sono elencati nella sezione Certificati, Identificatori e profili di Dev Center. Spesso, questo elenco mostrerà i valori ID di *, a indicare che il nome ID - app può essere usato con un numero qualsiasi di suffissi. Tali ID app con caratteri jolly non possono essere usati con Health Kit.

Per creare un ID app esplicito, fare clic sul + pulsante in alto a destra per visualizzare la pagina Registra ID app iOS:

Come illustrato nell'immagine precedente, dopo aver creato una descrizione dell'app, usare la sezione EXPLICIT App ID (ID app esplicito) per creare un ID per l'applicazione. Nella sezione servizio app s selezionare Health Kit nella sezione Abilita servizi.

Al termine, premere il pulsante Continua per registrare l'ID app nell'account. Si tornerà alla pagina Certificati, Identificatori e Profili . Fare clic su Profili di provisioning per passare all'elenco dei profili di provisioning correnti e fare clic sul + pulsante nell'angolo in alto a destra per passare alla pagina Aggiungi profilo di provisioning iOS. Selezionare l'opzione Sviluppo app iOS e fare clic su Continua per passare alla pagina Seleziona ID app. Selezionare qui l'ID app esplicito specificato in precedenza:

Fare clic su Continua ed esaminare le schermate rimanenti, in cui verranno specificati i certificati per sviluppatori, i dispositivi e un nome per questo profilo di provisioning:

Fare clic su Genera e attendere la creazione del profilo. Scaricare il file e fare doppio clic su di esso per installarlo in Xcode. È possibile confermare che l'installazione è in Xcode > Preferenze > Account > Visualizza dettagli... Dovrebbe essere visualizzato il profilo di provisioning appena installato e dovrebbe avere l'icona per Health Kit e qualsiasi altro servizio speciale nella riga Entitlement:

Associazione dell'ID app e del profilo di provisioning all'app Xamarin.iOS

Dopo aver creato e installato un profilo di provisioning appropriato come descritto, in genere sarebbe il momento di creare una soluzione in Visual Studio per Mac o Visual Studio. L'accesso a Health Kit è disponibile per qualsiasi progetto IOS C# o F#.

Invece di esaminare il processo di creazione di un progetto Xamarin iOS 8 a mano, aprire l'app di esempio collegata a questo articolo (che include uno Storyboard predefinito e un codice). Per associare l'app di esempio al profilo di provisioning abilitato per Health Kit, nel riquadro della soluzione fare clic con il pulsante destro del mouse sul progetto e visualizzarne la finestra di dialogo Opzioni. Passare al pannello Applicazione iOS e immettere l'ID app esplicito creato in precedenza come identificatore bundle dell'app:

Passare ora al pannello Firma bundle iOS. Il profilo di provisioning installato di recente, con l'associazione all'ID app esplicito, sarà ora disponibile come profilo di provisioning:

Se il profilo di provisioning non è disponibile, controllare attentamente l'identificatore del bundle nel pannello dell'applicazione iOS rispetto a quello specificato in iOS Dev Center e che il profilo di provisioning è installato (Xcode > Preferences > Accounts > View Details...).

Quando il profilo di provisioning abilitato per Health Kit è selezionato, fare clic su OK per chiudere la finestra di dialogo Opzioni progetto.

Valori Entitlements.plist e Info.plist

L'app di esempio include un Entitlements.plist file (necessario per le app abilitate per Health Kit) e non incluso in ogni modello di progetto. Se il progetto non include diritti, fare clic con il pulsante destro del mouse sul progetto, scegliere File > nuovo file... > iOS > Entitlements.plist per aggiungerlo manualmente.

In definitiva, l'utente Entitlements.plist deve avere la coppia chiave e valore seguente:

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

Analogamente, per Info.plist l'app deve essere associato un valore healthkit alla UIRequiredDeviceCapabilities chiave:

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

L'applicazione di esempio fornita con questo articolo include un preconfigurato Entitlements.plist che include tutte le chiavi necessarie.

Programming Health Kit

L'archivio dati di Health Kit è un archivio dati privato specifico dell'utente condiviso tra le app. Poiché le informazioni sull'integrità sono così sensibili, l'utente deve eseguire passaggi positivi per consentire l'accesso ai dati. Questo accesso può essere parziale (scrittura ma non lettura, accesso per alcuni tipi di dati, ma non altri e così via) e può essere revocato in qualsiasi momento. Le applicazioni di Health Kit devono essere scritte in modo difensivo, con la consapevolezza che molti utenti saranno insita nell'archiviare le informazioni correlate all'integrità.

I dati di Health Kit sono limitati ai tipi specificati da Apple. Questi tipi sono rigorosamente definiti: alcuni, come il tipo di sangue, sono limitati ai valori particolari di un'enumerazione fornita da Apple, mentre altri combinano una grandezza con un'unità di misura (come grammi, calorie e litri). Anche i dati che condividono un'unità di misura compatibile sono distinti in base al relativo HKObjectType; ad esempio, il sistema di tipi intercetta un tentativo errato di archiviare un HKQuantityTypeIdentifier.NumberOfTimesFallen valore in un campo previsto HKQuantityTypeIdentifier.FlightsClimbed anche se entrambi usano l'unità HKUnit.Count di misura.

I tipi storable nell'archivio dati di Health Kit sono tutte sottoclassi di HKObjectType. HKCharacteristicType gli oggetti archivia sesso biologico, tipo di sangue e data di nascita. Più comune, tuttavia, sono HKSampleType oggetti che rappresentano i dati campionati in un momento specifico o in un periodo di tempo.

HKSampleType è astratto e ha quattro sottoclassi concrete. Attualmente esiste un solo tipo di HKCategoryType dati, ovvero Analisi sospensione. La maggior parte dei dati in Health Kit è di tipo HKQuantityType e archivia i dati in HKQuantitySample oggetti, creati usando il modello di progettazione factory familiare:

HKQuantityType I tipi vanno da HKQuantityTypeIdentifier.ActiveEnergyBurned a HKQuantityTypeIdentifier.StepCount.

Richiesta dell'autorizzazione dall'utente

Gli utenti finali devono eseguire passaggi positivi per consentire a un'app di leggere o scrivere dati di Health Kit. Questa operazione viene eseguita tramite l'app Integrità preinstallata nei dispositivi iOS 8. La prima volta che viene eseguita un'app Health Kit, all'utente viene visualizzata una finestra di dialogo di accesso all'integrità controllata dal sistema:

Successivamente, l'utente può modificare le autorizzazioni usando la finestra di dialogo Origini dell'app integrità:

Poiché le informazioni sull'integrità sono estremamente sensibili, gli sviluppatori di app devono scrivere i propri programmi in modo difensivo, con l'aspettativa che le autorizzazioni vengano rifiutate e modificate durante l'esecuzione dell'app. Il linguaggio più comune consiste nel richiedere le autorizzazioni nel UIApplicationDelegate.OnActivated metodo e quindi modificare l'interfaccia utente in base alle esigenze.

Procedura dettagliata per le autorizzazioni

Nel progetto di cui è stato effettuato il provisioning di Health Kit aprire il AppDelegate.cs file. Si noti l'istruzione che usa HealthKit; all'inizio del file.

Il codice seguente è correlato alle autorizzazioni di Health Kit:

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

Tutto il codice in questi metodi può essere eseguito inline in OnActivated, ma l'app di esempio usa metodi separati per rendere più chiara la finalità: ValidateAuthorization() ha i passaggi necessari per richiedere l'accesso ai tipi specifici scritti (e letti, se l'app desiderata) ed ReactToHealthCarePermissions() è un callback attivato dopo che l'utente ha interagito con la finestra di dialogo delle autorizzazioni nel Health.app.

Il processo di ValidateAuthorization() consiste nel compilare il set di HKObjectTypes che l'app scriverà e richiederà l'autorizzazione per aggiornare tali dati. Nell'app di esempio, è HKObjectType per la chiave KHQuantityTypeIdentifierKey.HeartRate. Questo tipo viene aggiunto al set typesToWrite, mentre il set typesToRead viene lasciato vuoto. Questi set e un riferimento al ReactToHealthCarePermissions() callback vengono passati a HKHealthStore.RequestAuthorizationToShare().

Il ReactToHealthCarePermissions() callback verrà chiamato dopo che l'utente ha interagito con la finestra di dialogo delle autorizzazioni e viene passato due informazioni: un bool valore che sarà true se l'utente ha interagito con la finestra di dialogo delle autorizzazioni e un oggetto NSError che, se non Null, indica un tipo di errore associato alla presentazione della finestra di dialogo delle autorizzazioni.

Importante

Per essere chiari sugli argomenti di questa funzione: i parametri di esito positivo e di errore non indicano se l'utente ha concesso l'autorizzazione per accedere ai dati di Health Kit. Indicano solo che all'utente è stata data la possibilità di consentire l'accesso ai dati.

Per verificare se l'app ha accesso ai dati, viene usato , HKHealthStore.GetAuthorizationStatus() passando HKQuantityTypeIdentifierKey.HeartRate. In base allo stato restituito, l'app abilita o disabilita la possibilità di immettere i dati. Non esiste un'esperienza utente standard per la gestione di un rifiuto dell'accesso e sono disponibili molte opzioni possibili. Nell'app di esempio lo stato viene impostato su un HeartRateModel oggetto singleton che, a sua volta, genera eventi rilevanti.

Modello, visualizzazione e controller

Per esaminare l'oggetto HeartRateModel singleton, aprire il HeartRateModel.cs file:

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

La prima sezione è il codice boilerplate per la creazione di eventi e gestori generici. Anche la parte iniziale della HeartRateModel classe è boilerplate per la creazione di un oggetto singleton thread-safe.

HeartRateModel Espone quindi 3 eventi:

• EnabledChanged - Indica che l'archiviazione della frequenza cardiaca è stata abilitata o disabilitata (si noti che l'archiviazione è inizialmente disabilitata).
• ErrorMessageChanged - Per questa app di esempio, è disponibile un modello di gestione degli errori molto semplice: una stringa con l'ultimo errore .
• HeartRateStored - Generato quando una frequenza cardiaca viene archiviata nel database di Health Kit.

Si noti che ogni volta che questi eventi vengono generati, viene eseguito tramite NSObject.InvokeOnMainThread(), che consente ai sottoscrittori di aggiornare l'interfaccia utente. In alternativa, gli eventi potrebbero essere documentati come generati nei thread in background e la responsabilità di garantire la compatibilità potrebbe essere lasciata ai gestori. Le considerazioni sui thread sono importanti nelle applicazioni di Health Kit perché molte delle funzioni, ad esempio la richiesta di autorizzazione, sono asincrone ed eseguono i callback su thread non principali.

Il codice specifico di Heath Kit in HeartRateModel si trova nelle due funzioni HeartRateInBeatsPerMinute() e StoreHeartRate().

HeartRateInBeatsPerMinute() converte il relativo argomento in un Health Kit HKQuantityfortemente tipizzato. Il tipo della quantità è quello specificato da HKQuantityTypeIdentifierKey.HeartRate e le unità della quantità sono HKUnit.Count divise per HKUnit.Minute (in altre parole, l'unità viene battuto al minuto).

La StoreHeartRate() funzione accetta ( HKQuantity nell'app di esempio, una creata da HeartRateInBeatsPerMinute() ). Per convalidare i dati, usa il HKQuantity.IsCompatible() metodo , che restituisce true se le unità dell'oggetto possono essere convertite nelle unità dell'argomento. Se la quantità è stata creata con HeartRateInBeatsPerMinute() questo restituirà trueovviamente , ma restituirà true anche se la quantità è stata creata come, ad esempio, Beats per hour. Più comunemente, HKQuantity.IsCompatible() può essere usato per convalidare la massa, la distanza e l'energia che l'utente o un dispositivo potrebbe inserire o visualizzare in un sistema di misurazione (ad esempio unità imperiali), ma che potrebbero essere memorizzati in un altro sistema (ad esempio unità di misura metrica).

Dopo aver convalidato la compatibilità della quantità, il HKQuantitySample.FromType() metodo factory viene usato per creare un oggetto fortemente tipizzato heartRateSample . HKSample gli oggetti hanno una data di inizio e di fine; per le letture istantanee, questi valori devono essere uguali, come nell'esempio. L'esempio non imposta anche dati chiave-valore nel relativo HKMetadata argomento, ma è possibile usare codice come il codice seguente per specificare la posizione del sensore:

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

heartRateSample Dopo aver creato , il codice crea una nuova connessione al database con il blocco using. All'interno di tale blocco, il HKHealthStore.SaveObject() metodo tenta la scrittura asincrona nel database. La chiamata risultante all'espressione lambda attiva eventi rilevanti, HeartRateStored o ErrorMessageChanged.

Ora che il modello è stato programmato, è possibile vedere in che modo il controller riflette lo stato del modello. Aprire il file HKWorkViewController.cs. Il costruttore collega semplicemente il HeartRateModel singleton ai metodi di gestione degli eventi (anche in questo caso, questa operazione può essere eseguita inline con le espressioni lambda, ma i metodi separati rendono la finalità un po' più ovvia):

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

Ecco i gestori pertinenti:

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

Ovviamente, in un'applicazione con un singolo controller, sarebbe possibile evitare la creazione di un oggetto modello separato e l'uso di eventi per il flusso di controllo, ma l'uso di oggetti modello è più appropriato per le app reali.

Esecuzione dell'app di esempio

Il simulatore iOS non supporta Health Kit. Il debug deve essere eseguito in un dispositivo fisico che esegue iOS 8.

Collegare un dispositivo di sviluppo iOS 8 con provisioning corretto al sistema. Selezionarlo come destinazione di distribuzione in Visual Studio per Mac e scegliere Esegui > debug dal menu.

Importante

A questo punto verranno visualizzati errori relativi al provisioning. Per risolvere gli errori, vedere la sezione Creazione e provisioning di un'app health kit precedente. I componenti sono:

• iOS Dev Center - ID app esplicito e Profilo di provisioning abilitato per Health Kit.
• Opzioni progetto - Identificatore bundle (ID app esplicito) e Profilo di provisioning.
• Codice sorgente - Entitlements.plist & Info.plist

Supponendo che le disposizioni siano state impostate correttamente, verrà avviata l'applicazione. Quando raggiunge il OnActivated metodo, richiederà l'autorizzazione di Health Kit. La prima volta che viene rilevato dal sistema operativo, l'utente verrà visualizzato con la finestra di dialogo seguente:

Abilitare l'app per aggiornare i dati relativi alla frequenza cardiaca e l'app verrà nuovamente visualizzata. Il ReactToHealthCarePermissions callback verrà attivato in modo asincrono. In questo modo la HeartRateModel’s Enabled proprietà verrà modificata, che genererà l'evento , che causerà l'esecuzione EnabledChanged del HKPermissionsViewController.OnEnabledChanged() gestore eventi, che abilita il StoreData pulsante. Il diagramma seguente mostra la sequenza:

Premere il pulsante Registra . In questo modo il StoreData_TouchUpInside() gestore verrà eseguito, che tenterà di analizzare il valore del heartRate campo di testo, convertirlo in un HKQuantity oggetto tramite la funzione descritta HeartRateModel.HeartRateInBeatsPerMinute() in precedenza e passare tale quantità a HeartRateModel.StoreHeartRate(). Come illustrato in precedenza, questo tenterà di archiviare i dati e genererà un HeartRateStored evento o ErrorMessageChanged .

Fare doppio clic sul pulsante Home nel dispositivo e aprire l'app Integrità. Fare clic sulla scheda Origini e verrà visualizzata l'app di esempio elencata. Scegliere e non consentire l'autorizzazione per aggiornare i dati della frequenza cardiaca. Fare doppio clic sul pulsante Home e tornare all'app. Anche in questo caso, ReactToHealthCarePermissions() verrà chiamato, ma questa volta, poiché l'accesso viene negato, il pulsante StoreData diventerà disabilitato (si noti che ciò si verifica in modo asincrono e la modifica nell'interfaccia utente potrebbe essere visibile all'utente finale).

Argomenti avanzati

La lettura dei dati dal database di Health Kit è molto simile alla scrittura dei dati: uno specifica i tipi di dati a cui si sta tentando di accedere, richiede l'autorizzazione e, se tale autorizzazione viene concessa, i dati sono disponibili, con conversione automatica in unità di misura compatibili.

Esistono numerose funzioni di query più sofisticate che consentono query e query basate su predicati che eseguono aggiornamenti quando vengono aggiornati i dati pertinenti.

Gli sviluppatori di applicazioni di Health Kit devono esaminare la sezione Health Kit delle linee guida per la revisione delle app di Apple.

Una volta compresi i modelli di sicurezza e di sistema dei tipi, l'archiviazione e la lettura dei dati nel database di Health Kit condiviso è piuttosto semplice. Molte delle funzioni all'interno di Health Kit operano in modo asincrono e gli sviluppatori di applicazioni devono scrivere i programmi in modo appropriato.

A partire dalla stesura di questo articolo, attualmente non esiste alcun equivalente a Health Kit in Android o Windows Phone.

Riepilogo

In questo articolo è stato illustrato come Health Kit consente alle applicazioni di archiviare, recuperare e condividere informazioni correlate all'integrità, fornendo anche un'app di integrità standard che consente all'utente di accedere e controllare questi dati.

Abbiamo anche visto come la privacy, la sicurezza e l'integrità dei dati sostituiscono preoccupazioni per le informazioni e le app correlate all'integrità che usano Health Kit devono gestire l'aumento della complessità negli aspetti di gestione delle applicazioni (provisioning), la codifica (sistema di tipi di Health Kit) e l'esperienza utente (controllo utente delle autorizzazioni tramite finestre di dialogo di sistema e app integrità).

Infine, abbiamo esaminato una semplice implementazione di Health Kit usando l'app di esempio inclusa che scrive i dati heartbeat nell'archivio di Health Kit e ha una progettazione asincrona.

Collegamenti correlati

• Introduzione a iOS 8