// /*
//  * 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 static android.app.ActivityManager.PROCESS_STATE_BOUND_TOP;
// import static android.os.BatteryStatsManager.NUM_WIFI_STATES;
// import static android.os.BatteryStatsManager.NUM_WIFI_SUPPL_STATES;
// import android.annotation.IntDef;
// import android.app.ActivityManager;
// import android.app.job.JobParameters;
// import android.compat.annotation.UnsupportedAppUsage;
// import android.content.Context;
// import android.content.pm.ApplicationInfo;
// import android.os.BatteryStatsManager.WifiState;
// import android.os.BatteryStatsManager.WifiSupplState;
// import android.server.ServerProtoEnums;
// import android.service.batterystats.BatteryStatsServiceDumpHistoryProto;
// import android.service.batterystats.BatteryStatsServiceDumpProto;
// import android.telephony.CellSignalStrength;
// 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.lang.annotation.Retention;
// import java.lang.annotation.RetentionPolicy;
// import java.text.DecimalFormat;
// 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 {
//     @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//     public BatteryStats() {}
//     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 = Context.BATTERY_STATS_SERVICE;
//     /**
//      * A constant indicating a partial wake lock timer.
//      */
//     @UnsupportedAppUsage
//     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.
//      *
//      * @deprecated As of {@link android.os.Build.VERSION_CODES#Q}, only {@link #STATS_SINCE_CHARGED}
//      * is supported.
//      */
//     @UnsupportedAppUsage
//     @Deprecated
//     public static final int STATS_CURRENT = 1;
//     /**
//      * Include only the run since the last time the device was unplugged in the stats.
//      *
//      * @deprecated As of {@link android.os.Build.VERSION_CODES#Q}, only {@link #STATS_SINCE_CHARGED}
//      * is supported.
//      */
//     @Deprecated
//     public static final int STATS_SINCE_UNPLUGGED = 2;
//     /** @hide */
//     @IntDef(flag = true, prefix = { "STATS_" }, value = {
//             STATS_SINCE_CHARGED,
//             STATS_CURRENT,
//             STATS_SINCE_UNPLUGGED
//     })
//     @Retention(RetentionPolicy.SOURCE)
//     public @interface StatName {}
//     // 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.
//      * New in version 32:
//      *   - Ambient display properly output in data dump.
//      * New in version 33:
//      *   - Fixed bug in min learned capacity updating process.
//      * New in version 34:
//      *   - Deprecated STATS_SINCE_UNPLUGGED and STATS_CURRENT.
//      * New in version 35:
//      *   - Fixed bug that was not reporting high cellular tx power correctly
//      *   - Added out of service and emergency service modes to data connection types
//      */
//     static final int CHECKIN_VERSION = 35;
//     /**
//      * 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
//     public static final double MILLISECONDS_IN_HOUR = 3600 * 1000;
//     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
//      * <p>
//      * @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 {
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         public 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
//          */
//         @UnsupportedAppUsage
//         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();
//         /**
//          * @return a non-null {@link LongCounter} representing total power monitored on the rails
//          * in mAms (miliamps-milliseconds). The counter may always yield a value of 0 if the device
//          * doesn't support power rail monitoring.
//          */
//         public abstract LongCounter getMonitoredRailChargeConsumedMaMs();
//     }
//     /**
//      * State for keeping track of timing information.
//      */
//     public static abstract class Timer {
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         public 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
//          */
//         @UnsupportedAppUsage
//         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
//          */
//         @UnsupportedAppUsage
//         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 (ActivityManager.isForegroundService(procState)) {
//             // 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 {
//         @UnsupportedAppUsage
//         public Uid() {
//         }
//         /**
//          * Returns a mapping containing wakelock statistics.
//          *
//          * @return a Map from Strings to Uid.Wakelock objects.
//          */
//         @UnsupportedAppUsage
//         public abstract ArrayMap<String, ? extends Wakelock> 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<String, ? extends Timer> getSyncStats();
//         /**
//          * Returns a mapping containing scheduled job statistics.
//          *
//          * @return a Map from Strings to Timer objects.
//          */
//         public abstract ArrayMap<String, ? extends Timer> getJobStats();
//         /**
//          * Returns statistics about how jobs have completed.
//          *
//          * @return A Map of String job names to completion type -> count mapping.
//          */
//         public abstract ArrayMap<String, SparseIntArray> getJobCompletionStats();
//         /**
//          * The statistics associated with a particular wake lock.
//          */
//         public static abstract class Wakelock {
//             @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//             public Wakelock() {}
//             @UnsupportedAppUsage
//             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.
//          */
//         @UnsupportedAppUsage
//         public abstract SparseArray<? extends Sensor> getSensorStats();
//         /**
//          * Returns a mapping containing active process data.
//          */
//         public abstract SparseArray<? extends Pid> getPidStats();
//         /**
//          * Returns a mapping containing process statistics.
//          *
//          * @return a Map from Strings to Uid.Proc objects.
//          */
//         @UnsupportedAppUsage
//         public abstract ArrayMap<String, ? extends Proc> getProcessStats();
//         /**
//          * Returns a mapping containing package statistics.
//          *
//          * @return a Map from Strings to Uid.Pkg objects.
//          */
//         @UnsupportedAppUsage
//         public abstract ArrayMap<String, ? extends Pkg> getPackageStats();
//         public abstract ControllerActivityCounter getWifiControllerActivity();
//         public abstract ControllerActivityCounter getBluetoothControllerActivity();
//         public abstract ControllerActivityCounter getModemControllerActivity();
//         /**
//          * {@hide}
//          */
//         @UnsupportedAppUsage
//         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);
//         @UnsupportedAppUsage
//         public abstract long getWifiRunningTime(long elapsedRealtimeUs, int which);
//         @UnsupportedAppUsage
//         public abstract long getFullWifiLockTime(long elapsedRealtimeUs, int which);
//         @UnsupportedAppUsage
//         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();
//         @UnsupportedAppUsage
//         public abstract long getWifiBatchedScanTime(int csphBin, long elapsedRealtimeUs, int which);
//         public abstract int getWifiBatchedScanCount(int csphBin, int which);
//         @UnsupportedAppUsage
//         public abstract long getWifiMulticastTime(long elapsedRealtimeUs, int which);
//         @UnsupportedAppUsage
//         public abstract Timer getAudioTurnedOnTimer();
//         @UnsupportedAppUsage
//         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_BOUND_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", "attention"
//         };
//         public static final int NUM_USER_ACTIVITY_TYPES = USER_ACTIVITY_TYPES.length;
//         public abstract void noteUserActivityLocked(int type);
//         public abstract boolean hasUserActivity();
//         public abstract int getUserActivityCount(int type, int which);
//         public abstract boolean hasNetworkActivity();
//         @UnsupportedAppUsage
//         public abstract long getNetworkActivityBytes(int type, int which);
//         public abstract long getNetworkActivityPackets(int type, int which);
//         @UnsupportedAppUsage
//         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 {
//             @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//             public 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.
//             @UnsupportedAppUsage
//             public static final int GPS = -10000;
//             @UnsupportedAppUsage
//             public abstract int getHandle();
//             @UnsupportedAppUsage
//             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 {
//             @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//             public Proc() {}
//             public static class ExcessivePower {
//                 @UnsupportedAppUsage
//                 public ExcessivePower() {
//                 }
//                 public static final int TYPE_WAKE = 1;
//                 public static final int TYPE_CPU = 2;
//                 @UnsupportedAppUsage
//                 public int type;
//                 @UnsupportedAppUsage
//                 public long overTime;
//                 @UnsupportedAppUsage
//                 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.
//              */
//             @UnsupportedAppUsage
//             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.
//              */
//             @UnsupportedAppUsage
//             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.
//              */
//             @UnsupportedAppUsage
//             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
//              */
//             @UnsupportedAppUsage
//             public abstract long getForegroundTime(int which);
//             @UnsupportedAppUsage
//             public abstract int countExcessivePowers();
//             @UnsupportedAppUsage
//             public abstract ExcessivePower getExcessivePower(int i);
//         }
//         /**
//          * The statistics associated with a particular package.
//          */
//         public static abstract class Pkg {
//             @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//             public 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.
//              */
//             @UnsupportedAppUsage
//             public abstract ArrayMap<String, ? extends Counter> getWakeupAlarmStats();
//             /**
//              * Returns a mapping containing service statistics.
//              */
//             @UnsupportedAppUsage
//             public abstract ArrayMap<String, ? extends Serv> 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
//                  */
//                 @UnsupportedAppUsage
//                 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.
//                  */
//                 @UnsupportedAppUsage
//                 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.
//                  */
//                 @UnsupportedAppUsage
//                 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)<<STEP_LEVEL_INITIAL_MODE_SHIFT);
//                         break;
//                     case 'o': out |= (((long)Display.STATE_ON-1)<<STEP_LEVEL_INITIAL_MODE_SHIFT);
//                         break;
//                     case 'd': out |= (((long)Display.STATE_DOZE-1)<<STEP_LEVEL_INITIAL_MODE_SHIFT);
//                         break;
//                     case 'z': out |= (((long)Display.STATE_DOZE_SUSPEND-1)
//                             << STEP_LEVEL_INITIAL_MODE_SHIFT);
//                         break;
//                     case 'p': out |= (((long)STEP_LEVEL_MODE_POWER_SAVE)
//                             << STEP_LEVEL_INITIAL_MODE_SHIFT);
//                         break;
//                     case 'i': out |= (((long)STEP_LEVEL_MODE_DEVICE_IDLE)
//                             << STEP_LEVEL_INITIAL_MODE_SHIFT);
//                         break;
//                     case 'F': out |= (((long)Display.STATE_OFF-1)<<STEP_LEVEL_MODIFIED_MODE_SHIFT);
//                         break;
//                     case 'O': out |= (((long)Display.STATE_ON-1)<<STEP_LEVEL_MODIFIED_MODE_SHIFT);
//                         break;
//                     case 'D': out |= (((long)Display.STATE_DOZE-1)<<STEP_LEVEL_MODIFIED_MODE_SHIFT);
//                         break;
//                     case 'Z': out |= (((long)Display.STATE_DOZE_SUSPEND-1)
//                             << STEP_LEVEL_MODIFIED_MODE_SHIFT);
//                         break;
//                     case 'P': out |= (((long)STEP_LEVEL_MODE_POWER_SAVE)
//                             << STEP_LEVEL_MODIFIED_MODE_SHIFT);
//                         break;
//                     case 'I': out |= (((long)STEP_LEVEL_MODE_DEVICE_IDLE)
//                             << STEP_LEVEL_MODIFIED_MODE_SHIFT);
//                         break;
//                 }
//             }
//             i++;
//             long level = 0;
//             while (i < N && (c=value.charAt(i)) != '-') {
//                 i++;
//                 level <<= 4;
//                 if (c >= '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<numSteps; i++) {
//                 total += steps[i] & STEP_LEVEL_TIME_MASK;
//             }
//             return total / numSteps;
//             /*
//             long[] buckets = new long[numSteps];
//             int numBuckets = 0;
//             int numToAverage = 4;
//             int i = 0;
//             while (i < numSteps) {
//                 long totalTime = 0;
//                 int num = 0;
//                 for (int j=0; j<numToAverage && (i+j)<numSteps; j++) {
//                     totalTime += steps[i+j] & STEP_LEVEL_TIME_MASK;
//                     num++;
//                 }
//                 buckets[numBuckets] = totalTime / num;
//                 numBuckets++;
//                 numToAverage *= 2;
//                 i += num;
//             }
//             if (numBuckets < 1) {
//                 return -1;
//             }
//             long averageTime = buckets[numBuckets-1];
//             for (i=numBuckets-2; 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<count; i++) {
//                 long initMode = (steps[i] & STEP_LEVEL_INITIAL_MODE_MASK)
//                         >> 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<numStepLevels; i++) {
//                     System.arraycopy(steps, 0, steps, 1, steps.length-1);
//                     long thisDuration = duration / (numStepLevels-i);
//                     duration -= thisDuration;
//                     if (thisDuration > 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<N; i++) {
//                 mStepDurations[i] = in.readLong();
//             }
//         }
//         public void writeToParcel(Parcel out) {
//             final int N = mNumStepDurations;
//             out.writeInt(N);
//             for (int i=0; i<N; i++) {
//                 out.writeLong(mStepDurations[i]);
//             }
//         }
//     }
//     public static final class PackageChange {
//         public String mPackageName;
//         public boolean mUpdate;
//         public long mVersionCode;
//     }
//     public static final class DailyItem {
//         public long mStartTime;
//         public long mEndTime;
//         public LevelStepTracker mDischargeSteps;
//         public LevelStepTracker mChargeSteps;
//         public ArrayList<PackageChange> 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();
//         }
//     }
//     /**
//      * Battery history record.
//      */
//     public static final class HistoryItem {
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         public HistoryItem next;
//         // The time of this event in milliseconds, as per SystemClock.elapsedRealtime().
//         @UnsupportedAppUsage
//         public long time;
//         @UnsupportedAppUsage
//         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;
//         @UnsupportedAppUsage
//         public byte cmd = CMD_NULL;
//         /**
//          * Return whether the command code is a delta data update.
//          */
//         public boolean isDeltaData() {
//             return cmd == CMD_UPDATE;
//         }
//         @UnsupportedAppUsage
//         public byte batteryLevel;
//         @UnsupportedAppUsage
//         public byte batteryStatus;
//         @UnsupportedAppUsage
//         public byte batteryHealth;
//         @UnsupportedAppUsage
//         public byte batteryPlugType;
//         public short batteryTemperature;
//         @UnsupportedAppUsage
//         public char batteryVoltage;
//         // The charge of the battery in micro-Ampere-hours.
//         public int batteryChargeUAh;
//         public double modemRailChargeMah;
//         public double wifiRailChargeMah;
//         // 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;
//         @UnsupportedAppUsage
//         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 STATE2_USB_DATA_LINK_FLAG = 1 << 18;
//         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;
//         @UnsupportedAppUsage
//         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 allowlist.
//         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();
//         @UnsupportedAppUsage
//         public HistoryItem() {
//         }
//         public HistoryItem(Parcel src) {
//             readFromParcel(src);
//         }
//         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.writeDouble(modemRailChargeMah);
//             dest.writeDouble(wifiRailChargeMah);
//             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();
//             time = src.readLong();
//             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();
//             modemRailChargeMah = src.readDouble();
//             wifiRailChargeMah = src.readDouble();
//             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;
//         }
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         public void clear() {
//             time = 0;
//             cmd = CMD_NULL;
//             batteryLevel = 0;
//             batteryStatus = 0;
//             batteryHealth = 0;
//             batteryPlugType = 0;
//             batteryTemperature = 0;
//             batteryVoltage = 0;
//             batteryChargeUAh = 0;
//             modemRailChargeMah = 0;
//             wifiRailChargeMah = 0;
//             states = 0;
//             states2 = 0;
//             wakelockTag = null;
//             wakeReasonTag = null;
//             eventCode = EVENT_NONE;
//             eventTag = null;
//         }
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         public void setTo(HistoryItem o) {
//             time = o.time;
//             cmd = o.cmd;
//             setToCommon(o);
//         }
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         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;
//             modemRailChargeMah = o.modemRailChargeMah;
//             wifiRailChargeMah = o.wifiRailChargeMah;
//             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
//                     && modemRailChargeMah == o.modemRailChargeMah
//                     && wifiRailChargeMah == o.wifiRailChargeMah
//                     && states == o.states
//                     && states2 == o.states2
//                     && currentTime == o.currentTime;
//         }
//         @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//         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<String, SparseIntArray>[] mActiveEvents
//                 = (HashMap<String, SparseIntArray>[]) 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<String, SparseIntArray> 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<String, SparseIntArray> 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<String, SparseIntArray> 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();
//     @UnsupportedAppUsage
//     public abstract boolean startIteratingHistoryLocked();
//     public abstract int getHistoryStringPoolSize();
//     public abstract int getHistoryStringPoolBytes();
//     public abstract String getHistoryTagPoolString(int index);
//     public abstract int getHistoryTagPoolUid(int index);
//     @UnsupportedAppUsage
//     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}
//      */
//     @UnsupportedAppUsage
//     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"
//     };
//     @UnsupportedAppUsage
//     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}
//      */
//     @UnsupportedAppUsage
//     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}
//      */
//     @UnsupportedAppUsage
//     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}
//      */
//     @UnsupportedAppUsage
//     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}
//      */
//     @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//     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_OUT_OF_SERVICE = 0;
//     public static final int DATA_CONNECTION_EMERGENCY_SERVICE =
//             TelephonyManager.getAllNetworkTypes().length + 1;
//     public static final int DATA_CONNECTION_OTHER = DATA_CONNECTION_EMERGENCY_SERVICE + 1;
//     static final String[] DATA_CONNECTION_NAMES = {
//         "oos", "gprs", "edge", "umts", "cdma", "evdo_0", "evdo_A",
//         "1xrtt", "hsdpa", "hsupa", "hspa", "iden", "evdo_b", "lte",
//         "ehrpd", "hspap", "gsm", "td_scdma", "iwlan", "lte_ca", "nr",
//         "emngcy", "other"
//     };
//     @UnsupportedAppUsage
//     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);
//     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",
//                 new String[] { "none", "poor", "moderate", "good", "great" },
//                 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_USB_DATA_LINK_FLAG, "usb_data", "Ud"),
//         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, sIntToString,
//             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}
//      */
//     @UnsupportedAppUsage
//     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}
//      */
//     @UnsupportedAppUsage
//     public abstract long getGlobalWifiRunningTime(long elapsedRealtimeUs, int which);
//     static final String[] WIFI_STATE_NAMES = {
//         "off", "scanning", "no_net", "disconn",
//         "sta", "p2p", "sta_p2p", "soft_ap"
//     };
//     /**
//      * Returns the time in microseconds that WiFi has been running in the given state.
//      *
//      * {@hide}
//      */
//     public abstract long getWifiStateTime(@WifiState int wifiState,
//             long elapsedRealtimeUs, @StatName int which);
//     /**
//      * Returns the number of times that WiFi has entered the given state.
//      *
//      * {@hide}
//      */
//     public abstract int getWifiStateCount(@WifiState int wifiState, @StatName int which);
//     /**
//      * Returns the {@link Timer} object that tracks the given WiFi state.
//      *
//      * {@hide}
//      */
//     public abstract Timer getWifiStateTimer(@WifiState int wifiState);
//     /**
//      * Returns the time in microseconds that the wifi supplicant has been
//      * in a given state.
//      *
//      * {@hide}
//      */
//     public abstract long getWifiSupplStateTime(@WifiSupplState int state, long elapsedRealtimeUs,
//             @StatName int which);
//     /**
//      * Returns the number of times that the wifi supplicant has transitioned
//      * to a given state.
//      *
//      * {@hide}
//      */
//     public abstract int getWifiSupplStateCount(@WifiSupplState int state, @StatName int which);
//     /**
//      * Returns the {@link Timer} object that tracks the given wifi supplicant state.
//      *
//      * {@hide}
//      */
//     public abstract Timer getWifiSupplStateTimer(@WifiSupplState 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;
//     @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
//     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.
//      */
//     @UnsupportedAppUsage
//     public abstract SparseArray<? extends Uid> getUidStats();
//     /**
//      * Returns the current battery uptime in microseconds.
//      *
//      * @param curTime the amount of elapsed realtime in microseconds.
//      */
//     @UnsupportedAppUsage
//     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 <var>which</var>.
//      */
//     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.
//      */
//     @UnsupportedAppUsage
//     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.
//      */
//     @UnsupportedAppUsage
//     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.
//      */
//     @UnsupportedAppUsage
//     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.
//      */
//     @UnsupportedAppUsage
//     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<PackageChange> getDailyPackageChanges();
//     public abstract Map<String, ? extends Timer> getWakeupReasonStats();
//     public abstract Map<String, ? extends Timer> getKernelWakelockStats();
//     /**
//      * Returns Timers tracking the total time of each Resource Power Manager state and voter.
//      */
//     public abstract Map<String, ? extends Timer> getRpmStats();
//     /**
//      * Returns Timers tracking the screen-off time of each Resource Power Manager state and voter.
//      */
//     public abstract Map<String, ? extends Timer> getScreenOffRpmStats();
//     public abstract LongSparseArray<? extends Timer> 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
//      */
//     @UnsupportedAppUsage
//     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
//                 || counter.getMonitoredRailChargeConsumedMaMs().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) / (MILLISECONDS_IN_HOUR));
//         pw.print(",");
//         pw.print(counter.getMonitoredRailChargeConsumedMaMs().getCountLocked(which)
//                 / (MILLISECONDS_IN_HOUR));
//         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) / (MILLISECONDS_IN_HOUR));
//         proto.write(ControllerActivityProto.MONITORED_RAIL_CHARGE_MAH,
//                 counter.getMonitoredRailChargeConsumedMaMs().getCountLocked(which)
//                         / (MILLISECONDS_IN_HOUR));
//         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);
//         final long monitoredRailChargeConsumedMaMs =
//                 counter.getMonitoredRailChargeConsumedMaMs().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 / MILLISECONDS_IN_HOUR));
//             sb.append("mAh");
//             pw.println(sb.toString());
//         }
//         if (monitoredRailChargeConsumedMaMs > 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//             sb.append("     ");
//             sb.append(controllerName);
//             sb.append(" Monitored rail energy drain: ").append(
//                     new DecimalFormat("#.##").format(
//                             monitoredRailChargeConsumedMaMs / MILLISECONDS_IN_HOUR));
//             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) {
//         if (which != BatteryStats.STATS_SINCE_CHARGED) {
//             dumpLine(pw, 0, STAT_NAMES[which], "err",
//                     "ERROR: BatteryStats.dumpCheckin called for which type " + which
//                     + " but only STATS_SINCE_CHARGED is supported.");
//             return;
//         }
//         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<? extends Uid> 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<String, ? extends BatteryStats.Uid.Wakelock> 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<NUM_SCREEN_BRIGHTNESS_BINS; i++) {
//             args[i] = getScreenBrightnessTime(i, rawRealtime, which) / 1000;
//         }
//         dumpLine(pw, 0 /* uid */, category, SCREEN_BRIGHTNESS_DATA, args);
//         // Dump signal strength stats
//         args = new Object[CellSignalStrength.getNumSignalStrengthLevels()];
//         for (int i = 0; i < CellSignalStrength.getNumSignalStrengthLevels(); i++) {
//             args[i] = getPhoneSignalStrengthTime(i, rawRealtime, which) / 1000;
//         }
//         dumpLine(pw, 0 /* uid */, category, SIGNAL_STRENGTH_TIME_DATA, args);
//         dumpLine(pw, 0 /* uid */, category, SIGNAL_SCANNING_TIME_DATA,
//                 getPhoneSignalScanningTime(rawRealtime, which) / 1000);
//         for (int i = 0; i < CellSignalStrength.getNumSignalStrengthLevels(); i++) {
//             args[i] = getPhoneSignalStrengthCount(i, which);
//         }
//         dumpLine(pw, 0 /* uid */, category, SIGNAL_STRENGTH_COUNT_DATA, args);
//         // Dump network type stats
//         args = new Object[NUM_DATA_CONNECTION_TYPES];
//         for (int i=0; i<NUM_DATA_CONNECTION_TYPES; i++) {
//             args[i] = getPhoneDataConnectionTime(i, rawRealtime, which) / 1000;
//         }
//         dumpLine(pw, 0 /* uid */, category, DATA_CONNECTION_TIME_DATA, args);
//         for (int i=0; i<NUM_DATA_CONNECTION_TYPES; i++) {
//             args[i] = getPhoneDataConnectionCount(i, which);
//         }
//         dumpLine(pw, 0 /* uid */, category, DATA_CONNECTION_COUNT_DATA, args);
//         // Dump wifi state stats
//         args = new Object[NUM_WIFI_STATES];
//         for (int i=0; i<NUM_WIFI_STATES; i++) {
//             args[i] = getWifiStateTime(i, rawRealtime, which) / 1000;
//         }
//         dumpLine(pw, 0 /* uid */, category, WIFI_STATE_TIME_DATA, args);
//         for (int i=0; i<NUM_WIFI_STATES; i++) {
//             args[i] = getWifiStateCount(i, which);
//         }
//         dumpLine(pw, 0 /* uid */, category, WIFI_STATE_COUNT_DATA, args);
//         // Dump wifi suppl state stats
//         args = new Object[NUM_WIFI_SUPPL_STATES];
//         for (int i=0; i<NUM_WIFI_SUPPL_STATES; i++) {
//             args[i] = getWifiSupplStateTime(i, rawRealtime, which) / 1000;
//         }
//         dumpLine(pw, 0 /* uid */, category, WIFI_SUPPL_STATE_TIME_DATA, args);
//         for (int i=0; i<NUM_WIFI_SUPPL_STATES; i++) {
//             args[i] = getWifiSupplStateCount(i, which);
//         }
//         dumpLine(pw, 0 /* uid */, category, WIFI_SUPPL_STATE_COUNT_DATA, args);
//         // Dump wifi signal strength stats
//         args = new Object[NUM_WIFI_SIGNAL_STRENGTH_BINS];
//         for (int i=0; i<NUM_WIFI_SIGNAL_STRENGTH_BINS; i++) {
//             args[i] = getWifiSignalStrengthTime(i, rawRealtime, which) / 1000;
//         }
//         dumpLine(pw, 0 /* uid */, category, WIFI_SIGNAL_STRENGTH_TIME_DATA, args);
//         for (int i=0; i<NUM_WIFI_SIGNAL_STRENGTH_BINS; i++) {
//             args[i] = getWifiSignalStrengthCount(i, which);
//         }
//         dumpLine(pw, 0 /* uid */, category, WIFI_SIGNAL_STRENGTH_COUNT_DATA, args);
//         // Dump Multicast total stats
//         final long multicastWakeLockTimeTotalMicros =
//                 getWifiMulticastWakelockTime(rawRealtime, which);
//         final int multicastWakeLockCountTotal = getWifiMulticastWakelockCount(which);
//         dumpLine(pw, 0 /* uid */, category, WIFI_MULTICAST_TOTAL_DATA,
//                 multicastWakeLockTimeTotalMicros / 1000,
//                 multicastWakeLockCountTotal);
//         dumpLine(pw, 0 /* uid */, category, BATTERY_DISCHARGE_DATA,
//                 getLowDischargeAmountSinceCharge(), getHighDischargeAmountSinceCharge(),
//                 getDischargeAmountScreenOnSinceCharge(),
//                 getDischargeAmountScreenOffSinceCharge(),
//                 dischargeCount / 1000, dischargeScreenOffCount / 1000,
//                 getDischargeAmountScreenDozeSinceCharge(), dischargeScreenDozeCount / 1000,
//                 dischargeLightDozeCount / 1000, dischargeDeepDozeCount / 1000);
//         if (reqUid < 0) {
//             final Map<String, ? extends Timer> kernelWakelocks = getKernelWakelockStats();
//             if (kernelWakelocks.size() > 0) {
//                 for (Map.Entry<String, ? extends Timer> 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<String, ? extends Timer> wakeupReasons = getWakeupReasonStats();
//             if (wakeupReasons.size() > 0) {
//                 for (Map.Entry<String, ? extends Timer> 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<String, ? extends Timer> rpmStats = getRpmStats();
//         final Map<String, ? extends Timer> screenOffRpmStats = getScreenOffRpmStats();
//         if (rpmStats.size() > 0) {
//             for (Map.Entry<String, ? extends Timer> 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<BatterySipper> 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<sippers.size(); i++) {
//                 final BatterySipper bs = sippers.get(i);
//                 String label;
//                 switch (bs.drainType) {
//                     case AMBIENT_DISPLAY:
//                         label = "ambi";
//                         break;
//                     case IDLE:
//                         label="idle";
//                         break;
//                     case CELL:
//                         label="cell";
//                         break;
//                     case PHONE:
//                         label="phone";
//                         break;
//                     case WIFI:
//                         label="wifi";
//                         break;
//                     case BLUETOOTH:
//                         label="blue";
//                         break;
//                     case SCREEN:
//                         label="scrn";
//                         break;
//                     case FLASHLIGHT:
//                         label="flashlight";
//                         break;
//                     case APP:
//                         uid = bs.uidObj.getUid();
//                         label = "uid";
//                         break;
//                     case USER:
//                         uid = UserHandle.getUid(bs.userId, 0);
//                         label = "user";
//                         break;
//                     case UNACCOUNTED:
//                         label = "unacc";
//                         break;
//                     case OVERCOUNTED:
//                         label = "over";
//                         break;
//                     case CAMERA:
//                         label = "camera";
//                         break;
//                     case MEMORY:
//                         label = "memory";
//                         break;
//                     default:
//                         label = "???";
//                 }
//                 dumpLine(pw, uid, category, POWER_USE_ITEM_DATA, label,
//                         BatteryStatsHelper.makemAh(bs.totalPowerMah),
//                         bs.shouldHide ? 1 : 0,
//                         BatteryStatsHelper.makemAh(bs.screenPowerMah),
//                         BatteryStatsHelper.makemAh(bs.proportionalSmearMah));
//             }
//         }
//         final long[] cpuFreqs = getCpuFreqs();
//         if (cpuFreqs != null) {
//             sb.setLength(0);
//             for (int i = 0; i < cpuFreqs.length; ++i) {
//                 sb.append((i == 0 ? "" : ",") + cpuFreqs[i]);
//             }
//             dumpLine(pw, 0 /* uid */, category, GLOBAL_CPU_FREQ_DATA, sb.toString());
//         }
//         // Dump stats per UID.
//         for (int iu = 0; iu < NU; iu++) {
//             final int uid = uidStats.keyAt(iu);
//             if (reqUid >= 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<Uid.NUM_USER_ACTIVITY_TYPES; i++) {
//                     int val = u.getUserActivityCount(i, which);
//                     args[i] = val;
//                     if (val != 0) hasData = true;
//                 }
//                 if (hasData) {
//                     dumpLine(pw, uid /* uid */, category, USER_ACTIVITY_DATA, args);
//                 }
//             }
//             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;
//                 dumpLine(pw, uid, category, AGGREGATED_WAKELOCK_DATA, totTimeMs, bgTimeMs);
//             }
//             final ArrayMap<String, ? extends Uid.Wakelock> 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<String, ? extends Timer> 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<String, ? extends Timer> 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 int[] jobStopReasonCodes = JobParameters.getJobStopReasonCodes();
//             final Object[] jobCompletionArgs = new Object[jobStopReasonCodes.length + 1];
//             final ArrayMap<String, SparseIntArray> completions = u.getJobCompletionStats();
//             for (int ic=completions.size()-1; ic>=0; ic--) {
//                 SparseIntArray types = completions.valueAt(ic);
//                 if (types != null) {
//                     jobCompletionArgs[0] = "\"" + completions.keyAt(ic) + "\"";
//                     for (int i = 0; i < jobStopReasonCodes.length; i++) {
//                         jobCompletionArgs[i + 1] = types.get(jobStopReasonCodes[i], 0);
//                     }
//                     dumpLine(pw, uid, category, JOB_COMPLETION_DATA, jobCompletionArgs);
//                 }
//             }
//             // 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<? extends BatteryStats.Uid.Sensor> sensors = u.getSensorStats();
//             final int NSE = sensors.size();
//             for (int ise=0; ise<NSE; ise++) {
//                 final Uid.Sensor se = sensors.valueAt(ise);
//                 final int sensorNumber = sensors.keyAt(ise);
//                 final Timer timer = se.getSensorTime();
//                 if (timer != null) {
//                     // Convert from microseconds to milliseconds with rounding
//                     final long totalTime = (timer.getTotalTimeLocked(rawRealtime, which) + 500)
//                             / 1000;
//                     if (totalTime != 0) {
//                         final int count = timer.getCountLocked(which);
//                         final Timer bgTimer = se.getSensorBackgroundTime();
//                         final int bgCount = bgTimer != null ? bgTimer.getCountLocked(which) : 0;
//                         // 'actualTime' are unpooled and always since reset (regardless of 'which')
//                         final long actualTime = timer.getTotalDurationMsLocked(rawRealtimeMs);
//                         final long bgActualTime = bgTimer != null ?
//                                 bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : 0;
//                         dumpLine(pw, uid, category, SENSOR_DATA, sensorNumber, totalTime,
//                                 count, bgCount, actualTime, bgActualTime);
//                     }
//                 }
//             }
//             dumpTimer(pw, uid, category, VIBRATOR_DATA, u.getVibratorOnTimer(),
//                     rawRealtime, which);
//             dumpTimer(pw, uid, category, FOREGROUND_ACTIVITY_DATA, u.getForegroundActivityTimer(),
//                     rawRealtime, which);
//             dumpTimer(pw, uid, category, FOREGROUND_SERVICE_DATA, u.getForegroundServiceTimer(),
//                     rawRealtime, which);
//             final Object[] stateTimes = new Object[Uid.NUM_PROCESS_STATE];
//             long totalStateTime = 0;
//             for (int ips=0; ips<Uid.NUM_PROCESS_STATE; ips++) {
//                 final long time = u.getProcessStateTime(ips, rawRealtime, which);
//                 totalStateTime += time;
//                 stateTimes[ips] = (time + 500) / 1000;
//             }
//             if (totalStateTime > 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<String, ? extends BatteryStats.Uid.Proc> 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<String, ? extends BatteryStats.Uid.Pkg> packageStats
//                     = u.getPackageStats();
//             for (int ipkg=packageStats.size()-1; ipkg>=0; ipkg--) {
//                 final Uid.Pkg ps = packageStats.valueAt(ipkg);
//                 int wakeups = 0;
//                 final ArrayMap<String, ? extends Counter> 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<String, ? extends  Uid.Pkg.Serv> 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) {
//         if (which != BatteryStats.STATS_SINCE_CHARGED) {
//             pw.println("ERROR: BatteryStats.dump called for which type " + which
//                     + " but only STATS_SINCE_CHARGED is supported");
//             return;
//         }
//         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<? extends Uid> 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;
//         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<NUM_SCREEN_BRIGHTNESS_BINS; i++) {
//             final long time = getScreenBrightnessTime(i, rawRealtime, which);
//             if (time == 0) {
//                 continue;
//             }
//             sb.append("\n    ");
//             sb.append(prefix);
//             didOne = true;
//             sb.append(SCREEN_BRIGHTNESS_NAMES[i]);
//             sb.append(" ");
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, screenOnTime));
//             sb.append(")");
//         }
//         if (!didOne) sb.append(" (no activity)");
//         pw.println(sb.toString());
//         if (powerSaveModeEnabledTime != 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//                     sb.append("  Power save mode enabled: ");
//                     formatTimeMs(sb, powerSaveModeEnabledTime / 1000);
//                     sb.append("(");
//                     sb.append(formatRatioLocked(powerSaveModeEnabledTime, whichBatteryRealtime));
//                     sb.append(")");
//             pw.println(sb.toString());
//         }
//         if (deviceLightIdlingTime != 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//                     sb.append("  Device light idling: ");
//                     formatTimeMs(sb, deviceLightIdlingTime / 1000);
//                     sb.append("(");
//                     sb.append(formatRatioLocked(deviceLightIdlingTime, whichBatteryRealtime));
//                     sb.append(") "); sb.append(getDeviceIdlingCount(DEVICE_IDLE_MODE_LIGHT, which));
//                     sb.append("x");
//             pw.println(sb.toString());
//         }
//         if (deviceIdleModeLightTime != 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//                     sb.append("  Idle mode light time: ");
//                     formatTimeMs(sb, deviceIdleModeLightTime / 1000);
//                     sb.append("(");
//                     sb.append(formatRatioLocked(deviceIdleModeLightTime, whichBatteryRealtime));
//                     sb.append(") ");
//                     sb.append(getDeviceIdleModeCount(DEVICE_IDLE_MODE_LIGHT, which));
//                     sb.append("x");
//                     sb.append(" -- longest ");
//                     formatTimeMs(sb, getLongestDeviceIdleModeTime(DEVICE_IDLE_MODE_LIGHT));
//             pw.println(sb.toString());
//         }
//         if (deviceIdlingTime != 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//                     sb.append("  Device full idling: ");
//                     formatTimeMs(sb, deviceIdlingTime / 1000);
//                     sb.append("(");
//                     sb.append(formatRatioLocked(deviceIdlingTime, whichBatteryRealtime));
//                     sb.append(") "); sb.append(getDeviceIdlingCount(DEVICE_IDLE_MODE_DEEP, which));
//                     sb.append("x");
//             pw.println(sb.toString());
//         }
//         if (deviceIdleModeFullTime != 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//                     sb.append("  Idle mode full time: ");
//                     formatTimeMs(sb, deviceIdleModeFullTime / 1000);
//                     sb.append("(");
//                     sb.append(formatRatioLocked(deviceIdleModeFullTime, whichBatteryRealtime));
//                     sb.append(") ");
//                     sb.append(getDeviceIdleModeCount(DEVICE_IDLE_MODE_DEEP, which));
//                     sb.append("x");
//                     sb.append(" -- longest ");
//                     formatTimeMs(sb, getLongestDeviceIdleModeTime(DEVICE_IDLE_MODE_DEEP));
//             pw.println(sb.toString());
//         }
//         if (phoneOnTime != 0) {
//             sb.setLength(0);
//             sb.append(prefix);
//                     sb.append("  Active phone call: "); formatTimeMs(sb, phoneOnTime / 1000);
//                     sb.append("("); sb.append(formatRatioLocked(phoneOnTime, whichBatteryRealtime));
//                     sb.append(") "); sb.append(getPhoneOnCount(which)); sb.append("x");
//         }
//         final int connChanges = getNumConnectivityChange(which);
//         if (connChanges != 0) {
//             pw.print(prefix);
//             pw.print("  Connectivity changes: "); pw.println(connChanges);
//         }
//         // Calculate wakelock times across all uids.
//         long fullWakeLockTimeTotalMicros = 0;
//         long partialWakeLockTimeTotalMicros = 0;
//         final ArrayList<TimerEntry> timers = new ArrayList<>();
//         for (int iu = 0; iu < NU; iu++) {
//             final Uid u = uidStats.valueAt(iu);
//             final ArrayMap<String, ? extends BatteryStats.Uid.Wakelock> 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());
//         printControllerActivity(pw, sb, prefix, CELLULAR_CONTROLLER_NAME,
//                 getModemControllerActivity(), which);
//         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<NUM_DATA_CONNECTION_TYPES; i++) {
//             final long time = getPhoneDataConnectionTime(i, rawRealtime, which);
//             if (time == 0) {
//                 continue;
//             }
//             sb.append("\n       ");
//             sb.append(prefix);
//             didOne = true;
//             sb.append(i < DATA_CONNECTION_NAMES.length ? DATA_CONNECTION_NAMES[i] : "ERROR");
//             sb.append(" ");
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, whichBatteryRealtime));
//             sb.append(") ");
//         }
//         if (!didOne) sb.append(" (no activity)");
//         pw.println(sb.toString());
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("     Cellular Rx signal strength (RSRP):");
//         final String[] cellularRxSignalStrengthDescription = new String[]{
//             "very poor (less than -128dBm): ",
//             "poor (-128dBm to -118dBm): ",
//             "moderate (-118dBm to -108dBm): ",
//             "good (-108dBm to -98dBm): ",
//             "great (greater than -98dBm): "};
//         didOne = false;
//         final int numCellularRxBins = Math.min(CellSignalStrength.getNumSignalStrengthLevels(),
//             cellularRxSignalStrengthDescription.length);
//         for (int i=0; i<numCellularRxBins; i++) {
//             final long time = getPhoneSignalStrengthTime(i, rawRealtime, which);
//             if (time == 0) {
//                 continue;
//             }
//             sb.append("\n       ");
//             sb.append(prefix);
//             didOne = true;
//             sb.append(cellularRxSignalStrengthDescription[i]);
//             sb.append(" ");
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, whichBatteryRealtime));
//             sb.append(") ");
//         }
//         if (!didOne) sb.append(" (no activity)");
//         pw.println(sb.toString());
//         pw.print(prefix);
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("  Wifi Statistics:");
//         pw.println(sb.toString());
//         pw.print(prefix);
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("     Wifi kernel active time: ");
//         final long wifiActiveTime = getWifiActiveTime(rawRealtime, which);
//         formatTimeMs(sb, wifiActiveTime / 1000);
//         sb.append("("); sb.append(formatRatioLocked(wifiActiveTime, whichBatteryRealtime));
//         sb.append(")");
//         pw.println(sb.toString());
//         printControllerActivity(pw, sb, prefix, WIFI_CONTROLLER_NAME,
//                 getWifiControllerActivity(), which);
//         pw.print("     Wifi data received: "); pw.println(formatBytesLocked(wifiRxTotalBytes));
//         pw.print("     Wifi data sent: "); pw.println(formatBytesLocked(wifiTxTotalBytes));
//         pw.print("     Wifi packets received: "); pw.println(wifiRxTotalPackets);
//         pw.print("     Wifi packets sent: "); pw.println(wifiTxTotalPackets);
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("     Wifi states:");
//         didOne = false;
//         for (int i=0; i<NUM_WIFI_STATES; i++) {
//             final long time = getWifiStateTime(i, rawRealtime, which);
//             if (time == 0) {
//                 continue;
//             }
//             sb.append("\n       ");
//             didOne = true;
//             sb.append(WIFI_STATE_NAMES[i]);
//             sb.append(" ");
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, whichBatteryRealtime));
//             sb.append(") ");
//         }
//         if (!didOne) sb.append(" (no activity)");
//         pw.println(sb.toString());
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("     Wifi supplicant states:");
//         didOne = false;
//         for (int i=0; i<NUM_WIFI_SUPPL_STATES; i++) {
//             final long time = getWifiSupplStateTime(i, rawRealtime, which);
//             if (time == 0) {
//                 continue;
//             }
//             sb.append("\n       ");
//             didOne = true;
//             sb.append(WIFI_SUPPL_STATE_NAMES[i]);
//             sb.append(" ");
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, whichBatteryRealtime));
//             sb.append(") ");
//         }
//         if (!didOne) sb.append(" (no activity)");
//         pw.println(sb.toString());
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("     Wifi Rx signal strength (RSSI):");
//         final String[] wifiRxSignalStrengthDescription = new String[]{
//             "very poor (less than -88.75dBm): ",
//             "poor (-88.75 to -77.5dBm): ",
//             "moderate (-77.5dBm to -66.25dBm): ",
//             "good (-66.25dBm to -55dBm): ",
//             "great (greater than -55dBm): "};
//         didOne = false;
//         final int numWifiRxBins = Math.min(NUM_WIFI_SIGNAL_STRENGTH_BINS,
//             wifiRxSignalStrengthDescription.length);
//         for (int i=0; i<numWifiRxBins; i++) {
//             final long time = getWifiSignalStrengthTime(i, rawRealtime, which);
//             if (time == 0) {
//                 continue;
//             }
//             sb.append("\n    ");
//             sb.append(prefix);
//             didOne = true;
//             sb.append("     ");
//             sb.append(wifiRxSignalStrengthDescription[i]);
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, whichBatteryRealtime));
//             sb.append(") ");
//         }
//         if (!didOne) sb.append(" (no activity)");
//         pw.println(sb.toString());
//         pw.print(prefix);
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("  GPS Statistics:");
//         pw.println(sb.toString());
//         sb.setLength(0);
//         sb.append(prefix);
//         sb.append("     GPS signal quality (Top 4 Average CN0):");
//         final String[] gpsSignalQualityDescription = new String[]{
//             "poor (less than 20 dBHz): ",
//             "good (greater than 20 dBHz): "};
//         final int numGpsSignalQualityBins = Math.min(GnssMetrics.NUM_GPS_SIGNAL_QUALITY_LEVELS,
//             gpsSignalQualityDescription.length);
//         for (int i=0; i<numGpsSignalQualityBins; i++) {
//             final long time = getGpsSignalQualityTime(i, rawRealtime, which);
//             sb.append("\n    ");
//             sb.append(prefix);
//             sb.append("  ");
//             sb.append(gpsSignalQualityDescription[i]);
//             formatTimeMs(sb, time/1000);
//             sb.append("(");
//             sb.append(formatRatioLocked(time, whichBatteryRealtime));
//             sb.append(") ");
//         }
//         pw.println(sb.toString());
//         final long gpsBatteryDrainMaMs = getGpsBatteryDrainMaMs();
//         if (gpsBatteryDrainMaMs > 0) {
//             pw.print(prefix);
//             sb.setLength(0);
//             sb.append(prefix);
//             sb.append("     GPS Battery Drain: ");
//             sb.append(new DecimalFormat("#.##").format(
//                     ((double) gpsBatteryDrainMaMs) / (3600 * 1000)));
//             sb.append("mAh");
//             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();
//         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<BatterySipper> 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<sippers.size(); i++) {
//                 final BatterySipper bs = sippers.get(i);
//                 pw.print(prefix);
//                 switch (bs.drainType) {
//                     case AMBIENT_DISPLAY:
//                         pw.print("    Ambient display: ");
//                         break;
//                     case IDLE:
//                         pw.print("    Idle: ");
//                         break;
//                     case CELL:
//                         pw.print("    Cell standby: ");
//                         break;
//                     case PHONE:
//                         pw.print("    Phone calls: ");
//                         break;
//                     case WIFI:
//                         pw.print("    Wifi: ");
//                         break;
//                     case BLUETOOTH:
//                         pw.print("    Bluetooth: ");
//                         break;
//                     case SCREEN:
//                         pw.print("    Screen: ");
//                         break;
//                     case FLASHLIGHT:
//                         pw.print("    Flashlight: ");
//                         break;
//                     case APP:
//                         pw.print("    Uid ");
//                         UserHandle.formatUid(pw, bs.uidObj.getUid());
//                         pw.print(": ");
//                         break;
//                     case USER:
//                         pw.print("    User "); pw.print(bs.userId);
//                         pw.print(": ");
//                         break;
//                     case UNACCOUNTED:
//                         pw.print("    Unaccounted: ");
//                         break;
//                     case OVERCOUNTED:
//                         pw.print("    Over-counted: ");
//                         break;
//                     case CAMERA:
//                         pw.print("    Camera: ");
//                         break;
//                     default:
//                         pw.print("    ???: ");
//                         break;
//                 }
//                 printmAh(pw, bs.totalPowerMah);
//                 if (bs.usagePowerMah != bs.totalPowerMah) {
//                     // If the usage (generic power) isn't the whole amount, we list out
//                     // what components are involved in the calculation.
//                     pw.print(" (");
//                     if (bs.usagePowerMah != 0) {
//                         pw.print(" usage=");
//                         printmAh(pw, bs.usagePowerMah);
//                     }
//                     if (bs.cpuPowerMah != 0) {
//                         pw.print(" cpu=");
//                         printmAh(pw, bs.cpuPowerMah);
//                     }
//                     if (bs.wakeLockPowerMah != 0) {
//                         pw.print(" wake=");
//                         printmAh(pw, bs.wakeLockPowerMah);
//                     }
//                     if (bs.mobileRadioPowerMah != 0) {
//                         pw.print(" radio=");
//                         printmAh(pw, bs.mobileRadioPowerMah);
//                     }
//                     if (bs.wifiPowerMah != 0) {
//                         pw.print(" wifi=");
//                         printmAh(pw, bs.wifiPowerMah);
//                     }
//                     if (bs.bluetoothPowerMah != 0) {
//                         pw.print(" bt=");
//                         printmAh(pw, bs.bluetoothPowerMah);
//                     }
//                     if (bs.gpsPowerMah != 0) {
//                         pw.print(" gps=");
//                         printmAh(pw, bs.gpsPowerMah);
//                     }
//                     if (bs.sensorPowerMah != 0) {
//                         pw.print(" sensor=");
//                         printmAh(pw, bs.sensorPowerMah);
//                     }
//                     if (bs.cameraPowerMah != 0) {
//                         pw.print(" camera=");
//                         printmAh(pw, bs.cameraPowerMah);
//                     }
//                     if (bs.flashlightPowerMah != 0) {
//                         pw.print(" flash=");
//                         printmAh(pw, bs.flashlightPowerMah);
//                     }
//                     pw.print(" )");
//                 }
//                 // If there is additional smearing information, include it.
//                 if (bs.totalSmearedPowerMah != bs.totalPowerMah) {
//                     pw.print(" Including smearing: ");
//                     printmAh(pw, bs.totalSmearedPowerMah);
//                     pw.print(" (");
//                     if (bs.screenPowerMah != 0) {
//                         pw.print(" screen=");
//                         printmAh(pw, bs.screenPowerMah);
//                     }
//                     if (bs.proportionalSmearMah != 0) {
//                         pw.print(" proportional=");
//                         printmAh(pw, bs.proportionalSmearMah);
//                     }
//                     pw.print(" )");
//                 }
//                 if (bs.shouldHide) {
//                     pw.print(" Excluded from smearing");
//                 }
//                 pw.println();
//             }
//             pw.println();
//         }
//         sippers = helper.getMobilemsppList();
//         if (sippers != null && sippers.size() > 0) {
//             pw.print(prefix); pw.println("  Per-app mobile ms per packet:");
//             long totalTime = 0;
//             for (int i=0; i<sippers.size(); i++) {
//                 final BatterySipper bs = sippers.get(i);
//                 sb.setLength(0);
//                 sb.append(prefix); sb.append("    Uid ");
//                 UserHandle.formatUid(sb, bs.uidObj.getUid());
//                 sb.append(": "); sb.append(BatteryStatsHelper.makemAh(bs.mobilemspp));
//                 sb.append(" ("); sb.append(bs.mobileRxPackets+bs.mobileTxPackets);
//                 sb.append(" packets over "); formatTimeMsNoSpace(sb, bs.mobileActive);
//                 sb.append(") "); sb.append(bs.mobileActiveCount); sb.append("x");
//                 pw.println(sb.toString());
//                 totalTime += bs.mobileActive;
//             }
//             sb.setLength(0);
//             sb.append(prefix);
//             sb.append("    TOTAL TIME: ");
//             formatTimeMs(sb, totalTime);
//             sb.append("("); sb.append(formatRatioLocked(totalTime, whichBatteryRealtime));
//             sb.append(")");
//             pw.println(sb.toString());
//             pw.println();
//         }
//         final Comparator<TimerEntry> timerComparator = new Comparator<TimerEntry>() {
//             @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<String, ? extends BatteryStats.Timer> kernelWakelocks
//                     = getKernelWakelockStats();
//             if (kernelWakelocks.size() > 0) {
//                 final ArrayList<TimerEntry> ktimers = new ArrayList<>();
//                 for (Map.Entry<String, ? extends BatteryStats.Timer> 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<ktimers.size(); i++) {
//                         final TimerEntry timer = ktimers.get(i);
//                         String linePrefix = ": ";
//                         sb.setLength(0);
//                         sb.append(prefix);
//                         sb.append("  Kernel Wake lock ");
//                         sb.append(timer.mName);
//                         linePrefix = printWakeLock(sb, timer.mTimer, rawRealtime, null,
//                                 which, linePrefix);
//                         if (!linePrefix.equals(": ")) {
//                             sb.append(" realtime");
//                             // Only print out wake locks that were held
//                             pw.println(sb.toString());
//                         }
//                     }
//                     pw.println();
//                 }
//             }
//             if (timers.size() > 0) {
//                 Collections.sort(timers, timerComparator);
//                 pw.print(prefix); pw.println("  All partial wake locks:");
//                 for (int i=0; i<timers.size(); i++) {
//                     TimerEntry timer = timers.get(i);
//                     sb.setLength(0);
//                     sb.append("  Wake lock ");
//                     UserHandle.formatUid(sb, timer.mId);
//                     sb.append(" ");
//                     sb.append(timer.mName);
//                     printWakeLock(sb, timer.mTimer, rawRealtime, null, which, ": ");
//                     sb.append(" realtime");
//                     pw.println(sb.toString());
//                 }
//                 timers.clear();
//                 pw.println();
//             }
//             final Map<String, ? extends Timer> wakeupReasons = getWakeupReasonStats();
//             if (wakeupReasons.size() > 0) {
//                 pw.print(prefix); pw.println("  All wakeup reasons:");
//                 final ArrayList<TimerEntry> reasons = new ArrayList<>();
//                 for (Map.Entry<String, ? extends Timer> 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<reasons.size(); i++) {
//                     TimerEntry timer = reasons.get(i);
//                     String linePrefix = ": ";
//                     sb.setLength(0);
//                     sb.append(prefix);
//                     sb.append("  Wakeup reason ");
//                     sb.append(timer.mName);
//                     printWakeLock(sb, timer.mTimer, rawRealtime, null, which, ": ");
//                     sb.append(" realtime");
//                     pw.println(sb.toString());
//                 }
//                 pw.println();
//             }
//         }
//         final LongSparseArray<? extends Timer> 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<String, ? extends Timer> rpmStats = getRpmStats();
//         if (rpmStats.size() > 0) {
//             pw.print(prefix); pw.println("  Resource Power Manager Stats");
//             if (rpmStats.size() > 0) {
//                 for (Map.Entry<String, ? extends Timer> 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<String, ? extends Timer> 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<String, ? extends Timer> 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<NU; iu++) {
//             final int uid = uidStats.keyAt(iu);
//             if (reqUid >= 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<Uid.NUM_USER_ACTIVITY_TYPES; i++) {
//                     final int val = u.getUserActivityCount(i, which);
//                     if (val != 0) {
//                         if (!hasData) {
//                             sb.setLength(0);
//                             sb.append("    User activity: ");
//                             hasData = true;
//                         } else {
//                             sb.append(", ");
//                         }
//                         sb.append(val);
//                         sb.append(" ");
//                         sb.append(Uid.USER_ACTIVITY_TYPES[i]);
//                     }
//                 }
//                 if (hasData) {
//                     pw.println(sb.toString());
//                 }
//             }
//             final ArrayMap<String, ? extends BatteryStats.Uid.Wakelock> 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<String, ? extends Timer> 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<String, ? extends Timer> 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<String, SparseIntArray> 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<types.size(); it++) {
//                         pw.print(" ");
//                         pw.print(JobParameters.getReasonCodeDescription(types.keyAt(it)));
//                         pw.print("(");
//                         pw.print(types.valueAt(it));
//                         pw.print("x)");
//                     }
//                     pw.println();
//                 }
//             }
//             u.getDeferredJobsLineLocked(sb, which);
//             if (sb.length() > 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<? extends BatteryStats.Uid.Sensor> sensors = u.getSensorStats();
//             final int NSE = sensors.size();
//             for (int ise=0; ise<NSE; ise++) {
//                 final Uid.Sensor se = sensors.valueAt(ise);
//                 final int sensorNumber = sensors.keyAt(ise);
//                 sb.setLength(0);
//                 sb.append(prefix);
//                 sb.append("    Sensor ");
//                 int handle = se.getHandle();
//                 if (handle == Uid.Sensor.GPS) {
//                     sb.append("GPS");
//                 } else {
//                     sb.append(handle);
//                 }
//                 sb.append(": ");
//                 final Timer timer = se.getSensorTime();
//                 if (timer != null) {
//                     // 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 = se.getSensorBackgroundTime();
//                     final int bgCount = bgTimer != null ? bgTimer.getCountLocked(which) : 0;
//                     // 'actualTime' are unpooled and always since reset (regardless of 'which')
//                     final long actualTime = timer.getTotalDurationMsLocked(rawRealtimeMs);
//                     final long bgActualTime = bgTimer != null ?
//                             bgTimer.getTotalDurationMsLocked(rawRealtimeMs) : 0;
//                     //timer.logState();
//                     if (totalTime != 0) {
//                         if (actualTime != totalTime) {
//                             formatTimeMs(sb, totalTime);
//                             sb.append("blamed realtime, ");
//                         }
//                         formatTimeMs(sb, actualTime); // since reset, regardless of 'which'
//                         sb.append("realtime (");
//                         sb.append(count);
//                         sb.append(" times)");
//                         if (bgActualTime != 0 || bgCount > 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<Uid.NUM_PROCESS_STATE; ips++) {
//                 long time = u.getProcessStateTime(ips, rawRealtime, which);
//                 if (time > 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<String, ? extends BatteryStats.Uid.Proc> 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<numExcessive; e++) {
//                         Uid.Proc.ExcessivePower ew = ps.getExcessivePower(e);
//                         if (ew != null) {
//                             pw.print(prefix); pw.print("      * Killed for ");
//                                     if (ew.type == Uid.Proc.ExcessivePower.TYPE_CPU) {
//                                         pw.print("cpu");
//                                     } else {
//                                         pw.print("unknown");
//                                     }
//                                     pw.print(" use: ");
//                                     TimeUtils.formatDuration(ew.usedTime, pw);
//                                     pw.print(" over ");
//                                     TimeUtils.formatDuration(ew.overTime, pw);
//                                     if (ew.overTime != 0) {
//                                         pw.print(" (");
//                                         pw.print((ew.usedTime*100)/ew.overTime);
//                                         pw.println("%)");
//                                     }
//                         }
//                     }
//                     uidActivity = true;
//                 }
//             }
//             final ArrayMap<String, ? extends BatteryStats.Uid.Pkg> 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<String, ? extends Counter> 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<String, ? extends  Uid.Pkg.Serv> 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(StringBuilder sb, 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<descriptions.length; i++) {
//             BitDescription bd = descriptions[i];
//             if ((diff&bd.mask) != 0) {
//                 sb.append(longNames ? " " : ",");
//                 if (bd.shift < 0) {
//                     sb.append((newval & bd.mask) != 0 ? "+" : "-");
//                     sb.append(longNames ? bd.name : bd.shortName);
//                     if (bd.mask == HistoryItem.STATE_WAKE_LOCK_FLAG && wakelockTag != null) {
//                         didWake = true;
//                         sb.append("=");
//                         if (longNames) {
//                             UserHandle.formatUid(sb, wakelockTag.uid);
//                             sb.append(":\"");
//                             sb.append(wakelockTag.string);
//                             sb.append("\"");
//                         } else {
//                             sb.append(wakelockTag.poolIdx);
//                         }
//                     }
//                 } else {
//                     sb.append(longNames ? bd.name : bd.shortName);
//                     sb.append("=");
//                     int val = (newval&bd.mask)>>bd.shift;
//                     if (bd.values != null && val >= 0 && val < bd.values.length) {
//                         sb.append(longNames ? bd.values[val] : bd.shortValues[val]);
//                     } else {
//                         sb.append(val);
//                     }
//                 }
//             }
//         }
//         if (!didWake && wakelockTag != null) {
//             sb.append(longNames ? " wake_lock=" : ",w=");
//             if (longNames) {
//                 UserHandle.formatUid(sb, wakelockTag.uid);
//                 sb.append(":\"");
//                 sb.append(wakelockTag.string);
//                 sb.append("\"");
//             } else {
//                 sb.append(wakelockTag.poolIdx);
//             }
//         }
//     }
//     public void prepareForDumpLocked() {
//         // We don't need to require subclasses implement this.
//     }
//     public static class HistoryPrinter {
//         int oldState = 0;
//         int oldState2 = 0;
//         int oldLevel = -1;
//         int oldStatus = -1;
//         int oldHealth = -1;
//         int oldPlug = -1;
//         int oldTemp = -1;
//         int oldVolt = -1;
//         int oldChargeMAh = -1;
//         double oldModemRailChargeMah = -1;
//         double oldWifiRailChargeMah = -1;
//         long lastTime = -1;
//         void reset() {
//             oldState = oldState2 = 0;
//             oldLevel = -1;
//             oldStatus = -1;
//             oldHealth = -1;
//             oldPlug = -1;
//             oldTemp = -1;
//             oldVolt = -1;
//             oldChargeMAh = -1;
//             oldModemRailChargeMah = -1;
//             oldWifiRailChargeMah = -1;
//         }
//         public void printNextItem(PrintWriter pw, HistoryItem rec, long baseTime, boolean checkin,
//                 boolean verbose) {
//             pw.print(printNextItem(rec, baseTime, checkin, verbose));
//         }
//         /** Print the next history item to proto. */
//         public void printNextItem(ProtoOutputStream proto, HistoryItem rec, long baseTime,
//                 boolean verbose) {
//             String item = printNextItem(rec, baseTime, true, verbose);
//             for (String line : item.split("\n")) {
//                 proto.write(BatteryStatsServiceDumpHistoryProto.CSV_LINES, line);
//             }
//         }
//         private String printNextItem(HistoryItem rec, long baseTime, boolean checkin,
//                 boolean verbose) {
//             StringBuilder item = new StringBuilder();
//             if (!checkin) {
//                 item.append("  ");
//                 TimeUtils.formatDuration(
//                         rec.time - baseTime, item, TimeUtils.HUNDRED_DAY_FIELD_LEN);
//                 item.append(" (");
//                 item.append(rec.numReadInts);
//                 item.append(") ");
//             } else {
//                 item.append(BATTERY_STATS_CHECKIN_VERSION); item.append(',');
//                 item.append(HISTORY_DATA); item.append(',');
//                 if (lastTime < 0) {
//                     item.append(rec.time - baseTime);
//                 } else {
//                     item.append(rec.time - lastTime);
//                 }
//                 lastTime = rec.time;
//             }
//             if (rec.cmd == HistoryItem.CMD_START) {
//                 if (checkin) {
//                     item.append(":");
//                 }
//                 item.append("START\n");
//                 reset();
//             } else if (rec.cmd == HistoryItem.CMD_CURRENT_TIME
//                     || rec.cmd == HistoryItem.CMD_RESET) {
//                 if (checkin) {
//                     item.append(":");
//                 }
//                 if (rec.cmd == HistoryItem.CMD_RESET) {
//                     item.append("RESET:");
//                     reset();
//                 }
//                 item.append("TIME:");
//                 if (checkin) {
//                     item.append(rec.currentTime);
//                     item.append("\n");
//                 } else {
//                     item.append(" ");
//                     item.append(DateFormat.format("yyyy-MM-dd-HH-mm-ss",
//                             rec.currentTime).toString());
//                     item.append("\n");
//                 }
//             } else if (rec.cmd == HistoryItem.CMD_SHUTDOWN) {
//                 if (checkin) {
//                     item.append(":");
//                 }
//                 item.append("SHUTDOWN\n");
//             } else if (rec.cmd == HistoryItem.CMD_OVERFLOW) {
//                 if (checkin) {
//                     item.append(":");
//                 }
//                 item.append("*OVERFLOW*\n");
//             } else {
//                 if (!checkin) {
//                     if (rec.batteryLevel < 10) item.append("00");
//                     else if (rec.batteryLevel < 100) item.append("0");
//                     item.append(rec.batteryLevel);
//                     if (verbose) {
//                         item.append(" ");
//                         if (rec.states < 0) ;
//                         else if (rec.states < 0x10) item.append("0000000");
//                         else if (rec.states < 0x100) item.append("000000");
//                         else if (rec.states < 0x1000) item.append("00000");
//                         else if (rec.states < 0x10000) item.append("0000");
//                         else if (rec.states < 0x100000) item.append("000");
//                         else if (rec.states < 0x1000000) item.append("00");
//                         else if (rec.states < 0x10000000) item.append("0");
//                         item.append(Integer.toHexString(rec.states));
//                     }
//                 } else {
//                     if (oldLevel != rec.batteryLevel) {
//                         oldLevel = rec.batteryLevel;
//                         item.append(",Bl="); item.append(rec.batteryLevel);
//                     }
//                 }
//                 if (oldStatus != rec.batteryStatus) {
//                     oldStatus = rec.batteryStatus;
//                     item.append(checkin ? ",Bs=" : " status=");
//                     switch (oldStatus) {
//                         case BatteryManager.BATTERY_STATUS_UNKNOWN:
//                             item.append(checkin ? "?" : "unknown");
//                             break;
//                         case BatteryManager.BATTERY_STATUS_CHARGING:
//                             item.append(checkin ? "c" : "charging");
//                             break;
//                         case BatteryManager.BATTERY_STATUS_DISCHARGING:
//                             item.append(checkin ? "d" : "discharging");
//                             break;
//                         case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
//                             item.append(checkin ? "n" : "not-charging");
//                             break;
//                         case BatteryManager.BATTERY_STATUS_FULL:
//                             item.append(checkin ? "f" : "full");
//                             break;
//                         default:
//                             item.append(oldStatus);
//                             break;
//                     }
//                 }
//                 if (oldHealth != rec.batteryHealth) {
//                     oldHealth = rec.batteryHealth;
//                     item.append(checkin ? ",Bh=" : " health=");
//                     switch (oldHealth) {
//                         case BatteryManager.BATTERY_HEALTH_UNKNOWN:
//                             item.append(checkin ? "?" : "unknown");
//                             break;
//                         case BatteryManager.BATTERY_HEALTH_GOOD:
//                             item.append(checkin ? "g" : "good");
//                             break;
//                         case BatteryManager.BATTERY_HEALTH_OVERHEAT:
//                             item.append(checkin ? "h" : "overheat");
//                             break;
//                         case BatteryManager.BATTERY_HEALTH_DEAD:
//                             item.append(checkin ? "d" : "dead");
//                             break;
//                         case BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:
//                             item.append(checkin ? "v" : "over-voltage");
//                             break;
//                         case BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:
//                             item.append(checkin ? "f" : "failure");
//                             break;
//                         case BatteryManager.BATTERY_HEALTH_COLD:
//                             item.append(checkin ? "c" : "cold");
//                             break;
//                         default:
//                             item.append(oldHealth);
//                             break;
//                     }
//                 }
//                 if (oldPlug != rec.batteryPlugType) {
//                     oldPlug = rec.batteryPlugType;
//                     item.append(checkin ? ",Bp=" : " plug=");
//                     switch (oldPlug) {
//                         case 0:
//                             item.append(checkin ? "n" : "none");
//                             break;
//                         case BatteryManager.BATTERY_PLUGGED_AC:
//                             item.append(checkin ? "a" : "ac");
//                             break;
//                         case BatteryManager.BATTERY_PLUGGED_USB:
//                             item.append(checkin ? "u" : "usb");
//                             break;
//                         case BatteryManager.BATTERY_PLUGGED_WIRELESS:
//                             item.append(checkin ? "w" : "wireless");
//                             break;
//                         default:
//                             item.append(oldPlug);
//                             break;
//                     }
//                 }
//                 if (oldTemp != rec.batteryTemperature) {
//                     oldTemp = rec.batteryTemperature;
//                     item.append(checkin ? ",Bt=" : " temp=");
//                     item.append(oldTemp);
//                 }
//                 if (oldVolt != rec.batteryVoltage) {
//                     oldVolt = rec.batteryVoltage;
//                     item.append(checkin ? ",Bv=" : " volt=");
//                     item.append(oldVolt);
//                 }
//                 final int chargeMAh = rec.batteryChargeUAh / 1000;
//                 if (oldChargeMAh != chargeMAh) {
//                     oldChargeMAh = chargeMAh;
//                     item.append(checkin ? ",Bcc=" : " charge=");
//                     item.append(oldChargeMAh);
//                 }
//                 if (oldModemRailChargeMah != rec.modemRailChargeMah) {
//                     oldModemRailChargeMah = rec.modemRailChargeMah;
//                     item.append(checkin ? ",Mrc=" : " modemRailChargemAh=");
//                     item.append(new DecimalFormat("#.##").format(oldModemRailChargeMah));
//                 }
//                 if (oldWifiRailChargeMah != rec.wifiRailChargeMah) {
//                     oldWifiRailChargeMah = rec.wifiRailChargeMah;
//                     item.append(checkin ? ",Wrc=" : " wifiRailChargemAh=");
//                     item.append(new DecimalFormat("#.##").format(oldWifiRailChargeMah));
//                 }
//                 printBitDescriptions(item, oldState, rec.states, rec.wakelockTag,
//                         HISTORY_STATE_DESCRIPTIONS, !checkin);
//                 printBitDescriptions(item, oldState2, rec.states2, null,
//                         HISTORY_STATE2_DESCRIPTIONS, !checkin);
//                 if (rec.wakeReasonTag != null) {
//                     if (checkin) {
//                         item.append(",wr=");
//                         item.append(rec.wakeReasonTag.poolIdx);
//                     } else {
//                         item.append(" wake_reason=");
//                         item.append(rec.wakeReasonTag.uid);
//                         item.append(":\"");
//                         item.append(rec.wakeReasonTag.string);
//                         item.append("\"");
//                     }
//                 }
//                 if (rec.eventCode != HistoryItem.EVENT_NONE) {
//                     item.append(checkin ? "," : " ");
//                     if ((rec.eventCode&HistoryItem.EVENT_FLAG_START) != 0) {
//                         item.append("+");
//                     } else if ((rec.eventCode&HistoryItem.EVENT_FLAG_FINISH) != 0) {
//                         item.append("-");
//                     }
//                     String[] eventNames = checkin ? HISTORY_EVENT_CHECKIN_NAMES
//                             : HISTORY_EVENT_NAMES;
//                     int idx = rec.eventCode & ~(HistoryItem.EVENT_FLAG_START
//                             | HistoryItem.EVENT_FLAG_FINISH);
//                     if (idx >= 0 && idx < eventNames.length) {
//                         item.append(eventNames[idx]);
//                     } else {
//                         item.append(checkin ? "Ev" : "event");
//                         item.append(idx);
//                     }
//                     item.append("=");
//                     if (checkin) {
//                         item.append(rec.eventTag.poolIdx);
//                     } else {
//                         item.append(HISTORY_EVENT_INT_FORMATTERS[idx]
//                                 .applyAsString(rec.eventTag.uid));
//                         item.append(":\"");
//                         item.append(rec.eventTag.string);
//                         item.append("\"");
//                     }
//                 }
//                 item.append("\n");
//                 if (rec.stepDetails != null) {
//                     if (!checkin) {
//                         item.append("                 Details: cpu=");
//                         item.append(rec.stepDetails.userTime);
//                         item.append("u+");
//                         item.append(rec.stepDetails.systemTime);
//                         item.append("s");
//                         if (rec.stepDetails.appCpuUid1 >= 0) {
//                             item.append(" (");
//                             printStepCpuUidDetails(item, rec.stepDetails.appCpuUid1,
//                                     rec.stepDetails.appCpuUTime1, rec.stepDetails.appCpuSTime1);
//                             if (rec.stepDetails.appCpuUid2 >= 0) {
//                                 item.append(", ");
//                                 printStepCpuUidDetails(item, rec.stepDetails.appCpuUid2,
//                                         rec.stepDetails.appCpuUTime2, rec.stepDetails.appCpuSTime2);
//                             }
//                             if (rec.stepDetails.appCpuUid3 >= 0) {
//                                 item.append(", ");
//                                 printStepCpuUidDetails(item, rec.stepDetails.appCpuUid3,
//                                         rec.stepDetails.appCpuUTime3, rec.stepDetails.appCpuSTime3);
//                             }
//                             item.append(')');
//                         }
//                         item.append("\n");
//                         item.append("                          /proc/stat=");
//                         item.append(rec.stepDetails.statUserTime);
//                         item.append(" usr, ");
//                         item.append(rec.stepDetails.statSystemTime);
//                         item.append(" sys, ");
//                         item.append(rec.stepDetails.statIOWaitTime);
//                         item.append(" io, ");
//                         item.append(rec.stepDetails.statIrqTime);
//                         item.append(" irq, ");
//                         item.append(rec.stepDetails.statSoftIrqTime);
//                         item.append(" sirq, ");
//                         item.append(rec.stepDetails.statIdlTime);
//                         item.append(" 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) {
//                             item.append(" (");
//                             float perc = ((float)totalRun) / ((float)total) * 100;
//                             item.append(String.format("%.1f%%", perc));
//                             item.append(" of ");
//                             StringBuilder sb = new StringBuilder(64);
//                             formatTimeMsNoSpace(sb, total*10);
//                             item.append(sb);
//                             item.append(")");
//                         }
//                         item.append(", PlatformIdleStat ");
//                         item.append(rec.stepDetails.statPlatformIdleState);
//                         item.append("\n");
//                         item.append(", SubsystemPowerState ");
//                         item.append(rec.stepDetails.statSubsystemPowerState);
//                         item.append("\n");
//                     } else {
//                         item.append(BATTERY_STATS_CHECKIN_VERSION); item.append(',');
//                         item.append(HISTORY_DATA); item.append(",0,Dcpu=");
//                         item.append(rec.stepDetails.userTime);
//                         item.append(":");
//                         item.append(rec.stepDetails.systemTime);
//                         if (rec.stepDetails.appCpuUid1 >= 0) {
//                             printStepCpuUidCheckinDetails(item, rec.stepDetails.appCpuUid1,
//                                     rec.stepDetails.appCpuUTime1, rec.stepDetails.appCpuSTime1);
//                             if (rec.stepDetails.appCpuUid2 >= 0) {
//                                 printStepCpuUidCheckinDetails(item, rec.stepDetails.appCpuUid2,
//                                         rec.stepDetails.appCpuUTime2, rec.stepDetails.appCpuSTime2);
//                             }
//                             if (rec.stepDetails.appCpuUid3 >= 0) {
//                                 printStepCpuUidCheckinDetails(item, rec.stepDetails.appCpuUid3,
//                                         rec.stepDetails.appCpuUTime3, rec.stepDetails.appCpuSTime3);
//                             }
//                         }
//                         item.append("\n");
//                         item.append(BATTERY_STATS_CHECKIN_VERSION); item.append(',');
//                         item.append(HISTORY_DATA); item.append(",0,Dpst=");
//                         item.append(rec.stepDetails.statUserTime);
//                         item.append(',');
//                         item.append(rec.stepDetails.statSystemTime);
//                         item.append(',');
//                         item.append(rec.stepDetails.statIOWaitTime);
//                         item.append(',');
//                         item.append(rec.stepDetails.statIrqTime);
//                         item.append(',');
//                         item.append(rec.stepDetails.statSoftIrqTime);
//                         item.append(',');
//                         item.append(rec.stepDetails.statIdlTime);
//                         item.append(',');
//                         if (rec.stepDetails.statPlatformIdleState != null) {
//                             item.append(rec.stepDetails.statPlatformIdleState);
//                             if (rec.stepDetails.statSubsystemPowerState != null) {
//                                 item.append(',');
//                             }
//                         }
//                         if (rec.stepDetails.statSubsystemPowerState != null) {
//                             item.append(rec.stepDetails.statSubsystemPowerState);
//                         }
//                         item.append("\n");
//                     }
//                 }
//                 oldState = rec.states;
//                 oldState2 = rec.states2;
//                 // Clear High Tx Power Flag for volta positioning
//                 if ((rec.states2 & HistoryItem.STATE2_CELLULAR_HIGH_TX_POWER_FLAG) != 0) {
//                     rec.states2 &= ~HistoryItem.STATE2_CELLULAR_HIGH_TX_POWER_FLAG;
//                 }
//             }
//             return item.toString();
//         }
//         private void printStepCpuUidDetails(StringBuilder sb, int uid, int utime, int stime) {
//             UserHandle.formatUid(sb, uid);
//             sb.append("=");
//             sb.append(utime);
//             sb.append("u+");
//             sb.append(stime);
//             sb.append("s");
//         }
//         private void printStepCpuUidCheckinDetails(StringBuilder sb, int uid, int utime,
//                 int stime) {
//             sb.append('/');
//             sb.append(uid);
//             sb.append(":");
//             sb.append(utime);
//             sb.append(":");
//             sb.append(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<count; i++) {
//             long duration = steps.getDurationAt(i);
//             int level = steps.getLevelAt(i);
//             long initMode = steps.getInitModeAt(i);
//             long modMode = steps.getModModeAt(i);
//             if (checkin) {
//                 lineArgs[0] = Long.toString(duration);
//                 lineArgs[1] = Integer.toString(level);
//                 if ((modMode&STEP_LEVEL_MODE_SCREEN_STATE) == 0) {
//                     switch ((int)(initMode&STEP_LEVEL_MODE_SCREEN_STATE) + 1) {
//                         case Display.STATE_OFF: lineArgs[2] = "s-"; break;
//                         case Display.STATE_ON: lineArgs[2] = "s+"; break;
//                         case Display.STATE_DOZE: lineArgs[2] = "sd"; break;
//                         case Display.STATE_DOZE_SUSPEND: lineArgs[2] = "sds"; break;
//                         default: lineArgs[2] = "?"; break;
//                     }
//                 } else {
//                     lineArgs[2] = "";
//                 }
//                 if ((modMode&STEP_LEVEL_MODE_POWER_SAVE) == 0) {
//                     lineArgs[3] = (initMode&STEP_LEVEL_MODE_POWER_SAVE) != 0 ? "p+" : "p-";
//                 } else {
//                     lineArgs[3] = "";
//                 }
//                 if ((modMode&STEP_LEVEL_MODE_DEVICE_IDLE) == 0) {
//                     lineArgs[4] = (initMode&STEP_LEVEL_MODE_DEVICE_IDLE) != 0 ? "i+" : "i-";
//                 } else {
//                     lineArgs[4] = "";
//                 }
//                 dumpLine(pw, 0 /* uid */, "i" /* category */, header, (Object[])lineArgs);
//             } else {
//                 pw.print(prefix);
//                 pw.print("#"); pw.print(i); pw.print(": ");
//                 TimeUtils.formatDuration(duration, pw);
//                 pw.print(" to "); pw.print(level);
//                 boolean haveModes = false;
//                 if ((modMode&STEP_LEVEL_MODE_SCREEN_STATE) == 0) {
//                     pw.print(" (");
//                     switch ((int)(initMode&STEP_LEVEL_MODE_SCREEN_STATE) + 1) {
//                         case Display.STATE_OFF: pw.print("screen-off"); break;
//                         case Display.STATE_ON: pw.print("screen-on"); break;
//                         case Display.STATE_DOZE: pw.print("screen-doze"); break;
//                         case Display.STATE_DOZE_SUSPEND: pw.print("screen-doze-suspend"); break;
//                         default: pw.print("screen-?"); break;
//                     }
//                     haveModes = true;
//                 }
//                 if ((modMode&STEP_LEVEL_MODE_POWER_SAVE) == 0) {
//                     pw.print(haveModes ? ", " : " (");
//                     pw.print((initMode&STEP_LEVEL_MODE_POWER_SAVE) != 0
//                             ? "power-save-on" : "power-save-off");
//                     haveModes = true;
//                 }
//                 if ((modMode&STEP_LEVEL_MODE_DEVICE_IDLE) == 0) {
//                     pw.print(haveModes ? ", " : " (");
//                     pw.print((initMode&STEP_LEVEL_MODE_DEVICE_IDLE) != 0
//                             ? "device-idle-on" : "device-idle-off");
//                     haveModes = true;
//                 }
//                 if (haveModes) {
//                     pw.print(")");
//                 }
//                 pw.println();
//             }
//         }
//         return true;
//     }
//     private static void dumpDurationSteps(ProtoOutputStream proto, long fieldId,
//             LevelStepTracker steps) {
//         if (steps == null) {
//             return;
//         }
//         int count = steps.mNumStepDurations;
//         for (int i = 0; i < count; ++i) {
//             long token = proto.start(fieldId);
//             proto.write(SystemProto.BatteryLevelStep.DURATION_MS, steps.getDurationAt(i));
//             proto.write(SystemProto.BatteryLevelStep.LEVEL, steps.getLevelAt(i));
//             final long initMode = steps.getInitModeAt(i);
//             final long modMode = steps.getModModeAt(i);
//             int ds = SystemProto.BatteryLevelStep.DS_MIXED;
//             if ((modMode & STEP_LEVEL_MODE_SCREEN_STATE) == 0) {
//                 switch ((int) (initMode & STEP_LEVEL_MODE_SCREEN_STATE) + 1) {
//                     case Display.STATE_OFF:
//                         ds = SystemProto.BatteryLevelStep.DS_OFF;
//                         break;
//                     case Display.STATE_ON:
//                         ds = SystemProto.BatteryLevelStep.DS_ON;
//                         break;
//                     case Display.STATE_DOZE:
//                         ds = SystemProto.BatteryLevelStep.DS_DOZE;
//                         break;
//                     case Display.STATE_DOZE_SUSPEND:
//                         ds = SystemProto.BatteryLevelStep.DS_DOZE_SUSPEND;
//                         break;
//                     default:
//                         ds = SystemProto.BatteryLevelStep.DS_ERROR;
//                         break;
//                 }
//             }
//             proto.write(SystemProto.BatteryLevelStep.DISPLAY_STATE, ds);
//             int psm = SystemProto.BatteryLevelStep.PSM_MIXED;
//             if ((modMode & STEP_LEVEL_MODE_POWER_SAVE) == 0) {
//                 psm = (initMode & STEP_LEVEL_MODE_POWER_SAVE) != 0
//                     ? SystemProto.BatteryLevelStep.PSM_ON : SystemProto.BatteryLevelStep.PSM_OFF;
//             }
//             proto.write(SystemProto.BatteryLevelStep.POWER_SAVE_MODE, psm);
//             int im = SystemProto.BatteryLevelStep.IM_MIXED;
//             if ((modMode & STEP_LEVEL_MODE_DEVICE_IDLE) == 0) {
//                 im = (initMode & STEP_LEVEL_MODE_DEVICE_IDLE) != 0
//                     ? SystemProto.BatteryLevelStep.IM_ON : SystemProto.BatteryLevelStep.IM_OFF;
//             }
//             proto.write(SystemProto.BatteryLevelStep.IDLE_MODE, im);
//             proto.end(token);
//         }
//     }
//     public static final int DUMP_CHARGED_ONLY = 1<<1;
//     public static final int DUMP_DAILY_ONLY = 1<<2;
//     public static final int DUMP_HISTORY_ONLY = 1<<3;
//     public static final int DUMP_INCLUDE_HISTORY = 1<<4;
//     public static final int DUMP_VERBOSE = 1<<5;
//     public static final int DUMP_DEVICE_WIFI_ONLY = 1<<6;
//     private void dumpHistoryLocked(PrintWriter pw, int flags, long histStart, boolean checkin) {
//         final HistoryPrinter hprinter = new HistoryPrinter();
//         final HistoryItem rec = new HistoryItem();
//         long lastTime = -1;
//         long baseTime = -1;
//         boolean printed = false;
//         HistoryEventTracker tracker = null;
//         while (getNextHistoryLocked(rec)) {
//             lastTime = rec.time;
//             if (baseTime < 0) {
//                 baseTime = lastTime;
//             }
//             if (rec.time >= 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<HistoryItem.EVENT_COUNT; i++) {
//                             HashMap<String, SparseIntArray> active
//                                     = tracker.getStateForEvent(i);
//                             if (active == null) {
//                                 continue;
//                             }
//                             for (HashMap.Entry<String, SparseIntArray> ent
//                                     : active.entrySet()) {
//                                 SparseIntArray uids = ent.getValue();
//                                 for (int j=0; j<uids.size(); j++) {
//                                     rec.eventCode = i;
//                                     rec.eventTag.string = ent.getKey();
//                                     rec.eventTag.uid = uids.keyAt(j);
//                                     rec.eventTag.poolIdx = uids.valueAt(j);
//                                     hprinter.printNextItem(pw, rec, baseTime, checkin,
//                                             (flags&DUMP_VERBOSE) != 0);
//                                     rec.wakeReasonTag = null;
//                                     rec.wakelockTag = null;
//                                 }
//                             }
//                         }
//                         rec.eventCode = oldEventCode;
//                         rec.eventTag = oldEventTag;
//                         tracker = null;
//                     }
//                 }
//                 hprinter.printNextItem(pw, rec, baseTime, checkin,
//                         (flags&DUMP_VERBOSE) != 0);
//             } else if (false && rec.eventCode != HistoryItem.EVENT_NONE) {
//                 // This is an attempt to aggregate the previous state and generate
//                 // fake events to reflect that state at the point where we start
//                 // printing real events.  It doesn't really work right, so is turned off.
//                 if (tracker == null) {
//                     tracker = new HistoryEventTracker();
//                 }
//                 tracker.updateState(rec.eventCode, rec.eventTag.string,
//                         rec.eventTag.uid, rec.eventTag.poolIdx);
//             }
//         }
//         if (histStart >= 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<PackageChange> changes) {
//         if (changes == null) {
//             return;
//         }
//         pw.print(prefix); pw.println("Package changes:");
//         for (int i=0; i<changes.size(); i++) {
//             PackageChange pc = changes.get(i);
//             if (pc.mUpdate) {
//                 pw.print(prefix); pw.print("  Update "); pw.print(pc.mPackageName);
//                 pw.print(" vers="); pw.println(pc.mVersionCode);
//             } else {
//                 pw.print(prefix); pw.print("  Uninstall "); pw.println(pc.mPackageName);
//             }
//         }
//     }
//     /**
//      * Dumps a human-readable summary of the battery statistics to the given PrintWriter.
//      *
//      * @param pw a Printer to receive the dump output.
//      */
//     @SuppressWarnings("unused")
//     public void dumpLocked(Context context, PrintWriter pw, int flags, int reqUid, long histStart) {
//         prepareForDumpLocked();
//         final boolean filtering = (flags
//                 & (DUMP_HISTORY_ONLY|DUMP_CHARGED_ONLY|DUMP_DAILY_ONLY)) != 0;
//         if ((flags&DUMP_HISTORY_ONLY) != 0 || !filtering) {
//             final long historyTotalSize = getHistoryTotalSize();
//             final long historyUsedSize = getHistoryUsedSize();
//             if (startIteratingHistoryLocked()) {
//                 try {
//                     pw.print("Battery History (");
//                     pw.print((100*historyUsedSize)/historyTotalSize);
//                     pw.print("% used, ");
//                     printSizeValue(pw, historyUsedSize);
//                     pw.print(" used of ");
//                     printSizeValue(pw, historyTotalSize);
//                     pw.print(", ");
//                     pw.print(getHistoryStringPoolSize());
//                     pw.print(" strings using ");
//                     printSizeValue(pw, getHistoryStringPoolBytes());
//                     pw.println("):");
//                     dumpHistoryLocked(pw, flags, histStart, false);
//                     pw.println();
//                 } finally {
//                     finishIteratingHistoryLocked();
//                 }
//             }
//             if (startIteratingOldHistoryLocked()) {
//                 try {
//                     final HistoryItem rec = new HistoryItem();
//                     pw.println("Old battery History:");
//                     HistoryPrinter hprinter = new HistoryPrinter();
//                     long baseTime = -1;
//                     while (getNextOldHistoryLocked(rec)) {
//                         if (baseTime < 0) {
//                             baseTime = rec.time;
//                         }
//                         hprinter.printNextItem(pw, rec, baseTime, false, (flags&DUMP_VERBOSE) != 0);
//                     }
//                     pw.println();
//                 } finally {
//                     finishIteratingOldHistoryLocked();
//                 }
//             }
//         }
//         if (filtering && (flags&(DUMP_CHARGED_ONLY|DUMP_DAILY_ONLY)) == 0) {
//             return;
//         }
//         if (!filtering) {
//             SparseArray<? extends Uid> uidStats = getUidStats();
//             final int NU = uidStats.size();
//             boolean didPid = false;
//             long nowRealtime = SystemClock.elapsedRealtime();
//             for (int i=0; i<NU; i++) {
//                 Uid uid = uidStats.valueAt(i);
//                 SparseArray<? extends Uid.Pid> pids = uid.getPidStats();
//                 if (pids != null) {
//                     for (int j=0; j<pids.size(); j++) {
//                         Uid.Pid pid = pids.valueAt(j);
//                         if (!didPid) {
//                             pw.println("Per-PID Stats:");
//                             didPid = true;
//                         }
//                         long time = pid.mWakeSumMs + (pid.mWakeNesting > 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<PackageChange> 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<ApplicationInfo> 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<getHistoryStringPoolSize(); i++) {
//                         pw.print(BATTERY_STATS_CHECKIN_VERSION); pw.print(',');
//                         pw.print(HISTORY_STRING_POOL); pw.print(',');
//                         pw.print(i);
//                         pw.print(",");
//                         pw.print(getHistoryTagPoolUid(i));
//                         pw.print(",\"");
//                         String str = getHistoryTagPoolString(i);
//                         str = str.replace("\\", "\\\\");
//                         str = str.replace("\"", "\\\"");
//                         pw.print(str);
//                         pw.print("\"");
//                         pw.println();
//                     }
//                     dumpHistoryLocked(pw, flags, histStart, true);
//                 } finally {
//                     finishIteratingHistoryLocked();
//                 }
//             }
//         }
//         if ((flags & DUMP_HISTORY_ONLY) != 0) {
//             return;
//         }
//         if (apps != null) {
//             SparseArray<Pair<ArrayList<String>, MutableBoolean>> uids = new SparseArray<>();
//             for (int i=0; i<apps.size(); i++) {
//                 ApplicationInfo ai = apps.get(i);
//                 Pair<ArrayList<String>, MutableBoolean> pkgs = uids.get(
//                         UserHandle.getAppId(ai.uid));
//                 if (pkgs == null) {
//                     pkgs = new Pair<>(new ArrayList<String>(), new MutableBoolean(false));
//                     uids.put(UserHandle.getAppId(ai.uid), pkgs);
//                 }
//                 pkgs.first.add(ai.packageName);
//             }
//             SparseArray<? extends Uid> uidStats = getUidStats();
//             final int NU = uidStats.size();
//             String[] lineArgs = new String[2];
//             for (int i=0; i<NU; i++) {
//                 int uid = UserHandle.getAppId(uidStats.keyAt(i));
//                 Pair<ArrayList<String>, MutableBoolean> pkgs = uids.get(uid);
//                 if (pkgs != null && !pkgs.second.value) {
//                     pkgs.second.value = true;
//                     for (int j=0; j<pkgs.first.size(); j++) {
//                         lineArgs[0] = Integer.toString(uid);
//                         lineArgs[1] = pkgs.first.get(j);
//                         dumpLine(pw, 0 /* uid */, "i" /* category */, UID_DATA,
//                                 (Object[])lineArgs);
//                     }
//                 }
//             }
//         }
//         if ((flags & DUMP_DAILY_ONLY) == 0) {
//             dumpDurationSteps(pw, "", DISCHARGE_STEP_DATA, getDischargeLevelStepTracker(), true);
//             String[] lineArgs = new String[1];
//             long timeRemaining = computeBatteryTimeRemaining(SystemClock.elapsedRealtime() * 1000);
//             if (timeRemaining >= 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. If the flags include
//      * DUMP_INCLUDE_HISTORY or DUMP_HISTORY_ONLY, only the history will be dumped.
//      * @hide
//      */
//     public void dumpProtoLocked(Context context, FileDescriptor fd, List<ApplicationInfo> apps,
//             int flags, long histStart) {
//         final ProtoOutputStream proto = new ProtoOutputStream(fd);
//         prepareForDumpLocked();
//         if ((flags & (DUMP_INCLUDE_HISTORY | DUMP_HISTORY_ONLY)) != 0) {
//             dumpProtoHistoryLocked(proto, flags, histStart);
//             proto.flush();
//             return;
//         }
//         final long bToken = proto.start(BatteryStatsServiceDumpProto.BATTERYSTATS);
//         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());
//         if ((flags & 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<ApplicationInfo> 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<ArrayList<String>> 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<String> pkgs = aidToPackages.get(aid);
//                 if (pkgs == null) {
//                     pkgs = new ArrayList<String>();
//                     aidToPackages.put(aid, pkgs);
//                 }
//                 pkgs.add(ai.packageName);
//             }
//         }
//         SparseArray<BatterySipper> uidToSipper = new SparseArray<>();
//         final List<BatterySipper> 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<? extends Uid> 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<String> pkgs = aidToPackages.get(UserHandle.getAppId(uid));
//             if (pkgs == null) {
//                 pkgs = new ArrayList<String>();
//             }
//             final ArrayMap<String, ? extends BatteryStats.Uid.Pkg> packageStats =
//                     u.getPackageStats();
//             for (int ipkg = packageStats.size() - 1; ipkg >= 0; --ipkg) {
//                 String pkg = packageStats.keyAt(ipkg);
//                 final ArrayMap<String, ? extends  Uid.Pkg.Serv> 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);
//                     final long startTimeMs = roundUsToMs(ss.getStartTime(batteryUptimeUs, which));
//                     final int starts = ss.getStarts(which);
//                     final int launches = ss.getLaunches(which);
//                     if (startTimeMs == 0 && starts == 0 && launches == 0) {
//                         continue;
//                     }
//                     long sToken = proto.start(UidProto.Package.SERVICES);
//                     proto.write(UidProto.Package.Service.NAME, serviceStats.keyAt(isvc));
//                     proto.write(UidProto.Package.Service.START_DURATION_MS, startTimeMs);
//                     proto.write(UidProto.Package.Service.START_COUNT, starts);
//                     proto.write(UidProto.Package.Service.LAUNCH_COUNT, launches);
//                     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<String, SparseIntArray> completions = u.getJobCompletionStats();
//             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 : JobParameters.getJobStopReasonCodes()) {
//                         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<String, ? extends Timer> 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<String, ? extends BatteryStats.Uid.Proc> 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<? extends BatteryStats.Uid.Sensor> 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<String, ? extends Timer> 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<String, ? extends Uid.Wakelock> 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<String, ? extends Counter> 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 dumpProtoHistoryLocked(ProtoOutputStream proto, int flags, long histStart) {
//         if (!startIteratingHistoryLocked()) {
//             return;
//         }
//         proto.write(BatteryStatsServiceDumpHistoryProto.REPORT_VERSION, CHECKIN_VERSION);
//         proto.write(BatteryStatsServiceDumpHistoryProto.PARCEL_VERSION, getParcelVersion());
//         proto.write(BatteryStatsServiceDumpHistoryProto.START_PLATFORM_VERSION,
//                 getStartPlatformVersion());
//         proto.write(BatteryStatsServiceDumpHistoryProto.END_PLATFORM_VERSION,
//                 getEndPlatformVersion());
//         try {
//             long token;
//             // History string pool (HISTORY_STRING_POOL)
//             for (int i = 0; i < getHistoryStringPoolSize(); ++i) {
//                 token = proto.start(BatteryStatsServiceDumpHistoryProto.KEYS);
//                 proto.write(BatteryStatsServiceDumpHistoryProto.Key.INDEX, i);
//                 proto.write(BatteryStatsServiceDumpHistoryProto.Key.UID, getHistoryTagPoolUid(i));
//                 proto.write(BatteryStatsServiceDumpHistoryProto.Key.TAG,
//                         getHistoryTagPoolString(i));
//                 proto.end(token);
//             }
//             // History data (HISTORY_DATA)
//             final HistoryPrinter hprinter = new HistoryPrinter();
//             final HistoryItem rec = new HistoryItem();
//             long lastTime = -1;
//             long baseTime = -1;
//             boolean printed = false;
//             HistoryEventTracker tracker = null;
//             while (getNextHistoryLocked(rec)) {
//                 lastTime = rec.time;
//                 if (baseTime < 0) {
//                     baseTime = lastTime;
//                 }
//                 if (rec.time >= 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(proto, rec, baseTime,
//                                     (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(proto, rec, baseTime,
//                                     (flags & DUMP_VERBOSE) != 0);
//                             rec.cmd = cmd;
//                         }
//                         if (tracker != null) {
//                             if (rec.cmd != HistoryItem.CMD_UPDATE) {
//                                 hprinter.printNextItem(proto, rec, baseTime,
//                                         (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 < HistoryItem.EVENT_COUNT; i++) {
//                                 HashMap<String, SparseIntArray> active =
//                                         tracker.getStateForEvent(i);
//                                 if (active == null) {
//                                     continue;
//                                 }
//                                 for (HashMap.Entry<String, SparseIntArray> ent
//                                         : active.entrySet()) {
//                                     SparseIntArray uids = ent.getValue();
//                                     for (int j = 0; j < uids.size(); j++) {
//                                         rec.eventCode = i;
//                                         rec.eventTag.string = ent.getKey();
//                                         rec.eventTag.uid = uids.keyAt(j);
//                                         rec.eventTag.poolIdx = uids.valueAt(j);
//                                         hprinter.printNextItem(proto, rec, baseTime,
//                                                 (flags & DUMP_VERBOSE) != 0);
//                                         rec.wakeReasonTag = null;
//                                         rec.wakelockTag = null;
//                                     }
//                                 }
//                             }
//                             rec.eventCode = oldEventCode;
//                             rec.eventTag = oldEventTag;
//                             tracker = null;
//                         }
//                     }
//                     hprinter.printNextItem(proto, rec, baseTime,
//                             (flags & DUMP_VERBOSE) != 0);
//                 }
//             }
//             if (histStart >= 0) {
//                 commitCurrentHistoryBatchLocked();
//                 proto.write(BatteryStatsServiceDumpHistoryProto.CSV_LINES,
//                         "NEXT: " + (lastTime + 1));
//             }
//         } finally {
//             finishIteratingHistoryLocked();
//         }
//     }
//     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_OUT_OF_SERVICE);
//             int telephonyNetworkType = i;
//             if (i == DATA_CONNECTION_OTHER || i == DATA_CONNECTION_EMERGENCY_SERVICE) {
//                 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<String, ? extends Timer> kernelWakelocks = getKernelWakelockStats();
//         for (Map.Entry<String, ? extends Timer> 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<? extends Uid> uidStats = getUidStats();
//         for (int iu = 0; iu < uidStats.size(); iu++) {
//             final Uid u = uidStats.valueAt(iu);
//             final ArrayMap<String, ? extends BatteryStats.Uid.Wakelock> 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<BatterySipper> 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 AMBIENT_DISPLAY:
//                         n = SystemProto.PowerUseItem.AMBIENT_DISPLAY;
//                         break;
//                     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<String, ? extends Timer> rpmStats = getRpmStats();
//         final Map<String, ? extends Timer> screenOffRpmStats = getScreenOffRpmStats();
//         for (Map.Entry<String, ? extends Timer> 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 < CellSignalStrength.getNumSignalStrengthLevels(); ++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<String, ? extends Timer> wakeupReasons = getWakeupReasonStats();
//         for (Map.Entry<String, ? extends Timer> 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);
//     }
// }