private void RestartTimer(bool immediate = false) { lock (_timerLock) { if (_disposed) { return; } _volumeRefreshActive = true; var time = immediate ? 100 : 10000; _timer.Change(time, Timeout.Infinite); } }
/// <summary> /// /// </summary> /// <param name="item"></param> /// <param name="eventType"></param> public void QueueItem(BaseItem item, EventType eventType) { if (item == null) { throw new ArgumentNullException("item"); } if (_queueTimer == null) { _queueTimer = _timerFactory.Create(OnQueueTimerCallback, null, TimeSpan.FromMilliseconds(20000), Timeout.InfiniteTimeSpan); } else { _queueTimer.Change(TimeSpan.FromMilliseconds(20000), Timeout.InfiniteTimeSpan); } var users = Plugin.Instance.PluginConfiguration.TraktUsers; if (users == null || users.Length == 0) { return; } // we need to process the video for each user foreach (var user in users.Where(x => _traktApi.CanSync(item, x))) { // we have a match, this user is watching the folder the video is in. Add to queue and they // will be processed when the next timer elapsed event fires. var libraryEvent = new LibraryEvent { Item = item, TraktUser = user, EventType = eventType }; _queuedEvents.Add(libraryEvent); } }
protected override void OnStart() { base.OnStart(); var previousValue = Interlocked.Exchange(ref _started, 1); if (previousValue != 0) { return; } _stoppingSignal.Reset(); _scheduledJobs.Clear(); _timer.Change(CheckIntervalMs, Timeout.Infinite); }
private void RestartTimer() { if (_disposed) { return; } lock (_timerLock) { if (!_timerActive) { _logger.Debug("RestartTimer"); _timer.Change(10, GetPlaybackTimerIntervalMs()); } _timerActive = true; } }
public void StartRead() { decimal itemsProduced = (decimal)(_rand.NextDouble() * (_maxitems + (10 * (_rand.Next(0, 10) - 5)))); RaiseDataReceivedEvent(itemsProduced); var period = TimeSpan.FromSeconds(_rate) + TimeSpan.FromSeconds((_rand.NextDouble() - 0.5) * _variation); _timer.Change(period, period); }
private void ResetExpireCachedDevicesTimer() { if (IsDisposed) { return; } if (_ExpireCachedDevicesTimer == null) { _ExpireCachedDevicesTimer = _timerFactory.Create(this.ExpireCachedDevices, null, System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite); } _ExpireCachedDevicesTimer.Change(60000, System.Threading.Timeout.Infinite); }
public void RestartBroadcastTimer(TimeSpan dueTime, TimeSpan period) { lock (_timerLock) { if (_BroadcastTimer == null) { _BroadcastTimer = _timerFactory.Create(OnBroadcastTimerCallback, null, dueTime, period); } else { _BroadcastTimer.Change(dueTime, period); } } }
private void PushNow() { DateTime nextPushTime; DateTime now; do { _lastPush = _dateTime.UtcNow; _repo.ProcessRecords(ProcessRecords, _config.PushBatchSize); nextPushTime = _lastPush.AddSeconds(_config.PushIntervalSeconds); now = _dateTime.UtcNow; } while (nextPushTime <= now); _timer.Change(nextPushTime.Subtract(now), Timeout.InfiniteTimeSpan); }
public ItemLoadedDatasource(ITimer timer, DataCollectorConfiguration configuration) { _timer = timer; _variation = configuration.ItemProducedTimeVariation; _rate = configuration.ItemProducedSampleRate; _rand = new Random(); _maxitems = configuration.ItemProducedMax; _timer.Tick += (sender, args) => StartRead(); _timer.Change(TimeSpan.Zero, TimeSpan.FromSeconds(_rate) + TimeSpan.FromSeconds((_rand.NextDouble() - 0.5) * _variation)); Id = configuration.ItemProducedDeviceID; }
public void StartAutomaticProgress(ITimerFactory timerFactory, PlaybackProgressInfo progressInfo) { lock (_progressLock) { _lastProgressInfo = progressInfo; if (_progressTimer == null) { _progressTimer = timerFactory.Create(OnProgressTimerCallback, null, 1000, 1000); } else { _progressTimer.Change(1000, 1000); } } }
/// <summary> /// Update the next timer callback based on the time of the next saga timeout. /// </summary> private void RescheduleTimer(DateTime timeout) { const Int64 minimumInterval = 100; const Int64 maximumInterval = 60000; lock (syncLock) { if (timeout == scheduledTimeout || disposed) { return; } var dueTime = Math.Min(maximumInterval, Math.Max(timeout.Subtract(SystemTime.Now).Ticks / TimeSpan.TicksPerMillisecond, minimumInterval)); scheduledTimeout = timeout; timer.Change(dueTime, System.Threading.Timeout.Infinite); Log.Trace("Timer due in {0}ms", dueTime); } }
public Task SlideDelayAsync(bool processNow) { // delegate can't be async or shared exclusive scheduler is pointless return(_timerTaskFactory.StartNew(() => { var currentTimestamp = Stopwatch.GetTimestamp(); var timeUntilNextTrigger = processNow ? TimeSpan.Zero : ComputeTimeUntilNextTrigger(currentTimestamp); // if the computation resulted in Zero, then call _act() now and skip creating the timer if (timeUntilNextTrigger <= TimeSpan.Zero) { CancelExistingTimer(); _act(); _isRunning = false; return; } _timer.Change(Fire, timeUntilNextTrigger); })); }
public void RestartTimer() { if (_disposed) { return; } lock (_timerLock) { if (_disposed) { return; } if (_timer == null) { _timer = _timerFactory.Create(OnTimerCallback, null, TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1)); } else { _timer.Change(TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1)); } } }
private void StartSaveImageSizeTimer() { _saveImageSizeTimer.Change(SaveImageSizeTimeout, Timeout.Infinite); }
/// <summary> /// /// </summary> /// <param name="userDataSaveEventArgs"></param> /// <param name="traktUser"></param> public void ProcessUserDataSaveEventArgs(UserDataSaveEventArgs userDataSaveEventArgs, TraktUser traktUser) { var userPackage = _userDataPackages.FirstOrDefault(e => e.TraktUser.Equals(traktUser)); if (userPackage == null) { userPackage = new UserDataPackage { TraktUser = traktUser }; _userDataPackages.Add(userPackage); } if (_timer == null) { _timer = _timerFactory.Create(OnTimerCallback, null, TimeSpan.FromMilliseconds(5000), Timeout.InfiniteTimeSpan); } else { _timer.Change(TimeSpan.FromMilliseconds(5000), Timeout.InfiniteTimeSpan); } var movie = userDataSaveEventArgs.Item as Movie; if (movie != null) { if (userDataSaveEventArgs.UserData.Played) { userPackage.SeenMovies.Add(movie); if (userPackage.SeenMovies.Count >= 100) { _traktApi.SendMoviePlaystateUpdates(userPackage.SeenMovies, userPackage.TraktUser, true, CancellationToken.None).ConfigureAwait(false); userPackage.SeenMovies = new List <Movie>(); } } else { userPackage.UnSeenMovies.Add(movie); if (userPackage.UnSeenMovies.Count >= 100) { _traktApi.SendMoviePlaystateUpdates(userPackage.UnSeenMovies, userPackage.TraktUser, false, CancellationToken.None).ConfigureAwait(false); userPackage.UnSeenMovies = new List <Movie>(); } } return; } var episode = userDataSaveEventArgs.Item as Episode; if (episode == null) { return; } // If it's not the series we're currently storing, upload our episodes and reset the arrays if (!userPackage.CurrentSeriesId.Equals(episode.Series.Id)) { if (userPackage.SeenEpisodes.Any()) { _traktApi.SendEpisodePlaystateUpdates(userPackage.SeenEpisodes, userPackage.TraktUser, true, CancellationToken.None).ConfigureAwait(false); userPackage.SeenEpisodes = new List <Episode>(); } if (userPackage.UnSeenEpisodes.Any()) { _traktApi.SendEpisodePlaystateUpdates(userPackage.UnSeenEpisodes, userPackage.TraktUser, false, CancellationToken.None).ConfigureAwait(false); userPackage.UnSeenEpisodes = new List <Episode>(); } userPackage.CurrentSeriesId = episode.Series.Id; } if (userDataSaveEventArgs.UserData.Played) { userPackage.SeenEpisodes.Add(episode); } else { userPackage.UnSeenEpisodes.Add(episode); } }
public void Start() { _updateStatusTimer.Change(2000, 5000); }
private void StartHeartBeatTimer() { heartBeatTimer.Tick += OnHeartBeatRequest; heartBeatTimer.Change(5000, 3000); }