719 lines
30 KiB
Java
719 lines
30 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2023 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.internal.os;
|
||
|
|
|
||
|
|
import android.annotation.NonNull;
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.os.BatteryConsumer;
|
||
|
|
import android.os.BatteryStats;
|
||
|
|
import android.os.Bundle;
|
||
|
|
import android.os.Parcel;
|
||
|
|
import android.os.PersistableBundle;
|
||
|
|
import android.os.UserHandle;
|
||
|
|
import android.util.IndentingPrintWriter;
|
||
|
|
import android.util.Slog;
|
||
|
|
import android.util.SparseArray;
|
||
|
|
|
||
|
|
import com.android.modules.utils.TypedXmlPullParser;
|
||
|
|
import com.android.modules.utils.TypedXmlSerializer;
|
||
|
|
|
||
|
|
import org.xmlpull.v1.XmlPullParser;
|
||
|
|
import org.xmlpull.v1.XmlPullParserException;
|
||
|
|
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Arrays;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.Objects;
|
||
|
|
import java.util.regex.Matcher;
|
||
|
|
import java.util.regex.Pattern;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Container for power stats, acquired by various PowerStatsCollector classes. See subclasses for
|
||
|
|
* details.
|
||
|
|
*/
|
||
|
|
@android.ravenwood.annotation.RavenwoodKeepWholeClass
|
||
|
|
public final class PowerStats {
|
||
|
|
private static final String TAG = "PowerStats";
|
||
|
|
|
||
|
|
private static final BatteryStatsHistory.VarintParceler VARINT_PARCELER =
|
||
|
|
new BatteryStatsHistory.VarintParceler();
|
||
|
|
private static final byte PARCEL_FORMAT_VERSION = 2;
|
||
|
|
|
||
|
|
private static final int PARCEL_FORMAT_VERSION_MASK = 0x000000FF;
|
||
|
|
private static final int PARCEL_FORMAT_VERSION_SHIFT =
|
||
|
|
Integer.numberOfTrailingZeros(PARCEL_FORMAT_VERSION_MASK);
|
||
|
|
private static final int STATS_ARRAY_LENGTH_MASK = 0x0000FF00;
|
||
|
|
private static final int STATS_ARRAY_LENGTH_SHIFT =
|
||
|
|
Integer.numberOfTrailingZeros(STATS_ARRAY_LENGTH_MASK);
|
||
|
|
public static final int MAX_STATS_ARRAY_LENGTH =
|
||
|
|
(1 << Integer.bitCount(STATS_ARRAY_LENGTH_MASK)) - 1;
|
||
|
|
private static final int STATE_STATS_ARRAY_LENGTH_MASK = 0x00FF0000;
|
||
|
|
private static final int STATE_STATS_ARRAY_LENGTH_SHIFT =
|
||
|
|
Integer.numberOfTrailingZeros(STATE_STATS_ARRAY_LENGTH_MASK);
|
||
|
|
public static final int MAX_STATE_STATS_ARRAY_LENGTH =
|
||
|
|
(1 << Integer.bitCount(STATE_STATS_ARRAY_LENGTH_MASK)) - 1;
|
||
|
|
private static final int UID_STATS_ARRAY_LENGTH_MASK = 0xFF000000;
|
||
|
|
private static final int UID_STATS_ARRAY_LENGTH_SHIFT =
|
||
|
|
Integer.numberOfTrailingZeros(UID_STATS_ARRAY_LENGTH_MASK);
|
||
|
|
public static final int MAX_UID_STATS_ARRAY_LENGTH =
|
||
|
|
(1 << Integer.bitCount(UID_STATS_ARRAY_LENGTH_MASK)) - 1;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Descriptor of the stats collected for a given power component (e.g. CPU, WiFi etc).
|
||
|
|
* This descriptor is used for storing PowerStats and can also be used by power models
|
||
|
|
* to adjust the algorithm in accordance with the stats available on the device.
|
||
|
|
*/
|
||
|
|
@android.ravenwood.annotation.RavenwoodKeepWholeClass
|
||
|
|
public static class Descriptor {
|
||
|
|
public static final String EXTRA_DEVICE_STATS_FORMAT = "format-device";
|
||
|
|
public static final String EXTRA_STATE_STATS_FORMAT = "format-state";
|
||
|
|
public static final String EXTRA_UID_STATS_FORMAT = "format-uid";
|
||
|
|
|
||
|
|
public static final String XML_TAG_DESCRIPTOR = "descriptor";
|
||
|
|
private static final String XML_ATTR_ID = "id";
|
||
|
|
private static final String XML_ATTR_NAME = "name";
|
||
|
|
private static final String XML_ATTR_STATS_ARRAY_LENGTH = "stats-array-length";
|
||
|
|
private static final String XML_TAG_STATE = "state";
|
||
|
|
private static final String XML_ATTR_STATE_KEY = "key";
|
||
|
|
private static final String XML_ATTR_STATE_LABEL = "label";
|
||
|
|
private static final String XML_ATTR_STATE_STATS_ARRAY_LENGTH = "state-stats-array-length";
|
||
|
|
private static final String XML_ATTR_UID_STATS_ARRAY_LENGTH = "uid-stats-array-length";
|
||
|
|
private static final String XML_TAG_EXTRAS = "extras";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* {@link BatteryConsumer.PowerComponent} (e.g. CPU, WIFI etc) that this snapshot relates
|
||
|
|
* to; or a custom power component ID (if the value
|
||
|
|
* is >= {@link BatteryConsumer#FIRST_CUSTOM_POWER_COMPONENT_ID}).
|
||
|
|
*/
|
||
|
|
public final int powerComponentId;
|
||
|
|
public final String name;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stats for the power component, such as the total usage time.
|
||
|
|
*/
|
||
|
|
public final int statsArrayLength;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Map of device state codes to their corresponding human-readable labels.
|
||
|
|
*/
|
||
|
|
public final SparseArray<String> stateLabels;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stats for a specific state of the power component, e.g. "mobile radio in the 5G mode"
|
||
|
|
*/
|
||
|
|
public final int stateStatsArrayLength;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stats for the usage of this power component by a specific UID (app)
|
||
|
|
*/
|
||
|
|
public final int uidStatsArrayLength;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Extra parameters specific to the power component, e.g. the availability of power
|
||
|
|
* monitors.
|
||
|
|
*/
|
||
|
|
public final PersistableBundle extras;
|
||
|
|
|
||
|
|
private PowerStatsFormatter mDeviceStatsFormatter;
|
||
|
|
private PowerStatsFormatter mStateStatsFormatter;
|
||
|
|
private PowerStatsFormatter mUidStatsFormatter;
|
||
|
|
|
||
|
|
public Descriptor(@BatteryConsumer.PowerComponent int powerComponentId,
|
||
|
|
int statsArrayLength, @Nullable SparseArray<String> stateLabels,
|
||
|
|
int stateStatsArrayLength, int uidStatsArrayLength,
|
||
|
|
@NonNull PersistableBundle extras) {
|
||
|
|
this(powerComponentId, BatteryConsumer.powerComponentIdToString(powerComponentId),
|
||
|
|
statsArrayLength, stateLabels, stateStatsArrayLength, uidStatsArrayLength,
|
||
|
|
extras);
|
||
|
|
}
|
||
|
|
|
||
|
|
public Descriptor(int customPowerComponentId, String name, int statsArrayLength,
|
||
|
|
@Nullable SparseArray<String> stateLabels, int stateStatsArrayLength,
|
||
|
|
int uidStatsArrayLength, @NonNull PersistableBundle extras) {
|
||
|
|
if (statsArrayLength > MAX_STATS_ARRAY_LENGTH) {
|
||
|
|
throw new IllegalArgumentException(
|
||
|
|
"statsArrayLength is too high. Max = " + MAX_STATS_ARRAY_LENGTH);
|
||
|
|
}
|
||
|
|
if (stateStatsArrayLength > MAX_STATE_STATS_ARRAY_LENGTH) {
|
||
|
|
throw new IllegalArgumentException(
|
||
|
|
"stateStatsArrayLength is too high. Max = " + MAX_STATE_STATS_ARRAY_LENGTH);
|
||
|
|
}
|
||
|
|
if (uidStatsArrayLength > MAX_UID_STATS_ARRAY_LENGTH) {
|
||
|
|
throw new IllegalArgumentException(
|
||
|
|
"uidStatsArrayLength is too high. Max = " + MAX_UID_STATS_ARRAY_LENGTH);
|
||
|
|
}
|
||
|
|
this.powerComponentId = customPowerComponentId;
|
||
|
|
this.name = name;
|
||
|
|
this.statsArrayLength = statsArrayLength;
|
||
|
|
this.stateLabels = stateLabels != null ? stateLabels : new SparseArray<>();
|
||
|
|
this.stateStatsArrayLength = stateStatsArrayLength;
|
||
|
|
this.uidStatsArrayLength = uidStatsArrayLength;
|
||
|
|
this.extras = extras;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a custom formatter for this type of power stats.
|
||
|
|
*/
|
||
|
|
public PowerStatsFormatter getDeviceStatsFormatter() {
|
||
|
|
if (mDeviceStatsFormatter == null) {
|
||
|
|
mDeviceStatsFormatter = new PowerStatsFormatter(
|
||
|
|
extras.getString(EXTRA_DEVICE_STATS_FORMAT));
|
||
|
|
}
|
||
|
|
return mDeviceStatsFormatter;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a custom formatter for this type of power stats, specifically per-state stats.
|
||
|
|
*/
|
||
|
|
public PowerStatsFormatter getStateStatsFormatter() {
|
||
|
|
if (mStateStatsFormatter == null) {
|
||
|
|
mStateStatsFormatter = new PowerStatsFormatter(
|
||
|
|
extras.getString(EXTRA_STATE_STATS_FORMAT));
|
||
|
|
}
|
||
|
|
return mStateStatsFormatter;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a custom formatter for this type of power stats, specifically per-UID stats.
|
||
|
|
*/
|
||
|
|
public PowerStatsFormatter getUidStatsFormatter() {
|
||
|
|
if (mUidStatsFormatter == null) {
|
||
|
|
mUidStatsFormatter = new PowerStatsFormatter(
|
||
|
|
extras.getString(EXTRA_UID_STATS_FORMAT));
|
||
|
|
}
|
||
|
|
return mUidStatsFormatter;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the label associated with the give state key, e.g. "5G-high" for the
|
||
|
|
* state of Mobile Radio representing the 5G mode and high signal power.
|
||
|
|
*/
|
||
|
|
public String getStateLabel(int key) {
|
||
|
|
String label = stateLabels.get(key);
|
||
|
|
if (label != null) {
|
||
|
|
return label;
|
||
|
|
}
|
||
|
|
return name + "-" + Integer.toHexString(key);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Writes the Descriptor into the parcel.
|
||
|
|
*/
|
||
|
|
public void writeSummaryToParcel(Parcel parcel) {
|
||
|
|
int firstWord = ((PARCEL_FORMAT_VERSION << PARCEL_FORMAT_VERSION_SHIFT)
|
||
|
|
& PARCEL_FORMAT_VERSION_MASK)
|
||
|
|
| ((statsArrayLength << STATS_ARRAY_LENGTH_SHIFT)
|
||
|
|
& STATS_ARRAY_LENGTH_MASK)
|
||
|
|
| ((stateStatsArrayLength << STATE_STATS_ARRAY_LENGTH_SHIFT)
|
||
|
|
& STATE_STATS_ARRAY_LENGTH_MASK)
|
||
|
|
| ((uidStatsArrayLength << UID_STATS_ARRAY_LENGTH_SHIFT)
|
||
|
|
& UID_STATS_ARRAY_LENGTH_MASK);
|
||
|
|
parcel.writeInt(firstWord);
|
||
|
|
parcel.writeInt(powerComponentId);
|
||
|
|
parcel.writeString(name);
|
||
|
|
parcel.writeInt(stateLabels.size());
|
||
|
|
for (int i = 0, size = stateLabels.size(); i < size; i++) {
|
||
|
|
parcel.writeInt(stateLabels.keyAt(i));
|
||
|
|
parcel.writeString(stateLabels.valueAt(i));
|
||
|
|
}
|
||
|
|
extras.writeToParcel(parcel, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reads a Descriptor from the parcel. If the parcel has an incompatible format,
|
||
|
|
* returns null.
|
||
|
|
*/
|
||
|
|
@Nullable
|
||
|
|
public static Descriptor readSummaryFromParcel(Parcel parcel) {
|
||
|
|
int firstWord = parcel.readInt();
|
||
|
|
int version = (firstWord & PARCEL_FORMAT_VERSION_MASK) >>> PARCEL_FORMAT_VERSION_SHIFT;
|
||
|
|
if (version != PARCEL_FORMAT_VERSION) {
|
||
|
|
Slog.w(TAG, "Cannot read PowerStats from Parcel - the parcel format version has "
|
||
|
|
+ "changed from " + version + " to " + PARCEL_FORMAT_VERSION);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
int statsArrayLength =
|
||
|
|
(firstWord & STATS_ARRAY_LENGTH_MASK) >>> STATS_ARRAY_LENGTH_SHIFT;
|
||
|
|
int stateStatsArrayLength =
|
||
|
|
(firstWord & STATE_STATS_ARRAY_LENGTH_MASK) >>> STATE_STATS_ARRAY_LENGTH_SHIFT;
|
||
|
|
int uidStatsArrayLength =
|
||
|
|
(firstWord & UID_STATS_ARRAY_LENGTH_MASK) >>> UID_STATS_ARRAY_LENGTH_SHIFT;
|
||
|
|
int powerComponentId = parcel.readInt();
|
||
|
|
String name = parcel.readString();
|
||
|
|
int stateLabelCount = parcel.readInt();
|
||
|
|
SparseArray<String> stateLabels = new SparseArray<>(stateLabelCount);
|
||
|
|
for (int i = stateLabelCount; i > 0; i--) {
|
||
|
|
int key = parcel.readInt();
|
||
|
|
String label = parcel.readString();
|
||
|
|
stateLabels.put(key, label);
|
||
|
|
}
|
||
|
|
PersistableBundle extras = parcel.readPersistableBundle();
|
||
|
|
return new Descriptor(powerComponentId, name, statsArrayLength, stateLabels,
|
||
|
|
stateStatsArrayLength, uidStatsArrayLength, extras);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean equals(Object o) {
|
||
|
|
if (this == o) return true;
|
||
|
|
if (!(o instanceof Descriptor)) return false;
|
||
|
|
Descriptor that = (Descriptor) o;
|
||
|
|
return powerComponentId == that.powerComponentId
|
||
|
|
&& statsArrayLength == that.statsArrayLength
|
||
|
|
&& stateLabels.contentEquals(that.stateLabels)
|
||
|
|
&& stateStatsArrayLength == that.stateStatsArrayLength
|
||
|
|
&& uidStatsArrayLength == that.uidStatsArrayLength
|
||
|
|
&& Objects.equals(name, that.name)
|
||
|
|
&& extras.size() == that.extras.size() // Unparcel the Parcel if not yet
|
||
|
|
&& Bundle.kindofEquals(extras,
|
||
|
|
that.extras); // Since the Parcel is now unparceled, do a deep comparison
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stores contents in an XML doc.
|
||
|
|
*/
|
||
|
|
public void writeXml(TypedXmlSerializer serializer) throws IOException {
|
||
|
|
serializer.startTag(null, XML_TAG_DESCRIPTOR);
|
||
|
|
serializer.attributeInt(null, XML_ATTR_ID, powerComponentId);
|
||
|
|
serializer.attribute(null, XML_ATTR_NAME, name);
|
||
|
|
serializer.attributeInt(null, XML_ATTR_STATS_ARRAY_LENGTH, statsArrayLength);
|
||
|
|
serializer.attributeInt(null, XML_ATTR_STATE_STATS_ARRAY_LENGTH, stateStatsArrayLength);
|
||
|
|
serializer.attributeInt(null, XML_ATTR_UID_STATS_ARRAY_LENGTH, uidStatsArrayLength);
|
||
|
|
for (int i = stateLabels.size() - 1; i >= 0; i--) {
|
||
|
|
serializer.startTag(null, XML_TAG_STATE);
|
||
|
|
serializer.attributeInt(null, XML_ATTR_STATE_KEY, stateLabels.keyAt(i));
|
||
|
|
serializer.attribute(null, XML_ATTR_STATE_LABEL, stateLabels.valueAt(i));
|
||
|
|
serializer.endTag(null, XML_TAG_STATE);
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
serializer.startTag(null, XML_TAG_EXTRAS);
|
||
|
|
extras.saveToXml(serializer);
|
||
|
|
serializer.endTag(null, XML_TAG_EXTRAS);
|
||
|
|
} catch (XmlPullParserException e) {
|
||
|
|
throw new IOException(e);
|
||
|
|
}
|
||
|
|
serializer.endTag(null, XML_TAG_DESCRIPTOR);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a Descriptor by parsing an XML doc. The parser is expected to be positioned
|
||
|
|
* on or before the opening "descriptor" tag.
|
||
|
|
*/
|
||
|
|
public static Descriptor createFromXml(TypedXmlPullParser parser)
|
||
|
|
throws XmlPullParserException, IOException {
|
||
|
|
int powerComponentId = -1;
|
||
|
|
String name = null;
|
||
|
|
int statsArrayLength = 0;
|
||
|
|
SparseArray<String> stateLabels = new SparseArray<>();
|
||
|
|
int stateStatsArrayLength = 0;
|
||
|
|
int uidStatsArrayLength = 0;
|
||
|
|
PersistableBundle extras = null;
|
||
|
|
int eventType = parser.getEventType();
|
||
|
|
while (eventType != XmlPullParser.END_DOCUMENT
|
||
|
|
&& !(eventType == XmlPullParser.END_TAG
|
||
|
|
&& parser.getName().equals(XML_TAG_DESCRIPTOR))) {
|
||
|
|
if (eventType == XmlPullParser.START_TAG) {
|
||
|
|
switch (parser.getName()) {
|
||
|
|
case XML_TAG_DESCRIPTOR:
|
||
|
|
powerComponentId = parser.getAttributeInt(null, XML_ATTR_ID);
|
||
|
|
name = parser.getAttributeValue(null, XML_ATTR_NAME);
|
||
|
|
statsArrayLength = parser.getAttributeInt(null,
|
||
|
|
XML_ATTR_STATS_ARRAY_LENGTH);
|
||
|
|
stateStatsArrayLength = parser.getAttributeInt(null,
|
||
|
|
XML_ATTR_STATE_STATS_ARRAY_LENGTH);
|
||
|
|
uidStatsArrayLength = parser.getAttributeInt(null,
|
||
|
|
XML_ATTR_UID_STATS_ARRAY_LENGTH);
|
||
|
|
break;
|
||
|
|
case XML_TAG_STATE:
|
||
|
|
int value = parser.getAttributeInt(null, XML_ATTR_STATE_KEY);
|
||
|
|
String label = parser.getAttributeValue(null, XML_ATTR_STATE_LABEL);
|
||
|
|
stateLabels.put(value, label);
|
||
|
|
break;
|
||
|
|
case XML_TAG_EXTRAS:
|
||
|
|
extras = PersistableBundle.restoreFromXml(parser);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
eventType = parser.next();
|
||
|
|
}
|
||
|
|
if (powerComponentId == -1) {
|
||
|
|
return null;
|
||
|
|
} else if (powerComponentId >= BatteryConsumer.FIRST_CUSTOM_POWER_COMPONENT_ID) {
|
||
|
|
return new Descriptor(powerComponentId, name, statsArrayLength,
|
||
|
|
stateLabels, stateStatsArrayLength, uidStatsArrayLength, extras);
|
||
|
|
} else if (powerComponentId < BatteryConsumer.POWER_COMPONENT_COUNT) {
|
||
|
|
return new Descriptor(powerComponentId, statsArrayLength, stateLabels,
|
||
|
|
stateStatsArrayLength, uidStatsArrayLength, extras);
|
||
|
|
} else {
|
||
|
|
Slog.e(TAG, "Unrecognized power component: " + powerComponentId);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int hashCode() {
|
||
|
|
return Objects.hash(powerComponentId);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
if (extras != null) {
|
||
|
|
extras.size(); // Unparcel
|
||
|
|
}
|
||
|
|
return "PowerStats.Descriptor{"
|
||
|
|
+ "powerComponentId=" + powerComponentId
|
||
|
|
+ ", name='" + name + '\''
|
||
|
|
+ ", statsArrayLength=" + statsArrayLength
|
||
|
|
+ ", stateStatsArrayLength=" + stateStatsArrayLength
|
||
|
|
+ ", stateLabels=" + stateLabels
|
||
|
|
+ ", uidStatsArrayLength=" + uidStatsArrayLength
|
||
|
|
+ ", extras=" + extras
|
||
|
|
+ '}';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A registry for all supported power component types (e.g. CPU, WiFi).
|
||
|
|
*/
|
||
|
|
public static class DescriptorRegistry {
|
||
|
|
private final SparseArray<Descriptor> mDescriptors = new SparseArray<>();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Adds the specified descriptor to the registry. If the registry already
|
||
|
|
* contained a descriptor for the same power component, then the new one replaces
|
||
|
|
* the old one.
|
||
|
|
*/
|
||
|
|
public void register(Descriptor descriptor) {
|
||
|
|
mDescriptors.put(descriptor.powerComponentId, descriptor);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param powerComponentId either a BatteryConsumer.PowerComponent or a custom power
|
||
|
|
* component ID
|
||
|
|
*/
|
||
|
|
public Descriptor get(int powerComponentId) {
|
||
|
|
return mDescriptors.get(powerComponentId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public final Descriptor descriptor;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Duration, in milliseconds, covered by this snapshot.
|
||
|
|
*/
|
||
|
|
public long durationMs;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Device-wide stats.
|
||
|
|
*/
|
||
|
|
public long[] stats;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Device-wide mode stats, used when the power component can operate in different modes,
|
||
|
|
* e.g. RATs such as LTE and 5G.
|
||
|
|
*/
|
||
|
|
public final SparseArray<long[]> stateStats = new SparseArray<>();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Per-UID CPU stats.
|
||
|
|
*/
|
||
|
|
public final SparseArray<long[]> uidStats = new SparseArray<>();
|
||
|
|
|
||
|
|
public PowerStats(Descriptor descriptor) {
|
||
|
|
this.descriptor = descriptor;
|
||
|
|
stats = new long[descriptor.statsArrayLength];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Writes the object into the parcel.
|
||
|
|
*/
|
||
|
|
public void writeToParcel(Parcel parcel) {
|
||
|
|
int lengthPos = parcel.dataPosition();
|
||
|
|
parcel.writeInt(0); // Placeholder for length
|
||
|
|
|
||
|
|
int startPos = parcel.dataPosition();
|
||
|
|
parcel.writeInt(descriptor.powerComponentId);
|
||
|
|
parcel.writeLong(durationMs);
|
||
|
|
VARINT_PARCELER.writeLongArray(parcel, stats);
|
||
|
|
|
||
|
|
if (descriptor.stateStatsArrayLength != 0) {
|
||
|
|
parcel.writeInt(stateStats.size());
|
||
|
|
for (int i = 0; i < stateStats.size(); i++) {
|
||
|
|
parcel.writeInt(stateStats.keyAt(i));
|
||
|
|
VARINT_PARCELER.writeLongArray(parcel, stateStats.valueAt(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
parcel.writeInt(uidStats.size());
|
||
|
|
for (int i = 0; i < uidStats.size(); i++) {
|
||
|
|
parcel.writeInt(uidStats.keyAt(i));
|
||
|
|
VARINT_PARCELER.writeLongArray(parcel, uidStats.valueAt(i));
|
||
|
|
}
|
||
|
|
|
||
|
|
int endPos = parcel.dataPosition();
|
||
|
|
parcel.setDataPosition(lengthPos);
|
||
|
|
parcel.writeInt(endPos - startPos);
|
||
|
|
parcel.setDataPosition(endPos);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reads a PowerStats object from the supplied Parcel. If the parcel has an incompatible
|
||
|
|
* format, returns null.
|
||
|
|
*/
|
||
|
|
@Nullable
|
||
|
|
public static PowerStats readFromParcel(Parcel parcel, DescriptorRegistry registry) {
|
||
|
|
int length = parcel.readInt();
|
||
|
|
int startPos = parcel.dataPosition();
|
||
|
|
int endPos = startPos + length;
|
||
|
|
|
||
|
|
try {
|
||
|
|
int powerComponentId = parcel.readInt();
|
||
|
|
|
||
|
|
Descriptor descriptor = registry.get(powerComponentId);
|
||
|
|
if (descriptor == null) {
|
||
|
|
Slog.e(TAG, "Unsupported PowerStats for power component ID: " + powerComponentId);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
PowerStats stats = new PowerStats(descriptor);
|
||
|
|
stats.durationMs = parcel.readLong();
|
||
|
|
stats.stats = new long[descriptor.statsArrayLength];
|
||
|
|
VARINT_PARCELER.readLongArray(parcel, stats.stats);
|
||
|
|
|
||
|
|
if (descriptor.stateStatsArrayLength != 0) {
|
||
|
|
int count = parcel.readInt();
|
||
|
|
for (int i = 0; i < count; i++) {
|
||
|
|
int state = parcel.readInt();
|
||
|
|
long[] stateStats = new long[descriptor.stateStatsArrayLength];
|
||
|
|
VARINT_PARCELER.readLongArray(parcel, stateStats);
|
||
|
|
stats.stateStats.put(state, stateStats);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int uidCount = parcel.readInt();
|
||
|
|
for (int i = 0; i < uidCount; i++) {
|
||
|
|
int uid = parcel.readInt();
|
||
|
|
long[] uidStats = new long[descriptor.uidStatsArrayLength];
|
||
|
|
VARINT_PARCELER.readLongArray(parcel, uidStats);
|
||
|
|
stats.uidStats.put(uid, uidStats);
|
||
|
|
}
|
||
|
|
if (parcel.dataPosition() != endPos) {
|
||
|
|
Slog.e(TAG, "Corrupted PowerStats parcel. Expected length: " + length
|
||
|
|
+ ", actual length: " + (parcel.dataPosition() - startPos));
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return stats;
|
||
|
|
} finally {
|
||
|
|
// Unconditionally skip to the end of the written data, even if the actual parcel
|
||
|
|
// format is incompatible
|
||
|
|
if (endPos > parcel.dataPosition()) {
|
||
|
|
if (endPos >= parcel.dataSize()) {
|
||
|
|
throw new IndexOutOfBoundsException(
|
||
|
|
"PowerStats end position: " + endPos + " is outside the parcel bounds: "
|
||
|
|
+ parcel.dataSize());
|
||
|
|
}
|
||
|
|
parcel.setDataPosition(endPos);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Formats the stats as a string suitable to be included in the Battery History dump.
|
||
|
|
*/
|
||
|
|
public String formatForBatteryHistory(String uidPrefix) {
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.append("duration=").append(durationMs).append(" ").append(descriptor.name);
|
||
|
|
if (stats.length > 0) {
|
||
|
|
sb.append("=").append(descriptor.getDeviceStatsFormatter().format(stats));
|
||
|
|
}
|
||
|
|
if (descriptor.stateStatsArrayLength != 0) {
|
||
|
|
PowerStatsFormatter formatter = descriptor.getStateStatsFormatter();
|
||
|
|
for (int i = 0; i < stateStats.size(); i++) {
|
||
|
|
sb.append(" (");
|
||
|
|
sb.append(descriptor.getStateLabel(stateStats.keyAt(i)));
|
||
|
|
sb.append(") ");
|
||
|
|
sb.append(formatter.format(stateStats.valueAt(i)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PowerStatsFormatter uidStatsFormatter = descriptor.getUidStatsFormatter();
|
||
|
|
for (int i = 0; i < uidStats.size(); i++) {
|
||
|
|
sb.append(uidPrefix)
|
||
|
|
.append(UserHandle.formatUid(uidStats.keyAt(i)))
|
||
|
|
.append(": ").append(uidStatsFormatter.format(uidStats.valueAt(i)));
|
||
|
|
}
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Prints the contents of the stats snapshot.
|
||
|
|
*/
|
||
|
|
public void dump(IndentingPrintWriter pw) {
|
||
|
|
pw.println(descriptor.name + " (" + descriptor.powerComponentId + ')');
|
||
|
|
pw.increaseIndent();
|
||
|
|
pw.print("duration", durationMs).println();
|
||
|
|
|
||
|
|
if (descriptor.statsArrayLength != 0) {
|
||
|
|
pw.println(descriptor.getDeviceStatsFormatter().format(stats));
|
||
|
|
}
|
||
|
|
if (descriptor.stateStatsArrayLength != 0) {
|
||
|
|
PowerStatsFormatter formatter = descriptor.getStateStatsFormatter();
|
||
|
|
for (int i = 0; i < stateStats.size(); i++) {
|
||
|
|
pw.print(" (");
|
||
|
|
pw.print(descriptor.getStateLabel(stateStats.keyAt(i)));
|
||
|
|
pw.print(") ");
|
||
|
|
pw.print(formatter.format(stateStats.valueAt(i)));
|
||
|
|
pw.println();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PowerStatsFormatter uidStatsFormatter = descriptor.getUidStatsFormatter();
|
||
|
|
for (int i = 0; i < uidStats.size(); i++) {
|
||
|
|
pw.print("UID ");
|
||
|
|
pw.print(UserHandle.formatUid(uidStats.keyAt(i)));
|
||
|
|
pw.print(": ");
|
||
|
|
pw.print(uidStatsFormatter.format(uidStats.valueAt(i)));
|
||
|
|
pw.println();
|
||
|
|
}
|
||
|
|
pw.decreaseIndent();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
return "PowerStats: " + formatForBatteryHistory(" UID ");
|
||
|
|
}
|
||
|
|
|
||
|
|
public static class PowerStatsFormatter {
|
||
|
|
private static class Section {
|
||
|
|
public String label;
|
||
|
|
public int position;
|
||
|
|
public int length;
|
||
|
|
public boolean optional;
|
||
|
|
public boolean typePower;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final double NANO_TO_MILLI_MULTIPLIER = 1.0 / 1000000.0;
|
||
|
|
private static final Pattern SECTION_PATTERN =
|
||
|
|
Pattern.compile("([^:]+):(\\d+)(\\[(?<L>\\d+)])?(?<F>\\S*)\\s*");
|
||
|
|
private final List<Section> mSections;
|
||
|
|
|
||
|
|
public PowerStatsFormatter(String format) {
|
||
|
|
mSections = parseFormat(format);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Produces a formatted string representing the supplied array, with labels
|
||
|
|
* and other adornments specific to the power stats layout.
|
||
|
|
*/
|
||
|
|
public String format(long[] stats) {
|
||
|
|
return format(mSections, stats);
|
||
|
|
}
|
||
|
|
|
||
|
|
private List<Section> parseFormat(String format) {
|
||
|
|
if (format == null || format.isBlank()) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
ArrayList<Section> sections = new ArrayList<>();
|
||
|
|
Matcher matcher = SECTION_PATTERN.matcher(format);
|
||
|
|
for (int position = 0; position < format.length(); position = matcher.end()) {
|
||
|
|
if (!matcher.find() || matcher.start() != position) {
|
||
|
|
Slog.wtf(TAG, "Bad power stats format '" + format + "'");
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
Section section = new Section();
|
||
|
|
section.label = matcher.group(1);
|
||
|
|
section.position = Integer.parseUnsignedInt(matcher.group(2));
|
||
|
|
String length = matcher.group("L");
|
||
|
|
if (length != null) {
|
||
|
|
section.length = Integer.parseUnsignedInt(length);
|
||
|
|
} else {
|
||
|
|
section.length = 1;
|
||
|
|
}
|
||
|
|
String flags = matcher.group("F");
|
||
|
|
if (flags != null) {
|
||
|
|
for (int i = 0; i < flags.length(); i++) {
|
||
|
|
char flag = flags.charAt(i);
|
||
|
|
switch (flag) {
|
||
|
|
case '?':
|
||
|
|
section.optional = true;
|
||
|
|
break;
|
||
|
|
case 'p':
|
||
|
|
section.typePower = true;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
Slog.e(TAG,
|
||
|
|
"Unsupported format option '" + flag + "' in " + format);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sections.add(section);
|
||
|
|
}
|
||
|
|
|
||
|
|
return sections;
|
||
|
|
}
|
||
|
|
|
||
|
|
private String format(List<Section> sections, long[] stats) {
|
||
|
|
if (sections == null) {
|
||
|
|
return Arrays.toString(stats);
|
||
|
|
}
|
||
|
|
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
for (int i = 0, count = sections.size(); i < count; i++) {
|
||
|
|
Section section = sections.get(i);
|
||
|
|
if (section.length == 0) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (section.optional) {
|
||
|
|
boolean nonZero = false;
|
||
|
|
for (int offset = 0; offset < section.length; offset++) {
|
||
|
|
if (stats[section.position + offset] != 0) {
|
||
|
|
nonZero = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!nonZero) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!sb.isEmpty()) {
|
||
|
|
sb.append(' ');
|
||
|
|
}
|
||
|
|
sb.append(section.label).append(": ");
|
||
|
|
if (section.length != 1) {
|
||
|
|
sb.append('[');
|
||
|
|
}
|
||
|
|
for (int offset = 0; offset < section.length; offset++) {
|
||
|
|
if (offset != 0) {
|
||
|
|
sb.append(", ");
|
||
|
|
}
|
||
|
|
if (section.typePower) {
|
||
|
|
sb.append(BatteryStats.formatCharge(
|
||
|
|
stats[section.position + offset] * NANO_TO_MILLI_MULTIPLIER));
|
||
|
|
} else {
|
||
|
|
sb.append(stats[section.position + offset]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (section.length != 1) {
|
||
|
|
sb.append(']');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|