creation and first commit of repo

.gitignore

+# OSX
+#
+.DS_Store
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+project.xcworkspace
+
+# Android/IJ
+#
+.idea
+.gradle
+local.properties
+*.iml
+local.properties
+.idea/workspace.xml
+.idea/libraries
+build
+captures
+
+# node.js
+#
+node_modules/
+npm-debug.log
+
+# BUCK
+buck-out/
+\.buckd/
+android/app/libs
+android/keystores/debug.keystore

.npmignore

+node_modules
+RCTAppleHealthKit.xcodeproj/xcuserdata
+RCTAppleHealthKit.xcodeproj/project.xcworkspace
+.DS_Store

RCTAppleHealthKit/RCTAppleHealthKit+Queries.h

+//
+//  RCTAppleHealthKit+Queries.h
+//  RCTAppleHealthKit
+//
+//  Created by Greg Wilson on 2016-06-26.
+//  Copyright © 2016 Greg Wilson. All rights reserved.
+//
+
+#import "RCTAppleHealthKit.h"
+
+@interface RCTAppleHealthKit (Queries)
+
+- (void)fetchMostRecentQuantitySampleOfType:(HKQuantityType *)quantityType predicate:(NSPredicate *)predicate completion:(void (^)(HKQuantity *mostRecentQuantity, NSError *error))completion;
+- (void)fetchSumOfSamplesTodayForType:(HKQuantityType *)quantityType unit:(HKUnit *)unit completion:(void (^)(double, NSError *))completionHandler;
+- (NSPredicate *)predicateForSamplesToday;
+
+@end

RCTAppleHealthKit/RCTAppleHealthKit+Queries.m

+//
+//  RCTAppleHealthKit+Queries.m
+//  RCTAppleHealthKit
+//
+//  Created by Greg Wilson on 2016-06-26.
+//  Copyright © 2016 Greg Wilson. All rights reserved.
+//
+
+#import "RCTAppleHealthKit+Queries.h"
+
+@implementation RCTAppleHealthKit (Queries)
+
+
+- (void)fetchMostRecentQuantitySampleOfType:(HKQuantityType *)quantityType predicate:(NSPredicate *)predicate completion:(void (^)(HKQuantity *, NSError *))completion { NSSortDescriptor *timeSortDescriptor = [[NSSortDescriptor alloc] initWithKey:HKSampleSortIdentifierEndDate ascending:NO];
+    
+    // Since we are interested in retrieving the user's latest sample, we sort the samples in descending order, and set the limit to 1. We are not filtering the data, and so the predicate is set to nil.
+    HKSampleQuery *query = [[HKSampleQuery alloc] initWithSampleType:quantityType
+                                                           predicate:predicate
+                                                               limit:1
+                                                     sortDescriptors:@[timeSortDescriptor]
+                                                      resultsHandler:^(HKSampleQuery *query, NSArray *results, NSError *error) {
+                                                          if (!results) {
+                                                              if (completion) {
+                                                                  completion(nil, error);
+                                                              }
+                                                              
+                                                              return;
+                                                          }
+                                                          
+                                                          if (completion) {
+                                                              // If quantity isn't in the database, return nil in the completion block.
+                                                              HKQuantitySample *quantitySample = results.firstObject;
+                                                              HKQuantity *quantity = quantitySample.quantity;
+                                                              
+                                                              completion(quantity, error);
+                                                          }
+                                                      }];
+    
+    [self.healthStore executeQuery:query];
+}
+
+
+
+- (void)fetchSumOfSamplesTodayForType:(HKQuantityType *)quantityType unit:(HKUnit *)unit completion:(void (^)(double, NSError *))completionHandler {
+    NSPredicate *predicate = [self predicateForSamplesToday];
+    
+    HKStatisticsQuery *query = [[HKStatisticsQuery alloc] initWithQuantityType:quantityType quantitySamplePredicate:predicate options:HKStatisticsOptionCumulativeSum completionHandler:^(HKStatisticsQuery *query, HKStatistics *result, NSError *error) {
+        HKQuantity *sum = [result sumQuantity];
+        
+        if (completionHandler) {
+            double value = [sum doubleValueForUnit:unit];
+            
+            completionHandler(value, error);
+        }
+    }];
+    
+    [self.healthStore executeQuery:query];
+}
+
+
+
+
+#pragma mark - Convenience
+
+- (NSPredicate *)predicateForSamplesToday {
+    NSCalendar *calendar = [NSCalendar currentCalendar];
+    
+    NSDate *now = [NSDate date];
+    
+    NSDate *startDate = [calendar startOfDayForDate:now];
+    NSDate *endDate = [calendar dateByAddingUnit:NSCalendarUnitDay value:1 toDate:startDate options:0];
+    
+    return [HKQuery predicateForSamplesWithStartDate:startDate endDate:endDate options:HKQueryOptionStrictStartDate];
+}
+
+
+
+@end

