HealthKit dans Xamarin.iOS

Health Kit fournit un magasin de données sécurisé pour les informations relatives à l’intégrité de l’utilisateur. Les applications Health Kit peuvent, avec l’autorisation explicite de l’utilisateur, lire et écrire dans ce magasin de données et recevoir des notifications lorsque des données pertinentes sont ajoutées. Les applications peuvent présenter les données, ou les utilisateurs peuvent utiliser l’application d’intégrité fournie par Apple pour afficher un tableau de bord de toutes leurs données.

Étant donné que les données relatives à la santé sont si sensibles et cruciales, Health Kit est fortement typé, avec des unités de mesure et une association explicite avec le type d’informations enregistrées (par exemple, le taux de glucose sanguin ou la fréquence cardiaque). En outre, les applications Health Kit doivent utiliser des droits explicites, doivent demander l’accès aux types d’informations particuliers, et l’utilisateur doit accorder explicitement à l’application l’accès à ces types de données.

Cet article présente les points suivants :

• Exigences de sécurité du Kit d’intégrité, notamment l’approvisionnement d’applications et la demande d’autorisation de l’utilisateur pour accéder à la base de données Health Kit ;
• Le système de type du Kit d’intégrité, qui réduit la possibilité d’appliquer ou d’interpréter mal les données ;
• Écriture dans le magasin de données du Kit de contrôle d’intégrité partagé à l’échelle du système.

Cet article ne traite pas de sujets plus avancés, tels que l’interrogation de la base de données, la conversion entre unités de mesure ou la réception de notifications de nouvelles données.

Dans cet article, nous allons créer un exemple d’application pour enregistrer la fréquence cardiaque de l’utilisateur :

Spécifications

Les étapes suivantes sont requises pour effectuer les étapes présentées dans cet article :

• Xcode 7 et iOS 8 (ou version ultérieure) : les dernières API Xcode et iOS d’Apple doivent être installées et configurées sur l’ordinateur du développeur.
• Visual Studio pour Mac ou Visual Studio : la dernière version de Visual Studio pour Mac doit être installée et configurée sur l’ordinateur du développeur.
• Appareil iOS 8 (ou version ultérieure) : appareil iOS exécutant la dernière version d’iOS 8 ou ultérieure à des fins de test.

Important

Health Kit a été introduit dans iOS 8. Actuellement, le Kit d’intégrité n’est pas disponible sur le simulateur iOS et le débogage nécessite une connexion à un appareil iOS physique.

Création et approvisionnement d’une application Health Kit

Avant qu’une application Xamarin iOS 8 puisse utiliser l’API HealthKit, elle doit être correctement configurée et configurée. Cette section décrit les étapes requises pour configurer correctement votre application Xamarin.

Les applications du Kit d’intégrité nécessitent :

• ID d’application explicite.
• Profil d’approvisionnement associé à cet ID d’application explicite et aux autorisations du Kit d’intégrité.
• Avec Entitlements.plist une com.apple.developer.healthkit propriété de type Boolean définie sur Yes.
• Dont Info.plist la clé contient une entrée avec la String valeur healthkitUIRequiredDeviceCapabilities .
• Les Info.plist entrées d’explication de confidentialité doivent également être appropriées : explication String de la clé NSHealthUpdateUsageDescription si l’application va écrire des données et une String explication de la clé NSHealthShareUsageDescription si l’application va lire les données du Kit d’intégrité.

Pour en savoir plus sur l’approvisionnement d’une application iOS, l’article Device Provisioning de la série De prise en main de Xamarin décrit la relation entre les certificats de développeur, les ID d’application, les profils d’approvisionnement et les droits d’utilisation des applications.

ID d’application explicite et profil d’approvisionnement

La création d’un ID d’application explicite et d’un profil d’approvisionnement approprié est effectuée dans le Centre de développement iOS d’Apple.

Vos ID d’application actuels sont répertoriés dans la section Certificats, identificateurs et profils du Centre de développement. Souvent, cette liste affiche les valeurs d’ID , indiquant que le nom de l’ID - d’application *peut être utilisé avec n’importe quel nombre de suffixes. Ces ID d’application générique ne peuvent pas être utilisés avec Health Kit.

Pour créer un ID d’application explicite, cliquez sur le + bouton en haut à droite pour vous rendre sur la page Inscrire l’ID d’application iOS :

Comme indiqué dans l’image ci-dessus, après avoir créé une description d’application, utilisez la section ID d’application explicite pour créer un ID pour votre application. Dans la section App Services , consultez Le Kit d’intégrité dans la section Activer les services .

