public void FetchMetersWalked(Action <double> completionHandler)
        {
            var calendar          = NSCalendar.CurrentCalendar;
            var startDate         = DateTime.Today;
            var endDate           = DateTime.Now;
            var stepsQuantityType = HKQuantityType.Create(HKQuantityTypeIdentifier.DistanceWalkingRunning);

            var predicate = HKQuery.GetPredicateForSamples((NSDate)startDate, (NSDate)endDate, HKQueryOptions.StrictStartDate);

            var query = new HKStatisticsQuery(stepsQuantityType, predicate, HKStatisticsOptions.CumulativeSum,
                                              (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) =>
            {
                if (error != null && completionHandler != null)
                {
                    completionHandler(0);
                }

                var distance = results.SumQuantity();
                if (distance == null)
                {
                    distance = HKQuantity.FromQuantity(HKUnit.Meter, 0);
                }

                completionHandler(distance.GetDoubleValue(HKUnit.Meter));
            });

            HealthStore.ExecuteQuery(query);
        }
        public void FetchSteps(Action <double> completionHandler)
        {
            var calendar          = NSCalendar.CurrentCalendar;
            var startDate         = DateTime.Today;
            var endDate           = DateTime.Now;
            var stepsQuantityType = HKQuantityType.Create(HKQuantityTypeIdentifier.StepCount);

            var predicate = HKQuery.GetPredicateForSamples((NSDate)startDate, (NSDate)endDate, HKQueryOptions.StrictStartDate);

            var query = new HKStatisticsQuery(stepsQuantityType, predicate, HKStatisticsOptions.CumulativeSum,
                                              (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) =>
            {
                if (error != null && completionHandler != null)
                {
                    completionHandler(0.0f);
                }

                var totalSteps = results.SumQuantity();
                if (totalSteps == null)
                {
                    totalSteps = HKQuantity.FromQuantity(HKUnit.Count, 0.0);
                }

                completionHandler(totalSteps.GetDoubleValue(HKUnit.Count));
            });

            HealthStore.ExecuteQuery(query);
        }
        void FetchMostRecentData(Action <double, NSError> completionHandler)
        {
            var calendar  = NSCalendar.CurrentCalendar;
            var startDate = DateTime.Now.Date;
            var endDate   = startDate.AddDays(1);

            var sampleType = HKQuantityType.GetQuantityType(HKQuantityTypeIdentifierKey.DietaryEnergyConsumed);
            var predicate  = HKQuery.GetPredicateForSamples((NSDate)startDate, (NSDate)endDate, HKQueryOptions.StrictStartDate);

            var query = new HKStatisticsQuery(sampleType, predicate, HKStatisticsOptions.CumulativeSum,
                                              (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) => {
                if (error != null && completionHandler != null)
                {
                    completionHandler(0.0f, error);
                }

                var totalCalories = results.SumQuantity();
                if (totalCalories == null)
                {
                    totalCalories = HKQuantity.FromQuantity(HKUnit.Joule, 0.0);
                }

                if (completionHandler != null)
                {
                    completionHandler(totalCalories.GetDoubleValue(HKUnit.Joule), error);
                }
            });

            HealthStore.ExecuteQuery(query);
        }
        public async Task <int> QueryTotalFlights()
        {
            var flightsCount         = HKObjectType.GetQuantityType(HKQuantityTypeIdentifierKey.FlightsClimbed);
            var sumOptions           = HKStatisticsOptions.CumulativeSum;
            int totalRecordetFlights = 0;
            var query = new HKStatisticsQuery(flightsCount, new NSPredicate(IntPtr.Zero), sumOptions, (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) => {
                if (results != null)
                {
                    var quantitySample   = results;
                    totalRecordetFlights = (int)quantitySample.SumQuantity().GetDoubleValue(HKUnit.Count);
                    HealthKitDataContext.ActiveHealthKitData.DistanceReadings.TotalFlightsClimed = totalRecordetFlights;
                    Console.WriteLine(string.Format("totally walked {0} flights", totalRecordetFlights));
                }
            });
            await Task.Factory.StartNew(() => HealthKitStore.ExecuteQuery(query));

            return(totalRecordetFlights);
        }
        public async Task <string> QueryTotalStepsRecordingLastRecordingDate()
        {
            var    stepsCount   = HKObjectType.GetQuantityType(HKQuantityTypeIdentifierKey.StepCount);
            var    sumOptions   = HKStatisticsOptions.CumulativeSum;
            string resultString = string.Empty;
            var    query        = new HKStatisticsQuery(stepsCount, new NSPredicate(IntPtr.Zero), sumOptions, (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) => {
                if (results != null)
                {
                    var quantitySample = results;
                    var quantity       = quantitySample.EndDate;
                    //	resultString = quantity.ToString();
                    HealthKitDataContext.ActiveHealthKitData.DistanceReadings.RecordingStoped = quantity.ToString();
                    Console.WriteLine(string.Format("Last recording of steps: {0} ", quantity.ToString()));
                }
            });
            await Task.Factory.StartNew(() => HealthKitStore.ExecuteQuery(query));

            return(resultString);
        }
        public async Task <double> QueryTotalLengthWalked()
        {
            var    stepsCount        = HKObjectType.GetQuantityType(HKQuantityTypeIdentifierKey.DistanceWalkingRunning);
            var    sumOptions        = HKStatisticsOptions.CumulativeSum;
            double totalLengthWalked = 0;
            var    query             = new HKStatisticsQuery(stepsCount, new NSPredicate(IntPtr.Zero), sumOptions, (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) => {
                if (results != null)
                {
                    var quantitySample = results;
                    totalLengthWalked  = quantitySample.SumQuantity().GetDoubleValue(HKUnit.Meter);

                    HealthKitDataContext.ActiveHealthKitData.DistanceReadings.TotalDistance = totalLengthWalked;
                    Console.WriteLine(string.Format("totally walked {0}", totalLengthWalked));
                }
            });
            await Task.Factory.StartNew(() => HealthKitStore.ExecuteQuery(query));

            return(totalLengthWalked);
        }
		void FetchMostRecentData (Action <double, NSError> completionHandler)
		{
			var calendar = NSCalendar.CurrentCalendar;
			var startDate = DateTime.Now.Date;
			var endDate = startDate.AddDays (1);

			var sampleType = HKQuantityType.GetQuantityType (HKQuantityTypeIdentifierKey.DietaryEnergyConsumed);
			var predicate = HKQuery.GetPredicateForSamples ((NSDate)startDate, (NSDate)endDate, HKQueryOptions.StrictStartDate);

			var query = new HKStatisticsQuery (sampleType, predicate, HKStatisticsOptions.CumulativeSum,
				            (HKStatisticsQuery resultQuery, HKStatistics results, NSError error) => {

					if (error != null && completionHandler != null)
						completionHandler (0.0f, error);

					var totalCalories = results.SumQuantity ();
					if (totalCalories == null)
						totalCalories = HKQuantity.FromQuantity (HKUnit.Joule, 0.0);

					if (completionHandler != null)
						completionHandler (totalCalories.GetDoubleValue (HKUnit.Joule), error);
			});

			HealthStore.ExecuteQuery (query);
		}