RCTAppleHealthKit/RCTAppleHealthKit+TypesAndPermissions.h

+//
+//  RCTAppleHealthKit+TypesAndPermissions.h
+//  RCTAppleHealthKit
+//
+//  Created by Greg Wilson on 2016-06-26.
+//  Copyright © 2016 Greg Wilson. All rights reserved.
+//
+
+#import "RCTAppleHealthKit.h"
+
+@interface RCTAppleHealthKit (TypesAndPermissions)
+
+- (NSSet *)dataTypesToWrite;
+- (NSSet *)dataTypesToRead;
+
+- (NSDictionary *)readPermsDict;
+- (NSDictionary *)writePermsDict;
+
+- (NSSet *)getReadPermsFromOptions:(NSArray *)options;
+- (NSSet *)getWritePermsFromOptions:(NSArray *)options;
+
+@end

RCTAppleHealthKit/RCTAppleHealthKit+TypesAndPermissions.m

+//
+//  RCTAppleHealthKit+TypesAndPermissions.m
+//  RCTAppleHealthKit
+//
+//  Created by Greg Wilson on 2016-06-26.
+//  Copyright © 2016 Greg Wilson. All rights reserved.
+//
+
+#import "RCTAppleHealthKit+TypesAndPermissions.h"
+
+@implementation RCTAppleHealthKit (TypesAndPermissions)
+
+#pragma mark - HealthKit Permissions
+
+
+// Returns the types of data that Fit wishes to write to HealthKit.
+- (NSSet *)dataTypesToWrite {
+    HKQuantityType *dietaryCalorieEnergyType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierDietaryEnergyConsumed];
+    HKQuantityType *activeEnergyBurnType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierActiveEnergyBurned];
+    HKQuantityType *heightType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierHeight];
+    HKQuantityType *weightType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierBodyMass];
+    
+    return [NSSet setWithObjects:dietaryCalorieEnergyType, activeEnergyBurnType, heightType, weightType, nil];
+}
+
+
+
+// Returns the types of data that Fit wishes to read from HealthKit.
+- (NSSet *)dataTypesToRead {
+    HKQuantityType *dietaryCalorieEnergyType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierDietaryEnergyConsumed];
+    HKQuantityType *activeEnergyBurnType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierActiveEnergyBurned];
+    HKQuantityType *heightType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierHeight];
+    HKQuantityType *weightType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierBodyMass];
+    
+    HKQuantityType *stepCountType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierStepCount];
+    
+    HKCharacteristicType *birthdayType = [HKObjectType characteristicTypeForIdentifier:HKCharacteristicTypeIdentifierDateOfBirth];
+    HKCharacteristicType *biologicalSexType = [HKObjectType characteristicTypeForIdentifier:HKCharacteristicTypeIdentifierBiologicalSex];
+    
+    return [NSSet setWithObjects:dietaryCalorieEnergyType, activeEnergyBurnType, heightType, weightType, stepCountType, birthdayType, biologicalSexType, nil];
+}
+
+
+- (NSDictionary *)readPermsDict {
+    NSDictionary *readPerms = @{
+        @"DietaryEnergy" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierDietaryEnergyConsumed],
+        @"ActiveEnergy" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierActiveEnergyBurned],
+        @"Height" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierHeight],
+        @"Weight" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierBodyMass],
+        @"Steps" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierStepCount],
+        @"DateOfBirth" : [HKObjectType characteristicTypeForIdentifier:HKCharacteristicTypeIdentifierDateOfBirth],
+        @"Sex" : [HKObjectType characteristicTypeForIdentifier:HKCharacteristicTypeIdentifierBiologicalSex],
+    };
+    return readPerms;
+}
+
+- (NSDictionary *)writePermsDict {
+    NSDictionary *writePerms = @{
+        @"DietaryEnergy" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierDietaryEnergyConsumed],
+        @"ActiveEnergy" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierActiveEnergyBurned],
+        @"Height" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierHeight],
+        @"Weight" : [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierBodyMass],
+    };
+    return writePerms;
+}
+
+
+// Returns HealthKit read permissions from options array
+- (NSSet *)getReadPermsFromOptions:(NSArray *)options {
+    NSDictionary *readPermDict = [self readPermsDict];
+    NSMutableSet *readPermSet = [NSMutableSet setWithCapacity:1];
+    
+    for(int i=0; i<[options count]; i++) {
+        NSString *optionKey = options[i];
+        HKObjectType *val = [readPermDict objectForKey:optionKey];
+        if(val != nil) {
+            RCTLogInfo(@"Adding read permissions from options: %@", optionKey);
+            [readPermSet addObject:val];
+        }
+    }
+    
+    return readPermSet;
+    //    return [self dataTypesToRead];
+}
+
+
+// Returns HealthKit write permissions from options array
+- (NSSet *)getWritePermsFromOptions:(NSArray *)options {
+    NSDictionary *writePermDict = [self writePermsDict];
+    NSMutableSet *writePermSet = [NSMutableSet setWithCapacity:1];
+    
+    for(int i=0; i<[options count]; i++) {
+        NSString *optionKey = options[i];
+        HKObjectType *val = [writePermDict objectForKey:optionKey];
+        if(val != nil) {
+            RCTLogInfo(@"Adding write permissions from options: %@", optionKey);
+            [writePermSet addObject:val];
+        }
+    }
+    
+    return writePermSet;
+    //    return [self dataTypesToWrite];
+}
+
+@end

