/// <summary>
/// Returns steps for given day at given resolution
/// </summary>
/// <param name="day">Day to fetch data for</param>
/// <param name="resolution">Resolution in minutes. Minimum resolution is five minutes.</param>
/// <returns>List of steps counts for the given day at given resolution.</returns>
public async Task <List <KeyValuePair <TimeSpan, uint> > > GetStepsCountsForDay(DateTime day, uint resolution)
{
List <KeyValuePair <TimeSpan, uint> > steps = new List <KeyValuePair <TimeSpan, uint> >();
uint numIntervals = (((24 * 60) / resolution) + 1);
if (day.Date.Equals(DateTime.Today))
{
numIntervals = (uint)((DateTime.Now - DateTime.Today).TotalMinutes / resolution) + 1;
}
uint totalSteps = 0;
for (uint i = 0; i < numIntervals; i++)
{
TimeSpan ts = TimeSpan.FromMinutes(i * resolution);
DateTime startTime = day.Date + ts;
if (startTime < DateTime.Now)
{
// Get history from startTime to the resolution duration
var readings = await Pedometer.GetSystemHistoryAsync(startTime, TimeSpan.FromMinutes(resolution));
// Compute the deltas
var stepsDelta = StepCountData.FromPedometerReadings(readings);
// Add to the total count
totalSteps += stepsDelta.TotalCount;
steps.Add(new KeyValuePair <TimeSpan, uint>(ts, totalSteps));
}
else
{
break;
}
}
return(steps);
}
/// <summary>
/// Returns step count for given day
/// </summary>
/// <returns>Step count for given day</returns>
public async Task <StepCountData> GetTotalStepCountAsync(DateTime day)
{
// Get history from 1 day
var readings = await Pedometer.GetSystemHistoryAsync(day.Date, TimeSpan.FromDays(1));
return(StepCountData.FromPedometerReadings(readings));
}
/// <summary>
/// Gets number of steps for current day
/// </summary>
/// <returns><c>true</c> if steps were successfully fetched, <c>false</c> otherwise</returns>
private async Task <bool> GetStepsAsync()
{
// First try the pedometer
try
{
var readings = await Pedometer.GetSystemHistoryAsync(DateTime.Now.Date, DateTime.Now - DateTime.Now.Date);
_steps = StepCountData.FromPedometerReadings(readings);
return(true);
}
catch (Exception)
{
// Continue to the fallback
}
// Fall back to using Lumia Sensor Core.
IStepCounter stepCounter = null;
try
{
//var qualifiers = Windows.ApplicationModel.Resources.Core.ResourceContext.GetForCurrentView().QualifierValues;
if (DeviceTypeHelper.GetDeviceFormFactorType() == DeviceFormFactorType.Phone)
{
stepCounter = await StepCounter.GetDefaultAsync();
StepCount count = await stepCounter.GetStepCountForRangeAsync(DateTime.Now.Date, DateTime.Now - DateTime.Now.Date);
_steps = StepCountData.FromLumiaStepCount(count);
}
else
{
var obj = await SenseRecording.LoadFromFileAsync("Simulations\\short recording.txt");
if (!await CallSensorCoreApiAsync(async() => {
stepCounter = await StepCounterSimulator.GetDefaultAsync(obj, DateTime.Now - TimeSpan.FromHours(12));
StepCount count = await stepCounter.GetStepCountForRangeAsync(DateTime.Now.Date, DateTime.Now - DateTime.Now.Date);
_steps = StepCountData.FromLumiaStepCount(count);
}))
{
return(false);
}
}
}
catch (Exception e)
{
_lastError = SenseHelper.GetSenseError(e.HResult);
return(false);
}
finally
{
if (stepCounter != null && typeof(StepCounter) == stepCounter.GetType())
{
((StepCounter)stepCounter).Dispose();
}
}
return(true);
}
/// <summary>
/// Invoked when 'GetCurrentButton' is clicked.
/// 'ReadingChanged' will not be fired when there is no activity on the pedometer
/// and hence can't be reliably used to get the current step count. This handler makes
/// use of pedometer history on the system to get the current step count of the parameter
/// </summary>
async private void GetCurrentButton_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
DateTime dt = DateTime.FromFileTimeUtc(0);
int totalStepCount = 0;
int lastTotalCount = 0;
rootPage.NotifyUser("Retrieving history to get current step counts", NotifyType.StatusMessage);
// Disable the button while we get the history
GetCurrentButton.IsEnabled = false;
DateTimeOffset fromBeginning = new DateTimeOffset(dt);
IReadOnlyList <PedometerReading> historyReadings = await Pedometer.GetSystemHistoryAsync(fromBeginning);
// History always returns chronological list of step counts for all PedometerStepKinds
// And each record represents cumulative step counts for that step kind.
// So we will use the last set of records - that gives us the cumulative step count for
// each kind and ignore rest of the records
PedometerStepKind stepKind = PedometerStepKind.Unknown;
DateTimeOffset lastReadingTimestamp;
bool resetTotal = false;
foreach (PedometerReading reading in historyReadings)
{
if (stepKind == PedometerStepKind.Running)
{
// reset the total after reading the 'PedometerStepKind.Running' count
resetTotal = true;
}
totalStepCount += reading.CumulativeSteps;
if (resetTotal)
{
lastReadingTimestamp = reading.Timestamp;
lastTotalCount = totalStepCount;
stepKind = PedometerStepKind.Unknown;
totalStepCount = 0;
resetTotal = false;
}
else
{
stepKind++;
}
}
ScenarioOutput_TotalStepCount.Text = lastTotalCount.ToString();
DateTimeFormatter timestampFormatter = new DateTimeFormatter("shortdate longtime");
ScenarioOutput_Timestamp.Text = timestampFormatter.Format(lastReadingTimestamp);
rootPage.NotifyUser("Hit the 'Get steps count' Button", NotifyType.StatusMessage);
GetCurrentButton.IsEnabled = true;
}
/// <summary>
/// Gets number of steps for current day
/// </summary>
/// <returns><c>true</c> if steps were successfully fetched, <c>false</c> otherwise</returns>
private async Task <bool> GetStepsAsync()
{
// First try the pedometer
try
{
var readings = await Pedometer.GetSystemHistoryAsync(DateTime.Now.Date, DateTime.Now - DateTime.Now.Date);
_steps = StepCountData.FromPedometerReadings(readings);
return(true);
}
catch (Exception)
{
// Continue to the fallback
}
// Fall back to using Lumia Sensor Core.
StepCounter stepCounter = null;
try
{
stepCounter = await StepCounter.GetDefaultAsync();
StepCount count = await stepCounter.GetStepCountForRangeAsync(
DateTime.Now.Date,
DateTime.Now - DateTime.Now.Date);
_steps = StepCountData.FromLumiaStepCount(count);
}
catch (Exception e)
{
_lastError = SenseHelper.GetSenseError(e.HResult);
return(false);
}
finally
{
if (stepCounter != null)
{
stepCounter.Dispose();
}
}
return(true);
}
public async Task <List <ReadingByDate> > GetStepsForHour(int hour, int days)
{
List <ReadingByDate> stepsByDay = new List <ReadingByDate>();
for (int i = 0; i < days; i++)
{
var dateTime = DateTime.Now.Subtract(TimeSpan.FromDays(i));
var stepsForDay = await Pedometer.GetSystemHistoryAsync(dateTime, TimeSpan.FromHours(hour));
var data = StepCountData.FromPedometerReadings(stepsForDay);
stepsByDay.Add(new ReadingByDate
{
DateTime = dateTime.AddHours(hour),
RunningStepsCount = data.RunningCount,
WalkingStepsCount = data.WalkingCount,
TotalStepsCount = data.TotalCount
});
}
return(stepsByDay);
}
/// <summary>
/// Invoked when 'Get History' button is clicked.
/// Depending on the user selection, this handler uses one of the overloaded
/// 'GetSystemHistoryAsync' APIs to retrieve the pedometer history of the user
/// </summary>
/// <param name="sender">unused</param>
/// <param name="e">unused</param>
async private void GetHistory_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
IReadOnlyList <PedometerReading> historyReadings = null;
DateTimeFormatter timestampFormatter = new DateTimeFormatter("shortdate longtime");
// Disable subsequent history retrieval while the async operation is in progress
GetHistory.IsEnabled = false;
// clear previous content being displayed
historyRecords.Clear();
try
{
if (getAllHistory)
{
DateTime dt = DateTime.FromFileTimeUtc(0);
DateTimeOffset fromBeginning = new DateTimeOffset(dt);
rootPage.NotifyUser("Retrieving all available History", NotifyType.StatusMessage);
historyReadings = await Pedometer.GetSystemHistoryAsync(fromBeginning);
}
else
{
String notificationString = "Retrieving history from: ";
Calendar calendar = new Calendar();
calendar.ChangeClock("24HourClock");
// DateTime picker will also include hour, minute and seconds from the the system time.
// Decrement the same to be able to correctly add TimePicker values.
calendar.SetDateTime(FromDate.Date);
calendar.AddNanoseconds(-calendar.Nanosecond);
calendar.AddSeconds(-calendar.Second);
calendar.AddMinutes(-calendar.Minute);
calendar.AddHours(-calendar.Hour);
calendar.AddSeconds(Convert.ToInt32(FromTime.Time.TotalSeconds));
DateTimeOffset fromTime = calendar.GetDateTime();
calendar.SetDateTime(ToDate.Date);
calendar.AddNanoseconds(-calendar.Nanosecond);
calendar.AddSeconds(-calendar.Second);
calendar.AddMinutes(-calendar.Minute);
calendar.AddHours(-calendar.Hour);
calendar.AddSeconds(Convert.ToInt32(ToTime.Time.TotalSeconds));
DateTimeOffset toTime = calendar.GetDateTime();
notificationString += timestampFormatter.Format(fromTime);
notificationString += " To ";
notificationString += timestampFormatter.Format(toTime);
if (toTime.ToFileTime() < fromTime.ToFileTime())
{
rootPage.NotifyUser("Invalid time span. 'To Time' must be equal or more than 'From Time'", NotifyType.ErrorMessage);
// Enable subsequent history retrieval while the async operation is in progress
GetHistory.IsEnabled = true;
}
else
{
TimeSpan span;
span = TimeSpan.FromTicks(toTime.Ticks - fromTime.Ticks);
rootPage.NotifyUser(notificationString, NotifyType.StatusMessage);
historyReadings = await Pedometer.GetSystemHistoryAsync(fromTime, span);
}
}
if (historyReadings != null)
{
foreach (PedometerReading reading in historyReadings)
{
HistoryRecord record = new HistoryRecord(reading);
historyRecords.Add(record);
}
rootPage.NotifyUser("History retrieval completed", NotifyType.StatusMessage);
}
}
catch (UnauthorizedAccessException)
{
rootPage.NotifyUser("User has denied access to activity history", NotifyType.ErrorMessage);
}
// Finally, re-enable history retrieval
GetHistory.IsEnabled = true;
}
/// <summary>
/// Invoked when 'GetCurrentButton' is clicked.
/// 'ReadingChanged' will not be fired when there is no activity on the pedometer
/// and hence can't be reliably used to get the current step count. This handler makes
/// use of pedometer history on the system to get the current step count of the parameter
/// </summary>
async private void GetCurrentButton_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
// Determine if we can access pedometers
var deviceAccessInfo = DeviceAccessInformation.CreateFromDeviceClassId(PedometerClassId);
if (deviceAccessInfo.CurrentStatus == DeviceAccessStatus.Allowed)
{
// Determine if a pedometer is present
// This can also be done using Windows::Devices::Enumeration::DeviceInformation::FindAllAsync
var sensor = await Pedometer.GetDefaultAsync();
if (sensor != null)
{
DateTime dt = DateTime.FromFileTimeUtc(0);
int totalStepCount = 0;
int lastTotalCount = 0;
rootPage.NotifyUser("Retrieving history to get current step counts", NotifyType.StatusMessage);
// Disable the button while we get the history
GetCurrentButton.IsEnabled = false;
DateTimeOffset fromBeginning = new DateTimeOffset(dt);
try
{
var historyReadings = await Pedometer.GetSystemHistoryAsync(fromBeginning);
// History always returns chronological list of step counts for all PedometerStepKinds
// And each record represents cumulative step counts for that step kind.
// So we will use the last set of records - that gives us the cumulative step count for
// each kind and ignore rest of the records
PedometerStepKind stepKind = PedometerStepKind.Unknown;
DateTimeOffset lastReadingTimestamp;
bool resetTotal = false;
foreach (PedometerReading reading in historyReadings)
{
if (stepKind == PedometerStepKind.Running)
{
// reset the total after reading the 'PedometerStepKind.Running' count
resetTotal = true;
}
totalStepCount += reading.CumulativeSteps;
if (resetTotal)
{
lastReadingTimestamp = reading.Timestamp;
lastTotalCount = totalStepCount;
stepKind = PedometerStepKind.Unknown;
totalStepCount = 0;
resetTotal = false;
}
else
{
stepKind++;
}
}
ScenarioOutput_TotalStepCount.Text = lastTotalCount.ToString();
DateTimeFormatter timestampFormatter = new DateTimeFormatter("shortdate longtime");
ScenarioOutput_Timestamp.Text = timestampFormatter.Format(lastReadingTimestamp);
rootPage.NotifyUser("Hit the 'Get steps count' Button", NotifyType.StatusMessage);
}
catch (UnauthorizedAccessException)
{
rootPage.NotifyUser("User has denied access to activity history", NotifyType.ErrorMessage);
}
// Re-enable button
GetCurrentButton.IsEnabled = true;
}
else
{
rootPage.NotifyUser("No pedometers found", NotifyType.ErrorMessage);
}
}
else
{
rootPage.NotifyUser("Access to pedometers is denied", NotifyType.ErrorMessage);
}
}
/// <summary>
/// Invoked when 'Get History' button is clicked.
/// Depending on the user selection, this handler uses one of the overloaded
/// 'GetSystemHistoryAsync' APIs to retrieve the pedometer history of the user
/// </summary>
/// <param name="sender">unused</param>
/// <param name="e">unused</param>
async private void GetHistory_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
GetHistory.IsEnabled = false;
// Determine if we can access pedometers
var deviceAccessInfo = DeviceAccessInformation.CreateFromDeviceClassId(PedometerClassId);
if (deviceAccessInfo.CurrentStatus == DeviceAccessStatus.Allowed)
{
// Determine if a pedometer is present
// This can also be done using Windows::Devices::Enumeration::DeviceInformation::FindAllAsync
var sensor = await Pedometer.GetDefaultAsync();
if (sensor != null)
{
IReadOnlyList <PedometerReading> historyReadings = null;
var timestampFormatter = new DateTimeFormatter("shortdate longtime");
// Disable subsequent history retrieval while the async operation is in progress
GetHistory.IsEnabled = false;
// clear previous content being displayed
historyRecords.Clear();
try
{
if (getAllHistory)
{
var dt = DateTime.FromFileTimeUtc(0);
var fromBeginning = new DateTimeOffset(dt);
rootPage.NotifyUser("Retrieving all available History", NotifyType.StatusMessage);
historyReadings = await Pedometer.GetSystemHistoryAsync(fromBeginning);
}
else
{
String notificationString = "Retrieving history from: ";
var calendar = new Calendar();
calendar.ChangeClock("24HourClock");
// DateTime picker will also include hour, minute and seconds from the the system time.
// Decrement the same to be able to correctly add TimePicker values.
calendar.SetDateTime(FromDate.Date);
calendar.AddNanoseconds(-calendar.Nanosecond);
calendar.AddSeconds(-calendar.Second);
calendar.AddMinutes(-calendar.Minute);
calendar.AddHours(-calendar.Hour);
calendar.AddSeconds(Convert.ToInt32(FromTime.Time.TotalSeconds));
DateTimeOffset fromTime = calendar.GetDateTime();
calendar.SetDateTime(ToDate.Date);
calendar.AddNanoseconds(-calendar.Nanosecond);
calendar.AddSeconds(-calendar.Second);
calendar.AddMinutes(-calendar.Minute);
calendar.AddHours(-calendar.Hour);
calendar.AddSeconds(Convert.ToInt32(ToTime.Time.TotalSeconds));
DateTimeOffset toTime = calendar.GetDateTime();
notificationString += timestampFormatter.Format(fromTime);
notificationString += " To ";
notificationString += timestampFormatter.Format(toTime);
if (toTime.ToFileTime() < fromTime.ToFileTime())
{
rootPage.NotifyUser("Invalid time span. 'To Time' must be equal or more than 'From Time'", NotifyType.ErrorMessage);
// Enable subsequent history retrieval while the async operation is in progress
GetHistory.IsEnabled = true;
}
else
{
TimeSpan span = TimeSpan.FromTicks(toTime.Ticks - fromTime.Ticks);
rootPage.NotifyUser(notificationString, NotifyType.StatusMessage);
historyReadings = await Pedometer.GetSystemHistoryAsync(fromTime, span);
}
}
if (historyReadings != null)
{
foreach (PedometerReading reading in historyReadings)
{
HistoryRecord record = new HistoryRecord(reading);
historyRecords.Add(record);
// Get at most 100 records (number is arbitrary chosen for demonstration purposes)
if (historyRecords.Count == 100)
{
break;
}
}
rootPage.NotifyUser("History retrieval completed", NotifyType.StatusMessage);
}
}
catch (UnauthorizedAccessException)
{
rootPage.NotifyUser("User has denied access to activity history", NotifyType.ErrorMessage);
}
// Finally, re-enable history retrieval
GetHistory.IsEnabled = true;
}
else
{
rootPage.NotifyUser("No pedometers found", NotifyType.ErrorMessage);
}
}
else
{
rootPage.NotifyUser("Access to pedometers is denied", NotifyType.ErrorMessage);
}
}
