| /* |
| * 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)); |
| } |
| } |
| } |
| |
