/// <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()
{
StepCounter stepCounter = null;
try
{
stepCounter = await StepCounter.GetDefaultAsync();
_steps = await stepCounter.GetStepCountForRangeAsync(
DateTime.Now.Date,
DateTime.Now - DateTime.Now.Date);
}
catch (Exception e)
{
_lastError = SenseHelper.GetSenseError(e.HResult);
return(false);
}
finally
{
if (stepCounter != null)
{
stepCounter.Dispose();
}
}
return(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.
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>
/// Initializes StepCounter
/// </summary>
private async Task InitializeSensorAsync()
{
if (_stepCounter == null)
{
await CallSensorCoreApiAsync(async() => { _stepCounter = await StepCounter.GetDefaultAsync(); });
}
else
{
await _stepCounter.ActivateAsync();
}
_sensorActive = 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);
}
/// <summary>
/// Initializes sensor
/// </summary>
/// <returns>Asynchronous task</returns>
private async Task Initialize()
{
if (!await StepCounter.IsSupportedAsync())
{
MessageDialog dlg = new MessageDialog("Unfortunately this device does not support step counting");
await dlg.ShowAsync();
}
else
{
MotionDataSettings settings = await SenseHelper.GetSettingsAsync();
// Starting from version 2 of Motion data settings Step counter and Acitivity monitor are always available. In earlier versions system
// location setting and Motion data had to be enabled.
if (settings.Version < 2)
{
if (!settings.LocationEnabled)
{
MessageDialog dlg = new MessageDialog("In order to count steps you need to enable location in system settings. Do you want to open settings now?", "Information");
dlg.Commands.Add(new UICommand("Yes", new UICommandInvokedHandler(async(cmd) => await SenseHelper.LaunchLocationSettingsAsync())));
dlg.Commands.Add(new UICommand("No"));
await dlg.ShowAsync();
}
else if (!settings.PlacesVisited)
{
MessageDialog dlg = new MessageDialog("In order to count steps you need to enable Motion data collection in Motion data settings. Do you want to open settings now?", "Information");
dlg.Commands.Add(new UICommand("Yes", new UICommandInvokedHandler(async(cmd) => await SenseHelper.LaunchSenseSettingsAsync())));
dlg.Commands.Add(new UICommand("No"));
await dlg.ShowAsync();
}
}
}
if (!await CallSenseApiAsync(async() =>
{
_stepCounter = await StepCounter.GetDefaultAsync();
}))
{
Application.Current.Exit();
}
await SetSelectedDayAsync(_selectedDay);
}
private async Task InitializeSensorAsync()
{
Exception failure = null;
if (!await StepCounter.IsSupportedAsync())
{
MessageBox.Show(
"Your device doesn't support Motion Data. Application will be closed",
"Information", MessageBoxButton.OK);
Application.Current.Terminate();
}
try
{
_stepCounter = await StepCounter.GetDefaultAsync();
}
catch (Exception e)
{
failure = e;
}
if (failure != null)
{
switch (SenseHelper.GetSenseError(failure.HResult))
{
case SenseError.LocationDisabled:
case SenseError.SenseDisabled:
NavigationService.Navigate(new Uri("/ActivateSensorCore;component/Pages/ActivateSensorCore.xaml", UriKind.Relative));
break;
default:
throw (failure);
}
}
else
{
await _stepCounter.ActivateAsync();
await UpdateModelAsync();
}
}
public MainPage()
{
this.InitializeComponent();
this.NavigationCacheMode = NavigationCacheMode.Required;
Window.Current.VisibilityChanged += async(oo, ee) =>
{
if (ee.Visible)
{
if (await CallSensorcoreApiAsync(async() =>
{
if (_stepCounter == null)
{
// Get sensor instance if needed...
_stepCounter = await StepCounter.GetDefaultAsync();
}
else
{
// ... otherwise just activate it
await _stepCounter.ActivateAsync();
}
}))
{
// Display current reading whenever application is brought to foreground
await ShowCurrentReading();
}
}
else
{
// Sensor needs to be deactivated when application is put to background
if (_stepCounter != null)
{
await CallSensorcoreApiAsync(async() => await _stepCounter.DeactivateAsync());
}
}
};
}
public async void initialize(string options)
{
PluginResult result = new PluginResult(PluginResult.Status.OK);
result.KeepCallback = true;
try
{
if (await StepCounter.IsSupportedAsync())
{
stepCounter = await StepCounter.GetDefaultAsync();
isReady = true;
}
DispatchCommandResult(result);
}
catch (Exception ex)
{
result.Message = JsonHelper.Serialize(new { error = "init", message = ex.Message });
DispatchCommandResult(result);
}
}
/// <summary>
/// Initialize SensorCore
/// </summary>
/// <param name="rec">Recording instance</param>
/// <param name="type">Sense type</param>
/// <returns>Asynchronous task</returns>
private async Task HandleSensorActivity(Recording rec, SenseType type)
{
if (rec.Recorder == null)
{
if (await CallSensorcoreApiAsync(async() =>
{
switch (type)
{
case SenseType.Activity:
_aMonitor = await ActivityMonitor.GetDefaultAsync();
break;
case SenseType.Places:
_pMonitor = await PlaceMonitor.GetDefaultAsync();
break;
case SenseType.Route:
_rTracker = await TrackPointMonitor.GetDefaultAsync();
break;
case SenseType.Steps:
_sCounter = await StepCounter.GetDefaultAsync();
break;
}
}))
{
Debug.WriteLine("Recorder initialized.");
switch (type)
{
case SenseType.Activity:
rec.Recorder = new SenseRecorder(_aMonitor);
break;
case SenseType.Places:
rec.Recorder = new SenseRecorder(_pMonitor);
break;
case SenseType.Route:
rec.Recorder = new SenseRecorder(_rTracker);
break;
case SenseType.Steps:
rec.Recorder = new SenseRecorder(_sCounter);
break;
}
}
else
{
return;
}
}
if (rec.Recorder == null)
{
return;
}
else
{
await ActivateAsync();
switch (rec.ItemState)
{
case Status.Recording:
await rec.Recorder.StartAsync();
break;
case Status.Stopped:
await rec.Recorder.StopAsync();
break;
case Status.Empty:
await rec.Recorder.GetRecording().SaveAsync();
break;
}
}
}