Lorsque vous avez terminé, appuyez sur le bouton Continuer pour inscrire l’ID d’application dans votre compte. Vous allez revenir à la page Certificats, identificateurs et profils . Cliquez sur Profils d’approvisionnement pour vous amener à la liste de vos profils d’approvisionnement actuels, puis cliquez sur le + bouton dans le coin supérieur droit pour vous amener à la page Ajouter un profil d’approvisionnement iOS. Sélectionnez l’option Développement d’applications iOS, puis cliquez sur Continuer pour accéder à la page Sélectionner l’ID d’application. Sélectionnez ici l’ID d’application explicite que vous avez spécifié précédemment :

Cliquez sur Continuer et parcourir les écrans restants, où vous allez spécifier votre ou vos certificats de développeur, appareils et un nom pour ce profil d’approvisionnement :

Cliquez sur Générer et attendre la création de votre profil. Téléchargez le fichier et double-cliquez dessus pour l’installer dans Xcode. Vous pouvez confirmer son installation sous Xcode > Preferences > Accounts > View Details... Vous devez voir votre profil d’approvisionnement juste installé et avoir l’icône du Kit d’intégrité et d’autres services spéciaux dans sa ligne Droits d’utilisation :

Association de l’ID d’application et du profil d’approvisionnement à votre application Xamarin.iOS

Une fois que vous avez créé et installé un profil d’approvisionnement approprié comme décrit, il serait normalement temps de créer une solution dans Visual Studio pour Mac ou Visual Studio. L’accès au Kit d’intégrité est disponible pour n’importe quel projet C# ou F# iOS.

Au lieu de parcourir le processus de création d’un projet Xamarin iOS 8 manuellement, ouvrez l’exemple d’application attaché à cet article (qui inclut un Storyboard et un code prédéfinis). Pour associer l’exemple d’application à votre profil d’approvisionnement activé pour Health Kit, dans le panneau Solution, cliquez avec le bouton droit sur votre projet et affichez sa boîte de dialogue Options. Basculez vers le panneau Application iOS et entrez l’ID d’application explicite que vous avez créé précédemment en tant qu’identificateur de bundle de l’application :

Basculez maintenant vers le panneau de signature de bundle iOS. Votre profil d’approvisionnement récemment installé, avec son association à l’ID d’application explicite, sera désormais disponible en tant que profil d’approvisionnement :

Si le profil d’approvisionnement n’est pas disponible, vérifiez l’identificateur de bundle dans le panneau Application iOS par rapport à celui spécifié dans le Centre de développement iOS et que le profil d’approvisionnement est installé (détails des comptes > de préférences > Xcode>...).

Lorsque le profil d’approvisionnement activé pour le Kit d’intégrité est sélectionné, cliquez sur OK pour fermer la boîte de dialogue Options du projet.

Droits d’utilisation.plist et valeurs Info.plist

L’exemple d’application inclut un Entitlements.plist fichier (nécessaire pour les applications activées pour Health Kit) et non inclus dans chaque modèle de projet. Si votre projet n’inclut pas les droits, cliquez avec le bouton droit sur votre projet, choisissez Fichier > nouveau fichier... > Droits iOS.plist > pour en ajouter un manuellement.

En fin de compte, vous Entitlements.plist devez avoir la paire clé et valeur suivante :

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

De même, la Info.plist valeur de healthkit l’application doit être associée à la UIRequiredDeviceCapabilities clé :

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

L’exemple d’application fourni avec cet article inclut un préconfiguré Entitlements.plist qui inclut toutes les clés requises.

Kit d’intégrité de programmation

Le magasin de données Health Kit est un magasin de données privé spécifique à l’utilisateur qui est partagé entre les applications. Étant donné que les informations d’intégrité sont si sensibles, l’utilisateur doit prendre des mesures positives pour autoriser l’accès aux données. Cet accès peut être partiel (écriture, lecture, accès pour certains types de données, mais pas d’autres, etc.) et peut être révoqué à tout moment. Les applications du Kit d’intégrité doivent être écrites de manière défensive, avec la compréhension que de nombreux utilisateurs hésiteront à stocker leurs informations relatives à l’intégrité.

