/// <summary> /// Invoked when 'Register Task' button is clicked. Attempts to find a default /// Pedometer and registers a background task with a step goal of 50 steps. /// Adds a /// </summary> private async void ScenarioRegisterTask_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e) { try { sensor = await Pedometer.GetDefaultAsync(); if (sensor != 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 pedometer sensors found", NotifyType.ErrorMessage); } } catch (UnauthorizedAccessException) { rootPage.NotifyUser("User has denied access to Pedometer history", NotifyType.ErrorMessage); } }
/// <summary> /// 'Register ReadingChanged' button click handler. Registers to the ' /// ReadingChanged' event of the default pedometer opened earlier. /// </summary> /// <param name="sender">unused</param> /// <param name="e">unused</param> async private void RegisterButton_Click(object sender, RoutedEventArgs e) { // Get the default sensor if (!registeredForEvents) { RegisterButton.IsEnabled = false; try { pedometer = await Pedometer.GetDefaultAsync(); if (pedometer == null) { rootPage.NotifyUser("No pedometer available", NotifyType.ErrorMessage); } RegisterButton.Content = "UnRegister ReadingChanged"; RegisterButton.IsEnabled = true; rootPage.NotifyUser("Registered for step count changes", NotifyType.StatusMessage); } catch (System.UnauthorizedAccessException) { rootPage.NotifyUser("Access to the default pedometer is denied", NotifyType.ErrorMessage); } pedometer.ReadingChanged += Pedometer_ReadingChanged; registeredForEvents = true; } else { pedometer.ReadingChanged -= Pedometer_ReadingChanged; pedometer = null; RegisterButton.Content = "Register ReadingChanged"; registeredForEvents = false; rootPage.NotifyUser("Pedometer available - Not registered for events", NotifyType.StatusMessage); } }
public async void StartReading(int reportInterval = -1) { _pedometer = await Pedometer.GetDefaultAsync(); if (reportInterval >= 0) { _pedometer.ReportInterval = (uint)reportInterval; } _pedometer.ReadingChanged += PedometerReadingChanged; }
/// <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 'GetCurrentReadings' API to determine the current step count /// </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; // Get the current readings to find the current step counters var currentReadings = sensor.GetCurrentReadings(); bool updateTimestamp = true; foreach (PedometerStepKind kind in Enum.GetValues(typeof(PedometerStepKind))) { PedometerReading reading; if (currentReadings.TryGetValue(kind, out reading)) { totalStepCount += reading.CumulativeSteps; } if (updateTimestamp) { DateTimeFormatter timestampFormatter = new DateTimeFormatter("shortdate longtime"); ScenarioOutput_Timestamp.Text = timestampFormatter.Format(reading.Timestamp); updateTimestamp = false; } } ScenarioOutput_TotalStepCount.Text = totalStepCount.ToString(); rootPage.NotifyUser("Hit the 'Get steps count' Button", NotifyType.StatusMessage); // 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> // Background task entry point. // </summary> // <param name="taskInstance"></param> public async void Run(IBackgroundTaskInstance taskInstance) { //alti = Altimeter.GetDefault(); high = Altimeter.GetDefault(); if (null != high) { TimerCallback timerc = new TimerCallback(timerTask); timer = new Timer(timerc, null, 1000 * 60 * 10, 1000 * 60 * 10); dm = DataManager.getInstance(); //dm.setHeightTable(); //IAsyncOperation<Pedometer> iasyncP = Pedometer.GetDefaultAsync(); pressure = Barometer.GetDefault(); // Select a report interval that is both suitable for the purposes of the app and supported by the sensor. //uint minReportIntervalMsecs = alti.MinimumReportInterval; //alti.ReportInterval = 50000; // Subscribe to accelerometer ReadingChanged events. //initAlti = alti.GetCurrentReading().AltitudeChangeInMeters; //barometer = Barometer.GetDefault(); //barometer.ReportInterval = 2000; //initBarometer = barometer.GetCurrentReading().StationPressureInHectopascals; //barometer.ReadingChanged += new TypedEventHandler<Barometer, BarometerReadingChangedEventArgs>(Barometer_Readingchanged); // Take a deferral that is released when the task is completed. _deferral = taskInstance.GetDeferral(); // Get notified when the task is canceled. taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled); //Task.Delay(500).Wait(); // Store a setting so that the app knows that the task is running. //ApplicationData.Current.LocalSettings.Values["IsBackgroundTaskActive"] = true; //pedometer = iasyncP.GetResults(); pedometer = await Pedometer.GetDefaultAsync(); start(); high.ReadingChanged += new TypedEventHandler <Altimeter, AltimeterReadingChangedEventArgs>(ReadingChanged); pedometer.ReadingChanged += new TypedEventHandler <Pedometer, PedometerReadingChangedEventArgs>(Pedometer_ReadingChanged); } }
/// <summary> /// Static method to get the default steps engine present in the system. /// </summary> public static async Task <IStepsEngine> GetDefaultAsync() { IStepsEngine stepsEngine = null; try { // Check if there is a pedometer in the system. // This also checks if the user has disabled motion data from Privacy settings Pedometer pedometer = await Pedometer.GetDefaultAsync(); // If there is one then create OSStepsEngine. if (pedometer != null) { stepsEngine = new OSStepsEngine(); } } catch (System.UnauthorizedAccessException) { // If there is a pedometer 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); } // No Windows.Devices.Sensors.Pedometer exists, fall back to using Lumia Sensor Core. if (stepsEngine == null) { // Check if all the required settings have been configured correctly await LumiaStepsEngine.ValidateSettingsAsync(); stepsEngine = new LumiaStepsEngine(); } return(stepsEngine); }
private async void end(string name) { DataManager dm = DataManager.getInstance(); var settings = ApplicationData.Current.LocalSettings; double nowH = (double)settings.Values["nowH"]; int startRS = (int)settings.Values["startRS"]; int startWS = (int)settings.Values["startWS"]; var aaa = await Pedometer.GetDefaultAsync(); var aa = aaa.GetCurrentReadings(); int rs = aa[PedometerStepKind.Running].CumulativeSteps; int ws = aa[PedometerStepKind.Walking].CumulativeSteps; double p = Barometer.GetDefault().GetCurrentReading().StationPressureInHectopascals; double h = Math.Round(nowH, 1); double la = 200; double lo = 200; try { Geolocator geolocator = new Geolocator(); // 获取当前的位置 Geoposition pos = await geolocator.GetGeopositionAsync(); //纬度 la = pos.Coordinate.Point.Position.Latitude; //经度 lo = pos.Coordinate.Point.Position.Longitude; } catch (UnauthorizedAccessException) { //未授权的访问异常 } catch (Exception ex) { //超时 time out } dm.end(la, lo, h, p, ws, rs, (ws - startWS) + (rs - startRS), name); dm.closeDB(); }
/// <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); } }