private ActivityPeriod FindMergablePeriod(ActivityPeriod period, SortedSet <ActivityPeriod> candidates)
{
if (candidates.Count == 0)
{
return(null);
}
if (period is ActivePeriod)
{
foreach (var candidatePeriod in candidates)
{
if (candidatePeriod.IsCloseAndSameType(period, policies.IdleTimeout))
{
return(candidatePeriod);
}
}
}
if (period is IdlePeriod)
{
var candidatePeriod = candidates.Last();
if (candidatePeriod.IsCloseAndSameType(period, policies.IdleTimeout))
{
return(candidatePeriod);
}
}
return(null);
}
public bool Overlap(ActivityPeriod other)
{
if (this.Start >= other.End ||
this.End <= other.Start)
return false;
return true;
}
private SortedSet <ActivityPeriod> GetMergeCandidates(ActivityPeriod currentPeriod)
{
var mergeTimeWindowStart = currentPeriod.Start - policies.IdleTimeout;
var candidates = periodStorage.GetPeriodsAfter(mergeTimeWindowStart)
.Where(period => !period.Equals(currentPeriod));
return(new SortedSet <ActivityPeriod>(candidates));
}
public ActivityPeriod AddPeriod(ActivityPeriod activityPeriod)
{
log.Debug("add period " + activityPeriod);
var mergedPeriod = Merge(activityPeriod);
NotifyUserActivityListener(activityPeriod, mergedPeriod);
return(mergedPeriod);
}
public override void Add(ActivityPeriod activityPeriod)
{
log.Debug("add period " + activityPeriod);
using (var command = conn.CreateCommand())
{
command.CommandText = "INSERT INTO Periods (start, end, type) VALUES (:start, :end, :type)";
command.Parameters.AddWithValue("start", activityPeriod.Start);
command.Parameters.AddWithValue("end", activityPeriod.End);
command.Parameters.AddWithValue("type", activityPeriod is ActivePeriod ? "A" : "I");
var rowsAffected = command.ExecuteNonQuery();
log.Debug("rows affected " + rowsAffected);
}
}
public override void Remove(ActivityPeriod activityPeriod)
{
log.Debug("remove period " + activityPeriod);
using (var command = conn.CreateCommand())
{
command.CommandText = "DELETE FROM Periods WHERE start = :start AND end = :end AND type = :type";
command.Parameters.AddWithValue("start", activityPeriod.Start);
command.Parameters.AddWithValue("end", activityPeriod.End);
command.Parameters.AddWithValue("type", activityPeriod is ActivePeriod ? "A" : "I");
var rowsAffected = command.ExecuteNonQuery();
log.Debug("rows affected " + rowsAffected);
}
}
private void UpdateStats(StatsReporter reporter)
{
UpdateLabels(
(int)reporter.GetTotalActiveToday(DateTime.Now.Date).Round(100.ms()).TotalSeconds,
(int)reporter.GetLastInactiveTimespan().Round(100.ms()).TotalSeconds
);
ActivityPeriod currentActivityPeriod = reporter.GetCurrentLogicalPeriod();
UpdateNotifyIcon(currentActivityPeriod is ActivePeriod, (int)currentActivityPeriod.Length.TotalMinutes);
UpdateAlldayIcon(reporter.GetTotalActiveToday(DateTime.Now.Date));
UpdateHistoryWindow();
}
public bool IsCloseAndSameType(ActivityPeriod activityPeriod, TimeSpan closenessPeriod)
{
if (GetType() != activityPeriod.GetType())
{
return false;
}
if (((End - activityPeriod.Start).Duration() <= closenessPeriod) ||
((Start - activityPeriod.End).Duration() <= closenessPeriod))
{
return true;
}
return false;
}
public void Check()
{
var now = clock.CurrentTime();
if (lastInputTick == null || IsAfterWakeUp())
{
SaveLastInputTick(now);
return;
}
var wasActive = lastInputTick != probe.GetLastInputTick();
log.Debug("period was " + (wasActive ? "active" : "idle"));
activityPeriodsListener.PeriodPassed(ActivityPeriod.Create(wasActive, now - TimeSpanSinceLastCheck(), now));
SaveLastInputTick(now);
}
private void NotifyUserActivityListener(ActivityPeriod activityPeriod, ActivityPeriod mergedPeriod)
{
if (userActivityListner == null)
{
log.Debug("listener is null");
return;
}
if (activityPeriod is IdlePeriod)
{
log.Debug("period is idle");
return;
}
var periodMerged = !mergedPeriod.Equals(activityPeriod);
if (periodMerged)
{
log.Debug("period merged");
return;
}
var periodBefore = periodStorage.GetPeriodBefore(activityPeriod.Start);
if (!(periodBefore is IdlePeriod))
{
log.Debug("period before was not idle");
return;
}
if (periodBefore.Length < policies.IdleTimeout)
{
log.Debug("period before too short " + periodBefore.Length + " expected " + policies.IdleTimeout);
return;
}
if (!periodBefore.IsDirectlyBefore(activityPeriod))
{
log.Debug("period before is not directly before, before " + periodBefore + ", added" + activityPeriod);
return;
}
userActivityListner.NotifyActiveAfterBreak(periodBefore.Length);
}
private ActivityPeriod Merge(ActivityPeriod activityPeriod)
{
ActivityPeriod mergablePeriod = FindMergablePeriod(activityPeriod, GetMergeCandidates(activityPeriod));
if (mergablePeriod != null)
{
var merged = activityPeriod.Merge(mergablePeriod);
log.Debug("merged " + merged);
periodStorage.ExecuteInTransaction(() =>
{
periodStorage.RemoveFromTimePeriod(merged);
periodStorage.Add(merged);
});
return(merged);
}
periodStorage.Add(activityPeriod);
return(activityPeriod);
}
public virtual ActivityPeriod Merge(ActivityPeriod aActivityPeriod)
{
var start = Start < aActivityPeriod.Start ? Start : aActivityPeriod.Start;
var end = End > aActivityPeriod.End ? End : aActivityPeriod.End;
return new ActivityPeriod(start, end);
}
public override ActivityPeriod Merge(ActivityPeriod activityPeriod)
{
ActivityPeriod merged = base.Merge(activityPeriod);
return new IdlePeriod(merged.Start, merged.End);
}
public override void Remove(ActivityPeriod activityPeriod)
{
periods.Remove(activityPeriod);
}
public override void Add(ActivityPeriod activityPeriod)
{
periods.Add(activityPeriod);
}
public abstract void Remove(ActivityPeriod activityPeriod);
public abstract void Add(ActivityPeriod activityPeriod);
private bool IsLastIdlePeriodTreatedAsActive(ActivityPeriod last)
{
return(last is IdlePeriod && last.Length <= policies.IdleTimeout);
}
public void PeriodPassed(ActivityPeriod activityPeriod)
{
AddPeriod(activityPeriod);
}
