Support monitoring / observing health data changes #12

Author: EddyVerbruggen

README.md

@@ -117,6 +117,41 @@ this.healthData.query(
     .catch(error => this.resultToShow = error);
 ```
 
+
+### `startMonitoring` (iOS only, for now)
+If you want to be notified when health data was changed, you can monitor specific types. This even works when your app is in the background, with `enableBackgroundUpdates: true`. Note that iOS will wake up your app so you can act upon this notification (in the `onUpdate` function by fi. querying recent changes to this data type), but in return you are responsible for telling iOS you're done. So make sure you invoke the `completionHandler` as shown below.
+
+Not all data types support `backgroundUpdateFrequency: "immediate"`, so your app may not always be invoked immediately when data is added/deleted in HealthKit.
+
+> Background notifications probably don't work on the iOS simulator, so please test those on a real device.
+
+```typescript
+this.healthData.startMonitoring(
+    {
+      dataType: dataType,
+      enableBackgroundUpdates: true,
+      backgroundUpdateFrequency: "immediate",
+      onUpdate: (completionHandler: () => void) => {
+        console.log("Our app was notified that health data changed, so querying...");
+        this.getData(dataType, unit).then(() => completionHandler());
+      }
+    })
+    .then(() => this.resultToShow = `Started monitoring ${dataType}`)
+    .catch(error => this.resultToShow = error);
+```
+
+### `stopMonitoring` (iOS only, for now)
+It's best to call this method in case you no longer wish to receive notifications when health data changes.
+
+```typescript
+this.healthData.stopMonitoring(
+    {
+      dataType: dataType,
+    })
+    .then(() => this.resultToShow = `Stopped monitoring ${dataType}`)
+    .catch(error => this.resultToShow = error);
+```
+
 ## Available Data Types
 With version 1.0.0 these are the supported types of data you can read. Also, make sure you pass in the correct `unit`.
 

demo-ng/app/app.component.html

@@ -5,6 +5,8 @@
         <Button ios:text="Apple Health Data available?" android:text="Google Fit Data available?" (tap)="isAvailable()"></Button>
         <Button text="Is Authorized?" (tap)="isAuthorized()"></Button>
         <Button text="Request Authorization" (tap)="requestAuthForVariousTypes()"></Button>
+        <Button text="Start background Hearth Rate monitoring" (tap)="startMonitoringData('heartRate', 'count/min')"></Button>
+        <Button text="Stop background Hearth Rate monitoring" (tap)="stopMonitoringData('heartRate')"></Button>
         <Button text="Get Daily Steps per source (count)" (tap)="getData('steps', 'count', 'sourceAndDay')"></Button>
         <Button text="Get Hourly Distance data (km)" (tap)="getData('distance', 'km', 'hour')"></Button>
         <!--<Button text="Get Hourly Distance data (mi)" (tap)="getData('distance', 'mi', 'hour')"></Button>-->

demo-ng/app/app.component.ts

@@ -1,4 +1,4 @@
-import { Component } from "@angular/core";
+import { Component, NgZone } from "@angular/core";
 import { alert } from "tns-core-modules/ui/dialogs";
 import { AggregateBy, HealthData, HealthDataType } from "nativescript-health-data";
 
@@ -20,7 +20,7 @@ export class AppComponent {
   private healthData: HealthData;
   resultToShow = "";
 
-  constructor() {
+  constructor(private zone: NgZone) {
     this.healthData = new HealthData();
   }
 
@@ -48,20 +48,46 @@ export class AppComponent {
         .catch(error => console.log("Request auth error: ", error));
   }
 
-  getData(dataType: string, unit: string, aggregateBy?: AggregateBy): void {
-    this.healthData.query(
+  getData(dataType: string, unit: string, aggregateBy?: AggregateBy): Promise<void> {
+    return this.healthData.query(
         {
-          startDate: new Date(new Date().getTime() - 3 * 24 * 60 * 60 * 1000), // 3 days ago
+          startDate: new Date(new Date().getTime() - 24 * 60 * 60 * 1000), // 1 day ago
           endDate: new Date(), // now
           dataType: dataType,
           unit: unit,
           aggregateBy: aggregateBy,
           sortOrder: "desc"
         })
         .then(result => {
-          console.log(JSON.stringify(result));
-          this.resultToShow = JSON.stringify(result);
+          this.zone.run(() => {
+            console.log(JSON.stringify(result));
+            this.resultToShow = JSON.stringify(result)
+          });
         })
         .catch(error => this.resultToShow = error);
   }
+
+  startMonitoringData(dataType: string, unit: string): void {
+    this.healthData.startMonitoring(
+        {
+          dataType: dataType,
+          enableBackgroundUpdates: true,
+          backgroundUpdateFrequency: "immediate",
+          onUpdate: (completionHandler: () => void) => {
+            console.log("Our app was notified that health data changed, so querying...");
+            this.getData(dataType, unit).then(() => completionHandler());
+          }
+        })
+        .then(() => this.resultToShow = `Started monitoring ${dataType}`)
+        .catch(error => this.resultToShow = error);
+  }
+
+  stopMonitoringData(dataType: string): void {
+    this.healthData.stopMonitoring(
+        {
+          dataType: dataType,
+        })
+        .then(() => this.resultToShow = `Stopped monitoring ${dataType}`)
+        .catch(error => this.resultToShow = error);
+  }
 }

src/health-data.android.ts

@@ -1,4 +1,12 @@
-import { Common, HealthDataApi, HealthDataType, QueryRequest, ResponseItem } from './health-data.common';
+import {
+  Common,
+  HealthDataApi,
+  HealthDataType,
+  QueryRequest,
+  ResponseItem,
+  StartMonitoringRequest,
+  StopMonitoringRequest
+} from './health-data.common';
 import * as utils from 'tns-core-modules/utils/utils';
 import { ad } from 'tns-core-modules/utils/utils';
 import * as application from 'tns-core-modules/application';
@@ -82,7 +90,7 @@ export class HealthData extends Common implements HealthDataApi {
     return new Promise((resolve, reject) => {
       try {
         // make sure the user is authorized
-        this.requestAuthorization([{ name: opts.dataType, accessType: "read"}]).then(authorized => {
+        this.requestAuthorization([{name: opts.dataType, accessType: "read"}]).then(authorized => {
           if (!authorized) {
             reject("Not authorized");
             return;
@@ -121,6 +129,18 @@ export class HealthData extends Common implements HealthDataApi {
     });
   }
 
+  startMonitoring(opts: StartMonitoringRequest): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      reject("Not supported");
+    });
+  }
+
+  stopMonitoring(opts: StopMonitoringRequest): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      reject("Not supported");
+    });
+  }
+
   private parseData(readResult: any /* com.google.android.gms.fitness.result.DataReadResult */, opts: QueryRequest) {
     let result = [];
     if (readResult.getBuckets().size() > 0) {

src/health-data.common.ts

@@ -13,6 +13,8 @@ export interface HealthDataType {
 
 export type AggregateBy = "hour" | "day" | "sourceAndDay";
 
+export type BackgroundUpdateFrequency = "immediate" | "hourly" | "daily" | "weekly";
+
 export type SortOrder = "asc" | "desc";
 
 export interface QueryRequest {
@@ -31,6 +33,28 @@ export interface QueryRequest {
   limit?: number;
 }
 
+export interface StartMonitoringRequest {
+  /**
+   * Default false
+   */
+  enableBackgroundUpdates?: boolean;
+  /**
+   * Default 'immediate', only relevant when 'enableBackgroundUpdates' is 'true'.
+   */
+  backgroundUpdateFrequency?: BackgroundUpdateFrequency;
+  dataType: string;
+  /**
+   * This callback function is invoked when the health store receives an update (add/delete data).
+   * You can use this trigger to fetch the latest data.
+   */
+  onUpdate: (completionHandler: () => void) => void;
+  onError?: (error: string) => void;
+}
+
+export interface StopMonitoringRequest {
+  dataType?: string;
+}
+
 export interface ResponseItem {
   start: Date;
   end: Date;
@@ -82,6 +106,10 @@ export interface HealthDataApi {
   requestAuthorization(types: Array<HealthDataType>): Promise<boolean>;
 
   query(opts: QueryRequest): Promise<Array<ResponseItem>>;
+
+  startMonitoring(opts: StartMonitoringRequest): Promise<void>;
+
+  stopMonitoring(opts: StopMonitoringRequest): Promise<void>;
 }
 
 export abstract class Common {

src/health-data.ios.ts

@@ -1,7 +1,17 @@
-import { Common, HealthDataApi, HealthDataType, QueryRequest, ResponseItem } from './health-data.common';
+import {
+  BackgroundUpdateFrequency,
+  Common,
+  HealthDataApi,
+  HealthDataType,
+  QueryRequest,
+  ResponseItem,
+  StartMonitoringRequest,
+  StopMonitoringRequest
+} from './health-data.common';
 
 export class HealthData extends Common implements HealthDataApi {
   private healthStore: HKHealthStore;
+  private monitorQueries: Map<string /* type */, HKObserverQuery> = new Map();
 
   constructor() {
     super();
@@ -63,7 +73,7 @@ export class HealthData extends Common implements HealthDataApi {
   query(opts: QueryRequest): Promise<Array<ResponseItem>> {
     return new Promise((resolve, reject) => {
       // make sure the user is authorized
-      this.requestAuthorization([{ name: opts.dataType, accessType: "read"}]).then(authorized => {
+      this.requestAuthorization([{name: opts.dataType, accessType: "read"}]).then(authorized => {
         if (!authorized) {
           reject("Not authorized");
           return;
@@ -87,6 +97,49 @@ export class HealthData extends Common implements HealthDataApi {
     });
   }
 
+  startMonitoring(opts: StartMonitoringRequest): Promise<void> {
+    return new Promise((resolve, reject) => {
+      // make sure the user is authorized
+      this.requestAuthorization([{name: opts.dataType, accessType: "read"}]).then(authorized => {
+        if (!authorized) {
+          reject("Not authorized");
+          return;
+        }
+
+        let typeOfData = acceptableDataTypes[opts.dataType];
+        if (quantityTypes[typeOfData] || categoryTypes[typeOfData]) {
+          this.monitorData(typeOfData, opts);
+          resolve();
+        } else {
+          reject('Type not supported (yet)');
+        }
+      });
+    });
+  }
+
+  stopMonitoring(opts: StopMonitoringRequest): Promise<void> {
+    return new Promise((resolve, reject) => {
+      let typeOfData = acceptableDataTypes[opts.dataType];
+      const objectType = this.resolveDataType(typeOfData);
+
+      if (quantityTypes[typeOfData] || categoryTypes[typeOfData]) {
+
+        const rememberedQuery = this.monitorQueries.get(opts.dataType);
+        if (rememberedQuery) {
+          this.healthStore.stopQuery(rememberedQuery);
+          this.monitorQueries.delete(opts.dataType);
+        }
+
+        this.healthStore.disableBackgroundDeliveryForTypeWithCompletion(
+            objectType, (success: boolean, error: NSError) => {
+              success ? resolve() : reject(error.localizedDescription);
+            });
+      } else {
+        reject('Type not supported (yet)');
+      }
+    });
+  }
+
   private resolveDataType(type: string): HKObjectType {
     if (quantityTypes[type]) {
       return HKObjectType.quantityTypeForIdentifier(quantityTypes[type]);
@@ -101,7 +154,7 @@ export class HealthData extends Common implements HealthDataApi {
   }
 
   private queryForQuantityOrCategoryData(dataType: string, opts: QueryRequest, callback: (data: Array<ResponseItem>, error: string) => void) {
-    let objectType = this.resolveDataType(dataType);
+    const objectType = this.resolveDataType(dataType);
 
     const predicate = HKQuery.predicateForSamplesWithStartDateEndDateOptions(opts.startDate, opts.endDate, HKQueryOptions.StrictStartDate);
 
@@ -149,6 +202,48 @@ export class HealthData extends Common implements HealthDataApi {
     this.healthStore.executeQuery(query);
   }
 
+  private monitorData(dataType: string, opts: StartMonitoringRequest): void {
+    const objectType = this.resolveDataType(dataType);
+
+    let query = HKObserverQuery.alloc().initWithSampleTypePredicateUpdateHandler(
+        objectType, null, (observerQuery: HKObserverQuery, handler: () => void, error: NSError) => {
+          if (error) {
+            opts.onError(error.localizedDescription);
+            handler();
+          } else {
+            // We need to tell iOS when our app is done background processing by calling the handler
+            opts.onUpdate(() => handler());
+          }
+        }
+    );
+
+    // remember this query, so we can stop it at a later time
+    this.monitorQueries.set(opts.dataType, query);
+
+    this.healthStore.executeQuery(query);
+
+    if (opts.enableBackgroundUpdates) {
+      this.healthStore.enableBackgroundDeliveryForTypeFrequencyWithCompletion(
+          objectType, this.getHKUpdateFrequency(opts.backgroundUpdateFrequency), (success: boolean, error: NSError) => {
+            if (!success) {
+              opts.onError(error.localizedDescription);
+            }
+          });
+    }
+  }
+
+  private getHKUpdateFrequency(frequency: BackgroundUpdateFrequency): HKUpdateFrequency {
+    if (frequency === "weekly") {
+      return HKUpdateFrequency.Weekly;
+    } else if (frequency === "daily") {
+      return HKUpdateFrequency.Daily;
+    } else if (frequency === "hourly") {
+      return HKUpdateFrequency.Hourly;
+    } else {
+      return HKUpdateFrequency.Immediate;
+    }
+  };
+
   private queryForCharacteristicData(dataType: string) {
     // console.log('ask for characteristic data ' + data);
     let dataToRetrieve;

src/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nativescript-health-data",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Health Data plugin for Nativescript, using Google Fit and Apple HealthKit.",
   "main": "health-data",
   "typings": "index.d.ts",