public synchronized void gatherLatestDatapointsLocking(long catId, int history) {
waitForLock();
mDatapointCache.populateLatest(catId, history);
TimeSeries ts = getSeriesByIdNonlocking(catId);
if (ts == null) {
unlock();
return;
}
if (ts.getDbRow().getSynthetic() == false) {
ts.clearSeries();
EntryDbTable.Row entry = mDbh.fetchLastCategoryEntry(catId);
if (entry != null) {
ArrayList<Datapoint> l = mDatapointCache.getLast(catId, history);
if (l == null
|| l.size() < 1
|| entry.getTimestamp() > l.get(0).mMillis
|| entry.getValue() != l.get(0).mValue.y) {
mDatapointCache.clearCache(catId);
mDatapointCache.populateLatest(catId, history);
l = mDatapointCache.getLast(catId, history);
}
l = aggregateDatapoints(l, ts.getDbRow().getType());
ts.setDatapoints(null, l, null, true);
}
}
unlock();
}
private void aggregateDatapoints(TimeSeries ts) {
ArrayList<Datapoint> pre;
ArrayList<Datapoint> range;
ArrayList<Datapoint> post;
pre = aggregateDatapoints(ts.getVisiblePre(), ts.getDbRow().getType());
range = aggregateDatapoints(ts.getVisible(), ts.getDbRow().getType());
post = aggregateDatapoints(ts.getVisiblePost(), ts.getDbRow().getType());
ts.setDatapoints(pre, range, post, true);
return;
}
public synchronized void gatherSeries(long milliStart, long milliEnd) {
ArrayList<Datapoint> pre, range, post;
boolean has_data;
long oldAggregationMs = mAggregationMs;
mQueryStart = milliStart;
mQueryEnd = milliEnd;
setCollectionTimes(milliStart, milliEnd);
for (int i = 0; i < mSeries.size(); i++) {
has_data = false;
TimeSeries ts = mSeries.get(i);
if (ts == null || ts.getDbRow().getSynthetic()) continue;
if (ts.isEnabled() == false) {
boolean skip = true;
for (int j = 0; j < ts.getDependees().size(); j++) {
if (ts.getDependees().get(j).isEnabled() == true) {
skip = false;
break;
}
}
if (skip == true) continue;
}
mDatapointCache.populateRange(
ts.getDbRow().getId(), mCollectionStart, mCollectionEnd, mAggregationMs);
pre = mDatapointCache.getDataBefore(ts.getDbRow().getId(), mHistory, mCollectionStart);
if (pre != null && pre.size() > 0) has_data = true;
range =
mDatapointCache.getDataInRange(ts.getDbRow().getId(), mCollectionStart, mCollectionEnd);
if (range != null && range.size() > 0) has_data = true;
post = mDatapointCache.getDataAfter(ts.getDbRow().getId(), 1, mCollectionEnd);
if (post != null && range.size() > 0) has_data = true;
if (has_data == true) ts.setDatapoints(pre, range, post, true);
}
generateSynthetics();
ArrayList<TimeSeries> enabledSeries = getAllEnabledSeries();
for (int i = 0; i < enabledSeries.size(); i++) {
aggregateDatapoints(enabledSeries.get(i));
}
mAggregationMs = oldAggregationMs;
return;
}
public TimeSeries getSeriesByNameNonlocking(String name) {
for (int i = 0; i < mSeries.size(); i++) {
TimeSeries ts = mSeries.get(i);
if (ts != null && ts.getDbRow().getCategoryName().equals(name)) return ts;
}
return null;
}
private TimeSeries getSeriesByIdNonlocking(long catId) {
for (int i = 0; i < mSeries.size(); i++) {
TimeSeries ts = mSeries.get(i);
if (ts != null && ts.getDbRow().getId() == catId) return ts;
}
return null;
}
private void setDependees(TimeSeries ts) {
ts.getDependees().clear();
for (int i = 0; i < mSeries.size(); i++) {
TimeSeries dependee = getSeries(i);
if (ts == null || dependee == null || ts == dependee) continue;
if (dependee.getDbRow().getSynthetic() == true) {
Formula formula = mFormulaCache.getFormula(dependee.getDbRow().getId());
ArrayList<String> names = formula.getDependentNames();
if (names != null && names.contains(ts.getDbRow().getCategoryName()))
ts.addDependee(dependee);
}
}
return;
}
private void setDependents(TimeSeries synth) {
if (synth.getDbRow().getSynthetic() == false) return;
Formula formula = mFormulaCache.getFormula(synth.getDbRow().getId());
ArrayList<String> names = formula.getDependentNames();
if (names == null) return;
synth.getDependents().clear();
for (int i = 0; i < mSeries.size(); i++) {
TimeSeries ts = mSeries.get(i);
if (ts == null || ts == synth) continue;
if (names.contains(ts.getDbRow().getCategoryName())) synth.addDependent(ts);
}
return;
}
public long getSeriesIdLocking(int i) {
long id = -1;
waitForLock();
TimeSeries ts = getSeries(i);
if (ts != null) id = ts.getDbRow().getId();
unlock();
return id;
}
public CategoryDbTable.Row getSeriesMetaLocking(int i) {
CategoryDbTable.Row row = null;
waitForLock();
TimeSeries ts = getSeries(i);
row = new CategoryDbTable.Row(ts.getDbRow());
unlock();
return row;
}
private void generateSynthetics() {
for (int i = 0; i < mSeries.size(); i++) {
TimeSeries synth = mSeries.get(i);
if (synth == null || synth.getDbRow().getSynthetic() == false || synth.isEnabled() == false)
continue;
generateSynthetic(synth);
}
}
public void updateTimeSeriesData(long start, long end, boolean flushCache) {
for (int i = 0; i < mSeries.size(); i++) {
TimeSeries ts = mSeries.get(i);
if (ts != null && ts.isEnabled() == true) {
long catId = ts.getDbRow().getId();
updateTimeSeriesDataLocking(catId, start, end, flushCache);
}
}
}
private void generateSynthetic(TimeSeries synth) {
Formula formula = mFormulaCache.getFormula(synth.getDbRow().getId());
long ms;
long firstVisibleMs = Long.MAX_VALUE;
long lastVisibleMs = Long.MIN_VALUE;
for (int j = 0; j < synth.getDependents().size(); j++) {
TimeSeries ts = synth.getDependents().get(j);
List<Datapoint> range = ts.getVisible();
if (range != null) {
ms = range.get(0).mMillis;
if (ms < firstVisibleMs) firstVisibleMs = ms;
ms = range.get(range.size() - 1).mMillis;
if (ms > lastVisibleMs) lastVisibleMs = ms;
}
}
ArrayList<Datapoint> calculated = formula.apply(synth.getDependents());
ArrayList<Datapoint> pre = new ArrayList<Datapoint>();
ArrayList<Datapoint> visible = new ArrayList<Datapoint>();
ArrayList<Datapoint> post = new ArrayList<Datapoint>();
for (int j = 0; j < calculated.size(); j++) {
Datapoint d = calculated.get(j);
d.mCatId = synth.getDbRow().getId();
d.mSynthetic = true;
if (d.mMillis < firstVisibleMs) pre.add(d);
else if (d.mMillis <= lastVisibleMs) visible.add(d);
else post.add(d);
}
pre = aggregateDatapoints(pre, synth.getDbRow().getType());
visible = aggregateDatapoints(visible, synth.getDbRow().getType());
post = aggregateDatapoints(post, synth.getDbRow().getType());
synth.setDatapoints(pre, visible, post, true);
}
public synchronized void updateCategoryTrend(long catId) {
String trendStr = "trend_unknown";
float stdDev = 0.0f;
float lastTrend = 0.0f;
float newTrend = 0.0f;
gatherLatestDatapointsLocking(catId, mHistory);
TimeSeries ts = getSeriesByIdLocking(catId);
if (ts == null) return;
if (ts.getDbRow().getSynthetic() == true) return;
lastTrend = ts.getTrendStats().mTrendPrev;
newTrend = ts.getTrendStats().mTrend;
stdDev = ts.getValueStats().mStdDev;
TrendState state =
Number.getTrendState(lastTrend, newTrend, ts.getDbRow().getGoal(), mSensitivity, stdDev);
trendStr = Number.mapTrendStateToString(state);
mDbh.updateCategoryTrend(catId, trendStr, newTrend);
if (ts.getDependees() != null && ts.getDependees().size() > 0) {
for (int i = 0; i < ts.getDependees().size(); i++) {
TimeSeries dependee = ts.getDependees().get(i);
for (int j = 0; j < dependee.getDependents().size(); j++) {
TimeSeries tmp = dependee.getDependents().get(j);
if (tmp != null) gatherLatestDatapointsLocking(tmp.getDbRow().getId(), mHistory);
}
Formula formula = mFormulaCache.getFormula(dependee.getDbRow().getId());
ArrayList<Datapoint> calculated = formula.apply(dependee.getDependents());
dependee.setDatapoints(null, calculated, null, true);
lastTrend = dependee.getTrendStats().mTrendPrev;
newTrend = dependee.getTrendStats().mTrend;
stdDev = dependee.getValueStats().mStdDev;
state =
Number.getTrendState(
lastTrend, newTrend, dependee.getDbRow().getGoal(), mSensitivity, stdDev);
trendStr = Number.mapTrendStateToString(state);
mDbh.updateCategoryTrend(dependee.getDbRow().getId(), trendStr, newTrend);
}
}
}