Les données du Kit d’intégrité sont limitées aux types spécifiés par Apple. Ces types sont strictement définis : certains, tels que le type de sang, sont limités aux valeurs particulières d’une énumération fournie par Apple, tandis que d’autres combinent une magnitude avec une unité de mesure (par exemple, des grammes, des calories et des litres). Même les données qui partagent une unité de mesure compatible sont distinguées par leur HKObjectType; par exemple, le système de type intercepte une tentative erronée de stocker une HKQuantityTypeIdentifier.NumberOfTimesFallen valeur dans un champ qui attend un HKQuantityTypeIdentifier.FlightsClimbed champ même si les deux utilisent l’unité HKUnit.Count de mesure.

Les types stockables dans le magasin de données Health Kit sont tous les sous-classes de HKObjectType. HKCharacteristicType les objets stockent le sexe biologique, le type de sang et la date de naissance. Toutefois, les objets sont HKSampleType plus courants, qui représentent des données échantillonées à un moment spécifique ou sur une période donnée.

HKSampleType est abstrait et a quatre sous-classes concrètes. Il n’existe actuellement qu’un seul type de données, qui est Analyse du HKCategoryType sommeil. La grande majorité des données du Kit d’intégrité sont de type HKQuantityType et stockent leurs données dans HKQuantitySample des objets, qui sont créées à l’aide du modèle de conception Factory familier :

HKQuantityType les types vont de HKQuantityTypeIdentifier.ActiveEnergyBurned à HKQuantityTypeIdentifier.StepCount.

Demande d’autorisation de l’utilisateur

Les utilisateurs finaux doivent prendre des mesures positives pour permettre à une application de lire ou d’écrire des données health Kit. Cette opération est effectuée via l’application Intégrité qui est préinstallée sur les appareils iOS 8. La première fois qu’une application Health Kit est exécutée, l’utilisateur reçoit une boîte de dialogue d’accès à l’intégrité contrôlée par le système :

Plus tard, l’utilisateur peut modifier les autorisations à l’aide de la boîte de dialogue Sources de l’application Intégrité :

Étant donné que les informations d’intégrité sont extrêmement sensibles, les développeurs d’applications doivent écrire leurs programmes de manière défensive, avec l’attente que les autorisations seront refusées et modifiées pendant l’exécution de l’application. L’idiome le plus courant consiste à demander des autorisations dans la UIApplicationDelegate.OnActivated méthode, puis à modifier l’interface utilisateur selon les besoins.

Procédure pas à pas des autorisations

Dans votre projet d’approvisionnement du Kit d’intégrité, ouvrez le AppDelegate.cs fichier. Notez l’instruction using HealthKit; en haut du fichier.

Le code suivant concerne les autorisations du Kit d’intégrité :

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

Tout le code de ces méthodes peut être effectué inline inline, OnActivatedmais l’exemple d’application utilise des méthodes distinctes pour rendre leur intention plus claire : ValidateAuthorization() les étapes nécessaires pour demander l’accès aux types spécifiques écrits (et lire, si l’application le souhaite) et ReactToHealthCarePermissions() est un rappel activé après l’interaction de l’utilisateur avec la boîte de dialogue autorisations dans le Health.app.

Le travail de ValidateAuthorization() consiste à générer l’ensemble de celui-ci HKObjectTypes que l’application écrit et demande l’autorisation de mettre à jour ces données. Dans l’exemple d’application, il s’agit HKObjectType de la clé KHQuantityTypeIdentifierKey.HeartRate. Ce type est ajouté au jeu typesToWrite, tandis que le jeu typesToRead est laissé vide. Ces jeux, et une référence au ReactToHealthCarePermissions() rappel, sont passés à HKHealthStore.RequestAuthorizationToShare().

Le ReactToHealthCarePermissions() rappel est appelé une fois que l’utilisateur a interagi avec la boîte de dialogue autorisations et qu’il a passé deux informations : une bool valeur qui sera true si l’utilisateur a interagissant avec la boîte de dialogue d’autorisations et un NSError qui, si non null, indique un type d’erreur associé à la présentation de la boîte de dialogue d’autorisations.

Important

Pour être clair sur les arguments de cette fonction : les paramètres de réussite et d’erreur n’indiquent pas si l’utilisateur a accordé l’autorisation d’accéder aux données du Kit d’intégrité ! Ils indiquent uniquement que l’utilisateur a eu la possibilité d’autoriser l’accès aux données.

Pour vérifier si l’application a accès aux données, celle-ci HKHealthStore.GetAuthorizationStatus() est utilisée, en HKQuantityTypeIdentifierKey.HeartRatepassant . En fonction de l’état retourné, l’application active ou désactive la possibilité d’entrer des données. Il n’existe aucune expérience utilisateur standard pour traiter un déni d’accès et il existe de nombreuses options possibles. Dans l’exemple d’application, l’état est défini sur un HeartRateModel objet singleton qui déclenche à son tour des événements pertinents.

