Apresentando o HealthKit

Neste artigo do HealthKit, você aprenderá como solicitar permissão para acessar dados do HealthKit, além de ler e gravar dados no repositório central do HealthKit. O artigo usa a versão Swift 4, iOS 11, Xcode 9.

O HealthKit é uma API que foi introduzida no iOS 8. O HealthKit serve como repositório central de todos os dados relacionados à saúde, permitindo que os usuários criem um perfil biológico e armazenem dados de exercícios.

Ao ler o artigo HealthKit, você criará o aplicativo de rastreamento de treinamento mais simples e aprenderá:

• Como solicitar permissão e acessar dados do HealthKit
• Como ler dados do HealthKit e exibi-los em um UITableView
• Como gravar dados no repositório central do HealthKit

Pronto para começar a usar o HealthKit? Continue lendo!

Nota: Para trabalhar neste tutorial, você precisará de uma conta de desenvolvedor iOS ativa. Sem isso, você não pode ativar o HealthKit Capability e obter acesso ao repositório do HealthKit.

Iniciar

O aplicativo inicial rastreia a queima de calorias durante um programa de exercícios. Para pessoas de dentro e socialites de Hollywood, deve ser óbvio que estou falando de Prancercise .


Faça o download do projeto inicial e abra-o no Xcode .

Compile e execute o aplicativo. Você verá o "esqueleto" da interface do usuário. Nos próximos dois artigos, você adicionará funcionalidades gradualmente a este aplicativo.

Atribuindo uma equipe

HealthKit é uma estrutura especial. O aplicativo não poderá usá-lo se você não tiver uma conta de desenvolvedor ativa. Depois de ter uma conta de desenvolvedor, você pode atribuir sua equipe.

Selecione PrancerciseTracker no Project Navigator e, em seguida, selecione o destino PrancerciseTracker . Vá para a guia Geral e clique no campo Equipe .

Selecione o comando associado à sua conta de desenvolvedor:

Permissões / direitos

O HealthKit também possui seu próprio conjunto de direitos, e você precisará habilitá-los para criar aplicativos que usam a estrutura.

Abra a guia Recursos no editor de destino e ative o HealthKit , conforme mostrado na captura de tela abaixo:



Aguarde o Xcode configurar o HealthKit para você. Como regra, não há problemas aqui, mas você ainda pode encontrar alguns se esquecer de especificar o Identificador de equipe e pacote corretamente.

Agora está tudo pronto. Você só precisa pedir permissão ao usuário para usar o HealthKit.

Permissões

O HealthKit trabalha com dados confidenciais e sensíveis. Nem todo mundo se sente tão à vontade para permitir que aplicativos instalados acessem essas informações.

É por isso que o HealthKit possui um forte sistema de privacidade. O HealthKit tem acesso apenas aos dados que os usuários concordam em compartilhar. Para criar um perfil para os usuários do seu Prancercise Tracker, você deve primeiro obter permissão para acessar cada tipo de dados.

Atualização da descrição de uso

Primeiro, você precisa descrever por que está solicitando indicadores de saúde de seus usuários. O Xcode permite especificar isso no arquivo Info.plist do seu aplicativo.

Abra Info.plist . Em seguida, adicione as seguintes chaves:
Privacidade - Descrição do uso do compartilhamento de saúde
Privacidade - Descrição do uso da atualização de integridade

Essas chaves armazenam o texto que será exibido quando a tela de login do HeathKit aparecer. Descrição do uso do compartilhamento de integridade refere-se à seção de dados que deve ser lida no HealthKit. Descrição de uso da atualização de integridade corresponde aos dados gravados no HealthKit.

Você pode "adicionar" tudo o que quiser lá. Geralmente, é uma descrição: "Usaremos suas informações de saúde para rastrear melhor seus exercícios".

Lembre-se de que, se essas chaves não estiverem instaladas, o aplicativo falhará quando você tentar fazer login no HealthKit.

Autorização HealthKit

Abra o arquivo HealthKitSetupAssistant.swift dentro do qual é o método de classe que você usará para autorizar no HealthKit.