RCTAppleHealthKit/RCTAppleHealthKit.h

+//
+//  RCTAppleHealthKit.h
+//  RCTAppleHealthKit
+//
+//  Created by Greg Wilson on 2016-06-26.
+//  Copyright © 2016 Greg Wilson. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <HealthKit/HealthKit.h>
+#import "RCTBridgeModule.h"
+#import "RCTUtils.h"
+#import "RCTLog.h"
+
+@interface RCTAppleHealthKit : NSObject <RCTBridgeModule>
+
+@property (nonatomic) HKHealthStore *healthStore;
+- (void)isHealthKitAvailable:(RCTResponseSenderBlock)callback;
+- (void)initializeHealthKit:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback;
+- (void)getHealthKitUserWeight:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback;
+- (void)saveHealthKitUserWeight:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback;
+- (void)getHealthKitUserStepCount:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback;
+- (void)getModuleInfo:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback;
+
+@end

RCTAppleHealthKit/RCTAppleHealthKit.m

+//
+//  RCTAppleHealthKit.m
+//  RCTAppleHealthKit
+//
+//  Created by Greg Wilson on 2016-06-26.
+//  Copyright © 2016 Greg Wilson. All rights reserved.
+//
+
+#import "RCTAppleHealthKit.h"
+#import "RCTAppleHealthKit+Queries.h"
+#import "RCTAppleHealthKit+TypesAndPermissions.h"
+
+@implementation RCTAppleHealthKit
+
+RCT_EXPORT_MODULE();
+
+
+RCT_EXPORT_METHOD(isAvailable:(RCTResponseSenderBlock)callback)
+{
+    [self isHealthKitAvailable:callback];
+}
+
+RCT_EXPORT_METHOD(initHealthKit:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback)
+{
+    [self initializeHealthKit:input callback:callback];
+}
+
+RCT_EXPORT_METHOD(getCurrentWeight:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback)
+{
+    [self getHealthKitUserWeight:input callback:callback];
+}
+
+RCT_EXPORT_METHOD(saveWeight:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback)
+{
+    [self saveHealthKitUserWeight:input callback:callback];
+}
+
+RCT_EXPORT_METHOD(getStepCountForToday:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback)
+{
+    [self getHealthKitUserStepCount:input callback:callback];
+}
+
+RCT_EXPORT_METHOD(getInfo:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback)
+{
+    [self getModuleInfo:input callback:callback];
+}
+
+
+- (void)isHealthKitAvailable:(RCTResponseSenderBlock)callback
+{
+    BOOL isAvailable = NO;
+    if ([HKHealthStore isHealthDataAvailable]) {
+        isAvailable = YES;
+    }
+    callback(@[[NSNull null], @(isAvailable)]);
+}
+
+
+- (void)initializeHealthKit:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback
+{
+    self.healthStore = [[HKHealthStore alloc] init];
+    
+    if ([HKHealthStore isHealthDataAvailable]) {
+        
+        NSSet *writeDataTypes = [self dataTypesToWrite];
+        NSSet *readDataTypes = [self dataTypesToRead];
+        
+        // get permissions from input object provided by JS options object argument
+        NSDictionary* permissions =[input objectForKey:@"permissions"];
+        if(permissions != nil){
+            NSArray* readPermsArray = [permissions objectForKey:@"read"];
+            NSArray* writePermsArray = [permissions objectForKey:@"write"];
+            
+            NSSet* readPerms = [self getReadPermsFromOptions:readPermsArray];
+            NSSet* writePerms = [self getWritePermsFromOptions:writePermsArray];
+            
+            if(readPerms != nil) {
+                readDataTypes = readPerms;
+            }
+            if(writePerms != nil) {
+                writeDataTypes = writePerms;
+            }
+        }
+        
+        
+        [self.healthStore requestAuthorizationToShareTypes:writeDataTypes readTypes:readDataTypes completion:^(BOOL success, NSError *error) {
+            if (!success) {
+                NSLog(@"You didn't allow HealthKit to access these read/write data types. In your app, try to handle this error gracefully when a user decides not to provide access. The error was: %@. If you're using a simulator, try it on a device.", error);
+                callback(@[RCTMakeError(@"You didn't allow HealthKit to access these read/write data types. In your app, try to handle this error gracefully when a user decides not to provide access. The error was: %@. If you're using a simulator, try it on a device.", nil, nil)]);
+                return;
+            } else {
+                dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+                    callback(@[[NSNull null], @true]);
+                });
+            }
+            
+            
+        }];
+    } else {
+        callback(@[RCTMakeError(@"HealthKit not available....", nil, nil)]);
+    }
+}
+
+
+- (void)getHealthKitUserWeight:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback
+{
+    NSMassFormatter *massFormatter = [[NSMassFormatter alloc] init];
+    massFormatter.unitStyle = NSFormattingUnitStyleLong;
+    
+    //    NSMassFormatterUnit weightFormatterUnit = NSMassFormatterUnitPound;
+    //    NSString *weightUnitString = [massFormatter unitStringFromValue:10 unit:weightFormatterUnit];
+    //    NSString *localizedWeightUnitDescriptionFormat = NSLocalizedString(@"Weight (%@)", nil);
+    
+    // Query to get the user's latest weight, if it exists.
+    HKQuantityType *weightType = [HKQuantityType quantityTypeForIdentifier:HKQuantityTypeIdentifierBodyMass];
+    
+    [self fetchMostRecentQuantitySampleOfType:weightType predicate:nil completion:^(HKQuantity *mostRecentQuantity, NSError *error) {
+        if (!mostRecentQuantity) {
+            NSLog(@"Either an error occured fetching the user's weight information or none has been stored yet. In your app, try to handle this gracefully.");
+            callback(@[RCTMakeError(@"Either an error occured fetching the user's weight information or none has been stored yet. In your app, try to handle this gracefully.", nil, nil)]);
+        }
+        else {
+            // Determine the weight in the required unit.
+            HKUnit *weightUnit = [HKUnit poundUnit];
+            double usersWeight = [mostRecentQuantity doubleValueForUnit:weightUnit];
+            
+            callback(@[[NSNull null], @(usersWeight)]);
+            //      dispatch_async(dispatch_get_main_queue(), ^{
+            //      });
+        }
+    }];
+}
+
+
+- (void)saveHealthKitUserWeight:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback
+{
+    double weight= [[input objectForKey:@"weight"] doubleValue];
+    
+    HKUnit *poundUnit = [HKUnit poundUnit];
+    HKQuantity *weightQuantity = [HKQuantity quantityWithUnit:poundUnit doubleValue:weight];
+    
+    HKQuantityType *weightType = [HKQuantityType quantityTypeForIdentifier:HKQuantityTypeIdentifierBodyMass];
+    NSDate *now = [NSDate date];
+    
+    HKQuantitySample *weightSample = [HKQuantitySample quantitySampleWithType:weightType quantity:weightQuantity startDate:now endDate:now];
+    
+    [self.healthStore saveObject:weightSample withCompletion:^(BOOL success, NSError *error) {
+        if (!success) {
+            NSLog(@"An error occured saving the weight sample %@. In your app, try to handle this gracefully. The error was: %@.", weightSample, error);
+            callback(@[RCTMakeError(@"An error occured saving the weight sample", nil, nil)]);
+            return;
+            // abort();
+        }
+        callback(@[[NSNull null], @(weight)]);
+    }];
+}
+
+
+- (void)getHealthKitUserStepCount:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback
+{
+    HKQuantityType *stepCountType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierStepCount];
+    HKUnit *stepsUnit = [HKUnit countUnit];
+    
+    [self fetchSumOfSamplesTodayForType:stepCountType unit:stepsUnit completion:^(double totalSteps, NSError *error) {
+        if (!totalSteps) {
+            NSLog(@"Either an error occured fetching the user's step count information or none has been stored yet. In your app, try to handle this gracefully.");
+            callback(@[RCTMakeError(@"Either an error occured fetching the user's step count information or none has been stored yet. In your app, try to handle this gracefully.", nil, nil)]);
+            return;
+        }
+        
+        callback(@[[NSNull null], @(totalSteps)]);
+    }];
+}
+
+
+
+- (void)getModuleInfo:(NSDictionary *)input callback:(RCTResponseSenderBlock)callback
+{
+    callback(@[[NSNull null], @"ReactNative Apple HealthKit Native Module. Created By Greg Wilson."]);
+}
+
+
+
+
+@end

README.md

+### RCTAppleHealthKit
+

index.js

+'use strict'
+
+let { RCTAppleHealthKit } = require('react-native').NativeModules;
+module.exports = RCTAppleHealthKit;

package.json

+{
+  "name": "react-native-apple-healthkit",
+  "version": "0.0.1",
+  "description": "A React Native bridge module for interacting with Apple HealthKit data",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "github.com:GregWilson/RCTAppleHealthKit.git"
+  },
+  "keywords": [
+    "Apple",
+    "HealthKit",
+	"health-kit",
+    "ReactNative",
+	"react-native"
+  ],
+  "author": "Greg Wilson",
+  "license": "MIT",
+  "devDependencies": {
+    "react-native": "^0.28.0"
+  },
+  "peerDependencies": {
+    "react-native": "^0.28.0"
+  }
+}