/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
*/
package com.android.server.notification;
import android.app.Notification;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import com.android.internal.logging.MetricsLogger;
import com.android.server.notification.NotificationManagerService.DumpFilter;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Map;
/**
* Keeps track of notification activity, display, and user interaction.
*
* <p>This class receives signals from NoMan and keeps running stats of
* notification usage. Some metrics are updated as events occur. Others, namely
* those involving durations, are updated as the notification is canceled.</p>
*
* <p>This class is thread-safe.</p>
*
* {@hide}
*/
public class NotificationUsageStats {
private static final String TAG = "NotificationUsageStats";
private static final boolean ENABLE_AGGREGATED_IN_MEMORY_STATS = true;
private static final boolean ENABLE_SQLITE_LOG = true;
private static final AggregatedStats[] EMPTY_AGGREGATED_STATS = new AggregatedStats[0];
private static final String DEVICE_GLOBAL_STATS = "__global"; // packages start with letters
private static final int MSG_EMIT = 1;
private static final boolean DEBUG = false;
public static final int TEN_SECONDS = 1000 * 10;
public static final int FOUR_HOURS = 1000 * 60 * 60 * 4;
private static final long EMIT_PERIOD = DEBUG ? TEN_SECONDS : FOUR_HOURS;
// Guarded by synchronized(this).
private final Map<String, AggregatedStats> mStats = new HashMap<>();
private final ArrayDeque<AggregatedStats[]> mStatsArrays = new ArrayDeque<>();
private final SQLiteLog mSQLiteLog;
private final Context mContext;
private final Handler mHandler;
private long mLastEmitTime;
public NotificationUsageStats(Context context) {
mContext = context;
mLastEmitTime = SystemClock.elapsedRealtime();
mSQLiteLog = ENABLE_SQLITE_LOG ? new SQLiteLog(context) : null;
mHandler = new Handler(mContext.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_EMIT:
emit();
break;
default:
Log.wtf(TAG, "Unknown message type: " + msg.what);
break;
}
}
};
mHandler.sendEmptyMessageDelayed(MSG_EMIT, EMIT_PERIOD);
}
/**
* Called when a notification has been posted.
*/
public synchronized void registerPostedByApp(NotificationRecord notification) {
notification.stats = new SingleNotificationStats();
notification.stats.posttimeElapsedMs = SystemClock.elapsedRealtime();
AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
for (AggregatedStats stats : aggregatedStatsArray) {
stats.numPostedByApp++;
stats.countApiUse(notification);
}
releaseAggregatedStatsLocked(aggregatedStatsArray);
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logPosted(notification);
}
}
/**
* Called when a notification has been updated.
*/
public void registerUpdatedByApp(NotificationRecord notification, NotificationRecord old) {
notification.stats = old.stats;
AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
for (AggregatedStats stats : aggregatedStatsArray) {
stats.numUpdatedByApp++;
stats.countApiUse(notification);
}
releaseAggregatedStatsLocked(aggregatedStatsArray);
}
/**
* Called when the originating app removed the notification programmatically.
*/
public synchronized void registerRemovedByApp(NotificationRecord notification) {
notification.stats.onRemoved();
AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
for (AggregatedStats stats : aggregatedStatsArray) {
stats.numRemovedByApp++;
}
releaseAggregatedStatsLocked(aggregatedStatsArray);
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logRemoved(notification);
}
}
/**
* Called when the user dismissed the notification via the UI.
*/
public synchronized void registerDismissedByUser(NotificationRecord notification) {
MetricsLogger.histogram(mContext, "note_dismiss_longevity",
(int) (System.currentTimeMillis() - notification.getRankingTimeMs()) / (60 * 1000));
notification.stats.onDismiss();
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logDismissed(notification);
}
}
/**
* Called when the user clicked the notification in the UI.
*/
public synchronized void registerClickedByUser(NotificationRecord notification) {
MetricsLogger.histogram(mContext, "note_click_longevity",
(int) (System.currentTimeMillis() - notification.getRankingTimeMs()) / (60 * 1000));
notification.stats.onClick();
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logClicked(notification);
}
}
public synchronized void registerPeopleAffinity(NotificationRecord notification, boolean valid,
boolean starred, boolean cached) {
AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
for (AggregatedStats stats : aggregatedStatsArray) {
if (valid) {
stats.numWithValidPeople++;
}
if (starred) {
stats.numWithStaredPeople++;
}
if (cached) {
stats.numPeopleCacheHit++;
} else {
stats.numPeopleCacheMiss++;
}
}
releaseAggregatedStatsLocked(aggregatedStatsArray);
}
public synchronized void registerBlocked(NotificationRecord notification) {
AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
for (AggregatedStats stats : aggregatedStatsArray) {
stats.numBlocked++;
}
releaseAggregatedStatsLocked(aggregatedStatsArray);
}
// Locked by this.
private AggregatedStats[] getAggregatedStatsLocked(NotificationRecord record) {
if (!ENABLE_AGGREGATED_IN_MEMORY_STATS) {
return EMPTY_AGGREGATED_STATS;
}
// TODO: expand to package-level counts in the future.
AggregatedStats[] array = mStatsArrays.poll();
if (array == null) {
array = new AggregatedStats[1];
}
array[0] = getOrCreateAggregatedStatsLocked(DEVICE_GLOBAL_STATS);
return array;
}
// Locked by this.
private void releaseAggregatedStatsLocked(AggregatedStats[] array) {
for(int i = 0; i < array.length; i++) {
array[i] = null;
}
mStatsArrays.offer(array);
}
// Locked by this.
private AggregatedStats getOrCreateAggregatedStatsLocked(String key) {
AggregatedStats result = mStats.get(key);
if (result == null) {
result = new AggregatedStats(mContext, key);
mStats.put(key, result);
}
return result;
}
public synchronized JSONObject dumpJson(DumpFilter filter) {
JSONObject dump = new JSONObject();
if (ENABLE_AGGREGATED_IN_MEMORY_STATS) {
try {
JSONArray aggregatedStats = new JSONArray();
for (AggregatedStats as : mStats.values()) {
if (filter != null && !filter.matches(as.key))
continue;
aggregatedStats.put(as.dumpJson());
}
dump.put("current", aggregatedStats);
} catch (JSONException e) {
// pass
}
}
if (ENABLE_SQLITE_LOG) {
try {
dump.put("historical", mSQLiteLog.dumpJson(filter));
} catch (JSONException e) {
// pass
}
}
return dump;
}
public synchronized void dump(PrintWriter pw, String indent, DumpFilter filter) {
if (ENABLE_AGGREGATED_IN_MEMORY_STATS) {
for (AggregatedStats as : mStats.values()) {
if (filter != null && !filter.matches(as.key))
continue;
as.dump(pw, indent);
}
pw.println(indent + "mStatsArrays.size(): " + mStatsArrays.size());
}
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.dump(pw, indent, filter);
}
}
public synchronized void emit() {
// TODO: expand to package-level counts in the future.
AggregatedStats stats = getOrCreateAggregatedStatsLocked(DEVICE_GLOBAL_STATS);
stats.emit();
mLastEmitTime = SystemClock.elapsedRealtime();
mHandler.removeMessages(MSG_EMIT);
mHandler.sendEmptyMessageDelayed(MSG_EMIT, EMIT_PERIOD);
}
/**
* Aggregated notification stats.
*/
private static class AggregatedStats {
private final Context mContext;
public final String key;
private final long mCreated;
private AggregatedStats mPrevious;
// ---- Updated as the respective events occur.
public int numPostedByApp;
public int numUpdatedByApp;
public int numRemovedByApp;
public int numPeopleCacheHit;
public int numPeopleCacheMiss;;
public int numWithStaredPeople;
public int numWithValidPeople;
public int numBlocked;
public int numWithActions;
public int numPrivate;
public int numSecret;
public int numPriorityMax;
public int numPriorityHigh;
public int numPriorityLow;
public int numPriorityMin;
public int numWithBigText;
public int numWithBigPicture;
public int numForegroundService;
public int numOngoing;
public int numAutoCancel;
public int numWithLargeIcon;
public int numWithInbox;
public int numWithMediaSession;
public int numWithTitle;
public int numWithText;
public int numWithSubText;
public int numWithInfoText;
public int numInterrupt;
public AggregatedStats(Context context, String key) {
this.key = key;
mContext = context;
mCreated = SystemClock.elapsedRealtime();
}
public void countApiUse(NotificationRecord record) {
final Notification n = record.getNotification();
if (n.actions != null) {
numWithActions++;
}
if ((n.flags & Notification.FLAG_FOREGROUND_SERVICE) != 0) {
numForegroundService++;
}
if ((n.flags & Notification.FLAG_ONGOING_EVENT) != 0) {
numOngoing++;
}
if ((n.flags & Notification.FLAG_AUTO_CANCEL) != 0) {
numAutoCancel++;
}
if ((n.defaults & Notification.DEFAULT_SOUND) != 0 ||
(n.defaults & Notification.DEFAULT_VIBRATE) != 0 ||
n.sound != null || n.vibrate != null) {
numInterrupt++;
}
switch (n.visibility) {
case Notification.VISIBILITY_PRIVATE:
numPrivate++;
break;
case Notification.VISIBILITY_SECRET:
numSecret++;
break;
}
switch (n.priority) {
case Notification.PRIORITY_MAX:
numPriorityMax++;
break;
case Notification.PRIORITY_HIGH:
numPriorityHigh++;
break;
case Notification.PRIORITY_LOW:
numPriorityLow++;
break;
case Notification.PRIORITY_MIN:
numPriorityMin++;
break;
}
for (String Key : n.extras.keySet()) {
if (Notification.EXTRA_BIG_TEXT.equals(key)) {
numWithBigText++;
} else if (Notification.EXTRA_PICTURE.equals(key)) {
numWithBigPicture++;
} else if (Notification.EXTRA_LARGE_ICON.equals(key)) {
numWithLargeIcon++;
} else if (Notification.EXTRA_TEXT_LINES.equals(key)) {
numWithInbox++;
} else if (Notification.EXTRA_MEDIA_SESSION.equals(key)) {
numWithMediaSession++;
} else if (Notification.EXTRA_TITLE.equals(key)) {
numWithTitle++;
} else if (Notification.EXTRA_TEXT.equals(key)) {
numWithText++;
} else if (Notification.EXTRA_SUB_TEXT.equals(key)) {
numWithSubText++;
} else if (Notification.EXTRA_INFO_TEXT.equals(key)) {
numWithInfoText++;
}
}
}
public void emit() {
if (mPrevious == null) {
mPrevious = new AggregatedStats(null, key);
}
maybeCount("note_post", (numPostedByApp - mPrevious.numPostedByApp));
maybeCount("note_update", (numUpdatedByApp - mPrevious.numUpdatedByApp));
maybeCount("note_remove", (numRemovedByApp - mPrevious.numRemovedByApp));
maybeCount("note_with_people", (numWithValidPeople - mPrevious.numWithValidPeople));
maybeCount("note_with_stars", (numWithStaredPeople - mPrevious.numWithStaredPeople));
maybeCount("people_cache_hit", (numPeopleCacheHit - mPrevious.numPeopleCacheHit));
maybeCount("people_cache_miss", (numPeopleCacheMiss - mPrevious.numPeopleCacheMiss));
maybeCount("note_blocked", (numBlocked - mPrevious.numBlocked));
maybeCount("note_with_actions", (numWithActions - mPrevious.numWithActions));
maybeCount("note_private", (numPrivate - mPrevious.numPrivate));
maybeCount("note_secret", (numSecret - mPrevious.numSecret));
maybeCount("note_prio_max", (numPriorityMax - mPrevious.numPriorityMax));
maybeCount("note_prio_high", (numPriorityHigh - mPrevious.numPriorityHigh));
maybeCount("note_prio_low", (numPriorityLow - mPrevious.numPriorityLow));
maybeCount("note_prio_min", (numPriorityMin - mPrevious.numPriorityMin));
maybeCount("note_interupt", (numInterrupt - mPrevious.numInterrupt));
maybeCount("note_big_text", (numWithBigText - mPrevious.numWithBigText));
maybeCount("note_big_pic", (numWithBigPicture - mPrevious.numWithBigPicture));
maybeCount("note_fg", (numForegroundService - mPrevious.numForegroundService));
maybeCount("note_ongoing", (numOngoing - mPrevious.numOngoing));
maybeCount("note_auto", (numAutoCancel - mPrevious.numAutoCancel));
maybeCount("note_large_icon", (numWithLargeIcon - mPrevious.numWithLargeIcon));
maybeCount("note_inbox", (numWithInbox - mPrevious.numWithInbox));
maybeCount("note_media", (numWithMediaSession - mPrevious.numWithMediaSession));
maybeCount("note_title", (numWithTitle - mPrevious.numWithTitle));
maybeCount("note_text", (numWithText - mPrevious.numWithText));
maybeCount("note_sub_text", (numWithSubText - mPrevious.numWithSubText));
maybeCount("note_info_text", (numWithInfoText - mPrevious.numWithInfoText));
mPrevious.numPostedByApp = numPostedByApp;
mPrevious.numUpdatedByApp = numUpdatedByApp;
mPrevious.numRemovedByApp = numRemovedByApp;
mPrevious.numPeopleCacheHit = numPeopleCacheHit;
mPrevious.numPeopleCacheMiss = numPeopleCacheMiss;
mPrevious.numWithStaredPeople = numWithStaredPeople;
mPrevious.numWithValidPeople = numWithValidPeople;
mPrevious.numBlocked = numBlocked;
mPrevious.numWithActions = numWithActions;
mPrevious.numPrivate = numPrivate;
mPrevious.numSecret = numSecret;
mPrevious.numPriorityMax = numPriorityMax;
mPrevious.numPriorityHigh = numPriorityHigh;
mPrevious.numPriorityLow = numPriorityLow;
mPrevious.numPriorityMin = numPriorityMin;
mPrevious.numInterrupt = numInterrupt;
mPrevious.numWithBigText = numWithBigText;
mPrevious.numWithBigPicture = numWithBigPicture;
mPrevious.numForegroundService = numForegroundService;
mPrevious.numOngoing = numOngoing;
mPrevious.numAutoCancel = numAutoCancel;
mPrevious.numWithLargeIcon = numWithLargeIcon;
mPrevious.numWithInbox = numWithInbox;
mPrevious.numWithMediaSession = numWithMediaSession;
mPrevious.numWithTitle = numWithTitle;
mPrevious.numWithText = numWithText;
mPrevious.numWithSubText = numWithSubText;
mPrevious.numWithInfoText = numWithInfoText;
}
void maybeCount(String name, int value) {
if (value > 0) {
MetricsLogger.count(mContext, name, value);
}
}
public void dump(PrintWriter pw, String indent) {
pw.println(toStringWithIndent(indent));
}
@Override
public String toString() {
return toStringWithIndent("");
}
private String toStringWithIndent(String indent) {
return indent + "AggregatedStats{\n" +
indent + " key='" + key + "',\n" +
indent + " numPostedByApp=" + numPostedByApp + ",\n" +
indent + " numUpdatedByApp=" + numUpdatedByApp + ",\n" +
indent + " numRemovedByApp=" + numRemovedByApp + ",\n" +
indent + " numPeopleCacheHit=" + numPeopleCacheHit + ",\n" +
indent + " numWithStaredPeople=" + numWithStaredPeople + ",\n" +
indent + " numWithValidPeople=" + numWithValidPeople + ",\n" +
indent + " numPeopleCacheMiss=" + numPeopleCacheMiss + ",\n" +
indent + " numBlocked=" + numBlocked + ",\n" +
indent + "}";
}
public JSONObject dumpJson() throws JSONException {
JSONObject dump = new JSONObject();
dump.put("key", key);
dump.put("duration", SystemClock.elapsedRealtime() - mCreated);
maybePut(dump, "numPostedByApp", numPostedByApp);
maybePut(dump, "numUpdatedByApp", numUpdatedByApp);
maybePut(dump, "numRemovedByApp", numRemovedByApp);
maybePut(dump, "numPeopleCacheHit", numPeopleCacheHit);
maybePut(dump, "numPeopleCacheMiss", numPeopleCacheMiss);
maybePut(dump, "numWithStaredPeople", numWithStaredPeople);
maybePut(dump, "numWithValidPeople", numWithValidPeople);
maybePut(dump, "numBlocked", numBlocked);
maybePut(dump, "numWithActions", numWithActions);
maybePut(dump, "numPrivate", numPrivate);
maybePut(dump, "numSecret", numSecret);
maybePut(dump, "numPriorityMax", numPriorityMax);
maybePut(dump, "numPriorityHigh", numPriorityHigh);
maybePut(dump, "numPriorityLow", numPriorityLow);
maybePut(dump, "numPriorityMin", numPriorityMin);
maybePut(dump, "numInterrupt", numInterrupt);
maybePut(dump, "numWithBigText", numWithBigText);
maybePut(dump, "numWithBigPicture", numWithBigPicture);
maybePut(dump, "numForegroundService", numForegroundService);
maybePut(dump, "numOngoing", numOngoing);
maybePut(dump, "numAutoCancel", numAutoCancel);
maybePut(dump, "numWithLargeIcon", numWithLargeIcon);
maybePut(dump, "numWithInbox", numWithInbox);
maybePut(dump, "numWithMediaSession", numWithMediaSession);
maybePut(dump, "numWithTitle", numWithTitle);
maybePut(dump, "numWithText", numWithText);
maybePut(dump, "numWithSubText", numWithSubText);
maybePut(dump, "numWithInfoText", numWithInfoText);
return dump;
}
private void maybePut(JSONObject dump, String name, int value) throws JSONException {
if (value > 0) {
dump.put(name, value);
}
}
}
/**
* Tracks usage of an individual notification that is currently active.
*/
public static class SingleNotificationStats {
private boolean isVisible = false;
private boolean isExpanded = false;
/** SystemClock.elapsedRealtime() when the notification was posted. */
public long posttimeElapsedMs = -1;
/** Elapsed time since the notification was posted until it was first clicked, or -1. */
public long posttimeToFirstClickMs = -1;
/** Elpased time since the notification was posted until it was dismissed by the user. */
public long posttimeToDismissMs = -1;
/** Number of times the notification has been made visible. */
public long airtimeCount = 0;
/** Time in ms between the notification was posted and first shown; -1 if never shown. */
public long posttimeToFirstAirtimeMs = -1;
/**
* If currently visible, SystemClock.elapsedRealtime() when the notification was made
* visible; -1 otherwise.
*/
public long currentAirtimeStartElapsedMs = -1;
/** Accumulated visible time. */
public long airtimeMs = 0;
/**
* Time in ms between the notification being posted and when it first
* became visible and expanded; -1 if it was never visibly expanded.
*/
public long posttimeToFirstVisibleExpansionMs = -1;
/**
* If currently visible, SystemClock.elapsedRealtime() when the notification was made
* visible; -1 otherwise.
*/
public long currentAirtimeExpandedStartElapsedMs = -1;
/** Accumulated visible expanded time. */
public long airtimeExpandedMs = 0;
/** Number of times the notification has been expanded by the user. */
public long userExpansionCount = 0;
public long getCurrentPosttimeMs() {
if (posttimeElapsedMs < 0) {
return 0;
}
return SystemClock.elapsedRealtime() - posttimeElapsedMs;
}
public long getCurrentAirtimeMs() {
long result = airtimeMs;
// Add incomplete airtime if currently shown.
if (currentAirtimeStartElapsedMs >= 0) {
result += (SystemClock.elapsedRealtime() - currentAirtimeStartElapsedMs);
}
return result;
}
public long getCurrentAirtimeExpandedMs() {
long result = airtimeExpandedMs;
// Add incomplete expanded airtime if currently shown.
if (currentAirtimeExpandedStartElapsedMs >= 0) {
result += (SystemClock.elapsedRealtime() - currentAirtimeExpandedStartElapsedMs);
}
return result;
}
/**
* Called when the user clicked the notification.
*/
public void onClick() {
if (posttimeToFirstClickMs < 0) {
posttimeToFirstClickMs = SystemClock.elapsedRealtime() - posttimeElapsedMs;
}
}
/**
* Called when the user removed the notification.
*/
public void onDismiss() {
if (posttimeToDismissMs < 0) {
posttimeToDismissMs = SystemClock.elapsedRealtime() - posttimeElapsedMs;
}
finish();
}
public void onCancel() {
finish();
}
public void onRemoved() {
finish();
}
public void onVisibilityChanged(boolean visible) {
long elapsedNowMs = SystemClock.elapsedRealtime();
final boolean wasVisible = isVisible;
isVisible = visible;
if (visible) {
if (currentAirtimeStartElapsedMs < 0) {
airtimeCount++;
currentAirtimeStartElapsedMs = elapsedNowMs;
}
if (posttimeToFirstAirtimeMs < 0) {
posttimeToFirstAirtimeMs = elapsedNowMs - posttimeElapsedMs;
}
} else {
if (currentAirtimeStartElapsedMs >= 0) {
airtimeMs += (elapsedNowMs - currentAirtimeStartElapsedMs);
currentAirtimeStartElapsedMs = -1;
}
}
if (wasVisible != isVisible) {
updateVisiblyExpandedStats();
}
}
public void onExpansionChanged(boolean userAction, boolean expanded) {
isExpanded = expanded;
if (isExpanded && userAction) {
userExpansionCount++;
}
updateVisiblyExpandedStats();
}
private void updateVisiblyExpandedStats() {
long elapsedNowMs = SystemClock.elapsedRealtime();
if (isExpanded && isVisible) {
// expanded and visible
if (currentAirtimeExpandedStartElapsedMs < 0) {
currentAirtimeExpandedStartElapsedMs = elapsedNowMs;
}
if (posttimeToFirstVisibleExpansionMs < 0) {
posttimeToFirstVisibleExpansionMs = elapsedNowMs - posttimeElapsedMs;
}
} else {
// not-expanded or not-visible
if (currentAirtimeExpandedStartElapsedMs >= 0) {
airtimeExpandedMs += (elapsedNowMs - currentAirtimeExpandedStartElapsedMs);
currentAirtimeExpandedStartElapsedMs = -1;
}
}
}
/** The notification is leaving the system. Finalize. */
public void finish() {
onVisibilityChanged(false);
}
@Override
public String toString() {
return "SingleNotificationStats{" +
"posttimeElapsedMs=" + posttimeElapsedMs +
", posttimeToFirstClickMs=" + posttimeToFirstClickMs +
", posttimeToDismissMs=" + posttimeToDismissMs +
", airtimeCount=" + airtimeCount +
", airtimeMs=" + airtimeMs +
", currentAirtimeStartElapsedMs=" + currentAirtimeStartElapsedMs +
", airtimeExpandedMs=" + airtimeExpandedMs +
", posttimeToFirstVisibleExpansionMs=" + posttimeToFirstVisibleExpansionMs +
", currentAirtimeExpandedSEMs=" + currentAirtimeExpandedStartElapsedMs +
'}';
}
}
/**
* Aggregates long samples to sum and averages.
*/
public static class Aggregate {
long numSamples;
double avg;
double sum2;
double var;
public void addSample(long sample) {
// Welford's "Method for Calculating Corrected Sums of Squares"
// http://www.jstor.org/stable/1266577?seq=2
numSamples++;
final double n = numSamples;
final double delta = sample - avg;
avg += (1.0 / n) * delta;
sum2 += ((n - 1) / n) * delta * delta;
final double divisor = numSamples == 1 ? 1.0 : n - 1.0;
var = sum2 / divisor;
}
@Override
public String toString() {
return "Aggregate{" +
"numSamples=" + numSamples +
", avg=" + avg +
", var=" + var +
'}';
}
}
private static class SQLiteLog {
private static final String TAG = "NotificationSQLiteLog";
// Message types passed to the background handler.
private static final int MSG_POST = 1;
private static final int MSG_CLICK = 2;
private static final int MSG_REMOVE = 3;
private static final int MSG_DISMISS = 4;
private static final String DB_NAME = "notification_log.db";
private static final int DB_VERSION = 4;
/** Age in ms after which events are pruned from the DB. */
private static final long HORIZON_MS = 7 * 24 * 60 * 60 * 1000L; // 1 week
/** Delay between pruning the DB. Used to throttle pruning. */
private static final long PRUNE_MIN_DELAY_MS = 6 * 60 * 60 * 1000L; // 6 hours
/** Mininum number of writes between pruning the DB. Used to throttle pruning. */
private static final long PRUNE_MIN_WRITES = 1024;
// Table 'log'
private static final String TAB_LOG = "log";
private static final String COL_EVENT_USER_ID = "event_user_id";
private static final String COL_EVENT_TYPE = "event_type";
private static final String COL_EVENT_TIME = "event_time_ms";
private static final String COL_KEY = "key";
private static final String COL_PKG = "pkg";
private static final String COL_NOTIFICATION_ID = "nid";
private static final String COL_TAG = "tag";
private static final String COL_WHEN_MS = "when_ms";
private static final String COL_DEFAULTS = "defaults";
private static final String COL_FLAGS = "flags";
private static final String COL_PRIORITY = "priority";
private static final String COL_CATEGORY = "category";
private static final String COL_ACTION_COUNT = "action_count";
private static final String COL_POSTTIME_MS = "posttime_ms";
private static final String COL_AIRTIME_MS = "airtime_ms";
private static final String COL_FIRST_EXPANSIONTIME_MS = "first_expansion_time_ms";
private static final String COL_AIRTIME_EXPANDED_MS = "expansion_airtime_ms";
private static final String COL_EXPAND_COUNT = "expansion_count";
private static final int EVENT_TYPE_POST = 1;
private static final int EVENT_TYPE_CLICK = 2;
private static final int EVENT_TYPE_REMOVE = 3;
private static final int EVENT_TYPE_DISMISS = 4;
private static long sLastPruneMs;
private static long sNumWrites;
private final SQLiteOpenHelper mHelper;
private final Handler mWriteHandler;
private static final long DAY_MS = 24 * 60 * 60 * 1000;
public SQLiteLog(Context context) {
HandlerThread backgroundThread = new HandlerThread("notification-sqlite-log",
android.os.Process.THREAD_PRIORITY_BACKGROUND);
backgroundThread.start();
mWriteHandler = new Handler(backgroundThread.getLooper()) {
@Override
public void handleMessage(Message msg) {
NotificationRecord r = (NotificationRecord) msg.obj;
long nowMs = System.currentTimeMillis();
switch (msg.what) {
case MSG_POST:
writeEvent(r.sbn.getPostTime(), EVENT_TYPE_POST, r);
break;
case MSG_CLICK:
writeEvent(nowMs, EVENT_TYPE_CLICK, r);
break;
case MSG_REMOVE:
writeEvent(nowMs, EVENT_TYPE_REMOVE, r);
break;
case MSG_DISMISS:
writeEvent(nowMs, EVENT_TYPE_DISMISS, r);
break;
default:
Log.wtf(TAG, "Unknown message type: " + msg.what);
break;
}
}
};
mHelper = new SQLiteOpenHelper(context, DB_NAME, null, DB_VERSION) {
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE " + TAB_LOG + " (" +
"_id INTEGER PRIMARY KEY AUTOINCREMENT," +
COL_EVENT_USER_ID + " INT," +
COL_EVENT_TYPE + " INT," +
COL_EVENT_TIME + " INT," +
COL_KEY + " TEXT," +
COL_PKG + " TEXT," +
COL_NOTIFICATION_ID + " INT," +
COL_TAG + " TEXT," +
COL_WHEN_MS + " INT," +
COL_DEFAULTS + " INT," +
COL_FLAGS + " INT," +
COL_PRIORITY + " INT," +
COL_CATEGORY + " TEXT," +
COL_ACTION_COUNT + " INT," +
COL_POSTTIME_MS + " INT," +
COL_AIRTIME_MS + " INT," +
COL_FIRST_EXPANSIONTIME_MS + " INT," +
COL_AIRTIME_EXPANDED_MS + " INT," +
COL_EXPAND_COUNT + " INT" +
")");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
if (oldVersion <= 3) {
// Version 3 creation left 'log' in a weird state. Just reset for now.
db.execSQL("DROP TABLE IF EXISTS " + TAB_LOG);
onCreate(db);
}
}
};
}
public void logPosted(NotificationRecord notification) {
mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_POST, notification));
}
public void logClicked(NotificationRecord notification) {
mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_CLICK, notification));
}
public void logRemoved(NotificationRecord notification) {
mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_REMOVE, notification));
}
public void logDismissed(NotificationRecord notification) {
mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_DISMISS, notification));
}
private JSONArray JsonPostFrequencies(DumpFilter filter) throws JSONException {
JSONArray frequencies = new JSONArray();
SQLiteDatabase db = mHelper.getReadableDatabase();
long midnight = getMidnightMs();
String q = "SELECT " +
COL_EVENT_USER_ID + ", " +
COL_PKG + ", " +
// Bucket by day by looking at 'floor((midnight - eventTimeMs) / dayMs)'
"CAST(((" + midnight + " - " + COL_EVENT_TIME + ") / " + DAY_MS + ") AS int) " +
"AS day, " +
"COUNT(*) AS cnt " +
"FROM " + TAB_LOG + " " +
"WHERE " +
COL_EVENT_TYPE + "=" + EVENT_TYPE_POST +
" AND " + COL_EVENT_TIME + " > " + filter.since +
" GROUP BY " + COL_EVENT_USER_ID + ", day, " + COL_PKG;
Cursor cursor = db.rawQuery(q, null);
try {
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
int userId = cursor.getInt(0);
String pkg = cursor.getString(1);
if (filter != null && !filter.matches(pkg)) continue;
int day = cursor.getInt(2);
int count = cursor.getInt(3);
JSONObject row = new JSONObject();
row.put("user_id", userId);
row.put("package", pkg);
row.put("day", day);
row.put("count", count);
frequencies.put(row);
}
} finally {
cursor.close();
}
return frequencies;
}
public void printPostFrequencies(PrintWriter pw, String indent, DumpFilter filter) {
SQLiteDatabase db = mHelper.getReadableDatabase();
long midnight = getMidnightMs();
String q = "SELECT " +
COL_EVENT_USER_ID + ", " +
COL_PKG + ", " +
// Bucket by day by looking at 'floor((midnight - eventTimeMs) / dayMs)'
"CAST(((" + midnight + " - " + COL_EVENT_TIME + ") / " + DAY_MS + ") AS int) " +
"AS day, " +
"COUNT(*) AS cnt " +
"FROM " + TAB_LOG + " " +
"WHERE " +
COL_EVENT_TYPE + "=" + EVENT_TYPE_POST + " " +
"GROUP BY " + COL_EVENT_USER_ID + ", day, " + COL_PKG;
Cursor cursor = db.rawQuery(q, null);
try {
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
int userId = cursor.getInt(0);
String pkg = cursor.getString(1);
if (filter != null && !filter.matches(pkg)) continue;
int day = cursor.getInt(2);
int count = cursor.getInt(3);
pw.println(indent + "post_frequency{user_id=" + userId + ",pkg=" + pkg +
",day=" + day + ",count=" + count + "}");
}
} finally {
cursor.close();
}
}
private long getMidnightMs() {
GregorianCalendar midnight = new GregorianCalendar();
midnight.set(midnight.get(Calendar.YEAR), midnight.get(Calendar.MONTH),
midnight.get(Calendar.DATE), 23, 59, 59);
return midnight.getTimeInMillis();
}
private void writeEvent(long eventTimeMs, int eventType, NotificationRecord r) {
ContentValues cv = new ContentValues();
cv.put(COL_EVENT_USER_ID, r.sbn.getUser().getIdentifier());
cv.put(COL_EVENT_TIME, eventTimeMs);
cv.put(COL_EVENT_TYPE, eventType);
putNotificationIdentifiers(r, cv);
if (eventType == EVENT_TYPE_POST) {
putNotificationDetails(r, cv);
} else {
putPosttimeVisibility(r, cv);
}
SQLiteDatabase db = mHelper.getWritableDatabase();
if (db.insert(TAB_LOG, null, cv) < 0) {
Log.wtf(TAG, "Error while trying to insert values: " + cv);
}
sNumWrites++;
pruneIfNecessary(db);
}
private void pruneIfNecessary(SQLiteDatabase db) {
// Prune if we haven't in a while.
long nowMs = System.currentTimeMillis();
if (sNumWrites > PRUNE_MIN_WRITES ||
nowMs - sLastPruneMs > PRUNE_MIN_DELAY_MS) {
sNumWrites = 0;
sLastPruneMs = nowMs;
long horizonStartMs = nowMs - HORIZON_MS;
int deletedRows = db.delete(TAB_LOG, COL_EVENT_TIME + " < ?",
new String[] { String.valueOf(horizonStartMs) });
Log.d(TAG, "Pruned event entries: " + deletedRows);
}
}
private static void putNotificationIdentifiers(NotificationRecord r, ContentValues outCv) {
outCv.put(COL_KEY, r.sbn.getKey());
outCv.put(COL_PKG, r.sbn.getPackageName());
}
private static void putNotificationDetails(NotificationRecord r, ContentValues outCv) {
outCv.put(COL_NOTIFICATION_ID, r.sbn.getId());
if (r.sbn.getTag() != null) {
outCv.put(COL_TAG, r.sbn.getTag());
}
outCv.put(COL_WHEN_MS, r.sbn.getPostTime());
outCv.put(COL_FLAGS, r.getNotification().flags);
outCv.put(COL_PRIORITY, r.getNotification().priority);
if (r.getNotification().category != null) {
outCv.put(COL_CATEGORY, r.getNotification().category);
}
outCv.put(COL_ACTION_COUNT, r.getNotification().actions != null ?
r.getNotification().actions.length : 0);
}
private static void putPosttimeVisibility(NotificationRecord r, ContentValues outCv) {
outCv.put(COL_POSTTIME_MS, r.stats.getCurrentPosttimeMs());
outCv.put(COL_AIRTIME_MS, r.stats.getCurrentAirtimeMs());
outCv.put(COL_EXPAND_COUNT, r.stats.userExpansionCount);
outCv.put(COL_AIRTIME_EXPANDED_MS, r.stats.getCurrentAirtimeExpandedMs());
outCv.put(COL_FIRST_EXPANSIONTIME_MS, r.stats.posttimeToFirstVisibleExpansionMs);
}
public void dump(PrintWriter pw, String indent, DumpFilter filter) {
printPostFrequencies(pw, indent, filter);
}
public JSONObject dumpJson(DumpFilter filter) {
JSONObject dump = new JSONObject();
try {
dump.put("post_frequency", JsonPostFrequencies(filter));
} catch (JSONException e) {
// pass
}
return dump;
}
}
}