public void StartPomodoro()
{
if (PomodoroStatus.PomodoroState == PomodoroState.Pomodoro && PomodoroStatus.TimerState == TimerState.Paused) // if paused
{
TimerService.Continue();
PomodoroStatus = new PomdoroStatus()
{
PomodoroState = PomodoroState.Pomodoro,
RemainingTime = TimerService.RemainingTime,
RunTime = PomodoroSettings.PomodoroDuration,
StartTime = TimerService.StartTime,
TimerState = TimerState.Running,
};
}
else
{
TimerService.Start(PomodoroSettings.PomodoroDuration);
PomodoroStatus = new PomdoroStatus()
{
PomodoroState = PomodoroState.Pomodoro,
RemainingTime = PomodoroSettings.PomodoroDuration,
RunTime = PomodoroSettings.PomodoroDuration,
StartTime = TimerService.StartTime,
TimerState = TimerState.Running,
};
}
StorageService.SaveAppState(PomodoroStatus);
}
/// <summary>
/// Raised when the client connects to Discord.
/// <para>
/// Restarts the <see cref="TimerService"/> and logs that the client has connected.
/// </para>
/// </summary>
/// <returns>No object or value is returned by this method when it completes.</returns>
private Task ConnectedEventHandler()
{
Console.WriteLine($"\n{DateTime.Now}\nCLIENT CONNECTED\n");
_timer.Start(); // TODO: Remove if it is determined that it is redundant due to ReadyHandler.
return(Task.CompletedTask);
}
public GameWindowViewModel(MainWindowViewModel main)
{
Main = main;
var puzzle = Puzzle.FromRowStrings(
"xxxxx",
"x...x",
"x...x",
"x...x",
"xxxxx"
);
var facade = new PiCrossFacade();
//timer
var timeService = ServiceLocator.Current.GetInstance <ITimeService>();
_start = timeService.Now;
_timer = ServiceLocator.Current.GetInstance <ITimerService>();
_timer.Tick += Timer_Tick;
_timer.Start(new TimeSpan(0, 0, 0, 0, 100));
PlayablePuzzle = facade.CreatePlayablePuzzle(puzzle);
SquareGrid = Grid.Create <SquareViewModel>(PlayablePuzzle.Grid.Size, p => new SquareViewModel(PlayablePuzzle.Grid[p]));
Timer = "00:00:00";
CloseGameWindow = new CloseGameWindowCommand(main);
IsSolved = new IsSolvedCommand(this);
}
public LampStateMachine(IMessageService messageService, ITimeService timeService = null, LampState initialState = LampState.Off, ITimerService timer = null)
: base(initialState)
{
this.timeService = timeService ?? new TimeService();
this.timer = timer ?? new TimerService();
timer.Elapsed += (s, a) => this.Fire(LampTrigger.ElapsedTime);
this.Configure(LampState.Off)
// .Permit(LampTrigger.PushUp, LampState.On)
.PermitIf(LampTrigger.PushUp, LampState.On, () => IsOverTime, $"Limit > {TimeLimit}")
.IgnoreIf(LampTrigger.PushUp, () => !IsOverTime, $"Limit <= {TimeLimit}")
.Ignore(LampTrigger.PushDown)
.OnEntry(() => messageService.Send("Dziękujemy za wyłączenie światła"), nameof(messageService.Send));
this.Configure(LampState.On)
.OnEntry(() => messageService.Send("Pamiętaj o wyłączeniu światła!"), nameof(messageService.Send))
.OnEntry(() => timer.Start(), "Start timer")
.Permit(LampTrigger.PushDown, LampState.Off)
.PermitIf(LampTrigger.PushUp, LampState.Red, () => !IsOverLimit)
.PermitIf(LampTrigger.PushUp, LampState.Off, () => IsOverLimit)
.Permit(LampTrigger.ElapsedTime, LampState.Off)
.OnExit(() => timer.Stop());
this.Configure(LampState.Red)
.OnEntry(() => redCounter++)
.Permit(LampTrigger.PushUp, LampState.On)
.Permit(LampTrigger.PushDown, LampState.Off);
this.OnTransitioned(t => Console.WriteLine($"{t.Source} -> {t.Destination}"));
this.timer = timer;
}
public void OnGameModeInit(IWorldService worldService, IEntityManager entityManager,
INativeObjectProxyFactory proxyFactory, ITimerService timerService)
{
// Only test FastNative performance if FastNative is not activated
if (proxyFactory is FastNativeBasedNativeObjectProxyFactory)
{
return;
}
// Benchmarking
var fastFactory = new FastNativeBasedNativeObjectProxyFactory(_client);
var fastProxy = (TestingFastNative)fastFactory.CreateInstance(typeof(TestingFastNative));
_fastProxy = fastProxy;
_nativeGetVehicleParamsEx = Interop.FastNativeFind("GetVehicleParamsEx");
_testVehicleId = worldService.CreateVehicle(VehicleModelType.BMX, Vector3.One, 0, 0, 0).Entity.Handle;
//timerService.Start(_ => BenchmarkRunTimer(), TimeSpan.FromSeconds(2));
timerService.Start(_ => BenchmarkRunTimerProxy(), TimeSpan.FromSeconds(2));
// Test native features
Console.WriteLine("TEST WITH HANDLE FACTORY:");
// RunTests(proxyFactory);
Console.WriteLine("TEST WITH FAST FACTORY:");
RunTests(fastFactory);
// Threading test
// timerService.Start(_ => ThreadingTest(fastProxy, handleProxy), TimeSpan.FromSeconds(15));
// Multiple calls test
InvokeVehicleNatives(entityManager, fastProxy);
GetNetworkStats(out string x, 500);
Console.WriteLine(x);
}
public ShellPageViewModel(
IUserSettings userSettings,
ITimerService timer,
ITelemetry telemetry,
ISystemInfoProvider systemInfoProvider)
{
Guard.IsNotNull(userSettings, nameof(userSettings));
Guard.IsNotNull(timer, nameof(timer));
Guard.IsNotNull(telemetry, nameof(telemetry));
_userSettings = userSettings;
_ratingTimer = timer;
_telemetry = telemetry;
_userSettings.SettingSet += OnSettingSet;
var lastDismissDateTime = _userSettings.GetAndDeserialize <DateTime>(UserSettingsConstants.RatingDismissed);
if (!systemInfoProvider.IsFirstRun() &&
!systemInfoProvider.IsTenFoot() &&
!_userSettings.Get <bool>(UserSettingsConstants.HasRated) &&
lastDismissDateTime.AddDays(7) <= DateTime.UtcNow)
{
_ratingTimer.Interval = 1800000; // 30 minutes
_ratingTimer.IntervalElapsed += OnIntervalLapsed;
_ratingTimer.Start();
}
}
/// <summary>
/// Starts a timer with the specified <paramref name="interval"/>. The specified <paramref name="method"/> will be invoked on the specified <paramref name="target"/> each timer tick.
/// </summary>
/// <param name="timerService">The timer service.</param>
/// <param name="target">The target on which to tick.</param>
/// <param name="method">The method to invoke each timer tick.</param>
/// <param name="interval">The interval at which to tick.</param>
/// <returns>A reference to the started timer.</returns>
public static TimerReference Start(this ITimerService timerService, object target, MethodInfo method, TimeSpan interval)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (!TimerSystem.IsValidInterval(interval))
{
throw new ArgumentOutOfRangeException(nameof(interval), interval, "The interval should be a nonzero positive value.");
}
if (!method.DeclaringType.IsInstanceOfType(target))
{
throw new ArgumentException("The specified method is not a member of the specified target", nameof(method));
}
var parameterInfos = method.GetParameters()
.Select(info => new MethodParameterSource(info)
{
IsService = true
})
.ToArray();
var compiled = MethodInvokerFactory.Compile(method, parameterInfos);
return(timerService.Start(serviceProvider => compiled(target, null, serviceProvider, null), interval));
}
private void Start()
{
if (CanStart())
{
TimerDuration = _timerService.Start(new TimeSpan(TimerDuration.Hours, TimerDuration.Minutes, TimerDuration.Seconds));
}
}
public void Sort(IList <int> list)
{
Console.WriteLine("******Heap Sort*******");
_timer.Start();
Sort(list, list.Count);
Console.WriteLine("Time taken to sort using heap sort = " + _timer.GetTimerValue() + " MilliSeconds");
}
public void Sort(IList <int> list)
{
Console.WriteLine("******Merge Sort*******");
_timer.Start();
Sort(list, new int[list.Count], 0, list.Count - 1);
Console.WriteLine("Time taken to sort using merge sort = " + _timer.GetTimerValue() + " MilliSeconds");
}
public Task <int> OnExecute()
{
if (double.TryParse(Time, out var time) && time > 0)
{
timer.Start(time);
}
return(Task.FromResult(0));
}
public void Start(String destination)
{
_destination = destination;
if (_timerToken == null)
{
_timerToken = _timerService.Start(TimeSpan.FromMilliseconds(1000), Do);
}
}
public CyrillicString(ITimerService timerService, IRandomService randomService)
{
_timerService = timerService;
_randomService = randomService;
var milliseconds = _randomService.RandomInt(500, 1000);
_timerService.Start(TimeSpan.FromMilliseconds(milliseconds), RefreshString);
}
public override Task Initialize()
{
timerService.Interval = TimeSpan.FromSeconds(1);
timerService.Tick += Timer_Tick;
timerService.Start();
return Task.CompletedTask;
}
public ParkingService(bool IsStartTimer)
{
if (IsStartTimer)
{
WithdrawTimer = new TimeService();
WithdrawTimer.Start();
}
LogFileService = new LogService(Settings.LogPath);
}
public TopClothesService(IServiceScopeFactory factory, ITimerService timer)
{
_scopeFactory = factory;
_timer = timer;
_timer.Elapsed += Service_Elapsed;
_timer.Interval = 30000;
_timer.Start();
Service_Elapsed(this, null);
}
public void StartPomodoro()
{
// check if paused
if (PomodoroStatus.PomodoroState == PomodoroState.Pomodoro &&
PomodoroStatus.TimerState == TimerState.Paused)
{
PomodoroStatus = PomodoroTimerState.Pomodoro(PomodoroStatus.RunTime, PomodoroStatus.RemainingRunTime);
}
else
{
// start new pomodoro
PomodoroStatus = PomodoroTimerState.Pomodoro(PomodoroSettings.PomodoroDuration, PomodoroSettings.PomodoroDuration);
}
TimerService.Start(PomodoroStatus.RemainingTime);
StorageService.SaveAppState(PomodoroStatus);
PomodoroTimerStateChangedEvent?.Invoke(this, new PomodoroTimerStateChangedEventArgs(PomodoroStatus));
LogState("StartPomodoro");
}
internal NotificationReporter(ITimeService timeService, ITimerService timerService)
{
_notificationList = new ObservableCollection <Notification>();
_notificationObs = new ReadOnlyObservableCollection <Notification>(_notificationList);
_timeService = new UniqueTimeService(timeService);
_timerService = timerService;
_timerService.TimeSpan = TimeSpan.FromSeconds(1);
ExpirationTime = TimeSpan.FromSeconds(25);
LifeTime = TimeSpan.FromDays(7);
_timerService.Elapsed += TimerServiceElapsed;
_timerService.Start();
}
/// <summary>
/// 計測を開始する
/// </summary>
public void Start()
{
if (Status == StopwatchStatus.Stoped)
{
_beginDateTime = _timeService.Now;
_previousLapDateTime = _beginDateTime;
Status = StopwatchStatus.Running;
_timerService.Start();
}
else if (Status == StopwatchStatus.Paused)
{
_beginDateTime = _timeService.Now;
_previousLapDateTime = _beginDateTime;
Status = StopwatchStatus.Running;
_timerService.Start();
}
else
{
throw new InvalidOperationException($"Stopwatch status is {Status}.");
}
}
public void Run()
{
if (mCurrentState == ExerciseServiceState.Stopped)
{
mTimerService.Start(TIMER_INTERVAL_MS);
}
else if (mCurrentState == ExerciseServiceState.Paused)
{
mTimerService.Resume();
}
ChangeState(ExerciseServiceState.Started);
}
public bool StartApp(string action)
{
var commandLine = Console.ReadLine();
var commandArray = commandLine?.Split(' ');
action = commandArray.FirstOrDefault();
var result = true;
switch (action?.ToLower())
{
case "create_product":
Console.WriteLine(_productService.CreateProduct(commandArray));
break;
case "get_product_info":
Console.WriteLine(_productService.GetProductInfo(commandArray));
result = _campaignService.IsExistActiveCampaign();
break;
case "create_campaign":
Console.WriteLine(_campaignService.CreateCampaign(commandArray));
_timerService.Start();
result = _campaignService.IsExistActiveCampaign();
break;
case "get_campaign_info":
Console.WriteLine(_campaignService.GetCampaignInfo(commandArray));
result = _campaignService.IsExistActiveCampaign();
break;
case "increase_time":
Console.WriteLine(_appTimeService.IncreaseTime(commandArray));
result = _campaignService.IsExistActiveCampaign();
break;
case "exit":
_timerService.End();
Console.WriteLine("bye bye");
result = false;
break;
default:
Console.WriteLine("Incorrect command usage!");
break;
}
return(result);
}
public PlayerManager(IDataService dataService,
IPlayerService playerService,
ISettingsService settingsService,
IEventAggregator eventAggregator,
ITimerService timerService)
{
_dataService = dataService;
_playerService = playerService;
_settingsService = settingsService;
_eventAggregator = eventAggregator;
_timerService = timerService;
_timerService.TimerElapsed += OnTimerElapsed;
_timerService.Start();
_playerService.AudioPlayerStateChanged += OnAudioPlayerStateChanged;
_playerService.MediaStateChanged += OnMediaStateChanged;
}
public ParkingService(ITimerService withdrawTimer, ITimerService logTimer, ILogService logService)
{
parking = Parking.GetInstance;
_withdrawTimer = withdrawTimer;
_logTimer = logTimer;
_logService = logService;
_withdrawTimer.Interval = Settings.WithdrawTime * SecToMilisec;
_withdrawTimer.Elapsed += Withdraw;
_logTimer.Interval = Settings.LogTime * SecToMilisec;
_logTimer.Elapsed += Log;
_withdrawTimer.Start();
_logTimer.Start();
}
public TeamStatisticsViewModel(ITeamClient teamClient, IStatisticsClient statisticsClient, ITimerService timerService, IEventAggregator eventAggregator, ICacheService cacheService)
{
_teamClient = teamClient;
_statisticsClient = statisticsClient;
timerService.Start(TimeSpan.FromSeconds(10), OnRefresh);
_eventAggregator = eventAggregator;
_cacheService = cacheService;
Func<Boolean> canExecute = () =>
{
var password = new NetworkCredential(string.Empty, TeamPassword).Password;
return !String.IsNullOrWhiteSpace(TeamName) && !TeamName.Contains(" ") &&
!String.IsNullOrWhiteSpace(password) && !password.Contains(" ");
};
AcceptExistingTeamCommand = new RelayCommand(OnAcceptExistingTeam, canExecute);
CreateNewTeamCommand = new RelayCommand(OnCreateNewTeam, canExecute);
}
public void OnGameModeInit(ITimerService timerService)
{
_stopwatch1.Start();
_stopwatch2.Start();
TimerReference timer = null;
timer = timerService.Start(_ =>
{
if (++_readonlyTicks == 3)
{
Console.WriteLine("Stop timer");
timerService.Stop(timer);
}
Console.WriteLine($"Manual timer {_stopwatch2.Elapsed}");
_stopwatch2.Restart();
}, TimeSpan.FromSeconds(0.1));
}
private void StartCountdown()
{
_timer.Start(TimeSpan.FromSeconds(1), () =>
{
if (!IsTracking)
{
return(false);
}
TimeLeft = _timeEnd - DateTime.Now;
if (TimeLeft < TimeSpan.FromSeconds(0))
{
StopTracking();
}
return(IsTracking);
});
}
public MainWindowViewModel()
{
var diContainer = new UnityContainer();
diContainer.RegisterType <ITimerService, TimerService>(new ContainerControlledLifetimeManager());
diContainer.RegisterType <IRandomService, RandomService>(new ContainerControlledLifetimeManager());
diContainer.RegisterType <ICoreService, CoreService>();
diContainer.RegisterType <ISampleGenerationService, SampleGenerationService>();
_offline = CreateCyrillicString(diContainer, "OFFLINE", "ОФФЛИНЕ");
_online = CreateCyrillicString(diContainer, "ONLINE", "ОНЛИНЕ");
_title = CreateCyrillicString(diContainer, "Dusty Drones Sensor StreamService Configuration Dashboard", "Дусты Дронес Сенсор СтреамСервице Цонфигуратион Дашбоард");
_fileTitle = CreateCyrillicString(diContainer, "Test Interface For File/Binary Based Listeners", "Тест Интерфаце Фор Филе/Бинары Басед Листенерс");
_fileStatus = _offline;
_webTitle = CreateCyrillicString(diContainer, "Test Interface For Web/HTTP Based Listeners", "Тест Интерфаце Фор Үеб/HТТП Басед Листенерс");
_webStatus = _offline;
_footer1 = CreateCyrillicString(diContainer, "DDSSCD v0.13.267.9782964387", "ДДССЦД в0.13.267.9782964387");
_footer2 = CreateCyrillicString(diContainer, "DDSSCD is connected to the service backend", "ДДССЦД ис цоннецтед то тhе сервице бацкенд");
_outputPath = CreateCyrillicString(diContainer, "Output Path", "Оутпут Патh");
_outputHttp = CreateCyrillicString(diContainer, "Output HTTP", "Оутпут HТТП");
_fileSamplesReceived = CreateCyrillicString(diContainer, "No samples received", "Но самплес рецеивед");
_webSamplesReceived = CreateCyrillicString(diContainer, "No samples received", "Но самплес рецеивед");
_timerService = diContainer.Resolve <ITimerService>();
_timerService.Start(TimeSpan.FromMilliseconds(50), RefreshBullShit);
_coreFileService = diContainer.Resolve <ICoreService>(new DependencyOverride <IOutputService>(new FileOutputService()));
_coreFileService.SampleReceived += coreFileService_SampleReceived;
_coreHttpService = diContainer.Resolve <ICoreService>(new DependencyOverride <IOutputService>(new HttpOutputService()));
_coreHttpService.SampleReceived += coreHttpService_SampleReceived;
Observable.FromEventPattern(x => this.PathOutputChanged += x, x => this.PathOutputChanged -= x)
.Throttle(TimeSpan.FromMilliseconds(1000))
.ObserveOnDispatcher()
.Do(x => RefreshOutput())
.Subscribe();
Observable.FromEventPattern(x => this.HttpOutputChanged += x, x => this.HttpOutputChanged -= x)
.Throttle(TimeSpan.FromMilliseconds(1000))
.ObserveOnDispatcher()
.Do(x => RefreshOutput())
.Subscribe();
}
public async Task OnTheHour_ASilentPushNotificationShouldBeSent(int hour, int minutes, int seconds, bool onHour)
{
_sut = new TimerService(_timerClock, _clock.Object, _mediator.Object, _ledBoard.Object,
_timerEvents.Object, _lightsController.Object, _relayBoard.Object);
_clock.Setup(x => x.Now).Returns(new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
hour, minutes, seconds));
_sut.Start();
await Task.Delay(2.Seconds());
if (onHour)
{
_mediator.Verify(x => x.Send(It.IsAny <PushNotificationCommand>(), CancellationToken.None), Times.AtLeastOnce);
}
else
{
_mediator.Verify(x => x.Send(It.IsAny <PushNotificationCommand>(), CancellationToken.None), Times.Never);
}
}
public async Task Every5Seconds_TheRingDoorbellShouldBePolled(int hour, int minutes, int seconds, bool on5Seconds)
{
_sut = new TimerService(_timerClock, _clock.Object, _mediator.Object, _ledBoard.Object,
_timerEvents.Object, _lightsController.Object, _relayBoard.Object);
_clock.Setup(x => x.Now).Returns(new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
hour, minutes, seconds));
_sut.Start();
await Task.Delay(2.Seconds());
if (on5Seconds)
{
_mediator.Verify(x => x.Publish(It.IsAny <PollDoorbellMotionCommand>(), CancellationToken.None), Times.AtLeastOnce);
}
else
{
_mediator.Verify(x => x.Publish(It.IsAny <PollDoorbellMotionCommand>(), CancellationToken.None), Times.Never);
}
}
public BotDeploymentViewModel(IArenaClient arenaClient, IBotClient botClient, IDeploymentClient deploymentClient, IScriptClient scriptClient, IEventAggregator eventAggregator, IFileExplorerService fileExplorerService, IFileService fileService, ITimerService timerService, ICacheService cacheService)
{
_arenaClient = arenaClient;
_botClient = botClient;
_deploymentClient = deploymentClient;
_scriptClient = scriptClient;
_eventAggregator = eventAggregator;
_fileExplorerService = fileExplorerService;
_fileService = fileService;
_cacheService = cacheService;
timerService.Start(TimeSpan.FromSeconds(5), RefreshArenas);
SubscribeEvents(eventAggregator);
SaveScriptCommand = new RelayCommand(OnSaveScript);
LoadScriptCommand = new RelayCommand(OnLoadScript);
ValidateBotScriptCommand = new RelayCommand(OnValidateBotScript);
DeployBotCommand = new RelayCommand(OnDeployBot,
() => SelectedArena != null && ScriptValid && (TimeUntilNextAllowedDeployment <= TimeSpan.Zero && (BotPhysicalHealth + BotStamina <= SelectedArena.MaximumPoints) /*|| CurrentTeam.Predator*/));
}