Modèle, vue et contrôleur

Pour passer en revue l’objet HeartRateModel singleton, ouvrez le HeartRateModel.cs fichier :

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 première section est un code réutilisable pour la création d’événements et de gestionnaires génériques. La partie initiale de la HeartRateModel classe est également réutilisable pour la création d’un objet singleton thread-safe.

Ensuite, HeartRateModel expose 3 événements :

• EnabledChanged - Indique que le stockage de fréquence cardiaque a été activé ou désactivé (notez que le stockage est initialement désactivé).
• ErrorMessageChanged - Pour cet exemple d’application, nous avons un modèle de gestion des erreurs très simple : une chaîne avec la dernière erreur.
• HeartRateStored - Déclenché lorsqu’une fréquence cardiaque est stockée dans la base de données Health Kit.

Notez que chaque fois que ces événements sont déclenchés, il est effectué via NSObject.InvokeOnMainThread(), ce qui permet aux abonnés de mettre à jour l’interface utilisateur. Vous pouvez également documenter les événements comme étant déclenchés sur des threads d’arrière-plan et la responsabilité de garantir la compatibilité peut être laissée à leurs gestionnaires. Les considérations relatives aux threads sont importantes dans les applications du Kit d’intégrité, car de nombreuses fonctions, telles que la demande d’autorisation, sont asynchrones et exécutent leurs rappels sur des threads non principaux.

Le code HeartRateModel spécifique du Kit Heath se trouve dans les deux fonctions HeartRateInBeatsPerMinute() et StoreHeartRate().

HeartRateInBeatsPerMinute() convertit son argument en kit d’intégrité HKQuantityfortement typé. Le type de la quantité est celui spécifié par la HKQuantityTypeIdentifierKey.HeartRate quantité et les unités de la quantité sont divisés HKUnit.Count par HKUnit.Minute (en d’autres termes, l’unité est battue par minute).

La StoreHeartRate() fonction prend un HKQuantity (dans l’exemple d’application, un créé par HeartRateInBeatsPerMinute() ). Pour valider ses données, elle utilise la HKQuantity.IsCompatible() méthode, qui retourne true si les unités de l’objet peuvent être converties en unités dans l’argument. Si la quantité a été créée avec HeartRateInBeatsPerMinute() cela retourne évidemment true, mais elle retourne true également si la quantité a été créée comme, par exemple, Beats Per Hour. Plus souvent, HKQuantity.IsCompatible() il est possible de valider la masse, la distance et l’énergie que l’utilisateur ou un appareil peut entrer ou afficher dans un système de mesure (par exemple, les unités impériales), mais qui peut être stocké dans un autre système (comme les unités de métrique).

Une fois la compatibilité de la quantité validée, la HKQuantitySample.FromType() méthode de fabrique est utilisée pour créer un objet fortement typé heartRateSample . HKSample les objets ont une date de début et de fin ; pour les lectures instantanées, ces valeurs doivent être identiques, comme dans l’exemple. L’exemple ne définit pas non plus de données clé-valeur dans son HKMetadata argument, mais il est possible d’utiliser du code tel que le code suivant pour spécifier l’emplacement du capteur :

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

Une fois le heartRateSample code créé, le code crée une connexion à la base de données avec le bloc using. Dans ce bloc, la HKHealthStore.SaveObject() méthode tente l’écriture asynchrone dans la base de données. L’appel obtenu à l’expression lambda déclenche des événements pertinents, soit HeartRateStored ErrorMessageChanged.

Maintenant que le modèle a été programmé, il est temps de voir comment le contrôleur reflète l’état du modèle. Ouvrez le fichier HKWorkViewController.cs. Le constructeur relie simplement le HeartRateModel singleton aux méthodes de gestion des événements (là encore, cela peut être effectué en ligne avec des expressions lambda, mais les méthodes distinctes rendent l’intention un peu plus évidente) :

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

Voici les gestionnaires appropriés :

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

Évidemment, dans une application avec un seul contrôleur, il serait possible d’éviter la création d’un objet modèle distinct et l’utilisation d’événements pour le flux de contrôle, mais l’utilisation d’objets de modèle est plus appropriée pour les applications réelles.

Exécution de l’exemple d’application

Le simulateur iOS ne prend pas en charge le Kit d’intégrité. Le débogage doit être effectué sur un appareil physique exécutant iOS 8.

