/// <summary>
        /// Initializes the sensor
        /// </summary>
        /// <exception cref="NotSupportedException">The device does not support the sensor</exception>
        /// <exception cref="UnauthorizedAccessException">The user does not grant your app access to sensors</exception>
        public PedometerService()
        {
            try
            {
                // A NotSupportedException will be thrown if the sensor is not available on the device
                _sensor = new Pedometer();

                // Add an event handler to the sensor
                _sensor.DataUpdated += OnSensorDataUpdated;

                // TODO: Declare how the sensor behaves when the screen turns off or the device goes into power save mode
                // For details see https://docs.tizen.org/application/dotnet/guides/location-sensors/device-sensors
                // _sensor.PausePolicy = SensorPausePolicy.None;

                // TODO: Set the update interval in milliseconds
                // _sensor.Interval = 1000;
            }
            catch (NotSupportedException)
            {
                // TODO: The device does not support the sensor, handle exception as appropriate to your scenario
            }
            catch (UnauthorizedAccessException)
            {
                // TODO: The user does not grant your app access to sensors, handle exception as appropriate to your scenario
            }
        }
        /// <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>
        /// 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.AlwaysAllowed == status) ||
                        (BackgroundAccessStatus.AllowedSubjectToSystemPolicy == 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);
            }
        }
Esempio n. 4
0
        /// <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>
        /// Gets sensor information.
        /// </summary>
        /// <returns>Sensor information.</returns>
        public SensorInfo GetSensorInfo()
        {
            SensorInfo info = new SensorInfo();

            info.Type = SensorTypes.PedometerType;

            try
            {
                sensor = new Pedometer
                {
                    Interval    = 100,
                    PausePolicy = SensorPausePolicy.None
                };

                info.Name        = sensor.Name;
                info.Vendor      = sensor.Vendor;
                info.MinRange    = sensor.MinValue;
                info.MaxRange    = sensor.MaxValue;
                info.Resolution  = sensor.Resolution;
                info.MinInterval = sensor.MinInterval;
            }
            catch (Exception e)
            {
                global::Tizen.Log.Info(Log.LogTag, e.Message);
                info.Status = "Permission Denied";
            }

            return(info);
        }
Esempio n. 6
0
        /// <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);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// 步数变化
        /// </summary>
        private void Pedometer_ReadingChanged(Pedometer sender, PedometerReadingChangedEventArgs args)
        {
            PedometerReading reding = args.Reading;

            if (reding.StepKind == PedometerStepKind.Running)
            {
                if (rs == reding.CumulativeSteps)
                {
                    return;
                }
                rs = reding.CumulativeSteps;
            }
            else
            {
                if (ws == reding.CumulativeSteps)
                {
                    return;
                }
                ws = reding.CumulativeSteps;
            }
            double h    = Math.Round(nowH, 1);
            double p    = pressure.GetCurrentReading().StationPressureInHectopascals;
            int    s    = args.Reading.CumulativeSteps;
            long   time = TimeUtil.getNowStamp();

            dm.insertHeight(time, h, p, ws, rs);
        }
Esempio n. 8
0
    public Database()
    {
        DropTables();           // Drop table to ensure that the table is fresh

        CheckDbExist("1");

        GetAugmonInfo();                // retrieve default augmon data
        GetPedometerInfo();             // retrieve default pedometer data


        Augmon tempmon = new Augmon();


        /*** Tested Dummy Data ***/
        tempmon.ID        = 1;
        tempmon.Total_xp  = 50;
        tempmon.Lvl       = 2;
        tempmon.Attack    = 35;
        tempmon.Defense   = 26;
        tempmon.Happiness = 99;
        StoreAugmonInfo(tempmon);

        Pedometer pp = new Pedometer();

        /*** Tested Dummy Data ***/
        pp.ID         = 1;
        pp.Total_step = 500;
        pp.Daily_step = 60;
        StorePedometerInfo(pp);


        GetAugmonInfo();                // retrieve updated augmon data
        GetPedometerInfo();             // retrieve updated pedometer data
    }
