public ConnectionHeartbeatRequest(ConnectionManager manager, ICountdownTimer timer, Func <DateTimeOffset> nowFunc)
{
Logger = manager.Logger;
_manager = manager;
_timer = timer;
Now = nowFunc;
}
public static ConnectionHeartbeatRequest Execute(IConnectionManager manager, ICountdownTimer timer, Action <bool, ErrorInfo> callback)
{
ConnectionHeartbeatRequest request = new ConnectionHeartbeatRequest();
if (manager.Connection.State != Realtime.ConnectionState.Connected)
{
if (callback != null)
{
callback(false, DefaultError);
}
return(request);
}
if (callback != null)
{
request.manager = manager;
request.manager.MessageReceived += request.OnMessageReceived;
request.manager.Connection.ConnectionStateChanged += request.OnConnectionStateChanged;
request.timer = timer;
request.callback = callback;
}
manager.Send(new ProtocolMessage(ProtocolMessage.MessageAction.Heartbeat), null);
if (callback != null)
{
request.timer.Start(HeartbeatTimeout, request.OnTimeout);
}
return(request);
}
public static ConnectionHeartbeatRequest Execute(ConnectionManager manager, ICountdownTimer timer,
Func <DateTimeOffset> nowProvider, Action <TimeSpan?, ErrorInfo> callback)
{
var request = new ConnectionHeartbeatRequest(manager, timer, nowProvider);
return(request.Send(callback));
}
public ConnectionDisconnectedState(IConnectionContext context, ErrorInfo error, ICountdownTimer timer, ILogger logger) :
base(context, logger)
{
_timer = timer;
Error = error;
RetryIn = context.RetryTimeout;
}
public ConnectionSuspendedState(IConnectionContext context, ErrorInfo error, ICountdownTimer timer, ILogger logger)
: base(context, logger)
{
_timer = timer;
Error = error ?? ErrorInfo.ReasonSuspended;
RetryIn = context.SuspendRetryTimeout;
}
public ConnectionSuspendedState(IConnectionContext context, ErrorInfo error, ICountdownTimer timer) :
base(context)
{
_timer = timer;
this.Error = error ?? ErrorInfo.ReasonSuspended;
this.RetryIn = ConnectTimeout;
}
public ConnectionClosingState(IConnectionContext context, ErrorInfo error, bool connectedTransport, ICountdownTimer timer, ILogger logger)
: base(context, logger)
{
_connectedTransport = connectedTransport;
_timer = timer;
Error = error ?? ErrorInfo.ReasonClosed;
}
public void Setup()
{
_fakeApplicationAccessor = A.Fake <IApplicationAccessor>();
_fakeCountdownTimer = A.Fake <ICountdownTimer>();
_fakeAppSettings = A.Fake <IOptions <AppSettings> >();
_sut = new MainWindowViewModel(_fakeApplicationAccessor, _fakeCountdownTimer, _fakeAppSettings);
}
protected PomodoroPeriod(ICountdownTimer timer, ICountdownTimerStartAction startAction, ICountdownTimerUpdateAction updateAction)
{
_timer = timer;
_startAction = startAction;
_updateAction = updateAction;
_timer.TimerEvent += TimerOnTimerEvent;
}
public PomoTimer(ITimeProvider timeProvider)
{
_WorkTimer = timeProvider.CreateCountdownTimer(_WorkDuration, _Interval);
_WorkTimer.Done += OnWorkTimerDone;
_WorkTimer.Tick += OnTick;
_RestTimer = timeProvider.CreateCountdownTimer(_RestDuration, _Interval);
_RestTimer.Done += OnRestTimerDone;
_RestTimer.Tick += OnTick;
}
private void SetupCountdownTimer()
{
_countdownTimer = _container.Resolve <ICountdownTimer>(new ParameterOverrides
{
{ "time", TimeSpan.FromSeconds(_settings.CountdownTime) },
{ "updateInterval", TimeSpan.FromMilliseconds(_settings.CountdownInterval) }
});
_countdownTimer.CountdownTimerTick += (sender, e) => OnTimeLeftTick(e.TimeLeft);
_countdownTimer.TimeElaped += (sender, args) => EnableControl();
}
public MainWindowViewModel(IApplicationAccessor applicationAccessor, ICountdownTimer countdownTimer, IOptions <AppSettings> appSettings)
{
_applicationAccessor = applicationAccessor;
_countdownTimer = countdownTimer;
_appSettings = appSettings.Value;
_countdownTimer.Callback = val => RemainingTime = val;
ExitCommand = new DelegateCommand(Exit);
StartTimerCommand = new DelegateCommand(StartTimer);
StartBreakTimerCommand = new DelegateCommand(StartBreakTimer);
StopTimerCommand = new DelegateCommand(StopTimer);
}
private void FinishRequest(bool result, ErrorInfo error)
{
this.manager.MessageReceived -= this.OnMessageReceived;
this.manager.Connection.ConnectionStateChanged -= this.OnConnectionStateChanged;
this.timer.Abort();
if (this.callback != null)
{
this.callback(result, error);
}
this.callback = null;
this.manager = null;
this.timer = null;
}
public ScreenUpdater(ICradiatorView view, DiscJockey discJockey,
ICountdownTimer countdownTimer, IPollTimer pollTimer,
BuildDataFetcher buildDataFetcher, BuildDataTransformer buildDataTransformer,
FetchExceptionHandler fetchExceptionHandler, BackgroundWorker worker)
{
_view = view;
_discJockey = discJockey;
_countdownTimer = countdownTimer;
_pollTimer = pollTimer;
_pollTimer.Tick = (sender, e) => Update();
_fetcher = buildDataFetcher;
_fetchExceptionHandler = fetchExceptionHandler;
_transformer = buildDataTransformer;
_worker = worker;
worker.RunWorkerCompleted += DataFetched;
worker.DoWork += FetchData;
}
public ScreenUpdater(ICradiatorView view, DiscJockey discJockey, ICountdownTimer countdownTimer,
IPollTimer pollTimer, IConfigSettings configSettings,
BuildDataFetcher buildDataFetcher, BuildDataTransformer transformer,
FetchExceptionHandler fetchExceptionHandler, BackgroundWorker worker)
{
_view = view;
_discJockey = discJockey;
_countdownTimer = countdownTimer;
_pollTimer = pollTimer;
_configSettings = configSettings;
_pollTimer.Tick = (sender, e) => PollTimeup();
_fetcher = buildDataFetcher;
_fetchExceptionHandler = fetchExceptionHandler;
_transformer = transformer;
SetLocalValuesFromConfig(configSettings);
_configSettings.AddObserver(this);
_worker = worker;
worker.DoWork += FetchData;
worker.RunWorkerCompleted += DataFetched;
}
private void FinishRequest(TimeSpan?result, ErrorInfo error)
{
if (_finished == false)
{
lock (_syncLock)
{
if (_finished == false)
{
_finished = true;
_manager.MessageReceived -= OnMessageReceived;
_manager.Connection.InternalStateChanged -= OnInternalStateChanged;
_timer.Abort();
_callback?.Invoke(result, error);
_callback = null;
_manager = null;
_timer = null;
}
}
}
}
public ScreenUpdater(ICradiatorView view, DiscJockey discJockey, ICountdownTimer countdownTimer,
IPollTimer pollTimer, IConfigSettings configSettings,
BuildDataFetcher buildDataFetcher, BuildDataTransformer transformer,
FetchExceptionHandler fetchExceptionHandler, BackgroundWorker worker)
{
_view = view;
_discJockey = discJockey;
_countdownTimer = countdownTimer;
_pollTimer = pollTimer;
_configSettings = configSettings;
_pollTimer.Tick = (sender, e) => PollTimeup();
_fetcher = buildDataFetcher;
_fetchExceptionHandler = fetchExceptionHandler;
_transformer = transformer;
SetLocalValuesFromConfig(configSettings);
_configSettings.AddObserver(this);
_worker = worker;
worker.DoWork += FetchData;
worker.RunWorkerCompleted += DataFetched;
}
private ConnectionDisconnectedState GetState(ErrorInfo error = null, ICountdownTimer timer = null)
{
return(new ConnectionDisconnectedState(_context, error, _timer));
}
public PollIntervalChangeHandler(IPollTimer pollTimer, ICountdownTimer countTimer)
{
_pollTimer = pollTimer;
_countdownTimer = countTimer;
}
public void Act(ICountdownTimer timer) => _act.Invoke(timer);
public ConnectionConnectingState(IConnectionContext context, ICountdownTimer timer)
: base(context)
{
_timer = timer;
}
public void AssertActInvokedWith(ICountdownTimer timer) => _act.AssertInvokedWith(timer);
public void SetUp()
{
_pollTimer = MockRepository.GenerateMock<IPollTimer>();
_countdownChangeHandler = MockRepository.GenerateMock<ICountdownTimer>();
_pollingChangeHandler = new PollIntervalChangeHandler(_pollTimer, _countdownChangeHandler);
}
public void AssertActInvokedWith(IMainForm form, ICountdownTimer timer) => _act.AssertInvokedWith(new Tuple <IMainForm, ICountdownTimer>(form, timer));
private void SetupCountdownTimer()
{
_countdownTimer = _container.Resolve<ICountdownTimer>(new ParameterOverrides
{
{"time", TimeSpan.FromSeconds(_settings.CountdownTime)},
{"updateInterval", TimeSpan.FromMilliseconds(_settings.CountdownInterval)}
});
_countdownTimer.CountdownTimerTick += (sender, e) => OnTimeLeftTick(e.TimeLeft);
_countdownTimer.TimeElaped += (sender, args) => EnableControl();
}
public void Start()
{
var container = ContainerSingletone.Container;
var boundaryCenterCoordinate = Plane.transform.position;
var boundaryScale = Plane.transform.localScale;
var spawner1=new EntitySpawner();
container.BuildUp(spawner1);
spawner1.Start(SpawnerPlace1.transform.position);
var spawner2 = new EntitySpawner();
container.BuildUp(spawner2);
spawner2.Start(SpawnerPlace2.transform.position);
var spawner3 = new EntitySpawner();
container.BuildUp(spawner3);
spawner3.Start(SpawnerPlace3.transform.position);
var scoreManager = container.Resolve<IScoreManager>();
var audioPlayer = container.Resolve<IAudioPlayer> ();
audioPlayer.PlayLoop("MainTheme");
scoreManager.ScoreManipulator = _scorePlaneManuManipulator;
_countdownTimer = container.Resolve<ICountdownTimer>();
_countdownTimer.StartCountdown(30f, ShowMenu);
_scorePrinter = container.Resolve<IScorePrinter> ();
_scorePrinter.CorrectScorePlace = CorrectScorePlace;
_scorePrinter.IncorrectScorePlace = IncorrectScorePlace;
_scorePrinter.FontSize = fontSize;
_menuButtonFactory = container.Resolve<IMenuButtonFactory>();
BuildSelectedCharacter ();
BuildAdditionalButton();
}
public void SetUp()
{
_view = MockRepository.GenerateMock<ICradiatorView>();
_timer = MockRepository.GenerateMock<ICountdownTimer>();
_changeHandler = new ShowCountdownChangeHandler(_timer, _view);
}
public void SetUp()
{
_view = MockRepository.GenerateMock <IBigVisibleCruiseView>();
_timer = MockRepository.GenerateMock <ICountdownTimer>();
_updateResponder = new ShowCountdownUpdateResponder(_timer, _view);
}
public void Act(IMainForm form, ICountdownTimer timer)
{
}
private void CreateCountdownTimer(TimeSpan duration, TimeSpan interval)
{
_CountdownTimer = new CountdownTimer(
_MockTimeProvider.Object, duration, interval);
}
public void Act(IMainForm form, ICountdownTimer timer) => _act.Invoke(new Tuple <IMainForm, ICountdownTimer>(form, timer));
public ConnectionConnectingState(IConnectionContext context, ICountdownTimer timer, bool useFallbackHost = false) :
base(context)
{
_timer = timer;
_useFallbackHost = useFallbackHost;
}
public ShowCountdownChangeHandler(ICountdownTimer countdownTimer, ICradiatorView view)
{
_countdownTimer = countdownTimer;
_view = view;
}
public void SetUp()
{
_view = Create.Mock<ICradiatorView>();
_timer = Create.Mock<ICountdownTimer>();
_changeHandler = new ShowCountdownChangeHandler(_timer, _view);
}
public ConnectionClosingState(IConnectionContext context, ErrorInfo error, ICountdownTimer timer) :
base(context)
{
_timer = timer;
Error = error ?? ErrorInfo.ReasonClosed;
}
public ConnectionHeartbeatRequest(ConnectionManager manager, ICountdownTimer timer)
{
_manager = manager;
_timer = timer;
}
public ShowCountdownChangeHandler(ICountdownTimer countdownTimer, ICradiatorView view)
{
_countdownTimer = countdownTimer;
_view = view;
}
public void Act(ICountdownTimer timer)
{
} // NoOp
public PollIntervalChangeHandler(IPollTimer pollTimer, ICountdownTimer countTimer)
{
_pollTimer = pollTimer;
_countdownTimer = countTimer;
}
public void SetUp()
{
_pollTimer = Create.Mock <IPollTimer>();
_countdownChangeHandler = Create.Mock <ICountdownTimer>();
_pollingChangeHandler = new PollIntervalChangeHandler(_pollTimer, _countdownChangeHandler);
}
public TestPomodoroPeriod(ICountdownTimer timer, ICountdownTimerStartAction startAction, ICountdownTimerUpdateAction updateAction) :
base(timer, startAction, updateAction)
{
}
public void SetUp()
{
_pollTimer = Create.Mock<IPollTimer>();
_countdownChangeHandler = Create.Mock<ICountdownTimer>();
_pollingChangeHandler = new PollIntervalChangeHandler(_pollTimer, _countdownChangeHandler);
}
