/// <summary>
/// Sets SnoozeTime user state and starts the snooze timer countdown.
/// </summary>
protected virtual void GoToSnoozeState(DateTime now, int?remainingSnoozeIntervalMs = null)
{
UserState = UserInteractionState.SnoozeTime;
SnoozeTimerStarted = now;
//determine interval
int configuredIntervalMs = SnoozeIntervalMinutes.Value * 60 * 1000;
int snoozeIntervalToUse = remainingSnoozeIntervalMs ?? configuredIntervalMs;
//start timer
SnoozeTimer.Interval = snoozeIntervalToUse;
Log.Logger.Information($"Starting snooze timer with intveral [Interval = {snoozeIntervalToUse} ms]");
SnoozeTimer.Start();
}
//TODO DP->SI: provide functionallity to run immediately all snooze reminders, not to bother user later with them. This will also be useful for IsOkToModifyReminder situation
public virtual bool IsOkToModifyReminder(string reminderName)
{
bool reminderIsInList = ElapsedActiveReminders.Any(rem => rem.Name == reminderName);
DateTime now = DateTime.UtcNow;
//TODO DP->SI: instead of running them now, it would be more polite to ask user if he wants to run the reminder now. It would be even better to just update the reminders immediately, but that is too complex for now (see UpdateReminderList method)
if (reminderIsInList && UserState != UserInteractionState.Disabled)
{
Log.Logger.Information("Change of elapsed but not dismissed reminder was attempted. Running snoozed reminders now.");
SnoozeTimer.Stop();
GoToRingingOrIdleState(now); //TODO: this may be unsafe as maybe we are not in snooze state, but e.g. already waiting user reaction?
}
return(!reminderIsInList);
}
/// <summary>
/// Set new snooze settings. Settings will take effect immediately.
/// </summary>
public virtual void ConfigureSnooze(bool snoozeEnabled, int snoozeIntervalMinutes)
{
DateTime now = DateTime.UtcNow;
int? oldSnoozeInterval = SnoozeIntervalMinutes;
SnoozeTimer.Stop(); //preventing concurrency issues, we will restart it again if state was indeed SnoozeTime
UpdateSnoozeIntervalPropertyValue(snoozeEnabled, snoozeIntervalMinutes);
bool snoozeIntervalChanged = oldSnoozeInterval != SnoozeIntervalMinutes;
if (snoozeIntervalChanged && UserState == UserInteractionState.SnoozeTime)
{
SetStateAfterSnoozeIntervalChange(now, snoozeIntervalChanged);
}
}
protected virtual void HandleStatusChangeAndSetIsEnabled(bool wasEnabledBefore, bool isEnabled)
{
bool startedNow = !wasEnabledBefore && isEnabled;
bool stoppedNow = wasEnabledBefore && !isEnabled;
DateTime now = DateTime.UtcNow;
if (startedNow)
{
Log.Logger.Information($"Starting UserInteractionManager");
GoToRingingOrIdleState(now);
Log.Logger.Information($"Starting UserInteractionManager done");
}
else if (stoppedNow)
{
SnoozeTimer.Stop();
UserState = UserInteractionState.Disabled;
Log.Logger.Information($"Stopped UserInteractionManager");
}
else
{
Log.Logger.Information($"UserInteractionManager already {(isEnabled ? "started" : "stopped")}");
}
}
//DEAD CODE FOR NOW
/// <summary>
/// We are not introducing new reminders through this method, we are just filtering out timers that are possibly not for ringing any more (and that are deleted) or modifying the existing ones
/// </summary>
public virtual void UpdateReminderList(IList <ReminderEntity> upToDateReminders)
{
Log.Logger.Information("Updating list of reminders in UserInteractionManger");
DateTime now = DateTime.UtcNow; //good to be constant in a variable during this analysis in method so that it doesn't change during analysis. It could make some kind of timer deadlock where timer would never ring.
//pause timer util we decide when should it ring again
if (UserState != UserInteractionState.Disabled)
{
Log.Logger.Information("Pausing UserInteractionManger timer (if it is running at all)");
SnoozeTimer.Stop();
}
List <ReminderEntity> remindersToBeRemoved = new List <ReminderEntity>();
//finding elapsed reminders that don't exist anymore
foreach (ReminderEntity elapsedReminder in ElapsedActiveReminders)
{
ReminderEntity upToDateVersionOfElapsedReminder = upToDateReminders.FirstOrDefault(rem => rem.Name == elapsedReminder.Name);
bool elapsedReminderStillExists = upToDateVersionOfElapsedReminder == null;
if (elapsedReminderStillExists)
{
//TODO: elapsed reminder still exists but it could be changed. Maybe it is not for ringing anymore or some other its parameter was modified? Should we event prevent this kind of changes during snooze period?
}
else
{
remindersToBeRemoved.Add(elapsedReminder);
}
}
bool willFirstReminderBeRemoved = WillFirstReminderBeRemoved(remindersToBeRemoved);
if (willFirstReminderBeRemoved)
{
//handle state change
}
foreach (ReminderEntity reminderToBeRemoved in remindersToBeRemoved)
{
ElapsedActiveReminders.RemoveAll(r => r.Name == reminderToBeRemoved.Name);
}
//foreach (ReminderEntity upToDateReminder in upToDateReminders)
//{
// ReminderEntity elapsedVersionOfUpToDateReminder = ElapsedActiveReminders.FirstOrDefault(rem => rem.Name == upToDateReminder.Name);
// if (elapsedVersionOfUpToDateReminder == null)
// {
// //new reminder is detected, but we can ignore this because it will first be processed by NextReminderNotifier, and if it is elapsed it will fire an event for that reminder
// }
//}
//if scheduler is enabled continue timer (if there is need for this at all after change of reminders)
if (UserState != UserInteractionState.Disabled)
{
//TryToScheduleNextReminder(now);
}
Log.Logger.Information("Updating list of reminders in ReminderScheduler done");
}