Esempio n. 9
0
    // Use this for initialization
    void Start()
    {
        Database db = new Database();

        DAO dao = new DAO();

        Debug.Log("Login With Email:\t\t" + dao.LoginWithEmail("*****@*****.**", "aaa"));
        Debug.Log("Register with Email:\t\t" + dao.Register("*****@*****.**", "zzz"));
        Debug.Log("Register with Facebook:\t\t" + dao.RegisterWithFacebook("32151fads12321"));

        Debug.Log("Login with Facebook:\t\t" + dao.LoginWithFacebook("32151fads12321"));

        Augmon augmon = new Augmon();

        augmon.ID        = 2;
        augmon.Total_xp  = 292929;
        augmon.Attack    = 25;
        augmon.Defense   = 40;
        augmon.Happiness = 88;

        Debug.Log("Update Augmon Info:\t\t" + dao.UpdateAugmon(augmon));

        Pedometer p = new Pedometer();

        p.ID         = 2;
        p.Total_step = 10231;
        p.Daily_step = 2131;
        Debug.Log("Update Pedometer Info:\t\t" + dao.UpdatePedometer(p));

        Debug.Log("Get Augmon Info:\t\t" + dao.GetAugmonInfo(2));

        Debug.Log("Get Pedometer Info:\t\t" + dao.GetPedometerInfo(2));

        Debug.Log("Get User Info:\t\t" + dao.GetUserInfo(2));
    }
Esempio n. 10
0
        /// <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));
        }
Esempio n. 11
0
        public void StartSensors()
        {
            m_logger.Debug("StartSensors");

            Pedometer.Start();
            Compass.Start();
        }
Esempio n. 12
0
 public WizardBotThread(Client Client)
 {
     this.Client = Client;
     Target      = new Targeting(this);
     PathFinder  = new SonarV2(Client);
     WalkingPath = new Pedometer(Client, PathFinder);
 }
Esempio n. 13
0
 // Start is called before the first frame update
 public void Start()
 {
     pedometer = new Pedometer(OnStep);
     OnStep(0, 0);
     print_shoes_count();
     print_gold_count();
 }
Esempio n. 14
0
 private void Start()
 {
     // Create a new pedometer
     pedometer = new Pedometer(OnStep);
     // Reset UI
     OnStep(0, 0);
 }
Esempio n. 15
0
    // Use this for initialization
    void Awake()
    {
        DAO       database = new DAO();
        Pedometer ped      = database.GetPedometerInfo(FacebookManager.Instance().user_ID);

        pedometersteps = ped.Total_step;
        isClosed       = true;
    }
Esempio n. 16
0
 private void Start()
 {
     // Create a new pedometer
     // Reset UI
     mileStep.text = milestone.ToString();
     pedometer     = new Pedometer(OnStep);
     OnStep(0, 0);
 }
Esempio n. 17
0
 private void Start()
 {
     Debug.Log("Started");
     // Create a new pedometer
     pedometer = new Pedometer(OnStep);
     // Reset UI
     OnStep(0, 0);
 }
Esempio n. 18
0
 private void Start()
 {
     // Create a new pedometer
     // Reset UI
     HPBar.maxValue = HP = PlayerPrefs.GetInt("m_current_hp");
     pedometer      = new Pedometer(OnStep);
     OnStep(0, 0);
 }
Esempio n. 19
0
 private void Start()
 {
     sceneM = SceneManager.GetActiveScene();
     // Create a new pedometer
     pedometer = new Pedometer(OnStep);
     // Reset UI
     OnStep(0, 0);
 }
Esempio n. 20
0
        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);
        }
Esempio n. 21
0
        /// <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);
        }
Esempio n. 22
0
        private void Start()
        {
            // Create a new pedometer
            pedometer  = new Pedometer(OnStep);
            player     = FindObjectOfType <PlayerInfo>();
            savedSteps = player.steps;

            OnStep(0, 0);
        }
        /// <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;
        }
