/*
* 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.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.service.notification.StatusBarNotification;
import android.util.Log;
import com.android.server.notification.NotificationManagerService.DumpFilter;
import java.io.PrintWriter;
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 {
// WARNING: Aggregated stats can grow unboundedly with pkg+id+tag.
// Don't enable on production builds.
private static final boolean ENABLE_AGGREGATED_IN_MEMORY_STATS = false;
private static final boolean ENABLE_SQLITE_LOG = false;
private static final AggregatedStats[] EMPTY_AGGREGATED_STATS = new AggregatedStats[0];
// Guarded by synchronized(this).
private final Map<String, AggregatedStats> mStats = new HashMap<String, AggregatedStats>();
private final SQLiteLog mSQLiteLog;
public NotificationUsageStats(Context context) {
mSQLiteLog = ENABLE_SQLITE_LOG ? new SQLiteLog(context) : null;
}
/**
* Called when a notification has been posted.
*/
public synchronized void registerPostedByApp(NotificationRecord notification) {
notification.stats = new SingleNotificationStats();
notification.stats.posttimeElapsedMs = SystemClock.elapsedRealtime();
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.numPostedByApp++;
}
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;
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.numUpdatedByApp++;
}
}
/**
* Called when the originating app removed the notification programmatically.
*/
public synchronized void registerRemovedByApp(NotificationRecord notification) {
notification.stats.onRemoved();
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.numRemovedByApp++;
stats.collect(notification.stats);
}
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logRemoved(notification);
}
}
/**
* Called when the user dismissed the notification via the UI.
*/
public synchronized void registerDismissedByUser(NotificationRecord notification) {
notification.stats.onDismiss();
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.numDismissedByUser++;
stats.collect(notification.stats);
}
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logDismissed(notification);
}
}
/**
* Called when the user clicked the notification in the UI.
*/
public synchronized void registerClickedByUser(NotificationRecord notification) {
notification.stats.onClick();
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.numClickedByUser++;
}
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.logClicked(notification);
}
}
/**
* Called when the notification is canceled because the user clicked it.
*
* <p>Called after {@link #registerClickedByUser(NotificationRecord)}.</p>
*/
public synchronized void registerCancelDueToClick(NotificationRecord notification) {
notification.stats.onCancel();
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.collect(notification.stats);
}
}
/**
* Called when the notification is canceled due to unknown reasons.
*
* <p>Called for notifications of apps being uninstalled, for example.</p>
*/
public synchronized void registerCancelUnknown(NotificationRecord notification) {
notification.stats.onCancel();
for (AggregatedStats stats : getAggregatedStatsLocked(notification)) {
stats.collect(notification.stats);
}
}
// Locked by this.
private AggregatedStats[] getAggregatedStatsLocked(NotificationRecord record) {
if (!ENABLE_AGGREGATED_IN_MEMORY_STATS) {
return EMPTY_AGGREGATED_STATS;
}
StatusBarNotification n = record.sbn;
String user = String.valueOf(n.getUserId());
String userPackage = user + ":" + n.getPackageName();
// TODO: Use pool of arrays.
return new AggregatedStats[] {
getOrCreateAggregatedStatsLocked(user),
getOrCreateAggregatedStatsLocked(userPackage),
getOrCreateAggregatedStatsLocked(n.getKey()),
};
}
// Locked by this.
private AggregatedStats getOrCreateAggregatedStatsLocked(String key) {
AggregatedStats result = mStats.get(key);
if (result == null) {
result = new AggregatedStats(key);
mStats.put(key, result);
}
return result;
}
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);
}
}
if (ENABLE_SQLITE_LOG) {
mSQLiteLog.dump(pw, indent, filter);
}
}
/**
* Aggregated notification stats.
*/
private static class AggregatedStats {
public final String key;
// ---- Updated as the respective events occur.
public int numPostedByApp;
public int numUpdatedByApp;
public int numRemovedByApp;
public int numClickedByUser;
public int numDismissedByUser;
// ---- Updated when a notification is canceled.
public final Aggregate posttimeMs = new Aggregate();
public final Aggregate posttimeToDismissMs = new Aggregate();
public final Aggregate posttimeToFirstClickMs = new Aggregate();
public final Aggregate airtimeCount = new Aggregate();
public final Aggregate airtimeMs = new Aggregate();
public final Aggregate posttimeToFirstAirtimeMs = new Aggregate();
public final Aggregate userExpansionCount = new Aggregate();
public final Aggregate airtimeExpandedMs = new Aggregate();
public final Aggregate posttimeToFirstVisibleExpansionMs = new Aggregate();
public AggregatedStats(String key) {
this.key = key;
}
public void collect(SingleNotificationStats singleNotificationStats) {
posttimeMs.addSample(
SystemClock.elapsedRealtime() - singleNotificationStats.posttimeElapsedMs);
if (singleNotificationStats.posttimeToDismissMs >= 0) {
posttimeToDismissMs.addSample(singleNotificationStats.posttimeToDismissMs);
}
if (singleNotificationStats.posttimeToFirstClickMs >= 0) {
posttimeToFirstClickMs.addSample(singleNotificationStats.posttimeToFirstClickMs);
}
airtimeCount.addSample(singleNotificationStats.airtimeCount);
if (singleNotificationStats.airtimeMs >= 0) {
airtimeMs.addSample(singleNotificationStats.airtimeMs);
}
if (singleNotificationStats.posttimeToFirstAirtimeMs >= 0) {
posttimeToFirstAirtimeMs.addSample(
singleNotificationStats.posttimeToFirstAirtimeMs);
}
if (singleNotificationStats.posttimeToFirstVisibleExpansionMs >= 0) {
posttimeToFirstVisibleExpansionMs.addSample(
singleNotificationStats.posttimeToFirstVisibleExpansionMs);
}
userExpansionCount.addSample(singleNotificationStats.userExpansionCount);
if (singleNotificationStats.airtimeExpandedMs >= 0) {
airtimeExpandedMs.addSample(singleNotificationStats.airtimeExpandedMs);
}
}
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 + " numClickedByUser=" + numClickedByUser + ",\n" +
indent + " numDismissedByUser=" + numDismissedByUser + ",\n" +
indent + " posttimeMs=" + posttimeMs + ",\n" +
indent + " posttimeToDismissMs=" + posttimeToDismissMs + ",\n" +
indent + " posttimeToFirstClickMs=" + posttimeToFirstClickMs + ",\n" +
indent + " airtimeCount=" + airtimeCount + ",\n" +
indent + " airtimeMs=" + airtimeMs + ",\n" +
indent + " posttimeToFirstAirtimeMs=" + posttimeToFirstAirtimeMs + ",\n" +
indent + " userExpansionCount=" + userExpansionCount + ",\n" +
indent + " airtimeExpandedMs=" + airtimeExpandedMs + ",\n" +
indent + " posttimeToFVEMs=" + posttimeToFirstVisibleExpansionMs + ",\n" +
indent + "}";
}
}
/**
* 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));
}
public void printPostFrequencies(PrintWriter pw, String indent, DumpFilter filter) {
SQLiteDatabase db = mHelper.getReadableDatabase();
long nowMs = System.currentTimeMillis();
String q = "SELECT " +
COL_EVENT_USER_ID + ", " +
COL_PKG + ", " +
// Bucket by day by looking at 'floor((nowMs - eventTimeMs) / dayMs)'
"CAST(((" + nowMs + " - " + 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 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);
}
}
}
|
