Example #1
0
        public void Resume()
        {
            var cts   = new CancellationTokenSource();
            var count = 0;

            using (var src = new WakeableTimer())
            {
                src.Interval = TimeSpan.FromSeconds(1);
                src.Start(TimeSpan.FromMilliseconds(100));
                _ = src.Subscribe(Synchronous.AsTask(() =>
                {
                    ++count;
                    src.Stop();
                    cts.Cancel();
                }));
                src.Start();
                src.Suspend();

                Assert.That(count, Is.EqualTo(0));
                Task.Delay(300).Wait();
                Assert.That(count, Is.EqualTo(0));
                Assert.That(Execute(src, 0, cts), "Timeout");
                Assert.That(count, Is.EqualTo(1));
            }
        }
Example #2
0
        public void Transition_PowerMode()
        {
            var pmc   = new PowerModeContext(Power.Mode);
            var count = 0;
            var dummy = 0;

            Power.Configure(pmc);

            using (var src = new WakeableTimer())
                using (src.Subscribe(Synchronous.AsTask(() => ++ dummy)))
                {
                    src.PowerModeChanged += (s, e) => ++ count;
                    src.Start();

                    pmc.Mode = PowerModes.Suspend;
                    Assert.That(Power.Mode, Is.EqualTo(PowerModes.Suspend));
                    Assert.That(src.State, Is.EqualTo(TimerState.Suspend));

                    pmc.Mode = PowerModes.Resume;
                    Assert.That(Power.Mode, Is.EqualTo(PowerModes.Resume));
                    Assert.That(src.State, Is.EqualTo(TimerState.Run));

                    src.Stop();
                    Assert.That(Power.Mode, Is.EqualTo(PowerModes.Resume));
                    Assert.That(src.State, Is.EqualTo(TimerState.Stop));
                }
        }
Example #3
0
        /* ----------------------------------------------------------------- */
        ///
        /// Execute
        ///
        /// <summary>
        /// Waits for the timer to execute the specified number of callbacks.
        /// </summary>
        ///
        /// <param name="src">Timer object.</param>
        /// <param name="msec">Initial delay.</param>
        /// <param name="count">
        /// Number of callbacks that the timer waits.
        /// </param>
        ///
        /// <returns>true for success.</returns>
        ///
        /* ----------------------------------------------------------------- */
        private bool Execute(WakeableTimer src, int msec, int count)
        {
            var n   = 0;
            var cts = new CancellationTokenSource();

            using (src.Subscribe(Synchronous.AsTask(() =>
            {
                if (++n >= count)
                {
                    src.Stop();
                    cts.Cancel();
                }
            }))) return(Execute(src, msec, cts));
        }
Example #4
0
        /* ----------------------------------------------------------------- */
        ///
        /// UpdateChecker
        ///
        /// <summary>
        /// オブジェクトを初期化します。
        /// </summary>
        ///
        /// <param name="src">設定用オブジェクト</param>
        ///
        /* ----------------------------------------------------------------- */
        public UpdateChecker(SettingFolder src)
        {
            var io  = src.IO;
            var dir = Assembly.GetExecutingAssembly().GetDirectoryName();

            FileName = io.Combine(dir, "UpdateChecker.exe");
            Setting  = src;

            _timer.Interval = TimeSpan.FromDays(1);
            _timer.Subscribe(Synchronous.AsTask(WhenTick));

            if (Setting.Shared.CheckUpdate)
            {
                Start();
            }
        }