class func authorizeHealthKit(completion: @escaping (Bool, Error?) -> Swift.Void) { } 

O método authorizeHealthKit (conclusão :) não aceita nenhum parâmetro e possui uma conclusão que retorna um booleano ( êxito ou falha ) e um erro opcional no caso de algo dar errado. Se erros forem retornados, você os passará para conclusão em dois casos:

1. O HealthKit pode não estar disponível no seu dispositivo. Por exemplo, se o aplicativo estiver sendo executado em um iPad.
2. Alguns tipos de dados podem não estar disponíveis na versão atual do HealthKit.

Vamos quebrar esse processo. Para autorizar HealthKit, o método authorizeHealthKit (conclusão :) deve concluir as quatro etapas a seguir:

1. Verifique se o Healthkit está disponível neste dispositivo. Se não for esse o caso, retorne uma falha e um erro à conclusão.
2. Prepare tipos de dados de integridade. O Prancercise Tracker lerá e gravará no HealthKit.
3. Organize esses dados em uma lista de tipos para ler e tipos para escrever.
4. Solicitar autorização. Se essa ação for bem-sucedida, todas as atividades foram corretas e concluídas corretamente.

Verificação de disponibilidade do HealthKit

Primeiro de tudo, você precisa verificar a disponibilidade do HealthKit no dispositivo.
Cole o seguinte código no início do método authorizeHealthKit (conclusão :) :

 //1. ,      HealthKit guard HKHealthStore.isHealthDataAvailable() else { completion(false, HealthkitSetupError.notAvailableOnDevice) return } 

Você interagirá com o HKHealthStore com muita frequência. É um repositório central que armazena dados de integridade do usuário. O método isHealthDataAvailable () ajudará você a entender se o dispositivo do usuário atual suporta dados do Heathkit.

A declaração de proteção impede que o aplicativo execute o restante do método authorizeHealthKit (conclusão :) se o HealthKit não estiver disponível no dispositivo. Quando isso acontece, o bloco de conclusão é chamado com o erro notAvailableOnDevice . Você pode simplesmente enviar isso para o console ou no controlador principal para processar outras etapas em caso de erro.

Preparação de dados

Depois de saber que o HealthKit está disponível no dispositivo do usuário, é hora de preparar os tipos de dados que serão lidos e gravados no HealthKit.
HealthKit funciona com o tipo HKObjectType . Cada tipo que entra ou retorna ao repositório central do HealthKit é um tipo de HKObjectType . Você também verá HKSampleType e HKWorkoutType . Ambos herdam do HKObjectType , então basicamente é a mesma coisa.

Cole o seguinte trecho de código imediatamente após o primeiro trecho de código:

 //2.   ,     HealthKit guard let dateOfBirth = HKObjectType.characteristicType(forIdentifier: .dateOfBirth), let bloodType = HKObjectType.characteristicType(forIdentifier: .bloodType), let biologicalSex = HKObjectType.characteristicType(forIdentifier: .biologicalSex), let bodyMassIndex = HKObjectType.quantityType(forIdentifier: .bodyMassIndex), let height = HKObjectType.quantityType(forIdentifier: .height), let bodyMass = HKObjectType.quantityType(forIdentifier: .bodyMass), let activeEnergy = HKObjectType.quantityType(forIdentifier: .activeEnergyBurned) else { completion(false, HealthkitSetupError.dataTypeNotAvailable) return } 

Uau, isso é uma grande guarda ! Este também é um ótimo exemplo do uso de uma única proteção para recuperar várias opções.

Para criar um HKObjectType para essas características, você precisa usar HKObjectType.characteristicType (forIdentifier :) ou HKObjectType.quantityType (forIdentifier :)
Tipos de característica e tipos de quantidade são enumerações definidas pela estrutura. O HealthKit é inicializado com eles.

Você também notará que, se uma característica ou tipo de seleção não estiver disponível, o método falhará. Isso é intencional. Seu aplicativo sempre deve saber exatamente com que tipos de HealthKit ele pode trabalhar, se houver.

