/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.server.am;

import android.os.BatteryStats;
import static android.os.BatteryStats.STATS_SINCE_UNPLUGGED;
import android.os.PowerManager;
import android.os.SystemClock;
import android.os.health.HealthKeys;
import android.os.health.HealthStatsParceler;
import android.os.health.HealthStatsWriter;
import android.os.health.PackageHealthStats;
import android.os.health.ProcessHealthStats;
import android.os.health.PidHealthStats;
import android.os.health.ServiceHealthStats;
import android.os.health.TimerStat;
import android.os.health.UidHealthStats;
import android.util.SparseArray;

import java.util.Map;

public class HealthStatsBatteryStatsWriter {

    private final long mNowRealtimeMs;
    private final long mNowUptimeMs;

    public HealthStatsBatteryStatsWriter() {
        mNowRealtimeMs = SystemClock.elapsedRealtime();
        mNowUptimeMs = SystemClock.uptimeMillis();
    }

    /**
     * Writes the contents of a BatteryStats.Uid into a HealthStatsWriter.
     */
    public void writeUid(HealthStatsWriter uidWriter, BatteryStats bs, BatteryStats.Uid uid) {
        int N;
        BatteryStats.Timer timer;
        SparseArray<? extends BatteryStats.Uid.Sensor> sensors;
        SparseArray<? extends BatteryStats.Uid.Pid> pids;
        BatteryStats.ControllerActivityCounter controller;
        long sum;

        //
        // It's a little odd for these first four to be here but it's not the end of the
        // world. It would be easy enough to duplicate them somewhere else if this API
        // grows.
        //

        // MEASUREMENT_REALTIME_BATTERY_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_REALTIME_BATTERY_MS,
                bs.computeBatteryRealtime(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_UPTIME_BATTERY_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_UPTIME_BATTERY_MS,
                bs.computeBatteryUptime(mNowUptimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_REALTIME_SCREEN_OFF_BATTERY_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_REALTIME_SCREEN_OFF_BATTERY_MS,
                bs.computeBatteryScreenOffRealtime(
                    mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_UPTIME_SCREEN_OFF_BATTERY_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_UPTIME_SCREEN_OFF_BATTERY_MS,
                bs.computeBatteryScreenOffUptime(mNowUptimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        //
        // Now on to the real per-uid stats...
        //

        for (final Map.Entry<String,? extends BatteryStats.Uid.Wakelock> entry:
                uid.getWakelockStats().entrySet()) {
            final String key = entry.getKey();
            final BatteryStats.Uid.Wakelock wakelock = entry.getValue();

            // TIMERS_WAKELOCKS_FULL
            timer = wakelock.getWakeTime(BatteryStats.WAKE_TYPE_FULL);
            addTimers(uidWriter, UidHealthStats.TIMERS_WAKELOCKS_FULL, key, timer);

            // TIMERS_WAKELOCKS_PARTIAL
            timer = wakelock.getWakeTime(BatteryStats.WAKE_TYPE_PARTIAL);
            addTimers(uidWriter, UidHealthStats.TIMERS_WAKELOCKS_PARTIAL, key, timer);
            
            // TIMERS_WAKELOCKS_WINDOW
            timer = wakelock.getWakeTime(BatteryStats.WAKE_TYPE_WINDOW);
            addTimers(uidWriter, UidHealthStats.TIMERS_WAKELOCKS_WINDOW, key, timer);
            
            // TIMERS_WAKELOCKS_DRAW
            timer = wakelock.getWakeTime(BatteryStats.WAKE_TYPE_DRAW);
            addTimers(uidWriter, UidHealthStats.TIMERS_WAKELOCKS_DRAW, key, timer);
        }
        
        // TIMERS_SYNCS
        for (final Map.Entry<String,? extends BatteryStats.Timer> entry:
                uid.getSyncStats().entrySet()) {
            addTimers(uidWriter, UidHealthStats.TIMERS_SYNCS, entry.getKey(), entry.getValue());
        }

        // TIMERS_JOBS
        for (final Map.Entry<String,? extends BatteryStats.Timer> entry:
                uid.getJobStats().entrySet()) {
            addTimers(uidWriter, UidHealthStats.TIMERS_JOBS, entry.getKey(), entry.getValue());
        }

        // TIMERS_SENSORS
        sensors = uid.getSensorStats();
        N = sensors.size();
        for (int i=0; i<N; i++) {
            int sensorId = sensors.keyAt(i);
            // Battery Stats stores the GPS sensors with a bogus key in this API. Pull it out
            // as a separate metric here so as to not expose that in the API.
            if (sensorId == BatteryStats.Uid.Sensor.GPS) {
                addTimer(uidWriter, UidHealthStats.TIMER_GPS_SENSOR,
                        sensors.valueAt(i).getSensorTime());
            } else {
                addTimers(uidWriter, UidHealthStats.TIMERS_SENSORS, Integer.toString(sensorId),
                        sensors.valueAt(i).getSensorTime());
            }
        }

        // STATS_PIDS
        pids = uid.getPidStats();
        N = pids.size();
        for (int i=0; i<N; i++) {
            final HealthStatsWriter writer = new HealthStatsWriter(PidHealthStats.CONSTANTS);
            writePid(writer, pids.valueAt(i));
            uidWriter.addStats(UidHealthStats.STATS_PIDS, Integer.toString(pids.keyAt(i)), writer);
        }

        // STATS_PROCESSES
        for (final Map.Entry<String,? extends BatteryStats.Uid.Proc> entry:
                uid.getProcessStats().entrySet()) {
            final HealthStatsWriter writer = new HealthStatsWriter(ProcessHealthStats.CONSTANTS);
            writeProc(writer, entry.getValue());
            uidWriter.addStats(UidHealthStats.STATS_PROCESSES, entry.getKey(), writer);
        }

        // STATS_PACKAGES
        for (final Map.Entry<String,? extends BatteryStats.Uid.Pkg> entry:
                uid.getPackageStats().entrySet()) {
            final HealthStatsWriter writer = new HealthStatsWriter(PackageHealthStats.CONSTANTS);
            writePkg(writer, entry.getValue());
            uidWriter.addStats(UidHealthStats.STATS_PACKAGES, entry.getKey(), writer);
        }

        controller = uid.getWifiControllerActivity();
        if (controller != null) {
            // MEASUREMENT_WIFI_IDLE_MS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_IDLE_MS,
                    controller.getIdleTimeCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
            // MEASUREMENT_WIFI_RX_MS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_RX_MS,
                    controller.getRxTimeCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
            // MEASUREMENT_WIFI_TX_MS
            sum = 0;
            for (final BatteryStats.LongCounter counter: controller.getTxTimeCounters()) {
                sum += counter.getCountLocked(STATS_SINCE_UNPLUGGED);
            }
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_TX_MS, sum);
            // MEASUREMENT_WIFI_POWER_MAMS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_POWER_MAMS,
                    controller.getPowerCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
        }

        controller = uid.getBluetoothControllerActivity();
        if (controller != null) {
            // MEASUREMENT_BLUETOOTH_IDLE_MS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_IDLE_MS,
                    controller.getIdleTimeCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
            // MEASUREMENT_BLUETOOTH_RX_MS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_RX_MS,
                    controller.getRxTimeCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
            // MEASUREMENT_BLUETOOTH_TX_MS
            sum = 0;
            for (final BatteryStats.LongCounter counter: controller.getTxTimeCounters()) {
                sum += counter.getCountLocked(STATS_SINCE_UNPLUGGED);
            }
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_TX_MS, sum);
            // MEASUREMENT_BLUETOOTH_POWER_MAMS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_POWER_MAMS,
                    controller.getPowerCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
        }

        controller = uid.getModemControllerActivity();
        if (controller != null) {
            // MEASUREMENT_MOBILE_IDLE_MS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_IDLE_MS,
                    controller.getIdleTimeCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
            // MEASUREMENT_MOBILE_RX_MS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_RX_MS,
                    controller.getRxTimeCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
            // MEASUREMENT_MOBILE_TX_MS
            sum = 0;
            for (final BatteryStats.LongCounter counter: controller.getTxTimeCounters()) {
                sum += counter.getCountLocked(STATS_SINCE_UNPLUGGED);
            }
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_TX_MS, sum);
            // MEASUREMENT_MOBILE_POWER_MAMS
            uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_POWER_MAMS,
                    controller.getPowerCounter().getCountLocked(STATS_SINCE_UNPLUGGED));
        }

        // MEASUREMENT_WIFI_RUNNING_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_RUNNING_MS,
                uid.getWifiRunningTime(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_WIFI_FULL_LOCK_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_FULL_LOCK_MS,
                uid.getFullWifiLockTime(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // TIMER_WIFI_SCAN
        uidWriter.addTimer(UidHealthStats.TIMER_WIFI_SCAN,
                uid.getWifiScanCount(STATS_SINCE_UNPLUGGED),
                uid.getWifiScanTime(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_WIFI_MULTICAST_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_MULTICAST_MS,
                uid.getWifiMulticastTime(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED)/1000);

        // TIMER_AUDIO
        addTimer(uidWriter, UidHealthStats.TIMER_AUDIO, uid.getAudioTurnedOnTimer());

        // TIMER_VIDEO
        addTimer(uidWriter, UidHealthStats.TIMER_VIDEO, uid.getVideoTurnedOnTimer());

        // TIMER_FLASHLIGHT
        addTimer(uidWriter, UidHealthStats.TIMER_FLASHLIGHT, uid.getFlashlightTurnedOnTimer());

        // TIMER_CAMERA
        addTimer(uidWriter, UidHealthStats.TIMER_CAMERA, uid.getCameraTurnedOnTimer());

        // TIMER_FOREGROUND_ACTIVITY
        addTimer(uidWriter, UidHealthStats.TIMER_FOREGROUND_ACTIVITY,
                uid.getForegroundActivityTimer());

        // TIMER_BLUETOOTH_SCAN
        addTimer(uidWriter, UidHealthStats.TIMER_BLUETOOTH_SCAN, uid.getBluetoothScanTimer());

        // TIMER_PROCESS_STATE_TOP_MS
        addTimer(uidWriter, UidHealthStats.TIMER_PROCESS_STATE_TOP_MS,
                uid.getProcessStateTimer(BatteryStats.Uid.PROCESS_STATE_TOP));

        // TIMER_PROCESS_STATE_FOREGROUND_SERVICE_MS
        addTimer(uidWriter, UidHealthStats.TIMER_PROCESS_STATE_FOREGROUND_SERVICE_MS,
                uid.getProcessStateTimer(BatteryStats.Uid.PROCESS_STATE_FOREGROUND_SERVICE));

        // TIMER_PROCESS_STATE_TOP_SLEEPING_MS
        addTimer(uidWriter, UidHealthStats.TIMER_PROCESS_STATE_TOP_SLEEPING_MS,
                uid.getProcessStateTimer(BatteryStats.Uid.PROCESS_STATE_TOP_SLEEPING));

        // TIMER_PROCESS_STATE_FOREGROUND_MS
        addTimer(uidWriter, UidHealthStats.TIMER_PROCESS_STATE_FOREGROUND_MS,
                uid.getProcessStateTimer(BatteryStats.Uid.PROCESS_STATE_FOREGROUND));

        // TIMER_PROCESS_STATE_BACKGROUND_MS
        addTimer(uidWriter, UidHealthStats.TIMER_PROCESS_STATE_BACKGROUND_MS,
                uid.getProcessStateTimer(BatteryStats.Uid.PROCESS_STATE_BACKGROUND));

        // TIMER_PROCESS_STATE_CACHED_MS
        addTimer(uidWriter, UidHealthStats.TIMER_PROCESS_STATE_CACHED_MS,
                uid.getProcessStateTimer(BatteryStats.Uid.PROCESS_STATE_CACHED));

        // TIMER_VIBRATOR
        addTimer(uidWriter, UidHealthStats.TIMER_VIBRATOR, uid.getVibratorOnTimer());

        // MEASUREMENT_OTHER_USER_ACTIVITY_COUNT
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_OTHER_USER_ACTIVITY_COUNT,
                uid.getUserActivityCount(PowerManager.USER_ACTIVITY_EVENT_OTHER,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_BUTTON_USER_ACTIVITY_COUNT
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BUTTON_USER_ACTIVITY_COUNT,
                uid.getUserActivityCount(PowerManager.USER_ACTIVITY_EVENT_BUTTON,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_TOUCH_USER_ACTIVITY_COUNT
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_TOUCH_USER_ACTIVITY_COUNT,
                uid.getUserActivityCount(PowerManager.USER_ACTIVITY_EVENT_TOUCH,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_MOBILE_RX_BYTES
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_RX_BYTES,
                uid.getNetworkActivityBytes(BatteryStats.NETWORK_MOBILE_RX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_MOBILE_TX_BYTES
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_TX_BYTES,
                uid.getNetworkActivityBytes(BatteryStats.NETWORK_MOBILE_TX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_WIFI_RX_BYTES
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_RX_BYTES,
                uid.getNetworkActivityBytes(BatteryStats.NETWORK_WIFI_RX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_WIFI_TX_BYTES
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_TX_BYTES,
                uid.getNetworkActivityBytes(BatteryStats.NETWORK_WIFI_TX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_BLUETOOTH_RX_BYTES
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_RX_BYTES,
                uid.getNetworkActivityBytes(BatteryStats.NETWORK_BT_RX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_BLUETOOTH_TX_BYTES
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_TX_BYTES,
                uid.getNetworkActivityBytes(BatteryStats.NETWORK_BT_TX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_MOBILE_RX_PACKETS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_RX_PACKETS,
                uid.getNetworkActivityPackets(BatteryStats.NETWORK_MOBILE_RX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_MOBILE_TX_PACKETS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_MOBILE_TX_PACKETS,
                uid.getNetworkActivityPackets(BatteryStats.NETWORK_MOBILE_TX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_WIFI_RX_PACKETS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_RX_PACKETS,
                uid.getNetworkActivityPackets(BatteryStats.NETWORK_WIFI_RX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_WIFI_TX_PACKETS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_WIFI_TX_PACKETS,
                uid.getNetworkActivityPackets(BatteryStats.NETWORK_WIFI_TX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_BLUETOOTH_RX_PACKETS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_RX_PACKETS,
                uid.getNetworkActivityPackets(BatteryStats.NETWORK_BT_RX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_BLUETOOTH_TX_PACKETS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_BLUETOOTH_TX_PACKETS,
                uid.getNetworkActivityPackets(BatteryStats.NETWORK_BT_TX_DATA,
                    STATS_SINCE_UNPLUGGED));

        // TIMER_MOBILE_RADIO_ACTIVE
        uidWriter.addTimer(UidHealthStats.TIMER_MOBILE_RADIO_ACTIVE,
                uid.getMobileRadioActiveCount(STATS_SINCE_UNPLUGGED),
                uid.getMobileRadioActiveTime(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_USER_CPU_TIME_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_USER_CPU_TIME_MS,
                uid.getUserCpuTimeUs(STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_SYSTEM_CPU_TIME_MS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_SYSTEM_CPU_TIME_MS,
                uid.getSystemCpuTimeUs(STATS_SINCE_UNPLUGGED)/1000);

        // MEASUREMENT_CPU_POWER_MAMS
        uidWriter.addMeasurement(UidHealthStats.MEASUREMENT_CPU_POWER_MAMS,
                uid.getCpuPowerMaUs(STATS_SINCE_UNPLUGGED)/1000);
    }

    /**
     * Writes the contents of a BatteryStats.Uid.Pid into a HealthStatsWriter.
     */
    public void writePid(HealthStatsWriter pidWriter, BatteryStats.Uid.Pid pid) {
        if (pid == null) {
            return;
        }

        // MEASUREMENT_WAKE_NESTING_COUNT
        pidWriter.addMeasurement(PidHealthStats.MEASUREMENT_WAKE_NESTING_COUNT, pid.mWakeNesting);

        // MEASUREMENT_WAKE_SUM_MS
        pidWriter.addMeasurement(PidHealthStats.MEASUREMENT_WAKE_SUM_MS, pid.mWakeSumMs);

        // MEASUREMENT_WAKE_START_MS
        pidWriter.addMeasurement(PidHealthStats.MEASUREMENT_WAKE_SUM_MS, pid.mWakeStartMs);
    }

    /**
     * Writes the contents of a BatteryStats.Uid.Proc into a HealthStatsWriter.
     */
    public void writeProc(HealthStatsWriter procWriter, BatteryStats.Uid.Proc proc) {
        // MEASUREMENT_USER_TIME_MS
        procWriter.addMeasurement(ProcessHealthStats.MEASUREMENT_USER_TIME_MS,
                proc.getUserTime(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_SYSTEM_TIME_MS
        procWriter.addMeasurement(ProcessHealthStats.MEASUREMENT_SYSTEM_TIME_MS,
                proc.getSystemTime(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_STARTS_COUNT
        procWriter.addMeasurement(ProcessHealthStats.MEASUREMENT_STARTS_COUNT,
                proc.getStarts(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_CRASHES_COUNT
        procWriter.addMeasurement(ProcessHealthStats.MEASUREMENT_CRASHES_COUNT,
                proc.getNumCrashes(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_ANR_COUNT
        procWriter.addMeasurement(ProcessHealthStats.MEASUREMENT_ANR_COUNT,
                proc.getNumAnrs(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_FOREGROUND_MS
        procWriter.addMeasurement(ProcessHealthStats.MEASUREMENT_FOREGROUND_MS,
                proc.getForegroundTime(STATS_SINCE_UNPLUGGED));
    }

    /**
     * Writes the contents of a BatteryStats.Uid.Pkg into a HealthStatsWriter.
     */
    public void writePkg(HealthStatsWriter pkgWriter, BatteryStats.Uid.Pkg pkg) {
        // STATS_SERVICES
        for (final Map.Entry<String,? extends BatteryStats.Uid.Pkg.Serv> entry:
                pkg.getServiceStats().entrySet()) {
            final HealthStatsWriter writer = new HealthStatsWriter(ServiceHealthStats.CONSTANTS);
            writeServ(writer, entry.getValue());
            pkgWriter.addStats(PackageHealthStats.STATS_SERVICES, entry.getKey(), writer);
        }

        // MEASUREMENTS_WAKEUP_ALARMS_COUNT
        for (final Map.Entry<String,? extends BatteryStats.Counter> entry:
                pkg.getWakeupAlarmStats().entrySet()) {
            final BatteryStats.Counter counter = entry.getValue();
            if (counter != null) {
                pkgWriter.addMeasurements(PackageHealthStats.MEASUREMENTS_WAKEUP_ALARMS_COUNT,
                        entry.getKey(), counter.getCountLocked(STATS_SINCE_UNPLUGGED));
            }
        }
    }

    /**
     * Writes the contents of a BatteryStats.Uid.Pkg.Serv into a HealthStatsWriter.
     */
    public void writeServ(HealthStatsWriter servWriter, BatteryStats.Uid.Pkg.Serv serv) {
        // MEASUREMENT_START_SERVICE_COUNT
        servWriter.addMeasurement(ServiceHealthStats.MEASUREMENT_START_SERVICE_COUNT,
                serv.getStarts(STATS_SINCE_UNPLUGGED));

        // MEASUREMENT_LAUNCH_COUNT
        servWriter.addMeasurement(ServiceHealthStats.MEASUREMENT_LAUNCH_COUNT,
                serv.getLaunches(STATS_SINCE_UNPLUGGED));
    }

    /**
     * Adds a BatteryStats.Timer into a HealthStatsWriter. Safe to pass a null timer.
     */
    private void addTimer(HealthStatsWriter writer, int key, BatteryStats.Timer timer) {
        if (timer != null) {
            writer.addTimer(key, timer.getCountLocked(STATS_SINCE_UNPLUGGED),
                    timer.getTotalTimeLocked(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED) / 1000);
        }
    }

    /**
     * Adds a named BatteryStats.Timer into a HealthStatsWriter. Safe to pass a null timer.
     */
    private void addTimers(HealthStatsWriter writer, int key, String name,
            BatteryStats.Timer timer) {
        if (timer != null) {
            writer.addTimers(key, name, new TimerStat(timer.getCountLocked(STATS_SINCE_UNPLUGGED),
                    timer.getTotalTimeLocked(mNowRealtimeMs*1000, STATS_SINCE_UNPLUGGED) / 1000));
        }
    }
}