Attachez un appareil de développement iOS 8 correctement approvisionné à votre système. Sélectionnez-la comme cible de déploiement dans Visual Studio pour Mac et dans le menu, choisissez Exécuter > le débogage.

Important

Les erreurs relatives à l’approvisionnement s’affichent à ce stade. Pour résoudre les erreurs, consultez la section Création et approvisionnement d’une application Health Kit ci-dessus. Les composants sont :

• iOS Centre de développement - Id d’application explicite et profil d’approvisionnement activé pour le Kit d’intégrité.
• Options de projet - Identificateur de bundle (ID d’application explicite) & Profil d’approvisionnement.
• Code source - Entitlements.plist & Info.plist

En supposant que les dispositions ont été correctement définies, votre application démarre. Lorsqu’elle atteint sa OnActivated méthode, elle demande l’autorisation du Kit d’intégrité. La première fois que cela est rencontré par le système d’exploitation, votre utilisateur sera présenté avec la boîte de dialogue suivante :

Activez votre application pour mettre à jour les données de fréquence cardiaque et votre application réapparaît. Le ReactToHealthCarePermissions rappel sera activé de façon asynchrone. Cela entraîne la modification de la HeartRateModel’s Enabled propriété, qui déclenche l’événement EnabledChanged , ce qui entraîne l’exécution du HKPermissionsViewController.OnEnabledChanged() gestionnaire d’événements, ce qui active le StoreData bouton. Le diagramme suivant montre la séquence :

Appuyez sur le bouton Enregistrer . Cela entraîne l’exécution du StoreData_TouchUpInside() gestionnaire, qui tente d’analyser la valeur du champ de heartRate texte, de convertir en une HKQuantity via la fonction précédemment abordée HeartRateModel.HeartRateInBeatsPerMinute() et de passer cette quantité à HeartRateModel.StoreHeartRate(). Comme indiqué précédemment, cela tentera de stocker les données et déclenchera une ou ErrorMessageChanged un HeartRateStored événement.

Double-cliquez sur le bouton Accueil sur votre appareil et ouvrez l’application Intégrité. Cliquez sur l’onglet Sources et vous verrez l’exemple d’application répertorié. Choisissez-le et autorisez-le à mettre à jour les données de fréquence cardiaque. Double-cliquez sur le bouton Accueil et revenez à votre application. Une fois de plus, ReactToHealthCarePermissions() sera appelé, mais cette fois, car l’accès est refusé, le bouton StoreData devient désactivé (notez que cela se produit de manière asynchrone et que la modification de l’interface utilisateur peut être visible pour l’utilisateur final).

Sujets avancés

La lecture des données à partir de la base de données health Kit est très similaire à l’écriture de données : on spécifie les types de données qu’il essaie d’accéder, de demander une autorisation et, si cette autorisation est accordée, les données sont disponibles, avec une conversion automatique en unités de mesure compatibles.

Il existe un certain nombre de fonctions de requête plus sophistiquées qui autorisent des requêtes et des requêtes basées sur des prédicats qui effectuent des mises à jour lorsque des données pertinentes sont mises à jour.

Les développeurs d’applications Health Kit doivent passer en revue la section Health Kit des instructions de révision des applications d’Apple.

Une fois que les modèles de sécurité et de système de type sont compris, le stockage et la lecture des données dans la base de données du Kit d’intégrité partagé est assez simple. De nombreuses fonctions dans Health Kit fonctionnent de manière asynchrone et les développeurs d’applications doivent écrire leurs programmes de manière appropriée.

À compter de l’écriture de cet article, il n’existe actuellement aucun équivalent au Kit d’intégrité dans Android ou Windows Phone.

Résumé

Dans cet article, nous avons vu comment Health Kit permet aux applications de stocker, récupérer et partager des informations relatives à l’intégrité, tout en fournissant une application d’intégrité standard qui permet à l’utilisateur d’accéder et de contrôler ces données.

Nous avons également vu comment la confidentialité, la sécurité et l’intégrité des données remplacent les préoccupations liées à l’intégrité des informations et applications à l’aide du Kit d’intégrité doivent gérer l’augmentation de la complexité des aspects de gestion des applications (approvisionnement), codage (système de type du Kit d’intégrité) et l’expérience utilisateur (contrôle utilisateur des autorisations via les boîtes de dialogue système et l’application Intégrité).

Enfin, nous avons examiné une implémentation simple du Kit d’intégrité à l’aide de l’exemple d’application inclus qui écrit des données de pulsation dans le magasin Health Kit et qui a une conception asynchrone.

Liens associés

• Introduction à iOS 8