/// <summary> /// This is the click handler for the 'Reading Changed On' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void ScenarioEnableReadingChanged(object sender, RoutedEventArgs e) { // Determine if we can access activity sensors if (_deviceAccessInformation.CurrentStatus == DeviceAccessStatus.Allowed) { if (_activitySensor == null) { _activitySensor = await ActivitySensor.GetDefaultAsync(); } if (_activitySensor != null) { _activitySensor.SubscribedActivities.Add(ActivityType.Walking); _activitySensor.SubscribedActivities.Add(ActivityType.Running); _activitySensor.SubscribedActivities.Add(ActivityType.InVehicle); _activitySensor.SubscribedActivities.Add(ActivityType.Biking); _activitySensor.SubscribedActivities.Add(ActivityType.Fidgeting); _activitySensor.ReadingChanged += new TypedEventHandler <ActivitySensor, ActivitySensorReadingChangedEventArgs>(ReadingChanged); ScenarioEnableReadingChangedButton.IsEnabled = false; ScenarioDisableReadingChangedButton.IsEnabled = true; rootPage.NotifyUser("Subscribed to reading changes", NotifyType.StatusMessage); } else { rootPage.NotifyUser("No activity sensor found", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("Access denied to activity sensors", NotifyType.ErrorMessage); } }
private async void EnableActivityDetectionAsync() { var deviceAccessInfo = DeviceAccessInformation.CreateFromDeviceClassId(ActivitySensorClassId); // Determine if we can access activity sensors if (deviceAccessInfo.CurrentStatus == DeviceAccessStatus.Allowed) { if (activitySensor == null) { activitySensor = await ActivitySensor.GetDefaultAsync(); } if (activitySensor != null) { activitySensor.SubscribedActivities.Add(ActivityType.Walking); activitySensor.SubscribedActivities.Add(ActivityType.Running); activitySensor.SubscribedActivities.Add(ActivityType.Fidgeting); activitySensor.SubscribedActivities.Add(ActivityType.Stationary); activitySensor.ReadingChanged += new TypedEventHandler <ActivitySensor, ActivitySensorReadingChangedEventArgs>(ReadingChanged); Status.Text = "Subscribed to reading changes"; } else { Status.Text = "No activity sensor found"; } } else { Status.Text = "Access denied to activity sensors"; } }
/// <summary> /// This is the click handler for the 'Get Current Activity' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioGetCurrentActivity(object sender, RoutedEventArgs e) { // Reset fields and status ScenarioOutput_Activity.Text = "No data"; ScenarioOutput_Confidence.Text = "No data"; ScenarioOutput_Timestamp.Text = "No data"; rootPage.NotifyUser("", NotifyType.StatusMessage); // Get the default sensor var activitySensor = await ActivitySensor.GetDefaultAsync(); if (activitySensor) { // Get the current activity reading var reading = await activitySensor.GetCurrentReadingAsync(); ScenarioOutput_Activity.Text = reading.Activity.ToString(); ScenarioOutput_Confidence.Text = reading.Confidence.ToString(); ScenarioOutput_Timestamp.Text = reading.Timestamp.ToString("u"); } else { rootPage.NotifyUser("No activity sensor found", NotifyType.ErrorMessage); } }
async void OnLoaded(object sender, RoutedEventArgs e) { this.DataContext = this; // We should check that we have access to this sensor really rather // than just going for it as we do here. this.activitySensor = await ActivitySensor.GetDefaultAsync(); if (this.activitySensor != null) { var reading = await this.activitySensor.GetCurrentReadingAsync(); if (reading != null) { this.DisplayReading(reading); } // Subscribe to all the activities that the sensor supports. foreach (var activityType in Enum.GetValues(typeof(ActivityType))) { if (this.activitySensor.SupportedActivities.Contains((ActivityType)activityType)) { this.activitySensor.SubscribedActivities.Add((ActivityType)activityType); } } // Wait for new values to come through. this.activitySensor.ReadingChanged += OnReadingChanged; // Get the history for the past week var history = await ActivitySensor.GetSystemHistoryAsync( DateTimeOffset.Now - TimeSpan.FromDays(7)); this.ActivityHistory = new ObservableCollection <ActivitySensorReading>( history); } }
/// <summary> /// This is the click handler for the 'Get Activity History' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioGetActivityHistory(object sender, RoutedEventArgs e) { // Reset fields and status ScenarioOutput_Count.Text = "No data"; ScenarioOutput_Activity1.Text = "No data"; ScenarioOutput_Confidence1.Text = "No data"; ScenarioOutput_Timestamp1.Text = "No data"; ScenarioOutput_ActivityN.Text = "No data"; ScenarioOutput_ConfidenceN.Text = "No data"; ScenarioOutput_TimestampN.Text = "No data"; rootPage.NotifyUser("", NotifyType.StatusMessage); var calendar = new Calendar(); calendar.SetToNow(); calendar.AddDays(-1); var yesterday = calendar.GetDateTime(); // Get history from yesterday onwards var history = await ActivitySensor.GetSystemHistoryAsync(yesterday); ScenarioOutput_Count.Text = history.Count.ToString(); if (history.Count > 0) { var reading1 = history[0]; ScenarioOutput_Activity1.Text = reading1.Activity.ToString(); ScenarioOutput_Confidence1.Text = reading1.Confidence.ToString(); ScenarioOutput_Timestamp1.Text = reading1.Timestamp.ToString("u"); var readingN = history[history.Count - 1]; ScenarioOutput_ActivityN.Text = readingN.Activity.ToString(); ScenarioOutput_ConfidenceN.Text = readingN.Confidence.ToString(); ScenarioOutput_TimestampN.Text = readingN.Timestamp.ToString("u"); } }
/// <summary> /// This is the click handler for the 'Reading Changed On' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioEnableReadingChanged(object sender, RoutedEventArgs e) { if (null == _activitySensor) { _activitySensor = await ActivitySensor.GetDefaultAsync(); } if (_activitySensor) { _activitySensor.SubscribedActivities.Add(ActivityType.Walking); _activitySensor.SubscribedActivities.Add(ActivityType.Running); _activitySensor.SubscribedActivities.Add(ActivityType.InVehicle); _activitySensor.SubscribedActivities.Add(ActivityType.Biking); _activitySensor.SubscribedActivities.Add(ActivityType.Fidgeting); _activitySensor.ReadingChanged += new TypedEventHandler <ActivitySensor, ActivitySensorReadingChangedEventArgs>(ReadingChanged); ScenarioEnableReadingChangedButton.IsEnabled = false; ScenarioDisableReadingChangedButton.IsEnabled = true; } else { rootPage.NotifyUser("No activity sensor found", NotifyType.ErrorMessage); } }
/// <summary> /// This is the click handler for the 'Register Task' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioRegisterTask(object sender, RoutedEventArgs e) { // Determine if we can access activity sensors var deviceAccessInfo = DeviceAccessInformation.CreateFromDeviceClassId(ActivitySensorClassId); if (deviceAccessInfo.CurrentStatus == DeviceAccessStatus.Allowed) { // Determine if an activity sensor is present // This can also be done using Windows::Devices::Enumeration::DeviceInformation::FindAllAsync var activitySensor = await ActivitySensor.GetDefaultAsync(); if (activitySensor != null) { var status = await BackgroundExecutionManager.RequestAccessAsync(); if ((BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity == status) || (BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity == status)) { RegisterBackgroundTask(); } else { rootPage.NotifyUser("Background tasks may be disabled for this app", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("No activity sensors found", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("Access denied to activity sensors", NotifyType.ErrorMessage); } }
/// <summary> /// This is the click handler for the 'Status Changed On' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioEnableStatusChanged(object sender, RoutedEventArgs e) { try { if (null == _activitySensor) { _activitySensor = await ActivitySensor.GetDefaultAsync(); } if (null != _activitySensor) { _activitySensor.StatusChanged += new TypedEventHandler <ActivitySensor, ActivitySensorStatusChangedEventArgs>(StatusChanged); ScenarioEnableStatusChangedButton.IsEnabled = false; ScenarioDisableStatusChangedButton.IsEnabled = true; } else { rootPage.NotifyUser("No activity sensor found", NotifyType.ErrorMessage); } } catch (UnauthorizedAccessException) { rootPage.NotifyUser("User has denied access to the activity sensor", NotifyType.ErrorMessage); } }
public ActivityStateTrigger() { var watcher = DeviceInformation.CreateWatcher(ActivitySensor.GetDeviceSelector()); watcher.Added += OnActivitySensorAddedAsync; watcher.Removed += OnActivitySensorRemoved; watcher.Start(); }
public List <DeviceInfo> CreateList() { List <DeviceInfo> selectors = new List <DeviceInfo>(); // Pre-canned device class selectors selectors.Add(new DeviceInfo() { DisplayName = "All Device Interfaces (default)", DeviceClassSelector = DeviceClass.All, Selection = null }); selectors.Add(new DeviceInfo() { DisplayName = "Audio Capture", DeviceClassSelector = DeviceClass.AudioCapture, Selection = null }); selectors.Add(new DeviceInfo() { DisplayName = "Audio Render", DeviceClassSelector = DeviceClass.AudioRender, Selection = null }); selectors.Add(new DeviceInfo() { DisplayName = "Image Scanner", DeviceClassSelector = DeviceClass.ImageScanner, Selection = null }); selectors.Add(new DeviceInfo() { DisplayName = "Location", DeviceClassSelector = DeviceClass.Location, Selection = null }); selectors.Add(new DeviceInfo() { DisplayName = "Portable Storage", DeviceClassSelector = DeviceClass.PortableStorageDevice, Selection = null }); selectors.Add(new DeviceInfo() { DisplayName = "Video Capture", DeviceClassSelector = DeviceClass.VideoCapture, Selection = null }); // A few examples of selectors built dynamically by windows runtime apis. selectors.Add(new DeviceInfo() { DisplayName = "Human Interface (HID)", Selection = HidDevice.GetDeviceSelector(0, 0) }); selectors.Add(new DeviceInfo() { DisplayName = "Activity Sensor", Selection = ActivitySensor.GetDeviceSelector() }); selectors.Add(new DeviceInfo() { DisplayName = "Pedometer", Selection = Pedometer.GetDeviceSelector() }); selectors.Add(new DeviceInfo() { DisplayName = "Proximity", Selection = ProximityDevice.GetDeviceSelector() }); selectors.Add(new DeviceInfo() { DisplayName = "Proximity Sensor", Selection = ProximitySensor.GetDeviceSelector() }); return(selectors); }
public Scenario3_ChangeEvents() { this.InitializeComponent(); _activitySensor = null; // Register for access changed notifications for activity sensors _deviceAccessInformation = DeviceAccessInformation.CreateFromDeviceClassId(ActivitySensorClassId); _deviceAccessInformation.AccessChanged += new TypedEventHandler <DeviceAccessInformation, DeviceAccessChangedEventArgs>(AccessChanged); }
private async void ReadingChanged(ActivitySensor sender, ActivitySensorReadingChangedEventArgs args) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { ActivitySensorReading reading = args.Reading; SendMessage(reading.Activity.ToString()); }); }
public Scenario3_ChangeEvents() { this.InitializeComponent(); _activitySensor = null; // Register for access changed notifications for activity sensors _deviceAccessInformation = DeviceAccessInformation.CreateFromDeviceClassId(ActivitySensorClassId); _deviceAccessInformation.AccessChanged += new TypedEventHandler<DeviceAccessInformation, DeviceAccessChangedEventArgs>(AccessChanged); }
/// <summary> /// This is the click handler for the 'Get Activity History' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioGetActivityHistory(object sender, RoutedEventArgs e) { // Reset fields and status ScenarioOutput_Count.Text = "No data"; ScenarioOutput_Activity1.Text = "No data"; ScenarioOutput_Confidence1.Text = "No data"; ScenarioOutput_Timestamp1.Text = "No data"; ScenarioOutput_ActivityN.Text = "No data"; ScenarioOutput_ConfidenceN.Text = "No data"; ScenarioOutput_TimestampN.Text = "No data"; rootPage.NotifyUser("", NotifyType.StatusMessage); // Determine if we can access activity sensors var deviceAccessInfo = DeviceAccessInformation.CreateFromDeviceClassId(ActivitySensorClassId); if (deviceAccessInfo.CurrentStatus == DeviceAccessStatus.Allowed) { // Determine if an activity sensor is present // This can also be done using Windows::Devices::Enumeration::DeviceInformation::FindAllAsync var activitySensor = await ActivitySensor.GetDefaultAsync(); if (activitySensor != null) { var calendar = new Calendar(); calendar.SetToNow(); calendar.AddDays(-1); var yesterday = calendar.GetDateTime(); // Get history from yesterday onwards var history = await ActivitySensor.GetSystemHistoryAsync(yesterday); ScenarioOutput_Count.Text = history.Count.ToString(); if (history.Count > 0) { var reading1 = history[0]; ScenarioOutput_Activity1.Text = reading1.Activity.ToString(); ScenarioOutput_Confidence1.Text = reading1.Confidence.ToString(); ScenarioOutput_Timestamp1.Text = reading1.Timestamp.ToString("u"); var readingN = history[history.Count - 1]; ScenarioOutput_ActivityN.Text = readingN.Activity.ToString(); ScenarioOutput_ConfidenceN.Text = readingN.Confidence.ToString(); ScenarioOutput_TimestampN.Text = readingN.Timestamp.ToString("u"); } } else { rootPage.NotifyUser("No activity sensors found", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("Access to activity sensors is denied", NotifyType.ErrorMessage); } }
/// <summary> /// Invoked when the device watcher detects that the activity sensor was removed. /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="device">The device that was removed.</param> private void OnActivitySensorRemoved(DeviceWatcher sender, DeviceInformationUpdate device) { if ((this.activitySensor != null) && (this.activitySensor.DeviceId == device.Id)) { this.activitySensor.ReadingChanged -= ActivitySensor_ReadingChangedAsync; this.deviceAccessInformation.AccessChanged -= DeviceAccessInfo_AccessChangedAsync; this.activitySensor = null; SetActive(false); } }
/// <summary> /// OSActivitySensor constructor. /// </summary public OSActivitySensor(ActivitySensor sensor) { _sensor = sensor; // Using this method to detect if the application runs in the emulator or on a real device. Later the *Simulator API is used to read fake sense data on emulator. // In production code you do not need this and in fact you should ensure that you do not include the Lumia.Sense.Test reference in your project. EasClientDeviceInformation x = new EasClientDeviceInformation(); if (x.SystemProductName.StartsWith("Virtual")) { _runningInEmulator = true; } }
async void OnReadingChanged(ActivitySensor sender, ActivitySensorReadingChangedEventArgs args) { await this.Dispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { if (args.Reading != null) { this.DisplayReading(args.Reading); } } ); }
/// <summary> /// Invoked when ActivitySensor reading changed event gets raised. /// </summary> ///<param name="sender"></param> ///<param name="args"></param> private async void ActivitySensor_ReadingChangedAsync(ActivitySensor sender, ActivitySensorReadingChangedEventArgs args) { var isActive = false; var reading = args.Reading; if (reading != null) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { isActive = (reading.Activity == this.ActivityType) && (reading.Confidence >= this.ActivityReadingConfidence); }); } SetActive(isActive); }
/// <summary> /// Invoked when ActivitySensor reading changed event gets raised. /// </summary> ///<param name="sender"></param> ///<param name="args"></param> private async void ActivitySensor_ReadingChangedAsync(ActivitySensor sender, ActivitySensorReadingChangedEventArgs args) { var isActive = false; var reading = args.Reading; if (reading != null) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { isActive = (reading.Activity == this.ActivityType) && (reading.Confidence >= this.ActivityReadingConfidence); }); } SetActive(isActive); }
/// <summary> /// Invoked when the device watcher detects that the activity sensor was added. /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="device">The device that was added.</param> private async void OnActivitySensorAddedAsync(DeviceWatcher sender, DeviceInformation device) { if (this.activitySensor == null) { var addedSensor = await ActivitySensor.FromIdAsync(device.Id); if (addedSensor != null) { this.activitySensor = addedSensor; this.deviceAccessInformation = DeviceAccessInformation.CreateFromId(this.activitySensor.DeviceId); this.deviceAccessInformation.AccessChanged += DeviceAccessInfo_AccessChangedAsync; } } }
/// <summary> /// This is the event handler for AccessChanged events. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void AccessChanged(DeviceAccessInformation sender, DeviceAccessChangedEventArgs e) { var status = e.Status; if (status != DeviceAccessStatus.Allowed) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Access denied to activity sensors", NotifyType.ErrorMessage); _activitySensor = null; ScenarioEnableReadingChangedButton.IsEnabled = true; ScenarioDisableReadingChangedButton.IsEnabled = false; }); } }
/// <summary> /// Returns the activity at the given time /// </summary> /// <param name="sensor">Sensor instance</param> /// <param name="timestamp">Time stamp</param> /// <returns>Activity at the given time or <c>null</c> if no activity is found.</returns> public static async Task <ActivitySensorReading> GetActivityAtAsync(DateTimeOffset timestamp) { // We assume here that one day overshoot is enough to cover most cases. If the previous activity lasted longer // than that, we will miss it. Overshoot duration can be extended but will decrease performance. TimeSpan overshoot = TimeSpan.FromDays(1); IReadOnlyList <ActivitySensorReading> history = await ActivitySensor.GetSystemHistoryAsync( timestamp - overshoot, overshoot); if (history.Count > 0) { return(history[history.Count - 1]); } else { return(null); } }
/// <summary> /// Static method to get the default activity sensor present in the system. /// </summary> public static async Task <IActivitySensor> GetDefaultAsync() { IActivitySensor sensor = null; try { // Check if there is an activity sensor in the system ActivitySensor activitySensor = await ActivitySensor.GetDefaultAsync(); // If there is one then create OSActivitySensor. if (activitySensor != null) { sensor = new OSActivitySensor(activitySensor); } } catch (System.UnauthorizedAccessException) { // If there is an activity sensor but the user has disabled motion data // then check if the user wants to open settngs and enable motion data. MessageDialog dialog = new MessageDialog("Motion access has been disabled in system settings. Do you want to open settings now?", "Information"); dialog.Commands.Add(new UICommand("Yes", async cmd => await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-motion")))); dialog.Commands.Add(new UICommand("No")); await dialog.ShowAsync(); new System.Threading.ManualResetEvent(false).WaitOne(500); return(null); } // If the OS activity sensor is not present then create the LumiaActivitySensor. // This will use ActivityMonitor from SensorCore. if (sensor == null) { // Check if all the required settings have been configured correctly await LumiaActivitySensor.ValidateSettingsAsync(); sensor = new LumiaActivitySensor(); } return(sensor); }
/// <summary> /// This is the click handler for the 'Get Current Activity' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> async private void ScenarioGetCurrentActivity(object sender, RoutedEventArgs e) { // Reset fields and status ScenarioOutput_Activity.Text = "No data"; ScenarioOutput_Confidence.Text = "No data"; ScenarioOutput_Timestamp.Text = "No data"; rootPage.NotifyUser("", NotifyType.StatusMessage); // Determine if we can access activity sensors var deviceAccessInfo = DeviceAccessInformation.CreateFromDeviceClassId(ActivitySensorClassId); if (deviceAccessInfo.CurrentStatus == DeviceAccessStatus.Allowed) { // Get the default sensor var activitySensor = await ActivitySensor.GetDefaultAsync(); if (activitySensor != null) { // Get the current activity reading var reading = await activitySensor.GetCurrentReadingAsync(); if (reading != null) { ScenarioOutput_Activity.Text = reading.Activity.ToString(); ScenarioOutput_Confidence.Text = reading.Confidence.ToString(); ScenarioOutput_Timestamp.Text = reading.Timestamp.ToString("u"); } } else { rootPage.NotifyUser("No activity sensor found", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("Access denied to activity sensors", NotifyType.ErrorMessage); } }
public Scenario3_ChangeEvents() { this.InitializeComponent(); _activitySensor = null; }
/// <summary> /// Invoked when the device watcher detects that the activity sensor was added. /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="device">The device that was added.</param> private async void OnActivitySensorAddedAsync(DeviceWatcher sender, DeviceInformation device) { if (this.activitySensor == null) { var addedSensor = await ActivitySensor.FromIdAsync(device.Id); if (addedSensor != null) { this.activitySensor = addedSensor; this.deviceAccessInformation = DeviceAccessInformation.CreateFromId(this.activitySensor.DeviceId); this.deviceAccessInformation.AccessChanged += DeviceAccessInfo_AccessChangedAsync; } } }
/// <summary> /// Invoked when the device watcher detects that the activity sensor was removed. /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="device">The device that was removed.</param> private void OnActivitySensorRemoved(DeviceWatcher sender, DeviceInformationUpdate device) { if ((this.activitySensor != null) && (this.activitySensor.DeviceId == device.Id)) { this.activitySensor.ReadingChanged -= ActivitySensor_ReadingChangedAsync; this.deviceAccessInformation.AccessChanged -= DeviceAccessInfo_AccessChangedAsync; this.activitySensor = null; SetActive(false); } }
/// <summary> /// OSActivitySensor constructor. /// </summary public OSActivitySensor(ActivitySensor sensor) { _sensor = sensor; // Using this method to detect if the application runs in the emulator or on a real device. Later the *Simulator API is used to read fake sense data on emulator. // In production code you do not need this and in fact you should ensure that you do not include the Lumia.Sense.Test reference in your project. EasClientDeviceInformation x = new EasClientDeviceInformation(); if (x.SystemProductName.StartsWith("Virtual")) { _runningInEmulator = true; } }
/// <summary> /// Updates the summary in the screen. /// </summary> /// <returns>Asynchronous task/returns> /// <param name="DayOffset">Day offset</param> /// <returns>Asyncrhonous Task</returns> public async Task UpdateSummaryAsync(uint DayOffset) { // Read current activity ActivitySensorReading reading = await _sensor.GetCurrentReadingAsync(); if (reading != null) { ActivityData <Windows.Devices.Sensors.ActivityType> .Instance().CurrentActivity = reading.Activity; } // Fetch activity history for the day DateTime startDate = DateTime.Today.Subtract(TimeSpan.FromDays(DayOffset)); DateTime endDate = startDate + TimeSpan.FromDays(1); var history = await ActivitySensor.GetSystemHistoryAsync(startDate, TimeSpan.FromDays(1)); // Create a dictionary to store data Dictionary <Windows.Devices.Sensors.ActivityType, TimeSpan> activitySummary = new Dictionary <Windows.Devices.Sensors.ActivityType, TimeSpan>(); // Initialize timespan for all entries var activityTypes = Enum.GetValues(typeof(Windows.Devices.Sensors.ActivityType)); foreach (var type in activityTypes) { activitySummary[(Windows.Devices.Sensors.ActivityType)type] = TimeSpan.Zero; } if (history.Count == 0 || history[0].Timestamp > startDate) { ActivitySensorReading firstReading = await GetActivityAtAsync(startDate); if (firstReading != null) { List <ActivitySensorReading> finalHistory = new List <ActivitySensorReading>(history); finalHistory.Insert(0, firstReading); history = finalHistory.AsReadOnly(); } } // Update the timespan for all activities in the dictionary if (history.Count > 0) { Windows.Devices.Sensors.ActivityType currentActivity = history[0].Activity; DateTime currentDate = history[0].Timestamp.DateTime; foreach (var item in history) { if (item.Timestamp >= startDate) { TimeSpan duration = TimeSpan.Zero; if (currentDate < startDate) { // If first activity of the day started already yesterday, set start time to midnight. currentDate = startDate; } if (item.Timestamp > endDate) { // If last activity extends over to next day, set end time to midnight. duration = endDate - currentDate; break; } else { duration = item.Timestamp - currentDate; } activitySummary[currentActivity] += duration; } currentActivity = item.Activity; currentDate = item.Timestamp.DateTime; } } // Prepare the summary to add it to data source List <ActivityDuration <Windows.Devices.Sensors.ActivityType> > historyList = new List <ActivityDuration <Windows.Devices.Sensors.ActivityType> >(); foreach (var activityType in activityTypes) { // For each entry in the summary add the type and duration to data source historyList.Add(new ActivityDuration <Windows.Devices.Sensors.ActivityType>((Windows.Devices.Sensors.ActivityType)activityType, activitySummary[(Windows.Devices.Sensors.ActivityType)activityType])); } // Update the singleton instance of the data source ActivityData <Windows.Devices.Sensors.ActivityType> .Instance().History = historyList; ActivityData <Windows.Devices.Sensors.ActivityType> .Instance().Date = startDate; }
/// <summary> /// This is the event handler for AccessChanged events. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void AccessChanged(DeviceAccessInformation sender, DeviceAccessChangedEventArgs e) { var status = e.Status; if (status != DeviceAccessStatus.Allowed) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Access denied to activity sensors", NotifyType.ErrorMessage); _activitySensor = null; ScenarioEnableReadingChangedButton.IsEnabled = true; ScenarioDisableReadingChangedButton.IsEnabled = false; }); } }
/// <summary> /// This is the click handler for the 'Reading Changed On' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void ScenarioEnableReadingChanged(object sender, RoutedEventArgs e) { // Determine if we can access activity sensors if (_deviceAccessInformation.CurrentStatus == DeviceAccessStatus.Allowed) { if (_activitySensor == null) { _activitySensor = await ActivitySensor.GetDefaultAsync(); } if (_activitySensor != null) { _activitySensor.SubscribedActivities.Add(ActivityType.Walking); _activitySensor.SubscribedActivities.Add(ActivityType.Running); _activitySensor.SubscribedActivities.Add(ActivityType.InVehicle); _activitySensor.SubscribedActivities.Add(ActivityType.Biking); _activitySensor.SubscribedActivities.Add(ActivityType.Fidgeting); _activitySensor.ReadingChanged += new TypedEventHandler<ActivitySensor, ActivitySensorReadingChangedEventArgs>(ReadingChanged); ScenarioEnableReadingChangedButton.IsEnabled = false; ScenarioDisableReadingChangedButton.IsEnabled = true; rootPage.NotifyUser("Subscribed to reading changes", NotifyType.StatusMessage); } else { rootPage.NotifyUser("No activity sensor found", NotifyType.ErrorMessage); } } else { rootPage.NotifyUser("Access denied to activity sensors", NotifyType.ErrorMessage); } }
public ActivitySensorEvents(ActivitySensor This) { this.This = This; }
public SensorTests() { tSensor = new TemperatureSensor(); pSensor = new PulseSensor(); aSensor = new ActivitySensor(); }