BatteryStats.java revision a029ea131836725b050e1a7550aa171b68171522 
1/*
2 * Copyright (C) 2008 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
17package android.os;
18
19import java.io.PrintWriter;
20import java.util.ArrayList;
21import java.util.Collections;
22import java.util.Comparator;
23import java.util.Formatter;
24import java.util.List;
25import java.util.Map;
26
27import android.content.pm.ApplicationInfo;
28import android.telephony.SignalStrength;
29import android.util.Log;
30import android.util.Printer;
31import android.util.Slog;
32import android.util.SparseArray;
33import android.util.TimeUtils;
34
35/**
36 * A class providing access to battery usage statistics, including information on
37 * wakelocks, processes, packages, and services.  All times are represented in microseconds
38 * except where indicated otherwise.
39 * @hide
40 */
41public abstract class BatteryStats implements Parcelable {
42
43    private static final boolean LOCAL_LOGV = false;
44
45    /** @hide */
46    public static final String SERVICE_NAME = "batterystats";
47
48    /**
49     * A constant indicating a partial wake lock timer.
50     */
51    public static final int WAKE_TYPE_PARTIAL = 0;
52
53    /**
54     * A constant indicating a full wake lock timer.
55     */
56    public static final int WAKE_TYPE_FULL = 1;
57
58    /**
59     * A constant indicating a window wake lock timer.
60     */
61    public static final int WAKE_TYPE_WINDOW = 2;
62
63    /**
64     * A constant indicating a sensor timer.
65     */
66    public static final int SENSOR = 3;
67
68    /**
69     * A constant indicating a a wifi running timer
70     */
71    public static final int WIFI_RUNNING = 4;
72
73    /**
74     * A constant indicating a full wifi lock timer
75     */
76    public static final int FULL_WIFI_LOCK = 5;
77
78    /**
79     * A constant indicating a wifi scan
80     */
81    public static final int WIFI_SCAN = 6;
82
83     /**
84      * A constant indicating a wifi multicast timer
85      */
86     public static final int WIFI_MULTICAST_ENABLED = 7;
87
88    /**
89     * A constant indicating an audio turn on timer
90     */
91    public static final int AUDIO_TURNED_ON = 7;
92
93    /**
94     * A constant indicating a video turn on timer
95     */
96    public static final int VIDEO_TURNED_ON = 8;
97
98    /**
99     * A constant indicating a vibrator on timer
100     */
101    public static final int VIBRATOR_ON = 9;
102
103    /**
104     * A constant indicating a foreground activity timer
105     */
106    public static final int FOREGROUND_ACTIVITY = 10;
107
108    /**
109     * A constant indicating a wifi batched scan is active
110     */
111    public static final int WIFI_BATCHED_SCAN = 11;
112
113    /**
114     * Include all of the data in the stats, including previously saved data.
115     */
116    public static final int STATS_SINCE_CHARGED = 0;
117
118    /**
119     * Include only the last run in the stats.
120     */
121    public static final int STATS_LAST = 1;
122
123    /**
124     * Include only the current run in the stats.
125     */
126    public static final int STATS_CURRENT = 2;
127
128    /**
129     * Include only the run since the last time the device was unplugged in the stats.
130     */
131    public static final int STATS_SINCE_UNPLUGGED = 3;
132
133    // NOTE: Update this list if you add/change any stats above.
134    // These characters are supposed to represent "total", "last", "current",
135    // and "unplugged". They were shortened for efficiency sake.
136    private static final String[] STAT_NAMES = { "t", "l", "c", "u" };
137
138    /**
139     * Bump the version on this if the checkin format changes.
140     */
141    private static final int BATTERY_STATS_CHECKIN_VERSION = 7;
142
143    private static final long BYTES_PER_KB = 1024;
144    private static final long BYTES_PER_MB = 1048576; // 1024^2
145    private static final long BYTES_PER_GB = 1073741824; //1024^3
146
147
148    private static final String UID_DATA = "uid";
149    private static final String APK_DATA = "apk";
150    private static final String PROCESS_DATA = "pr";
151    private static final String SENSOR_DATA = "sr";
152    private static final String VIBRATOR_DATA = "vib";
153    private static final String FOREGROUND_DATA = "fg";
154    private static final String WAKELOCK_DATA = "wl";
155    private static final String KERNEL_WAKELOCK_DATA = "kwl";
156    private static final String NETWORK_DATA = "nt";
157    private static final String USER_ACTIVITY_DATA = "ua";
158    private static final String BATTERY_DATA = "bt";
159    private static final String BATTERY_DISCHARGE_DATA = "dc";
160    private static final String BATTERY_LEVEL_DATA = "lv";
161    private static final String WIFI_DATA = "wfl";
162    private static final String MISC_DATA = "m";
163    private static final String HISTORY_DATA = "h";
164    private static final String SCREEN_BRIGHTNESS_DATA = "br";
165    private static final String SIGNAL_STRENGTH_TIME_DATA = "sgt";
166    private static final String SIGNAL_SCANNING_TIME_DATA = "sst";
167    private static final String SIGNAL_STRENGTH_COUNT_DATA = "sgc";
168    private static final String DATA_CONNECTION_TIME_DATA = "dct";
169    private static final String DATA_CONNECTION_COUNT_DATA = "dcc";
170
171    private final StringBuilder mFormatBuilder = new StringBuilder(32);
172    private final Formatter mFormatter = new Formatter(mFormatBuilder);
173
174    /**
175     * State for keeping track of counting information.
176     */
177    public static abstract class Counter {
178
179        /**
180         * Returns the count associated with this Counter for the
181         * selected type of statistics.
182         *
183         * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT
184         */
185        public abstract int getCountLocked(int which);
186
187        /**
188         * Temporary for debugging.
189         */
190        public abstract void logState(Printer pw, String prefix);
191    }
192
193    /**
194     * State for keeping track of timing information.
195     */
196    public static abstract class Timer {
197
198        /**
199         * Returns the count associated with this Timer for the
200         * selected type of statistics.
201         *
202         * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT
203         */
204        public abstract int getCountLocked(int which);
205
206        /**
207         * Returns the total time in microseconds associated with this Timer for the
208         * selected type of statistics.
209         *
210         * @param batteryRealtime system realtime on  battery in microseconds
211         * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT
212         * @return a time in microseconds
213         */
214        public abstract long getTotalTimeLocked(long batteryRealtime, int which);
215
216        /**
217         * Temporary for debugging.
218         */
219        public abstract void logState(Printer pw, String prefix);
220    }
221
222    /**
223     * The statistics associated with a particular uid.
224     */
225    public static abstract class Uid {
226
227        /**
228         * Returns a mapping containing wakelock statistics.
229         *
230         * @return a Map from Strings to Uid.Wakelock objects.
231         */
232        public abstract Map<String, ? extends Wakelock> getWakelockStats();
233
234        /**
235         * The statistics associated with a particular wake lock.
236         */
237        public static abstract class Wakelock {
238            public abstract Timer getWakeTime(int type);
239        }
240
241        /**
242         * Returns a mapping containing sensor statistics.
243         *
244         * @return a Map from Integer sensor ids to Uid.Sensor objects.
245         */
246        public abstract Map<Integer, ? extends Sensor> getSensorStats();
247
248        /**
249         * Returns a mapping containing active process data.
250         */
251        public abstract SparseArray<? extends Pid> getPidStats();
252
253        /**
254         * Returns a mapping containing process statistics.
255         *
256         * @return a Map from Strings to Uid.Proc objects.
257         */
258        public abstract Map<String, ? extends Proc> getProcessStats();
259
260        /**
261         * Returns a mapping containing package statistics.
262         *
263         * @return a Map from Strings to Uid.Pkg objects.
264         */
265        public abstract Map<String, ? extends Pkg> getPackageStats();
266
267        /**
268         * {@hide}
269         */
270        public abstract int getUid();
271
272        public abstract void noteWifiRunningLocked();
273        public abstract void noteWifiStoppedLocked();
274        public abstract void noteFullWifiLockAcquiredLocked();
275        public abstract void noteFullWifiLockReleasedLocked();
276        public abstract void noteWifiScanStartedLocked();
277        public abstract void noteWifiScanStoppedLocked();
278        public abstract void noteWifiBatchedScanStartedLocked(int csph);
279        public abstract void noteWifiBatchedScanStoppedLocked();
280        public abstract void noteWifiMulticastEnabledLocked();
281        public abstract void noteWifiMulticastDisabledLocked();
282        public abstract void noteAudioTurnedOnLocked();
283        public abstract void noteAudioTurnedOffLocked();
284        public abstract void noteVideoTurnedOnLocked();
285        public abstract void noteVideoTurnedOffLocked();
286        public abstract void noteActivityResumedLocked();
287        public abstract void noteActivityPausedLocked();
288        public abstract long getWifiRunningTime(long batteryRealtime, int which);
289        public abstract long getFullWifiLockTime(long batteryRealtime, int which);
290        public abstract long getWifiScanTime(long batteryRealtime, int which);
291        public abstract long getWifiBatchedScanTime(int csphBin, long batteryRealtime, int which);
292        public abstract long getWifiMulticastTime(long batteryRealtime,
293                                                  int which);
294        public abstract long getAudioTurnedOnTime(long batteryRealtime, int which);
295        public abstract long getVideoTurnedOnTime(long batteryRealtime, int which);
296        public abstract Timer getForegroundActivityTimer();
297        public abstract Timer getVibratorOnTimer();
298
299        public static final int NUM_WIFI_BATCHED_SCAN_BINS = 5;
300
301        /**
302         * Note that these must match the constants in android.os.PowerManager.
303         * Also, if the user activity types change, the BatteryStatsImpl.VERSION must
304         * also be bumped.
305         */
306        static final String[] USER_ACTIVITY_TYPES = {
307            "other", "button", "touch"
308        };
309
310        public static final int NUM_USER_ACTIVITY_TYPES = 3;
311
312        public abstract void noteUserActivityLocked(int type);
313        public abstract boolean hasUserActivity();
314        public abstract int getUserActivityCount(int type, int which);
315
316        public abstract boolean hasNetworkActivity();
317        public abstract long getNetworkActivityCount(int type, int which);
318
319        public static abstract class Sensor {
320            /*
321             * FIXME: it's not correct to use this magic value because it
322             * could clash with a sensor handle (which are defined by
323             * the sensor HAL, and therefore out of our control
324             */
325            // Magic sensor number for the GPS.
326            public static final int GPS = -10000;
327
328            public abstract int getHandle();
329
330            public abstract Timer getSensorTime();
331        }
332
333        public class Pid {
334            public long mWakeSum;
335            public long mWakeStart;
336        }
337
338        /**
339         * The statistics associated with a particular process.
340         */
341        public static abstract class Proc {
342
343            public static class ExcessivePower {
344                public static final int TYPE_WAKE = 1;
345                public static final int TYPE_CPU = 2;
346
347                public int type;
348                public long overTime;
349                public long usedTime;
350            }
351
352            /**
353             * Returns the total time (in 1/100 sec) spent executing in user code.
354             *
355             * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
356             */
357            public abstract long getUserTime(int which);
358
359            /**
360             * Returns the total time (in 1/100 sec) spent executing in system code.
361             *
362             * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
363             */
364            public abstract long getSystemTime(int which);
365
366            /**
367             * Returns the number of times the process has been started.
368             *
369             * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
370             */
371            public abstract int getStarts(int which);
372
373            /**
374             * Returns the cpu time spent in microseconds while the process was in the foreground.
375             * @param which one of STATS_TOTAL, STATS_LAST, STATS_CURRENT or STATS_UNPLUGGED
376             * @return foreground cpu time in microseconds
377             */
378            public abstract long getForegroundTime(int which);
379
380            /**
381             * Returns the approximate cpu time spent in microseconds, at a certain CPU speed.
382             * @param speedStep the index of the CPU speed. This is not the actual speed of the
383             * CPU.
384             * @param which one of STATS_TOTAL, STATS_LAST, STATS_CURRENT or STATS_UNPLUGGED
385             * @see BatteryStats#getCpuSpeedSteps()
386             */
387            public abstract long getTimeAtCpuSpeedStep(int speedStep, int which);
388
389            public abstract int countExcessivePowers();
390
391            public abstract ExcessivePower getExcessivePower(int i);
392        }
393
394        /**
395         * The statistics associated with a particular package.
396         */
397        public static abstract class Pkg {
398
399            /**
400             * Returns the number of times this package has done something that could wake up the
401             * device from sleep.
402             *
403             * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
404             */
405            public abstract int getWakeups(int which);
406
407            /**
408             * Returns a mapping containing service statistics.
409             */
410            public abstract Map<String, ? extends Serv> getServiceStats();
411
412            /**
413             * The statistics associated with a particular service.
414             */
415            public abstract class Serv {
416
417                /**
418                 * Returns the amount of time spent started.
419                 *
420                 * @param batteryUptime elapsed uptime on battery in microseconds.
421                 * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
422                 * @return
423                 */
424                public abstract long getStartTime(long batteryUptime, int which);
425
426                /**
427                 * Returns the total number of times startService() has been called.
428                 *
429                 * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
430                 */
431                public abstract int getStarts(int which);
432
433                /**
434                 * Returns the total number times the service has been launched.
435                 *
436                 * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
437                 */
438                public abstract int getLaunches(int which);
439            }
440        }
441    }
442
443    public final static class HistoryItem implements Parcelable {
444        static final String TAG = "HistoryItem";
445        static final boolean DEBUG = false;
446
447        public HistoryItem next;
448
449        public long time;
450
451        public static final byte CMD_NULL = 0;
452        public static final byte CMD_UPDATE = 1;
453        public static final byte CMD_START = 2;
454        public static final byte CMD_OVERFLOW = 3;
455
456        public byte cmd = CMD_NULL;
457
458        public byte batteryLevel;
459        public byte batteryStatus;
460        public byte batteryHealth;
461        public byte batteryPlugType;
462
463        public char batteryTemperature;
464        public char batteryVoltage;
465
466        // Constants from SCREEN_BRIGHTNESS_*
467        public static final int STATE_BRIGHTNESS_MASK = 0x0000000f;
468        public static final int STATE_BRIGHTNESS_SHIFT = 0;
469        // Constants from SIGNAL_STRENGTH_*
470        public static final int STATE_SIGNAL_STRENGTH_MASK = 0x000000f0;
471        public static final int STATE_SIGNAL_STRENGTH_SHIFT = 4;
472        // Constants from ServiceState.STATE_*
473        public static final int STATE_PHONE_STATE_MASK = 0x00000f00;
474        public static final int STATE_PHONE_STATE_SHIFT = 8;
475        // Constants from DATA_CONNECTION_*
476        public static final int STATE_DATA_CONNECTION_MASK = 0x0000f000;
477        public static final int STATE_DATA_CONNECTION_SHIFT = 12;
478
479        // These states always appear directly in the first int token
480        // of a delta change; they should be ones that change relatively
481        // frequently.
482        public static final int STATE_WAKE_LOCK_FLAG = 1<<30;
483        public static final int STATE_SENSOR_ON_FLAG = 1<<29;
484        public static final int STATE_GPS_ON_FLAG = 1<<28;
485        public static final int STATE_PHONE_SCANNING_FLAG = 1<<27;
486        public static final int STATE_WIFI_RUNNING_FLAG = 1<<26;
487        public static final int STATE_WIFI_FULL_LOCK_FLAG = 1<<25;
488        public static final int STATE_WIFI_SCAN_FLAG = 1<<24;
489        public static final int STATE_WIFI_MULTICAST_ON_FLAG = 1<<23;
490        // These are on the lower bits used for the command; if they change
491        // we need to write another int of data.
492        public static final int STATE_AUDIO_ON_FLAG = 1<<22;
493        public static final int STATE_VIDEO_ON_FLAG = 1<<21;
494        public static final int STATE_SCREEN_ON_FLAG = 1<<20;
495        public static final int STATE_BATTERY_PLUGGED_FLAG = 1<<19;
496        public static final int STATE_PHONE_IN_CALL_FLAG = 1<<18;
497        public static final int STATE_WIFI_ON_FLAG = 1<<17;
498        public static final int STATE_BLUETOOTH_ON_FLAG = 1<<16;
499
500        public static final int MOST_INTERESTING_STATES =
501            STATE_BATTERY_PLUGGED_FLAG | STATE_SCREEN_ON_FLAG
502            | STATE_GPS_ON_FLAG | STATE_PHONE_IN_CALL_FLAG;
503
504        public int states;
505
506        public HistoryItem() {
507        }
508
509        public HistoryItem(long time, Parcel src) {
510            this.time = time;
511            readFromParcel(src);
512        }
513
514        public int describeContents() {
515            return 0;
516        }
517
518        public void writeToParcel(Parcel dest, int flags) {
519            dest.writeLong(time);
520            int bat = (((int)cmd)&0xff)
521                    | ((((int)batteryLevel)<<8)&0xff00)
522                    | ((((int)batteryStatus)<<16)&0xf0000)
523                    | ((((int)batteryHealth)<<20)&0xf00000)
524                    | ((((int)batteryPlugType)<<24)&0xf000000);
525            dest.writeInt(bat);
526            bat = (((int)batteryTemperature)&0xffff)
527                    | ((((int)batteryVoltage)<<16)&0xffff0000);
528            dest.writeInt(bat);
529            dest.writeInt(states);
530        }
531
532        private void readFromParcel(Parcel src) {
533            int bat = src.readInt();
534            cmd = (byte)(bat&0xff);
535            batteryLevel = (byte)((bat>>8)&0xff);
536            batteryStatus = (byte)((bat>>16)&0xf);
537            batteryHealth = (byte)((bat>>20)&0xf);
538            batteryPlugType = (byte)((bat>>24)&0xf);
539            bat = src.readInt();
540            batteryTemperature = (char)(bat&0xffff);
541            batteryVoltage = (char)((bat>>16)&0xffff);
542            states = src.readInt();
543        }
544
545        // Part of initial delta int that specifies the time delta.
546        static final int DELTA_TIME_MASK = 0x3ffff;
547        static final int DELTA_TIME_ABS = 0x3fffd;    // Following is an entire abs update.
548        static final int DELTA_TIME_INT = 0x3fffe;    // The delta is a following int
549        static final int DELTA_TIME_LONG = 0x3ffff;   // The delta is a following long
550        // Part of initial delta int holding the command code.
551        static final int DELTA_CMD_MASK = 0x3;
552        static final int DELTA_CMD_SHIFT = 18;
553        // Flag in delta int: a new battery level int follows.
554        static final int DELTA_BATTERY_LEVEL_FLAG = 1<<20;
555        // Flag in delta int: a new full state and battery status int follows.
556        static final int DELTA_STATE_FLAG = 1<<21;
557        static final int DELTA_STATE_MASK = 0xffc00000;
558
559        public void writeDelta(Parcel dest, HistoryItem last) {
560            if (last == null || last.cmd != CMD_UPDATE) {
561                dest.writeInt(DELTA_TIME_ABS);
562                writeToParcel(dest, 0);
563                return;
564            }
565
566            final long deltaTime = time - last.time;
567            final int lastBatteryLevelInt = last.buildBatteryLevelInt();
568            final int lastStateInt = last.buildStateInt();
569
570            int deltaTimeToken;
571            if (deltaTime < 0 || deltaTime > Integer.MAX_VALUE) {
572                deltaTimeToken = DELTA_TIME_LONG;
573            } else if (deltaTime >= DELTA_TIME_ABS) {
574                deltaTimeToken = DELTA_TIME_INT;
575            } else {
576                deltaTimeToken = (int)deltaTime;
577            }
578            int firstToken = deltaTimeToken
579                    | (cmd<<DELTA_CMD_SHIFT)
580                    | (states&DELTA_STATE_MASK);
581            final int batteryLevelInt = buildBatteryLevelInt();
582            final boolean batteryLevelIntChanged = batteryLevelInt != lastBatteryLevelInt;
583            if (batteryLevelIntChanged) {
584                firstToken |= DELTA_BATTERY_LEVEL_FLAG;
585            }
586            final int stateInt = buildStateInt();
587            final boolean stateIntChanged = stateInt != lastStateInt;
588            if (stateIntChanged) {
589                firstToken |= DELTA_STATE_FLAG;
590            }
591            dest.writeInt(firstToken);
592            if (DEBUG) Slog.i(TAG, "WRITE DELTA: firstToken=0x" + Integer.toHexString(firstToken)
593                    + " deltaTime=" + deltaTime);
594
595            if (deltaTimeToken >= DELTA_TIME_INT) {
596                if (deltaTimeToken == DELTA_TIME_INT) {
597                    if (DEBUG) Slog.i(TAG, "WRITE DELTA: int deltaTime=" + (int)deltaTime);
598                    dest.writeInt((int)deltaTime);
599                } else {
600                    if (DEBUG) Slog.i(TAG, "WRITE DELTA: long deltaTime=" + deltaTime);
601                    dest.writeLong(deltaTime);
602                }
603            }
604            if (batteryLevelIntChanged) {
605                dest.writeInt(batteryLevelInt);
606                if (DEBUG) Slog.i(TAG, "WRITE DELTA: batteryToken=0x"
607                        + Integer.toHexString(batteryLevelInt)
608                        + " batteryLevel=" + batteryLevel
609                        + " batteryTemp=" + (int)batteryTemperature
610                        + " batteryVolt=" + (int)batteryVoltage);
611            }
612            if (stateIntChanged) {
613                dest.writeInt(stateInt);
614                if (DEBUG) Slog.i(TAG, "WRITE DELTA: stateToken=0x"
615                        + Integer.toHexString(stateInt)
616                        + " batteryStatus=" + batteryStatus
617                        + " batteryHealth=" + batteryHealth
618                        + " batteryPlugType=" + batteryPlugType
619                        + " states=0x" + Integer.toHexString(states));
620            }
621        }
622
623        private int buildBatteryLevelInt() {
624            return ((((int)batteryLevel)<<24)&0xff000000)
625                    | ((((int)batteryTemperature)<<14)&0x00ffc000)
626                    | (((int)batteryVoltage)&0x00003fff);
627        }
628
629        private int buildStateInt() {
630            return ((((int)batteryStatus)<<28)&0xf0000000)
631                    | ((((int)batteryHealth)<<24)&0x0f000000)
632                    | ((((int)batteryPlugType)<<22)&0x00c00000)
633                    | (states&(~DELTA_STATE_MASK));
634        }
635
636        public void readDelta(Parcel src) {
637            int firstToken = src.readInt();
638            int deltaTimeToken = firstToken&DELTA_TIME_MASK;
639            cmd = (byte)((firstToken>>DELTA_CMD_SHIFT)&DELTA_CMD_MASK);
640            if (DEBUG) Slog.i(TAG, "READ DELTA: firstToken=0x" + Integer.toHexString(firstToken)
641                    + " deltaTimeToken=" + deltaTimeToken);
642
643            if (deltaTimeToken < DELTA_TIME_ABS) {
644                time += deltaTimeToken;
645            } else if (deltaTimeToken == DELTA_TIME_ABS) {
646                time = src.readLong();
647                readFromParcel(src);
648                return;
649            } else if (deltaTimeToken == DELTA_TIME_INT) {
650                int delta = src.readInt();
651                time += delta;
652                if (DEBUG) Slog.i(TAG, "READ DELTA: time delta=" + delta + " new time=" + time);
653            } else {
654                long delta = src.readLong();
655                if (DEBUG) Slog.i(TAG, "READ DELTA: time delta=" + delta + " new time=" + time);
656                time += delta;
657            }
658
659            if ((firstToken&DELTA_BATTERY_LEVEL_FLAG) != 0) {
660                int batteryLevelInt = src.readInt();
661                batteryLevel = (byte)((batteryLevelInt>>24)&0xff);
662                batteryTemperature = (char)((batteryLevelInt>>14)&0x3ff);
663                batteryVoltage = (char)(batteryLevelInt&0x3fff);
664                if (DEBUG) Slog.i(TAG, "READ DELTA: batteryToken=0x"
665                        + Integer.toHexString(batteryLevelInt)
666                        + " batteryLevel=" + batteryLevel
667                        + " batteryTemp=" + (int)batteryTemperature
668                        + " batteryVolt=" + (int)batteryVoltage);
669            }
670
671            if ((firstToken&DELTA_STATE_FLAG) != 0) {
672                int stateInt = src.readInt();
673                states = (firstToken&DELTA_STATE_MASK) | (stateInt&(~DELTA_STATE_MASK));
674                batteryStatus = (byte)((stateInt>>28)&0xf);
675                batteryHealth = (byte)((stateInt>>24)&0xf);
676                batteryPlugType = (byte)((stateInt>>22)&0x3);
677                if (DEBUG) Slog.i(TAG, "READ DELTA: stateToken=0x"
678                        + Integer.toHexString(stateInt)
679                        + " batteryStatus=" + batteryStatus
680                        + " batteryHealth=" + batteryHealth
681                        + " batteryPlugType=" + batteryPlugType
682                        + " states=0x" + Integer.toHexString(states));
683            } else {
684                states = (firstToken&DELTA_STATE_MASK) | (states&(~DELTA_STATE_MASK));
685            }
686        }
687
688        public void clear() {
689            time = 0;
690            cmd = CMD_NULL;
691            batteryLevel = 0;
692            batteryStatus = 0;
693            batteryHealth = 0;
694            batteryPlugType = 0;
695            batteryTemperature = 0;
696            batteryVoltage = 0;
697            states = 0;
698        }
699
700        public void setTo(HistoryItem o) {
701            time = o.time;
702            cmd = o.cmd;
703            batteryLevel = o.batteryLevel;
704            batteryStatus = o.batteryStatus;
705            batteryHealth = o.batteryHealth;
706            batteryPlugType = o.batteryPlugType;
707            batteryTemperature = o.batteryTemperature;
708            batteryVoltage = o.batteryVoltage;
709            states = o.states;
710        }
711
712        public void setTo(long time, byte cmd, HistoryItem o) {
713            this.time = time;
714            this.cmd = cmd;
715            batteryLevel = o.batteryLevel;
716            batteryStatus = o.batteryStatus;
717            batteryHealth = o.batteryHealth;
718            batteryPlugType = o.batteryPlugType;
719            batteryTemperature = o.batteryTemperature;
720            batteryVoltage = o.batteryVoltage;
721            states = o.states;
722        }
723
724        public boolean same(HistoryItem o) {
725            return batteryLevel == o.batteryLevel
726                    && batteryStatus == o.batteryStatus
727                    && batteryHealth == o.batteryHealth
728                    && batteryPlugType == o.batteryPlugType
729                    && batteryTemperature == o.batteryTemperature
730                    && batteryVoltage == o.batteryVoltage
731                    && states == o.states;
732        }
733    }
734
735    public static final class BitDescription {
736        public final int mask;
737        public final int shift;
738        public final String name;
739        public final String[] values;
740
741        public BitDescription(int mask, String name) {
742            this.mask = mask;
743            this.shift = -1;
744            this.name = name;
745            this.values = null;
746        }
747
748        public BitDescription(int mask, int shift, String name, String[] values) {
749            this.mask = mask;
750            this.shift = shift;
751            this.name = name;
752            this.values = values;
753        }
754    }
755
756    public abstract boolean startIteratingHistoryLocked();
757
758    public abstract boolean getNextHistoryLocked(HistoryItem out);
759
760    public abstract void finishIteratingHistoryLocked();
761
762    public abstract boolean startIteratingOldHistoryLocked();
763
764    public abstract boolean getNextOldHistoryLocked(HistoryItem out);
765
766    public abstract void finishIteratingOldHistoryLocked();
767
768    /**
769     * Return the base time offset for the battery history.
770     */
771    public abstract long getHistoryBaseTime();
772
773    /**
774     * Returns the number of times the device has been started.
775     */
776    public abstract int getStartCount();
777
778    /**
779     * Returns the time in microseconds that the screen has been on while the device was
780     * running on battery.
781     *
782     * {@hide}
783     */
784    public abstract long getScreenOnTime(long batteryRealtime, int which);
785
786    public static final int SCREEN_BRIGHTNESS_DARK = 0;
787    public static final int SCREEN_BRIGHTNESS_DIM = 1;
788    public static final int SCREEN_BRIGHTNESS_MEDIUM = 2;
789    public static final int SCREEN_BRIGHTNESS_LIGHT = 3;
790    public static final int SCREEN_BRIGHTNESS_BRIGHT = 4;
791
792    static final String[] SCREEN_BRIGHTNESS_NAMES = {
793        "dark", "dim", "medium", "light", "bright"
794    };
795
796    public static final int NUM_SCREEN_BRIGHTNESS_BINS = 5;
797
798    /**
799     * Returns the time in microseconds that the screen has been on with
800     * the given brightness
801     *
802     * {@hide}
803     */
804    public abstract long getScreenBrightnessTime(int brightnessBin,
805            long batteryRealtime, int which);
806
807    public abstract int getInputEventCount(int which);
808
809    /**
810     * Returns the time in microseconds that the phone has been on while the device was
811     * running on battery.
812     *
813     * {@hide}
814     */
815    public abstract long getPhoneOnTime(long batteryRealtime, int which);
816
817    /**
818     * Returns the time in microseconds that the phone has been running with
819     * the given signal strength.
820     *
821     * {@hide}
822     */
823    public abstract long getPhoneSignalStrengthTime(int strengthBin,
824            long batteryRealtime, int which);
825
826    /**
827     * Returns the time in microseconds that the phone has been trying to
828     * acquire a signal.
829     *
830     * {@hide}
831     */
832    public abstract long getPhoneSignalScanningTime(
833            long batteryRealtime, int which);
834
835    /**
836     * Returns the number of times the phone has entered the given signal strength.
837     *
838     * {@hide}
839     */
840    public abstract int getPhoneSignalStrengthCount(int strengthBin, int which);
841
842    public static final int DATA_CONNECTION_NONE = 0;
843    public static final int DATA_CONNECTION_GPRS = 1;
844    public static final int DATA_CONNECTION_EDGE = 2;
845    public static final int DATA_CONNECTION_UMTS = 3;
846    public static final int DATA_CONNECTION_CDMA = 4;
847    public static final int DATA_CONNECTION_EVDO_0 = 5;
848    public static final int DATA_CONNECTION_EVDO_A = 6;
849    public static final int DATA_CONNECTION_1xRTT = 7;
850    public static final int DATA_CONNECTION_HSDPA = 8;
851    public static final int DATA_CONNECTION_HSUPA = 9;
852    public static final int DATA_CONNECTION_HSPA = 10;
853    public static final int DATA_CONNECTION_IDEN = 11;
854    public static final int DATA_CONNECTION_EVDO_B = 12;
855    public static final int DATA_CONNECTION_LTE = 13;
856    public static final int DATA_CONNECTION_EHRPD = 14;
857    public static final int DATA_CONNECTION_HSPAP = 15;
858    public static final int DATA_CONNECTION_OTHER = 16;
859
860    static final String[] DATA_CONNECTION_NAMES = {
861        "none", "gprs", "edge", "umts", "cdma", "evdo_0", "evdo_A",
862        "1xrtt", "hsdpa", "hsupa", "hspa", "iden", "evdo_b", "lte",
863        "ehrpd", "hspap", "other"
864    };
865
866    public static final int NUM_DATA_CONNECTION_TYPES = DATA_CONNECTION_OTHER+1;
867
868    /**
869     * Returns the time in microseconds that the phone has been running with
870     * the given data connection.
871     *
872     * {@hide}
873     */
874    public abstract long getPhoneDataConnectionTime(int dataType,
875            long batteryRealtime, int which);
876
877    /**
878     * Returns the number of times the phone has entered the given data
879     * connection type.
880     *
881     * {@hide}
882     */
883    public abstract int getPhoneDataConnectionCount(int dataType, int which);
884
885    public static final BitDescription[] HISTORY_STATE_DESCRIPTIONS
886            = new BitDescription[] {
887        new BitDescription(HistoryItem.STATE_BATTERY_PLUGGED_FLAG, "plugged"),
888        new BitDescription(HistoryItem.STATE_SCREEN_ON_FLAG, "screen"),
889        new BitDescription(HistoryItem.STATE_GPS_ON_FLAG, "gps"),
890        new BitDescription(HistoryItem.STATE_PHONE_IN_CALL_FLAG, "phone_in_call"),
891        new BitDescription(HistoryItem.STATE_PHONE_SCANNING_FLAG, "phone_scanning"),
892        new BitDescription(HistoryItem.STATE_WIFI_ON_FLAG, "wifi"),
893        new BitDescription(HistoryItem.STATE_WIFI_RUNNING_FLAG, "wifi_running"),
894        new BitDescription(HistoryItem.STATE_WIFI_FULL_LOCK_FLAG, "wifi_full_lock"),
895        new BitDescription(HistoryItem.STATE_WIFI_SCAN_FLAG, "wifi_scan"),
896        new BitDescription(HistoryItem.STATE_WIFI_MULTICAST_ON_FLAG, "wifi_multicast"),
897        new BitDescription(HistoryItem.STATE_BLUETOOTH_ON_FLAG, "bluetooth"),
898        new BitDescription(HistoryItem.STATE_AUDIO_ON_FLAG, "audio"),
899        new BitDescription(HistoryItem.STATE_VIDEO_ON_FLAG, "video"),
900        new BitDescription(HistoryItem.STATE_WAKE_LOCK_FLAG, "wake_lock"),
901        new BitDescription(HistoryItem.STATE_SENSOR_ON_FLAG, "sensor"),
902        new BitDescription(HistoryItem.STATE_BRIGHTNESS_MASK,
903                HistoryItem.STATE_BRIGHTNESS_SHIFT, "brightness",
904                SCREEN_BRIGHTNESS_NAMES),
905        new BitDescription(HistoryItem.STATE_SIGNAL_STRENGTH_MASK,
906                HistoryItem.STATE_SIGNAL_STRENGTH_SHIFT, "signal_strength",
907                SignalStrength.SIGNAL_STRENGTH_NAMES),
908        new BitDescription(HistoryItem.STATE_PHONE_STATE_MASK,
909                HistoryItem.STATE_PHONE_STATE_SHIFT, "phone_state",
910                new String[] {"in", "out", "emergency", "off"}),
911        new BitDescription(HistoryItem.STATE_DATA_CONNECTION_MASK,
912                HistoryItem.STATE_DATA_CONNECTION_SHIFT, "data_conn",
913                DATA_CONNECTION_NAMES),
914    };
915
916    /**
917     * Returns the time in microseconds that wifi has been on while the device was
918     * running on battery.
919     *
920     * {@hide}
921     */
922    public abstract long getWifiOnTime(long batteryRealtime, int which);
923
924    /**
925     * Returns the time in microseconds that wifi has been on and the driver has
926     * been in the running state while the device was running on battery.
927     *
928     * {@hide}
929     */
930    public abstract long getGlobalWifiRunningTime(long batteryRealtime, int which);
931
932    /**
933     * Returns the time in microseconds that bluetooth has been on while the device was
934     * running on battery.
935     *
936     * {@hide}
937     */
938    public abstract long getBluetoothOnTime(long batteryRealtime, int which);
939
940    public static final int NETWORK_MOBILE_RX_BYTES = 0;
941    public static final int NETWORK_MOBILE_TX_BYTES = 1;
942    public static final int NETWORK_WIFI_RX_BYTES = 2;
943    public static final int NETWORK_WIFI_TX_BYTES = 3;
944
945    public static final int NUM_NETWORK_ACTIVITY_TYPES = NETWORK_WIFI_TX_BYTES + 1;
946
947    public abstract long getNetworkActivityCount(int type, int which);
948
949    /**
950     * Return whether we are currently running on battery.
951     */
952    public abstract boolean getIsOnBattery();
953
954    /**
955     * Returns a SparseArray containing the statistics for each uid.
956     */
957    public abstract SparseArray<? extends Uid> getUidStats();
958
959    /**
960     * Returns the current battery uptime in microseconds.
961     *
962     * @param curTime the amount of elapsed realtime in microseconds.
963     */
964    public abstract long getBatteryUptime(long curTime);
965
966    /**
967     * @deprecated use getRadioDataUptime
968     */
969    public long getRadioDataUptimeMs() {
970        return getRadioDataUptime() / 1000;
971    }
972
973    /**
974     * Returns the time that the radio was on for data transfers.
975     * @return the uptime in microseconds while unplugged
976     */
977    public abstract long getRadioDataUptime();
978
979    /**
980     * Returns the current battery realtime in microseconds.
981     *
982     * @param curTime the amount of elapsed realtime in microseconds.
983     */
984    public abstract long getBatteryRealtime(long curTime);
985
986    /**
987     * Returns the battery percentage level at the last time the device was unplugged from power, or
988     * the last time it booted on battery power.
989     */
990    public abstract int getDischargeStartLevel();
991
992    /**
993     * Returns the current battery percentage level if we are in a discharge cycle, otherwise
994     * returns the level at the last plug event.
995     */
996    public abstract int getDischargeCurrentLevel();
997
998    /**
999     * Get the amount the battery has discharged since the stats were
1000     * last reset after charging, as a lower-end approximation.
1001     */
1002    public abstract int getLowDischargeAmountSinceCharge();
1003
1004    /**
1005     * Get the amount the battery has discharged since the stats were
1006     * last reset after charging, as an upper-end approximation.
1007     */
1008    public abstract int getHighDischargeAmountSinceCharge();
1009
1010    /**
1011     * Get the amount the battery has discharged while the screen was on,
1012     * since the last time power was unplugged.
1013     */
1014    public abstract int getDischargeAmountScreenOn();
1015
1016    /**
1017     * Get the amount the battery has discharged while the screen was on,
1018     * since the last time the device was charged.
1019     */
1020    public abstract int getDischargeAmountScreenOnSinceCharge();
1021
1022    /**
1023     * Get the amount the battery has discharged while the screen was off,
1024     * since the last time power was unplugged.
1025     */
1026    public abstract int getDischargeAmountScreenOff();
1027
1028    /**
1029     * Get the amount the battery has discharged while the screen was off,
1030     * since the last time the device was charged.
1031     */
1032    public abstract int getDischargeAmountScreenOffSinceCharge();
1033
1034    /**
1035     * Returns the total, last, or current battery uptime in microseconds.
1036     *
1037     * @param curTime the elapsed realtime in microseconds.
1038     * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
1039     */
1040    public abstract long computeBatteryUptime(long curTime, int which);
1041
1042    /**
1043     * Returns the total, last, or current battery realtime in microseconds.
1044     *
1045     * @param curTime the current elapsed realtime in microseconds.
1046     * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
1047     */
1048    public abstract long computeBatteryRealtime(long curTime, int which);
1049
1050    /**
1051     * Returns the total, last, or current uptime in microseconds.
1052     *
1053     * @param curTime the current elapsed realtime in microseconds.
1054     * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
1055     */
1056    public abstract long computeUptime(long curTime, int which);
1057
1058    /**
1059     * Returns the total, last, or current realtime in microseconds.
1060     * *
1061     * @param curTime the current elapsed realtime in microseconds.
1062     * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
1063     */
1064    public abstract long computeRealtime(long curTime, int which);
1065
1066    public abstract Map<String, ? extends Timer> getKernelWakelockStats();
1067
1068    /** Returns the number of different speeds that the CPU can run at */
1069    public abstract int getCpuSpeedSteps();
1070
1071    private final static void formatTimeRaw(StringBuilder out, long seconds) {
1072        long days = seconds / (60 * 60 * 24);
1073        if (days != 0) {
1074            out.append(days);
1075            out.append("d ");
1076        }
1077        long used = days * 60 * 60 * 24;
1078
1079        long hours = (seconds - used) / (60 * 60);
1080        if (hours != 0 || used != 0) {
1081            out.append(hours);
1082            out.append("h ");
1083        }
1084        used += hours * 60 * 60;
1085
1086        long mins = (seconds-used) / 60;
1087        if (mins != 0 || used != 0) {
1088            out.append(mins);
1089            out.append("m ");
1090        }
1091        used += mins * 60;
1092
1093        if (seconds != 0 || used != 0) {
1094            out.append(seconds-used);
1095            out.append("s ");
1096        }
1097    }
1098
1099    private final static void formatTime(StringBuilder sb, long time) {
1100        long sec = time / 100;
1101        formatTimeRaw(sb, sec);
1102        sb.append((time - (sec * 100)) * 10);
1103        sb.append("ms ");
1104    }
1105
1106    private final static void formatTimeMs(StringBuilder sb, long time) {
1107        long sec = time / 1000;
1108        formatTimeRaw(sb, sec);
1109        sb.append(time - (sec * 1000));
1110        sb.append("ms ");
1111    }
1112
1113    private final String formatRatioLocked(long num, long den) {
1114        if (den == 0L) {
1115            return "---%";
1116        }
1117        float perc = ((float)num) / ((float)den) * 100;
1118        mFormatBuilder.setLength(0);
1119        mFormatter.format("%.1f%%", perc);
1120        return mFormatBuilder.toString();
1121    }
1122
1123    private final String formatBytesLocked(long bytes) {
1124        mFormatBuilder.setLength(0);
1125
1126        if (bytes < BYTES_PER_KB) {
1127            return bytes + "B";
1128        } else if (bytes < BYTES_PER_MB) {
1129            mFormatter.format("%.2fKB", bytes / (double) BYTES_PER_KB);
1130            return mFormatBuilder.toString();
1131        } else if (bytes < BYTES_PER_GB){
1132            mFormatter.format("%.2fMB", bytes / (double) BYTES_PER_MB);
1133            return mFormatBuilder.toString();
1134        } else {
1135            mFormatter.format("%.2fGB", bytes / (double) BYTES_PER_GB);
1136            return mFormatBuilder.toString();
1137        }
1138    }
1139
1140    private static long computeWakeLock(Timer timer, long batteryRealtime, int which) {
1141        if (timer != null) {
1142            // Convert from microseconds to milliseconds with rounding
1143            long totalTimeMicros = timer.getTotalTimeLocked(batteryRealtime, which);
1144            long totalTimeMillis = (totalTimeMicros + 500) / 1000;
1145            return totalTimeMillis;
1146        }
1147        return 0;
1148    }
1149
1150    /**
1151     *
1152     * @param sb a StringBuilder object.
1153     * @param timer a Timer object contining the wakelock times.
1154     * @param batteryRealtime the current on-battery time in microseconds.
1155     * @param name the name of the wakelock.
1156     * @param which which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
1157     * @param linePrefix a String to be prepended to each line of output.
1158     * @return the line prefix
1159     */
1160    private static final String printWakeLock(StringBuilder sb, Timer timer,
1161            long batteryRealtime, String name, int which, String linePrefix) {
1162
1163        if (timer != null) {
1164            long totalTimeMillis = computeWakeLock(timer, batteryRealtime, which);
1165
1166            int count = timer.getCountLocked(which);
1167            if (totalTimeMillis != 0) {
1168                sb.append(linePrefix);
1169                formatTimeMs(sb, totalTimeMillis);
1170                if (name != null) {
1171                    sb.append(name);
1172                    sb.append(' ');
1173                }
1174                sb.append('(');
1175                sb.append(count);
1176                sb.append(" times)");
1177                return ", ";
1178            }
1179        }
1180        return linePrefix;
1181    }
1182
1183    /**
1184     * Checkin version of wakelock printer. Prints simple comma-separated list.
1185     *
1186     * @param sb a StringBuilder object.
1187     * @param timer a Timer object contining the wakelock times.
1188     * @param now the current time in microseconds.
1189     * @param name the name of the wakelock.
1190     * @param which which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT.
1191     * @param linePrefix a String to be prepended to each line of output.
1192     * @return the line prefix
1193     */
1194    private static final String printWakeLockCheckin(StringBuilder sb, Timer timer, long now,
1195            String name, int which, String linePrefix) {
1196        long totalTimeMicros = 0;
1197        int count = 0;
1198        if (timer != null) {
1199            totalTimeMicros = timer.getTotalTimeLocked(now, which);
1200            count = timer.getCountLocked(which);
1201        }
1202        sb.append(linePrefix);
1203        sb.append((totalTimeMicros + 500) / 1000); // microseconds to milliseconds with rounding
1204        sb.append(',');
1205        sb.append(name != null ? name + "," : "");
1206        sb.append(count);
1207        return ",";
1208    }
1209
1210    /**
1211     * Dump a comma-separated line of values for terse checkin mode.
1212     *
1213     * @param pw the PageWriter to dump log to
1214     * @param category category of data (e.g. "total", "last", "unplugged", "current" )
1215     * @param type type of data (e.g. "wakelock", "sensor", "process", "apk" ,  "process", "network")
1216     * @param args type-dependent data arguments
1217     */
1218    private static final void dumpLine(PrintWriter pw, int uid, String category, String type,
1219           Object... args ) {
1220        pw.print(BATTERY_STATS_CHECKIN_VERSION); pw.print(',');
1221        pw.print(uid); pw.print(',');
1222        pw.print(category); pw.print(',');
1223        pw.print(type);
1224
1225        for (Object arg : args) {
1226            pw.print(',');
1227            pw.print(arg);
1228        }
1229        pw.println();
1230    }
1231
1232    /**
1233     * Checkin server version of dump to produce more compact, computer-readable log.
1234     *
1235     * NOTE: all times are expressed in 'ms'.
1236     */
1237    public final void dumpCheckinLocked(PrintWriter pw, int which, int reqUid) {
1238        final long rawUptime = SystemClock.uptimeMillis() * 1000;
1239        final long rawRealtime = SystemClock.elapsedRealtime() * 1000;
1240        final long batteryUptime = getBatteryUptime(rawUptime);
1241        final long batteryRealtime = getBatteryRealtime(rawRealtime);
1242        final long whichBatteryUptime = computeBatteryUptime(rawUptime, which);
1243        final long whichBatteryRealtime = computeBatteryRealtime(rawRealtime, which);
1244        final long totalRealtime = computeRealtime(rawRealtime, which);
1245        final long totalUptime = computeUptime(rawUptime, which);
1246        final long screenOnTime = getScreenOnTime(batteryRealtime, which);
1247        final long phoneOnTime = getPhoneOnTime(batteryRealtime, which);
1248        final long wifiOnTime = getWifiOnTime(batteryRealtime, which);
1249        final long wifiRunningTime = getGlobalWifiRunningTime(batteryRealtime, which);
1250        final long bluetoothOnTime = getBluetoothOnTime(batteryRealtime, which);
1251
1252        StringBuilder sb = new StringBuilder(128);
1253
1254        SparseArray<? extends Uid> uidStats = getUidStats();
1255        final int NU = uidStats.size();
1256
1257        String category = STAT_NAMES[which];
1258
1259        // Dump "battery" stat
1260        dumpLine(pw, 0 /* uid */, category, BATTERY_DATA,
1261                which == STATS_SINCE_CHARGED ? getStartCount() : "N/A",
1262                whichBatteryRealtime / 1000, whichBatteryUptime / 1000,
1263                totalRealtime / 1000, totalUptime / 1000);
1264
1265        // Calculate total network and wakelock times across all uids.
1266        long mobileRxTotal = 0;
1267        long mobileTxTotal = 0;
1268        long wifiRxTotal = 0;
1269        long wifiTxTotal = 0;
1270        long fullWakeLockTimeTotal = 0;
1271        long partialWakeLockTimeTotal = 0;
1272
1273        for (int iu = 0; iu < NU; iu++) {
1274            Uid u = uidStats.valueAt(iu);
1275            mobileRxTotal += u.getNetworkActivityCount(NETWORK_MOBILE_RX_BYTES, which);
1276            mobileTxTotal += u.getNetworkActivityCount(NETWORK_MOBILE_TX_BYTES, which);
1277            wifiRxTotal += u.getNetworkActivityCount(NETWORK_WIFI_RX_BYTES, which);
1278            wifiTxTotal += u.getNetworkActivityCount(NETWORK_WIFI_TX_BYTES, which);
1279
1280            Map<String, ? extends BatteryStats.Uid.Wakelock> wakelocks = u.getWakelockStats();
1281            if (wakelocks.size() > 0) {
1282                for (Map.Entry<String, ? extends BatteryStats.Uid.Wakelock> ent
1283                        : wakelocks.entrySet()) {
1284                    Uid.Wakelock wl = ent.getValue();
1285
1286                    Timer fullWakeTimer = wl.getWakeTime(WAKE_TYPE_FULL);
1287                    if (fullWakeTimer != null) {
1288                        fullWakeLockTimeTotal += fullWakeTimer.getTotalTimeLocked(batteryRealtime, which);
1289                    }
1290
1291                    Timer partialWakeTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL);
1292                    if (partialWakeTimer != null) {
1293                        partialWakeLockTimeTotal += partialWakeTimer.getTotalTimeLocked(
1294                            batteryRealtime, which);
1295                    }
1296                }
1297            }
1298        }
1299
1300        // Dump misc stats
1301        dumpLine(pw, 0 /* uid */, category, MISC_DATA,
1302                screenOnTime / 1000, phoneOnTime / 1000, wifiOnTime / 1000,
1303                wifiRunningTime / 1000, bluetoothOnTime / 1000,
1304                mobileRxTotal, mobileTxTotal, wifiRxTotal, wifiTxTotal,
1305                fullWakeLockTimeTotal, partialWakeLockTimeTotal,
1306                getInputEventCount(which));
1307
1308        // Dump screen brightness stats
1309        Object[] args = new Object[NUM_SCREEN_BRIGHTNESS_BINS];
1310        for (int i=0; i<NUM_SCREEN_BRIGHTNESS_BINS; i++) {
1311            args[i] = getScreenBrightnessTime(i, batteryRealtime, which) / 1000;
1312        }
1313        dumpLine(pw, 0 /* uid */, category, SCREEN_BRIGHTNESS_DATA, args);
1314
1315        // Dump signal strength stats
1316        args = new Object[SignalStrength.NUM_SIGNAL_STRENGTH_BINS];
1317        for (int i=0; i<SignalStrength.NUM_SIGNAL_STRENGTH_BINS; i++) {
1318            args[i] = getPhoneSignalStrengthTime(i, batteryRealtime, which) / 1000;
1319        }
1320        dumpLine(pw, 0 /* uid */, category, SIGNAL_STRENGTH_TIME_DATA, args);
1321        dumpLine(pw, 0 /* uid */, category, SIGNAL_SCANNING_TIME_DATA,
1322                getPhoneSignalScanningTime(batteryRealtime, which) / 1000);
1323        for (int i=0; i<SignalStrength.NUM_SIGNAL_STRENGTH_BINS; i++) {
1324            args[i] = getPhoneSignalStrengthCount(i, which);
1325        }
1326        dumpLine(pw, 0 /* uid */, category, SIGNAL_STRENGTH_COUNT_DATA, args);
1327
1328        // Dump network type stats
1329        args = new Object[NUM_DATA_CONNECTION_TYPES];
1330        for (int i=0; i<NUM_DATA_CONNECTION_TYPES; i++) {
1331            args[i] = getPhoneDataConnectionTime(i, batteryRealtime, which) / 1000;
1332        }
1333        dumpLine(pw, 0 /* uid */, category, DATA_CONNECTION_TIME_DATA, args);
1334        for (int i=0; i<NUM_DATA_CONNECTION_TYPES; i++) {
1335            args[i] = getPhoneDataConnectionCount(i, which);
1336        }
1337        dumpLine(pw, 0 /* uid */, category, DATA_CONNECTION_COUNT_DATA, args);
1338
1339        if (which == STATS_SINCE_UNPLUGGED) {
1340            dumpLine(pw, 0 /* uid */, category, BATTERY_LEVEL_DATA, getDischargeStartLevel(),
1341                    getDischargeCurrentLevel());
1342        }
1343
1344        if (which == STATS_SINCE_UNPLUGGED) {
1345            dumpLine(pw, 0 /* uid */, category, BATTERY_DISCHARGE_DATA,
1346                    getDischargeStartLevel()-getDischargeCurrentLevel(),
1347                    getDischargeStartLevel()-getDischargeCurrentLevel(),
1348                    getDischargeAmountScreenOn(), getDischargeAmountScreenOff());
1349        } else {
1350            dumpLine(pw, 0 /* uid */, category, BATTERY_DISCHARGE_DATA,
1351                    getLowDischargeAmountSinceCharge(), getHighDischargeAmountSinceCharge(),
1352                    getDischargeAmountScreenOn(), getDischargeAmountScreenOff());
1353        }
1354
1355        if (reqUid < 0) {
1356            Map<String, ? extends BatteryStats.Timer> kernelWakelocks = getKernelWakelockStats();
1357            if (kernelWakelocks.size() > 0) {
1358                for (Map.Entry<String, ? extends BatteryStats.Timer> ent : kernelWakelocks.entrySet()) {
1359                    sb.setLength(0);
1360                    printWakeLockCheckin(sb, ent.getValue(), batteryRealtime, null, which, "");
1361
1362                    dumpLine(pw, 0 /* uid */, category, KERNEL_WAKELOCK_DATA, ent.getKey(),
1363                            sb.toString());
1364                }
1365            }
1366        }
1367
1368        for (int iu = 0; iu < NU; iu++) {
1369            final int uid = uidStats.keyAt(iu);
1370            if (reqUid >= 0 && uid != reqUid) {
1371                continue;
1372            }
1373            Uid u = uidStats.valueAt(iu);
1374            // Dump Network stats per uid, if any
1375            long mobileRx = u.getNetworkActivityCount(NETWORK_MOBILE_RX_BYTES, which);
1376            long mobileTx = u.getNetworkActivityCount(NETWORK_MOBILE_TX_BYTES, which);
1377            long wifiRx = u.getNetworkActivityCount(NETWORK_WIFI_RX_BYTES, which);
1378            long wifiTx = u.getNetworkActivityCount(NETWORK_WIFI_TX_BYTES, which);
1379            long fullWifiLockOnTime = u.getFullWifiLockTime(batteryRealtime, which);
1380            long wifiScanTime = u.getWifiScanTime(batteryRealtime, which);
1381            long uidWifiRunningTime = u.getWifiRunningTime(batteryRealtime, which);
1382
1383            if (mobileRx > 0 || mobileTx > 0 || wifiRx > 0 || wifiTx > 0) {
1384                dumpLine(pw, uid, category, NETWORK_DATA, mobileRx, mobileTx, wifiRx, wifiTx);
1385            }
1386
1387            if (fullWifiLockOnTime != 0 || wifiScanTime != 0
1388                    || uidWifiRunningTime != 0) {
1389                dumpLine(pw, uid, category, WIFI_DATA,
1390                        fullWifiLockOnTime, wifiScanTime, uidWifiRunningTime);
1391            }
1392
1393            if (u.hasUserActivity()) {
1394                args = new Object[Uid.NUM_USER_ACTIVITY_TYPES];
1395                boolean hasData = false;
1396                for (int i=0; i<Uid.NUM_USER_ACTIVITY_TYPES; i++) {
1397                    int val = u.getUserActivityCount(i, which);
1398                    args[i] = val;
1399                    if (val != 0) hasData = true;
1400                }
1401                if (hasData) {
1402                    dumpLine(pw, 0 /* uid */, category, USER_ACTIVITY_DATA, args);
1403                }
1404            }
1405
1406            Map<String, ? extends BatteryStats.Uid.Wakelock> wakelocks = u.getWakelockStats();
1407            if (wakelocks.size() > 0) {
1408                for (Map.Entry<String, ? extends BatteryStats.Uid.Wakelock> ent
1409                        : wakelocks.entrySet()) {
1410                    Uid.Wakelock wl = ent.getValue();
1411                    String linePrefix = "";
1412                    sb.setLength(0);
1413                    linePrefix = printWakeLockCheckin(sb, wl.getWakeTime(WAKE_TYPE_FULL),
1414                            batteryRealtime, "f", which, linePrefix);
1415                    linePrefix = printWakeLockCheckin(sb, wl.getWakeTime(WAKE_TYPE_PARTIAL),
1416                            batteryRealtime, "p", which, linePrefix);
1417                    linePrefix = printWakeLockCheckin(sb, wl.getWakeTime(WAKE_TYPE_WINDOW),
1418                            batteryRealtime, "w", which, linePrefix);
1419
1420                    // Only log if we had at lease one wakelock...
1421                    if (sb.length() > 0) {
1422                        String name = ent.getKey();
1423                        if (name.indexOf(',') >= 0) {
1424                            name = name.replace(',', '_');
1425                        }
1426                        dumpLine(pw, uid, category, WAKELOCK_DATA, name, sb.toString());
1427                    }
1428                }
1429            }
1430
1431            Map<Integer, ? extends BatteryStats.Uid.Sensor> sensors = u.getSensorStats();
1432            if (sensors.size() > 0)  {
1433                for (Map.Entry<Integer, ? extends BatteryStats.Uid.Sensor> ent
1434                        : sensors.entrySet()) {
1435                    Uid.Sensor se = ent.getValue();
1436                    int sensorNumber = ent.getKey();
1437                    Timer timer = se.getSensorTime();
1438                    if (timer != null) {
1439                        // Convert from microseconds to milliseconds with rounding
1440                        long totalTime = (timer.getTotalTimeLocked(batteryRealtime, which) + 500) / 1000;
1441                        int count = timer.getCountLocked(which);
1442                        if (totalTime != 0) {
1443                            dumpLine(pw, uid, category, SENSOR_DATA, sensorNumber, totalTime, count);
1444                        }
1445                    }
1446                }
1447            }
1448
1449            Timer vibTimer = u.getVibratorOnTimer();
1450            if (vibTimer != null) {
1451                // Convert from microseconds to milliseconds with rounding
1452                long totalTime = (vibTimer.getTotalTimeLocked(batteryRealtime, which) + 500) / 1000;
1453                int count = vibTimer.getCountLocked(which);
1454                if (totalTime != 0) {
1455                    dumpLine(pw, uid, category, VIBRATOR_DATA, totalTime, count);
1456                }
1457            }
1458
1459            Timer fgTimer = u.getForegroundActivityTimer();
1460            if (fgTimer != null) {
1461                // Convert from microseconds to milliseconds with rounding
1462                long totalTime = (fgTimer.getTotalTimeLocked(batteryRealtime, which) + 500) / 1000;
1463                int count = fgTimer.getCountLocked(which);
1464                if (totalTime != 0) {
1465                    dumpLine(pw, uid, category, FOREGROUND_DATA, totalTime, count);
1466                }
1467            }
1468
1469            Map<String, ? extends BatteryStats.Uid.Proc> processStats = u.getProcessStats();
1470            if (processStats.size() > 0) {
1471                for (Map.Entry<String, ? extends BatteryStats.Uid.Proc> ent
1472                        : processStats.entrySet()) {
1473                    Uid.Proc ps = ent.getValue();
1474
1475                    final long userMillis = ps.getUserTime(which) * 10;
1476                    final long systemMillis = ps.getSystemTime(which) * 10;
1477                    final long foregroundMillis = ps.getForegroundTime(which) * 10;
1478                    final long starts = ps.getStarts(which);
1479
1480                    if (userMillis != 0 || systemMillis != 0 || foregroundMillis != 0
1481                            || starts != 0) {
1482                        dumpLine(pw, uid, category, PROCESS_DATA, ent.getKey(), userMillis,
1483                                systemMillis, foregroundMillis, starts);
1484                    }
1485                }
1486            }
1487
1488            Map<String, ? extends BatteryStats.Uid.Pkg> packageStats = u.getPackageStats();
1489            if (packageStats.size() > 0) {
1490                for (Map.Entry<String, ? extends BatteryStats.Uid.Pkg> ent
1491                        : packageStats.entrySet()) {
1492
1493                    Uid.Pkg ps = ent.getValue();
1494                    int wakeups = ps.getWakeups(which);
1495                    Map<String, ? extends  Uid.Pkg.Serv> serviceStats = ps.getServiceStats();
1496                    for (Map.Entry<String, ? extends BatteryStats.Uid.Pkg.Serv> sent
1497                            : serviceStats.entrySet()) {
1498                        BatteryStats.Uid.Pkg.Serv ss = sent.getValue();
1499                        long startTime = ss.getStartTime(batteryUptime, which);
1500                        int starts = ss.getStarts(which);
1501                        int launches = ss.getLaunches(which);
1502                        if (startTime != 0 || starts != 0 || launches != 0) {
1503                            dumpLine(pw, uid, category, APK_DATA,
1504                                    wakeups, // wakeup alarms
1505                                    ent.getKey(), // Apk
1506                                    sent.getKey(), // service
1507                                    startTime / 1000, // time spent started, in ms
1508                                    starts,
1509                                    launches);
1510                        }
1511                    }
1512                }
1513            }
1514        }
1515    }
1516
1517    static final class TimerEntry {
1518        final String mName;
1519        final int mId;
1520        final BatteryStats.Timer mTimer;
1521        final long mTime;
1522        TimerEntry(String name, int id, BatteryStats.Timer timer, long time) {
1523            mName = name;
1524            mId = id;
1525            mTimer = timer;
1526            mTime = time;
1527        }
1528    }
1529
1530    @SuppressWarnings("unused")
1531    public final void dumpLocked(PrintWriter pw, String prefix, final int which, int reqUid) {
1532        final long rawUptime = SystemClock.uptimeMillis() * 1000;
1533        final long rawRealtime = SystemClock.elapsedRealtime() * 1000;
1534        final long batteryUptime = getBatteryUptime(rawUptime);
1535        final long batteryRealtime = getBatteryRealtime(rawRealtime);
1536
1537        final long whichBatteryUptime = computeBatteryUptime(rawUptime, which);
1538        final long whichBatteryRealtime = computeBatteryRealtime(rawRealtime, which);
1539        final long totalRealtime = computeRealtime(rawRealtime, which);
1540        final long totalUptime = computeUptime(rawUptime, which);
1541
1542        StringBuilder sb = new StringBuilder(128);
1543
1544        SparseArray<? extends Uid> uidStats = getUidStats();
1545        final int NU = uidStats.size();
1546
1547        sb.setLength(0);
1548        sb.append(prefix);
1549                sb.append("  Time on battery: ");
1550                formatTimeMs(sb, whichBatteryRealtime / 1000); sb.append("(");
1551                sb.append(formatRatioLocked(whichBatteryRealtime, totalRealtime));
1552                sb.append(") realtime, ");
1553                formatTimeMs(sb, whichBatteryUptime / 1000);
1554                sb.append("("); sb.append(formatRatioLocked(whichBatteryUptime, totalRealtime));
1555                sb.append(") uptime");
1556        pw.println(sb.toString());
1557        sb.setLength(0);
1558        sb.append(prefix);
1559                sb.append("  Total run time: ");
1560                formatTimeMs(sb, totalRealtime / 1000);
1561                sb.append("realtime, ");
1562                formatTimeMs(sb, totalUptime / 1000);
1563                sb.append("uptime, ");
1564        pw.println(sb.toString());
1565
1566        final long screenOnTime = getScreenOnTime(batteryRealtime, which);
1567        final long phoneOnTime = getPhoneOnTime(batteryRealtime, which);
1568        final long wifiRunningTime = getGlobalWifiRunningTime(batteryRealtime, which);
1569        final long wifiOnTime = getWifiOnTime(batteryRealtime, which);
1570        final long bluetoothOnTime = getBluetoothOnTime(batteryRealtime, which);
1571        sb.setLength(0);
1572        sb.append(prefix);
1573                sb.append("  Screen on: "); formatTimeMs(sb, screenOnTime / 1000);
1574                sb.append("("); sb.append(formatRatioLocked(screenOnTime, whichBatteryRealtime));
1575                sb.append("), Input events: "); sb.append(getInputEventCount(which));
1576                sb.append(", Active phone call: "); formatTimeMs(sb, phoneOnTime / 1000);
1577                sb.append("("); sb.append(formatRatioLocked(phoneOnTime, whichBatteryRealtime));
1578                sb.append(")");
1579        pw.println(sb.toString());
1580        sb.setLength(0);
1581        sb.append(prefix);
1582        sb.append("  Screen brightnesses: ");
1583        boolean didOne = false;
1584        for (int i=0; i<NUM_SCREEN_BRIGHTNESS_BINS; i++) {
1585            final long time = getScreenBrightnessTime(i, batteryRealtime, which);
1586            if (time == 0) {
1587                continue;
1588            }
1589            if (didOne) sb.append(", ");
1590            didOne = true;
1591            sb.append(SCREEN_BRIGHTNESS_NAMES[i]);
1592            sb.append(" ");
1593            formatTimeMs(sb, time/1000);
1594            sb.append("(");
1595            sb.append(formatRatioLocked(time, screenOnTime));
1596            sb.append(")");
1597        }
1598        if (!didOne) sb.append("No activity");
1599        pw.println(sb.toString());
1600
1601        // Calculate total network and wakelock times across all uids.
1602        long mobileRxTotal = 0;
1603        long mobileTxTotal = 0;
1604        long wifiRxTotal = 0;
1605        long wifiTxTotal = 0;
1606        long fullWakeLockTimeTotalMicros = 0;
1607        long partialWakeLockTimeTotalMicros = 0;
1608
1609        final Comparator<TimerEntry> timerComparator = new Comparator<TimerEntry>() {
1610            @Override
1611            public int compare(TimerEntry lhs, TimerEntry rhs) {
1612                long lhsTime = lhs.mTime;
1613                long rhsTime = rhs.mTime;
1614                if (lhsTime < rhsTime) {
1615                    return 1;
1616                }
1617                if (lhsTime > rhsTime) {
1618                    return -1;
1619                }
1620                return 0;
1621            }
1622        };
1623
1624        if (reqUid < 0) {
1625            Map<String, ? extends BatteryStats.Timer> kernelWakelocks = getKernelWakelockStats();
1626            if (kernelWakelocks.size() > 0) {
1627                final ArrayList<TimerEntry> timers = new ArrayList<TimerEntry>();
1628                for (Map.Entry<String, ? extends BatteryStats.Timer> ent : kernelWakelocks.entrySet()) {
1629                    BatteryStats.Timer timer = ent.getValue();
1630                    long totalTimeMillis = computeWakeLock(timer, batteryRealtime, which);
1631                    if (totalTimeMillis > 0) {
1632                        timers.add(new TimerEntry(ent.getKey(), 0, timer, totalTimeMillis));
1633                    }
1634                }
1635                Collections.sort(timers, timerComparator);
1636                for (int i=0; i<timers.size(); i++) {
1637                    TimerEntry timer = timers.get(i);
1638                    String linePrefix = ": ";
1639                    sb.setLength(0);
1640                    sb.append(prefix);
1641                    sb.append("  Kernel Wake lock ");
1642                    sb.append(timer.mName);
1643                    linePrefix = printWakeLock(sb, timer.mTimer, batteryRealtime, null,
1644                            which, linePrefix);
1645                    if (!linePrefix.equals(": ")) {
1646                        sb.append(" realtime");
1647                        // Only print out wake locks that were held
1648                        pw.println(sb.toString());
1649                    }
1650                }
1651            }
1652        }
1653
1654        final ArrayList<TimerEntry> timers = new ArrayList<TimerEntry>();
1655
1656        for (int iu = 0; iu < NU; iu++) {
1657            Uid u = uidStats.valueAt(iu);
1658            mobileRxTotal += u.getNetworkActivityCount(NETWORK_MOBILE_RX_BYTES, which);
1659            mobileTxTotal += u.getNetworkActivityCount(NETWORK_MOBILE_TX_BYTES, which);
1660            wifiRxTotal += u.getNetworkActivityCount(NETWORK_WIFI_RX_BYTES, which);
1661            wifiTxTotal += u.getNetworkActivityCount(NETWORK_WIFI_TX_BYTES, which);
1662
1663            Map<String, ? extends BatteryStats.Uid.Wakelock> wakelocks = u.getWakelockStats();
1664            if (wakelocks.size() > 0) {
1665                for (Map.Entry<String, ? extends BatteryStats.Uid.Wakelock> ent
1666                        : wakelocks.entrySet()) {
1667                    Uid.Wakelock wl = ent.getValue();
1668
1669                    Timer fullWakeTimer = wl.getWakeTime(WAKE_TYPE_FULL);
1670                    if (fullWakeTimer != null) {
1671                        fullWakeLockTimeTotalMicros += fullWakeTimer.getTotalTimeLocked(
1672                                batteryRealtime, which);
1673                    }
1674
1675                    Timer partialWakeTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL);
1676                    if (partialWakeTimer != null) {
1677                        long totalTimeMicros = partialWakeTimer.getTotalTimeLocked(
1678                                batteryRealtime, which);
1679                        if (totalTimeMicros > 0) {
1680                            if (reqUid < 0) {
1681                                // Only show the ordered list of all wake
1682                                // locks if the caller is not asking for data
1683                                // about a specific uid.
1684                                timers.add(new TimerEntry(ent.getKey(), u.getUid(),
1685                                        partialWakeTimer, totalTimeMicros));
1686                            }
1687                            partialWakeLockTimeTotalMicros += totalTimeMicros;
1688                        }
1689                    }
1690                }
1691            }
1692        }
1693
1694        pw.print(prefix);
1695                pw.print("  Mobile total received: "); pw.print(formatBytesLocked(mobileRxTotal));
1696                pw.print(", Total sent: "); pw.println(formatBytesLocked(mobileTxTotal));
1697        pw.print(prefix);
1698                pw.print("  Wi-Fi total received: "); pw.print(formatBytesLocked(wifiRxTotal));
1699                pw.print(", Total sent: "); pw.println(formatBytesLocked(wifiTxTotal));
1700        sb.setLength(0);
1701        sb.append(prefix);
1702                sb.append("  Total full wakelock time: "); formatTimeMs(sb,
1703                        (fullWakeLockTimeTotalMicros + 500) / 1000);
1704                sb.append(", Total partial wakelock time: "); formatTimeMs(sb,
1705                        (partialWakeLockTimeTotalMicros + 500) / 1000);
1706        pw.println(sb.toString());
1707
1708        sb.setLength(0);
1709        sb.append(prefix);
1710        sb.append("  Signal levels: ");
1711        didOne = false;
1712        for (int i=0; i<SignalStrength.NUM_SIGNAL_STRENGTH_BINS; i++) {
1713            final long time = getPhoneSignalStrengthTime(i, batteryRealtime, which);
1714            if (time == 0) {
1715                continue;
1716            }
1717            if (didOne) sb.append(", ");
1718            didOne = true;
1719            sb.append(SignalStrength.SIGNAL_STRENGTH_NAMES[i]);
1720            sb.append(" ");
1721            formatTimeMs(sb, time/1000);
1722            sb.append("(");
1723            sb.append(formatRatioLocked(time, whichBatteryRealtime));
1724            sb.append(") ");
1725            sb.append(getPhoneSignalStrengthCount(i, which));
1726            sb.append("x");
1727        }
1728        if (!didOne) sb.append("No activity");
1729        pw.println(sb.toString());
1730
1731        sb.setLength(0);
1732        sb.append(prefix);
1733        sb.append("  Signal scanning time: ");
1734        formatTimeMs(sb, getPhoneSignalScanningTime(batteryRealtime, which) / 1000);
1735        pw.println(sb.toString());
1736
1737        sb.setLength(0);
1738        sb.append(prefix);
1739        sb.append("  Radio types: ");
1740        didOne = false;
1741        for (int i=0; i<NUM_DATA_CONNECTION_TYPES; i++) {
1742            final long time = getPhoneDataConnectionTime(i, batteryRealtime, which);
1743            if (time == 0) {
1744                continue;
1745            }
1746            if (didOne) sb.append(", ");
1747            didOne = true;
1748            sb.append(DATA_CONNECTION_NAMES[i]);
1749            sb.append(" ");
1750            formatTimeMs(sb, time/1000);
1751            sb.append("(");
1752            sb.append(formatRatioLocked(time, whichBatteryRealtime));
1753            sb.append(") ");
1754            sb.append(getPhoneDataConnectionCount(i, which));
1755            sb.append("x");
1756        }
1757        if (!didOne) sb.append("No activity");
1758        pw.println(sb.toString());
1759
1760        sb.setLength(0);
1761        sb.append(prefix);
1762        sb.append("  Radio data uptime when unplugged: ");
1763        sb.append(getRadioDataUptime() / 1000);
1764        sb.append(" ms");
1765        pw.println(sb.toString());
1766
1767        sb.setLength(0);
1768        sb.append(prefix);
1769                sb.append("  Wifi on: "); formatTimeMs(sb, wifiOnTime / 1000);
1770                sb.append("("); sb.append(formatRatioLocked(wifiOnTime, whichBatteryRealtime));
1771                sb.append("), Wifi running: "); formatTimeMs(sb, wifiRunningTime / 1000);
1772                sb.append("("); sb.append(formatRatioLocked(wifiRunningTime, whichBatteryRealtime));
1773                sb.append("), Bluetooth on: "); formatTimeMs(sb, bluetoothOnTime / 1000);
1774                sb.append("("); sb.append(formatRatioLocked(bluetoothOnTime, whichBatteryRealtime));
1775                sb.append(")");
1776        pw.println(sb.toString());
1777
1778        pw.println(" ");
1779
1780        if (which == STATS_SINCE_UNPLUGGED) {
1781            if (getIsOnBattery()) {
1782                pw.print(prefix); pw.println("  Device is currently unplugged");
1783                pw.print(prefix); pw.print("    Discharge cycle start level: ");
1784                        pw.println(getDischargeStartLevel());
1785                pw.print(prefix); pw.print("    Discharge cycle current level: ");
1786                        pw.println(getDischargeCurrentLevel());
1787            } else {
1788                pw.print(prefix); pw.println("  Device is currently plugged into power");
1789                pw.print(prefix); pw.print("    Last discharge cycle start level: ");
1790                        pw.println(getDischargeStartLevel());
1791                pw.print(prefix); pw.print("    Last discharge cycle end level: ");
1792                        pw.println(getDischargeCurrentLevel());
1793            }
1794            pw.print(prefix); pw.print("    Amount discharged while screen on: ");
1795                    pw.println(getDischargeAmountScreenOn());
1796            pw.print(prefix); pw.print("    Amount discharged while screen off: ");
1797                    pw.println(getDischargeAmountScreenOff());
1798            pw.println(" ");
1799        } else {
1800            pw.print(prefix); pw.println("  Device battery use since last full charge");
1801            pw.print(prefix); pw.print("    Amount discharged (lower bound): ");
1802                    pw.println(getLowDischargeAmountSinceCharge());
1803            pw.print(prefix); pw.print("    Amount discharged (upper bound): ");
1804                    pw.println(getHighDischargeAmountSinceCharge());
1805            pw.print(prefix); pw.print("    Amount discharged while screen on: ");
1806                    pw.println(getDischargeAmountScreenOnSinceCharge());
1807            pw.print(prefix); pw.print("    Amount discharged while screen off: ");
1808                    pw.println(getDischargeAmountScreenOffSinceCharge());
1809            pw.println();
1810        }
1811
1812        if (timers.size() > 0) {
1813            Collections.sort(timers, timerComparator);
1814            pw.print(prefix); pw.println("  All partial wake locks:");
1815            for (int i=0; i<timers.size(); i++) {
1816                TimerEntry timer = timers.get(i);
1817                sb.setLength(0);
1818                sb.append("  Wake lock ");
1819                UserHandle.formatUid(sb, timer.mId);
1820                sb.append(" ");
1821                sb.append(timer.mName);
1822                printWakeLock(sb, timer.mTimer, batteryRealtime, null, which, ": ");
1823                sb.append(" realtime");
1824                pw.println(sb.toString());
1825            }
1826            timers.clear();
1827            pw.println();
1828        }
1829
1830        for (int iu=0; iu<NU; iu++) {
1831            final int uid = uidStats.keyAt(iu);
1832            if (reqUid >= 0 && uid != reqUid && uid != Process.SYSTEM_UID) {
1833                continue;
1834            }
1835
1836            Uid u = uidStats.valueAt(iu);
1837
1838            pw.print(prefix);
1839            pw.print("  ");
1840            UserHandle.formatUid(pw, uid);
1841            pw.println(":");
1842            boolean uidActivity = false;
1843
1844            long mobileRxBytes = u.getNetworkActivityCount(NETWORK_MOBILE_RX_BYTES, which);
1845            long mobileTxBytes = u.getNetworkActivityCount(NETWORK_MOBILE_TX_BYTES, which);
1846            long wifiRxBytes = u.getNetworkActivityCount(NETWORK_WIFI_RX_BYTES, which);
1847            long wifiTxBytes = u.getNetworkActivityCount(NETWORK_WIFI_TX_BYTES, which);
1848            long fullWifiLockOnTime = u.getFullWifiLockTime(batteryRealtime, which);
1849            long wifiScanTime = u.getWifiScanTime(batteryRealtime, which);
1850            long uidWifiRunningTime = u.getWifiRunningTime(batteryRealtime, which);
1851
1852            if (mobileRxBytes > 0 || mobileTxBytes > 0) {
1853                pw.print(prefix); pw.print("    Mobile network: ");
1854                        pw.print(formatBytesLocked(mobileRxBytes)); pw.print(" received, ");
1855                        pw.print(formatBytesLocked(mobileTxBytes)); pw.println(" sent");
1856            }
1857            if (wifiRxBytes > 0 || wifiTxBytes > 0) {
1858                pw.print(prefix); pw.print("    Wi-Fi network: ");
1859                        pw.print(formatBytesLocked(wifiRxBytes)); pw.print(" received, ");
1860                        pw.print(formatBytesLocked(wifiTxBytes)); pw.println(" sent");
1861            }
1862
1863            if (u.hasUserActivity()) {
1864                boolean hasData = false;
1865                for (int i=0; i<Uid.NUM_USER_ACTIVITY_TYPES; i++) {
1866                    int val = u.getUserActivityCount(i, which);
1867                    if (val != 0) {
1868                        if (!hasData) {
1869                            sb.setLength(0);
1870                            sb.append("    User activity: ");
1871                            hasData = true;
1872                        } else {
1873                            sb.append(", ");
1874                        }
1875                        sb.append(val);
1876                        sb.append(" ");
1877                        sb.append(Uid.USER_ACTIVITY_TYPES[i]);
1878                    }
1879                }
1880                if (hasData) {
1881                    pw.println(sb.toString());
1882                }
1883            }
1884
1885            if (fullWifiLockOnTime != 0 || wifiScanTime != 0
1886                    || uidWifiRunningTime != 0) {
1887                sb.setLength(0);
1888                sb.append(prefix); sb.append("    Wifi Running: ");
1889                        formatTimeMs(sb, uidWifiRunningTime / 1000);
1890                        sb.append("("); sb.append(formatRatioLocked(uidWifiRunningTime,
1891                                whichBatteryRealtime)); sb.append(")\n");
1892                sb.append(prefix); sb.append("    Full Wifi Lock: ");
1893                        formatTimeMs(sb, fullWifiLockOnTime / 1000);
1894                        sb.append("("); sb.append(formatRatioLocked(fullWifiLockOnTime,
1895                                whichBatteryRealtime)); sb.append(")\n");
1896                sb.append(prefix); sb.append("    Wifi Scan: ");
1897                        formatTimeMs(sb, wifiScanTime / 1000);
1898                        sb.append("("); sb.append(formatRatioLocked(wifiScanTime,
1899                                whichBatteryRealtime)); sb.append(")");
1900                pw.println(sb.toString());
1901            }
1902
1903            Map<String, ? extends BatteryStats.Uid.Wakelock> wakelocks = u.getWakelockStats();
1904            if (wakelocks.size() > 0) {
1905                long totalFull = 0, totalPartial = 0, totalWindow = 0;
1906                int count = 0;
1907                for (Map.Entry<String, ? extends BatteryStats.Uid.Wakelock> ent
1908                    : wakelocks.entrySet()) {
1909                    Uid.Wakelock wl = ent.getValue();
1910                    String linePrefix = ": ";
1911                    sb.setLength(0);
1912                    sb.append(prefix);
1913                    sb.append("    Wake lock ");
1914                    sb.append(ent.getKey());
1915                    linePrefix = printWakeLock(sb, wl.getWakeTime(WAKE_TYPE_FULL), batteryRealtime,
1916                            "full", which, linePrefix);
1917                    linePrefix = printWakeLock(sb, wl.getWakeTime(WAKE_TYPE_PARTIAL), batteryRealtime,
1918                            "partial", which, linePrefix);
1919                    linePrefix = printWakeLock(sb, wl.getWakeTime(WAKE_TYPE_WINDOW), batteryRealtime,
1920                            "window", which, linePrefix);
1921                    if (!linePrefix.equals(": ")) {
1922                        sb.append(" realtime");
1923                        // Only print out wake locks that were held
1924                        pw.println(sb.toString());
1925                        uidActivity = true;
1926                        count++;
1927                    }
1928                    totalFull += computeWakeLock(wl.getWakeTime(WAKE_TYPE_FULL),
1929                            batteryRealtime, which);
1930                    totalPartial += computeWakeLock(wl.getWakeTime(WAKE_TYPE_PARTIAL),
1931                            batteryRealtime, which);
1932                    totalWindow += computeWakeLock(wl.getWakeTime(WAKE_TYPE_WINDOW),
1933                            batteryRealtime, which);
1934                }
1935                if (count > 1) {
1936                    if (totalFull != 0 || totalPartial != 0 || totalWindow != 0) {
1937                        sb.setLength(0);
1938                        sb.append(prefix);
1939                        sb.append("    TOTAL wake: ");
1940                        boolean needComma = false;
1941                        if (totalFull != 0) {
1942                            needComma = true;
1943                            formatTimeMs(sb, totalFull);
1944                            sb.append("full");
1945                        }
1946                        if (totalPartial != 0) {
1947                            if (needComma) {
1948                                sb.append(", ");
1949                            }
1950                            needComma = true;
1951                            formatTimeMs(sb, totalPartial);
1952                            sb.append("partial");
1953                        }
1954                        if (totalWindow != 0) {
1955                            if (needComma) {
1956                                sb.append(", ");
1957                            }
1958                            needComma = true;
1959                            formatTimeMs(sb, totalWindow);
1960                            sb.append("window");
1961                        }
1962                        sb.append(" realtime");
1963                        pw.println(sb.toString());
1964                    }
1965                }
1966            }
1967
1968            Map<Integer, ? extends BatteryStats.Uid.Sensor> sensors = u.getSensorStats();
1969            if (sensors.size() > 0) {
1970                for (Map.Entry<Integer, ? extends BatteryStats.Uid.Sensor> ent
1971                    : sensors.entrySet()) {
1972                    Uid.Sensor se = ent.getValue();
1973                    int sensorNumber = ent.getKey();
1974                    sb.setLength(0);
1975                    sb.append(prefix);
1976                    sb.append("    Sensor ");
1977                    int handle = se.getHandle();
1978                    if (handle == Uid.Sensor.GPS) {
1979                        sb.append("GPS");
1980                    } else {
1981                        sb.append(handle);
1982                    }
1983                    sb.append(": ");
1984
1985                    Timer timer = se.getSensorTime();
1986                    if (timer != null) {
1987                        // Convert from microseconds to milliseconds with rounding
1988                        long totalTime = (timer.getTotalTimeLocked(
1989                                batteryRealtime, which) + 500) / 1000;
1990                        int count = timer.getCountLocked(which);
1991                        //timer.logState();
1992                        if (totalTime != 0) {
1993                            formatTimeMs(sb, totalTime);
1994                            sb.append("realtime (");
1995                            sb.append(count);
1996                            sb.append(" times)");
1997                        } else {
1998                            sb.append("(not used)");
1999                        }
2000                    } else {
2001                        sb.append("(not used)");
2002                    }
2003
2004                    pw.println(sb.toString());
2005                    uidActivity = true;
2006                }
2007            }
2008
2009            Timer vibTimer = u.getVibratorOnTimer();
2010            if (vibTimer != null) {
2011                // Convert from microseconds to milliseconds with rounding
2012                long totalTime = (vibTimer.getTotalTimeLocked(
2013                        batteryRealtime, which) + 500) / 1000;
2014                int count = vibTimer.getCountLocked(which);
2015                //timer.logState();
2016                if (totalTime != 0) {
2017                    sb.setLength(0);
2018                    sb.append(prefix);
2019                    sb.append("    Vibrator: ");
2020                    formatTimeMs(sb, totalTime);
2021                    sb.append("realtime (");
2022                    sb.append(count);
2023                    sb.append(" times)");
2024                    pw.println(sb.toString());
2025                    uidActivity = true;
2026                }
2027            }
2028
2029            Timer fgTimer = u.getForegroundActivityTimer();
2030            if (fgTimer != null) {
2031                // Convert from microseconds to milliseconds with rounding
2032                long totalTime = (fgTimer.getTotalTimeLocked(batteryRealtime, which) + 500) / 1000;
2033                int count = fgTimer.getCountLocked(which);
2034                if (totalTime != 0) {
2035                    sb.setLength(0);
2036                    sb.append(prefix);
2037                    sb.append("    Foreground activities: ");
2038                    formatTimeMs(sb, totalTime);
2039                    sb.append("realtime (");
2040                    sb.append(count);
2041                    sb.append(" times)");
2042                    pw.println(sb.toString());
2043                    uidActivity = true;
2044                }
2045            }
2046
2047            Map<String, ? extends BatteryStats.Uid.Proc> processStats = u.getProcessStats();
2048            if (processStats.size() > 0) {
2049                for (Map.Entry<String, ? extends BatteryStats.Uid.Proc> ent
2050                    : processStats.entrySet()) {
2051                    Uid.Proc ps = ent.getValue();
2052                    long userTime;
2053                    long systemTime;
2054                    long foregroundTime;
2055                    int starts;
2056                    int numExcessive;
2057
2058                    userTime = ps.getUserTime(which);
2059                    systemTime = ps.getSystemTime(which);
2060                    foregroundTime = ps.getForegroundTime(which);
2061                    starts = ps.getStarts(which);
2062                    numExcessive = which == STATS_SINCE_CHARGED
2063                            ? ps.countExcessivePowers() : 0;
2064
2065                    if (userTime != 0 || systemTime != 0 || foregroundTime != 0 || starts != 0
2066                            || numExcessive != 0) {
2067                        sb.setLength(0);
2068                        sb.append(prefix); sb.append("    Proc ");
2069                                sb.append(ent.getKey()); sb.append(":\n");
2070                        sb.append(prefix); sb.append("      CPU: ");
2071                                formatTime(sb, userTime); sb.append("usr + ");
2072                                formatTime(sb, systemTime); sb.append("krn ; ");
2073                                formatTime(sb, foregroundTime); sb.append("fg");
2074                        if (starts != 0) {
2075                            sb.append("\n"); sb.append(prefix); sb.append("      ");
2076                                    sb.append(starts); sb.append(" proc starts");
2077                        }
2078                        pw.println(sb.toString());
2079                        for (int e=0; e<numExcessive; e++) {
2080                            Uid.Proc.ExcessivePower ew = ps.getExcessivePower(e);
2081                            if (ew != null) {
2082                                pw.print(prefix); pw.print("      * Killed for ");
2083                                        if (ew.type == Uid.Proc.ExcessivePower.TYPE_WAKE) {
2084                                            pw.print("wake lock");
2085                                        } else if (ew.type == Uid.Proc.ExcessivePower.TYPE_CPU) {
2086                                            pw.print("cpu");
2087                                        } else {
2088                                            pw.print("unknown");
2089                                        }
2090                                        pw.print(" use: ");
2091                                        TimeUtils.formatDuration(ew.usedTime, pw);
2092                                        pw.print(" over ");
2093                                        TimeUtils.formatDuration(ew.overTime, pw);
2094                                        if (ew.overTime != 0) {
2095                                            pw.print(" (");
2096                                            pw.print((ew.usedTime*100)/ew.overTime);
2097                                            pw.println("%)");
2098                                        }
2099                            }
2100                        }
2101                        uidActivity = true;
2102                    }
2103                }
2104            }
2105
2106            Map<String, ? extends BatteryStats.Uid.Pkg> packageStats = u.getPackageStats();
2107            if (packageStats.size() > 0) {
2108                for (Map.Entry<String, ? extends BatteryStats.Uid.Pkg> ent
2109                    : packageStats.entrySet()) {
2110                    pw.print(prefix); pw.print("    Apk "); pw.print(ent.getKey()); pw.println(":");
2111                    boolean apkActivity = false;
2112                    Uid.Pkg ps = ent.getValue();
2113                    int wakeups = ps.getWakeups(which);
2114                    if (wakeups != 0) {
2115                        pw.print(prefix); pw.print("      ");
2116                                pw.print(wakeups); pw.println(" wakeup alarms");
2117                        apkActivity = true;
2118                    }
2119                    Map<String, ? extends  Uid.Pkg.Serv> serviceStats = ps.getServiceStats();
2120                    if (serviceStats.size() > 0) {
2121                        for (Map.Entry<String, ? extends BatteryStats.Uid.Pkg.Serv> sent
2122                                : serviceStats.entrySet()) {
2123                            BatteryStats.Uid.Pkg.Serv ss = sent.getValue();
2124                            long startTime = ss.getStartTime(batteryUptime, which);
2125                            int starts = ss.getStarts(which);
2126                            int launches = ss.getLaunches(which);
2127                            if (startTime != 0 || starts != 0 || launches != 0) {
2128                                sb.setLength(0);
2129                                sb.append(prefix); sb.append("      Service ");
2130                                        sb.append(sent.getKey()); sb.append(":\n");
2131                                sb.append(prefix); sb.append("        Created for: ");
2132                                        formatTimeMs(sb, startTime / 1000);
2133                                        sb.append("uptime\n");
2134                                sb.append(prefix); sb.append("        Starts: ");
2135                                        sb.append(starts);
2136                                        sb.append(", launches: "); sb.append(launches);
2137                                pw.println(sb.toString());
2138                                apkActivity = true;
2139                            }
2140                        }
2141                    }
2142                    if (!apkActivity) {
2143                        pw.print(prefix); pw.println("      (nothing executed)");
2144                    }
2145                    uidActivity = true;
2146                }
2147            }
2148            if (!uidActivity) {
2149                pw.print(prefix); pw.println("    (nothing executed)");
2150            }
2151        }
2152    }
2153
2154    static void printBitDescriptions(PrintWriter pw, int oldval, int newval, BitDescription[] descriptions) {
2155        int diff = oldval ^ newval;
2156        if (diff == 0) return;
2157        for (int i=0; i<descriptions.length; i++) {
2158            BitDescription bd = descriptions[i];
2159            if ((diff&bd.mask) != 0) {
2160                if (bd.shift < 0) {
2161                    pw.print((newval&bd.mask) != 0 ? " +" : " -");
2162                    pw.print(bd.name);
2163                } else {
2164                    pw.print(" ");
2165                    pw.print(bd.name);
2166                    pw.print("=");
2167                    int val = (newval&bd.mask)>>bd.shift;
2168                    if (bd.values != null && val >= 0 && val < bd.values.length) {
2169                        pw.print(bd.values[val]);
2170                    } else {
2171                        pw.print(val);
2172                    }
2173                }
2174            }
2175        }
2176    }
2177
2178    public void prepareForDumpLocked() {
2179    }
2180
2181    public static class HistoryPrinter {
2182        int oldState = 0;
2183        int oldStatus = -1;
2184        int oldHealth = -1;
2185        int oldPlug = -1;
2186        int oldTemp = -1;
2187        int oldVolt = -1;
2188
2189        public void printNextItem(PrintWriter pw, HistoryItem rec, long now) {
2190            pw.print("  ");
2191            TimeUtils.formatDuration(rec.time-now, pw, TimeUtils.HUNDRED_DAY_FIELD_LEN);
2192            pw.print(" ");
2193            if (rec.cmd == HistoryItem.CMD_START) {
2194                pw.println(" START");
2195            } else if (rec.cmd == HistoryItem.CMD_OVERFLOW) {
2196                pw.println(" *OVERFLOW*");
2197            } else {
2198                if (rec.batteryLevel < 10) pw.print("00");
2199                else if (rec.batteryLevel < 100) pw.print("0");
2200                pw.print(rec.batteryLevel);
2201                pw.print(" ");
2202                if (rec.states < 0x10) pw.print("0000000");
2203                else if (rec.states < 0x100) pw.print("000000");
2204                else if (rec.states < 0x1000) pw.print("00000");
2205                else if (rec.states < 0x10000) pw.print("0000");
2206                else if (rec.states < 0x100000) pw.print("000");
2207                else if (rec.states < 0x1000000) pw.print("00");
2208                else if (rec.states < 0x10000000) pw.print("0");
2209                pw.print(Integer.toHexString(rec.states));
2210                if (oldStatus != rec.batteryStatus) {
2211                    oldStatus = rec.batteryStatus;
2212                    pw.print(" status=");
2213                    switch (oldStatus) {
2214                        case BatteryManager.BATTERY_STATUS_UNKNOWN:
2215                            pw.print("unknown");
2216                            break;
2217                        case BatteryManager.BATTERY_STATUS_CHARGING:
2218                            pw.print("charging");
2219                            break;
2220                        case BatteryManager.BATTERY_STATUS_DISCHARGING:
2221                            pw.print("discharging");
2222                            break;
2223                        case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
2224                            pw.print("not-charging");
2225                            break;
2226                        case BatteryManager.BATTERY_STATUS_FULL:
2227                            pw.print("full");
2228                            break;
2229                        default:
2230                            pw.print(oldStatus);
2231                            break;
2232                    }
2233                }
2234                if (oldHealth != rec.batteryHealth) {
2235                    oldHealth = rec.batteryHealth;
2236                    pw.print(" health=");
2237                    switch (oldHealth) {
2238                        case BatteryManager.BATTERY_HEALTH_UNKNOWN:
2239                            pw.print("unknown");
2240                            break;
2241                        case BatteryManager.BATTERY_HEALTH_GOOD:
2242                            pw.print("good");
2243                            break;
2244                        case BatteryManager.BATTERY_HEALTH_OVERHEAT:
2245                            pw.print("overheat");
2246                            break;
2247                        case BatteryManager.BATTERY_HEALTH_DEAD:
2248                            pw.print("dead");
2249                            break;
2250                        case BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:
2251                            pw.print("over-voltage");
2252                            break;
2253                        case BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:
2254                            pw.print("failure");
2255                            break;
2256                        default:
2257                            pw.print(oldHealth);
2258                            break;
2259                    }
2260                }
2261                if (oldPlug != rec.batteryPlugType) {
2262                    oldPlug = rec.batteryPlugType;
2263                    pw.print(" plug=");
2264                    switch (oldPlug) {
2265                        case 0:
2266                            pw.print("none");
2267                            break;
2268                        case BatteryManager.BATTERY_PLUGGED_AC:
2269                            pw.print("ac");
2270                            break;
2271                        case BatteryManager.BATTERY_PLUGGED_USB:
2272                            pw.print("usb");
2273                            break;
2274                        case BatteryManager.BATTERY_PLUGGED_WIRELESS:
2275                            pw.print("wireless");
2276                            break;
2277                        default:
2278                            pw.print(oldPlug);
2279                            break;
2280                    }
2281                }
2282                if (oldTemp != rec.batteryTemperature) {
2283                    oldTemp = rec.batteryTemperature;
2284                    pw.print(" temp=");
2285                    pw.print(oldTemp);
2286                }
2287                if (oldVolt != rec.batteryVoltage) {
2288                    oldVolt = rec.batteryVoltage;
2289                    pw.print(" volt=");
2290                    pw.print(oldVolt);
2291                }
2292                printBitDescriptions(pw, oldState, rec.states,
2293                        HISTORY_STATE_DESCRIPTIONS);
2294                pw.println();
2295            }
2296            oldState = rec.states;
2297        }
2298
2299        public void printNextItemCheckin(PrintWriter pw, HistoryItem rec, long now) {
2300            pw.print(rec.time-now);
2301            pw.print(",");
2302            if (rec.cmd == HistoryItem.CMD_START) {
2303                pw.print("start");
2304            } else if (rec.cmd == HistoryItem.CMD_OVERFLOW) {
2305                pw.print("overflow");
2306            } else {
2307                pw.print(rec.batteryLevel);
2308                pw.print(",");
2309                pw.print(rec.states);
2310                pw.print(",");
2311                pw.print(rec.batteryStatus);
2312                pw.print(",");
2313                pw.print(rec.batteryHealth);
2314                pw.print(",");
2315                pw.print(rec.batteryPlugType);
2316                pw.print(",");
2317                pw.print((int)rec.batteryTemperature);
2318                pw.print(",");
2319                pw.print((int)rec.batteryVoltage);
2320            }
2321        }
2322    }
2323
2324    /**
2325     * Dumps a human-readable summary of the battery statistics to the given PrintWriter.
2326     *
2327     * @param pw a Printer to receive the dump output.
2328     */
2329    @SuppressWarnings("unused")
2330    public void dumpLocked(PrintWriter pw, boolean isUnpluggedOnly, int reqUid) {
2331        prepareForDumpLocked();
2332
2333        long now = getHistoryBaseTime() + SystemClock.elapsedRealtime();
2334
2335        final HistoryItem rec = new HistoryItem();
2336        if (startIteratingHistoryLocked()) {
2337            pw.println("Battery History:");
2338            HistoryPrinter hprinter = new HistoryPrinter();
2339            while (getNextHistoryLocked(rec)) {
2340                hprinter.printNextItem(pw, rec, now);
2341            }
2342            finishIteratingHistoryLocked();
2343            pw.println("");
2344        }
2345
2346        if (startIteratingOldHistoryLocked()) {
2347            pw.println("Old battery History:");
2348            HistoryPrinter hprinter = new HistoryPrinter();
2349            while (getNextOldHistoryLocked(rec)) {
2350                hprinter.printNextItem(pw, rec, now);
2351            }
2352            finishIteratingOldHistoryLocked();
2353            pw.println("");
2354        }
2355
2356        SparseArray<? extends Uid> uidStats = getUidStats();
2357        final int NU = uidStats.size();
2358        boolean didPid = false;
2359        long nowRealtime = SystemClock.elapsedRealtime();
2360        for (int i=0; i<NU; i++) {
2361            Uid uid = uidStats.valueAt(i);
2362            SparseArray<? extends Uid.Pid> pids = uid.getPidStats();
2363            if (pids != null) {
2364                for (int j=0; j<pids.size(); j++) {
2365                    Uid.Pid pid = pids.valueAt(j);
2366                    if (!didPid) {
2367                        pw.println("Per-PID Stats:");
2368                        didPid = true;
2369                    }
2370                    long time = pid.mWakeSum + (pid.mWakeStart != 0
2371                            ? (nowRealtime - pid.mWakeStart) : 0);
2372                    pw.print("  PID "); pw.print(pids.keyAt(j));
2373                            pw.print(" wake time: ");
2374                            TimeUtils.formatDuration(time, pw);
2375                            pw.println("");
2376                }
2377            }
2378        }
2379        if (didPid) {
2380            pw.println("");
2381        }
2382
2383        if (!isUnpluggedOnly) {
2384            pw.println("Statistics since last charge:");
2385            pw.println("  System starts: " + getStartCount()
2386                    + ", currently on battery: " + getIsOnBattery());
2387            dumpLocked(pw, "", STATS_SINCE_CHARGED, reqUid);
2388            pw.println("");
2389        }
2390        pw.println("Statistics since last unplugged:");
2391        dumpLocked(pw, "", STATS_SINCE_UNPLUGGED, reqUid);
2392    }
2393
2394    @SuppressWarnings("unused")
2395    public void dumpCheckinLocked(
2396            PrintWriter pw, List<ApplicationInfo> apps, boolean isUnpluggedOnly,
2397            boolean includeHistory) {
2398        prepareForDumpLocked();
2399
2400        long now = getHistoryBaseTime() + SystemClock.elapsedRealtime();
2401
2402        if (includeHistory) {
2403            final HistoryItem rec = new HistoryItem();
2404            if (startIteratingHistoryLocked()) {
2405                HistoryPrinter hprinter = new HistoryPrinter();
2406                while (getNextHistoryLocked(rec)) {
2407                    pw.print(BATTERY_STATS_CHECKIN_VERSION); pw.print(',');
2408                    pw.print(0); pw.print(',');
2409                    pw.print(HISTORY_DATA); pw.print(',');
2410                    hprinter.printNextItemCheckin(pw, rec, now);
2411                    pw.println();
2412                }
2413                finishIteratingHistoryLocked();
2414            }
2415        }
2416
2417        if (apps != null) {
2418            SparseArray<ArrayList<String>> uids = new SparseArray<ArrayList<String>>();
2419            for (int i=0; i<apps.size(); i++) {
2420                ApplicationInfo ai = apps.get(i);
2421                ArrayList<String> pkgs = uids.get(ai.uid);
2422                if (pkgs == null) {
2423                    pkgs = new ArrayList<String>();
2424                    uids.put(ai.uid, pkgs);
2425                }
2426                pkgs.add(ai.packageName);
2427            }
2428            SparseArray<? extends Uid> uidStats = getUidStats();
2429            final int NU = uidStats.size();
2430            String[] lineArgs = new String[2];
2431            for (int i=0; i<NU; i++) {
2432                int uid = uidStats.keyAt(i);
2433                ArrayList<String> pkgs = uids.get(uid);
2434                if (pkgs != null) {
2435                    for (int j=0; j<pkgs.size(); j++) {
2436                        lineArgs[0] = Integer.toString(uid);
2437                        lineArgs[1] = pkgs.get(j);
2438                        dumpLine(pw, 0 /* uid */, "i" /* category */, UID_DATA,
2439                                (Object[])lineArgs);
2440                    }
2441                }
2442            }
2443        }
2444        if (isUnpluggedOnly) {
2445            dumpCheckinLocked(pw, STATS_SINCE_UNPLUGGED, -1);
2446        }
2447        else {
2448            dumpCheckinLocked(pw, STATS_SINCE_CHARGED, -1);
2449            dumpCheckinLocked(pw, STATS_SINCE_UNPLUGGED, -1);
2450        }
2451    }
2452}
2453