Esempio n. 24
0
 public PedometerDeviceSensor()
 {
     try
     {
         _pedometer = new Pedometer();
     }
     catch (NotSupportedException)
     {
     }
 }
        /// <summary>
        /// Invoked when the underlying Pedometer sees a change in the step count for a step kind
        /// </summary>
        /// <param name="sender">unused</param>
        /// <param name="args">Pedometer reading that is being notified</param>
        async private void Pedometer_ReadingChanged(Pedometer sender, PedometerReadingChangedEventArgs args)
        {
            await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                PedometerReading reading = args.Reading;
                int newCount             = 0;

                // update step counts based on the step kind
                switch (reading.StepKind)
                {
                case PedometerStepKind.Unknown:
                    if (reading.CumulativeSteps < unknownStepCount)
                    {
                        unknownStepCount = 0;
                    }
                    newCount         = reading.CumulativeSteps - unknownStepCount;
                    unknownStepCount = reading.CumulativeSteps;
                    ScenarioOutput_UnknownCount.Text    = unknownStepCount.ToString();
                    ScenarioOutput_UnknownDuration.Text = reading.CumulativeStepsDuration.TotalMilliseconds.ToString();
                    break;

                case PedometerStepKind.Walking:
                    if (reading.CumulativeSteps < walkingStepCount)
                    {
                        walkingStepCount = 0;
                    }
                    newCount         = reading.CumulativeSteps - walkingStepCount;
                    walkingStepCount = reading.CumulativeSteps;
                    ScenarioOutput_WalkingCount.Text    = walkingStepCount.ToString();
                    ScenarioOutput_WalkingDuration.Text = reading.CumulativeStepsDuration.TotalMilliseconds.ToString();
                    break;

                case PedometerStepKind.Running:
                    if (reading.CumulativeSteps < runningStepCount)
                    {
                        runningStepCount = 0;
                    }
                    newCount         = reading.CumulativeSteps - runningStepCount;
                    runningStepCount = reading.CumulativeSteps;
                    ScenarioOutput_RunningCount.Text    = runningStepCount.ToString();
                    ScenarioOutput_RunningDuration.Text = reading.CumulativeStepsDuration.TotalMilliseconds.ToString();
                    break;

                default:
                    break;
                }

                totalCumulativeSteps += newCount;
                ScenarioOutput_TotalStepCount.Text = totalCumulativeSteps.ToString();

                DateTimeFormatter timestampFormatter = new DateTimeFormatter("shortdate longtime");
                ScenarioOutput_Timestamp.Text        = timestampFormatter.Format(reading.Timestamp);
            });
        }
Esempio n. 26
0
        public async void StartReading(int reportInterval = -1)
        {
            _pedometer = await Pedometer.GetDefaultAsync();

            if (reportInterval >= 0)
            {
                _pedometer.ReportInterval = (uint)reportInterval;
            }

            _pedometer.ReadingChanged += PedometerReadingChanged;
        }
Esempio n. 27
0
        private void Update()
        {
            // Release the pedometer
            pedometer.Dispose();
            pedometer = null;

            for (int i = 0; i < options.Length; i++)
            {
                if (i == index)
                {
                    part.sprite = options[i];
                }
            }
        }
Esempio n. 28
0
        /// <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>
        /// Releases all resources used by the current instance
        /// </summary>
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    _sensor.DataUpdated -= OnSensorDataUpdated;
                    _sensor.Dispose();
                }

                _sensor   = null;
                _disposed = true;
            }
        }
Esempio n. 30
0
    /******************************************************************************************************************************/
    /***                                        Update All function : Pedometer													***/
    /******************************************************************************************************************************/
    public void StorePedometerInfo(Pedometer pedometer)
    {
        OpenConnection();
        Debug.Log("StorePedometerInfo being called");
        dbcmd             = dbcon.CreateCommand();
        dbcmd.CommandType = CommandType.Text;

        string sql = "UPDATE pedometer SET total_steps = " + pedometer.Total_step + ", daily_steps = " + pedometer.Daily_step + " WHERE id = " + pedometer.ID;

        dbcmd.CommandText = sql;
        dbcmd.ExecuteNonQuery();
        Debug.Log("all columns on pedometer table updated");
        CloseConnection();
    }