Preparando uma lista de tipos de dados para leitura e gravação

Agora é hora de preparar uma lista de tipos de dados para leitura e gravação.
Cole esse terceiro código no método authorizeHealthKit (conclusão :) imediatamente após a segunda parte:

 //3.   ,  HealthKit     let healthKitTypesToWrite: Set<HKSampleType> = [bodyMassIndex, activeEnergy, HKObjectType.workoutType()] let healthKitTypesToRead: Set<HKObjectType> = [dateOfBirth, bloodType, biologicalSex, bodyMassIndex, height, bodyMass, HKObjectType.workoutType()] 

O HealthKit espera que um conjunto de objetos HKSampleType represente os tipos de dados que seu usuário pode gravar e também espera que um conjunto de objetos HKObjectType seja exibido para seu aplicativo.

HKObjectType.workoutType () é um tipo especial de HKObjectType . É qualquer treino.

Autorização HealthKit

A última parte é a mais fácil. Você só precisa solicitar autorização do HealthKit. Cole este último pedaço de código:

 //4.    HKHealthStore().requestAuthorization(toShare: healthKitTypesToWrite, read: healthKitTypesToRead) { (success, error) in completion(success, error) } 

Esse código solicita autorização do HealthKit e chama a conclusão. Eles usam variáveis ​​para operações bem-sucedidas e erros transmitidos pelo método requestAuthorization (toShare: read: complete :) do HKHealthStore .

Você pode pensar nisso como um redirecionamento. Em vez de manipular a conclusão dentro do HealthKitSetupAssistant, você passa o pacote para o controlador principal, que pode exibir um aviso ou executar outra ação.

O projeto já possui um botão Authorize HealthKit e chama o método authorizeHealthKit () no MasterViewController. Este é o lugar perfeito para chamar o método de autorização que acabamos de escrever.

Abra MasterViewController.swift , encontre o método authorizeHealthKit ( ) e cole este código:

 HealthKitSetupAssistant.authorizeHealthKit { (authorized, error) in guard authorized else { let baseMessage = "HealthKit Authorization Failed" if let error = error { print("\(baseMessage). Reason: \(error.localizedDescription)") } else { print(baseMessage) } return } print("HealthKit Successfully Authorized.") } 

Esse código usa o método authorizeHealthKit (conclusão :) que você acabou de implementar. Quando concluído, ele exibirá uma mensagem no console para indicar se a autorização foi bem-sucedida no HealthKit.

Inicie o aplicativo. Clique em Autorizar HealthKit na janela principal e você verá uma tela de autorização pop-up:


Ligue todos os comutadores, role para vê-los e pressione Permitir . No console, você verá uma mensagem como esta:

 HealthKit Successfully Authorized. 

Ótimo! O aplicativo tem acesso ao repositório central do HealthKit. Agora é hora de começar a rastrear itens.

Características e amostras

Nesta seção, você aprenderá:

• Como ler as características biológicas do seu usuário.
• Como ler e escrever diferentes tipos de amostras (peso, altura, etc.)

As características biológicas, em regra, são tipos de elementos que não mudam, assim como o seu tipo sanguíneo. Amostras são elementos que mudam frequentemente, como peso.

Para rastrear adequadamente a eficácia do modo de treino Prancercise , o aplicativo Prancercise Tracker deve receber uma amostra do peso e da altura do usuário. Juntas, essas amostras podem ser usadas para calcular o índice de massa corporal (IMC).

Nota: O Índice de Massa Corporal (IMC) é um indicador amplamente usado de gordura corporal e é calculado com base no peso e na altura de uma pessoa. Saiba mais aqui .

Especificações de leitura

O Prancercise Tracker não registra características biológicas. Ele os obtém do HealthKit. Isso significa que essas características devem primeiro ser armazenadas no repositório central do HeathKit.

Se você ainda não o fez, é hora de falar um pouco mais sobre o HeathKit .

Abra o aplicativo Health no seu dispositivo ou simulador. Selecione a guia Dados de integridade. Em seguida, clique no ícone do perfil no canto superior direito para visualizar seu perfil de saúde. Clique em Editar e insira as informações da data de nascimento, sexo e tipo sanguíneo:


