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);
}