Esempio n. 31
0
        /// <summary>
        /// The entry point of a background task.
        /// </summary>
        /// <param name="taskInstance">The current background task instance.</param>
        public void Run(IBackgroundTaskInstance taskInstance)
        {
            // Associate a cancellation handler with the background task.
            // Even though this task isn't performing much work, it can still be cancelled.
            taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled);

            // Read the pedometer reports from the trigger
            SensorDataThresholdTriggerDetails triggerDetails = taskInstance.TriggerDetails as SensorDataThresholdTriggerDetails;

            // Ensure that this trigger is of Pedometer type
            if (SensorType.Pedometer == triggerDetails.SensorType)
            {
                var nThFromLast    = 1;
                var reports        = Pedometer.GetReadingsFromTriggerDetails(triggerDetails);
                var settings       = ApplicationData.Current.LocalSettings;
                var lastReading    = reports[reports.Count - nThFromLast];
                var knownTimestamp = lastReading.Timestamp;

                settings.Values["ReportCount"]   = reports.Count.ToString();
                settings.Values["LastTimestamp"] = lastReading.Timestamp;

                // insert this step kind count
                settings.Values[lastReading.StepKind.ToString()] = lastReading.CumulativeSteps.ToString();

                // All reports that have the same timestamp correspond to step counts
                // of different step kinds supported by the sensor - Parse each one of
                // them and save in the application data
                while (nThFromLast < reports.Count)
                {
                    // get the next reading from the last
                    nThFromLast++;
                    lastReading = reports[reports.Count - nThFromLast];

                    if (knownTimestamp.UtcTicks == lastReading.Timestamp.UtcTicks)
                    {
                        // captured at the same time indicates that this step-kind data belongs to the same sample
                        // insert this step kind count
                        settings.Values[lastReading.StepKind.ToString()] = lastReading.CumulativeSteps.ToString();
                    }
                    else
                    {
                        break;
                    }
                }

                settings.Values["TaskStatus"] = "Completed at " + DateTime.Now.ToString("u");
            }
            // No deferral is held on taskInstance because we are returning immediately.
        }
 public PedometerEvents(Pedometer This)
 {
     this.This = This;
 }
        /// <summary>
        /// Invoked when the underlying Pedometer sees a change in the step count for a step kind
        /// </summary>
        /// <param name="sender">unused</param>
        /// <param name="args">Pedometer reading that is being notified</param>
        async private void Pedometer_ReadingChanged(Pedometer sender, PedometerReadingChangedEventArgs args)
        {
            await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                PedometerReading reading = args.Reading;
                int newCount = 0;

                // update step counts based on the step kind
                switch (reading.StepKind)
                {
                    case PedometerStepKind.Unknown:
                        if (reading.CumulativeSteps < unknownStepCount)
                        {
                            unknownStepCount = 0;
                        }
                        newCount = reading.CumulativeSteps - unknownStepCount;
                        unknownStepCount = reading.CumulativeSteps;
                        ScenarioOutput_UnknownCount.Text = unknownStepCount.ToString();
                        ScenarioOutput_UnknownDuration.Text = reading.CumulativeStepsDuration.TotalMilliseconds.ToString();
                        break;
                    case PedometerStepKind.Walking:
                        if (reading.CumulativeSteps < walkingStepCount)
                        {
                            walkingStepCount = 0;
                        }
                        newCount = reading.CumulativeSteps - walkingStepCount;
                        walkingStepCount = reading.CumulativeSteps;
                        ScenarioOutput_WalkingCount.Text = walkingStepCount.ToString();
                        ScenarioOutput_WalkingDuration.Text = reading.CumulativeStepsDuration.TotalMilliseconds.ToString();
                        break;
                    case PedometerStepKind.Running:
                        if (reading.CumulativeSteps < runningStepCount)
                        {
                            runningStepCount = 0;
                        }
                        newCount = reading.CumulativeSteps - runningStepCount;
                        runningStepCount = reading.CumulativeSteps;
                        ScenarioOutput_RunningCount.Text = runningStepCount.ToString();
                        ScenarioOutput_RunningDuration.Text = reading.CumulativeStepsDuration.TotalMilliseconds.ToString();
                        break;
                    default:
                        break;
                }

                totalCumulativeSteps += newCount;
                ScenarioOutput_TotalStepCount.Text = totalCumulativeSteps.ToString();

                DateTimeFormatter timestampFormatter = new DateTimeFormatter("shortdate longtime");
                ScenarioOutput_Timestamp.Text = timestampFormatter.Format(reading.Timestamp);
            });
        }