Agora que o HealthKit sabe sua data de nascimento, sexo e tipo sanguíneo, é hora de ler esses recursos no Prancercise Tracker .

Volte ao Xcode e abra ProfileDataStore.swift . A classe ProfileDataStore representa seu ponto de acesso a todos os dados relacionados à saúde de seus usuários.

Cole o seguinte método no ProfileDataStore :

 class func getAgeSexAndBloodType() throws -> (age: Int, biologicalSex: HKBiologicalSex, bloodType: HKBloodType) { let healthKitStore = HKHealthStore() do { //1. This method throws an error if these data are not available. let birthdayComponents = try healthKitStore.dateOfBirthComponents() let biologicalSex = try healthKitStore.biologicalSex() let bloodType = try healthKitStore.bloodType() //2. Use Calendar to calculate age. let today = Date() let calendar = Calendar.current let todayDateComponents = calendar.dateComponents([.year], from: today) let thisYear = todayDateComponents.year! let age = thisYear - birthdayComponents.year! //3. Unwrap the wrappers to get the underlying enum values. let unwrappedBiologicalSex = biologicalSex.biologicalSex let unwrappedBloodType = bloodType.bloodType return (age, unwrappedBiologicalSex, unwrappedBloodType) } } 

O método getAgeSexAndBloodType () chama o HKHealthStore , solicitando a data de nascimento, sexo e tipo de sangue do usuário. Ele também calcula a idade do usuário usando a data de nascimento.

1. Você deve ter notado que esse método pode causar um erro. Isso acontece sempre que uma data de nascimento, sexo ou tipo de sangue não foi armazenada no repositório central do HealthKit. Como você acabou de inserir essas informações no seu aplicativo, não deve causar erros.
2. Usando a classe Calendário , você pode converter qualquer data em um conjunto de Componentes de Data . Isso é realmente conveniente quando você deseja obter um ano para um encontro. Esse código apenas obtém seu ano de nascimento, ano atual e calcula a diferença.
3. As variáveis ​​“expandidas” são nomeadas de maneira que fique claro que você precisa acessar a enumeração base da classe de wrapper ( HKBiologicalSexObject e HKBloodTypeObject ).

Atualização da interface do usuário

Se você agora compilar e executar o aplicativo, não verá nenhuma alteração na interface do usuário, porque ainda não conectou essa lógica a ela.
Abra ProfileViewController.swif te encontre o método loadAndDisplayAgeSexAndBloodType ( )

Este método usará seu ProfileDataStore para carregar características biológicas na interface do usuário.

Cole o seguinte código no método loadAndDisplayAgeSexAndBloodType () :

 do { let userAgeSexAndBloodType = try ProfileDataStore.getAgeSexAndBloodType() userHealthProfile.age = userAgeSexAndBloodType.age userHealthProfile.biologicalSex = userAgeSexAndBloodType.biologicalSex userHealthProfile.bloodType = userAgeSexAndBloodType.bloodType updateLabels() } catch let error { self.displayAlert(for: error) } 

Esse bloco de código carrega a idade, sexo e tipo de sangue como uma tupla. Ele então define esses campos na instância local do modelo UserHealthProfile. Por fim, atualiza a interface do usuário com os novos campos no UserHealthProfile chamando o método updateLabels () .

Como o método ProfileDataStore getAgeSexAndBloodType () pode gerar um erro, o ProfileViewController deve tratá-lo. Nesse caso, você apenas pega o erro e o apresenta como um aviso.

Tudo isso é ótimo, mas há um problema. O método updateLabels () ainda não faz nada. Este é apenas um anúncio em branco. Desta vez, vamos para a interface do usuário.

Encontre o método updateLabels () e cole este código nele:

 if let age = userHealthProfile.age { ageLabel.text = "\(age)" } if let biologicalSex = userHealthProfile.biologicalSex { biologicalSexLabel.text = biologicalSex.stringRepresentation } if let bloodType = userHealthProfile.bloodType { bloodTypeLabel.text = bloodType.stringRepresentation } 

O código é bem simples. Se o usuário definiu a idade, ele será formatado em um rótulo. O mesmo vale para sexo biológico e tipo sanguíneo. A variável stringRepresentation converte a enumeração em uma string para fins de exibição.

Compile e execute o aplicativo. Vá para a tela Perfil e IMC. Clique no botão Ler dados do HealthKit.


Se você já inseriu suas informações no aplicativo, elas devem aparecer nos atalhos dessa tela. Se você não tiver feito isso, uma mensagem de erro será exibida.

Uau! Você lê e exibe dados diretamente do HealthKit .

Amostras de consulta

Agora é hora de ler o peso e a altura do usuário. Eles serão usados ​​para calcular e exibir o IMC na visualização do perfil.

As características biológicas estão prontamente disponíveis porque quase nunca mudam. As amostras requerem uma abordagem muito mais complexa. Eles usam o HKQuery , mais precisamente o HKSampleQuery .

Para solicitar amostras do HealthKit, você precisará de:

1. Especifique o tipo de amostra que você deseja solicitar (peso, altura etc.),
2. Algumas opções adicionais que ajudam a filtrar e classificar dados. Para fazer isso, você pode transmitir um NSPredicate opcional ou uma matriz de NSSortDescriptors .

Nota: Se você está familiarizado com o CoreData, provavelmente notou algumas semelhanças. HKSampleQuery é muito semelhante a NSFetchedRequest para um tipo de objeto, em que você especifica o predicado e os descritores de classificação e, em seguida, define o contexto do objeto para executar a consulta para obter os resultados.

Depois que sua consulta é configurada, basta chamar o método HKHealthStore ExecuteQuery () para obter os resultados.

Para o Prancercise Tracker, você criará uma função única e universal que baixa as amostras mais recentes de qualquer tipo. Assim, você pode usá-lo para peso e altura.

Abra ProfileDataStore.swift e cole o seguinte método na classe, logo abaixo do método getAgeSexAndBloodType () :

 class func getMostRecentSample(for sampleType: HKSampleType, completion: @escaping (HKQuantitySample?, Error?) -> Swift.Void) { //1.  HKQuery    . let mostRecentPredicate = HKQuery.predicateForSamples(withStart: Date.distantPast, end: Date(), options: .strictEndDate) let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false) let limit = 1 let sampleQuery = HKSampleQuery(sampleType: sampleType, predicate: mostRecentPredicate, limit: limit, sortDescriptors: [sortDescriptor]) { (query, samples, error) in //2.       . DispatchQueue.main.async { guard let samples = samples, let mostRecentSample = samples.first as? HKQuantitySample else { completion(nil, error) return } completion(mostRecentSample, nil) } } HKHealthStore().execute(sampleQuery) } 

Este método utiliza o tipo de amostra (altura, peso, IMC, etc.). Ele então cria uma consulta para recuperar a última amostra desse tipo. Se você passar pelo tipo de amostra para crescimento, retornará ao seu último registro de crescimento.

Muita coisa está acontecendo aqui. Vou parar para explicar algumas coisas.

1. Existem vários métodos no HKQuery que podem ajudá-lo a filtrar os exemplos de consulta do HealthKit. Nesse caso, usamos o predicado de data interno.
2. Solicitar amostras do HealthKit é um processo assíncrono. É por isso que o código no manipulador de conclusão é encontrado dentro do bloco Dispatch. A conformidade é necessária no encadeamento principal. Caso contrário, o aplicativo falhará.

Se tudo der certo, sua solicitação será executada e você obterá uma amostra limpa retornada no encadeamento principal , onde o ProfileViewController pode colocar seu conteúdo no rótulo. Vamos fazer esta parte agora.

Exibindo amostras na interface do usuário

Na seção anterior, você baixou dados do HealthKit . Salve-os como modelo no ProfileViewController e atualize o conteúdo em linhas usando o método ProfileViewController updateLabels ()

Tudo o que você precisa fazer é expandir esse processo, adicionando uma função que carrega as amostras, as processa para a interface do usuário e chama updateLabels () para preencher os rótulos com texto.

Abra o arquivo ProfileViewController.swift , localize o método loadAndDisplayMostRecentHeight ( ) e cole o seguinte código:

 //1.  HealthKit      guard let heightSampleType = HKSampleType.quantityType(forIdentifier: .height) else { print("Height Sample Type is no longer available in HealthKit") return } ProfileDataStore.getMostRecentSample(for: heightSampleType) { (sample, error) in guard let sample = sample else { if let error = error { self.displayAlert(for: error) } return } //2.     ,   , //    . let heightInMeters = sample.quantity.doubleValue(for: HKUnit.meter()) self.userHealthProfile.heightInMeters = heightInMeters self.updateLabels() } 

1. Este método começa criando um tipo de amostra de crescimento. Ele passa esse tipo de amostra para o método que você acabou de escrever, que retornará a amostra de crescimento de usuário mais recente registrada no HealthKit.
2. Assim que a amostra retornar, o crescimento é convertido em metros e armazenado no modelo UserHealthProfile. A interface do usuário será atualizada.

Nota: Geralmente você deseja converter uma amostra de quantidade em uma unidade padrão. Para fazer isso, o código acima usa o método doubleValue (for :) , que permite passar os dados relevantes necessários (neste caso, medidores) para o HKUnit .

Você pode criar vários tipos de HKUnits usando alguns dos métodos de classe comuns disponíveis no HealthKit . Para obter contadores, você pode simplesmente usar o método meter () no HKUnit , e será isso o que você precisa.

Com crescimento resolvido. E o peso? Tudo é bem parecido, mas você precisará preencher o método loadAndDisplayMostRecentWeight () no ProfileViewController .

Cole o seguinte código no método loadAndDisplayMostRecentWeight () :

 guard let weightSampleType = HKSampleType.quantityType(forIdentifier: .bodyMass) else { print("Body Mass Sample Type is no longer available in HealthKit") return } ProfileDataStore.getMostRecentSample(for: weightSampleType) { (sample, error) in guard let sample = sample else { if let error = error { self.displayAlert(for: error) } return } let weightInKilograms = sample.quantity.doubleValue(for: HKUnit.gramUnit(with: .kilo)) self.userHealthProfile.weightInKilograms = weightInKilograms self.updateLabels() } 

Você cria o tipo de amostra que deseja receber, solicita o HealthKit , realiza algumas conversões de unidade, salva no modelo e atualiza a interface do usuário.

No momento, isso pode mostrar que o trabalho está concluído, mas há outra coisa. A função updateLabels () não está ciente dos novos dados que você disponibilizou para ela.

Vamos consertar.

Adicione as seguintes linhas à função updateLabels () , logo abaixo da parte em que você expande o grupo sanguíneo para exibi-lo na interface do usuário:

 if let weight = userHealthProfile.weightInKilograms { let weightFormatter = MassFormatter() weightFormatter.isForPersonMassUse = true weightLabel.text = weightFormatter.string(fromKilograms: weight) } if let height = userHealthProfile.heightInMeters { let heightFormatter = LengthFormatter() heightFormatter.isForPersonHeightUse = true heightLabel.text = heightFormatter.string(fromMeters: height) } if let bodyMassIndex = userHealthProfile.bodyMassIndex { bodyMassIndexLabel.text = String(format: "%.02f", bodyMassIndex) } 

Seguindo o modelo original na função updateLabels () , ele expande a altura, o peso e o índice de massa corporal em seu modelo UserHealthProfile . Se disponíveis, eles geram as linhas apropriadas e as atribuem aos rótulos na tela do usuário.

MassFormatter e LengthFormatter fazem o trabalho de converter seus valores em strings.

O índice de massa corporal não é realmente armazenado no modelo UserHealthProfile . Esta é uma propriedade calculada que faz o cálculo para você.

Clique na propriedade bodyMassIndex e você verá o que quero dizer:

 var bodyMassIndex: Double? { guard let weightInKilograms = weightInKilograms, let heightInMeters = heightInMeters, heightInMeters > 0 else { return nil } return (weightInKilograms/(heightInMeters*heightInMeters)) } 

O índice de massa corporal é uma propriedade opcional, ou seja, ele pode retornar nulo se você não especificou altura ou peso (ou se eles estão configurados para um número que não faz sentido). O cálculo real é simplesmente o peso dividido pela altura ao quadrado.

Nota: Em breve, você mergulhará nisso tudo se não tiver adicionado dados ao HealthKit para leitura pelo aplicativo. Se ainda não o fez, é necessário criar pelo menos amostras de altura e peso.

Abra o aplicativo Health e vá para a guia Health Data. Lá, selecione o parâmetro Body Measurements, selecione Weight e Add Data Point para adicionar uma nova amostra de peso. Repita o processo para crescimento.

Nesse ponto, o Prancercise Tracker deve ser capaz de ler uma amostra recente do peso e da altura do usuário e exibi-la no texto.

Compile e execute os aplicativos. Vá para Perfil e IMC . Em seguida, clique no botão Ler dados do HealthKit .


Awesome! Você acabou de ler suas primeiras amostras no repositório HealthKit e as usou para calcular o IMC.

Salvando amostras

Em Prancercise Rastreador já tem um índice de massa corporal calculadora acessível. Vamos usá-lo para registrar a amostra do IMC do usuário.

Abra ProfileDataStore.swift e adicione o seguinte método:

 class func saveBodyMassIndexSample(bodyMassIndex: Double, date: Date) { //1. ,      guard let bodyMassIndexType = HKQuantityType.quantityType(forIdentifier: .bodyMassIndex) else { fatalError("Body Mass Index Type is no longer available in HealthKit") } //2.   HKUnit     let bodyMassQuantity = HKQuantity(unit: HKUnit.count(), doubleValue: bodyMassIndex) let bodyMassIndexSample = HKQuantitySample(type: bodyMassIndexType, quantity: bodyMassQuantity, start: date, end: date) //3.      HealthKit HKHealthStore().save(bodyMassIndexSample) { (success, error) in if let error = error { print("Error Saving BMI Sample: \(error.localizedDescription)") } else { print("Successfully saved BMI Sample") } } } 

Como em outros tipos de amostra, você deve primeiro garantir que o tipo de amostra esteja disponível no HealthKit .

1. Nesse caso, o código verifica se existe um tipo de quantidade para o índice de massa corporal. Nesse caso, é usado para criar uma amostra de quantidade. Caso contrário, o aplicativo para de funcionar.
2. count() HKUnit , , . - , , .
3. HKHealthStore , . , .

Quase pronto. Para resumir a interface do usuário.

Abra ProfileViewController.swif , localize o método saveBodyMassIndexToHealthKit ( ). Este método é chamado quando o usuário clica no botão Salvar IMC na tabela.

Cole o seguinte código no método:

 guard let bodyMassIndex = userHealthProfile.bodyMassIndex else { displayAlert(for: ProfileDataError.missingBodyMassIndex) return } ProfileDataStore.saveBodyMassIndexSample(bodyMassIndex: bodyMassIndex, date: Date()) 

Você se lembra que o índice de massa corporal é uma propriedade calculada que retorna um valor quando amostras de altura e peso são carregadas no HealthKit . Este código está tentando calcular essa propriedade e, se possível, será passada para o método savedBodyMassIndexSample (bodyMassIndex: date :) que você acabou de escrever.

Também mostra um alerta conveniente se o índice de massa corporal não puder ser calculado por qualquer motivo.

Compile e execute o aplicativo. Vá para a tela Perfil e IMC . Faça o download dos dados do HeathKit e clique no botão Salvar IMC.

Olhe para o console. Você vê isso?

    BMI 

Se sim, parabéns! Sua amostra de IMC agora está armazenada no repositório central do HealthKit . Vamos ver se conseguimos encontrá-lo.

Abra o aplicativo Health, toque na guia Health Data, clique em Body Measurements na exibição de tabela e clique em Body Mass Index.