services/core/java/com/android/server/notification/NotificationUsageStats.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License
  15  */
  16
  17 package com.android.server.notification;
  18
  19 import static android.app.NotificationManager.IMPORTANCE_HIGH;
  20
  21 import android.app.Notification;
  22 import android.content.ContentValues;
  23 import android.content.Context;
  24 import android.database.Cursor;
  25 import android.database.sqlite.SQLiteDatabase;
  26 import android.database.sqlite.SQLiteOpenHelper;
  27 import android.os.Handler;
  28 import android.os.HandlerThread;
  29 import android.os.Message;
  30 import android.os.SystemClock;
  31 import android.text.TextUtils;
  32 import android.util.ArraySet;
  33 import android.util.Log;
  34
  35 import com.android.internal.logging.MetricsLogger;
  36 import com.android.server.notification.NotificationManagerService.DumpFilter;
  37
  38 import org.json.JSONArray;
  39 import org.json.JSONException;
  40 import org.json.JSONObject;
  41
  42 import java.io.PrintWriter;
  43 import java.lang.Math;
  44 import java.util.ArrayDeque;
  45 import java.util.Calendar;
  46 import java.util.GregorianCalendar;
  47 import java.util.HashMap;
  48 import java.util.Map;
  49 import java.util.Set;
  50
  51 /**
  52  * Keeps track of notification activity, display, and user interaction.
  53  *
  54  * <p>This class receives signals from NoMan and keeps running stats of
  55  * notification usage. Some metrics are updated as events occur. Others, namely
  56  * those involving durations, are updated as the notification is canceled.</p>
  57  *
  58  * <p>This class is thread-safe.</p>
  59  *
  60  * {@hide}
  61  */
  62 public class NotificationUsageStats {
  63     private static final String TAG = "NotificationUsageStats";
  64
  65     private static final boolean ENABLE_AGGREGATED_IN_MEMORY_STATS = true;
  66     private static final boolean ENABLE_SQLITE_LOG = true;
  67     private static final AggregatedStats[] EMPTY_AGGREGATED_STATS = new AggregatedStats[0];
  68     private static final String DEVICE_GLOBAL_STATS = "__global"; // packages start with letters
  69     private static final int MSG_EMIT = 1;
  70
  71     private static final boolean DEBUG = false;
  72     public static final int TEN_SECONDS = 1000 * 10;
  73     public static final int FOUR_HOURS = 1000 * 60 * 60 * 4;
  74     private static final long EMIT_PERIOD = DEBUG ? TEN_SECONDS : FOUR_HOURS;
  75
  76     // Guarded by synchronized(this).
  77     private final Map<String, AggregatedStats> mStats = new HashMap<>();
  78     private final ArrayDeque<AggregatedStats[]> mStatsArrays = new ArrayDeque<>();
  79     private ArraySet<String> mStatExpiredkeys = new ArraySet<>();
  80     private final SQLiteLog mSQLiteLog;
  81     private final Context mContext;
  82     private final Handler mHandler;
  83     private long mLastEmitTime;
  84
  85     public NotificationUsageStats(Context context) {
  86         mContext = context;
  87         mLastEmitTime = SystemClock.elapsedRealtime();
  88         mSQLiteLog = ENABLE_SQLITE_LOG ? new SQLiteLog(context) : null;
  89         mHandler = new Handler(mContext.getMainLooper()) {
  90             @Override
  91             public void handleMessage(Message msg) {
  92                 switch (msg.what) {
  93                     case MSG_EMIT:
  94                         emit();
  95                         break;
  96                     default:
  97                         Log.wtf(TAG, "Unknown message type: " + msg.what);
  98                         break;
  99                 }
 100             }
 101         };
 102         mHandler.sendEmptyMessageDelayed(MSG_EMIT, EMIT_PERIOD);
 103     }
 104
 105     /**
 106      * Called when a notification has been posted.
 107      */
 108     public synchronized float getAppEnqueueRate(String packageName) {
 109         AggregatedStats stats = getOrCreateAggregatedStatsLocked(packageName);
 110         if (stats != null) {
 111             return stats.getEnqueueRate(SystemClock.elapsedRealtime());
 112         } else {
 113             return 0f;
 114         }
 115     }
 116
 117     /**
 118      * Called when a notification wants to alert.
 119      */
 120     public synchronized boolean isAlertRateLimited(String packageName) {
 121         AggregatedStats stats = getOrCreateAggregatedStatsLocked(packageName);
 122         if (stats != null) {
 123             return stats.isAlertRateLimited();
 124         } else {
 125             return false;
 126         }
 127     }
 128
 129     /**
 130      * Called when a notification is tentatively enqueued by an app, before rate checking.
 131      */
 132     public synchronized void registerEnqueuedByApp(String packageName) {
 133         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(packageName);
 134         for (AggregatedStats stats : aggregatedStatsArray) {
 135             stats.numEnqueuedByApp++;
 136         }
 137         releaseAggregatedStatsLocked(aggregatedStatsArray);
 138     }
 139
 140     /**
 141      * Called when a notification has been posted.
 142      */
 143     public synchronized void registerPostedByApp(NotificationRecord notification) {
 144         final long now = SystemClock.elapsedRealtime();
 145         notification.stats.posttimeElapsedMs = now;
 146
 147         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
 148         for (AggregatedStats stats : aggregatedStatsArray) {
 149             stats.numPostedByApp++;
 150             stats.updateInterarrivalEstimate(now);
 151             stats.countApiUse(notification);
 152         }
 153         releaseAggregatedStatsLocked(aggregatedStatsArray);
 154         if (ENABLE_SQLITE_LOG) {
 155             mSQLiteLog.logPosted(notification);
 156         }
 157     }
 158
 159     /**
 160      * Called when a notification has been updated.
 161      */
 162     public synchronized void registerUpdatedByApp(NotificationRecord notification,
 163             NotificationRecord old) {
 164         notification.stats.updateFrom(old.stats);
 165         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
 166         for (AggregatedStats stats : aggregatedStatsArray) {
 167             stats.numUpdatedByApp++;
 168             stats.updateInterarrivalEstimate(SystemClock.elapsedRealtime());
 169             stats.countApiUse(notification);
 170         }
 171         releaseAggregatedStatsLocked(aggregatedStatsArray);
 172         if (ENABLE_SQLITE_LOG) {
 173             mSQLiteLog.logPosted(notification);
 174         }
 175     }
 176
 177     /**
 178      * Called when the originating app removed the notification programmatically.
 179      */
 180     public synchronized void registerRemovedByApp(NotificationRecord notification) {
 181         notification.stats.onRemoved();
 182         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
 183         for (AggregatedStats stats : aggregatedStatsArray) {
 184             stats.numRemovedByApp++;
 185         }
 186         releaseAggregatedStatsLocked(aggregatedStatsArray);
 187         if (ENABLE_SQLITE_LOG) {
 188             mSQLiteLog.logRemoved(notification);
 189         }
 190     }
 191
 192     /**
 193      * Called when the user dismissed the notification via the UI.
 194      */
 195     public synchronized void registerDismissedByUser(NotificationRecord notification) {
 196         MetricsLogger.histogram(mContext, "note_dismiss_longevity",
 197                 (int) (System.currentTimeMillis() - notification.getRankingTimeMs()) / (60 * 1000));
 198         notification.stats.onDismiss();
 199         if (ENABLE_SQLITE_LOG) {
 200             mSQLiteLog.logDismissed(notification);
 201         }
 202     }
 203
 204     /**
 205      * Called when the user clicked the notification in the UI.
 206      */
 207     public synchronized void registerClickedByUser(NotificationRecord notification) {
 208         MetricsLogger.histogram(mContext, "note_click_longevity",
 209                 (int) (System.currentTimeMillis() - notification.getRankingTimeMs()) / (60 * 1000));
 210         notification.stats.onClick();
 211         if (ENABLE_SQLITE_LOG) {
 212             mSQLiteLog.logClicked(notification);
 213         }
 214     }
 215
 216     public synchronized void registerPeopleAffinity(NotificationRecord notification, boolean valid,
 217             boolean starred, boolean cached) {
 218         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
 219         for (AggregatedStats stats : aggregatedStatsArray) {
 220             if (valid) {
 221                 stats.numWithValidPeople++;
 222             }
 223             if (starred) {
 224                 stats.numWithStaredPeople++;
 225             }
 226             if (cached) {
 227                 stats.numPeopleCacheHit++;
 228             } else {
 229                 stats.numPeopleCacheMiss++;
 230             }
 231         }
 232         releaseAggregatedStatsLocked(aggregatedStatsArray);
 233     }
 234
 235     public synchronized void registerBlocked(NotificationRecord notification) {
 236         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
 237         for (AggregatedStats stats : aggregatedStatsArray) {
 238             stats.numBlocked++;
 239         }
 240         releaseAggregatedStatsLocked(aggregatedStatsArray);
 241     }
 242
 243     public synchronized void registerSuspendedByAdmin(NotificationRecord notification) {
 244         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(notification);
 245         for (AggregatedStats stats : aggregatedStatsArray) {
 246             stats.numSuspendedByAdmin++;
 247         }
 248         releaseAggregatedStatsLocked(aggregatedStatsArray);
 249     }
 250
 251     public synchronized void registerOverRateQuota(String packageName) {
 252         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(packageName);
 253         for (AggregatedStats stats : aggregatedStatsArray) {
 254             stats.numRateViolations++;
 255         }
 256     }
 257
 258     public synchronized void registerOverCountQuota(String packageName) {
 259         AggregatedStats[] aggregatedStatsArray = getAggregatedStatsLocked(packageName);
 260         for (AggregatedStats stats : aggregatedStatsArray) {
 261             stats.numQuotaViolations++;
 262         }
 263     }
 264
 265     // Locked by this.
 266     private AggregatedStats[] getAggregatedStatsLocked(NotificationRecord record) {
 267         return getAggregatedStatsLocked(record.sbn.getPackageName());
 268     }
 269
 270     // Locked by this.
 271     private AggregatedStats[] getAggregatedStatsLocked(String packageName) {
 272         if (!ENABLE_AGGREGATED_IN_MEMORY_STATS) {
 273             return EMPTY_AGGREGATED_STATS;
 274         }
 275
 276         AggregatedStats[] array = mStatsArrays.poll();
 277         if (array == null) {
 278             array = new AggregatedStats[2];
 279         }
 280         array[0] = getOrCreateAggregatedStatsLocked(DEVICE_GLOBAL_STATS);
 281         array[1] = getOrCreateAggregatedStatsLocked(packageName);
 282         return array;
 283     }
 284
 285     // Locked by this.
 286     private void releaseAggregatedStatsLocked(AggregatedStats[] array) {
 287         for(int i = 0; i < array.length; i++) {
 288             array[i] = null;
 289         }
 290         mStatsArrays.offer(array);
 291     }
 292
 293     // Locked by this.
 294     private AggregatedStats getOrCreateAggregatedStatsLocked(String key) {
 295         AggregatedStats result = mStats.get(key);
 296         if (result == null) {
 297             result = new AggregatedStats(mContext, key);
 298             mStats.put(key, result);
 299         }
 300         result.mLastAccessTime = SystemClock.elapsedRealtime();
 301         return result;
 302     }
 303
 304     public synchronized JSONObject dumpJson(DumpFilter filter) {
 305         JSONObject dump = new JSONObject();
 306         if (ENABLE_AGGREGATED_IN_MEMORY_STATS) {
 307             try {
 308                 JSONArray aggregatedStats = new JSONArray();
 309                 for (AggregatedStats as : mStats.values()) {
 310                     if (filter != null && !filter.matches(as.key))
 311                         continue;
 312                     aggregatedStats.put(as.dumpJson());
 313                 }
 314                 dump.put("current", aggregatedStats);
 315             } catch (JSONException e) {
 316                 // pass
 317             }
 318         }
 319         if (ENABLE_SQLITE_LOG) {
 320             try {
 321                 dump.put("historical", mSQLiteLog.dumpJson(filter));
 322             } catch (JSONException e) {
 323                 // pass
 324             }
 325         }
 326         return dump;
 327     }
 328
 329     public synchronized void dump(PrintWriter pw, String indent, DumpFilter filter) {
 330         if (ENABLE_AGGREGATED_IN_MEMORY_STATS) {
 331             for (AggregatedStats as : mStats.values()) {
 332                 if (filter != null && !filter.matches(as.key))
 333                     continue;
 334                 as.dump(pw, indent);
 335             }
 336             pw.println(indent + "mStatsArrays.size(): " + mStatsArrays.size());
 337             pw.println(indent + "mStats.size(): " + mStats.size());
 338         }
 339         if (ENABLE_SQLITE_LOG) {
 340             mSQLiteLog.dump(pw, indent, filter);
 341         }
 342     }
 343
 344     public synchronized void emit() {
 345         AggregatedStats stats = getOrCreateAggregatedStatsLocked(DEVICE_GLOBAL_STATS);
 346         stats.emit();
 347         mHandler.removeMessages(MSG_EMIT);
 348         mHandler.sendEmptyMessageDelayed(MSG_EMIT, EMIT_PERIOD);
 349         for(String key: mStats.keySet()) {
 350             if (mStats.get(key).mLastAccessTime < mLastEmitTime) {
 351                 mStatExpiredkeys.add(key);
 352             }
 353         }
 354         for(String key: mStatExpiredkeys) {
 355             mStats.remove(key);
 356         }
 357         mStatExpiredkeys.clear();
 358         mLastEmitTime = SystemClock.elapsedRealtime();
 359     }
 360
 361     /**
 362      * Aggregated notification stats.
 363      */
 364     private static class AggregatedStats {
 365
 366         private final Context mContext;
 367         public final String key;
 368         private final long mCreated;
 369         private AggregatedStats mPrevious;
 370
 371         // ---- Updated as the respective events occur.
 372         public int numEnqueuedByApp;
 373         public int numPostedByApp;
 374         public int numUpdatedByApp;
 375         public int numRemovedByApp;
 376         public int numPeopleCacheHit;
 377         public int numPeopleCacheMiss;;
 378         public int numWithStaredPeople;
 379         public int numWithValidPeople;
 380         public int numBlocked;
 381         public int numSuspendedByAdmin;
 382         public int numWithActions;
 383         public int numPrivate;
 384         public int numSecret;
 385         public int numWithBigText;
 386         public int numWithBigPicture;
 387         public int numForegroundService;
 388         public int numOngoing;
 389         public int numAutoCancel;
 390         public int numWithLargeIcon;
 391         public int numWithInbox;
 392         public int numWithMediaSession;
 393         public int numWithTitle;
 394         public int numWithText;
 395         public int numWithSubText;
 396         public int numWithInfoText;
 397         public int numInterrupt;
 398         public ImportanceHistogram noisyImportance;
 399         public ImportanceHistogram quietImportance;
 400         public ImportanceHistogram finalImportance;
 401         public RateEstimator enqueueRate;
 402         public AlertRateLimiter alertRate;
 403         public int numRateViolations;
 404         public int numAlertViolations;
 405         public int numQuotaViolations;
 406         public long mLastAccessTime;
 407
 408         public AggregatedStats(Context context, String key) {
 409             this.key = key;
 410             mContext = context;
 411             mCreated = SystemClock.elapsedRealtime();
 412             noisyImportance = new ImportanceHistogram(context, "note_imp_noisy_");
 413             quietImportance = new ImportanceHistogram(context, "note_imp_quiet_");
 414             finalImportance = new ImportanceHistogram(context, "note_importance_");
 415             enqueueRate = new RateEstimator();
 416             alertRate = new AlertRateLimiter();
 417         }
 418
 419         public AggregatedStats getPrevious() {
 420             if (mPrevious == null) {
 421                 mPrevious = new AggregatedStats(mContext, key);
 422             }
 423             return mPrevious;
 424         }
 425
 426         public void countApiUse(NotificationRecord record) {
 427             final Notification n = record.getNotification();
 428             if (n.actions != null) {
 429                 numWithActions++;
 430             }
 431
 432             if ((n.flags & Notification.FLAG_FOREGROUND_SERVICE) != 0) {
 433                 numForegroundService++;
 434             }
 435
 436             if ((n.flags & Notification.FLAG_ONGOING_EVENT) != 0) {
 437                 numOngoing++;
 438             }
 439
 440             if ((n.flags & Notification.FLAG_AUTO_CANCEL) != 0) {
 441                 numAutoCancel++;
 442             }
 443
 444             if ((n.defaults & Notification.DEFAULT_SOUND) != 0 ||
 445                     (n.defaults & Notification.DEFAULT_VIBRATE) != 0 ||
 446                     n.sound != null || n.vibrate != null) {
 447                 numInterrupt++;
 448             }
 449
 450             switch (n.visibility) {
 451                 case Notification.VISIBILITY_PRIVATE:
 452                     numPrivate++;
 453                     break;
 454                 case Notification.VISIBILITY_SECRET:
 455                     numSecret++;
 456                     break;
 457             }
 458
 459             if (record.stats.isNoisy) {
 460                 noisyImportance.increment(record.stats.requestedImportance);
 461             } else {
 462                 quietImportance.increment(record.stats.requestedImportance);
 463             }
 464             finalImportance.increment(record.getImportance());
 465
 466             final Set<String> names = n.extras.keySet();
 467             if (names.contains(Notification.EXTRA_BIG_TEXT)) {
 468                 numWithBigText++;
 469             }
 470             if (names.contains(Notification.EXTRA_PICTURE)) {
 471                 numWithBigPicture++;
 472             }
 473             if (names.contains(Notification.EXTRA_LARGE_ICON)) {
 474                 numWithLargeIcon++;
 475             }
 476             if (names.contains(Notification.EXTRA_TEXT_LINES)) {
 477                 numWithInbox++;
 478             }
 479             if (names.contains(Notification.EXTRA_MEDIA_SESSION)) {
 480                 numWithMediaSession++;
 481             }
 482             if (names.contains(Notification.EXTRA_TITLE) &&
 483                     !TextUtils.isEmpty(n.extras.getCharSequence(Notification.EXTRA_TITLE))) {
 484                 numWithTitle++;
 485             }
 486             if (names.contains(Notification.EXTRA_TEXT) &&
 487                     !TextUtils.isEmpty(n.extras.getCharSequence(Notification.EXTRA_TEXT))) {
 488                 numWithText++;
 489             }
 490             if (names.contains(Notification.EXTRA_SUB_TEXT) &&
 491                     !TextUtils.isEmpty(n.extras.getCharSequence(Notification.EXTRA_SUB_TEXT))) {
 492                 numWithSubText++;
 493             }
 494             if (names.contains(Notification.EXTRA_INFO_TEXT) &&
 495                     !TextUtils.isEmpty(n.extras.getCharSequence(Notification.EXTRA_INFO_TEXT))) {
 496                 numWithInfoText++;
 497             }
 498         }
 499
 500         public void emit() {
 501             AggregatedStats previous = getPrevious();
 502             maybeCount("note_enqueued", (numEnqueuedByApp - previous.numEnqueuedByApp));
 503             maybeCount("note_post", (numPostedByApp - previous.numPostedByApp));
 504             maybeCount("note_update", (numUpdatedByApp - previous.numUpdatedByApp));
 505             maybeCount("note_remove", (numRemovedByApp - previous.numRemovedByApp));
 506             maybeCount("note_with_people", (numWithValidPeople - previous.numWithValidPeople));
 507             maybeCount("note_with_stars", (numWithStaredPeople - previous.numWithStaredPeople));
 508             maybeCount("people_cache_hit", (numPeopleCacheHit - previous.numPeopleCacheHit));
 509             maybeCount("people_cache_miss", (numPeopleCacheMiss - previous.numPeopleCacheMiss));
 510             maybeCount("note_blocked", (numBlocked - previous.numBlocked));
 511             maybeCount("note_suspended", (numSuspendedByAdmin - previous.numSuspendedByAdmin));
 512             maybeCount("note_with_actions", (numWithActions - previous.numWithActions));
 513             maybeCount("note_private", (numPrivate - previous.numPrivate));
 514             maybeCount("note_secret", (numSecret - previous.numSecret));
 515             maybeCount("note_interupt", (numInterrupt - previous.numInterrupt));
 516             maybeCount("note_big_text", (numWithBigText - previous.numWithBigText));
 517             maybeCount("note_big_pic", (numWithBigPicture - previous.numWithBigPicture));
 518             maybeCount("note_fg", (numForegroundService - previous.numForegroundService));
 519             maybeCount("note_ongoing", (numOngoing - previous.numOngoing));
 520             maybeCount("note_auto", (numAutoCancel - previous.numAutoCancel));
 521             maybeCount("note_large_icon", (numWithLargeIcon - previous.numWithLargeIcon));
 522             maybeCount("note_inbox", (numWithInbox - previous.numWithInbox));
 523             maybeCount("note_media", (numWithMediaSession - previous.numWithMediaSession));
 524             maybeCount("note_title", (numWithTitle - previous.numWithTitle));
 525             maybeCount("note_text", (numWithText - previous.numWithText));
 526             maybeCount("note_sub_text", (numWithSubText - previous.numWithSubText));
 527             maybeCount("note_info_text", (numWithInfoText - previous.numWithInfoText));
 528             maybeCount("note_over_rate", (numRateViolations - previous.numRateViolations));
 529             maybeCount("note_over_alert_rate", (numAlertViolations - previous.numAlertViolations));
 530             maybeCount("note_over_quota", (numQuotaViolations - previous.numQuotaViolations));
 531             noisyImportance.maybeCount(previous.noisyImportance);
 532             quietImportance.maybeCount(previous.quietImportance);
 533             finalImportance.maybeCount(previous.finalImportance);
 534
 535             previous.numEnqueuedByApp = numEnqueuedByApp;
 536             previous.numPostedByApp = numPostedByApp;
 537             previous.numUpdatedByApp = numUpdatedByApp;
 538             previous.numRemovedByApp = numRemovedByApp;
 539             previous.numPeopleCacheHit = numPeopleCacheHit;
 540             previous.numPeopleCacheMiss = numPeopleCacheMiss;
 541             previous.numWithStaredPeople = numWithStaredPeople;
 542             previous.numWithValidPeople = numWithValidPeople;
 543             previous.numBlocked = numBlocked;
 544             previous.numSuspendedByAdmin = numSuspendedByAdmin;
 545             previous.numWithActions = numWithActions;
 546             previous.numPrivate = numPrivate;
 547             previous.numSecret = numSecret;
 548             previous.numInterrupt = numInterrupt;
 549             previous.numWithBigText = numWithBigText;
 550             previous.numWithBigPicture = numWithBigPicture;
 551             previous.numForegroundService = numForegroundService;
 552             previous.numOngoing = numOngoing;
 553             previous.numAutoCancel = numAutoCancel;
 554             previous.numWithLargeIcon = numWithLargeIcon;
 555             previous.numWithInbox = numWithInbox;
 556             previous.numWithMediaSession = numWithMediaSession;
 557             previous.numWithTitle = numWithTitle;
 558             previous.numWithText = numWithText;
 559             previous.numWithSubText = numWithSubText;
 560             previous.numWithInfoText = numWithInfoText;
 561             previous.numRateViolations = numRateViolations;
 562             previous.numAlertViolations = numAlertViolations;
 563             previous.numQuotaViolations = numQuotaViolations;
 564             noisyImportance.update(previous.noisyImportance);
 565             quietImportance.update(previous.quietImportance);
 566             finalImportance.update(previous.finalImportance);
 567         }
 568
 569         void maybeCount(String name, int value) {
 570             if (value > 0) {
 571                 MetricsLogger.count(mContext, name, value);
 572             }
 573         }
 574
 575         public void dump(PrintWriter pw, String indent) {
 576             pw.println(toStringWithIndent(indent));
 577         }
 578
 579         @Override
 580         public String toString() {
 581             return toStringWithIndent("");
 582         }
 583
 584         /** @return the enqueue rate if there were a new enqueue event right now. */
 585         public float getEnqueueRate() {
 586             return getEnqueueRate(SystemClock.elapsedRealtime());
 587         }
 588
 589         public float getEnqueueRate(long now) {
 590             return enqueueRate.getRate(now);
 591         }
 592
 593         public void updateInterarrivalEstimate(long now) {
 594             enqueueRate.update(now);
 595         }
 596
 597         public boolean isAlertRateLimited() {
 598             boolean limited = alertRate.shouldRateLimitAlert(SystemClock.elapsedRealtime());
 599             if (limited) {
 600                 numAlertViolations++;
 601             }
 602             return limited;
 603         }
 604
 605         private String toStringWithIndent(String indent) {
 606             StringBuilder output = new StringBuilder();
 607             output.append(indent).append("AggregatedStats{\n");
 608             String indentPlusTwo = indent + "  ";
 609             output.append(indentPlusTwo);
 610             output.append("key='").append(key).append("',\n");
 611             output.append(indentPlusTwo);
 612             output.append("numEnqueuedByApp=").append(numEnqueuedByApp).append(",\n");
 613             output.append(indentPlusTwo);
 614             output.append("numPostedByApp=").append(numPostedByApp).append(",\n");
 615             output.append(indentPlusTwo);
 616             output.append("numUpdatedByApp=").append(numUpdatedByApp).append(",\n");
 617             output.append(indentPlusTwo);
 618             output.append("numRemovedByApp=").append(numRemovedByApp).append(",\n");
 619             output.append(indentPlusTwo);
 620             output.append("numPeopleCacheHit=").append(numPeopleCacheHit).append(",\n");
 621             output.append(indentPlusTwo);
 622             output.append("numWithStaredPeople=").append(numWithStaredPeople).append(",\n");
 623             output.append(indentPlusTwo);
 624             output.append("numWithValidPeople=").append(numWithValidPeople).append(",\n");
 625             output.append(indentPlusTwo);
 626             output.append("numPeopleCacheMiss=").append(numPeopleCacheMiss).append(",\n");
 627             output.append(indentPlusTwo);
 628             output.append("numBlocked=").append(numBlocked).append(",\n");
 629             output.append(indentPlusTwo);
 630             output.append("numSuspendedByAdmin=").append(numSuspendedByAdmin).append(",\n");
 631             output.append(indentPlusTwo);
 632             output.append("numWithActions=").append(numWithActions).append(",\n");
 633             output.append(indentPlusTwo);
 634             output.append("numPrivate=").append(numPrivate).append(",\n");
 635             output.append(indentPlusTwo);
 636             output.append("numSecret=").append(numSecret).append(",\n");
 637             output.append(indentPlusTwo);
 638             output.append("numInterrupt=").append(numInterrupt).append(",\n");
 639             output.append(indentPlusTwo);
 640             output.append("numWithBigText=").append(numWithBigText).append(",\n");
 641             output.append(indentPlusTwo);
 642             output.append("numWithBigPicture=").append(numWithBigPicture).append("\n");
 643             output.append(indentPlusTwo);
 644             output.append("numForegroundService=").append(numForegroundService).append("\n");
 645             output.append(indentPlusTwo);
 646             output.append("numOngoing=").append(numOngoing).append("\n");
 647             output.append(indentPlusTwo);
 648             output.append("numAutoCancel=").append(numAutoCancel).append("\n");
 649             output.append(indentPlusTwo);
 650             output.append("numWithLargeIcon=").append(numWithLargeIcon).append("\n");
 651             output.append(indentPlusTwo);
 652             output.append("numWithInbox=").append(numWithInbox).append("\n");
 653             output.append(indentPlusTwo);
 654             output.append("numWithMediaSession=").append(numWithMediaSession).append("\n");
 655             output.append(indentPlusTwo);
 656             output.append("numWithTitle=").append(numWithTitle).append("\n");
 657             output.append(indentPlusTwo);
 658             output.append("numWithText=").append(numWithText).append("\n");
 659             output.append(indentPlusTwo);
 660             output.append("numWithSubText=").append(numWithSubText).append("\n");
 661             output.append(indentPlusTwo);
 662             output.append("numWithInfoText=").append(numWithInfoText).append("\n");
 663             output.append(indentPlusTwo);
 664             output.append("numRateViolations=").append(numRateViolations).append("\n");
 665             output.append(indentPlusTwo);
 666             output.append("numAlertViolations=").append(numAlertViolations).append("\n");
 667             output.append(indentPlusTwo);
 668             output.append("numQuotaViolations=").append(numQuotaViolations).append("\n");
 669             output.append(indentPlusTwo).append(noisyImportance.toString()).append("\n");
 670             output.append(indentPlusTwo).append(quietImportance.toString()).append("\n");
 671             output.append(indentPlusTwo).append(finalImportance.toString()).append("\n");
 672             output.append(indent).append("}");
 673             return output.toString();
 674         }
 675
 676         public JSONObject dumpJson() throws JSONException {
 677             AggregatedStats previous = getPrevious();
 678             JSONObject dump = new JSONObject();
 679             dump.put("key", key);
 680             dump.put("duration", SystemClock.elapsedRealtime() - mCreated);
 681             maybePut(dump, "numEnqueuedByApp", numEnqueuedByApp);
 682             maybePut(dump, "numPostedByApp", numPostedByApp);
 683             maybePut(dump, "numUpdatedByApp", numUpdatedByApp);
 684             maybePut(dump, "numRemovedByApp", numRemovedByApp);
 685             maybePut(dump, "numPeopleCacheHit", numPeopleCacheHit);
 686             maybePut(dump, "numPeopleCacheMiss", numPeopleCacheMiss);
 687             maybePut(dump, "numWithStaredPeople", numWithStaredPeople);
 688             maybePut(dump, "numWithValidPeople", numWithValidPeople);
 689             maybePut(dump, "numBlocked", numBlocked);
 690             maybePut(dump, "numSuspendedByAdmin", numSuspendedByAdmin);
 691             maybePut(dump, "numWithActions", numWithActions);
 692             maybePut(dump, "numPrivate", numPrivate);
 693             maybePut(dump, "numSecret", numSecret);
 694             maybePut(dump, "numInterrupt", numInterrupt);
 695             maybePut(dump, "numWithBigText", numWithBigText);
 696             maybePut(dump, "numWithBigPicture", numWithBigPicture);
 697             maybePut(dump, "numForegroundService", numForegroundService);
 698             maybePut(dump, "numOngoing", numOngoing);
 699             maybePut(dump, "numAutoCancel", numAutoCancel);
 700             maybePut(dump, "numWithLargeIcon", numWithLargeIcon);
 701             maybePut(dump, "numWithInbox", numWithInbox);
 702             maybePut(dump, "numWithMediaSession", numWithMediaSession);
 703             maybePut(dump, "numWithTitle", numWithTitle);
 704             maybePut(dump, "numWithText", numWithText);
 705             maybePut(dump, "numWithSubText", numWithSubText);
 706             maybePut(dump, "numWithInfoText", numWithInfoText);
 707             maybePut(dump, "numRateViolations", numRateViolations);
 708             maybePut(dump, "numQuotaLViolations", numQuotaViolations);
 709             maybePut(dump, "notificationEnqueueRate", getEnqueueRate());
 710             maybePut(dump, "numAlertViolations", numAlertViolations);
 711             noisyImportance.maybePut(dump, previous.noisyImportance);
 712             quietImportance.maybePut(dump, previous.quietImportance);
 713             finalImportance.maybePut(dump, previous.finalImportance);
 714
 715             return dump;
 716         }
 717
 718         private void maybePut(JSONObject dump, String name, int value) throws JSONException {
 719             if (value > 0) {
 720                 dump.put(name, value);
 721             }
 722         }
 723
 724         private void maybePut(JSONObject dump, String name, float value) throws JSONException {
 725             if (value > 0.0) {
 726                 dump.put(name, value);
 727             }
 728         }
 729     }
 730
 731     private static class ImportanceHistogram {
 732         // TODO define these somewhere else
 733         private static final int NUM_IMPORTANCES = 6;
 734         private static final String[] IMPORTANCE_NAMES =
 735                 {"none", "min", "low", "default", "high", "max"};
 736         private final Context mContext;
 737         private final String[] mCounterNames;
 738         private final String mPrefix;
 739         private int[] mCount;
 740
 741         ImportanceHistogram(Context context, String prefix) {
 742             mContext = context;
 743             mCount = new int[NUM_IMPORTANCES];
 744             mCounterNames = new String[NUM_IMPORTANCES];
 745             mPrefix = prefix;
 746             for (int i = 0; i < NUM_IMPORTANCES; i++) {
 747                 mCounterNames[i] = mPrefix + IMPORTANCE_NAMES[i];
 748             }
 749         }
 750
 751         void increment(int imp) {
 752             imp = Math.max(0, Math.min(imp, mCount.length - 1));
 753             mCount[imp]++;
 754         }
 755
 756         void maybeCount(ImportanceHistogram prev) {
 757             for (int i = 0; i < NUM_IMPORTANCES; i++) {
 758                 final int value = mCount[i] - prev.mCount[i];
 759                 if (value > 0) {
 760                     MetricsLogger.count(mContext, mCounterNames[i], value);
 761                 }
 762             }
 763         }
 764
 765         void update(ImportanceHistogram that) {
 766             for (int i = 0; i < NUM_IMPORTANCES; i++) {
 767                 mCount[i] = that.mCount[i];
 768             }
 769         }
 770
 771         public void maybePut(JSONObject dump, ImportanceHistogram prev)
 772                 throws JSONException {
 773             dump.put(mPrefix, new JSONArray(mCount));
 774         }
 775
 776         @Override
 777         public String toString() {
 778             StringBuilder output = new StringBuilder();
 779             output.append(mPrefix).append(": [");
 780             for (int i = 0; i < NUM_IMPORTANCES; i++) {
 781                 output.append(mCount[i]);
 782                 if (i < (NUM_IMPORTANCES-1)) {
 783                     output.append(", ");
 784                 }
 785             }
 786             output.append("]");
 787             return output.toString();
 788         }
 789     }
 790
 791     /**
 792      * Tracks usage of an individual notification that is currently active.
 793      */
 794     public static class SingleNotificationStats {
 795         private boolean isVisible = false;
 796         private boolean isExpanded = false;
 797         /** SystemClock.elapsedRealtime() when the notification was posted. */
 798         public long posttimeElapsedMs = -1;
 799         /** Elapsed time since the notification was posted until it was first clicked, or -1. */
 800         public long posttimeToFirstClickMs = -1;
 801         /** Elpased time since the notification was posted until it was dismissed by the user. */
 802         public long posttimeToDismissMs = -1;
 803         /** Number of times the notification has been made visible. */
 804         public long airtimeCount = 0;
 805         /** Time in ms between the notification was posted and first shown; -1 if never shown. */
 806         public long posttimeToFirstAirtimeMs = -1;
 807         /**
 808          * If currently visible, SystemClock.elapsedRealtime() when the notification was made
 809          * visible; -1 otherwise.
 810          */
 811         public long currentAirtimeStartElapsedMs = -1;
 812         /** Accumulated visible time. */
 813         public long airtimeMs = 0;
 814         /**
 815          * Time in ms between the notification being posted and when it first
 816          * became visible and expanded; -1 if it was never visibly expanded.
 817          */
 818         public long posttimeToFirstVisibleExpansionMs = -1;
 819         /**
 820          * If currently visible, SystemClock.elapsedRealtime() when the notification was made
 821          * visible; -1 otherwise.
 822          */
 823         public long currentAirtimeExpandedStartElapsedMs = -1;
 824         /** Accumulated visible expanded time. */
 825         public long airtimeExpandedMs = 0;
 826         /** Number of times the notification has been expanded by the user. */
 827         public long userExpansionCount = 0;
 828         /** Importance directly requested by the app. */
 829         public int requestedImportance;
 830         /** Did the app include sound or vibration on the notificaiton. */
 831         public boolean isNoisy;
 832         /** Importance after initial filtering for noise and other features */
 833         public int naturalImportance;
 834
 835         public long getCurrentPosttimeMs() {
 836             if (posttimeElapsedMs < 0) {
 837                 return 0;
 838             }
 839             return SystemClock.elapsedRealtime() - posttimeElapsedMs;
 840         }
 841
 842         public long getCurrentAirtimeMs() {
 843             long result = airtimeMs;
 844             // Add incomplete airtime if currently shown.
 845             if (currentAirtimeStartElapsedMs >= 0) {
 846                 result += (SystemClock.elapsedRealtime() - currentAirtimeStartElapsedMs);
 847             }
 848             return result;
 849         }
 850
 851         public long getCurrentAirtimeExpandedMs() {
 852             long result = airtimeExpandedMs;
 853             // Add incomplete expanded airtime if currently shown.
 854             if (currentAirtimeExpandedStartElapsedMs >= 0) {
 855                 result += (SystemClock.elapsedRealtime() - currentAirtimeExpandedStartElapsedMs);
 856             }
 857             return result;
 858         }
 859
 860         /**
 861          * Called when the user clicked the notification.
 862          */
 863         public void onClick() {
 864             if (posttimeToFirstClickMs < 0) {
 865                 posttimeToFirstClickMs = SystemClock.elapsedRealtime() - posttimeElapsedMs;
 866             }
 867         }
 868
 869         /**
 870          * Called when the user removed the notification.
 871          */
 872         public void onDismiss() {
 873             if (posttimeToDismissMs < 0) {
 874                 posttimeToDismissMs = SystemClock.elapsedRealtime() - posttimeElapsedMs;
 875             }
 876             finish();
 877         }
 878
 879         public void onCancel() {
 880             finish();
 881         }
 882
 883         public void onRemoved() {
 884             finish();
 885         }
 886
 887         public void onVisibilityChanged(boolean visible) {
 888             long elapsedNowMs = SystemClock.elapsedRealtime();
 889             final boolean wasVisible = isVisible;
 890             isVisible = visible;
 891             if (visible) {
 892                 if (currentAirtimeStartElapsedMs < 0) {
 893                     airtimeCount++;
 894                     currentAirtimeStartElapsedMs = elapsedNowMs;
 895                 }
 896                 if (posttimeToFirstAirtimeMs < 0) {
 897                     posttimeToFirstAirtimeMs = elapsedNowMs - posttimeElapsedMs;
 898                 }
 899             } else {
 900                 if (currentAirtimeStartElapsedMs >= 0) {
 901                     airtimeMs += (elapsedNowMs - currentAirtimeStartElapsedMs);
 902                     currentAirtimeStartElapsedMs = -1;
 903                 }
 904             }
 905
 906             if (wasVisible != isVisible) {
 907                 updateVisiblyExpandedStats();
 908             }
 909         }
 910
 911         public void onExpansionChanged(boolean userAction, boolean expanded) {
 912             isExpanded = expanded;
 913             if (isExpanded && userAction) {
 914                 userExpansionCount++;
 915             }
 916             updateVisiblyExpandedStats();
 917         }
 918
 919         private void updateVisiblyExpandedStats() {
 920             long elapsedNowMs = SystemClock.elapsedRealtime();
 921             if (isExpanded && isVisible) {
 922                 // expanded and visible
 923                 if (currentAirtimeExpandedStartElapsedMs < 0) {
 924                     currentAirtimeExpandedStartElapsedMs = elapsedNowMs;
 925                 }
 926                 if (posttimeToFirstVisibleExpansionMs < 0) {
 927                     posttimeToFirstVisibleExpansionMs = elapsedNowMs - posttimeElapsedMs;
 928                 }
 929             } else {
 930                 // not-expanded or not-visible
 931                 if (currentAirtimeExpandedStartElapsedMs >= 0) {
 932                     airtimeExpandedMs += (elapsedNowMs - currentAirtimeExpandedStartElapsedMs);
 933                     currentAirtimeExpandedStartElapsedMs = -1;
 934                 }
 935             }
 936         }
 937
 938         /** The notification is leaving the system. Finalize. */
 939         public void finish() {
 940             onVisibilityChanged(false);
 941         }
 942
 943         @Override
 944         public String toString() {
 945             StringBuilder output = new StringBuilder();
 946             output.append("SingleNotificationStats{");
 947
 948             output.append("posttimeElapsedMs=").append(posttimeElapsedMs).append(", ");
 949             output.append("posttimeToFirstClickMs=").append(posttimeToFirstClickMs).append(", ");
 950             output.append("posttimeToDismissMs=").append(posttimeToDismissMs).append(", ");
 951             output.append("airtimeCount=").append(airtimeCount).append(", ");
 952             output.append("airtimeMs=").append(airtimeMs).append(", ");
 953             output.append("currentAirtimeStartElapsedMs=").append(currentAirtimeStartElapsedMs)
 954                     .append(", ");
 955             output.append("airtimeExpandedMs=").append(airtimeExpandedMs).append(", ");
 956             output.append("posttimeToFirstVisibleExpansionMs=")
 957                     .append(posttimeToFirstVisibleExpansionMs).append(", ");
 958             output.append("currentAirtimeExpandedStartElapsedMs=")
 959                     .append(currentAirtimeExpandedStartElapsedMs).append(", ");
 960             output.append("requestedImportance=").append(requestedImportance).append(", ");
 961             output.append("naturalImportance=").append(naturalImportance).append(", ");
 962             output.append("isNoisy=").append(isNoisy);
 963             output.append('}');
 964             return output.toString();
 965         }
 966
 967         /** Copy useful information out of the stats from the pre-update notifications. */
 968         public void updateFrom(SingleNotificationStats old) {
 969             posttimeElapsedMs = old.posttimeElapsedMs;
 970             posttimeToFirstClickMs = old.posttimeToFirstClickMs;
 971             airtimeCount = old.airtimeCount;
 972             posttimeToFirstAirtimeMs = old.posttimeToFirstAirtimeMs;
 973             currentAirtimeStartElapsedMs = old.currentAirtimeStartElapsedMs;
 974             airtimeMs = old.airtimeMs;
 975             posttimeToFirstVisibleExpansionMs = old.posttimeToFirstVisibleExpansionMs;
 976             currentAirtimeExpandedStartElapsedMs = old.currentAirtimeExpandedStartElapsedMs;
 977             airtimeExpandedMs = old.airtimeExpandedMs;
 978             userExpansionCount = old.userExpansionCount;
 979         }
 980     }
 981
 982     /**
 983      * Aggregates long samples to sum and averages.
 984      */
 985     public static class Aggregate {
 986         long numSamples;
 987         double avg;
 988         double sum2;
 989         double var;
 990
 991         public void addSample(long sample) {
 992             // Welford's "Method for Calculating Corrected Sums of Squares"
 993             // http://www.jstor.org/stable/1266577?seq=2
 994             numSamples++;
 995             final double n = numSamples;
 996             final double delta = sample - avg;
 997             avg += (1.0 / n) * delta;
 998             sum2 += ((n - 1) / n) * delta * delta;
 999             final double divisor = numSamples == 1 ? 1.0 : n - 1.0;
1000             var = sum2 / divisor;
1001         }
1002
1003         @Override
1004         public String toString() {
1005             return "Aggregate{" +
1006                     "numSamples=" + numSamples +
1007                     ", avg=" + avg +
1008                     ", var=" + var +
1009                     '}';
1010         }
1011     }
1012
1013     private static class SQLiteLog {
1014         private static final String TAG = "NotificationSQLiteLog";
1015
1016         // Message types passed to the background handler.
1017         private static final int MSG_POST = 1;
1018         private static final int MSG_CLICK = 2;
1019         private static final int MSG_REMOVE = 3;
1020         private static final int MSG_DISMISS = 4;
1021
1022         private static final String DB_NAME = "notification_log.db";
1023         private static final int DB_VERSION = 5;
1024
1025         /** Age in ms after which events are pruned from the DB. */
1026         private static final long HORIZON_MS = 7 * 24 * 60 * 60 * 1000L;  // 1 week
1027         /** Delay between pruning the DB. Used to throttle pruning. */
1028         private static final long PRUNE_MIN_DELAY_MS = 6 * 60 * 60 * 1000L;  // 6 hours
1029         /** Mininum number of writes between pruning the DB. Used to throttle pruning. */
1030         private static final long PRUNE_MIN_WRITES = 1024;
1031
1032         // Table 'log'
1033         private static final String TAB_LOG = "log";
1034         private static final String COL_EVENT_USER_ID = "event_user_id";
1035         private static final String COL_EVENT_TYPE = "event_type";
1036         private static final String COL_EVENT_TIME = "event_time_ms";
1037         private static final String COL_KEY = "key";
1038         private static final String COL_PKG = "pkg";
1039         private static final String COL_NOTIFICATION_ID = "nid";
1040         private static final String COL_TAG = "tag";
1041         private static final String COL_WHEN_MS = "when_ms";
1042         private static final String COL_DEFAULTS = "defaults";
1043         private static final String COL_FLAGS = "flags";
1044         private static final String COL_IMPORTANCE_REQ = "importance_request";
1045         private static final String COL_IMPORTANCE_FINAL = "importance_final";
1046         private static final String COL_NOISY = "noisy";
1047         private static final String COL_MUTED = "muted";
1048         private static final String COL_DEMOTED = "demoted";
1049         private static final String COL_CATEGORY = "category";
1050         private static final String COL_ACTION_COUNT = "action_count";
1051         private static final String COL_POSTTIME_MS = "posttime_ms";
1052         private static final String COL_AIRTIME_MS = "airtime_ms";
1053         private static final String COL_FIRST_EXPANSIONTIME_MS = "first_expansion_time_ms";
1054         private static final String COL_AIRTIME_EXPANDED_MS = "expansion_airtime_ms";
1055         private static final String COL_EXPAND_COUNT = "expansion_count";
1056
1057
1058         private static final int EVENT_TYPE_POST = 1;
1059         private static final int EVENT_TYPE_CLICK = 2;
1060         private static final int EVENT_TYPE_REMOVE = 3;
1061         private static final int EVENT_TYPE_DISMISS = 4;
1062
1063         private static final int IDLE_CONNECTION_TIMEOUT_MS = 30000;
1064
1065         private static long sLastPruneMs;
1066
1067         private static long sNumWrites;
1068         private final SQLiteOpenHelper mHelper;
1069
1070         private final Handler mWriteHandler;
1071         private static final long DAY_MS = 24 * 60 * 60 * 1000;
1072         private static final String STATS_QUERY = "SELECT " +
1073                 COL_EVENT_USER_ID + ", " +
1074                 COL_PKG + ", " +
1075                 // Bucket by day by looking at 'floor((midnight - eventTimeMs) / dayMs)'
1076                 "CAST(((%d - " + COL_EVENT_TIME + ") / " + DAY_MS + ") AS int) " +
1077                 "AS day, " +
1078                 "COUNT(*) AS cnt, " +
1079                 "SUM(" + COL_MUTED + ") as muted, " +
1080                 "SUM(" + COL_NOISY + ") as noisy, " +
1081                 "SUM(" + COL_DEMOTED + ") as demoted " +
1082                 "FROM " + TAB_LOG + " " +
1083                 "WHERE " +
1084                 COL_EVENT_TYPE + "=" + EVENT_TYPE_POST +
1085                 " AND " + COL_EVENT_TIME + " > %d " +
1086                 " GROUP BY " + COL_EVENT_USER_ID + ", day, " + COL_PKG;
1087
1088         public SQLiteLog(Context context) {
1089             HandlerThread backgroundThread = new HandlerThread("notification-sqlite-log",
1090                     android.os.Process.THREAD_PRIORITY_BACKGROUND);
1091             backgroundThread.start();
1092             mWriteHandler = new Handler(backgroundThread.getLooper()) {
1093                 @Override
1094                 public void handleMessage(Message msg) {
1095                     NotificationRecord r = (NotificationRecord) msg.obj;
1096                     long nowMs = System.currentTimeMillis();
1097                     switch (msg.what) {
1098                         case MSG_POST:
1099                             writeEvent(r.sbn.getPostTime(), EVENT_TYPE_POST, r);
1100                             break;
1101                         case MSG_CLICK:
1102                             writeEvent(nowMs, EVENT_TYPE_CLICK, r);
1103                             break;
1104                         case MSG_REMOVE:
1105                             writeEvent(nowMs, EVENT_TYPE_REMOVE, r);
1106                             break;
1107                         case MSG_DISMISS:
1108                             writeEvent(nowMs, EVENT_TYPE_DISMISS, r);
1109                             break;
1110                         default:
1111                             Log.wtf(TAG, "Unknown message type: " + msg.what);
1112                             break;
1113                     }
1114                 }
1115             };
1116             mHelper = new SQLiteOpenHelper(context, DB_NAME, null, DB_VERSION) {
1117                 @Override
1118                 public void onCreate(SQLiteDatabase db) {
1119                     db.execSQL("CREATE TABLE " + TAB_LOG + " (" +
1120                             "_id INTEGER PRIMARY KEY AUTOINCREMENT," +
1121                             COL_EVENT_USER_ID + " INT," +
1122                             COL_EVENT_TYPE + " INT," +
1123                             COL_EVENT_TIME + " INT," +
1124                             COL_KEY + " TEXT," +
1125                             COL_PKG + " TEXT," +
1126                             COL_NOTIFICATION_ID + " INT," +
1127                             COL_TAG + " TEXT," +
1128                             COL_WHEN_MS + " INT," +
1129                             COL_DEFAULTS + " INT," +
1130                             COL_FLAGS + " INT," +
1131                             COL_IMPORTANCE_REQ + " INT," +
1132                             COL_IMPORTANCE_FINAL + " INT," +
1133                             COL_NOISY + " INT," +
1134                             COL_MUTED + " INT," +
1135                             COL_DEMOTED + " INT," +
1136                             COL_CATEGORY + " TEXT," +
1137                             COL_ACTION_COUNT + " INT," +
1138                             COL_POSTTIME_MS + " INT," +
1139                             COL_AIRTIME_MS + " INT," +
1140                             COL_FIRST_EXPANSIONTIME_MS + " INT," +
1141                             COL_AIRTIME_EXPANDED_MS + " INT," +
1142                             COL_EXPAND_COUNT + " INT" +
1143                             ")");
1144                 }
1145
1146                 @Override
1147                 public void onConfigure(SQLiteDatabase db) {
1148                     // Memory optimization - close idle connections after 30s of inactivity
1149                     setIdleConnectionTimeout(IDLE_CONNECTION_TIMEOUT_MS);
1150                 }
1151
1152                 @Override
1153                 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
1154                     if (oldVersion != newVersion) {
1155                         db.execSQL("DROP TABLE IF EXISTS " + TAB_LOG);
1156                         onCreate(db);
1157                     }
1158                 }
1159             };
1160         }
1161
1162         public void logPosted(NotificationRecord notification) {
1163             mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_POST, notification));
1164         }
1165
1166         public void logClicked(NotificationRecord notification) {
1167             mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_CLICK, notification));
1168         }
1169
1170         public void logRemoved(NotificationRecord notification) {
1171             mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_REMOVE, notification));
1172         }
1173
1174         public void logDismissed(NotificationRecord notification) {
1175             mWriteHandler.sendMessage(mWriteHandler.obtainMessage(MSG_DISMISS, notification));
1176         }
1177
1178         private JSONArray jsonPostFrequencies(DumpFilter filter) throws JSONException {
1179             JSONArray frequencies = new JSONArray();
1180             SQLiteDatabase db = mHelper.getReadableDatabase();
1181             long midnight = getMidnightMs();
1182             String q = String.format(STATS_QUERY, midnight, filter.since);
1183             Cursor cursor = db.rawQuery(q, null);
1184             try {
1185                 for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
1186                     int userId = cursor.getInt(0);
1187                     String pkg = cursor.getString(1);
1188                     if (filter != null && !filter.matches(pkg)) continue;
1189                     int day = cursor.getInt(2);
1190                     int count = cursor.getInt(3);
1191                     int muted = cursor.getInt(4);
1192                     int noisy = cursor.getInt(5);
1193                     int demoted = cursor.getInt(6);
1194                     JSONObject row = new JSONObject();
1195                     row.put("user_id", userId);
1196                     row.put("package", pkg);
1197                     row.put("day", day);
1198                     row.put("count", count);
1199                     row.put("noisy", noisy);
1200                     row.put("muted", muted);
1201                     row.put("demoted", demoted);
1202                     frequencies.put(row);
1203                 }
1204             } finally {
1205                 cursor.close();
1206             }
1207             return frequencies;
1208         }
1209
1210         public void printPostFrequencies(PrintWriter pw, String indent, DumpFilter filter) {
1211             SQLiteDatabase db = mHelper.getReadableDatabase();
1212             long midnight = getMidnightMs();
1213             String q = String.format(STATS_QUERY, midnight, filter.since);
1214             Cursor cursor = db.rawQuery(q, null);
1215             try {
1216                 for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
1217                     int userId = cursor.getInt(0);
1218                     String pkg = cursor.getString(1);
1219                     if (filter != null && !filter.matches(pkg)) continue;
1220                     int day = cursor.getInt(2);
1221                     int count = cursor.getInt(3);
1222                     int muted = cursor.getInt(4);
1223                     int noisy = cursor.getInt(5);
1224                     int demoted = cursor.getInt(6);
1225                     pw.println(indent + "post_frequency{user_id=" + userId + ",pkg=" + pkg +
1226                             ",day=" + day + ",count=" + count + ",muted=" + muted + "/" + noisy +
1227                             ",demoted=" + demoted + "}");
1228                 }
1229             } finally {
1230                 cursor.close();
1231             }
1232         }
1233
1234         private long getMidnightMs() {
1235             GregorianCalendar midnight = new GregorianCalendar();
1236             midnight.set(midnight.get(Calendar.YEAR), midnight.get(Calendar.MONTH),
1237                     midnight.get(Calendar.DATE), 23, 59, 59);
1238             return midnight.getTimeInMillis();
1239         }
1240
1241         private void writeEvent(long eventTimeMs, int eventType, NotificationRecord r) {
1242             ContentValues cv = new ContentValues();
1243             cv.put(COL_EVENT_USER_ID, r.sbn.getUser().getIdentifier());
1244             cv.put(COL_EVENT_TIME, eventTimeMs);
1245             cv.put(COL_EVENT_TYPE, eventType);
1246             putNotificationIdentifiers(r, cv);
1247             if (eventType == EVENT_TYPE_POST) {
1248                 putNotificationDetails(r, cv);
1249             } else {
1250                 putPosttimeVisibility(r, cv);
1251             }
1252             SQLiteDatabase db = mHelper.getWritableDatabase();
1253             if (db.insert(TAB_LOG, null, cv) < 0) {
1254                 Log.wtf(TAG, "Error while trying to insert values: " + cv);
1255             }
1256             sNumWrites++;
1257             pruneIfNecessary(db);
1258         }
1259
1260         private void pruneIfNecessary(SQLiteDatabase db) {
1261             // Prune if we haven't in a while.
1262             long nowMs = System.currentTimeMillis();
1263             if (sNumWrites > PRUNE_MIN_WRITES ||
1264                     nowMs - sLastPruneMs > PRUNE_MIN_DELAY_MS) {
1265                 sNumWrites = 0;
1266                 sLastPruneMs = nowMs;
1267                 long horizonStartMs = nowMs - HORIZON_MS;
1268                 int deletedRows = db.delete(TAB_LOG, COL_EVENT_TIME + " < ?",
1269                         new String[] { String.valueOf(horizonStartMs) });
1270                 Log.d(TAG, "Pruned event entries: " + deletedRows);
1271             }
1272         }
1273
1274         private static void putNotificationIdentifiers(NotificationRecord r, ContentValues outCv) {
1275             outCv.put(COL_KEY, r.sbn.getKey());
1276             outCv.put(COL_PKG, r.sbn.getPackageName());
1277         }
1278
1279         private static void putNotificationDetails(NotificationRecord r, ContentValues outCv) {
1280             outCv.put(COL_NOTIFICATION_ID, r.sbn.getId());
1281             if (r.sbn.getTag() != null) {
1282                 outCv.put(COL_TAG, r.sbn.getTag());
1283             }
1284             outCv.put(COL_WHEN_MS, r.sbn.getPostTime());
1285             outCv.put(COL_FLAGS, r.getNotification().flags);
1286             final int before = r.stats.requestedImportance;
1287             final int after = r.getImportance();
1288             final boolean noisy = r.stats.isNoisy;
1289             outCv.put(COL_IMPORTANCE_REQ, before);
1290             outCv.put(COL_IMPORTANCE_FINAL, after);
1291             outCv.put(COL_DEMOTED, after < before ? 1 : 0);
1292             outCv.put(COL_NOISY, noisy);
1293             if (noisy && after < IMPORTANCE_HIGH) {
1294                 outCv.put(COL_MUTED, 1);
1295             } else {
1296                 outCv.put(COL_MUTED, 0);
1297             }
1298             if (r.getNotification().category != null) {
1299                 outCv.put(COL_CATEGORY, r.getNotification().category);
1300             }
1301             outCv.put(COL_ACTION_COUNT, r.getNotification().actions != null ?
1302                     r.getNotification().actions.length : 0);
1303         }
1304
1305         private static void putPosttimeVisibility(NotificationRecord r, ContentValues outCv) {
1306             outCv.put(COL_POSTTIME_MS, r.stats.getCurrentPosttimeMs());
1307             outCv.put(COL_AIRTIME_MS, r.stats.getCurrentAirtimeMs());
1308             outCv.put(COL_EXPAND_COUNT, r.stats.userExpansionCount);
1309             outCv.put(COL_AIRTIME_EXPANDED_MS, r.stats.getCurrentAirtimeExpandedMs());
1310             outCv.put(COL_FIRST_EXPANSIONTIME_MS, r.stats.posttimeToFirstVisibleExpansionMs);
1311         }
1312
1313         public void dump(PrintWriter pw, String indent, DumpFilter filter) {
1314             printPostFrequencies(pw, indent, filter);
1315         }
1316
1317         public JSONObject dumpJson(DumpFilter filter) {
1318             JSONObject dump = new JSONObject();
1319             try {
1320                 dump.put("post_frequency", jsonPostFrequencies(filter));
1321                 dump.put("since", filter.since);
1322                 dump.put("now", System.currentTimeMillis());
1323             } catch (JSONException e) {
1324                 // pass
1325             }
1326             return dump;
1327         }
1328     }
1329 }