/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.os; import android.app.ActivityManager; import android.app.job.JobParameters; import android.content.Context; import android.content.pm.ApplicationInfo; import android.server.ServerProtoEnums; import android.service.batterystats.BatteryStatsServiceDumpProto; import android.telephony.SignalStrength; import android.telephony.TelephonyManager; import android.text.format.DateFormat; import android.util.ArrayMap; import android.util.LongSparseArray; import android.util.MutableBoolean; import android.util.Pair; import android.util.Printer; import android.util.SparseArray; import android.util.SparseIntArray; import android.util.TimeUtils; import android.util.proto.ProtoOutputStream; import android.view.Display; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.location.gnssmetrics.GnssMetrics; import com.android.internal.os.BatterySipper; import com.android.internal.os.BatteryStatsHelper; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Formatter; import java.util.HashMap; import java.util.List; import java.util.Map; /** * A class providing access to battery usage statistics, including information on * wakelocks, processes, packages, and services. All times are represented in microseconds * except where indicated otherwise. * @hide */ public abstract class BatteryStats implements Parcelable { private static final String TAG = "BatteryStats"; private static final boolean LOCAL_LOGV = false; /** Fetching RPM stats is too slow to do each time screen changes, so disable it. */ protected static final boolean SCREEN_OFF_RPM_STATS_ENABLED = false; /** @hide */ public static final String SERVICE_NAME = "batterystats"; /** * A constant indicating a partial wake lock timer. */ public static final int WAKE_TYPE_PARTIAL = 0; /** * A constant indicating a full wake lock timer. */ public static final int WAKE_TYPE_FULL = 1; /** * A constant indicating a window wake lock timer. */ public static final int WAKE_TYPE_WINDOW = 2; /** * A constant indicating a sensor timer. */ public static final int SENSOR = 3; /** * A constant indicating a a wifi running timer */ public static final int WIFI_RUNNING = 4; /** * A constant indicating a full wifi lock timer */ public static final int FULL_WIFI_LOCK = 5; /** * A constant indicating a wifi scan */ public static final int WIFI_SCAN = 6; /** * A constant indicating a wifi multicast timer */ public static final int WIFI_MULTICAST_ENABLED = 7; /** * A constant indicating a video turn on timer */ public static final int VIDEO_TURNED_ON = 8; /** * A constant indicating a vibrator on timer */ public static final int VIBRATOR_ON = 9; /** * A constant indicating a foreground activity timer */ public static final int FOREGROUND_ACTIVITY = 10; /** * A constant indicating a wifi batched scan is active */ public static final int WIFI_BATCHED_SCAN = 11; /** * A constant indicating a process state timer */ public static final int PROCESS_STATE = 12; /** * A constant indicating a sync timer */ public static final int SYNC = 13; /** * A constant indicating a job timer */ public static final int JOB = 14; /** * A constant indicating an audio turn on timer */ public static final int AUDIO_TURNED_ON = 15; /** * A constant indicating a flashlight turn on timer */ public static final int FLASHLIGHT_TURNED_ON = 16; /** * A constant indicating a camera turn on timer */ public static final int CAMERA_TURNED_ON = 17; /** * A constant indicating a draw wake lock timer. */ public static final int WAKE_TYPE_DRAW = 18; /** * A constant indicating a bluetooth scan timer. */ public static final int BLUETOOTH_SCAN_ON = 19; /** * A constant indicating an aggregated partial wake lock timer. */ public static final int AGGREGATED_WAKE_TYPE_PARTIAL = 20; /** * A constant indicating a bluetooth scan timer for unoptimized scans. */ public static final int BLUETOOTH_UNOPTIMIZED_SCAN_ON = 21; /** * A constant indicating a foreground service timer */ public static final int FOREGROUND_SERVICE = 22; /** * A constant indicating an aggregate wifi multicast timer */ public static final int WIFI_AGGREGATE_MULTICAST_ENABLED = 23; /** * Include all of the data in the stats, including previously saved data. */ public static final int STATS_SINCE_CHARGED = 0; /** * Include only the current run in the stats. */ public static final int STATS_CURRENT = 1; /** * Include only the run since the last time the device was unplugged in the stats. */ public static final int STATS_SINCE_UNPLUGGED = 2; // NOTE: Update this list if you add/change any stats above. // These characters are supposed to represent "total", "last", "current", // and "unplugged". They were shortened for efficiency sake. private static final String[] STAT_NAMES = { "l", "c", "u" }; /** * Current version of checkin data format. * * New in version 19: * - Wakelock data (wl) gets current and max times. * New in version 20: * - Background timers and counters for: Sensor, BluetoothScan, WifiScan, Jobs, Syncs. * New in version 21: * - Actual (not just apportioned) Wakelock time is also recorded. * - Aggregated partial wakelock time (per uid, instead of per wakelock) is recorded. * - BLE scan result count * - CPU frequency time per uid * New in version 22: * - BLE scan result background count, BLE unoptimized scan time * - Background partial wakelock time & count * New in version 23: * - Logging smeared power model values * New in version 24: * - Fixed bugs in background timers and BLE scan time * New in version 25: * - Package wakeup alarms are now on screen-off timebase * New in version 26: * - Resource power manager (rpm) states [but screenOffRpm is disabled from working properly] * New in version 27: * - Always On Display (screen doze mode) time and power * New in version 28: * - Light/Deep Doze power * - WiFi Multicast Wakelock statistics (count & duration) * New in version 29: * - Process states re-ordered. TOP_SLEEPING now below BACKGROUND. HEAVY_WEIGHT introduced. * - CPU times per UID process state * New in version 30: * - Uid.PROCESS_STATE_FOREGROUND_SERVICE only tracks * ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE. * New in version 31: * - New cellular network types. * - Deferred job metrics. */ static final int CHECKIN_VERSION = 31; /** * Old version, we hit 9 and ran out of room, need to remove. */ private static final int BATTERY_STATS_CHECKIN_VERSION = 9; private static final long BYTES_PER_KB = 1024; private static final long BYTES_PER_MB = 1048576; // 1024^2 private static final long BYTES_PER_GB = 1073741824; //1024^3 private static final String VERSION_DATA = "vers"; private static final String UID_DATA = "uid"; private static final String WAKEUP_ALARM_DATA = "wua"; private static final String APK_DATA = "apk"; private static final String PROCESS_DATA = "pr"; private static final String CPU_DATA = "cpu"; private static final String GLOBAL_CPU_FREQ_DATA = "gcf"; private static final String CPU_TIMES_AT_FREQ_DATA = "ctf"; // rpm line is: // BATTERY_STATS_CHECKIN_VERSION, uid, which, "rpm", state/voter name, total time, total count, // screen-off time, screen-off count private static final String RESOURCE_POWER_MANAGER_DATA = "rpm"; private static final String SENSOR_DATA = "sr"; private static final String VIBRATOR_DATA = "vib"; private static final String FOREGROUND_ACTIVITY_DATA = "fg"; // fgs line is: // BATTERY_STATS_CHECKIN_VERSION, uid, category, "fgs", // foreground service time, count private static final String FOREGROUND_SERVICE_DATA = "fgs"; private static final String STATE_TIME_DATA = "st"; // wl line is: // BATTERY_STATS_CHECKIN_VERSION, uid, which, "wl", name, // full totalTime, 'f', count, current duration, max duration, total duration, // partial totalTime, 'p', count, current duration, max duration, total duration, // bg partial totalTime, 'bp', count, current duration, max duration, total duration, // window totalTime, 'w', count, current duration, max duration, total duration // [Currently, full and window wakelocks have durations current = max = total = -1] private static final String WAKELOCK_DATA = "wl"; // awl line is: // BATTERY_STATS_CHECKIN_VERSION, uid, which, "awl", // cumulative partial wakelock duration, cumulative background partial wakelock duration private static final String AGGREGATED_WAKELOCK_DATA = "awl"; private static final String SYNC_DATA = "sy"; private static final String JOB_DATA = "jb"; private static final String JOB_COMPLETION_DATA = "jbc"; /** * jbd line is: * BATTERY_STATS_CHECKIN_VERSION, uid, which, "jbd", * jobsDeferredEventCount, jobsDeferredCount, totalLatencyMillis, * count at latency < 1 hr, count at latency 1 to 2 hrs, 2 to 4 hrs, 4 to 8 hrs, and past 8 hrs *

* @see #JOB_FRESHNESS_BUCKETS */ private static final String JOBS_DEFERRED_DATA = "jbd"; private static final String KERNEL_WAKELOCK_DATA = "kwl"; private static final String WAKEUP_REASON_DATA = "wr"; private static final String NETWORK_DATA = "nt"; private static final String USER_ACTIVITY_DATA = "ua"; private static final String BATTERY_DATA = "bt"; private static final String BATTERY_DISCHARGE_DATA = "dc"; private static final String BATTERY_LEVEL_DATA = "lv"; private static final String GLOBAL_WIFI_DATA = "gwfl"; private static final String WIFI_DATA = "wfl"; private static final String GLOBAL_WIFI_CONTROLLER_DATA = "gwfcd"; private static final String WIFI_CONTROLLER_DATA = "wfcd"; private static final String GLOBAL_BLUETOOTH_CONTROLLER_DATA = "gble"; private static final String BLUETOOTH_CONTROLLER_DATA = "ble"; private static final String BLUETOOTH_MISC_DATA = "blem"; private static final String MISC_DATA = "m"; private static final String GLOBAL_NETWORK_DATA = "gn"; private static final String GLOBAL_MODEM_CONTROLLER_DATA = "gmcd"; private static final String MODEM_CONTROLLER_DATA = "mcd"; private static final String HISTORY_STRING_POOL = "hsp"; private static final String HISTORY_DATA = "h"; private static final String SCREEN_BRIGHTNESS_DATA = "br"; private static final String SIGNAL_STRENGTH_TIME_DATA = "sgt"; private static final String SIGNAL_SCANNING_TIME_DATA = "sst"; private static final String SIGNAL_STRENGTH_COUNT_DATA = "sgc"; private static final String DATA_CONNECTION_TIME_DATA = "dct"; private static final String DATA_CONNECTION_COUNT_DATA = "dcc"; private static final String WIFI_STATE_TIME_DATA = "wst"; private static final String WIFI_STATE_COUNT_DATA = "wsc"; private static final String WIFI_SUPPL_STATE_TIME_DATA = "wsst"; private static final String WIFI_SUPPL_STATE_COUNT_DATA = "wssc"; private static final String WIFI_SIGNAL_STRENGTH_TIME_DATA = "wsgt"; private static final String WIFI_SIGNAL_STRENGTH_COUNT_DATA = "wsgc"; private static final String POWER_USE_SUMMARY_DATA = "pws"; private static final String POWER_USE_ITEM_DATA = "pwi"; private static final String DISCHARGE_STEP_DATA = "dsd"; private static final String CHARGE_STEP_DATA = "csd"; private static final String DISCHARGE_TIME_REMAIN_DATA = "dtr"; private static final String CHARGE_TIME_REMAIN_DATA = "ctr"; private static final String FLASHLIGHT_DATA = "fla"; private static final String CAMERA_DATA = "cam"; private static final String VIDEO_DATA = "vid"; private static final String AUDIO_DATA = "aud"; private static final String WIFI_MULTICAST_TOTAL_DATA = "wmct"; private static final String WIFI_MULTICAST_DATA = "wmc"; public static final String RESULT_RECEIVER_CONTROLLER_KEY = "controller_activity"; private final StringBuilder mFormatBuilder = new StringBuilder(32); private final Formatter mFormatter = new Formatter(mFormatBuilder); private static final String CELLULAR_CONTROLLER_NAME = "Cellular"; private static final String WIFI_CONTROLLER_NAME = "WiFi"; /** * Indicates times spent by the uid at each cpu frequency in all process states. * * Other types might include times spent in foreground, background etc. */ @VisibleForTesting public static final String UID_TIMES_TYPE_ALL = "A"; /** * These are the thresholds for bucketing last time since a job was run for an app * that just moved to ACTIVE due to a launch. So if the last time a job ran was less * than 1 hour ago, then it's reasonably fresh, 2 hours ago, not so fresh and so * on. */ public static final long[] JOB_FRESHNESS_BUCKETS = { 1 * 60 * 60 * 1000L, 2 * 60 * 60 * 1000L, 4 * 60 * 60 * 1000L, 8 * 60 * 60 * 1000L, Long.MAX_VALUE }; /** * State for keeping track of counting information. */ public static abstract class Counter { /** * Returns the count associated with this Counter for the * selected type of statistics. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT */ public abstract int getCountLocked(int which); /** * Temporary for debugging. */ public abstract void logState(Printer pw, String prefix); } /** * State for keeping track of long counting information. */ public static abstract class LongCounter { /** * Returns the count associated with this Counter for the * selected type of statistics. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT */ public abstract long getCountLocked(int which); /** * Temporary for debugging. */ public abstract void logState(Printer pw, String prefix); } /** * State for keeping track of array of long counting information. */ public static abstract class LongCounterArray { /** * Returns the counts associated with this Counter for the * selected type of statistics. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT */ public abstract long[] getCountsLocked(int which); /** * Temporary for debugging. */ public abstract void logState(Printer pw, String prefix); } /** * Container class that aggregates counters for transmit, receive, and idle state of a * radio controller. */ public static abstract class ControllerActivityCounter { /** * @return a non-null {@link LongCounter} representing time spent (milliseconds) in the * idle state. */ public abstract LongCounter getIdleTimeCounter(); /** * @return a non-null {@link LongCounter} representing time spent (milliseconds) in the * scan state. */ public abstract LongCounter getScanTimeCounter(); /** * @return a non-null {@link LongCounter} representing time spent (milliseconds) in the * sleep state. */ public abstract LongCounter getSleepTimeCounter(); /** * @return a non-null {@link LongCounter} representing time spent (milliseconds) in the * receive state. */ public abstract LongCounter getRxTimeCounter(); /** * An array of {@link LongCounter}, representing various transmit levels, where each level * may draw a different amount of power. The levels themselves are controller-specific. * @return non-null array of {@link LongCounter}s representing time spent (milliseconds) in * various transmit level states. */ public abstract LongCounter[] getTxTimeCounters(); /** * @return a non-null {@link LongCounter} representing the power consumed by the controller * in all states, measured in milli-ampere-milliseconds (mAms). The counter may always * yield a value of 0 if the device doesn't support power calculations. */ public abstract LongCounter getPowerCounter(); } /** * State for keeping track of timing information. */ public static abstract class Timer { /** * Returns the count associated with this Timer for the * selected type of statistics. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT */ public abstract int getCountLocked(int which); /** * Returns the total time in microseconds associated with this Timer for the * selected type of statistics. * * @param elapsedRealtimeUs current elapsed realtime of system in microseconds * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT * @return a time in microseconds */ public abstract long getTotalTimeLocked(long elapsedRealtimeUs, int which); /** * Returns the total time in microseconds associated with this Timer since the * 'mark' was last set. * * @param elapsedRealtimeUs current elapsed realtime of system in microseconds * @return a time in microseconds */ public abstract long getTimeSinceMarkLocked(long elapsedRealtimeUs); /** * Returns the max duration if it is being tracked. * Not all Timer subclasses track the max, total, and current durations. */ public long getMaxDurationMsLocked(long elapsedRealtimeMs) { return -1; } /** * Returns the current time the timer has been active, if it is being tracked. * Not all Timer subclasses track the max, total, and current durations. */ public long getCurrentDurationMsLocked(long elapsedRealtimeMs) { return -1; } /** * Returns the total time the timer has been active, if it is being tracked. * * Returns the total cumulative duration (i.e. sum of past durations) that this timer has * been on since reset. * This may differ from getTotalTimeLocked(elapsedRealtimeUs, STATS_SINCE_CHARGED)/1000 since, * depending on the Timer, getTotalTimeLocked may represent the total 'blamed' or 'pooled' * time, rather than the actual time. By contrast, getTotalDurationMsLocked always gives * the actual total time. * Not all Timer subclasses track the max, total, and current durations. */ public long getTotalDurationMsLocked(long elapsedRealtimeMs) { return -1; } /** * Returns the secondary Timer held by the Timer, if one exists. This secondary timer may be * used, for example, for tracking background usage. Secondary timers are never pooled. * * Not all Timer subclasses have a secondary timer; those that don't return null. */ public Timer getSubTimer() { return null; } /** * Returns whether the timer is currently running. Some types of timers * (e.g. BatchTimers) don't know whether the event is currently active, * and report false. */ public boolean isRunningLocked() { return false; } /** * Temporary for debugging. */ public abstract void logState(Printer pw, String prefix); } /** * Maps the ActivityManager procstate into corresponding BatteryStats procstate. */ public static int mapToInternalProcessState(int procState) { if (procState == ActivityManager.PROCESS_STATE_NONEXISTENT) { return ActivityManager.PROCESS_STATE_NONEXISTENT; } else if (procState == ActivityManager.PROCESS_STATE_TOP) { return Uid.PROCESS_STATE_TOP; } else if (procState == ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE) { // State when app has put itself in the foreground. return Uid.PROCESS_STATE_FOREGROUND_SERVICE; } else if (procState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) { // Persistent and other foreground states go here. return Uid.PROCESS_STATE_FOREGROUND; } else if (procState <= ActivityManager.PROCESS_STATE_RECEIVER) { return Uid.PROCESS_STATE_BACKGROUND; } else if (procState <= ActivityManager.PROCESS_STATE_TOP_SLEEPING) { return Uid.PROCESS_STATE_TOP_SLEEPING; } else if (procState <= ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) { return Uid.PROCESS_STATE_HEAVY_WEIGHT; } else { return Uid.PROCESS_STATE_CACHED; } } /** * The statistics associated with a particular uid. */ public static abstract class Uid { /** * Returns a mapping containing wakelock statistics. * * @return a Map from Strings to Uid.Wakelock objects. */ public abstract ArrayMap getWakelockStats(); /** * Returns the WiFi Multicast Wakelock statistics. * * @return a Timer Object for the per uid Multicast statistics. */ public abstract Timer getMulticastWakelockStats(); /** * Returns a mapping containing sync statistics. * * @return a Map from Strings to Timer objects. */ public abstract ArrayMap getSyncStats(); /** * Returns a mapping containing scheduled job statistics. * * @return a Map from Strings to Timer objects. */ public abstract ArrayMap getJobStats(); /** * Returns statistics about how jobs have completed. * * @return A Map of String job names to completion type -> count mapping. */ public abstract ArrayMap getJobCompletionStats(); /** * The statistics associated with a particular wake lock. */ public static abstract class Wakelock { public abstract Timer getWakeTime(int type); } /** * The cumulative time the uid spent holding any partial wakelocks. This will generally * differ from summing over the Wakelocks in getWakelockStats since the latter may have * wakelocks that overlap in time (and therefore over-counts). */ public abstract Timer getAggregatedPartialWakelockTimer(); /** * Returns a mapping containing sensor statistics. * * @return a Map from Integer sensor ids to Uid.Sensor objects. */ public abstract SparseArray getSensorStats(); /** * Returns a mapping containing active process data. */ public abstract SparseArray getPidStats(); /** * Returns a mapping containing process statistics. * * @return a Map from Strings to Uid.Proc objects. */ public abstract ArrayMap getProcessStats(); /** * Returns a mapping containing package statistics. * * @return a Map from Strings to Uid.Pkg objects. */ public abstract ArrayMap getPackageStats(); public abstract ControllerActivityCounter getWifiControllerActivity(); public abstract ControllerActivityCounter getBluetoothControllerActivity(); public abstract ControllerActivityCounter getModemControllerActivity(); /** * {@hide} */ public abstract int getUid(); public abstract void noteWifiRunningLocked(long elapsedRealtime); public abstract void noteWifiStoppedLocked(long elapsedRealtime); public abstract void noteFullWifiLockAcquiredLocked(long elapsedRealtime); public abstract void noteFullWifiLockReleasedLocked(long elapsedRealtime); public abstract void noteWifiScanStartedLocked(long elapsedRealtime); public abstract void noteWifiScanStoppedLocked(long elapsedRealtime); public abstract void noteWifiBatchedScanStartedLocked(int csph, long elapsedRealtime); public abstract void noteWifiBatchedScanStoppedLocked(long elapsedRealtime); public abstract void noteWifiMulticastEnabledLocked(long elapsedRealtime); public abstract void noteWifiMulticastDisabledLocked(long elapsedRealtime); public abstract void noteActivityResumedLocked(long elapsedRealtime); public abstract void noteActivityPausedLocked(long elapsedRealtime); public abstract long getWifiRunningTime(long elapsedRealtimeUs, int which); public abstract long getFullWifiLockTime(long elapsedRealtimeUs, int which); public abstract long getWifiScanTime(long elapsedRealtimeUs, int which); public abstract int getWifiScanCount(int which); /** * Returns the timer keeping track of wifi scans. */ public abstract Timer getWifiScanTimer(); public abstract int getWifiScanBackgroundCount(int which); public abstract long getWifiScanActualTime(long elapsedRealtimeUs); public abstract long getWifiScanBackgroundTime(long elapsedRealtimeUs); /** * Returns the timer keeping track of background wifi scans. */ public abstract Timer getWifiScanBackgroundTimer(); public abstract long getWifiBatchedScanTime(int csphBin, long elapsedRealtimeUs, int which); public abstract int getWifiBatchedScanCount(int csphBin, int which); public abstract long getWifiMulticastTime(long elapsedRealtimeUs, int which); public abstract Timer getAudioTurnedOnTimer(); public abstract Timer getVideoTurnedOnTimer(); public abstract Timer getFlashlightTurnedOnTimer(); public abstract Timer getCameraTurnedOnTimer(); public abstract Timer getForegroundActivityTimer(); /** * Returns the timer keeping track of Foreground Service time */ public abstract Timer getForegroundServiceTimer(); public abstract Timer getBluetoothScanTimer(); public abstract Timer getBluetoothScanBackgroundTimer(); public abstract Timer getBluetoothUnoptimizedScanTimer(); public abstract Timer getBluetoothUnoptimizedScanBackgroundTimer(); public abstract Counter getBluetoothScanResultCounter(); public abstract Counter getBluetoothScanResultBgCounter(); public abstract long[] getCpuFreqTimes(int which); public abstract long[] getScreenOffCpuFreqTimes(int which); /** * Returns cpu active time of an uid. */ public abstract long getCpuActiveTime(); /** * Returns cpu times of an uid on each cluster */ public abstract long[] getCpuClusterTimes(); /** * Returns cpu times of an uid at a particular process state. */ public abstract long[] getCpuFreqTimes(int which, int procState); /** * Returns cpu times of an uid while the screen if off at a particular process state. */ public abstract long[] getScreenOffCpuFreqTimes(int which, int procState); // Note: the following times are disjoint. They can be added together to find the // total time a uid has had any processes running at all. /** * Time this uid has any processes in the top state. */ public static final int PROCESS_STATE_TOP = 0; /** * Time this uid has any process with a started foreground service, but * none in the "top" state. */ public static final int PROCESS_STATE_FOREGROUND_SERVICE = 1; /** * Time this uid has any process in an active foreground state, but none in the * "foreground service" or better state. Persistent and other foreground states go here. */ public static final int PROCESS_STATE_FOREGROUND = 2; /** * Time this uid has any process in an active background state, but none in the * "foreground" or better state. */ public static final int PROCESS_STATE_BACKGROUND = 3; /** * Time this uid has any process that is top while the device is sleeping, but not * active for any other reason. We kind-of consider it a kind of cached process * for execution restrictions. */ public static final int PROCESS_STATE_TOP_SLEEPING = 4; /** * Time this uid has any process that is in the background but it has an activity * marked as "can't save state". This is essentially a cached process, though the * system will try much harder than normal to avoid killing it. */ public static final int PROCESS_STATE_HEAVY_WEIGHT = 5; /** * Time this uid has any processes that are sitting around cached, not in one of the * other active states. */ public static final int PROCESS_STATE_CACHED = 6; /** * Total number of process states we track. */ public static final int NUM_PROCESS_STATE = 7; // Used in dump static final String[] PROCESS_STATE_NAMES = { "Top", "Fg Service", "Foreground", "Background", "Top Sleeping", "Heavy Weight", "Cached" }; // Used in checkin dump @VisibleForTesting public static final String[] UID_PROCESS_TYPES = { "T", // TOP "FS", // FOREGROUND_SERVICE "F", // FOREGROUND "B", // BACKGROUND "TS", // TOP_SLEEPING "HW", // HEAVY_WEIGHT "C" // CACHED }; /** * When the process exits one of these states, we need to make sure cpu time in this state * is not attributed to any non-critical process states. */ public static final int[] CRITICAL_PROC_STATES = { PROCESS_STATE_TOP, PROCESS_STATE_FOREGROUND_SERVICE, PROCESS_STATE_FOREGROUND }; public abstract long getProcessStateTime(int state, long elapsedRealtimeUs, int which); public abstract Timer getProcessStateTimer(int state); public abstract Timer getVibratorOnTimer(); public static final int NUM_WIFI_BATCHED_SCAN_BINS = 5; /** * Note that these must match the constants in android.os.PowerManager. * Also, if the user activity types change, the BatteryStatsImpl.VERSION must * also be bumped. */ static final String[] USER_ACTIVITY_TYPES = { "other", "button", "touch", "accessibility" }; public static final int NUM_USER_ACTIVITY_TYPES = 4; public abstract void noteUserActivityLocked(int type); public abstract boolean hasUserActivity(); public abstract int getUserActivityCount(int type, int which); public abstract boolean hasNetworkActivity(); public abstract long getNetworkActivityBytes(int type, int which); public abstract long getNetworkActivityPackets(int type, int which); public abstract long getMobileRadioActiveTime(int which); public abstract int getMobileRadioActiveCount(int which); /** * Get the total cpu time (in microseconds) this UID had processes executing in userspace. */ public abstract long getUserCpuTimeUs(int which); /** * Get the total cpu time (in microseconds) this UID had processes executing kernel syscalls. */ public abstract long getSystemCpuTimeUs(int which); /** * Returns the approximate cpu time (in microseconds) spent at a certain CPU speed for a * given CPU cluster. * @param cluster the index of the CPU cluster. * @param step the index of the CPU speed. This is not the actual speed of the CPU. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. * @see com.android.internal.os.PowerProfile#getNumCpuClusters() * @see com.android.internal.os.PowerProfile#getNumSpeedStepsInCpuCluster(int) */ public abstract long getTimeAtCpuSpeed(int cluster, int step, int which); /** * Returns the number of times this UID woke up the Application Processor to * process a mobile radio packet. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long getMobileRadioApWakeupCount(int which); /** * Returns the number of times this UID woke up the Application Processor to * process a WiFi packet. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long getWifiRadioApWakeupCount(int which); /** * Appends the deferred jobs data to the StringBuilder passed in, in checkin format * @param sb StringBuilder that can be overwritten with the deferred jobs data * @param which one of STATS_* */ public abstract void getDeferredJobsCheckinLineLocked(StringBuilder sb, int which); /** * Appends the deferred jobs data to the StringBuilder passed in * @param sb StringBuilder that can be overwritten with the deferred jobs data * @param which one of STATS_* */ public abstract void getDeferredJobsLineLocked(StringBuilder sb, int which); public static abstract class Sensor { /* * FIXME: it's not correct to use this magic value because it * could clash with a sensor handle (which are defined by * the sensor HAL, and therefore out of our control */ // Magic sensor number for the GPS. public static final int GPS = -10000; public abstract int getHandle(); public abstract Timer getSensorTime(); /** Returns a Timer for sensor usage when app is in the background. */ public abstract Timer getSensorBackgroundTime(); } public class Pid { public int mWakeNesting; public long mWakeSumMs; public long mWakeStartMs; } /** * The statistics associated with a particular process. */ public static abstract class Proc { public static class ExcessivePower { public static final int TYPE_WAKE = 1; public static final int TYPE_CPU = 2; public int type; public long overTime; public long usedTime; } /** * Returns true if this process is still active in the battery stats. */ public abstract boolean isActive(); /** * Returns the total time (in milliseconds) spent executing in user code. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long getUserTime(int which); /** * Returns the total time (in milliseconds) spent executing in system code. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long getSystemTime(int which); /** * Returns the number of times the process has been started. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract int getStarts(int which); /** * Returns the number of times the process has crashed. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract int getNumCrashes(int which); /** * Returns the number of times the process has ANRed. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract int getNumAnrs(int which); /** * Returns the cpu time (milliseconds) spent while the process was in the foreground. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. * @return foreground cpu time in microseconds */ public abstract long getForegroundTime(int which); public abstract int countExcessivePowers(); public abstract ExcessivePower getExcessivePower(int i); } /** * The statistics associated with a particular package. */ public static abstract class Pkg { /** * Returns information about all wakeup alarms that have been triggered for this * package. The mapping keys are tag names for the alarms, the counter contains * the number of times the alarm was triggered while on battery. */ public abstract ArrayMap getWakeupAlarmStats(); /** * Returns a mapping containing service statistics. */ public abstract ArrayMap getServiceStats(); /** * The statistics associated with a particular service. */ public static abstract class Serv { /** * Returns the amount of time spent started. * * @param batteryUptime elapsed uptime on battery in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. * @return */ public abstract long getStartTime(long batteryUptime, int which); /** * Returns the total number of times startService() has been called. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract int getStarts(int which); /** * Returns the total number times the service has been launched. * * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract int getLaunches(int which); } } } public static final class LevelStepTracker { public long mLastStepTime = -1; public int mNumStepDurations; public final long[] mStepDurations; public LevelStepTracker(int maxLevelSteps) { mStepDurations = new long[maxLevelSteps]; } public LevelStepTracker(int numSteps, long[] steps) { mNumStepDurations = numSteps; mStepDurations = new long[numSteps]; System.arraycopy(steps, 0, mStepDurations, 0, numSteps); } public long getDurationAt(int index) { return mStepDurations[index] & STEP_LEVEL_TIME_MASK; } public int getLevelAt(int index) { return (int)((mStepDurations[index] & STEP_LEVEL_LEVEL_MASK) >> STEP_LEVEL_LEVEL_SHIFT); } public int getInitModeAt(int index) { return (int)((mStepDurations[index] & STEP_LEVEL_INITIAL_MODE_MASK) >> STEP_LEVEL_INITIAL_MODE_SHIFT); } public int getModModeAt(int index) { return (int)((mStepDurations[index] & STEP_LEVEL_MODIFIED_MODE_MASK) >> STEP_LEVEL_MODIFIED_MODE_SHIFT); } private void appendHex(long val, int topOffset, StringBuilder out) { boolean hasData = false; while (topOffset >= 0) { int digit = (int)( (val>>topOffset) & 0xf ); topOffset -= 4; if (!hasData && digit == 0) { continue; } hasData = true; if (digit >= 0 && digit <= 9) { out.append((char)('0' + digit)); } else { out.append((char)('a' + digit - 10)); } } } public void encodeEntryAt(int index, StringBuilder out) { long item = mStepDurations[index]; long duration = item & STEP_LEVEL_TIME_MASK; int level = (int)((item & STEP_LEVEL_LEVEL_MASK) >> STEP_LEVEL_LEVEL_SHIFT); int initMode = (int)((item & STEP_LEVEL_INITIAL_MODE_MASK) >> STEP_LEVEL_INITIAL_MODE_SHIFT); int modMode = (int)((item & STEP_LEVEL_MODIFIED_MODE_MASK) >> STEP_LEVEL_MODIFIED_MODE_SHIFT); switch ((initMode&STEP_LEVEL_MODE_SCREEN_STATE) + 1) { case Display.STATE_OFF: out.append('f'); break; case Display.STATE_ON: out.append('o'); break; case Display.STATE_DOZE: out.append('d'); break; case Display.STATE_DOZE_SUSPEND: out.append('z'); break; } if ((initMode&STEP_LEVEL_MODE_POWER_SAVE) != 0) { out.append('p'); } if ((initMode&STEP_LEVEL_MODE_DEVICE_IDLE) != 0) { out.append('i'); } switch ((modMode&STEP_LEVEL_MODE_SCREEN_STATE) + 1) { case Display.STATE_OFF: out.append('F'); break; case Display.STATE_ON: out.append('O'); break; case Display.STATE_DOZE: out.append('D'); break; case Display.STATE_DOZE_SUSPEND: out.append('Z'); break; } if ((modMode&STEP_LEVEL_MODE_POWER_SAVE) != 0) { out.append('P'); } if ((modMode&STEP_LEVEL_MODE_DEVICE_IDLE) != 0) { out.append('I'); } out.append('-'); appendHex(level, 4, out); out.append('-'); appendHex(duration, STEP_LEVEL_LEVEL_SHIFT-4, out); } public void decodeEntryAt(int index, String value) { final int N = value.length(); int i = 0; char c; long out = 0; while (i < N && (c=value.charAt(i)) != '-') { i++; switch (c) { case 'f': out |= (((long)Display.STATE_OFF-1)<= '0' && c <= '9') { level += c - '0'; } else if (c >= 'a' && c <= 'f') { level += c - 'a' + 10; } else if (c >= 'A' && c <= 'F') { level += c - 'A' + 10; } } i++; out |= (level << STEP_LEVEL_LEVEL_SHIFT) & STEP_LEVEL_LEVEL_MASK; long duration = 0; while (i < N && (c=value.charAt(i)) != '-') { i++; duration <<= 4; if (c >= '0' && c <= '9') { duration += c - '0'; } else if (c >= 'a' && c <= 'f') { duration += c - 'a' + 10; } else if (c >= 'A' && c <= 'F') { duration += c - 'A' + 10; } } mStepDurations[index] = out | (duration & STEP_LEVEL_TIME_MASK); } public void init() { mLastStepTime = -1; mNumStepDurations = 0; } public void clearTime() { mLastStepTime = -1; } public long computeTimePerLevel() { final long[] steps = mStepDurations; final int numSteps = mNumStepDurations; // For now we'll do a simple average across all steps. if (numSteps <= 0) { return -1; } long total = 0; for (int i=0; i=0; i--) { averageTime = (averageTime + buckets[i]) / 2; } return averageTime; */ } public long computeTimeEstimate(long modesOfInterest, long modeValues, int[] outNumOfInterest) { final long[] steps = mStepDurations; final int count = mNumStepDurations; if (count <= 0) { return -1; } long total = 0; int numOfInterest = 0; for (int i=0; i> STEP_LEVEL_INITIAL_MODE_SHIFT; long modMode = (steps[i] & STEP_LEVEL_MODIFIED_MODE_MASK) >> STEP_LEVEL_MODIFIED_MODE_SHIFT; // If the modes of interest didn't change during this step period... if ((modMode&modesOfInterest) == 0) { // And the mode values during this period match those we are measuring... if ((initMode&modesOfInterest) == modeValues) { // Then this can be used to estimate the total time! numOfInterest++; total += steps[i] & STEP_LEVEL_TIME_MASK; } } } if (numOfInterest <= 0) { return -1; } if (outNumOfInterest != null) { outNumOfInterest[0] = numOfInterest; } // The estimated time is the average time we spend in each level, multipled // by 100 -- the total number of battery levels return (total / numOfInterest) * 100; } public void addLevelSteps(int numStepLevels, long modeBits, long elapsedRealtime) { int stepCount = mNumStepDurations; final long lastStepTime = mLastStepTime; if (lastStepTime >= 0 && numStepLevels > 0) { final long[] steps = mStepDurations; long duration = elapsedRealtime - lastStepTime; for (int i=0; i STEP_LEVEL_TIME_MASK) { thisDuration = STEP_LEVEL_TIME_MASK; } steps[0] = thisDuration | modeBits; } stepCount += numStepLevels; if (stepCount > steps.length) { stepCount = steps.length; } } mNumStepDurations = stepCount; mLastStepTime = elapsedRealtime; } public void readFromParcel(Parcel in) { final int N = in.readInt(); if (N > mStepDurations.length) { throw new ParcelFormatException("more step durations than available: " + N); } mNumStepDurations = N; for (int i=0; i mPackageChanges; } public abstract DailyItem getDailyItemLocked(int daysAgo); public abstract long getCurrentDailyStartTime(); public abstract long getNextMinDailyDeadline(); public abstract long getNextMaxDailyDeadline(); public abstract long[] getCpuFreqs(); public final static class HistoryTag { public String string; public int uid; public int poolIdx; public void setTo(HistoryTag o) { string = o.string; uid = o.uid; poolIdx = o.poolIdx; } public void setTo(String _string, int _uid) { string = _string; uid = _uid; poolIdx = -1; } public void writeToParcel(Parcel dest, int flags) { dest.writeString(string); dest.writeInt(uid); } public void readFromParcel(Parcel src) { string = src.readString(); uid = src.readInt(); poolIdx = -1; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; HistoryTag that = (HistoryTag) o; if (uid != that.uid) return false; if (!string.equals(that.string)) return false; return true; } @Override public int hashCode() { int result = string.hashCode(); result = 31 * result + uid; return result; } } /** * Optional detailed information that can go into a history step. This is typically * generated each time the battery level changes. */ public final static class HistoryStepDetails { // Time (in 1/100 second) spent in user space and the kernel since the last step. public int userTime; public int systemTime; // Top three apps using CPU in the last step, with times in 1/100 second. public int appCpuUid1; public int appCpuUTime1; public int appCpuSTime1; public int appCpuUid2; public int appCpuUTime2; public int appCpuSTime2; public int appCpuUid3; public int appCpuUTime3; public int appCpuSTime3; // Information from /proc/stat public int statUserTime; public int statSystemTime; public int statIOWaitTime; public int statIrqTime; public int statSoftIrqTime; public int statIdlTime; // Platform-level low power state stats public String statPlatformIdleState; public String statSubsystemPowerState; public HistoryStepDetails() { clear(); } public void clear() { userTime = systemTime = 0; appCpuUid1 = appCpuUid2 = appCpuUid3 = -1; appCpuUTime1 = appCpuSTime1 = appCpuUTime2 = appCpuSTime2 = appCpuUTime3 = appCpuSTime3 = 0; } public void writeToParcel(Parcel out) { out.writeInt(userTime); out.writeInt(systemTime); out.writeInt(appCpuUid1); out.writeInt(appCpuUTime1); out.writeInt(appCpuSTime1); out.writeInt(appCpuUid2); out.writeInt(appCpuUTime2); out.writeInt(appCpuSTime2); out.writeInt(appCpuUid3); out.writeInt(appCpuUTime3); out.writeInt(appCpuSTime3); out.writeInt(statUserTime); out.writeInt(statSystemTime); out.writeInt(statIOWaitTime); out.writeInt(statIrqTime); out.writeInt(statSoftIrqTime); out.writeInt(statIdlTime); out.writeString(statPlatformIdleState); out.writeString(statSubsystemPowerState); } public void readFromParcel(Parcel in) { userTime = in.readInt(); systemTime = in.readInt(); appCpuUid1 = in.readInt(); appCpuUTime1 = in.readInt(); appCpuSTime1 = in.readInt(); appCpuUid2 = in.readInt(); appCpuUTime2 = in.readInt(); appCpuSTime2 = in.readInt(); appCpuUid3 = in.readInt(); appCpuUTime3 = in.readInt(); appCpuSTime3 = in.readInt(); statUserTime = in.readInt(); statSystemTime = in.readInt(); statIOWaitTime = in.readInt(); statIrqTime = in.readInt(); statSoftIrqTime = in.readInt(); statIdlTime = in.readInt(); statPlatformIdleState = in.readString(); statSubsystemPowerState = in.readString(); } } public final static class HistoryItem implements Parcelable { public HistoryItem next; // The time of this event in milliseconds, as per SystemClock.elapsedRealtime(). public long time; public static final byte CMD_UPDATE = 0; // These can be written as deltas public static final byte CMD_NULL = -1; public static final byte CMD_START = 4; public static final byte CMD_CURRENT_TIME = 5; public static final byte CMD_OVERFLOW = 6; public static final byte CMD_RESET = 7; public static final byte CMD_SHUTDOWN = 8; public byte cmd = CMD_NULL; /** * Return whether the command code is a delta data update. */ public boolean isDeltaData() { return cmd == CMD_UPDATE; } public byte batteryLevel; public byte batteryStatus; public byte batteryHealth; public byte batteryPlugType; public short batteryTemperature; public char batteryVoltage; // The charge of the battery in micro-Ampere-hours. public int batteryChargeUAh; // Constants from SCREEN_BRIGHTNESS_* public static final int STATE_BRIGHTNESS_SHIFT = 0; public static final int STATE_BRIGHTNESS_MASK = 0x7; // Constants from SIGNAL_STRENGTH_* public static final int STATE_PHONE_SIGNAL_STRENGTH_SHIFT = 3; public static final int STATE_PHONE_SIGNAL_STRENGTH_MASK = 0x7 << STATE_PHONE_SIGNAL_STRENGTH_SHIFT; // Constants from ServiceState.STATE_* public static final int STATE_PHONE_STATE_SHIFT = 6; public static final int STATE_PHONE_STATE_MASK = 0x7 << STATE_PHONE_STATE_SHIFT; // Constants from DATA_CONNECTION_* public static final int STATE_DATA_CONNECTION_SHIFT = 9; public static final int STATE_DATA_CONNECTION_MASK = 0x1f << STATE_DATA_CONNECTION_SHIFT; // These states always appear directly in the first int token // of a delta change; they should be ones that change relatively // frequently. public static final int STATE_CPU_RUNNING_FLAG = 1<<31; public static final int STATE_WAKE_LOCK_FLAG = 1<<30; public static final int STATE_GPS_ON_FLAG = 1<<29; public static final int STATE_WIFI_FULL_LOCK_FLAG = 1<<28; public static final int STATE_WIFI_SCAN_FLAG = 1<<27; public static final int STATE_WIFI_RADIO_ACTIVE_FLAG = 1<<26; public static final int STATE_MOBILE_RADIO_ACTIVE_FLAG = 1<<25; // Do not use, this is used for coulomb delta count. private static final int STATE_RESERVED_0 = 1<<24; // These are on the lower bits used for the command; if they change // we need to write another int of data. public static final int STATE_SENSOR_ON_FLAG = 1<<23; public static final int STATE_AUDIO_ON_FLAG = 1<<22; public static final int STATE_PHONE_SCANNING_FLAG = 1<<21; public static final int STATE_SCREEN_ON_FLAG = 1<<20; // consider moving to states2 public static final int STATE_BATTERY_PLUGGED_FLAG = 1<<19; // consider moving to states2 public static final int STATE_SCREEN_DOZE_FLAG = 1 << 18; // empty slot public static final int STATE_WIFI_MULTICAST_ON_FLAG = 1<<16; public static final int MOST_INTERESTING_STATES = STATE_BATTERY_PLUGGED_FLAG | STATE_SCREEN_ON_FLAG | STATE_SCREEN_DOZE_FLAG; public static final int SETTLE_TO_ZERO_STATES = 0xffff0000 & ~MOST_INTERESTING_STATES; public int states; // Constants from WIFI_SUPPL_STATE_* public static final int STATE2_WIFI_SUPPL_STATE_SHIFT = 0; public static final int STATE2_WIFI_SUPPL_STATE_MASK = 0xf; // Values for NUM_WIFI_SIGNAL_STRENGTH_BINS public static final int STATE2_WIFI_SIGNAL_STRENGTH_SHIFT = 4; public static final int STATE2_WIFI_SIGNAL_STRENGTH_MASK = 0x7 << STATE2_WIFI_SIGNAL_STRENGTH_SHIFT; // Values for NUM_GPS_SIGNAL_QUALITY_LEVELS public static final int STATE2_GPS_SIGNAL_QUALITY_SHIFT = 7; public static final int STATE2_GPS_SIGNAL_QUALITY_MASK = 0x1 << STATE2_GPS_SIGNAL_QUALITY_SHIFT; public static final int STATE2_POWER_SAVE_FLAG = 1<<31; public static final int STATE2_VIDEO_ON_FLAG = 1<<30; public static final int STATE2_WIFI_RUNNING_FLAG = 1<<29; public static final int STATE2_WIFI_ON_FLAG = 1<<28; public static final int STATE2_FLASHLIGHT_FLAG = 1<<27; public static final int STATE2_DEVICE_IDLE_SHIFT = 25; public static final int STATE2_DEVICE_IDLE_MASK = 0x3 << STATE2_DEVICE_IDLE_SHIFT; public static final int STATE2_CHARGING_FLAG = 1<<24; public static final int STATE2_PHONE_IN_CALL_FLAG = 1<<23; public static final int STATE2_BLUETOOTH_ON_FLAG = 1<<22; public static final int STATE2_CAMERA_FLAG = 1<<21; public static final int STATE2_BLUETOOTH_SCAN_FLAG = 1 << 20; public static final int STATE2_CELLULAR_HIGH_TX_POWER_FLAG = 1 << 19; public static final int MOST_INTERESTING_STATES2 = STATE2_POWER_SAVE_FLAG | STATE2_WIFI_ON_FLAG | STATE2_DEVICE_IDLE_MASK | STATE2_CHARGING_FLAG | STATE2_PHONE_IN_CALL_FLAG | STATE2_BLUETOOTH_ON_FLAG; public static final int SETTLE_TO_ZERO_STATES2 = 0xffff0000 & ~MOST_INTERESTING_STATES2; public int states2; // The wake lock that was acquired at this point. public HistoryTag wakelockTag; // Kernel wakeup reason at this point. public HistoryTag wakeReasonTag; // Non-null when there is more detailed information at this step. public HistoryStepDetails stepDetails; public static final int EVENT_FLAG_START = 0x8000; public static final int EVENT_FLAG_FINISH = 0x4000; // No event in this item. public static final int EVENT_NONE = 0x0000; // Event is about a process that is running. public static final int EVENT_PROC = 0x0001; // Event is about an application package that is in the foreground. public static final int EVENT_FOREGROUND = 0x0002; // Event is about an application package that is at the top of the screen. public static final int EVENT_TOP = 0x0003; // Event is about active sync operations. public static final int EVENT_SYNC = 0x0004; // Events for all additional wake locks aquired/release within a wake block. // These are not generated by default. public static final int EVENT_WAKE_LOCK = 0x0005; // Event is about an application executing a scheduled job. public static final int EVENT_JOB = 0x0006; // Events for users running. public static final int EVENT_USER_RUNNING = 0x0007; // Events for foreground user. public static final int EVENT_USER_FOREGROUND = 0x0008; // Event for connectivity changed. public static final int EVENT_CONNECTIVITY_CHANGED = 0x0009; // Event for becoming active taking us out of idle mode. public static final int EVENT_ACTIVE = 0x000a; // Event for a package being installed. public static final int EVENT_PACKAGE_INSTALLED = 0x000b; // Event for a package being uninstalled. public static final int EVENT_PACKAGE_UNINSTALLED = 0x000c; // Event for a package being uninstalled. public static final int EVENT_ALARM = 0x000d; // Record that we have decided we need to collect new stats data. public static final int EVENT_COLLECT_EXTERNAL_STATS = 0x000e; // Event for a package becoming inactive due to being unused for a period of time. public static final int EVENT_PACKAGE_INACTIVE = 0x000f; // Event for a package becoming active due to an interaction. public static final int EVENT_PACKAGE_ACTIVE = 0x0010; // Event for a package being on the temporary whitelist. public static final int EVENT_TEMP_WHITELIST = 0x0011; // Event for the screen waking up. public static final int EVENT_SCREEN_WAKE_UP = 0x0012; // Event for the UID that woke up the application processor. // Used for wakeups coming from WiFi, modem, etc. public static final int EVENT_WAKEUP_AP = 0x0013; // Event for reporting that a specific partial wake lock has been held for a long duration. public static final int EVENT_LONG_WAKE_LOCK = 0x0014; // Number of event types. public static final int EVENT_COUNT = 0x0016; // Mask to extract out only the type part of the event. public static final int EVENT_TYPE_MASK = ~(EVENT_FLAG_START|EVENT_FLAG_FINISH); public static final int EVENT_PROC_START = EVENT_PROC | EVENT_FLAG_START; public static final int EVENT_PROC_FINISH = EVENT_PROC | EVENT_FLAG_FINISH; public static final int EVENT_FOREGROUND_START = EVENT_FOREGROUND | EVENT_FLAG_START; public static final int EVENT_FOREGROUND_FINISH = EVENT_FOREGROUND | EVENT_FLAG_FINISH; public static final int EVENT_TOP_START = EVENT_TOP | EVENT_FLAG_START; public static final int EVENT_TOP_FINISH = EVENT_TOP | EVENT_FLAG_FINISH; public static final int EVENT_SYNC_START = EVENT_SYNC | EVENT_FLAG_START; public static final int EVENT_SYNC_FINISH = EVENT_SYNC | EVENT_FLAG_FINISH; public static final int EVENT_WAKE_LOCK_START = EVENT_WAKE_LOCK | EVENT_FLAG_START; public static final int EVENT_WAKE_LOCK_FINISH = EVENT_WAKE_LOCK | EVENT_FLAG_FINISH; public static final int EVENT_JOB_START = EVENT_JOB | EVENT_FLAG_START; public static final int EVENT_JOB_FINISH = EVENT_JOB | EVENT_FLAG_FINISH; public static final int EVENT_USER_RUNNING_START = EVENT_USER_RUNNING | EVENT_FLAG_START; public static final int EVENT_USER_RUNNING_FINISH = EVENT_USER_RUNNING | EVENT_FLAG_FINISH; public static final int EVENT_USER_FOREGROUND_START = EVENT_USER_FOREGROUND | EVENT_FLAG_START; public static final int EVENT_USER_FOREGROUND_FINISH = EVENT_USER_FOREGROUND | EVENT_FLAG_FINISH; public static final int EVENT_ALARM_START = EVENT_ALARM | EVENT_FLAG_START; public static final int EVENT_ALARM_FINISH = EVENT_ALARM | EVENT_FLAG_FINISH; public static final int EVENT_TEMP_WHITELIST_START = EVENT_TEMP_WHITELIST | EVENT_FLAG_START; public static final int EVENT_TEMP_WHITELIST_FINISH = EVENT_TEMP_WHITELIST | EVENT_FLAG_FINISH; public static final int EVENT_LONG_WAKE_LOCK_START = EVENT_LONG_WAKE_LOCK | EVENT_FLAG_START; public static final int EVENT_LONG_WAKE_LOCK_FINISH = EVENT_LONG_WAKE_LOCK | EVENT_FLAG_FINISH; // For CMD_EVENT. public int eventCode; public HistoryTag eventTag; // Only set for CMD_CURRENT_TIME or CMD_RESET, as per System.currentTimeMillis(). public long currentTime; // Meta-data when reading. public int numReadInts; // Pre-allocated objects. public final HistoryTag localWakelockTag = new HistoryTag(); public final HistoryTag localWakeReasonTag = new HistoryTag(); public final HistoryTag localEventTag = new HistoryTag(); public HistoryItem() { } public HistoryItem(long time, Parcel src) { this.time = time; numReadInts = 2; readFromParcel(src); } public int describeContents() { return 0; } public void writeToParcel(Parcel dest, int flags) { dest.writeLong(time); int bat = (((int)cmd)&0xff) | ((((int)batteryLevel)<<8)&0xff00) | ((((int)batteryStatus)<<16)&0xf0000) | ((((int)batteryHealth)<<20)&0xf00000) | ((((int)batteryPlugType)<<24)&0xf000000) | (wakelockTag != null ? 0x10000000 : 0) | (wakeReasonTag != null ? 0x20000000 : 0) | (eventCode != EVENT_NONE ? 0x40000000 : 0); dest.writeInt(bat); bat = (((int)batteryTemperature)&0xffff) | ((((int)batteryVoltage)<<16)&0xffff0000); dest.writeInt(bat); dest.writeInt(batteryChargeUAh); dest.writeInt(states); dest.writeInt(states2); if (wakelockTag != null) { wakelockTag.writeToParcel(dest, flags); } if (wakeReasonTag != null) { wakeReasonTag.writeToParcel(dest, flags); } if (eventCode != EVENT_NONE) { dest.writeInt(eventCode); eventTag.writeToParcel(dest, flags); } if (cmd == CMD_CURRENT_TIME || cmd == CMD_RESET) { dest.writeLong(currentTime); } } public void readFromParcel(Parcel src) { int start = src.dataPosition(); int bat = src.readInt(); cmd = (byte)(bat&0xff); batteryLevel = (byte)((bat>>8)&0xff); batteryStatus = (byte)((bat>>16)&0xf); batteryHealth = (byte)((bat>>20)&0xf); batteryPlugType = (byte)((bat>>24)&0xf); int bat2 = src.readInt(); batteryTemperature = (short)(bat2&0xffff); batteryVoltage = (char)((bat2>>16)&0xffff); batteryChargeUAh = src.readInt(); states = src.readInt(); states2 = src.readInt(); if ((bat&0x10000000) != 0) { wakelockTag = localWakelockTag; wakelockTag.readFromParcel(src); } else { wakelockTag = null; } if ((bat&0x20000000) != 0) { wakeReasonTag = localWakeReasonTag; wakeReasonTag.readFromParcel(src); } else { wakeReasonTag = null; } if ((bat&0x40000000) != 0) { eventCode = src.readInt(); eventTag = localEventTag; eventTag.readFromParcel(src); } else { eventCode = EVENT_NONE; eventTag = null; } if (cmd == CMD_CURRENT_TIME || cmd == CMD_RESET) { currentTime = src.readLong(); } else { currentTime = 0; } numReadInts += (src.dataPosition()-start)/4; } public void clear() { time = 0; cmd = CMD_NULL; batteryLevel = 0; batteryStatus = 0; batteryHealth = 0; batteryPlugType = 0; batteryTemperature = 0; batteryVoltage = 0; batteryChargeUAh = 0; states = 0; states2 = 0; wakelockTag = null; wakeReasonTag = null; eventCode = EVENT_NONE; eventTag = null; } public void setTo(HistoryItem o) { time = o.time; cmd = o.cmd; setToCommon(o); } public void setTo(long time, byte cmd, HistoryItem o) { this.time = time; this.cmd = cmd; setToCommon(o); } private void setToCommon(HistoryItem o) { batteryLevel = o.batteryLevel; batteryStatus = o.batteryStatus; batteryHealth = o.batteryHealth; batteryPlugType = o.batteryPlugType; batteryTemperature = o.batteryTemperature; batteryVoltage = o.batteryVoltage; batteryChargeUAh = o.batteryChargeUAh; states = o.states; states2 = o.states2; if (o.wakelockTag != null) { wakelockTag = localWakelockTag; wakelockTag.setTo(o.wakelockTag); } else { wakelockTag = null; } if (o.wakeReasonTag != null) { wakeReasonTag = localWakeReasonTag; wakeReasonTag.setTo(o.wakeReasonTag); } else { wakeReasonTag = null; } eventCode = o.eventCode; if (o.eventTag != null) { eventTag = localEventTag; eventTag.setTo(o.eventTag); } else { eventTag = null; } currentTime = o.currentTime; } public boolean sameNonEvent(HistoryItem o) { return batteryLevel == o.batteryLevel && batteryStatus == o.batteryStatus && batteryHealth == o.batteryHealth && batteryPlugType == o.batteryPlugType && batteryTemperature == o.batteryTemperature && batteryVoltage == o.batteryVoltage && batteryChargeUAh == o.batteryChargeUAh && states == o.states && states2 == o.states2 && currentTime == o.currentTime; } public boolean same(HistoryItem o) { if (!sameNonEvent(o) || eventCode != o.eventCode) { return false; } if (wakelockTag != o.wakelockTag) { if (wakelockTag == null || o.wakelockTag == null) { return false; } if (!wakelockTag.equals(o.wakelockTag)) { return false; } } if (wakeReasonTag != o.wakeReasonTag) { if (wakeReasonTag == null || o.wakeReasonTag == null) { return false; } if (!wakeReasonTag.equals(o.wakeReasonTag)) { return false; } } if (eventTag != o.eventTag) { if (eventTag == null || o.eventTag == null) { return false; } if (!eventTag.equals(o.eventTag)) { return false; } } return true; } } public final static class HistoryEventTracker { private final HashMap[] mActiveEvents = (HashMap[]) new HashMap[HistoryItem.EVENT_COUNT]; public boolean updateState(int code, String name, int uid, int poolIdx) { if ((code&HistoryItem.EVENT_FLAG_START) != 0) { int idx = code&HistoryItem.EVENT_TYPE_MASK; HashMap active = mActiveEvents[idx]; if (active == null) { active = new HashMap<>(); mActiveEvents[idx] = active; } SparseIntArray uids = active.get(name); if (uids == null) { uids = new SparseIntArray(); active.put(name, uids); } if (uids.indexOfKey(uid) >= 0) { // Already set, nothing to do! return false; } uids.put(uid, poolIdx); } else if ((code&HistoryItem.EVENT_FLAG_FINISH) != 0) { int idx = code&HistoryItem.EVENT_TYPE_MASK; HashMap active = mActiveEvents[idx]; if (active == null) { // not currently active, nothing to do. return false; } SparseIntArray uids = active.get(name); if (uids == null) { // not currently active, nothing to do. return false; } idx = uids.indexOfKey(uid); if (idx < 0) { // not currently active, nothing to do. return false; } uids.removeAt(idx); if (uids.size() <= 0) { active.remove(name); } } return true; } public void removeEvents(int code) { int idx = code&HistoryItem.EVENT_TYPE_MASK; mActiveEvents[idx] = null; } public HashMap getStateForEvent(int code) { return mActiveEvents[code]; } } public static final class BitDescription { public final int mask; public final int shift; public final String name; public final String shortName; public final String[] values; public final String[] shortValues; public BitDescription(int mask, String name, String shortName) { this.mask = mask; this.shift = -1; this.name = name; this.shortName = shortName; this.values = null; this.shortValues = null; } public BitDescription(int mask, int shift, String name, String shortName, String[] values, String[] shortValues) { this.mask = mask; this.shift = shift; this.name = name; this.shortName = shortName; this.values = values; this.shortValues = shortValues; } } /** * Don't allow any more batching in to the current history event. This * is called when printing partial histories, so to ensure that the next * history event will go in to a new batch after what was printed in the * last partial history. */ public abstract void commitCurrentHistoryBatchLocked(); public abstract int getHistoryTotalSize(); public abstract int getHistoryUsedSize(); public abstract boolean startIteratingHistoryLocked(); public abstract int getHistoryStringPoolSize(); public abstract int getHistoryStringPoolBytes(); public abstract String getHistoryTagPoolString(int index); public abstract int getHistoryTagPoolUid(int index); public abstract boolean getNextHistoryLocked(HistoryItem out); public abstract void finishIteratingHistoryLocked(); public abstract boolean startIteratingOldHistoryLocked(); public abstract boolean getNextOldHistoryLocked(HistoryItem out); public abstract void finishIteratingOldHistoryLocked(); /** * Return the base time offset for the battery history. */ public abstract long getHistoryBaseTime(); /** * Returns the number of times the device has been started. */ public abstract int getStartCount(); /** * Returns the time in microseconds that the screen has been on while the device was * running on battery. * * {@hide} */ public abstract long getScreenOnTime(long elapsedRealtimeUs, int which); /** * Returns the number of times the screen was turned on. * * {@hide} */ public abstract int getScreenOnCount(int which); /** * Returns the time in microseconds that the screen has been dozing while the device was * running on battery. * * {@hide} */ public abstract long getScreenDozeTime(long elapsedRealtimeUs, int which); /** * Returns the number of times the screen was turned dozing. * * {@hide} */ public abstract int getScreenDozeCount(int which); public abstract long getInteractiveTime(long elapsedRealtimeUs, int which); public static final int SCREEN_BRIGHTNESS_DARK = 0; public static final int SCREEN_BRIGHTNESS_DIM = 1; public static final int SCREEN_BRIGHTNESS_MEDIUM = 2; public static final int SCREEN_BRIGHTNESS_LIGHT = 3; public static final int SCREEN_BRIGHTNESS_BRIGHT = 4; static final String[] SCREEN_BRIGHTNESS_NAMES = { "dark", "dim", "medium", "light", "bright" }; static final String[] SCREEN_BRIGHTNESS_SHORT_NAMES = { "0", "1", "2", "3", "4" }; public static final int NUM_SCREEN_BRIGHTNESS_BINS = 5; /** * Returns the time in microseconds that the screen has been on with * the given brightness * * {@hide} */ public abstract long getScreenBrightnessTime(int brightnessBin, long elapsedRealtimeUs, int which); /** * Returns the {@link Timer} object that tracks the given screen brightness. * * {@hide} */ public abstract Timer getScreenBrightnessTimer(int brightnessBin); /** * Returns the time in microseconds that power save mode has been enabled while the device was * running on battery. * * {@hide} */ public abstract long getPowerSaveModeEnabledTime(long elapsedRealtimeUs, int which); /** * Returns the number of times that power save mode was enabled. * * {@hide} */ public abstract int getPowerSaveModeEnabledCount(int which); /** * Constant for device idle mode: not active. */ public static final int DEVICE_IDLE_MODE_OFF = ServerProtoEnums.DEVICE_IDLE_MODE_OFF; // 0 /** * Constant for device idle mode: active in lightweight mode. */ public static final int DEVICE_IDLE_MODE_LIGHT = ServerProtoEnums.DEVICE_IDLE_MODE_LIGHT; // 1 /** * Constant for device idle mode: active in full mode. */ public static final int DEVICE_IDLE_MODE_DEEP = ServerProtoEnums.DEVICE_IDLE_MODE_DEEP; // 2 /** * Returns the time in microseconds that device has been in idle mode while * running on battery. * * {@hide} */ public abstract long getDeviceIdleModeTime(int mode, long elapsedRealtimeUs, int which); /** * Returns the number of times that the devie has gone in to idle mode. * * {@hide} */ public abstract int getDeviceIdleModeCount(int mode, int which); /** * Return the longest duration we spent in a particular device idle mode (fully in the * mode, not in idle maintenance etc). */ public abstract long getLongestDeviceIdleModeTime(int mode); /** * Returns the time in microseconds that device has been in idling while on * battery. This is broader than {@link #getDeviceIdleModeTime} -- it * counts all of the time that we consider the device to be idle, whether or not * it is currently in the actual device idle mode. * * {@hide} */ public abstract long getDeviceIdlingTime(int mode, long elapsedRealtimeUs, int which); /** * Returns the number of times that the device has started idling. * * {@hide} */ public abstract int getDeviceIdlingCount(int mode, int which); /** * Returns the number of times that connectivity state changed. * * {@hide} */ public abstract int getNumConnectivityChange(int which); /** * Returns the time in microseconds that the phone has been running with * the given GPS signal quality level * * {@hide} */ public abstract long getGpsSignalQualityTime(int strengthBin, long elapsedRealtimeUs, int which); /** * Returns the GPS battery drain in mA-ms * * {@hide} */ public abstract long getGpsBatteryDrainMaMs(); /** * Returns the time in microseconds that the phone has been on while the device was * running on battery. * * {@hide} */ public abstract long getPhoneOnTime(long elapsedRealtimeUs, int which); /** * Returns the number of times a phone call was activated. * * {@hide} */ public abstract int getPhoneOnCount(int which); /** * Returns the time in microseconds that the phone has been running with * the given signal strength. * * {@hide} */ public abstract long getPhoneSignalStrengthTime(int strengthBin, long elapsedRealtimeUs, int which); /** * Returns the time in microseconds that the phone has been trying to * acquire a signal. * * {@hide} */ public abstract long getPhoneSignalScanningTime( long elapsedRealtimeUs, int which); /** * Returns the {@link Timer} object that tracks how much the phone has been trying to * acquire a signal. * * {@hide} */ public abstract Timer getPhoneSignalScanningTimer(); /** * Returns the number of times the phone has entered the given signal strength. * * {@hide} */ public abstract int getPhoneSignalStrengthCount(int strengthBin, int which); /** * Return the {@link Timer} object used to track the given signal strength's duration and * counts. */ protected abstract Timer getPhoneSignalStrengthTimer(int strengthBin); /** * Returns the time in microseconds that the mobile network has been active * (in a high power state). * * {@hide} */ public abstract long getMobileRadioActiveTime(long elapsedRealtimeUs, int which); /** * Returns the number of times that the mobile network has transitioned to the * active state. * * {@hide} */ public abstract int getMobileRadioActiveCount(int which); /** * Returns the time in microseconds that is the difference between the mobile radio * time we saw based on the elapsed timestamp when going down vs. the given time stamp * from the radio. * * {@hide} */ public abstract long getMobileRadioActiveAdjustedTime(int which); /** * Returns the time in microseconds that the mobile network has been active * (in a high power state) but not being able to blame on an app. * * {@hide} */ public abstract long getMobileRadioActiveUnknownTime(int which); /** * Return count of number of times radio was up that could not be blamed on apps. * * {@hide} */ public abstract int getMobileRadioActiveUnknownCount(int which); public static final int DATA_CONNECTION_NONE = 0; public static final int DATA_CONNECTION_OTHER = TelephonyManager.MAX_NETWORK_TYPE + 1; static final String[] DATA_CONNECTION_NAMES = { "none", "gprs", "edge", "umts", "cdma", "evdo_0", "evdo_A", "1xrtt", "hsdpa", "hsupa", "hspa", "iden", "evdo_b", "lte", "ehrpd", "hspap", "gsm", "td_scdma", "iwlan", "lte_ca", "other" }; public static final int NUM_DATA_CONNECTION_TYPES = DATA_CONNECTION_OTHER+1; /** * Returns the time in microseconds that the phone has been running with * the given data connection. * * {@hide} */ public abstract long getPhoneDataConnectionTime(int dataType, long elapsedRealtimeUs, int which); /** * Returns the number of times the phone has entered the given data * connection type. * * {@hide} */ public abstract int getPhoneDataConnectionCount(int dataType, int which); /** * Returns the {@link Timer} object that tracks the phone's data connection type stats. */ public abstract Timer getPhoneDataConnectionTimer(int dataType); public static final int WIFI_SUPPL_STATE_INVALID = 0; public static final int WIFI_SUPPL_STATE_DISCONNECTED = 1; public static final int WIFI_SUPPL_STATE_INTERFACE_DISABLED = 2; public static final int WIFI_SUPPL_STATE_INACTIVE = 3; public static final int WIFI_SUPPL_STATE_SCANNING = 4; public static final int WIFI_SUPPL_STATE_AUTHENTICATING = 5; public static final int WIFI_SUPPL_STATE_ASSOCIATING = 6; public static final int WIFI_SUPPL_STATE_ASSOCIATED = 7; public static final int WIFI_SUPPL_STATE_FOUR_WAY_HANDSHAKE = 8; public static final int WIFI_SUPPL_STATE_GROUP_HANDSHAKE = 9; public static final int WIFI_SUPPL_STATE_COMPLETED = 10; public static final int WIFI_SUPPL_STATE_DORMANT = 11; public static final int WIFI_SUPPL_STATE_UNINITIALIZED = 12; public static final int NUM_WIFI_SUPPL_STATES = WIFI_SUPPL_STATE_UNINITIALIZED+1; static final String[] WIFI_SUPPL_STATE_NAMES = { "invalid", "disconn", "disabled", "inactive", "scanning", "authenticating", "associating", "associated", "4-way-handshake", "group-handshake", "completed", "dormant", "uninit" }; static final String[] WIFI_SUPPL_STATE_SHORT_NAMES = { "inv", "dsc", "dis", "inact", "scan", "auth", "ascing", "asced", "4-way", "group", "compl", "dorm", "uninit" }; public static final BitDescription[] HISTORY_STATE_DESCRIPTIONS = new BitDescription[] { new BitDescription(HistoryItem.STATE_CPU_RUNNING_FLAG, "running", "r"), new BitDescription(HistoryItem.STATE_WAKE_LOCK_FLAG, "wake_lock", "w"), new BitDescription(HistoryItem.STATE_SENSOR_ON_FLAG, "sensor", "s"), new BitDescription(HistoryItem.STATE_GPS_ON_FLAG, "gps", "g"), new BitDescription(HistoryItem.STATE_WIFI_FULL_LOCK_FLAG, "wifi_full_lock", "Wl"), new BitDescription(HistoryItem.STATE_WIFI_SCAN_FLAG, "wifi_scan", "Ws"), new BitDescription(HistoryItem.STATE_WIFI_MULTICAST_ON_FLAG, "wifi_multicast", "Wm"), new BitDescription(HistoryItem.STATE_WIFI_RADIO_ACTIVE_FLAG, "wifi_radio", "Wr"), new BitDescription(HistoryItem.STATE_MOBILE_RADIO_ACTIVE_FLAG, "mobile_radio", "Pr"), new BitDescription(HistoryItem.STATE_PHONE_SCANNING_FLAG, "phone_scanning", "Psc"), new BitDescription(HistoryItem.STATE_AUDIO_ON_FLAG, "audio", "a"), new BitDescription(HistoryItem.STATE_SCREEN_ON_FLAG, "screen", "S"), new BitDescription(HistoryItem.STATE_BATTERY_PLUGGED_FLAG, "plugged", "BP"), new BitDescription(HistoryItem.STATE_SCREEN_DOZE_FLAG, "screen_doze", "Sd"), new BitDescription(HistoryItem.STATE_DATA_CONNECTION_MASK, HistoryItem.STATE_DATA_CONNECTION_SHIFT, "data_conn", "Pcn", DATA_CONNECTION_NAMES, DATA_CONNECTION_NAMES), new BitDescription(HistoryItem.STATE_PHONE_STATE_MASK, HistoryItem.STATE_PHONE_STATE_SHIFT, "phone_state", "Pst", new String[] {"in", "out", "emergency", "off"}, new String[] {"in", "out", "em", "off"}), new BitDescription(HistoryItem.STATE_PHONE_SIGNAL_STRENGTH_MASK, HistoryItem.STATE_PHONE_SIGNAL_STRENGTH_SHIFT, "phone_signal_strength", "Pss", SignalStrength.SIGNAL_STRENGTH_NAMES, new String[] { "0", "1", "2", "3", "4" }), new BitDescription(HistoryItem.STATE_BRIGHTNESS_MASK, HistoryItem.STATE_BRIGHTNESS_SHIFT, "brightness", "Sb", SCREEN_BRIGHTNESS_NAMES, SCREEN_BRIGHTNESS_SHORT_NAMES), }; public static final BitDescription[] HISTORY_STATE2_DESCRIPTIONS = new BitDescription[] { new BitDescription(HistoryItem.STATE2_POWER_SAVE_FLAG, "power_save", "ps"), new BitDescription(HistoryItem.STATE2_VIDEO_ON_FLAG, "video", "v"), new BitDescription(HistoryItem.STATE2_WIFI_RUNNING_FLAG, "wifi_running", "Ww"), new BitDescription(HistoryItem.STATE2_WIFI_ON_FLAG, "wifi", "W"), new BitDescription(HistoryItem.STATE2_FLASHLIGHT_FLAG, "flashlight", "fl"), new BitDescription(HistoryItem.STATE2_DEVICE_IDLE_MASK, HistoryItem.STATE2_DEVICE_IDLE_SHIFT, "device_idle", "di", new String[] { "off", "light", "full", "???" }, new String[] { "off", "light", "full", "???" }), new BitDescription(HistoryItem.STATE2_CHARGING_FLAG, "charging", "ch"), new BitDescription(HistoryItem.STATE2_PHONE_IN_CALL_FLAG, "phone_in_call", "Pcl"), new BitDescription(HistoryItem.STATE2_BLUETOOTH_ON_FLAG, "bluetooth", "b"), new BitDescription(HistoryItem.STATE2_WIFI_SIGNAL_STRENGTH_MASK, HistoryItem.STATE2_WIFI_SIGNAL_STRENGTH_SHIFT, "wifi_signal_strength", "Wss", new String[] { "0", "1", "2", "3", "4" }, new String[] { "0", "1", "2", "3", "4" }), new BitDescription(HistoryItem.STATE2_WIFI_SUPPL_STATE_MASK, HistoryItem.STATE2_WIFI_SUPPL_STATE_SHIFT, "wifi_suppl", "Wsp", WIFI_SUPPL_STATE_NAMES, WIFI_SUPPL_STATE_SHORT_NAMES), new BitDescription(HistoryItem.STATE2_CAMERA_FLAG, "camera", "ca"), new BitDescription(HistoryItem.STATE2_BLUETOOTH_SCAN_FLAG, "ble_scan", "bles"), new BitDescription(HistoryItem.STATE2_CELLULAR_HIGH_TX_POWER_FLAG, "cellular_high_tx_power", "Chtp"), new BitDescription(HistoryItem.STATE2_GPS_SIGNAL_QUALITY_MASK, HistoryItem.STATE2_GPS_SIGNAL_QUALITY_SHIFT, "gps_signal_quality", "Gss", new String[] { "poor", "good"}, new String[] { "poor", "good"}) }; public static final String[] HISTORY_EVENT_NAMES = new String[] { "null", "proc", "fg", "top", "sync", "wake_lock_in", "job", "user", "userfg", "conn", "active", "pkginst", "pkgunin", "alarm", "stats", "pkginactive", "pkgactive", "tmpwhitelist", "screenwake", "wakeupap", "longwake", "est_capacity" }; public static final String[] HISTORY_EVENT_CHECKIN_NAMES = new String[] { "Enl", "Epr", "Efg", "Etp", "Esy", "Ewl", "Ejb", "Eur", "Euf", "Ecn", "Eac", "Epi", "Epu", "Eal", "Est", "Eai", "Eaa", "Etw", "Esw", "Ewa", "Elw", "Eec" }; @FunctionalInterface public interface IntToString { String applyAsString(int val); } private static final IntToString sUidToString = UserHandle::formatUid; private static final IntToString sIntToString = Integer::toString; public static final IntToString[] HISTORY_EVENT_INT_FORMATTERS = new IntToString[] { sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sUidToString, sIntToString }; /** * Returns total time for WiFi Multicast Wakelock timer. * Note that this may be different from the sum of per uid timer values. * * {@hide} */ public abstract long getWifiMulticastWakelockTime(long elapsedRealtimeUs, int which); /** * Returns total time for WiFi Multicast Wakelock timer * Note that this may be different from the sum of per uid timer values. * * {@hide} */ public abstract int getWifiMulticastWakelockCount(int which); /** * Returns the time in microseconds that wifi has been on while the device was * running on battery. * * {@hide} */ public abstract long getWifiOnTime(long elapsedRealtimeUs, int which); /** * Returns the time in microseconds that wifi has been active while the device was * running on battery. * * {@hide} */ public abstract long getWifiActiveTime(long elapsedRealtimeUs, int which); /** * Returns the time in microseconds that wifi has been on and the driver has * been in the running state while the device was running on battery. * * {@hide} */ public abstract long getGlobalWifiRunningTime(long elapsedRealtimeUs, int which); public static final int WIFI_STATE_OFF = 0; public static final int WIFI_STATE_OFF_SCANNING = 1; public static final int WIFI_STATE_ON_NO_NETWORKS = 2; public static final int WIFI_STATE_ON_DISCONNECTED = 3; public static final int WIFI_STATE_ON_CONNECTED_STA = 4; public static final int WIFI_STATE_ON_CONNECTED_P2P = 5; public static final int WIFI_STATE_ON_CONNECTED_STA_P2P = 6; public static final int WIFI_STATE_SOFT_AP = 7; static final String[] WIFI_STATE_NAMES = { "off", "scanning", "no_net", "disconn", "sta", "p2p", "sta_p2p", "soft_ap" }; public static final int NUM_WIFI_STATES = WIFI_STATE_SOFT_AP+1; /** * Returns the time in microseconds that WiFi has been running in the given state. * * {@hide} */ public abstract long getWifiStateTime(int wifiState, long elapsedRealtimeUs, int which); /** * Returns the number of times that WiFi has entered the given state. * * {@hide} */ public abstract int getWifiStateCount(int wifiState, int which); /** * Returns the {@link Timer} object that tracks the given WiFi state. * * {@hide} */ public abstract Timer getWifiStateTimer(int wifiState); /** * Returns the time in microseconds that the wifi supplicant has been * in a given state. * * {@hide} */ public abstract long getWifiSupplStateTime(int state, long elapsedRealtimeUs, int which); /** * Returns the number of times that the wifi supplicant has transitioned * to a given state. * * {@hide} */ public abstract int getWifiSupplStateCount(int state, int which); /** * Returns the {@link Timer} object that tracks the given wifi supplicant state. * * {@hide} */ public abstract Timer getWifiSupplStateTimer(int state); public static final int NUM_WIFI_SIGNAL_STRENGTH_BINS = 5; /** * Returns the time in microseconds that WIFI has been running with * the given signal strength. * * {@hide} */ public abstract long getWifiSignalStrengthTime(int strengthBin, long elapsedRealtimeUs, int which); /** * Returns the number of times WIFI has entered the given signal strength. * * {@hide} */ public abstract int getWifiSignalStrengthCount(int strengthBin, int which); /** * Returns the {@link Timer} object that tracks the given WIFI signal strength. * * {@hide} */ public abstract Timer getWifiSignalStrengthTimer(int strengthBin); /** * Returns the time in microseconds that the flashlight has been on while the device was * running on battery. * * {@hide} */ public abstract long getFlashlightOnTime(long elapsedRealtimeUs, int which); /** * Returns the number of times that the flashlight has been turned on while the device was * running on battery. * * {@hide} */ public abstract long getFlashlightOnCount(int which); /** * Returns the time in microseconds that the camera has been on while the device was * running on battery. * * {@hide} */ public abstract long getCameraOnTime(long elapsedRealtimeUs, int which); /** * Returns the time in microseconds that bluetooth scans were running while the device was * on battery. * * {@hide} */ public abstract long getBluetoothScanTime(long elapsedRealtimeUs, int which); public static final int NETWORK_MOBILE_RX_DATA = 0; public static final int NETWORK_MOBILE_TX_DATA = 1; public static final int NETWORK_WIFI_RX_DATA = 2; public static final int NETWORK_WIFI_TX_DATA = 3; public static final int NETWORK_BT_RX_DATA = 4; public static final int NETWORK_BT_TX_DATA = 5; public static final int NETWORK_MOBILE_BG_RX_DATA = 6; public static final int NETWORK_MOBILE_BG_TX_DATA = 7; public static final int NETWORK_WIFI_BG_RX_DATA = 8; public static final int NETWORK_WIFI_BG_TX_DATA = 9; public static final int NUM_NETWORK_ACTIVITY_TYPES = NETWORK_WIFI_BG_TX_DATA + 1; public abstract long getNetworkActivityBytes(int type, int which); public abstract long getNetworkActivityPackets(int type, int which); /** * Returns true if the BatteryStats object has detailed WiFi power reports. * When true, calling {@link #getWifiControllerActivity()} will yield the * actual power data. */ public abstract boolean hasWifiActivityReporting(); /** * Returns a {@link ControllerActivityCounter} which is an aggregate of the times spent * in various radio controller states, such as transmit, receive, and idle. * @return non-null {@link ControllerActivityCounter} */ public abstract ControllerActivityCounter getWifiControllerActivity(); /** * Returns true if the BatteryStats object has detailed bluetooth power reports. * When true, calling {@link #getBluetoothControllerActivity()} will yield the * actual power data. */ public abstract boolean hasBluetoothActivityReporting(); /** * Returns a {@link ControllerActivityCounter} which is an aggregate of the times spent * in various radio controller states, such as transmit, receive, and idle. * @return non-null {@link ControllerActivityCounter} */ public abstract ControllerActivityCounter getBluetoothControllerActivity(); /** * Returns true if the BatteryStats object has detailed modem power reports. * When true, calling {@link #getModemControllerActivity()} will yield the * actual power data. */ public abstract boolean hasModemActivityReporting(); /** * Returns a {@link ControllerActivityCounter} which is an aggregate of the times spent * in various radio controller states, such as transmit, receive, and idle. * @return non-null {@link ControllerActivityCounter} */ public abstract ControllerActivityCounter getModemControllerActivity(); /** * Return the wall clock time when battery stats data collection started. */ public abstract long getStartClockTime(); /** * Return platform version tag that we were running in when the battery stats started. */ public abstract String getStartPlatformVersion(); /** * Return platform version tag that we were running in when the battery stats ended. */ public abstract String getEndPlatformVersion(); /** * Return the internal version code of the parcelled format. */ public abstract int getParcelVersion(); /** * Return whether we are currently running on battery. */ public abstract boolean getIsOnBattery(); /** * Returns a SparseArray containing the statistics for each uid. */ public abstract SparseArray getUidStats(); /** * Returns the current battery uptime in microseconds. * * @param curTime the amount of elapsed realtime in microseconds. */ public abstract long getBatteryUptime(long curTime); /** * Returns the current battery realtime in microseconds. * * @param curTime the amount of elapsed realtime in microseconds. */ public abstract long getBatteryRealtime(long curTime); /** * Returns the battery percentage level at the last time the device was unplugged from power, or * the last time it booted on battery power. */ public abstract int getDischargeStartLevel(); /** * Returns the current battery percentage level if we are in a discharge cycle, otherwise * returns the level at the last plug event. */ public abstract int getDischargeCurrentLevel(); /** * Get the amount the battery has discharged since the stats were * last reset after charging, as a lower-end approximation. */ public abstract int getLowDischargeAmountSinceCharge(); /** * Get the amount the battery has discharged since the stats were * last reset after charging, as an upper-end approximation. */ public abstract int getHighDischargeAmountSinceCharge(); /** * Retrieve the discharge amount over the selected discharge period which. */ public abstract int getDischargeAmount(int which); /** * Get the amount the battery has discharged while the screen was on, * since the last time power was unplugged. */ public abstract int getDischargeAmountScreenOn(); /** * Get the amount the battery has discharged while the screen was on, * since the last time the device was charged. */ public abstract int getDischargeAmountScreenOnSinceCharge(); /** * Get the amount the battery has discharged while the screen was off, * since the last time power was unplugged. */ public abstract int getDischargeAmountScreenOff(); /** * Get the amount the battery has discharged while the screen was off, * since the last time the device was charged. */ public abstract int getDischargeAmountScreenOffSinceCharge(); /** * Get the amount the battery has discharged while the screen was dozing, * since the last time power was unplugged. */ public abstract int getDischargeAmountScreenDoze(); /** * Get the amount the battery has discharged while the screen was dozing, * since the last time the device was charged. */ public abstract int getDischargeAmountScreenDozeSinceCharge(); /** * Returns the total, last, or current battery uptime in microseconds. * * @param curTime the elapsed realtime in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long computeBatteryUptime(long curTime, int which); /** * Returns the total, last, or current battery realtime in microseconds. * * @param curTime the current elapsed realtime in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long computeBatteryRealtime(long curTime, int which); /** * Returns the total, last, or current battery screen off/doze uptime in microseconds. * * @param curTime the elapsed realtime in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long computeBatteryScreenOffUptime(long curTime, int which); /** * Returns the total, last, or current battery screen off/doze realtime in microseconds. * * @param curTime the current elapsed realtime in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long computeBatteryScreenOffRealtime(long curTime, int which); /** * Returns the total, last, or current uptime in microseconds. * * @param curTime the current elapsed realtime in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long computeUptime(long curTime, int which); /** * Returns the total, last, or current realtime in microseconds. * * @param curTime the current elapsed realtime in microseconds. * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. */ public abstract long computeRealtime(long curTime, int which); /** * Compute an approximation for how much run time (in microseconds) is remaining on * the battery. Returns -1 if no time can be computed: either there is not * enough current data to make a decision, or the battery is currently * charging. * * @param curTime The current elepsed realtime in microseconds. */ public abstract long computeBatteryTimeRemaining(long curTime); // The part of a step duration that is the actual time. public static final long STEP_LEVEL_TIME_MASK = 0x000000ffffffffffL; // Bits in a step duration that are the new battery level we are at. public static final long STEP_LEVEL_LEVEL_MASK = 0x0000ff0000000000L; public static final int STEP_LEVEL_LEVEL_SHIFT = 40; // Bits in a step duration that are the initial mode we were in at that step. public static final long STEP_LEVEL_INITIAL_MODE_MASK = 0x00ff000000000000L; public static final int STEP_LEVEL_INITIAL_MODE_SHIFT = 48; // Bits in a step duration that indicate which modes changed during that step. public static final long STEP_LEVEL_MODIFIED_MODE_MASK = 0xff00000000000000L; public static final int STEP_LEVEL_MODIFIED_MODE_SHIFT = 56; // Step duration mode: the screen is on, off, dozed, etc; value is Display.STATE_* - 1. public static final int STEP_LEVEL_MODE_SCREEN_STATE = 0x03; // The largest value for screen state that is tracked in battery states. Any values above // this should be mapped back to one of the tracked values before being tracked here. public static final int MAX_TRACKED_SCREEN_STATE = Display.STATE_DOZE_SUSPEND; // Step duration mode: power save is on. public static final int STEP_LEVEL_MODE_POWER_SAVE = 0x04; // Step duration mode: device is currently in idle mode. public static final int STEP_LEVEL_MODE_DEVICE_IDLE = 0x08; public static final int[] STEP_LEVEL_MODES_OF_INTEREST = new int[] { STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE|STEP_LEVEL_MODE_DEVICE_IDLE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_DEVICE_IDLE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_POWER_SAVE|STEP_LEVEL_MODE_DEVICE_IDLE, STEP_LEVEL_MODE_SCREEN_STATE|STEP_LEVEL_MODE_DEVICE_IDLE, }; public static final int[] STEP_LEVEL_MODE_VALUES = new int[] { (Display.STATE_OFF-1), (Display.STATE_OFF-1)|STEP_LEVEL_MODE_POWER_SAVE, (Display.STATE_OFF-1)|STEP_LEVEL_MODE_DEVICE_IDLE, (Display.STATE_ON-1), (Display.STATE_ON-1)|STEP_LEVEL_MODE_POWER_SAVE, (Display.STATE_DOZE-1), (Display.STATE_DOZE-1)|STEP_LEVEL_MODE_POWER_SAVE, (Display.STATE_DOZE_SUSPEND-1), (Display.STATE_DOZE_SUSPEND-1)|STEP_LEVEL_MODE_POWER_SAVE, (Display.STATE_DOZE_SUSPEND-1)|STEP_LEVEL_MODE_DEVICE_IDLE, }; public static final String[] STEP_LEVEL_MODE_LABELS = new String[] { "screen off", "screen off power save", "screen off device idle", "screen on", "screen on power save", "screen doze", "screen doze power save", "screen doze-suspend", "screen doze-suspend power save", "screen doze-suspend device idle", }; /** * Return the amount of battery discharge while the screen was off, measured in * micro-Ampere-hours. This will be non-zero only if the device's battery has * a coulomb counter. */ public abstract long getUahDischargeScreenOff(int which); /** * Return the amount of battery discharge while the screen was in doze mode, measured in * micro-Ampere-hours. This will be non-zero only if the device's battery has * a coulomb counter. */ public abstract long getUahDischargeScreenDoze(int which); /** * Return the amount of battery discharge measured in micro-Ampere-hours. This will be * non-zero only if the device's battery has a coulomb counter. */ public abstract long getUahDischarge(int which); /** * @return the amount of battery discharge while the device is in light idle mode, measured in * micro-Ampere-hours. */ public abstract long getUahDischargeLightDoze(int which); /** * @return the amount of battery discharge while the device is in deep idle mode, measured in * micro-Ampere-hours. */ public abstract long getUahDischargeDeepDoze(int which); /** * Returns the estimated real battery capacity, which may be less than the capacity * declared by the PowerProfile. * @return The estimated battery capacity in mAh. */ public abstract int getEstimatedBatteryCapacity(); /** * @return The minimum learned battery capacity in uAh. */ public abstract int getMinLearnedBatteryCapacity(); /** * @return The maximum learned battery capacity in uAh. */ public abstract int getMaxLearnedBatteryCapacity() ; /** * Return the array of discharge step durations. */ public abstract LevelStepTracker getDischargeLevelStepTracker(); /** * Return the array of daily discharge step durations. */ public abstract LevelStepTracker getDailyDischargeLevelStepTracker(); /** * Compute an approximation for how much time (in microseconds) remains until the battery * is fully charged. Returns -1 if no time can be computed: either there is not * enough current data to make a decision, or the battery is currently * discharging. * * @param curTime The current elepsed realtime in microseconds. */ public abstract long computeChargeTimeRemaining(long curTime); /** * Return the array of charge step durations. */ public abstract LevelStepTracker getChargeLevelStepTracker(); /** * Return the array of daily charge step durations. */ public abstract LevelStepTracker getDailyChargeLevelStepTracker(); public abstract ArrayList getDailyPackageChanges(); public abstract Map getWakeupReasonStats(); public abstract Map getKernelWakelockStats(); /** * Returns Timers tracking the total time of each Resource Power Manager state and voter. */ public abstract Map getRpmStats(); /** * Returns Timers tracking the screen-off time of each Resource Power Manager state and voter. */ public abstract Map getScreenOffRpmStats(); public abstract LongSparseArray getKernelMemoryStats(); public abstract void writeToParcelWithoutUids(Parcel out, int flags); private final static void formatTimeRaw(StringBuilder out, long seconds) { long days = seconds / (60 * 60 * 24); if (days != 0) { out.append(days); out.append("d "); } long used = days * 60 * 60 * 24; long hours = (seconds - used) / (60 * 60); if (hours != 0 || used != 0) { out.append(hours); out.append("h "); } used += hours * 60 * 60; long mins = (seconds-used) / 60; if (mins != 0 || used != 0) { out.append(mins); out.append("m "); } used += mins * 60; if (seconds != 0 || used != 0) { out.append(seconds-used); out.append("s "); } } public final static void formatTimeMs(StringBuilder sb, long time) { long sec = time / 1000; formatTimeRaw(sb, sec); sb.append(time - (sec * 1000)); sb.append("ms "); } public final static void formatTimeMsNoSpace(StringBuilder sb, long time) { long sec = time / 1000; formatTimeRaw(sb, sec); sb.append(time - (sec * 1000)); sb.append("ms"); } public final String formatRatioLocked(long num, long den) { if (den == 0L) { return "--%"; } float perc = ((float)num) / ((float)den) * 100; mFormatBuilder.setLength(0); mFormatter.format("%.1f%%", perc); return mFormatBuilder.toString(); } final String formatBytesLocked(long bytes) { mFormatBuilder.setLength(0); if (bytes < BYTES_PER_KB) { return bytes + "B"; } else if (bytes < BYTES_PER_MB) { mFormatter.format("%.2fKB", bytes / (double) BYTES_PER_KB); return mFormatBuilder.toString(); } else if (bytes < BYTES_PER_GB){ mFormatter.format("%.2fMB", bytes / (double) BYTES_PER_MB); return mFormatBuilder.toString(); } else { mFormatter.format("%.2fGB", bytes / (double) BYTES_PER_GB); return mFormatBuilder.toString(); } } private static long roundUsToMs(long timeUs) { return (timeUs + 500) / 1000; } private static long computeWakeLock(Timer timer, long elapsedRealtimeUs, int which) { if (timer != null) { // Convert from microseconds to milliseconds with rounding long totalTimeMicros = timer.getTotalTimeLocked(elapsedRealtimeUs, which); long totalTimeMillis = (totalTimeMicros + 500) / 1000; return totalTimeMillis; } return 0; } /** * * @param sb a StringBuilder object. * @param timer a Timer object contining the wakelock times. * @param elapsedRealtimeUs the current on-battery time in microseconds. * @param name the name of the wakelock. * @param which which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. * @param linePrefix a String to be prepended to each line of output. * @return the line prefix */ private static final String printWakeLock(StringBuilder sb, Timer timer, long elapsedRealtimeUs, String name, int which, String linePrefix) { if (timer != null) { long totalTimeMillis = computeWakeLock(timer, elapsedRealtimeUs, which); int count = timer.getCountLocked(which); if (totalTimeMillis != 0) { sb.append(linePrefix); formatTimeMs(sb, totalTimeMillis); if (name != null) { sb.append(name); sb.append(' '); } sb.append('('); sb.append(count); sb.append(" times)"); final long maxDurationMs = timer.getMaxDurationMsLocked(elapsedRealtimeUs/1000); if (maxDurationMs >= 0) { sb.append(" max="); sb.append(maxDurationMs); } // Put actual time if it is available and different from totalTimeMillis. final long totalDurMs = timer.getTotalDurationMsLocked(elapsedRealtimeUs/1000); if (totalDurMs > totalTimeMillis) { sb.append(" actual="); sb.append(totalDurMs); } if (timer.isRunningLocked()) { final long currentMs = timer.getCurrentDurationMsLocked(elapsedRealtimeUs/1000); if (currentMs >= 0) { sb.append(" (running for "); sb.append(currentMs); sb.append("ms)"); } else { sb.append(" (running)"); } } return ", "; } } return linePrefix; } /** * Prints details about a timer, if its total time was greater than 0. * * @param pw a PrintWriter object to print to. * @param sb a StringBuilder object. * @param timer a Timer object contining the wakelock times. * @param rawRealtimeUs the current on-battery time in microseconds. * @param which which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. * @param prefix a String to be prepended to each line of output. * @param type the name of the timer. * @return true if anything was printed. */ private static final boolean printTimer(PrintWriter pw, StringBuilder sb, Timer timer, long rawRealtimeUs, int which, String prefix, String type) { if (timer != null) { // Convert from microseconds to milliseconds with rounding final long totalTimeMs = (timer.getTotalTimeLocked( rawRealtimeUs, which) + 500) / 1000; final int count = timer.getCountLocked(which); if (totalTimeMs != 0) { sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(type); sb.append(": "); formatTimeMs(sb, totalTimeMs); sb.append("realtime ("); sb.append(count); sb.append(" times)"); final long maxDurationMs = timer.getMaxDurationMsLocked(rawRealtimeUs/1000); if (maxDurationMs >= 0) { sb.append(" max="); sb.append(maxDurationMs); } if (timer.isRunningLocked()) { final long currentMs = timer.getCurrentDurationMsLocked(rawRealtimeUs/1000); if (currentMs >= 0) { sb.append(" (running for "); sb.append(currentMs); sb.append("ms)"); } else { sb.append(" (running)"); } } pw.println(sb.toString()); return true; } } return false; } /** * Checkin version of wakelock printer. Prints simple comma-separated list. * * @param sb a StringBuilder object. * @param timer a Timer object contining the wakelock times. * @param elapsedRealtimeUs the current time in microseconds. * @param name the name of the wakelock. * @param which which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT. * @param linePrefix a String to be prepended to each line of output. * @return the line prefix */ private static final String printWakeLockCheckin(StringBuilder sb, Timer timer, long elapsedRealtimeUs, String name, int which, String linePrefix) { long totalTimeMicros = 0; int count = 0; long max = 0; long current = 0; long totalDuration = 0; if (timer != null) { totalTimeMicros = timer.getTotalTimeLocked(elapsedRealtimeUs, which); count = timer.getCountLocked(which); current = timer.getCurrentDurationMsLocked(elapsedRealtimeUs/1000); max = timer.getMaxDurationMsLocked(elapsedRealtimeUs/1000); totalDuration = timer.getTotalDurationMsLocked(elapsedRealtimeUs/1000); } sb.append(linePrefix); sb.append((totalTimeMicros + 500) / 1000); // microseconds to milliseconds with rounding sb.append(','); sb.append(name != null ? name + "," : ""); sb.append(count); sb.append(','); sb.append(current); sb.append(','); sb.append(max); // Partial, full, and window wakelocks are pooled, so totalDuration is meaningful (albeit // not always tracked). Kernel wakelocks (which have name == null) have no notion of // totalDuration independent of totalTimeMicros (since they are not pooled). if (name != null) { sb.append(','); sb.append(totalDuration); } return ","; } private static final void dumpLineHeader(PrintWriter pw, int uid, String category, String type) { pw.print(BATTERY_STATS_CHECKIN_VERSION); pw.print(','); pw.print(uid); pw.print(','); pw.print(category); pw.print(','); pw.print(type); } /** * Dump a comma-separated line of values for terse checkin mode. * * @param pw the PageWriter to dump log to * @param category category of data (e.g. "total", "last", "unplugged", "current" ) * @param type type of data (e.g. "wakelock", "sensor", "process", "apk" , "process", "network") * @param args type-dependent data arguments */ private static final void dumpLine(PrintWriter pw, int uid, String category, String type, Object... args ) { dumpLineHeader(pw, uid, category, type); for (Object arg : args) { pw.print(','); pw.print(arg); } pw.println(); } /** * Dump a given timer stat for terse checkin mode. * * @param pw the PageWriter to dump log to * @param uid the UID to log * @param category category of data (e.g. "total", "last", "unplugged", "current" ) * @param type type of data (e.g. "wakelock", "sensor", "process", "apk" , "process", "network") * @param timer a {@link Timer} to dump stats for * @param rawRealtime the current elapsed realtime of the system in microseconds * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT */ private static final void dumpTimer(PrintWriter pw, int uid, String category, String type, Timer timer, long rawRealtime, int which) { if (timer != null) { // Convert from microseconds to milliseconds with rounding final long totalTime = roundUsToMs(timer.getTotalTimeLocked(rawRealtime, which)); final int count = timer.getCountLocked(which); if (totalTime != 0 || count != 0) { dumpLine(pw, uid, category, type, totalTime, count); } } } /** * Dump a given timer stat to the proto stream. * * @param proto the ProtoOutputStream to log to * @param fieldId type of data, the field to save to (e.g. AggregatedBatteryStats.WAKELOCK) * @param timer a {@link Timer} to dump stats for * @param rawRealtimeUs the current elapsed realtime of the system in microseconds * @param which one of STATS_SINCE_CHARGED, STATS_SINCE_UNPLUGGED, or STATS_CURRENT */ private static void dumpTimer(ProtoOutputStream proto, long fieldId, Timer timer, long rawRealtimeUs, int which) { if (timer == null) { return; } // Convert from microseconds to milliseconds with rounding final long timeMs = roundUsToMs(timer.getTotalTimeLocked(rawRealtimeUs, which)); final int count = timer.getCountLocked(which); final long maxDurationMs = timer.getMaxDurationMsLocked(rawRealtimeUs / 1000); final long curDurationMs = timer.getCurrentDurationMsLocked(rawRealtimeUs / 1000); final long totalDurationMs = timer.getTotalDurationMsLocked(rawRealtimeUs / 1000); if (timeMs != 0 || count != 0 || maxDurationMs != -1 || curDurationMs != -1 || totalDurationMs != -1) { final long token = proto.start(fieldId); proto.write(TimerProto.DURATION_MS, timeMs); proto.write(TimerProto.COUNT, count); // These values will be -1 for timers that don't implement the functionality. if (maxDurationMs != -1) { proto.write(TimerProto.MAX_DURATION_MS, maxDurationMs); } if (curDurationMs != -1) { proto.write(TimerProto.CURRENT_DURATION_MS, curDurationMs); } if (totalDurationMs != -1) { proto.write(TimerProto.TOTAL_DURATION_MS, totalDurationMs); } proto.end(token); } } /** * Checks if the ControllerActivityCounter has any data worth dumping. */ private static boolean controllerActivityHasData(ControllerActivityCounter counter, int which) { if (counter == null) { return false; } if (counter.getIdleTimeCounter().getCountLocked(which) != 0 || counter.getRxTimeCounter().getCountLocked(which) != 0 || counter.getPowerCounter().getCountLocked(which) != 0) { return true; } for (LongCounter c : counter.getTxTimeCounters()) { if (c.getCountLocked(which) != 0) { return true; } } return false; } /** * Dumps the ControllerActivityCounter if it has any data worth dumping. * The order of the arguments in the final check in line is: * * idle, rx, power, tx... * * where tx... is one or more transmit level times. */ private static final void dumpControllerActivityLine(PrintWriter pw, int uid, String category, String type, ControllerActivityCounter counter, int which) { if (!controllerActivityHasData(counter, which)) { return; } dumpLineHeader(pw, uid, category, type); pw.print(","); pw.print(counter.getIdleTimeCounter().getCountLocked(which)); pw.print(","); pw.print(counter.getRxTimeCounter().getCountLocked(which)); pw.print(","); pw.print(counter.getPowerCounter().getCountLocked(which) / (1000 * 60 * 60)); for (LongCounter c : counter.getTxTimeCounters()) { pw.print(","); pw.print(c.getCountLocked(which)); } pw.println(); } /** * Dumps the ControllerActivityCounter if it has any data worth dumping. */ private static void dumpControllerActivityProto(ProtoOutputStream proto, long fieldId, ControllerActivityCounter counter, int which) { if (!controllerActivityHasData(counter, which)) { return; } final long cToken = proto.start(fieldId); proto.write(ControllerActivityProto.IDLE_DURATION_MS, counter.getIdleTimeCounter().getCountLocked(which)); proto.write(ControllerActivityProto.RX_DURATION_MS, counter.getRxTimeCounter().getCountLocked(which)); proto.write(ControllerActivityProto.POWER_MAH, counter.getPowerCounter().getCountLocked(which) / (1000 * 60 * 60)); long tToken; LongCounter[] txCounters = counter.getTxTimeCounters(); for (int i = 0; i < txCounters.length; ++i) { LongCounter c = txCounters[i]; tToken = proto.start(ControllerActivityProto.TX); proto.write(ControllerActivityProto.TxLevel.LEVEL, i); proto.write(ControllerActivityProto.TxLevel.DURATION_MS, c.getCountLocked(which)); proto.end(tToken); } proto.end(cToken); } private final void printControllerActivityIfInteresting(PrintWriter pw, StringBuilder sb, String prefix, String controllerName, ControllerActivityCounter counter, int which) { if (controllerActivityHasData(counter, which)) { printControllerActivity(pw, sb, prefix, controllerName, counter, which); } } private final void printControllerActivity(PrintWriter pw, StringBuilder sb, String prefix, String controllerName, ControllerActivityCounter counter, int which) { final long idleTimeMs = counter.getIdleTimeCounter().getCountLocked(which); final long rxTimeMs = counter.getRxTimeCounter().getCountLocked(which); final long powerDrainMaMs = counter.getPowerCounter().getCountLocked(which); // Battery real time final long totalControllerActivityTimeMs = computeBatteryRealtime(SystemClock.elapsedRealtime() * 1000, which) / 1000; long totalTxTimeMs = 0; for (LongCounter txState : counter.getTxTimeCounters()) { totalTxTimeMs += txState.getCountLocked(which); } if (controllerName.equals(WIFI_CONTROLLER_NAME)) { final long scanTimeMs = counter.getScanTimeCounter().getCountLocked(which); sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Scan time: "); formatTimeMs(sb, scanTimeMs); sb.append("("); sb.append(formatRatioLocked(scanTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); final long sleepTimeMs = totalControllerActivityTimeMs - (idleTimeMs + rxTimeMs + totalTxTimeMs); sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Sleep time: "); formatTimeMs(sb, sleepTimeMs); sb.append("("); sb.append(formatRatioLocked(sleepTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); } if (controllerName.equals(CELLULAR_CONTROLLER_NAME)) { final long sleepTimeMs = counter.getSleepTimeCounter().getCountLocked(which); sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Sleep time: "); formatTimeMs(sb, sleepTimeMs); sb.append("("); sb.append(formatRatioLocked(sleepTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); } sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Idle time: "); formatTimeMs(sb, idleTimeMs); sb.append("("); sb.append(formatRatioLocked(idleTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Rx time: "); formatTimeMs(sb, rxTimeMs); sb.append("("); sb.append(formatRatioLocked(rxTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Tx time: "); String [] powerLevel; switch(controllerName) { case CELLULAR_CONTROLLER_NAME: powerLevel = new String[] { " less than 0dBm: ", " 0dBm to 8dBm: ", " 8dBm to 15dBm: ", " 15dBm to 20dBm: ", " above 20dBm: "}; break; default: powerLevel = new String[] {"[0]", "[1]", "[2]", "[3]", "[4]"}; break; } final int numTxLvls = Math.min(counter.getTxTimeCounters().length, powerLevel.length); if (numTxLvls > 1) { pw.println(sb.toString()); for (int lvl = 0; lvl < numTxLvls; lvl++) { final long txLvlTimeMs = counter.getTxTimeCounters()[lvl].getCountLocked(which); sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(powerLevel[lvl]); sb.append(" "); formatTimeMs(sb, txLvlTimeMs); sb.append("("); sb.append(formatRatioLocked(txLvlTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); } } else { final long txLvlTimeMs = counter.getTxTimeCounters()[0].getCountLocked(which); formatTimeMs(sb, txLvlTimeMs); sb.append("("); sb.append(formatRatioLocked(txLvlTimeMs, totalControllerActivityTimeMs)); sb.append(")"); pw.println(sb.toString()); } if (powerDrainMaMs > 0) { sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(controllerName); sb.append(" Battery drain: ").append( BatteryStatsHelper.makemAh(powerDrainMaMs / (double) (1000*60*60))); sb.append("mAh"); pw.println(sb.toString()); } } /** * Temporary for settings. */ public final void dumpCheckinLocked(Context context, PrintWriter pw, int which, int reqUid) { dumpCheckinLocked(context, pw, which, reqUid, BatteryStatsHelper.checkWifiOnly(context)); } /** * Checkin server version of dump to produce more compact, computer-readable log. * * NOTE: all times are expressed in microseconds, unless specified otherwise. */ public final void dumpCheckinLocked(Context context, PrintWriter pw, int which, int reqUid, boolean wifiOnly) { final long rawUptime = SystemClock.uptimeMillis() * 1000; final long rawRealtimeMs = SystemClock.elapsedRealtime(); final long rawRealtime = rawRealtimeMs * 1000; final long batteryUptime = getBatteryUptime(rawUptime); final long whichBatteryUptime = computeBatteryUptime(rawUptime, which); final long whichBatteryRealtime = computeBatteryRealtime(rawRealtime, which); final long whichBatteryScreenOffUptime = computeBatteryScreenOffUptime(rawUptime, which); final long whichBatteryScreenOffRealtime = computeBatteryScreenOffRealtime(rawRealtime, which); final long totalRealtime = computeRealtime(rawRealtime, which); final long totalUptime = computeUptime(rawUptime, which); final long screenOnTime = getScreenOnTime(rawRealtime, which); final long screenDozeTime = getScreenDozeTime(rawRealtime, which); final long interactiveTime = getInteractiveTime(rawRealtime, which); final long powerSaveModeEnabledTime = getPowerSaveModeEnabledTime(rawRealtime, which); final long deviceIdleModeLightTime = getDeviceIdleModeTime(DEVICE_IDLE_MODE_LIGHT, rawRealtime, which); final long deviceIdleModeFullTime = getDeviceIdleModeTime(DEVICE_IDLE_MODE_DEEP, rawRealtime, which); final long deviceLightIdlingTime = getDeviceIdlingTime(DEVICE_IDLE_MODE_LIGHT, rawRealtime, which); final long deviceIdlingTime = getDeviceIdlingTime(DEVICE_IDLE_MODE_DEEP, rawRealtime, which); final int connChanges = getNumConnectivityChange(which); final long phoneOnTime = getPhoneOnTime(rawRealtime, which); final long dischargeCount = getUahDischarge(which); final long dischargeScreenOffCount = getUahDischargeScreenOff(which); final long dischargeScreenDozeCount = getUahDischargeScreenDoze(which); final long dischargeLightDozeCount = getUahDischargeLightDoze(which); final long dischargeDeepDozeCount = getUahDischargeDeepDoze(which); final StringBuilder sb = new StringBuilder(128); final SparseArray uidStats = getUidStats(); final int NU = uidStats.size(); final String category = STAT_NAMES[which]; // Dump "battery" stat dumpLine(pw, 0 /* uid */, category, BATTERY_DATA, which == STATS_SINCE_CHARGED ? getStartCount() : "N/A", whichBatteryRealtime / 1000, whichBatteryUptime / 1000, totalRealtime / 1000, totalUptime / 1000, getStartClockTime(), whichBatteryScreenOffRealtime / 1000, whichBatteryScreenOffUptime / 1000, getEstimatedBatteryCapacity(), getMinLearnedBatteryCapacity(), getMaxLearnedBatteryCapacity(), screenDozeTime / 1000); // Calculate wakelock times across all uids. long fullWakeLockTimeTotal = 0; long partialWakeLockTimeTotal = 0; for (int iu = 0; iu < NU; iu++) { final Uid u = uidStats.valueAt(iu); final ArrayMap wakelocks = u.getWakelockStats(); for (int iw=wakelocks.size()-1; iw>=0; iw--) { final Uid.Wakelock wl = wakelocks.valueAt(iw); final Timer fullWakeTimer = wl.getWakeTime(WAKE_TYPE_FULL); if (fullWakeTimer != null) { fullWakeLockTimeTotal += fullWakeTimer.getTotalTimeLocked(rawRealtime, which); } final Timer partialWakeTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL); if (partialWakeTimer != null) { partialWakeLockTimeTotal += partialWakeTimer.getTotalTimeLocked( rawRealtime, which); } } } // Dump network stats final long mobileRxTotalBytes = getNetworkActivityBytes(NETWORK_MOBILE_RX_DATA, which); final long mobileTxTotalBytes = getNetworkActivityBytes(NETWORK_MOBILE_TX_DATA, which); final long wifiRxTotalBytes = getNetworkActivityBytes(NETWORK_WIFI_RX_DATA, which); final long wifiTxTotalBytes = getNetworkActivityBytes(NETWORK_WIFI_TX_DATA, which); final long mobileRxTotalPackets = getNetworkActivityPackets(NETWORK_MOBILE_RX_DATA, which); final long mobileTxTotalPackets = getNetworkActivityPackets(NETWORK_MOBILE_TX_DATA, which); final long wifiRxTotalPackets = getNetworkActivityPackets(NETWORK_WIFI_RX_DATA, which); final long wifiTxTotalPackets = getNetworkActivityPackets(NETWORK_WIFI_TX_DATA, which); final long btRxTotalBytes = getNetworkActivityBytes(NETWORK_BT_RX_DATA, which); final long btTxTotalBytes = getNetworkActivityBytes(NETWORK_BT_TX_DATA, which); dumpLine(pw, 0 /* uid */, category, GLOBAL_NETWORK_DATA, mobileRxTotalBytes, mobileTxTotalBytes, wifiRxTotalBytes, wifiTxTotalBytes, mobileRxTotalPackets, mobileTxTotalPackets, wifiRxTotalPackets, wifiTxTotalPackets, btRxTotalBytes, btTxTotalBytes); // Dump Modem controller stats dumpControllerActivityLine(pw, 0 /* uid */, category, GLOBAL_MODEM_CONTROLLER_DATA, getModemControllerActivity(), which); // Dump Wifi controller stats final long wifiOnTime = getWifiOnTime(rawRealtime, which); final long wifiRunningTime = getGlobalWifiRunningTime(rawRealtime, which); dumpLine(pw, 0 /* uid */, category, GLOBAL_WIFI_DATA, wifiOnTime / 1000, wifiRunningTime / 1000, /* legacy fields follow, keep at 0 */ 0, 0, 0); dumpControllerActivityLine(pw, 0 /* uid */, category, GLOBAL_WIFI_CONTROLLER_DATA, getWifiControllerActivity(), which); // Dump Bluetooth controller stats dumpControllerActivityLine(pw, 0 /* uid */, category, GLOBAL_BLUETOOTH_CONTROLLER_DATA, getBluetoothControllerActivity(), which); // Dump misc stats dumpLine(pw, 0 /* uid */, category, MISC_DATA, screenOnTime / 1000, phoneOnTime / 1000, fullWakeLockTimeTotal / 1000, partialWakeLockTimeTotal / 1000, getMobileRadioActiveTime(rawRealtime, which) / 1000, getMobileRadioActiveAdjustedTime(which) / 1000, interactiveTime / 1000, powerSaveModeEnabledTime / 1000, connChanges, deviceIdleModeFullTime / 1000, getDeviceIdleModeCount(DEVICE_IDLE_MODE_DEEP, which), deviceIdlingTime / 1000, getDeviceIdlingCount(DEVICE_IDLE_MODE_DEEP, which), getMobileRadioActiveCount(which), getMobileRadioActiveUnknownTime(which) / 1000, deviceIdleModeLightTime / 1000, getDeviceIdleModeCount(DEVICE_IDLE_MODE_LIGHT, which), deviceLightIdlingTime / 1000, getDeviceIdlingCount(DEVICE_IDLE_MODE_LIGHT, which), getLongestDeviceIdleModeTime(DEVICE_IDLE_MODE_LIGHT), getLongestDeviceIdleModeTime(DEVICE_IDLE_MODE_DEEP)); // Dump screen brightness stats Object[] args = new Object[NUM_SCREEN_BRIGHTNESS_BINS]; for (int i=0; i kernelWakelocks = getKernelWakelockStats(); if (kernelWakelocks.size() > 0) { for (Map.Entry ent : kernelWakelocks.entrySet()) { sb.setLength(0); printWakeLockCheckin(sb, ent.getValue(), rawRealtime, null, which, ""); dumpLine(pw, 0 /* uid */, category, KERNEL_WAKELOCK_DATA, "\"" + ent.getKey() + "\"", sb.toString()); } } final Map wakeupReasons = getWakeupReasonStats(); if (wakeupReasons.size() > 0) { for (Map.Entry ent : wakeupReasons.entrySet()) { // Not doing the regular wake lock formatting to remain compatible // with the old checkin format. long totalTimeMicros = ent.getValue().getTotalTimeLocked(rawRealtime, which); int count = ent.getValue().getCountLocked(which); dumpLine(pw, 0 /* uid */, category, WAKEUP_REASON_DATA, "\"" + ent.getKey() + "\"", (totalTimeMicros + 500) / 1000, count); } } } final Map rpmStats = getRpmStats(); final Map screenOffRpmStats = getScreenOffRpmStats(); if (rpmStats.size() > 0) { for (Map.Entry ent : rpmStats.entrySet()) { sb.setLength(0); Timer totalTimer = ent.getValue(); long timeMs = (totalTimer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; int count = totalTimer.getCountLocked(which); Timer screenOffTimer = screenOffRpmStats.get(ent.getKey()); long screenOffTimeMs = screenOffTimer != null ? (screenOffTimer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000 : 0; int screenOffCount = screenOffTimer != null ? screenOffTimer.getCountLocked(which) : 0; if (SCREEN_OFF_RPM_STATS_ENABLED) { dumpLine(pw, 0 /* uid */, category, RESOURCE_POWER_MANAGER_DATA, "\"" + ent.getKey() + "\"", timeMs, count, screenOffTimeMs, screenOffCount); } else { dumpLine(pw, 0 /* uid */, category, RESOURCE_POWER_MANAGER_DATA, "\"" + ent.getKey() + "\"", timeMs, count); } } } final BatteryStatsHelper helper = new BatteryStatsHelper(context, false, wifiOnly); helper.create(this); helper.refreshStats(which, UserHandle.USER_ALL); final List sippers = helper.getUsageList(); if (sippers != null && sippers.size() > 0) { dumpLine(pw, 0 /* uid */, category, POWER_USE_SUMMARY_DATA, BatteryStatsHelper.makemAh(helper.getPowerProfile().getBatteryCapacity()), BatteryStatsHelper.makemAh(helper.getComputedPower()), BatteryStatsHelper.makemAh(helper.getMinDrainedPower()), BatteryStatsHelper.makemAh(helper.getMaxDrainedPower())); int uid = 0; for (int i=0; i= 0 && uid != reqUid) { continue; } final Uid u = uidStats.valueAt(iu); // Dump Network stats per uid, if any final long mobileBytesRx = u.getNetworkActivityBytes(NETWORK_MOBILE_RX_DATA, which); final long mobileBytesTx = u.getNetworkActivityBytes(NETWORK_MOBILE_TX_DATA, which); final long wifiBytesRx = u.getNetworkActivityBytes(NETWORK_WIFI_RX_DATA, which); final long wifiBytesTx = u.getNetworkActivityBytes(NETWORK_WIFI_TX_DATA, which); final long mobilePacketsRx = u.getNetworkActivityPackets(NETWORK_MOBILE_RX_DATA, which); final long mobilePacketsTx = u.getNetworkActivityPackets(NETWORK_MOBILE_TX_DATA, which); final long mobileActiveTime = u.getMobileRadioActiveTime(which); final int mobileActiveCount = u.getMobileRadioActiveCount(which); final long mobileWakeup = u.getMobileRadioApWakeupCount(which); final long wifiPacketsRx = u.getNetworkActivityPackets(NETWORK_WIFI_RX_DATA, which); final long wifiPacketsTx = u.getNetworkActivityPackets(NETWORK_WIFI_TX_DATA, which); final long wifiWakeup = u.getWifiRadioApWakeupCount(which); final long btBytesRx = u.getNetworkActivityBytes(NETWORK_BT_RX_DATA, which); final long btBytesTx = u.getNetworkActivityBytes(NETWORK_BT_TX_DATA, which); // Background data transfers final long mobileBytesBgRx = u.getNetworkActivityBytes(NETWORK_MOBILE_BG_RX_DATA, which); final long mobileBytesBgTx = u.getNetworkActivityBytes(NETWORK_MOBILE_BG_TX_DATA, which); final long wifiBytesBgRx = u.getNetworkActivityBytes(NETWORK_WIFI_BG_RX_DATA, which); final long wifiBytesBgTx = u.getNetworkActivityBytes(NETWORK_WIFI_BG_TX_DATA, which); final long mobilePacketsBgRx = u.getNetworkActivityPackets(NETWORK_MOBILE_BG_RX_DATA, which); final long mobilePacketsBgTx = u.getNetworkActivityPackets(NETWORK_MOBILE_BG_TX_DATA, which); final long wifiPacketsBgRx = u.getNetworkActivityPackets(NETWORK_WIFI_BG_RX_DATA, which); final long wifiPacketsBgTx = u.getNetworkActivityPackets(NETWORK_WIFI_BG_TX_DATA, which); if (mobileBytesRx > 0 || mobileBytesTx > 0 || wifiBytesRx > 0 || wifiBytesTx > 0 || mobilePacketsRx > 0 || mobilePacketsTx > 0 || wifiPacketsRx > 0 || wifiPacketsTx > 0 || mobileActiveTime > 0 || mobileActiveCount > 0 || btBytesRx > 0 || btBytesTx > 0 || mobileWakeup > 0 || wifiWakeup > 0 || mobileBytesBgRx > 0 || mobileBytesBgTx > 0 || wifiBytesBgRx > 0 || wifiBytesBgTx > 0 || mobilePacketsBgRx > 0 || mobilePacketsBgTx > 0 || wifiPacketsBgRx > 0 || wifiPacketsBgTx > 0) { dumpLine(pw, uid, category, NETWORK_DATA, mobileBytesRx, mobileBytesTx, wifiBytesRx, wifiBytesTx, mobilePacketsRx, mobilePacketsTx, wifiPacketsRx, wifiPacketsTx, mobileActiveTime, mobileActiveCount, btBytesRx, btBytesTx, mobileWakeup, wifiWakeup, mobileBytesBgRx, mobileBytesBgTx, wifiBytesBgRx, wifiBytesBgTx, mobilePacketsBgRx, mobilePacketsBgTx, wifiPacketsBgRx, wifiPacketsBgTx ); } // Dump modem controller data, per UID. dumpControllerActivityLine(pw, uid, category, MODEM_CONTROLLER_DATA, u.getModemControllerActivity(), which); // Dump Wifi controller data, per UID. final long fullWifiLockOnTime = u.getFullWifiLockTime(rawRealtime, which); final long wifiScanTime = u.getWifiScanTime(rawRealtime, which); final int wifiScanCount = u.getWifiScanCount(which); final int wifiScanCountBg = u.getWifiScanBackgroundCount(which); // Note that 'ActualTime' are unpooled and always since reset (regardless of 'which') final long wifiScanActualTimeMs = (u.getWifiScanActualTime(rawRealtime) + 500) / 1000; final long wifiScanActualTimeMsBg = (u.getWifiScanBackgroundTime(rawRealtime) + 500) / 1000; final long uidWifiRunningTime = u.getWifiRunningTime(rawRealtime, which); if (fullWifiLockOnTime != 0 || wifiScanTime != 0 || wifiScanCount != 0 || wifiScanCountBg != 0 || wifiScanActualTimeMs != 0 || wifiScanActualTimeMsBg != 0 || uidWifiRunningTime != 0) { dumpLine(pw, uid, category, WIFI_DATA, fullWifiLockOnTime, wifiScanTime, uidWifiRunningTime, wifiScanCount, /* legacy fields follow, keep at 0 */ 0, 0, 0, wifiScanCountBg, wifiScanActualTimeMs, wifiScanActualTimeMsBg); } dumpControllerActivityLine(pw, uid, category, WIFI_CONTROLLER_DATA, u.getWifiControllerActivity(), which); final Timer bleTimer = u.getBluetoothScanTimer(); if (bleTimer != null) { // Convert from microseconds to milliseconds with rounding final long totalTime = (bleTimer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; if (totalTime != 0) { final int count = bleTimer.getCountLocked(which); final Timer bleTimerBg = u.getBluetoothScanBackgroundTimer(); final int countBg = bleTimerBg != null ? bleTimerBg.getCountLocked(which) : 0; // 'actualTime' are unpooled and always since reset (regardless of 'which') final long actualTime = bleTimer.getTotalDurationMsLocked(rawRealtimeMs); final long actualTimeBg = bleTimerBg != null ? bleTimerBg.getTotalDurationMsLocked(rawRealtimeMs) : 0; // Result counters final int resultCount = u.getBluetoothScanResultCounter() != null ? u.getBluetoothScanResultCounter().getCountLocked(which) : 0; final int resultCountBg = u.getBluetoothScanResultBgCounter() != null ? u.getBluetoothScanResultBgCounter().getCountLocked(which) : 0; // Unoptimized scan timer. Unpooled and since reset (regardless of 'which'). final Timer unoptimizedScanTimer = u.getBluetoothUnoptimizedScanTimer(); final long unoptimizedScanTotalTime = unoptimizedScanTimer != null ? unoptimizedScanTimer.getTotalDurationMsLocked(rawRealtimeMs) : 0; final long unoptimizedScanMaxTime = unoptimizedScanTimer != null ? unoptimizedScanTimer.getMaxDurationMsLocked(rawRealtimeMs) : 0; // Unoptimized bg scan timer. Unpooled and since reset (regardless of 'which'). final Timer unoptimizedScanTimerBg = u.getBluetoothUnoptimizedScanBackgroundTimer(); final long unoptimizedScanTotalTimeBg = unoptimizedScanTimerBg != null ? unoptimizedScanTimerBg.getTotalDurationMsLocked(rawRealtimeMs) : 0; final long unoptimizedScanMaxTimeBg = unoptimizedScanTimerBg != null ? unoptimizedScanTimerBg.getMaxDurationMsLocked(rawRealtimeMs) : 0; dumpLine(pw, uid, category, BLUETOOTH_MISC_DATA, totalTime, count, countBg, actualTime, actualTimeBg, resultCount, resultCountBg, unoptimizedScanTotalTime, unoptimizedScanTotalTimeBg, unoptimizedScanMaxTime, unoptimizedScanMaxTimeBg); } } dumpControllerActivityLine(pw, uid, category, BLUETOOTH_CONTROLLER_DATA, u.getBluetoothControllerActivity(), which); if (u.hasUserActivity()) { args = new Object[Uid.NUM_USER_ACTIVITY_TYPES]; boolean hasData = false; for (int i=0; i wakelocks = u.getWakelockStats(); for (int iw=wakelocks.size()-1; iw>=0; iw--) { final Uid.Wakelock wl = wakelocks.valueAt(iw); String linePrefix = ""; sb.setLength(0); linePrefix = printWakeLockCheckin(sb, wl.getWakeTime(WAKE_TYPE_FULL), rawRealtime, "f", which, linePrefix); final Timer pTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL); linePrefix = printWakeLockCheckin(sb, pTimer, rawRealtime, "p", which, linePrefix); linePrefix = printWakeLockCheckin(sb, pTimer != null ? pTimer.getSubTimer() : null, rawRealtime, "bp", which, linePrefix); linePrefix = printWakeLockCheckin(sb, wl.getWakeTime(WAKE_TYPE_WINDOW), rawRealtime, "w", which, linePrefix); // Only log if we had at least one wakelock... if (sb.length() > 0) { String name = wakelocks.keyAt(iw); if (name.indexOf(',') >= 0) { name = name.replace(',', '_'); } if (name.indexOf('\n') >= 0) { name = name.replace('\n', '_'); } if (name.indexOf('\r') >= 0) { name = name.replace('\r', '_'); } dumpLine(pw, uid, category, WAKELOCK_DATA, name, sb.toString()); } } // WiFi Multicast Wakelock Statistics final Timer mcTimer = u.getMulticastWakelockStats(); if (mcTimer != null) { final long totalMcWakelockTimeMs = mcTimer.getTotalTimeLocked(rawRealtime, which) / 1000 ; final int countMcWakelock = mcTimer.getCountLocked(which); if(totalMcWakelockTimeMs > 0) { dumpLine(pw, uid, category, WIFI_MULTICAST_DATA, totalMcWakelockTimeMs, countMcWakelock); } } final ArrayMap syncs = u.getSyncStats(); for (int isy=syncs.size()-1; isy>=0; isy--) { final Timer timer = syncs.valueAt(isy); // Convert from microseconds to milliseconds with rounding final long totalTime = (timer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; final int count = timer.getCountLocked(which); final Timer bgTimer = timer.getSubTimer(); final long bgTime = bgTimer != null ? bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : -1; final int bgCount = bgTimer != null ? bgTimer.getCountLocked(which) : -1; if (totalTime != 0) { dumpLine(pw, uid, category, SYNC_DATA, "\"" + syncs.keyAt(isy) + "\"", totalTime, count, bgTime, bgCount); } } final ArrayMap jobs = u.getJobStats(); for (int ij=jobs.size()-1; ij>=0; ij--) { final Timer timer = jobs.valueAt(ij); // Convert from microseconds to milliseconds with rounding final long totalTime = (timer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; final int count = timer.getCountLocked(which); final Timer bgTimer = timer.getSubTimer(); final long bgTime = bgTimer != null ? bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : -1; final int bgCount = bgTimer != null ? bgTimer.getCountLocked(which) : -1; if (totalTime != 0) { dumpLine(pw, uid, category, JOB_DATA, "\"" + jobs.keyAt(ij) + "\"", totalTime, count, bgTime, bgCount); } } final ArrayMap completions = u.getJobCompletionStats(); for (int ic=completions.size()-1; ic>=0; ic--) { SparseIntArray types = completions.valueAt(ic); if (types != null) { dumpLine(pw, uid, category, JOB_COMPLETION_DATA, "\"" + completions.keyAt(ic) + "\"", types.get(JobParameters.REASON_CANCELED, 0), types.get(JobParameters.REASON_CONSTRAINTS_NOT_SATISFIED, 0), types.get(JobParameters.REASON_PREEMPT, 0), types.get(JobParameters.REASON_TIMEOUT, 0), types.get(JobParameters.REASON_DEVICE_IDLE, 0)); } } // Dump deferred jobs stats u.getDeferredJobsCheckinLineLocked(sb, which); if (sb.length() > 0) { dumpLine(pw, uid, category, JOBS_DEFERRED_DATA, sb.toString()); } dumpTimer(pw, uid, category, FLASHLIGHT_DATA, u.getFlashlightTurnedOnTimer(), rawRealtime, which); dumpTimer(pw, uid, category, CAMERA_DATA, u.getCameraTurnedOnTimer(), rawRealtime, which); dumpTimer(pw, uid, category, VIDEO_DATA, u.getVideoTurnedOnTimer(), rawRealtime, which); dumpTimer(pw, uid, category, AUDIO_DATA, u.getAudioTurnedOnTimer(), rawRealtime, which); final SparseArray sensors = u.getSensorStats(); final int NSE = sensors.size(); for (int ise=0; ise 0) { dumpLine(pw, uid, category, STATE_TIME_DATA, stateTimes); } final long userCpuTimeUs = u.getUserCpuTimeUs(which); final long systemCpuTimeUs = u.getSystemCpuTimeUs(which); if (userCpuTimeUs > 0 || systemCpuTimeUs > 0) { dumpLine(pw, uid, category, CPU_DATA, userCpuTimeUs / 1000, systemCpuTimeUs / 1000, 0 /* old cpu power, keep for compatibility */); } // If the cpuFreqs is null, then don't bother checking for cpu freq times. if (cpuFreqs != null) { final long[] cpuFreqTimeMs = u.getCpuFreqTimes(which); // If total cpuFreqTimes is null, then we don't need to check for // screenOffCpuFreqTimes. if (cpuFreqTimeMs != null && cpuFreqTimeMs.length == cpuFreqs.length) { sb.setLength(0); for (int i = 0; i < cpuFreqTimeMs.length; ++i) { sb.append((i == 0 ? "" : ",") + cpuFreqTimeMs[i]); } final long[] screenOffCpuFreqTimeMs = u.getScreenOffCpuFreqTimes(which); if (screenOffCpuFreqTimeMs != null) { for (int i = 0; i < screenOffCpuFreqTimeMs.length; ++i) { sb.append("," + screenOffCpuFreqTimeMs[i]); } } else { for (int i = 0; i < cpuFreqTimeMs.length; ++i) { sb.append(",0"); } } dumpLine(pw, uid, category, CPU_TIMES_AT_FREQ_DATA, UID_TIMES_TYPE_ALL, cpuFreqTimeMs.length, sb.toString()); } for (int procState = 0; procState < Uid.NUM_PROCESS_STATE; ++procState) { final long[] timesMs = u.getCpuFreqTimes(which, procState); if (timesMs != null && timesMs.length == cpuFreqs.length) { sb.setLength(0); for (int i = 0; i < timesMs.length; ++i) { sb.append((i == 0 ? "" : ",") + timesMs[i]); } final long[] screenOffTimesMs = u.getScreenOffCpuFreqTimes( which, procState); if (screenOffTimesMs != null) { for (int i = 0; i < screenOffTimesMs.length; ++i) { sb.append("," + screenOffTimesMs[i]); } } else { for (int i = 0; i < timesMs.length; ++i) { sb.append(",0"); } } dumpLine(pw, uid, category, CPU_TIMES_AT_FREQ_DATA, Uid.UID_PROCESS_TYPES[procState], timesMs.length, sb.toString()); } } } final ArrayMap processStats = u.getProcessStats(); for (int ipr=processStats.size()-1; ipr>=0; ipr--) { final Uid.Proc ps = processStats.valueAt(ipr); final long userMillis = ps.getUserTime(which); final long systemMillis = ps.getSystemTime(which); final long foregroundMillis = ps.getForegroundTime(which); final int starts = ps.getStarts(which); final int numCrashes = ps.getNumCrashes(which); final int numAnrs = ps.getNumAnrs(which); if (userMillis != 0 || systemMillis != 0 || foregroundMillis != 0 || starts != 0 || numAnrs != 0 || numCrashes != 0) { dumpLine(pw, uid, category, PROCESS_DATA, "\"" + processStats.keyAt(ipr) + "\"", userMillis, systemMillis, foregroundMillis, starts, numAnrs, numCrashes); } } final ArrayMap packageStats = u.getPackageStats(); for (int ipkg=packageStats.size()-1; ipkg>=0; ipkg--) { final Uid.Pkg ps = packageStats.valueAt(ipkg); int wakeups = 0; final ArrayMap alarms = ps.getWakeupAlarmStats(); for (int iwa=alarms.size()-1; iwa>=0; iwa--) { int count = alarms.valueAt(iwa).getCountLocked(which); wakeups += count; String name = alarms.keyAt(iwa).replace(',', '_'); dumpLine(pw, uid, category, WAKEUP_ALARM_DATA, name, count); } final ArrayMap serviceStats = ps.getServiceStats(); for (int isvc=serviceStats.size()-1; isvc>=0; isvc--) { final BatteryStats.Uid.Pkg.Serv ss = serviceStats.valueAt(isvc); final long startTime = ss.getStartTime(batteryUptime, which); final int starts = ss.getStarts(which); final int launches = ss.getLaunches(which); if (startTime != 0 || starts != 0 || launches != 0) { dumpLine(pw, uid, category, APK_DATA, wakeups, // wakeup alarms packageStats.keyAt(ipkg), // Apk serviceStats.keyAt(isvc), // service startTime / 1000, // time spent started, in ms starts, launches); } } } } } static final class TimerEntry { final String mName; final int mId; final BatteryStats.Timer mTimer; final long mTime; TimerEntry(String name, int id, BatteryStats.Timer timer, long time) { mName = name; mId = id; mTimer = timer; mTime = time; } } private void printmAh(PrintWriter printer, double power) { printer.print(BatteryStatsHelper.makemAh(power)); } private void printmAh(StringBuilder sb, double power) { sb.append(BatteryStatsHelper.makemAh(power)); } /** * Temporary for settings. */ public final void dumpLocked(Context context, PrintWriter pw, String prefix, int which, int reqUid) { dumpLocked(context, pw, prefix, which, reqUid, BatteryStatsHelper.checkWifiOnly(context)); } @SuppressWarnings("unused") public final void dumpLocked(Context context, PrintWriter pw, String prefix, final int which, int reqUid, boolean wifiOnly) { final long rawUptime = SystemClock.uptimeMillis() * 1000; final long rawRealtime = SystemClock.elapsedRealtime() * 1000; final long rawRealtimeMs = (rawRealtime + 500) / 1000; final long batteryUptime = getBatteryUptime(rawUptime); final long whichBatteryUptime = computeBatteryUptime(rawUptime, which); final long whichBatteryRealtime = computeBatteryRealtime(rawRealtime, which); final long totalRealtime = computeRealtime(rawRealtime, which); final long totalUptime = computeUptime(rawUptime, which); final long whichBatteryScreenOffUptime = computeBatteryScreenOffUptime(rawUptime, which); final long whichBatteryScreenOffRealtime = computeBatteryScreenOffRealtime(rawRealtime, which); final long batteryTimeRemaining = computeBatteryTimeRemaining(rawRealtime); final long chargeTimeRemaining = computeChargeTimeRemaining(rawRealtime); final long screenDozeTime = getScreenDozeTime(rawRealtime, which); final StringBuilder sb = new StringBuilder(128); final SparseArray uidStats = getUidStats(); final int NU = uidStats.size(); final int estimatedBatteryCapacity = getEstimatedBatteryCapacity(); if (estimatedBatteryCapacity > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Estimated battery capacity: "); sb.append(BatteryStatsHelper.makemAh(estimatedBatteryCapacity)); sb.append(" mAh"); pw.println(sb.toString()); } final int minLearnedBatteryCapacity = getMinLearnedBatteryCapacity(); if (minLearnedBatteryCapacity > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Min learned battery capacity: "); sb.append(BatteryStatsHelper.makemAh(minLearnedBatteryCapacity / 1000)); sb.append(" mAh"); pw.println(sb.toString()); } final int maxLearnedBatteryCapacity = getMaxLearnedBatteryCapacity(); if (maxLearnedBatteryCapacity > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Max learned battery capacity: "); sb.append(BatteryStatsHelper.makemAh(maxLearnedBatteryCapacity / 1000)); sb.append(" mAh"); pw.println(sb.toString()); } sb.setLength(0); sb.append(prefix); sb.append(" Time on battery: "); formatTimeMs(sb, whichBatteryRealtime / 1000); sb.append("("); sb.append(formatRatioLocked(whichBatteryRealtime, totalRealtime)); sb.append(") realtime, "); formatTimeMs(sb, whichBatteryUptime / 1000); sb.append("("); sb.append(formatRatioLocked(whichBatteryUptime, whichBatteryRealtime)); sb.append(") uptime"); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" Time on battery screen off: "); formatTimeMs(sb, whichBatteryScreenOffRealtime / 1000); sb.append("("); sb.append(formatRatioLocked(whichBatteryScreenOffRealtime, whichBatteryRealtime)); sb.append(") realtime, "); formatTimeMs(sb, whichBatteryScreenOffUptime / 1000); sb.append("("); sb.append(formatRatioLocked(whichBatteryScreenOffUptime, whichBatteryRealtime)); sb.append(") uptime"); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" Time on battery screen doze: "); formatTimeMs(sb, screenDozeTime / 1000); sb.append("("); sb.append(formatRatioLocked(screenDozeTime, whichBatteryRealtime)); sb.append(")"); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" Total run time: "); formatTimeMs(sb, totalRealtime / 1000); sb.append("realtime, "); formatTimeMs(sb, totalUptime / 1000); sb.append("uptime"); pw.println(sb.toString()); if (batteryTimeRemaining >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Battery time remaining: "); formatTimeMs(sb, batteryTimeRemaining / 1000); pw.println(sb.toString()); } if (chargeTimeRemaining >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Charge time remaining: "); formatTimeMs(sb, chargeTimeRemaining / 1000); pw.println(sb.toString()); } final long dischargeCount = getUahDischarge(which); if (dischargeCount >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Discharge: "); sb.append(BatteryStatsHelper.makemAh(dischargeCount / 1000.0)); sb.append(" mAh"); pw.println(sb.toString()); } final long dischargeScreenOffCount = getUahDischargeScreenOff(which); if (dischargeScreenOffCount >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Screen off discharge: "); sb.append(BatteryStatsHelper.makemAh(dischargeScreenOffCount / 1000.0)); sb.append(" mAh"); pw.println(sb.toString()); } final long dischargeScreenDozeCount = getUahDischargeScreenDoze(which); if (dischargeScreenDozeCount >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Screen doze discharge: "); sb.append(BatteryStatsHelper.makemAh(dischargeScreenDozeCount / 1000.0)); sb.append(" mAh"); pw.println(sb.toString()); } final long dischargeScreenOnCount = dischargeCount - dischargeScreenOffCount - dischargeScreenDozeCount; if (dischargeScreenOnCount >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Screen on discharge: "); sb.append(BatteryStatsHelper.makemAh(dischargeScreenOnCount / 1000.0)); sb.append(" mAh"); pw.println(sb.toString()); } final long dischargeLightDozeCount = getUahDischargeLightDoze(which); if (dischargeLightDozeCount >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Device light doze discharge: "); sb.append(BatteryStatsHelper.makemAh(dischargeLightDozeCount / 1000.0)); sb.append(" mAh"); pw.println(sb.toString()); } final long dischargeDeepDozeCount = getUahDischargeDeepDoze(which); if (dischargeDeepDozeCount >= 0) { sb.setLength(0); sb.append(prefix); sb.append(" Device deep doze discharge: "); sb.append(BatteryStatsHelper.makemAh(dischargeDeepDozeCount / 1000.0)); sb.append(" mAh"); pw.println(sb.toString()); } pw.print(" Start clock time: "); pw.println(DateFormat.format("yyyy-MM-dd-HH-mm-ss", getStartClockTime()).toString()); final long screenOnTime = getScreenOnTime(rawRealtime, which); final long interactiveTime = getInteractiveTime(rawRealtime, which); final long powerSaveModeEnabledTime = getPowerSaveModeEnabledTime(rawRealtime, which); final long deviceIdleModeLightTime = getDeviceIdleModeTime(DEVICE_IDLE_MODE_LIGHT, rawRealtime, which); final long deviceIdleModeFullTime = getDeviceIdleModeTime(DEVICE_IDLE_MODE_DEEP, rawRealtime, which); final long deviceLightIdlingTime = getDeviceIdlingTime(DEVICE_IDLE_MODE_LIGHT, rawRealtime, which); final long deviceIdlingTime = getDeviceIdlingTime(DEVICE_IDLE_MODE_DEEP, rawRealtime, which); final long phoneOnTime = getPhoneOnTime(rawRealtime, which); final long wifiRunningTime = getGlobalWifiRunningTime(rawRealtime, which); final long wifiOnTime = getWifiOnTime(rawRealtime, which); sb.setLength(0); sb.append(prefix); sb.append(" Screen on: "); formatTimeMs(sb, screenOnTime / 1000); sb.append("("); sb.append(formatRatioLocked(screenOnTime, whichBatteryRealtime)); sb.append(") "); sb.append(getScreenOnCount(which)); sb.append("x, Interactive: "); formatTimeMs(sb, interactiveTime / 1000); sb.append("("); sb.append(formatRatioLocked(interactiveTime, whichBatteryRealtime)); sb.append(")"); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" Screen brightnesses:"); boolean didOne = false; for (int i=0; i timers = new ArrayList<>(); for (int iu = 0; iu < NU; iu++) { final Uid u = uidStats.valueAt(iu); final ArrayMap wakelocks = u.getWakelockStats(); for (int iw=wakelocks.size()-1; iw>=0; iw--) { final Uid.Wakelock wl = wakelocks.valueAt(iw); final Timer fullWakeTimer = wl.getWakeTime(WAKE_TYPE_FULL); if (fullWakeTimer != null) { fullWakeLockTimeTotalMicros += fullWakeTimer.getTotalTimeLocked( rawRealtime, which); } final Timer partialWakeTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL); if (partialWakeTimer != null) { final long totalTimeMicros = partialWakeTimer.getTotalTimeLocked( rawRealtime, which); if (totalTimeMicros > 0) { if (reqUid < 0) { // Only show the ordered list of all wake // locks if the caller is not asking for data // about a specific uid. timers.add(new TimerEntry(wakelocks.keyAt(iw), u.getUid(), partialWakeTimer, totalTimeMicros)); } partialWakeLockTimeTotalMicros += totalTimeMicros; } } } } final long mobileRxTotalBytes = getNetworkActivityBytes(NETWORK_MOBILE_RX_DATA, which); final long mobileTxTotalBytes = getNetworkActivityBytes(NETWORK_MOBILE_TX_DATA, which); final long wifiRxTotalBytes = getNetworkActivityBytes(NETWORK_WIFI_RX_DATA, which); final long wifiTxTotalBytes = getNetworkActivityBytes(NETWORK_WIFI_TX_DATA, which); final long mobileRxTotalPackets = getNetworkActivityPackets(NETWORK_MOBILE_RX_DATA, which); final long mobileTxTotalPackets = getNetworkActivityPackets(NETWORK_MOBILE_TX_DATA, which); final long wifiRxTotalPackets = getNetworkActivityPackets(NETWORK_WIFI_RX_DATA, which); final long wifiTxTotalPackets = getNetworkActivityPackets(NETWORK_WIFI_TX_DATA, which); final long btRxTotalBytes = getNetworkActivityBytes(NETWORK_BT_RX_DATA, which); final long btTxTotalBytes = getNetworkActivityBytes(NETWORK_BT_TX_DATA, which); if (fullWakeLockTimeTotalMicros != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Total full wakelock time: "); formatTimeMsNoSpace(sb, (fullWakeLockTimeTotalMicros + 500) / 1000); pw.println(sb.toString()); } if (partialWakeLockTimeTotalMicros != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Total partial wakelock time: "); formatTimeMsNoSpace(sb, (partialWakeLockTimeTotalMicros + 500) / 1000); pw.println(sb.toString()); } final long multicastWakeLockTimeTotalMicros = getWifiMulticastWakelockTime(rawRealtime, which); final int multicastWakeLockCountTotal = getWifiMulticastWakelockCount(which); if (multicastWakeLockTimeTotalMicros != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Total WiFi Multicast wakelock Count: "); sb.append(multicastWakeLockCountTotal); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" Total WiFi Multicast wakelock time: "); formatTimeMsNoSpace(sb, (multicastWakeLockTimeTotalMicros + 500) / 1000); pw.println(sb.toString()); } pw.println(""); pw.print(prefix); sb.setLength(0); sb.append(prefix); sb.append(" CONNECTIVITY POWER SUMMARY START"); pw.println(sb.toString()); pw.print(prefix); sb.setLength(0); sb.append(prefix); sb.append(" Logging duration for connectivity statistics: "); formatTimeMs(sb, whichBatteryRealtime / 1000); pw.println(sb.toString()); sb.setLength(0); sb.append(prefix); sb.append(" Cellular Statistics:"); pw.println(sb.toString()); pw.print(prefix); sb.setLength(0); sb.append(prefix); sb.append(" Cellular kernel active time: "); final long mobileActiveTime = getMobileRadioActiveTime(rawRealtime, which); formatTimeMs(sb, mobileActiveTime / 1000); sb.append("("); sb.append(formatRatioLocked(mobileActiveTime, whichBatteryRealtime)); sb.append(")"); pw.println(sb.toString()); pw.print(" Cellular data received: "); pw.println(formatBytesLocked(mobileRxTotalBytes)); pw.print(" Cellular data sent: "); pw.println(formatBytesLocked(mobileTxTotalBytes)); pw.print(" Cellular packets received: "); pw.println(mobileRxTotalPackets); pw.print(" Cellular packets sent: "); pw.println(mobileTxTotalPackets); sb.setLength(0); sb.append(prefix); sb.append(" Cellular Radio Access Technology:"); didOne = false; for (int i=0; i 0) { pw.print(prefix); sb.setLength(0); sb.append(prefix); sb.append(" Battery Drain (mAh): "); sb.append(Double.toString(((double) gpsBatteryDrainMaMs)/(3600 * 1000))); pw.println(sb.toString()); } pw.print(prefix); sb.setLength(0); sb.append(prefix); sb.append(" CONNECTIVITY POWER SUMMARY END"); pw.println(sb.toString()); pw.println(""); pw.print(prefix); pw.print(" Bluetooth total received: "); pw.print(formatBytesLocked(btRxTotalBytes)); pw.print(", sent: "); pw.println(formatBytesLocked(btTxTotalBytes)); final long bluetoothScanTimeMs = getBluetoothScanTime(rawRealtime, which) / 1000; sb.setLength(0); sb.append(prefix); sb.append(" Bluetooth scan time: "); formatTimeMs(sb, bluetoothScanTimeMs); pw.println(sb.toString()); printControllerActivity(pw, sb, prefix, "Bluetooth", getBluetoothControllerActivity(), which); pw.println(); if (which == STATS_SINCE_UNPLUGGED) { if (getIsOnBattery()) { pw.print(prefix); pw.println(" Device is currently unplugged"); pw.print(prefix); pw.print(" Discharge cycle start level: "); pw.println(getDischargeStartLevel()); pw.print(prefix); pw.print(" Discharge cycle current level: "); pw.println(getDischargeCurrentLevel()); } else { pw.print(prefix); pw.println(" Device is currently plugged into power"); pw.print(prefix); pw.print(" Last discharge cycle start level: "); pw.println(getDischargeStartLevel()); pw.print(prefix); pw.print(" Last discharge cycle end level: "); pw.println(getDischargeCurrentLevel()); } pw.print(prefix); pw.print(" Amount discharged while screen on: "); pw.println(getDischargeAmountScreenOn()); pw.print(prefix); pw.print(" Amount discharged while screen off: "); pw.println(getDischargeAmountScreenOff()); pw.print(prefix); pw.print(" Amount discharged while screen doze: "); pw.println(getDischargeAmountScreenDoze()); pw.println(" "); } else { pw.print(prefix); pw.println(" Device battery use since last full charge"); pw.print(prefix); pw.print(" Amount discharged (lower bound): "); pw.println(getLowDischargeAmountSinceCharge()); pw.print(prefix); pw.print(" Amount discharged (upper bound): "); pw.println(getHighDischargeAmountSinceCharge()); pw.print(prefix); pw.print(" Amount discharged while screen on: "); pw.println(getDischargeAmountScreenOnSinceCharge()); pw.print(prefix); pw.print(" Amount discharged while screen off: "); pw.println(getDischargeAmountScreenOffSinceCharge()); pw.print(prefix); pw.print(" Amount discharged while screen doze: "); pw.println(getDischargeAmountScreenDozeSinceCharge()); pw.println(); } final BatteryStatsHelper helper = new BatteryStatsHelper(context, false, wifiOnly); helper.create(this); helper.refreshStats(which, UserHandle.USER_ALL); List sippers = helper.getUsageList(); if (sippers != null && sippers.size() > 0) { pw.print(prefix); pw.println(" Estimated power use (mAh):"); pw.print(prefix); pw.print(" Capacity: "); printmAh(pw, helper.getPowerProfile().getBatteryCapacity()); pw.print(", Computed drain: "); printmAh(pw, helper.getComputedPower()); pw.print(", actual drain: "); printmAh(pw, helper.getMinDrainedPower()); if (helper.getMinDrainedPower() != helper.getMaxDrainedPower()) { pw.print("-"); printmAh(pw, helper.getMaxDrainedPower()); } pw.println(); for (int i=0; i 0) { pw.print(prefix); pw.println(" Per-app mobile ms per packet:"); long totalTime = 0; for (int i=0; i timerComparator = new Comparator() { @Override public int compare(TimerEntry lhs, TimerEntry rhs) { long lhsTime = lhs.mTime; long rhsTime = rhs.mTime; if (lhsTime < rhsTime) { return 1; } if (lhsTime > rhsTime) { return -1; } return 0; } }; if (reqUid < 0) { final Map kernelWakelocks = getKernelWakelockStats(); if (kernelWakelocks.size() > 0) { final ArrayList ktimers = new ArrayList<>(); for (Map.Entry ent : kernelWakelocks.entrySet()) { final BatteryStats.Timer timer = ent.getValue(); final long totalTimeMillis = computeWakeLock(timer, rawRealtime, which); if (totalTimeMillis > 0) { ktimers.add(new TimerEntry(ent.getKey(), 0, timer, totalTimeMillis)); } } if (ktimers.size() > 0) { Collections.sort(ktimers, timerComparator); pw.print(prefix); pw.println(" All kernel wake locks:"); for (int i=0; i 0) { Collections.sort(timers, timerComparator); pw.print(prefix); pw.println(" All partial wake locks:"); for (int i=0; i wakeupReasons = getWakeupReasonStats(); if (wakeupReasons.size() > 0) { pw.print(prefix); pw.println(" All wakeup reasons:"); final ArrayList reasons = new ArrayList<>(); for (Map.Entry ent : wakeupReasons.entrySet()) { final Timer timer = ent.getValue(); reasons.add(new TimerEntry(ent.getKey(), 0, timer, timer.getCountLocked(which))); } Collections.sort(reasons, timerComparator); for (int i=0; i mMemoryStats = getKernelMemoryStats(); if (mMemoryStats.size() > 0) { pw.println(" Memory Stats"); for (int i = 0; i < mMemoryStats.size(); i++) { sb.setLength(0); sb.append(" Bandwidth "); sb.append(mMemoryStats.keyAt(i)); sb.append(" Time "); sb.append(mMemoryStats.valueAt(i).getTotalTimeLocked(rawRealtime, which)); pw.println(sb.toString()); } pw.println(); } final Map rpmStats = getRpmStats(); if (rpmStats.size() > 0) { pw.print(prefix); pw.println(" Resource Power Manager Stats"); if (rpmStats.size() > 0) { for (Map.Entry ent : rpmStats.entrySet()) { final String timerName = ent.getKey(); final Timer timer = ent.getValue(); printTimer(pw, sb, timer, rawRealtime, which, prefix, timerName); } } pw.println(); } if (SCREEN_OFF_RPM_STATS_ENABLED) { final Map screenOffRpmStats = getScreenOffRpmStats(); if (screenOffRpmStats.size() > 0) { pw.print(prefix); pw.println(" Resource Power Manager Stats for when screen was off"); if (screenOffRpmStats.size() > 0) { for (Map.Entry ent : screenOffRpmStats.entrySet()) { final String timerName = ent.getKey(); final Timer timer = ent.getValue(); printTimer(pw, sb, timer, rawRealtime, which, prefix, timerName); } } pw.println(); } } final long[] cpuFreqs = getCpuFreqs(); if (cpuFreqs != null) { sb.setLength(0); sb.append(" CPU freqs:"); for (int i = 0; i < cpuFreqs.length; ++i) { sb.append(" " + cpuFreqs[i]); } pw.println(sb.toString()); pw.println(); } for (int iu=0; iu= 0 && uid != reqUid && uid != Process.SYSTEM_UID) { continue; } final Uid u = uidStats.valueAt(iu); pw.print(prefix); pw.print(" "); UserHandle.formatUid(pw, uid); pw.println(":"); boolean uidActivity = false; final long mobileRxBytes = u.getNetworkActivityBytes(NETWORK_MOBILE_RX_DATA, which); final long mobileTxBytes = u.getNetworkActivityBytes(NETWORK_MOBILE_TX_DATA, which); final long wifiRxBytes = u.getNetworkActivityBytes(NETWORK_WIFI_RX_DATA, which); final long wifiTxBytes = u.getNetworkActivityBytes(NETWORK_WIFI_TX_DATA, which); final long btRxBytes = u.getNetworkActivityBytes(NETWORK_BT_RX_DATA, which); final long btTxBytes = u.getNetworkActivityBytes(NETWORK_BT_TX_DATA, which); final long mobileRxPackets = u.getNetworkActivityPackets(NETWORK_MOBILE_RX_DATA, which); final long mobileTxPackets = u.getNetworkActivityPackets(NETWORK_MOBILE_TX_DATA, which); final long wifiRxPackets = u.getNetworkActivityPackets(NETWORK_WIFI_RX_DATA, which); final long wifiTxPackets = u.getNetworkActivityPackets(NETWORK_WIFI_TX_DATA, which); final long uidMobileActiveTime = u.getMobileRadioActiveTime(which); final int uidMobileActiveCount = u.getMobileRadioActiveCount(which); final long fullWifiLockOnTime = u.getFullWifiLockTime(rawRealtime, which); final long wifiScanTime = u.getWifiScanTime(rawRealtime, which); final int wifiScanCount = u.getWifiScanCount(which); final int wifiScanCountBg = u.getWifiScanBackgroundCount(which); // 'actualTime' are unpooled and always since reset (regardless of 'which') final long wifiScanActualTime = u.getWifiScanActualTime(rawRealtime); final long wifiScanActualTimeBg = u.getWifiScanBackgroundTime(rawRealtime); final long uidWifiRunningTime = u.getWifiRunningTime(rawRealtime, which); final long mobileWakeup = u.getMobileRadioApWakeupCount(which); final long wifiWakeup = u.getWifiRadioApWakeupCount(which); if (mobileRxBytes > 0 || mobileTxBytes > 0 || mobileRxPackets > 0 || mobileTxPackets > 0) { pw.print(prefix); pw.print(" Mobile network: "); pw.print(formatBytesLocked(mobileRxBytes)); pw.print(" received, "); pw.print(formatBytesLocked(mobileTxBytes)); pw.print(" sent (packets "); pw.print(mobileRxPackets); pw.print(" received, "); pw.print(mobileTxPackets); pw.println(" sent)"); } if (uidMobileActiveTime > 0 || uidMobileActiveCount > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Mobile radio active: "); formatTimeMs(sb, uidMobileActiveTime / 1000); sb.append("("); sb.append(formatRatioLocked(uidMobileActiveTime, mobileActiveTime)); sb.append(") "); sb.append(uidMobileActiveCount); sb.append("x"); long packets = mobileRxPackets + mobileTxPackets; if (packets == 0) { packets = 1; } sb.append(" @ "); sb.append(BatteryStatsHelper.makemAh(uidMobileActiveTime / 1000 / (double)packets)); sb.append(" mspp"); pw.println(sb.toString()); } if (mobileWakeup > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Mobile radio AP wakeups: "); sb.append(mobileWakeup); pw.println(sb.toString()); } printControllerActivityIfInteresting(pw, sb, prefix + " ", CELLULAR_CONTROLLER_NAME, u.getModemControllerActivity(), which); if (wifiRxBytes > 0 || wifiTxBytes > 0 || wifiRxPackets > 0 || wifiTxPackets > 0) { pw.print(prefix); pw.print(" Wi-Fi network: "); pw.print(formatBytesLocked(wifiRxBytes)); pw.print(" received, "); pw.print(formatBytesLocked(wifiTxBytes)); pw.print(" sent (packets "); pw.print(wifiRxPackets); pw.print(" received, "); pw.print(wifiTxPackets); pw.println(" sent)"); } if (fullWifiLockOnTime != 0 || wifiScanTime != 0 || wifiScanCount != 0 || wifiScanCountBg != 0 || wifiScanActualTime != 0 || wifiScanActualTimeBg != 0 || uidWifiRunningTime != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Wifi Running: "); formatTimeMs(sb, uidWifiRunningTime / 1000); sb.append("("); sb.append(formatRatioLocked(uidWifiRunningTime, whichBatteryRealtime)); sb.append(")\n"); sb.append(prefix); sb.append(" Full Wifi Lock: "); formatTimeMs(sb, fullWifiLockOnTime / 1000); sb.append("("); sb.append(formatRatioLocked(fullWifiLockOnTime, whichBatteryRealtime)); sb.append(")\n"); sb.append(prefix); sb.append(" Wifi Scan (blamed): "); formatTimeMs(sb, wifiScanTime / 1000); sb.append("("); sb.append(formatRatioLocked(wifiScanTime, whichBatteryRealtime)); sb.append(") "); sb.append(wifiScanCount); sb.append("x\n"); // actual and background times are unpooled and since reset (regardless of 'which') sb.append(prefix); sb.append(" Wifi Scan (actual): "); formatTimeMs(sb, wifiScanActualTime / 1000); sb.append("("); sb.append(formatRatioLocked(wifiScanActualTime, computeBatteryRealtime(rawRealtime, STATS_SINCE_CHARGED))); sb.append(") "); sb.append(wifiScanCount); sb.append("x\n"); sb.append(prefix); sb.append(" Background Wifi Scan: "); formatTimeMs(sb, wifiScanActualTimeBg / 1000); sb.append("("); sb.append(formatRatioLocked(wifiScanActualTimeBg, computeBatteryRealtime(rawRealtime, STATS_SINCE_CHARGED))); sb.append(") "); sb.append(wifiScanCountBg); sb.append("x"); pw.println(sb.toString()); } if (wifiWakeup > 0) { sb.setLength(0); sb.append(prefix); sb.append(" WiFi AP wakeups: "); sb.append(wifiWakeup); pw.println(sb.toString()); } printControllerActivityIfInteresting(pw, sb, prefix + " ", WIFI_CONTROLLER_NAME, u.getWifiControllerActivity(), which); if (btRxBytes > 0 || btTxBytes > 0) { pw.print(prefix); pw.print(" Bluetooth network: "); pw.print(formatBytesLocked(btRxBytes)); pw.print(" received, "); pw.print(formatBytesLocked(btTxBytes)); pw.println(" sent"); } final Timer bleTimer = u.getBluetoothScanTimer(); if (bleTimer != null) { // Convert from microseconds to milliseconds with rounding final long totalTimeMs = (bleTimer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; if (totalTimeMs != 0) { final int count = bleTimer.getCountLocked(which); final Timer bleTimerBg = u.getBluetoothScanBackgroundTimer(); final int countBg = bleTimerBg != null ? bleTimerBg.getCountLocked(which) : 0; // 'actualTime' are unpooled and always since reset (regardless of 'which') final long actualTimeMs = bleTimer.getTotalDurationMsLocked(rawRealtimeMs); final long actualTimeMsBg = bleTimerBg != null ? bleTimerBg.getTotalDurationMsLocked(rawRealtimeMs) : 0; // Result counters final int resultCount = u.getBluetoothScanResultCounter() != null ? u.getBluetoothScanResultCounter().getCountLocked(which) : 0; final int resultCountBg = u.getBluetoothScanResultBgCounter() != null ? u.getBluetoothScanResultBgCounter().getCountLocked(which) : 0; // Unoptimized scan timer. Unpooled and since reset (regardless of 'which'). final Timer unoptimizedScanTimer = u.getBluetoothUnoptimizedScanTimer(); final long unoptimizedScanTotalTime = unoptimizedScanTimer != null ? unoptimizedScanTimer.getTotalDurationMsLocked(rawRealtimeMs) : 0; final long unoptimizedScanMaxTime = unoptimizedScanTimer != null ? unoptimizedScanTimer.getMaxDurationMsLocked(rawRealtimeMs) : 0; // Unoptimized bg scan timer. Unpooled and since reset (regardless of 'which'). final Timer unoptimizedScanTimerBg = u.getBluetoothUnoptimizedScanBackgroundTimer(); final long unoptimizedScanTotalTimeBg = unoptimizedScanTimerBg != null ? unoptimizedScanTimerBg.getTotalDurationMsLocked(rawRealtimeMs) : 0; final long unoptimizedScanMaxTimeBg = unoptimizedScanTimerBg != null ? unoptimizedScanTimerBg.getMaxDurationMsLocked(rawRealtimeMs) : 0; sb.setLength(0); if (actualTimeMs != totalTimeMs) { sb.append(prefix); sb.append(" Bluetooth Scan (total blamed realtime): "); formatTimeMs(sb, totalTimeMs); sb.append(" ("); sb.append(count); sb.append(" times)"); if (bleTimer.isRunningLocked()) { sb.append(" (currently running)"); } sb.append("\n"); } sb.append(prefix); sb.append(" Bluetooth Scan (total actual realtime): "); formatTimeMs(sb, actualTimeMs); // since reset, ignores 'which' sb.append(" ("); sb.append(count); sb.append(" times)"); if (bleTimer.isRunningLocked()) { sb.append(" (currently running)"); } sb.append("\n"); if (actualTimeMsBg > 0 || countBg > 0) { sb.append(prefix); sb.append(" Bluetooth Scan (background realtime): "); formatTimeMs(sb, actualTimeMsBg); // since reset, ignores 'which' sb.append(" ("); sb.append(countBg); sb.append(" times)"); if (bleTimerBg != null && bleTimerBg.isRunningLocked()) { sb.append(" (currently running in background)"); } sb.append("\n"); } sb.append(prefix); sb.append(" Bluetooth Scan Results: "); sb.append(resultCount); sb.append(" ("); sb.append(resultCountBg); sb.append(" in background)"); if (unoptimizedScanTotalTime > 0 || unoptimizedScanTotalTimeBg > 0) { sb.append("\n"); sb.append(prefix); sb.append(" Unoptimized Bluetooth Scan (realtime): "); formatTimeMs(sb, unoptimizedScanTotalTime); // since reset, ignores 'which' sb.append(" (max "); formatTimeMs(sb, unoptimizedScanMaxTime); // since reset, ignores 'which' sb.append(")"); if (unoptimizedScanTimer != null && unoptimizedScanTimer.isRunningLocked()) { sb.append(" (currently running unoptimized)"); } if (unoptimizedScanTimerBg != null && unoptimizedScanTotalTimeBg > 0) { sb.append("\n"); sb.append(prefix); sb.append(" Unoptimized Bluetooth Scan (background realtime): "); formatTimeMs(sb, unoptimizedScanTotalTimeBg); // since reset sb.append(" (max "); formatTimeMs(sb, unoptimizedScanMaxTimeBg); // since reset sb.append(")"); if (unoptimizedScanTimerBg.isRunningLocked()) { sb.append(" (currently running unoptimized in background)"); } } } pw.println(sb.toString()); uidActivity = true; } } if (u.hasUserActivity()) { boolean hasData = false; for (int i=0; i wakelocks = u.getWakelockStats(); long totalFullWakelock = 0, totalPartialWakelock = 0, totalWindowWakelock = 0; long totalDrawWakelock = 0; int countWakelock = 0; for (int iw=wakelocks.size()-1; iw>=0; iw--) { final Uid.Wakelock wl = wakelocks.valueAt(iw); String linePrefix = ": "; sb.setLength(0); sb.append(prefix); sb.append(" Wake lock "); sb.append(wakelocks.keyAt(iw)); linePrefix = printWakeLock(sb, wl.getWakeTime(WAKE_TYPE_FULL), rawRealtime, "full", which, linePrefix); final Timer pTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL); linePrefix = printWakeLock(sb, pTimer, rawRealtime, "partial", which, linePrefix); linePrefix = printWakeLock(sb, pTimer != null ? pTimer.getSubTimer() : null, rawRealtime, "background partial", which, linePrefix); linePrefix = printWakeLock(sb, wl.getWakeTime(WAKE_TYPE_WINDOW), rawRealtime, "window", which, linePrefix); linePrefix = printWakeLock(sb, wl.getWakeTime(WAKE_TYPE_DRAW), rawRealtime, "draw", which, linePrefix); sb.append(" realtime"); pw.println(sb.toString()); uidActivity = true; countWakelock++; totalFullWakelock += computeWakeLock(wl.getWakeTime(WAKE_TYPE_FULL), rawRealtime, which); totalPartialWakelock += computeWakeLock(wl.getWakeTime(WAKE_TYPE_PARTIAL), rawRealtime, which); totalWindowWakelock += computeWakeLock(wl.getWakeTime(WAKE_TYPE_WINDOW), rawRealtime, which); totalDrawWakelock += computeWakeLock(wl.getWakeTime(WAKE_TYPE_DRAW), rawRealtime, which); } if (countWakelock > 1) { // get unpooled partial wakelock quantities (unlike totalPartialWakelock, which is // pooled and therefore just a lower bound) long actualTotalPartialWakelock = 0; long actualBgPartialWakelock = 0; if (u.getAggregatedPartialWakelockTimer() != null) { final Timer aggTimer = u.getAggregatedPartialWakelockTimer(); // Convert from microseconds to milliseconds with rounding actualTotalPartialWakelock = aggTimer.getTotalDurationMsLocked(rawRealtimeMs); final Timer bgAggTimer = aggTimer.getSubTimer(); actualBgPartialWakelock = bgAggTimer != null ? bgAggTimer.getTotalDurationMsLocked(rawRealtimeMs) : 0; } if (actualTotalPartialWakelock != 0 || actualBgPartialWakelock != 0 || totalFullWakelock != 0 || totalPartialWakelock != 0 || totalWindowWakelock != 0) { sb.setLength(0); sb.append(prefix); sb.append(" TOTAL wake: "); boolean needComma = false; if (totalFullWakelock != 0) { needComma = true; formatTimeMs(sb, totalFullWakelock); sb.append("full"); } if (totalPartialWakelock != 0) { if (needComma) { sb.append(", "); } needComma = true; formatTimeMs(sb, totalPartialWakelock); sb.append("blamed partial"); } if (actualTotalPartialWakelock != 0) { if (needComma) { sb.append(", "); } needComma = true; formatTimeMs(sb, actualTotalPartialWakelock); sb.append("actual partial"); } if (actualBgPartialWakelock != 0) { if (needComma) { sb.append(", "); } needComma = true; formatTimeMs(sb, actualBgPartialWakelock); sb.append("actual background partial"); } if (totalWindowWakelock != 0) { if (needComma) { sb.append(", "); } needComma = true; formatTimeMs(sb, totalWindowWakelock); sb.append("window"); } if (totalDrawWakelock != 0) { if (needComma) { sb.append(","); } needComma = true; formatTimeMs(sb, totalDrawWakelock); sb.append("draw"); } sb.append(" realtime"); pw.println(sb.toString()); } } // Calculate multicast wakelock stats final Timer mcTimer = u.getMulticastWakelockStats(); if (mcTimer != null) { final long multicastWakeLockTimeMicros = mcTimer.getTotalTimeLocked(rawRealtime, which); final int multicastWakeLockCount = mcTimer.getCountLocked(which); if (multicastWakeLockTimeMicros > 0) { sb.setLength(0); sb.append(prefix); sb.append(" WiFi Multicast Wakelock"); sb.append(" count = "); sb.append(multicastWakeLockCount); sb.append(" time = "); formatTimeMsNoSpace(sb, (multicastWakeLockTimeMicros + 500) / 1000); pw.println(sb.toString()); } } final ArrayMap syncs = u.getSyncStats(); for (int isy=syncs.size()-1; isy>=0; isy--) { final Timer timer = syncs.valueAt(isy); // Convert from microseconds to milliseconds with rounding final long totalTime = (timer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; final int count = timer.getCountLocked(which); final Timer bgTimer = timer.getSubTimer(); final long bgTime = bgTimer != null ? bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : -1; final int bgCount = bgTimer != null ? bgTimer.getCountLocked(which) : -1; sb.setLength(0); sb.append(prefix); sb.append(" Sync "); sb.append(syncs.keyAt(isy)); sb.append(": "); if (totalTime != 0) { formatTimeMs(sb, totalTime); sb.append("realtime ("); sb.append(count); sb.append(" times)"); if (bgTime > 0) { sb.append(", "); formatTimeMs(sb, bgTime); sb.append("background ("); sb.append(bgCount); sb.append(" times)"); } } else { sb.append("(not used)"); } pw.println(sb.toString()); uidActivity = true; } final ArrayMap jobs = u.getJobStats(); for (int ij=jobs.size()-1; ij>=0; ij--) { final Timer timer = jobs.valueAt(ij); // Convert from microseconds to milliseconds with rounding final long totalTime = (timer.getTotalTimeLocked(rawRealtime, which) + 500) / 1000; final int count = timer.getCountLocked(which); final Timer bgTimer = timer.getSubTimer(); final long bgTime = bgTimer != null ? bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : -1; final int bgCount = bgTimer != null ? bgTimer.getCountLocked(which) : -1; sb.setLength(0); sb.append(prefix); sb.append(" Job "); sb.append(jobs.keyAt(ij)); sb.append(": "); if (totalTime != 0) { formatTimeMs(sb, totalTime); sb.append("realtime ("); sb.append(count); sb.append(" times)"); if (bgTime > 0) { sb.append(", "); formatTimeMs(sb, bgTime); sb.append("background ("); sb.append(bgCount); sb.append(" times)"); } } else { sb.append("(not used)"); } pw.println(sb.toString()); uidActivity = true; } final ArrayMap completions = u.getJobCompletionStats(); for (int ic=completions.size()-1; ic>=0; ic--) { SparseIntArray types = completions.valueAt(ic); if (types != null) { pw.print(prefix); pw.print(" Job Completions "); pw.print(completions.keyAt(ic)); pw.print(":"); for (int it=0; it 0) { pw.print(" Jobs deferred on launch "); pw.println(sb.toString()); } uidActivity |= printTimer(pw, sb, u.getFlashlightTurnedOnTimer(), rawRealtime, which, prefix, "Flashlight"); uidActivity |= printTimer(pw, sb, u.getCameraTurnedOnTimer(), rawRealtime, which, prefix, "Camera"); uidActivity |= printTimer(pw, sb, u.getVideoTurnedOnTimer(), rawRealtime, which, prefix, "Video"); uidActivity |= printTimer(pw, sb, u.getAudioTurnedOnTimer(), rawRealtime, which, prefix, "Audio"); final SparseArray sensors = u.getSensorStats(); final int NSE = sensors.size(); for (int ise=0; ise 0) { sb.append(", "); formatTimeMs(sb, bgActualTime); // since reset, regardless of 'which' sb.append("background ("); sb.append(bgCount); sb.append(" times)"); } } else { sb.append("(not used)"); } } else { sb.append("(not used)"); } pw.println(sb.toString()); uidActivity = true; } uidActivity |= printTimer(pw, sb, u.getVibratorOnTimer(), rawRealtime, which, prefix, "Vibrator"); uidActivity |= printTimer(pw, sb, u.getForegroundActivityTimer(), rawRealtime, which, prefix, "Foreground activities"); uidActivity |= printTimer(pw, sb, u.getForegroundServiceTimer(), rawRealtime, which, prefix, "Foreground services"); long totalStateTime = 0; for (int ips=0; ips 0) { totalStateTime += time; sb.setLength(0); sb.append(prefix); sb.append(" "); sb.append(Uid.PROCESS_STATE_NAMES[ips]); sb.append(" for: "); formatTimeMs(sb, (time + 500) / 1000); pw.println(sb.toString()); uidActivity = true; } } if (totalStateTime > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Total running: "); formatTimeMs(sb, (totalStateTime + 500) / 1000); pw.println(sb.toString()); } final long userCpuTimeUs = u.getUserCpuTimeUs(which); final long systemCpuTimeUs = u.getSystemCpuTimeUs(which); if (userCpuTimeUs > 0 || systemCpuTimeUs > 0) { sb.setLength(0); sb.append(prefix); sb.append(" Total cpu time: u="); formatTimeMs(sb, userCpuTimeUs / 1000); sb.append("s="); formatTimeMs(sb, systemCpuTimeUs / 1000); pw.println(sb.toString()); } final long[] cpuFreqTimes = u.getCpuFreqTimes(which); if (cpuFreqTimes != null) { sb.setLength(0); sb.append(" Total cpu time per freq:"); for (int i = 0; i < cpuFreqTimes.length; ++i) { sb.append(" " + cpuFreqTimes[i]); } pw.println(sb.toString()); } final long[] screenOffCpuFreqTimes = u.getScreenOffCpuFreqTimes(which); if (screenOffCpuFreqTimes != null) { sb.setLength(0); sb.append(" Total screen-off cpu time per freq:"); for (int i = 0; i < screenOffCpuFreqTimes.length; ++i) { sb.append(" " + screenOffCpuFreqTimes[i]); } pw.println(sb.toString()); } for (int procState = 0; procState < Uid.NUM_PROCESS_STATE; ++procState) { final long[] cpuTimes = u.getCpuFreqTimes(which, procState); if (cpuTimes != null) { sb.setLength(0); sb.append(" Cpu times per freq at state " + Uid.PROCESS_STATE_NAMES[procState] + ":"); for (int i = 0; i < cpuTimes.length; ++i) { sb.append(" " + cpuTimes[i]); } pw.println(sb.toString()); } final long[] screenOffCpuTimes = u.getScreenOffCpuFreqTimes(which, procState); if (screenOffCpuTimes != null) { sb.setLength(0); sb.append(" Screen-off cpu times per freq at state " + Uid.PROCESS_STATE_NAMES[procState] + ":"); for (int i = 0; i < screenOffCpuTimes.length; ++i) { sb.append(" " + screenOffCpuTimes[i]); } pw.println(sb.toString()); } } final ArrayMap processStats = u.getProcessStats(); for (int ipr=processStats.size()-1; ipr>=0; ipr--) { final Uid.Proc ps = processStats.valueAt(ipr); long userTime; long systemTime; long foregroundTime; int starts; int numExcessive; userTime = ps.getUserTime(which); systemTime = ps.getSystemTime(which); foregroundTime = ps.getForegroundTime(which); starts = ps.getStarts(which); final int numCrashes = ps.getNumCrashes(which); final int numAnrs = ps.getNumAnrs(which); numExcessive = which == STATS_SINCE_CHARGED ? ps.countExcessivePowers() : 0; if (userTime != 0 || systemTime != 0 || foregroundTime != 0 || starts != 0 || numExcessive != 0 || numCrashes != 0 || numAnrs != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Proc "); sb.append(processStats.keyAt(ipr)); sb.append(":\n"); sb.append(prefix); sb.append(" CPU: "); formatTimeMs(sb, userTime); sb.append("usr + "); formatTimeMs(sb, systemTime); sb.append("krn ; "); formatTimeMs(sb, foregroundTime); sb.append("fg"); if (starts != 0 || numCrashes != 0 || numAnrs != 0) { sb.append("\n"); sb.append(prefix); sb.append(" "); boolean hasOne = false; if (starts != 0) { hasOne = true; sb.append(starts); sb.append(" starts"); } if (numCrashes != 0) { if (hasOne) { sb.append(", "); } hasOne = true; sb.append(numCrashes); sb.append(" crashes"); } if (numAnrs != 0) { if (hasOne) { sb.append(", "); } sb.append(numAnrs); sb.append(" anrs"); } } pw.println(sb.toString()); for (int e=0; e packageStats = u.getPackageStats(); for (int ipkg=packageStats.size()-1; ipkg>=0; ipkg--) { pw.print(prefix); pw.print(" Apk "); pw.print(packageStats.keyAt(ipkg)); pw.println(":"); boolean apkActivity = false; final Uid.Pkg ps = packageStats.valueAt(ipkg); final ArrayMap alarms = ps.getWakeupAlarmStats(); for (int iwa=alarms.size()-1; iwa>=0; iwa--) { pw.print(prefix); pw.print(" Wakeup alarm "); pw.print(alarms.keyAt(iwa)); pw.print(": "); pw.print(alarms.valueAt(iwa).getCountLocked(which)); pw.println(" times"); apkActivity = true; } final ArrayMap serviceStats = ps.getServiceStats(); for (int isvc=serviceStats.size()-1; isvc>=0; isvc--) { final BatteryStats.Uid.Pkg.Serv ss = serviceStats.valueAt(isvc); final long startTime = ss.getStartTime(batteryUptime, which); final int starts = ss.getStarts(which); final int launches = ss.getLaunches(which); if (startTime != 0 || starts != 0 || launches != 0) { sb.setLength(0); sb.append(prefix); sb.append(" Service "); sb.append(serviceStats.keyAt(isvc)); sb.append(":\n"); sb.append(prefix); sb.append(" Created for: "); formatTimeMs(sb, startTime / 1000); sb.append("uptime\n"); sb.append(prefix); sb.append(" Starts: "); sb.append(starts); sb.append(", launches: "); sb.append(launches); pw.println(sb.toString()); apkActivity = true; } } if (!apkActivity) { pw.print(prefix); pw.println(" (nothing executed)"); } uidActivity = true; } if (!uidActivity) { pw.print(prefix); pw.println(" (nothing executed)"); } } } static void printBitDescriptions(PrintWriter pw, int oldval, int newval, HistoryTag wakelockTag, BitDescription[] descriptions, boolean longNames) { int diff = oldval ^ newval; if (diff == 0) return; boolean didWake = false; for (int i=0; i= 0 && idx < eventNames.length) { pw.print(eventNames[idx]); } else { pw.print(checkin ? "Ev" : "event"); pw.print(idx); } pw.print("="); if (checkin) { pw.print(rec.eventTag.poolIdx); } else { pw.append(HISTORY_EVENT_INT_FORMATTERS[idx] .applyAsString(rec.eventTag.uid)); pw.print(":\""); pw.print(rec.eventTag.string); pw.print("\""); } } pw.println(); if (rec.stepDetails != null) { if (!checkin) { pw.print(" Details: cpu="); pw.print(rec.stepDetails.userTime); pw.print("u+"); pw.print(rec.stepDetails.systemTime); pw.print("s"); if (rec.stepDetails.appCpuUid1 >= 0) { pw.print(" ("); printStepCpuUidDetails(pw, rec.stepDetails.appCpuUid1, rec.stepDetails.appCpuUTime1, rec.stepDetails.appCpuSTime1); if (rec.stepDetails.appCpuUid2 >= 0) { pw.print(", "); printStepCpuUidDetails(pw, rec.stepDetails.appCpuUid2, rec.stepDetails.appCpuUTime2, rec.stepDetails.appCpuSTime2); } if (rec.stepDetails.appCpuUid3 >= 0) { pw.print(", "); printStepCpuUidDetails(pw, rec.stepDetails.appCpuUid3, rec.stepDetails.appCpuUTime3, rec.stepDetails.appCpuSTime3); } pw.print(')'); } pw.println(); pw.print(" /proc/stat="); pw.print(rec.stepDetails.statUserTime); pw.print(" usr, "); pw.print(rec.stepDetails.statSystemTime); pw.print(" sys, "); pw.print(rec.stepDetails.statIOWaitTime); pw.print(" io, "); pw.print(rec.stepDetails.statIrqTime); pw.print(" irq, "); pw.print(rec.stepDetails.statSoftIrqTime); pw.print(" sirq, "); pw.print(rec.stepDetails.statIdlTime); pw.print(" idle"); int totalRun = rec.stepDetails.statUserTime + rec.stepDetails.statSystemTime + rec.stepDetails.statIOWaitTime + rec.stepDetails.statIrqTime + rec.stepDetails.statSoftIrqTime; int total = totalRun + rec.stepDetails.statIdlTime; if (total > 0) { pw.print(" ("); float perc = ((float)totalRun) / ((float)total) * 100; pw.print(String.format("%.1f%%", perc)); pw.print(" of "); StringBuilder sb = new StringBuilder(64); formatTimeMsNoSpace(sb, total*10); pw.print(sb); pw.print(")"); } pw.print(", PlatformIdleStat "); pw.print(rec.stepDetails.statPlatformIdleState); pw.println(); pw.print(", SubsystemPowerState "); pw.print(rec.stepDetails.statSubsystemPowerState); pw.println(); } else { pw.print(BATTERY_STATS_CHECKIN_VERSION); pw.print(','); pw.print(HISTORY_DATA); pw.print(",0,Dcpu="); pw.print(rec.stepDetails.userTime); pw.print(":"); pw.print(rec.stepDetails.systemTime); if (rec.stepDetails.appCpuUid1 >= 0) { printStepCpuUidCheckinDetails(pw, rec.stepDetails.appCpuUid1, rec.stepDetails.appCpuUTime1, rec.stepDetails.appCpuSTime1); if (rec.stepDetails.appCpuUid2 >= 0) { printStepCpuUidCheckinDetails(pw, rec.stepDetails.appCpuUid2, rec.stepDetails.appCpuUTime2, rec.stepDetails.appCpuSTime2); } if (rec.stepDetails.appCpuUid3 >= 0) { printStepCpuUidCheckinDetails(pw, rec.stepDetails.appCpuUid3, rec.stepDetails.appCpuUTime3, rec.stepDetails.appCpuSTime3); } } pw.println(); pw.print(BATTERY_STATS_CHECKIN_VERSION); pw.print(','); pw.print(HISTORY_DATA); pw.print(",0,Dpst="); pw.print(rec.stepDetails.statUserTime); pw.print(','); pw.print(rec.stepDetails.statSystemTime); pw.print(','); pw.print(rec.stepDetails.statIOWaitTime); pw.print(','); pw.print(rec.stepDetails.statIrqTime); pw.print(','); pw.print(rec.stepDetails.statSoftIrqTime); pw.print(','); pw.print(rec.stepDetails.statIdlTime); pw.print(','); if (rec.stepDetails.statPlatformIdleState != null) { pw.print(rec.stepDetails.statPlatformIdleState); if (rec.stepDetails.statSubsystemPowerState != null) { pw.print(','); } } if (rec.stepDetails.statSubsystemPowerState != null) { pw.print(rec.stepDetails.statSubsystemPowerState); } pw.println(); } } oldState = rec.states; oldState2 = rec.states2; } } private void printStepCpuUidDetails(PrintWriter pw, int uid, int utime, int stime) { UserHandle.formatUid(pw, uid); pw.print("="); pw.print(utime); pw.print("u+"); pw.print(stime); pw.print("s"); } private void printStepCpuUidCheckinDetails(PrintWriter pw, int uid, int utime, int stime) { pw.print('/'); pw.print(uid); pw.print(":"); pw.print(utime); pw.print(":"); pw.print(stime); } } private void printSizeValue(PrintWriter pw, long size) { float result = size; String suffix = ""; if (result >= 10*1024) { suffix = "KB"; result = result / 1024; } if (result >= 10*1024) { suffix = "MB"; result = result / 1024; } if (result >= 10*1024) { suffix = "GB"; result = result / 1024; } if (result >= 10*1024) { suffix = "TB"; result = result / 1024; } if (result >= 10*1024) { suffix = "PB"; result = result / 1024; } pw.print((int)result); pw.print(suffix); } private static boolean dumpTimeEstimate(PrintWriter pw, String label1, String label2, String label3, long estimatedTime) { if (estimatedTime < 0) { return false; } pw.print(label1); pw.print(label2); pw.print(label3); StringBuilder sb = new StringBuilder(64); formatTimeMs(sb, estimatedTime); pw.print(sb); pw.println(); return true; } private static boolean dumpDurationSteps(PrintWriter pw, String prefix, String header, LevelStepTracker steps, boolean checkin) { if (steps == null) { return false; } int count = steps.mNumStepDurations; if (count <= 0) { return false; } if (!checkin) { pw.println(header); } String[] lineArgs = new String[5]; for (int i=0; i= histStart) { if (histStart >= 0 && !printed) { if (rec.cmd == HistoryItem.CMD_CURRENT_TIME || rec.cmd == HistoryItem.CMD_RESET || rec.cmd == HistoryItem.CMD_START || rec.cmd == HistoryItem.CMD_SHUTDOWN) { printed = true; hprinter.printNextItem(pw, rec, baseTime, checkin, (flags&DUMP_VERBOSE) != 0); rec.cmd = HistoryItem.CMD_UPDATE; } else if (rec.currentTime != 0) { printed = true; byte cmd = rec.cmd; rec.cmd = HistoryItem.CMD_CURRENT_TIME; hprinter.printNextItem(pw, rec, baseTime, checkin, (flags&DUMP_VERBOSE) != 0); rec.cmd = cmd; } if (tracker != null) { if (rec.cmd != HistoryItem.CMD_UPDATE) { hprinter.printNextItem(pw, rec, baseTime, checkin, (flags&DUMP_VERBOSE) != 0); rec.cmd = HistoryItem.CMD_UPDATE; } int oldEventCode = rec.eventCode; HistoryTag oldEventTag = rec.eventTag; rec.eventTag = new HistoryTag(); for (int i=0; i active = tracker.getStateForEvent(i); if (active == null) { continue; } for (HashMap.Entry ent : active.entrySet()) { SparseIntArray uids = ent.getValue(); for (int j=0; j= 0) { commitCurrentHistoryBatchLocked(); pw.print(checkin ? "NEXT: " : " NEXT: "); pw.println(lastTime+1); } } private void dumpDailyLevelStepSummary(PrintWriter pw, String prefix, String label, LevelStepTracker steps, StringBuilder tmpSb, int[] tmpOutInt) { if (steps == null) { return; } long timeRemaining = steps.computeTimeEstimate(0, 0, tmpOutInt); if (timeRemaining >= 0) { pw.print(prefix); pw.print(label); pw.print(" total time: "); tmpSb.setLength(0); formatTimeMs(tmpSb, timeRemaining); pw.print(tmpSb); pw.print(" (from "); pw.print(tmpOutInt[0]); pw.println(" steps)"); } for (int i=0; i< STEP_LEVEL_MODES_OF_INTEREST.length; i++) { long estimatedTime = steps.computeTimeEstimate(STEP_LEVEL_MODES_OF_INTEREST[i], STEP_LEVEL_MODE_VALUES[i], tmpOutInt); if (estimatedTime > 0) { pw.print(prefix); pw.print(label); pw.print(" "); pw.print(STEP_LEVEL_MODE_LABELS[i]); pw.print(" time: "); tmpSb.setLength(0); formatTimeMs(tmpSb, estimatedTime); pw.print(tmpSb); pw.print(" (from "); pw.print(tmpOutInt[0]); pw.println(" steps)"); } } } private void dumpDailyPackageChanges(PrintWriter pw, String prefix, ArrayList changes) { if (changes == null) { return; } pw.print(prefix); pw.println("Package changes:"); for (int i=0; i uidStats = getUidStats(); final int NU = uidStats.size(); boolean didPid = false; long nowRealtime = SystemClock.elapsedRealtime(); for (int i=0; i pids = uid.getPidStats(); if (pids != null) { for (int j=0; j 0 ? (nowRealtime - pid.mWakeStartMs) : 0); pw.print(" PID "); pw.print(pids.keyAt(j)); pw.print(" wake time: "); TimeUtils.formatDuration(time, pw); pw.println(""); } } } if (didPid) { pw.println(); } } if (!filtering || (flags&DUMP_CHARGED_ONLY) != 0) { if (dumpDurationSteps(pw, " ", "Discharge step durations:", getDischargeLevelStepTracker(), false)) { long timeRemaining = computeBatteryTimeRemaining( SystemClock.elapsedRealtime() * 1000); if (timeRemaining >= 0) { pw.print(" Estimated discharge time remaining: "); TimeUtils.formatDuration(timeRemaining / 1000, pw); pw.println(); } final LevelStepTracker steps = getDischargeLevelStepTracker(); for (int i=0; i< STEP_LEVEL_MODES_OF_INTEREST.length; i++) { dumpTimeEstimate(pw, " Estimated ", STEP_LEVEL_MODE_LABELS[i], " time: ", steps.computeTimeEstimate(STEP_LEVEL_MODES_OF_INTEREST[i], STEP_LEVEL_MODE_VALUES[i], null)); } pw.println(); } if (dumpDurationSteps(pw, " ", "Charge step durations:", getChargeLevelStepTracker(), false)) { long timeRemaining = computeChargeTimeRemaining( SystemClock.elapsedRealtime() * 1000); if (timeRemaining >= 0) { pw.print(" Estimated charge time remaining: "); TimeUtils.formatDuration(timeRemaining / 1000, pw); pw.println(); } pw.println(); } } if (!filtering || (flags & DUMP_DAILY_ONLY) != 0) { pw.println("Daily stats:"); pw.print(" Current start time: "); pw.println(DateFormat.format("yyyy-MM-dd-HH-mm-ss", getCurrentDailyStartTime()).toString()); pw.print(" Next min deadline: "); pw.println(DateFormat.format("yyyy-MM-dd-HH-mm-ss", getNextMinDailyDeadline()).toString()); pw.print(" Next max deadline: "); pw.println(DateFormat.format("yyyy-MM-dd-HH-mm-ss", getNextMaxDailyDeadline()).toString()); StringBuilder sb = new StringBuilder(64); int[] outInt = new int[1]; LevelStepTracker dsteps = getDailyDischargeLevelStepTracker(); LevelStepTracker csteps = getDailyChargeLevelStepTracker(); ArrayList pkgc = getDailyPackageChanges(); if (dsteps.mNumStepDurations > 0 || csteps.mNumStepDurations > 0 || pkgc != null) { if ((flags&DUMP_DAILY_ONLY) != 0 || !filtering) { if (dumpDurationSteps(pw, " ", " Current daily discharge step durations:", dsteps, false)) { dumpDailyLevelStepSummary(pw, " ", "Discharge", dsteps, sb, outInt); } if (dumpDurationSteps(pw, " ", " Current daily charge step durations:", csteps, false)) { dumpDailyLevelStepSummary(pw, " ", "Charge", csteps, sb, outInt); } dumpDailyPackageChanges(pw, " ", pkgc); } else { pw.println(" Current daily steps:"); dumpDailyLevelStepSummary(pw, " ", "Discharge", dsteps, sb, outInt); dumpDailyLevelStepSummary(pw, " ", "Charge", csteps, sb, outInt); } } DailyItem dit; int curIndex = 0; while ((dit=getDailyItemLocked(curIndex)) != null) { curIndex++; if ((flags&DUMP_DAILY_ONLY) != 0) { pw.println(); } pw.print(" Daily from "); pw.print(DateFormat.format("yyyy-MM-dd-HH-mm-ss", dit.mStartTime).toString()); pw.print(" to "); pw.print(DateFormat.format("yyyy-MM-dd-HH-mm-ss", dit.mEndTime).toString()); pw.println(":"); if ((flags&DUMP_DAILY_ONLY) != 0 || !filtering) { if (dumpDurationSteps(pw, " ", " Discharge step durations:", dit.mDischargeSteps, false)) { dumpDailyLevelStepSummary(pw, " ", "Discharge", dit.mDischargeSteps, sb, outInt); } if (dumpDurationSteps(pw, " ", " Charge step durations:", dit.mChargeSteps, false)) { dumpDailyLevelStepSummary(pw, " ", "Charge", dit.mChargeSteps, sb, outInt); } dumpDailyPackageChanges(pw, " ", dit.mPackageChanges); } else { dumpDailyLevelStepSummary(pw, " ", "Discharge", dit.mDischargeSteps, sb, outInt); dumpDailyLevelStepSummary(pw, " ", "Charge", dit.mChargeSteps, sb, outInt); } } pw.println(); } if (!filtering || (flags&DUMP_CHARGED_ONLY) != 0) { pw.println("Statistics since last charge:"); pw.println(" System starts: " + getStartCount() + ", currently on battery: " + getIsOnBattery()); dumpLocked(context, pw, "", STATS_SINCE_CHARGED, reqUid, (flags&DUMP_DEVICE_WIFI_ONLY) != 0); pw.println(); } } // This is called from BatteryStatsService. @SuppressWarnings("unused") public void dumpCheckinLocked(Context context, PrintWriter pw, List apps, int flags, long histStart) { prepareForDumpLocked(); dumpLine(pw, 0 /* uid */, "i" /* category */, VERSION_DATA, CHECKIN_VERSION, getParcelVersion(), getStartPlatformVersion(), getEndPlatformVersion()); long now = getHistoryBaseTime() + SystemClock.elapsedRealtime(); if ((flags & (DUMP_INCLUDE_HISTORY | DUMP_HISTORY_ONLY)) != 0) { if (startIteratingHistoryLocked()) { try { for (int i=0; i, MutableBoolean>> uids = new SparseArray<>(); for (int i=0; i, MutableBoolean> pkgs = uids.get( UserHandle.getAppId(ai.uid)); if (pkgs == null) { pkgs = new Pair<>(new ArrayList(), new MutableBoolean(false)); uids.put(UserHandle.getAppId(ai.uid), pkgs); } pkgs.first.add(ai.packageName); } SparseArray uidStats = getUidStats(); final int NU = uidStats.size(); String[] lineArgs = new String[2]; for (int i=0; i, MutableBoolean> pkgs = uids.get(uid); if (pkgs != null && !pkgs.second.value) { pkgs.second.value = true; for (int j=0; j= 0) { lineArgs[0] = Long.toString(timeRemaining); dumpLine(pw, 0 /* uid */, "i" /* category */, DISCHARGE_TIME_REMAIN_DATA, (Object[])lineArgs); } dumpDurationSteps(pw, "", CHARGE_STEP_DATA, getChargeLevelStepTracker(), true); timeRemaining = computeChargeTimeRemaining(SystemClock.elapsedRealtime() * 1000); if (timeRemaining >= 0) { lineArgs[0] = Long.toString(timeRemaining); dumpLine(pw, 0 /* uid */, "i" /* category */, CHARGE_TIME_REMAIN_DATA, (Object[])lineArgs); } dumpCheckinLocked(context, pw, STATS_SINCE_CHARGED, -1, (flags&DUMP_DEVICE_WIFI_ONLY) != 0); } } /** Dump #STATS_SINCE_CHARGED batterystats data to a proto. @hide */ public void dumpProtoLocked(Context context, FileDescriptor fd, List apps, int flags) { final ProtoOutputStream proto = new ProtoOutputStream(fd); final long bToken = proto.start(BatteryStatsServiceDumpProto.BATTERYSTATS); prepareForDumpLocked(); proto.write(BatteryStatsProto.REPORT_VERSION, CHECKIN_VERSION); proto.write(BatteryStatsProto.PARCEL_VERSION, getParcelVersion()); proto.write(BatteryStatsProto.START_PLATFORM_VERSION, getStartPlatformVersion()); proto.write(BatteryStatsProto.END_PLATFORM_VERSION, getEndPlatformVersion()); // History intentionally not included in proto dump. if ((flags & (DUMP_HISTORY_ONLY | DUMP_DAILY_ONLY)) == 0) { final BatteryStatsHelper helper = new BatteryStatsHelper(context, false, (flags & DUMP_DEVICE_WIFI_ONLY) != 0); helper.create(this); helper.refreshStats(STATS_SINCE_CHARGED, UserHandle.USER_ALL); dumpProtoAppsLocked(proto, helper, apps); dumpProtoSystemLocked(proto, helper); } proto.end(bToken); proto.flush(); } private void dumpProtoAppsLocked(ProtoOutputStream proto, BatteryStatsHelper helper, List apps) { final int which = STATS_SINCE_CHARGED; final long rawUptimeUs = SystemClock.uptimeMillis() * 1000; final long rawRealtimeMs = SystemClock.elapsedRealtime(); final long rawRealtimeUs = rawRealtimeMs * 1000; final long batteryUptimeUs = getBatteryUptime(rawUptimeUs); SparseArray> aidToPackages = new SparseArray<>(); if (apps != null) { for (int i = 0; i < apps.size(); ++i) { ApplicationInfo ai = apps.get(i); int aid = UserHandle.getAppId(ai.uid); ArrayList pkgs = aidToPackages.get(aid); if (pkgs == null) { pkgs = new ArrayList(); aidToPackages.put(aid, pkgs); } pkgs.add(ai.packageName); } } SparseArray uidToSipper = new SparseArray<>(); final List sippers = helper.getUsageList(); if (sippers != null) { for (int i = 0; i < sippers.size(); ++i) { final BatterySipper bs = sippers.get(i); if (bs.drainType != BatterySipper.DrainType.APP) { // Others are handled by dumpProtoSystemLocked() continue; } uidToSipper.put(bs.uidObj.getUid(), bs); } } SparseArray uidStats = getUidStats(); final int n = uidStats.size(); for (int iu = 0; iu < n; ++iu) { final long uTkn = proto.start(BatteryStatsProto.UIDS); final Uid u = uidStats.valueAt(iu); final int uid = uidStats.keyAt(iu); proto.write(UidProto.UID, uid); // Print packages and apk stats (UID_DATA & APK_DATA) ArrayList pkgs = aidToPackages.get(UserHandle.getAppId(uid)); if (pkgs == null) { pkgs = new ArrayList(); } final ArrayMap packageStats = u.getPackageStats(); for (int ipkg = packageStats.size() - 1; ipkg >= 0; --ipkg) { String pkg = packageStats.keyAt(ipkg); final ArrayMap serviceStats = packageStats.valueAt(ipkg).getServiceStats(); if (serviceStats.size() == 0) { // Due to the way ActivityManagerService logs wakeup alarms, some packages (for // example, "android") may be included in the packageStats that aren't part of // the UID. If they don't have any services, then they shouldn't be listed here. // These packages won't be a part in the pkgs List. continue; } final long pToken = proto.start(UidProto.PACKAGES); proto.write(UidProto.Package.NAME, pkg); // Remove from the packages list since we're logging it here. pkgs.remove(pkg); for (int isvc = serviceStats.size() - 1; isvc >= 0; --isvc) { final BatteryStats.Uid.Pkg.Serv ss = serviceStats.valueAt(isvc); long sToken = proto.start(UidProto.Package.SERVICES); proto.write(UidProto.Package.Service.NAME, serviceStats.keyAt(isvc)); proto.write(UidProto.Package.Service.START_DURATION_MS, roundUsToMs(ss.getStartTime(batteryUptimeUs, which))); proto.write(UidProto.Package.Service.START_COUNT, ss.getStarts(which)); proto.write(UidProto.Package.Service.LAUNCH_COUNT, ss.getLaunches(which)); proto.end(sToken); } proto.end(pToken); } // Print any remaining packages that weren't in the packageStats map. pkgs is pulled // from PackageManager data. Packages are only included in packageStats if there was // specific data tracked for them (services and wakeup alarms, etc.). for (String p : pkgs) { final long pToken = proto.start(UidProto.PACKAGES); proto.write(UidProto.Package.NAME, p); proto.end(pToken); } // Total wakelock data (AGGREGATED_WAKELOCK_DATA) if (u.getAggregatedPartialWakelockTimer() != null) { final Timer timer = u.getAggregatedPartialWakelockTimer(); // Times are since reset (regardless of 'which') final long totTimeMs = timer.getTotalDurationMsLocked(rawRealtimeMs); final Timer bgTimer = timer.getSubTimer(); final long bgTimeMs = bgTimer != null ? bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : 0; final long awToken = proto.start(UidProto.AGGREGATED_WAKELOCK); proto.write(UidProto.AggregatedWakelock.PARTIAL_DURATION_MS, totTimeMs); proto.write(UidProto.AggregatedWakelock.BACKGROUND_PARTIAL_DURATION_MS, bgTimeMs); proto.end(awToken); } // Audio (AUDIO_DATA) dumpTimer(proto, UidProto.AUDIO, u.getAudioTurnedOnTimer(), rawRealtimeUs, which); // Bluetooth Controller (BLUETOOTH_CONTROLLER_DATA) dumpControllerActivityProto(proto, UidProto.BLUETOOTH_CONTROLLER, u.getBluetoothControllerActivity(), which); // BLE scans (BLUETOOTH_MISC_DATA) (uses totalDurationMsLocked and MaxDurationMsLocked) final Timer bleTimer = u.getBluetoothScanTimer(); if (bleTimer != null) { final long bmToken = proto.start(UidProto.BLUETOOTH_MISC); dumpTimer(proto, UidProto.BluetoothMisc.APPORTIONED_BLE_SCAN, bleTimer, rawRealtimeUs, which); dumpTimer(proto, UidProto.BluetoothMisc.BACKGROUND_BLE_SCAN, u.getBluetoothScanBackgroundTimer(), rawRealtimeUs, which); // Unoptimized scan timer. Unpooled and since reset (regardless of 'which'). dumpTimer(proto, UidProto.BluetoothMisc.UNOPTIMIZED_BLE_SCAN, u.getBluetoothUnoptimizedScanTimer(), rawRealtimeUs, which); // Unoptimized bg scan timer. Unpooled and since reset (regardless of 'which'). dumpTimer(proto, UidProto.BluetoothMisc.BACKGROUND_UNOPTIMIZED_BLE_SCAN, u.getBluetoothUnoptimizedScanBackgroundTimer(), rawRealtimeUs, which); // Result counters proto.write(UidProto.BluetoothMisc.BLE_SCAN_RESULT_COUNT, u.getBluetoothScanResultCounter() != null ? u.getBluetoothScanResultCounter().getCountLocked(which) : 0); proto.write(UidProto.BluetoothMisc.BACKGROUND_BLE_SCAN_RESULT_COUNT, u.getBluetoothScanResultBgCounter() != null ? u.getBluetoothScanResultBgCounter().getCountLocked(which) : 0); proto.end(bmToken); } // Camera (CAMERA_DATA) dumpTimer(proto, UidProto.CAMERA, u.getCameraTurnedOnTimer(), rawRealtimeUs, which); // CPU stats (CPU_DATA & CPU_TIMES_AT_FREQ_DATA) final long cpuToken = proto.start(UidProto.CPU); proto.write(UidProto.Cpu.USER_DURATION_MS, roundUsToMs(u.getUserCpuTimeUs(which))); proto.write(UidProto.Cpu.SYSTEM_DURATION_MS, roundUsToMs(u.getSystemCpuTimeUs(which))); final long[] cpuFreqs = getCpuFreqs(); if (cpuFreqs != null) { final long[] cpuFreqTimeMs = u.getCpuFreqTimes(which); // If total cpuFreqTimes is null, then we don't need to check for // screenOffCpuFreqTimes. if (cpuFreqTimeMs != null && cpuFreqTimeMs.length == cpuFreqs.length) { long[] screenOffCpuFreqTimeMs = u.getScreenOffCpuFreqTimes(which); if (screenOffCpuFreqTimeMs == null) { screenOffCpuFreqTimeMs = new long[cpuFreqTimeMs.length]; } for (int ic = 0; ic < cpuFreqTimeMs.length; ++ic) { long cToken = proto.start(UidProto.Cpu.BY_FREQUENCY); proto.write(UidProto.Cpu.ByFrequency.FREQUENCY_INDEX, ic + 1); proto.write(UidProto.Cpu.ByFrequency.TOTAL_DURATION_MS, cpuFreqTimeMs[ic]); proto.write(UidProto.Cpu.ByFrequency.SCREEN_OFF_DURATION_MS, screenOffCpuFreqTimeMs[ic]); proto.end(cToken); } } } for (int procState = 0; procState < Uid.NUM_PROCESS_STATE; ++procState) { final long[] timesMs = u.getCpuFreqTimes(which, procState); if (timesMs != null && timesMs.length == cpuFreqs.length) { long[] screenOffTimesMs = u.getScreenOffCpuFreqTimes(which, procState); if (screenOffTimesMs == null) { screenOffTimesMs = new long[timesMs.length]; } final long procToken = proto.start(UidProto.Cpu.BY_PROCESS_STATE); proto.write(UidProto.Cpu.ByProcessState.PROCESS_STATE, procState); for (int ic = 0; ic < timesMs.length; ++ic) { long cToken = proto.start(UidProto.Cpu.ByProcessState.BY_FREQUENCY); proto.write(UidProto.Cpu.ByFrequency.FREQUENCY_INDEX, ic + 1); proto.write(UidProto.Cpu.ByFrequency.TOTAL_DURATION_MS, timesMs[ic]); proto.write(UidProto.Cpu.ByFrequency.SCREEN_OFF_DURATION_MS, screenOffTimesMs[ic]); proto.end(cToken); } proto.end(procToken); } } proto.end(cpuToken); // Flashlight (FLASHLIGHT_DATA) dumpTimer(proto, UidProto.FLASHLIGHT, u.getFlashlightTurnedOnTimer(), rawRealtimeUs, which); // Foreground activity (FOREGROUND_ACTIVITY_DATA) dumpTimer(proto, UidProto.FOREGROUND_ACTIVITY, u.getForegroundActivityTimer(), rawRealtimeUs, which); // Foreground service (FOREGROUND_SERVICE_DATA) dumpTimer(proto, UidProto.FOREGROUND_SERVICE, u.getForegroundServiceTimer(), rawRealtimeUs, which); // Job completion (JOB_COMPLETION_DATA) final ArrayMap completions = u.getJobCompletionStats(); final int[] reasons = new int[]{ JobParameters.REASON_CANCELED, JobParameters.REASON_CONSTRAINTS_NOT_SATISFIED, JobParameters.REASON_PREEMPT, JobParameters.REASON_TIMEOUT, JobParameters.REASON_DEVICE_IDLE, }; for (int ic = 0; ic < completions.size(); ++ic) { SparseIntArray types = completions.valueAt(ic); if (types != null) { final long jcToken = proto.start(UidProto.JOB_COMPLETION); proto.write(UidProto.JobCompletion.NAME, completions.keyAt(ic)); for (int r : reasons) { long rToken = proto.start(UidProto.JobCompletion.REASON_COUNT); proto.write(UidProto.JobCompletion.ReasonCount.NAME, r); proto.write(UidProto.JobCompletion.ReasonCount.COUNT, types.get(r, 0)); proto.end(rToken); } proto.end(jcToken); } } // Scheduled jobs (JOB_DATA) final ArrayMap jobs = u.getJobStats(); for (int ij = jobs.size() - 1; ij >= 0; --ij) { final Timer timer = jobs.valueAt(ij); final Timer bgTimer = timer.getSubTimer(); final long jToken = proto.start(UidProto.JOBS); proto.write(UidProto.Job.NAME, jobs.keyAt(ij)); // Background uses totalDurationMsLocked, while total uses totalTimeLocked dumpTimer(proto, UidProto.Job.TOTAL, timer, rawRealtimeUs, which); dumpTimer(proto, UidProto.Job.BACKGROUND, bgTimer, rawRealtimeUs, which); proto.end(jToken); } // Modem Controller (MODEM_CONTROLLER_DATA) dumpControllerActivityProto(proto, UidProto.MODEM_CONTROLLER, u.getModemControllerActivity(), which); // Network stats (NETWORK_DATA) final long nToken = proto.start(UidProto.NETWORK); proto.write(UidProto.Network.MOBILE_BYTES_RX, u.getNetworkActivityBytes(NETWORK_MOBILE_RX_DATA, which)); proto.write(UidProto.Network.MOBILE_BYTES_TX, u.getNetworkActivityBytes(NETWORK_MOBILE_TX_DATA, which)); proto.write(UidProto.Network.WIFI_BYTES_RX, u.getNetworkActivityBytes(NETWORK_WIFI_RX_DATA, which)); proto.write(UidProto.Network.WIFI_BYTES_TX, u.getNetworkActivityBytes(NETWORK_WIFI_TX_DATA, which)); proto.write(UidProto.Network.BT_BYTES_RX, u.getNetworkActivityBytes(NETWORK_BT_RX_DATA, which)); proto.write(UidProto.Network.BT_BYTES_TX, u.getNetworkActivityBytes(NETWORK_BT_TX_DATA, which)); proto.write(UidProto.Network.MOBILE_PACKETS_RX, u.getNetworkActivityPackets(NETWORK_MOBILE_RX_DATA, which)); proto.write(UidProto.Network.MOBILE_PACKETS_TX, u.getNetworkActivityPackets(NETWORK_MOBILE_TX_DATA, which)); proto.write(UidProto.Network.WIFI_PACKETS_RX, u.getNetworkActivityPackets(NETWORK_WIFI_RX_DATA, which)); proto.write(UidProto.Network.WIFI_PACKETS_TX, u.getNetworkActivityPackets(NETWORK_WIFI_TX_DATA, which)); proto.write(UidProto.Network.MOBILE_ACTIVE_DURATION_MS, roundUsToMs(u.getMobileRadioActiveTime(which))); proto.write(UidProto.Network.MOBILE_ACTIVE_COUNT, u.getMobileRadioActiveCount(which)); proto.write(UidProto.Network.MOBILE_WAKEUP_COUNT, u.getMobileRadioApWakeupCount(which)); proto.write(UidProto.Network.WIFI_WAKEUP_COUNT, u.getWifiRadioApWakeupCount(which)); proto.write(UidProto.Network.MOBILE_BYTES_BG_RX, u.getNetworkActivityBytes(NETWORK_MOBILE_BG_RX_DATA, which)); proto.write(UidProto.Network.MOBILE_BYTES_BG_TX, u.getNetworkActivityBytes(NETWORK_MOBILE_BG_TX_DATA, which)); proto.write(UidProto.Network.WIFI_BYTES_BG_RX, u.getNetworkActivityBytes(NETWORK_WIFI_BG_RX_DATA, which)); proto.write(UidProto.Network.WIFI_BYTES_BG_TX, u.getNetworkActivityBytes(NETWORK_WIFI_BG_TX_DATA, which)); proto.write(UidProto.Network.MOBILE_PACKETS_BG_RX, u.getNetworkActivityPackets(NETWORK_MOBILE_BG_RX_DATA, which)); proto.write(UidProto.Network.MOBILE_PACKETS_BG_TX, u.getNetworkActivityPackets(NETWORK_MOBILE_BG_TX_DATA, which)); proto.write(UidProto.Network.WIFI_PACKETS_BG_RX, u.getNetworkActivityPackets(NETWORK_WIFI_BG_RX_DATA, which)); proto.write(UidProto.Network.WIFI_PACKETS_BG_TX, u.getNetworkActivityPackets(NETWORK_WIFI_BG_TX_DATA, which)); proto.end(nToken); // Power use item (POWER_USE_ITEM_DATA) BatterySipper bs = uidToSipper.get(uid); if (bs != null) { final long bsToken = proto.start(UidProto.POWER_USE_ITEM); proto.write(UidProto.PowerUseItem.COMPUTED_POWER_MAH, bs.totalPowerMah); proto.write(UidProto.PowerUseItem.SHOULD_HIDE, bs.shouldHide); proto.write(UidProto.PowerUseItem.SCREEN_POWER_MAH, bs.screenPowerMah); proto.write(UidProto.PowerUseItem.PROPORTIONAL_SMEAR_MAH, bs.proportionalSmearMah); proto.end(bsToken); } // Processes (PROCESS_DATA) final ArrayMap processStats = u.getProcessStats(); for (int ipr = processStats.size() - 1; ipr >= 0; --ipr) { final Uid.Proc ps = processStats.valueAt(ipr); final long prToken = proto.start(UidProto.PROCESS); proto.write(UidProto.Process.NAME, processStats.keyAt(ipr)); proto.write(UidProto.Process.USER_DURATION_MS, ps.getUserTime(which)); proto.write(UidProto.Process.SYSTEM_DURATION_MS, ps.getSystemTime(which)); proto.write(UidProto.Process.FOREGROUND_DURATION_MS, ps.getForegroundTime(which)); proto.write(UidProto.Process.START_COUNT, ps.getStarts(which)); proto.write(UidProto.Process.ANR_COUNT, ps.getNumAnrs(which)); proto.write(UidProto.Process.CRASH_COUNT, ps.getNumCrashes(which)); proto.end(prToken); } // Sensors (SENSOR_DATA) final SparseArray sensors = u.getSensorStats(); for (int ise = 0; ise < sensors.size(); ++ise) { final Uid.Sensor se = sensors.valueAt(ise); final Timer timer = se.getSensorTime(); if (timer == null) { continue; } final Timer bgTimer = se.getSensorBackgroundTime(); final int sensorNumber = sensors.keyAt(ise); final long seToken = proto.start(UidProto.SENSORS); proto.write(UidProto.Sensor.ID, sensorNumber); // Background uses totalDurationMsLocked, while total uses totalTimeLocked dumpTimer(proto, UidProto.Sensor.APPORTIONED, timer, rawRealtimeUs, which); dumpTimer(proto, UidProto.Sensor.BACKGROUND, bgTimer, rawRealtimeUs, which); proto.end(seToken); } // State times (STATE_TIME_DATA) for (int ips = 0; ips < Uid.NUM_PROCESS_STATE; ++ips) { long durMs = roundUsToMs(u.getProcessStateTime(ips, rawRealtimeUs, which)); if (durMs == 0) { continue; } final long stToken = proto.start(UidProto.STATES); proto.write(UidProto.StateTime.STATE, ips); proto.write(UidProto.StateTime.DURATION_MS, durMs); proto.end(stToken); } // Syncs (SYNC_DATA) final ArrayMap syncs = u.getSyncStats(); for (int isy = syncs.size() - 1; isy >= 0; --isy) { final Timer timer = syncs.valueAt(isy); final Timer bgTimer = timer.getSubTimer(); final long syToken = proto.start(UidProto.SYNCS); proto.write(UidProto.Sync.NAME, syncs.keyAt(isy)); // Background uses totalDurationMsLocked, while total uses totalTimeLocked dumpTimer(proto, UidProto.Sync.TOTAL, timer, rawRealtimeUs, which); dumpTimer(proto, UidProto.Sync.BACKGROUND, bgTimer, rawRealtimeUs, which); proto.end(syToken); } // User activity (USER_ACTIVITY_DATA) if (u.hasUserActivity()) { for (int i = 0; i < Uid.NUM_USER_ACTIVITY_TYPES; ++i) { int val = u.getUserActivityCount(i, which); if (val != 0) { final long uaToken = proto.start(UidProto.USER_ACTIVITY); proto.write(UidProto.UserActivity.NAME, i); proto.write(UidProto.UserActivity.COUNT, val); proto.end(uaToken); } } } // Vibrator (VIBRATOR_DATA) dumpTimer(proto, UidProto.VIBRATOR, u.getVibratorOnTimer(), rawRealtimeUs, which); // Video (VIDEO_DATA) dumpTimer(proto, UidProto.VIDEO, u.getVideoTurnedOnTimer(), rawRealtimeUs, which); // Wakelocks (WAKELOCK_DATA) final ArrayMap wakelocks = u.getWakelockStats(); for (int iw = wakelocks.size() - 1; iw >= 0; --iw) { final Uid.Wakelock wl = wakelocks.valueAt(iw); final long wToken = proto.start(UidProto.WAKELOCKS); proto.write(UidProto.Wakelock.NAME, wakelocks.keyAt(iw)); dumpTimer(proto, UidProto.Wakelock.FULL, wl.getWakeTime(WAKE_TYPE_FULL), rawRealtimeUs, which); final Timer pTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL); if (pTimer != null) { dumpTimer(proto, UidProto.Wakelock.PARTIAL, pTimer, rawRealtimeUs, which); dumpTimer(proto, UidProto.Wakelock.BACKGROUND_PARTIAL, pTimer.getSubTimer(), rawRealtimeUs, which); } dumpTimer(proto, UidProto.Wakelock.WINDOW, wl.getWakeTime(WAKE_TYPE_WINDOW), rawRealtimeUs, which); proto.end(wToken); } // Wifi Multicast Wakelock (WIFI_MULTICAST_WAKELOCK_DATA) dumpTimer(proto, UidProto.WIFI_MULTICAST_WAKELOCK, u.getMulticastWakelockStats(), rawRealtimeUs, which); // Wakeup alarms (WAKEUP_ALARM_DATA) for (int ipkg = packageStats.size() - 1; ipkg >= 0; --ipkg) { final Uid.Pkg ps = packageStats.valueAt(ipkg); final ArrayMap alarms = ps.getWakeupAlarmStats(); for (int iwa = alarms.size() - 1; iwa >= 0; --iwa) { final long waToken = proto.start(UidProto.WAKEUP_ALARM); proto.write(UidProto.WakeupAlarm.NAME, alarms.keyAt(iwa)); proto.write(UidProto.WakeupAlarm.COUNT, alarms.valueAt(iwa).getCountLocked(which)); proto.end(waToken); } } // Wifi Controller (WIFI_CONTROLLER_DATA) dumpControllerActivityProto(proto, UidProto.WIFI_CONTROLLER, u.getWifiControllerActivity(), which); // Wifi data (WIFI_DATA) final long wToken = proto.start(UidProto.WIFI); proto.write(UidProto.Wifi.FULL_WIFI_LOCK_DURATION_MS, roundUsToMs(u.getFullWifiLockTime(rawRealtimeUs, which))); dumpTimer(proto, UidProto.Wifi.APPORTIONED_SCAN, u.getWifiScanTimer(), rawRealtimeUs, which); proto.write(UidProto.Wifi.RUNNING_DURATION_MS, roundUsToMs(u.getWifiRunningTime(rawRealtimeUs, which))); dumpTimer(proto, UidProto.Wifi.BACKGROUND_SCAN, u.getWifiScanBackgroundTimer(), rawRealtimeUs, which); proto.end(wToken); proto.end(uTkn); } } private void dumpProtoSystemLocked(ProtoOutputStream proto, BatteryStatsHelper helper) { final long sToken = proto.start(BatteryStatsProto.SYSTEM); final long rawUptimeUs = SystemClock.uptimeMillis() * 1000; final long rawRealtimeMs = SystemClock.elapsedRealtime(); final long rawRealtimeUs = rawRealtimeMs * 1000; final int which = STATS_SINCE_CHARGED; // Battery data (BATTERY_DATA) final long bToken = proto.start(SystemProto.BATTERY); proto.write(SystemProto.Battery.START_CLOCK_TIME_MS, getStartClockTime()); proto.write(SystemProto.Battery.START_COUNT, getStartCount()); proto.write(SystemProto.Battery.TOTAL_REALTIME_MS, computeRealtime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Battery.TOTAL_UPTIME_MS, computeUptime(rawUptimeUs, which) / 1000); proto.write(SystemProto.Battery.BATTERY_REALTIME_MS, computeBatteryRealtime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Battery.BATTERY_UPTIME_MS, computeBatteryUptime(rawUptimeUs, which) / 1000); proto.write(SystemProto.Battery.SCREEN_OFF_REALTIME_MS, computeBatteryScreenOffRealtime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Battery.SCREEN_OFF_UPTIME_MS, computeBatteryScreenOffUptime(rawUptimeUs, which) / 1000); proto.write(SystemProto.Battery.SCREEN_DOZE_DURATION_MS, getScreenDozeTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Battery.ESTIMATED_BATTERY_CAPACITY_MAH, getEstimatedBatteryCapacity()); proto.write(SystemProto.Battery.MIN_LEARNED_BATTERY_CAPACITY_UAH, getMinLearnedBatteryCapacity()); proto.write(SystemProto.Battery.MAX_LEARNED_BATTERY_CAPACITY_UAH, getMaxLearnedBatteryCapacity()); proto.end(bToken); // Battery discharge (BATTERY_DISCHARGE_DATA) final long bdToken = proto.start(SystemProto.BATTERY_DISCHARGE); proto.write(SystemProto.BatteryDischarge.LOWER_BOUND_SINCE_CHARGE, getLowDischargeAmountSinceCharge()); proto.write(SystemProto.BatteryDischarge.UPPER_BOUND_SINCE_CHARGE, getHighDischargeAmountSinceCharge()); proto.write(SystemProto.BatteryDischarge.SCREEN_ON_SINCE_CHARGE, getDischargeAmountScreenOnSinceCharge()); proto.write(SystemProto.BatteryDischarge.SCREEN_OFF_SINCE_CHARGE, getDischargeAmountScreenOffSinceCharge()); proto.write(SystemProto.BatteryDischarge.SCREEN_DOZE_SINCE_CHARGE, getDischargeAmountScreenDozeSinceCharge()); proto.write(SystemProto.BatteryDischarge.TOTAL_MAH, getUahDischarge(which) / 1000); proto.write(SystemProto.BatteryDischarge.TOTAL_MAH_SCREEN_OFF, getUahDischargeScreenOff(which) / 1000); proto.write(SystemProto.BatteryDischarge.TOTAL_MAH_SCREEN_DOZE, getUahDischargeScreenDoze(which) / 1000); proto.write(SystemProto.BatteryDischarge.TOTAL_MAH_LIGHT_DOZE, getUahDischargeLightDoze(which) / 1000); proto.write(SystemProto.BatteryDischarge.TOTAL_MAH_DEEP_DOZE, getUahDischargeDeepDoze(which) / 1000); proto.end(bdToken); // Time remaining long timeRemainingUs = computeChargeTimeRemaining(rawRealtimeUs); // These are part of a oneof, so we should only set one of them. if (timeRemainingUs >= 0) { // Charge time remaining (CHARGE_TIME_REMAIN_DATA) proto.write(SystemProto.CHARGE_TIME_REMAINING_MS, timeRemainingUs / 1000); } else { timeRemainingUs = computeBatteryTimeRemaining(rawRealtimeUs); // Discharge time remaining (DISCHARGE_TIME_REMAIN_DATA) if (timeRemainingUs >= 0) { proto.write(SystemProto.DISCHARGE_TIME_REMAINING_MS, timeRemainingUs / 1000); } else { proto.write(SystemProto.DISCHARGE_TIME_REMAINING_MS, -1); } } // Charge step (CHARGE_STEP_DATA) dumpDurationSteps(proto, SystemProto.CHARGE_STEP, getChargeLevelStepTracker()); // Phone data connection (DATA_CONNECTION_TIME_DATA and DATA_CONNECTION_COUNT_DATA) for (int i = 0; i < NUM_DATA_CONNECTION_TYPES; ++i) { // Map OTHER to TelephonyManager.NETWORK_TYPE_UNKNOWN and mark NONE as a boolean. boolean isNone = (i == DATA_CONNECTION_NONE); int telephonyNetworkType = i; if (i == DATA_CONNECTION_OTHER) { telephonyNetworkType = TelephonyManager.NETWORK_TYPE_UNKNOWN; } final long pdcToken = proto.start(SystemProto.DATA_CONNECTION); if (isNone) { proto.write(SystemProto.DataConnection.IS_NONE, isNone); } else { proto.write(SystemProto.DataConnection.NAME, telephonyNetworkType); } dumpTimer(proto, SystemProto.DataConnection.TOTAL, getPhoneDataConnectionTimer(i), rawRealtimeUs, which); proto.end(pdcToken); } // Discharge step (DISCHARGE_STEP_DATA) dumpDurationSteps(proto, SystemProto.DISCHARGE_STEP, getDischargeLevelStepTracker()); // CPU frequencies (GLOBAL_CPU_FREQ_DATA) final long[] cpuFreqs = getCpuFreqs(); if (cpuFreqs != null) { for (long i : cpuFreqs) { proto.write(SystemProto.CPU_FREQUENCY, i); } } // Bluetooth controller (GLOBAL_BLUETOOTH_CONTROLLER_DATA) dumpControllerActivityProto(proto, SystemProto.GLOBAL_BLUETOOTH_CONTROLLER, getBluetoothControllerActivity(), which); // Modem controller (GLOBAL_MODEM_CONTROLLER_DATA) dumpControllerActivityProto(proto, SystemProto.GLOBAL_MODEM_CONTROLLER, getModemControllerActivity(), which); // Global network data (GLOBAL_NETWORK_DATA) final long gnToken = proto.start(SystemProto.GLOBAL_NETWORK); proto.write(SystemProto.GlobalNetwork.MOBILE_BYTES_RX, getNetworkActivityBytes(NETWORK_MOBILE_RX_DATA, which)); proto.write(SystemProto.GlobalNetwork.MOBILE_BYTES_TX, getNetworkActivityBytes(NETWORK_MOBILE_TX_DATA, which)); proto.write(SystemProto.GlobalNetwork.MOBILE_PACKETS_RX, getNetworkActivityPackets(NETWORK_MOBILE_RX_DATA, which)); proto.write(SystemProto.GlobalNetwork.MOBILE_PACKETS_TX, getNetworkActivityPackets(NETWORK_MOBILE_TX_DATA, which)); proto.write(SystemProto.GlobalNetwork.WIFI_BYTES_RX, getNetworkActivityBytes(NETWORK_WIFI_RX_DATA, which)); proto.write(SystemProto.GlobalNetwork.WIFI_BYTES_TX, getNetworkActivityBytes(NETWORK_WIFI_TX_DATA, which)); proto.write(SystemProto.GlobalNetwork.WIFI_PACKETS_RX, getNetworkActivityPackets(NETWORK_WIFI_RX_DATA, which)); proto.write(SystemProto.GlobalNetwork.WIFI_PACKETS_TX, getNetworkActivityPackets(NETWORK_WIFI_TX_DATA, which)); proto.write(SystemProto.GlobalNetwork.BT_BYTES_RX, getNetworkActivityBytes(NETWORK_BT_RX_DATA, which)); proto.write(SystemProto.GlobalNetwork.BT_BYTES_TX, getNetworkActivityBytes(NETWORK_BT_TX_DATA, which)); proto.end(gnToken); // Wifi controller (GLOBAL_WIFI_CONTROLLER_DATA) dumpControllerActivityProto(proto, SystemProto.GLOBAL_WIFI_CONTROLLER, getWifiControllerActivity(), which); // Global wifi (GLOBAL_WIFI_DATA) final long gwToken = proto.start(SystemProto.GLOBAL_WIFI); proto.write(SystemProto.GlobalWifi.ON_DURATION_MS, getWifiOnTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.GlobalWifi.RUNNING_DURATION_MS, getGlobalWifiRunningTime(rawRealtimeUs, which) / 1000); proto.end(gwToken); // Kernel wakelock (KERNEL_WAKELOCK_DATA) final Map kernelWakelocks = getKernelWakelockStats(); for (Map.Entry ent : kernelWakelocks.entrySet()) { final long kwToken = proto.start(SystemProto.KERNEL_WAKELOCK); proto.write(SystemProto.KernelWakelock.NAME, ent.getKey()); dumpTimer(proto, SystemProto.KernelWakelock.TOTAL, ent.getValue(), rawRealtimeUs, which); proto.end(kwToken); } // Misc (MISC_DATA) // Calculate wakelock times across all uids. long fullWakeLockTimeTotalUs = 0; long partialWakeLockTimeTotalUs = 0; final SparseArray uidStats = getUidStats(); for (int iu = 0; iu < uidStats.size(); iu++) { final Uid u = uidStats.valueAt(iu); final ArrayMap wakelocks = u.getWakelockStats(); for (int iw = wakelocks.size() - 1; iw >= 0; --iw) { final Uid.Wakelock wl = wakelocks.valueAt(iw); final Timer fullWakeTimer = wl.getWakeTime(WAKE_TYPE_FULL); if (fullWakeTimer != null) { fullWakeLockTimeTotalUs += fullWakeTimer.getTotalTimeLocked(rawRealtimeUs, which); } final Timer partialWakeTimer = wl.getWakeTime(WAKE_TYPE_PARTIAL); if (partialWakeTimer != null) { partialWakeLockTimeTotalUs += partialWakeTimer.getTotalTimeLocked( rawRealtimeUs, which); } } } final long mToken = proto.start(SystemProto.MISC); proto.write(SystemProto.Misc.SCREEN_ON_DURATION_MS, getScreenOnTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.PHONE_ON_DURATION_MS, getPhoneOnTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.FULL_WAKELOCK_TOTAL_DURATION_MS, fullWakeLockTimeTotalUs / 1000); proto.write(SystemProto.Misc.PARTIAL_WAKELOCK_TOTAL_DURATION_MS, partialWakeLockTimeTotalUs / 1000); proto.write(SystemProto.Misc.MOBILE_RADIO_ACTIVE_DURATION_MS, getMobileRadioActiveTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.MOBILE_RADIO_ACTIVE_ADJUSTED_TIME_MS, getMobileRadioActiveAdjustedTime(which) / 1000); proto.write(SystemProto.Misc.MOBILE_RADIO_ACTIVE_COUNT, getMobileRadioActiveCount(which)); proto.write(SystemProto.Misc.MOBILE_RADIO_ACTIVE_UNKNOWN_DURATION_MS, getMobileRadioActiveUnknownTime(which) / 1000); proto.write(SystemProto.Misc.INTERACTIVE_DURATION_MS, getInteractiveTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.BATTERY_SAVER_MODE_ENABLED_DURATION_MS, getPowerSaveModeEnabledTime(rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.NUM_CONNECTIVITY_CHANGES, getNumConnectivityChange(which)); proto.write(SystemProto.Misc.DEEP_DOZE_ENABLED_DURATION_MS, getDeviceIdleModeTime(DEVICE_IDLE_MODE_DEEP, rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.DEEP_DOZE_COUNT, getDeviceIdleModeCount(DEVICE_IDLE_MODE_DEEP, which)); proto.write(SystemProto.Misc.DEEP_DOZE_IDLING_DURATION_MS, getDeviceIdlingTime(DEVICE_IDLE_MODE_DEEP, rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.DEEP_DOZE_IDLING_COUNT, getDeviceIdlingCount(DEVICE_IDLE_MODE_DEEP, which)); proto.write(SystemProto.Misc.LONGEST_DEEP_DOZE_DURATION_MS, getLongestDeviceIdleModeTime(DEVICE_IDLE_MODE_DEEP)); proto.write(SystemProto.Misc.LIGHT_DOZE_ENABLED_DURATION_MS, getDeviceIdleModeTime(DEVICE_IDLE_MODE_LIGHT, rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.LIGHT_DOZE_COUNT, getDeviceIdleModeCount(DEVICE_IDLE_MODE_LIGHT, which)); proto.write(SystemProto.Misc.LIGHT_DOZE_IDLING_DURATION_MS, getDeviceIdlingTime(DEVICE_IDLE_MODE_LIGHT, rawRealtimeUs, which) / 1000); proto.write(SystemProto.Misc.LIGHT_DOZE_IDLING_COUNT, getDeviceIdlingCount(DEVICE_IDLE_MODE_LIGHT, which)); proto.write(SystemProto.Misc.LONGEST_LIGHT_DOZE_DURATION_MS, getLongestDeviceIdleModeTime(DEVICE_IDLE_MODE_LIGHT)); proto.end(mToken); // Wifi multicast wakelock total stats (WIFI_MULTICAST_WAKELOCK_TOTAL_DATA) final long multicastWakeLockTimeTotalUs = getWifiMulticastWakelockTime(rawRealtimeUs, which); final int multicastWakeLockCountTotal = getWifiMulticastWakelockCount(which); final long wmctToken = proto.start(SystemProto.WIFI_MULTICAST_WAKELOCK_TOTAL); proto.write(SystemProto.WifiMulticastWakelockTotal.DURATION_MS, multicastWakeLockTimeTotalUs / 1000); proto.write(SystemProto.WifiMulticastWakelockTotal.COUNT, multicastWakeLockCountTotal); proto.end(wmctToken); // Power use item (POWER_USE_ITEM_DATA) final List sippers = helper.getUsageList(); if (sippers != null) { for (int i = 0; i < sippers.size(); ++i) { final BatterySipper bs = sippers.get(i); int n = SystemProto.PowerUseItem.UNKNOWN_SIPPER; int uid = 0; switch (bs.drainType) { case IDLE: n = SystemProto.PowerUseItem.IDLE; break; case CELL: n = SystemProto.PowerUseItem.CELL; break; case PHONE: n = SystemProto.PowerUseItem.PHONE; break; case WIFI: n = SystemProto.PowerUseItem.WIFI; break; case BLUETOOTH: n = SystemProto.PowerUseItem.BLUETOOTH; break; case SCREEN: n = SystemProto.PowerUseItem.SCREEN; break; case FLASHLIGHT: n = SystemProto.PowerUseItem.FLASHLIGHT; break; case APP: // dumpProtoAppsLocked will handle this. continue; case USER: n = SystemProto.PowerUseItem.USER; uid = UserHandle.getUid(bs.userId, 0); break; case UNACCOUNTED: n = SystemProto.PowerUseItem.UNACCOUNTED; break; case OVERCOUNTED: n = SystemProto.PowerUseItem.OVERCOUNTED; break; case CAMERA: n = SystemProto.PowerUseItem.CAMERA; break; case MEMORY: n = SystemProto.PowerUseItem.MEMORY; break; } final long puiToken = proto.start(SystemProto.POWER_USE_ITEM); proto.write(SystemProto.PowerUseItem.NAME, n); proto.write(SystemProto.PowerUseItem.UID, uid); proto.write(SystemProto.PowerUseItem.COMPUTED_POWER_MAH, bs.totalPowerMah); proto.write(SystemProto.PowerUseItem.SHOULD_HIDE, bs.shouldHide); proto.write(SystemProto.PowerUseItem.SCREEN_POWER_MAH, bs.screenPowerMah); proto.write(SystemProto.PowerUseItem.PROPORTIONAL_SMEAR_MAH, bs.proportionalSmearMah); proto.end(puiToken); } } // Power use summary (POWER_USE_SUMMARY_DATA) final long pusToken = proto.start(SystemProto.POWER_USE_SUMMARY); proto.write(SystemProto.PowerUseSummary.BATTERY_CAPACITY_MAH, helper.getPowerProfile().getBatteryCapacity()); proto.write(SystemProto.PowerUseSummary.COMPUTED_POWER_MAH, helper.getComputedPower()); proto.write(SystemProto.PowerUseSummary.MIN_DRAINED_POWER_MAH, helper.getMinDrainedPower()); proto.write(SystemProto.PowerUseSummary.MAX_DRAINED_POWER_MAH, helper.getMaxDrainedPower()); proto.end(pusToken); // RPM stats (RESOURCE_POWER_MANAGER_DATA) final Map rpmStats = getRpmStats(); final Map screenOffRpmStats = getScreenOffRpmStats(); for (Map.Entry ent : rpmStats.entrySet()) { final long rpmToken = proto.start(SystemProto.RESOURCE_POWER_MANAGER); proto.write(SystemProto.ResourcePowerManager.NAME, ent.getKey()); dumpTimer(proto, SystemProto.ResourcePowerManager.TOTAL, ent.getValue(), rawRealtimeUs, which); dumpTimer(proto, SystemProto.ResourcePowerManager.SCREEN_OFF, screenOffRpmStats.get(ent.getKey()), rawRealtimeUs, which); proto.end(rpmToken); } // Screen brightness (SCREEN_BRIGHTNESS_DATA) for (int i = 0; i < NUM_SCREEN_BRIGHTNESS_BINS; ++i) { final long sbToken = proto.start(SystemProto.SCREEN_BRIGHTNESS); proto.write(SystemProto.ScreenBrightness.NAME, i); dumpTimer(proto, SystemProto.ScreenBrightness.TOTAL, getScreenBrightnessTimer(i), rawRealtimeUs, which); proto.end(sbToken); } // Signal scanning time (SIGNAL_SCANNING_TIME_DATA) dumpTimer(proto, SystemProto.SIGNAL_SCANNING, getPhoneSignalScanningTimer(), rawRealtimeUs, which); // Phone signal strength (SIGNAL_STRENGTH_TIME_DATA and SIGNAL_STRENGTH_COUNT_DATA) for (int i = 0; i < SignalStrength.NUM_SIGNAL_STRENGTH_BINS; ++i) { final long pssToken = proto.start(SystemProto.PHONE_SIGNAL_STRENGTH); proto.write(SystemProto.PhoneSignalStrength.NAME, i); dumpTimer(proto, SystemProto.PhoneSignalStrength.TOTAL, getPhoneSignalStrengthTimer(i), rawRealtimeUs, which); proto.end(pssToken); } // Wakeup reasons (WAKEUP_REASON_DATA) final Map wakeupReasons = getWakeupReasonStats(); for (Map.Entry ent : wakeupReasons.entrySet()) { final long wrToken = proto.start(SystemProto.WAKEUP_REASON); proto.write(SystemProto.WakeupReason.NAME, ent.getKey()); dumpTimer(proto, SystemProto.WakeupReason.TOTAL, ent.getValue(), rawRealtimeUs, which); proto.end(wrToken); } // Wifi signal strength (WIFI_SIGNAL_STRENGTH_TIME_DATA and WIFI_SIGNAL_STRENGTH_COUNT_DATA) for (int i = 0; i < NUM_WIFI_SIGNAL_STRENGTH_BINS; ++i) { final long wssToken = proto.start(SystemProto.WIFI_SIGNAL_STRENGTH); proto.write(SystemProto.WifiSignalStrength.NAME, i); dumpTimer(proto, SystemProto.WifiSignalStrength.TOTAL, getWifiSignalStrengthTimer(i), rawRealtimeUs, which); proto.end(wssToken); } // Wifi state (WIFI_STATE_TIME_DATA and WIFI_STATE_COUNT_DATA) for (int i = 0; i < NUM_WIFI_STATES; ++i) { final long wsToken = proto.start(SystemProto.WIFI_STATE); proto.write(SystemProto.WifiState.NAME, i); dumpTimer(proto, SystemProto.WifiState.TOTAL, getWifiStateTimer(i), rawRealtimeUs, which); proto.end(wsToken); } // Wifi supplicant state (WIFI_SUPPL_STATE_TIME_DATA and WIFI_SUPPL_STATE_COUNT_DATA) for (int i = 0; i < NUM_WIFI_SUPPL_STATES; ++i) { final long wssToken = proto.start(SystemProto.WIFI_SUPPLICANT_STATE); proto.write(SystemProto.WifiSupplicantState.NAME, i); dumpTimer(proto, SystemProto.WifiSupplicantState.TOTAL, getWifiSupplStateTimer(i), rawRealtimeUs, which); proto.end(wssToken); } proto.end(sToken); } }