Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 79e65de3 authored by Dmitri Plotnikov's avatar Dmitri Plotnikov
Browse files

Remove SystemBatteryConsumer

which has been superceded by AggegateBatteryConsumer

Bug: 186006876
Test: atest FrameworksCoreTests:com.android.internal.os.BatteryStatsTests
Test: Use BatteryStatsViewer to verify that it's still functional
Change-Id: I2e4fe36ff310b6d68923fcecdfd22ce865b1f32d
parent a7c3e113
Loading
Loading
Loading
Loading
+20 −0
Original line number Diff line number Diff line
@@ -25,17 +25,22 @@ import android.annotation.NonNull;
 */
public final class AggregateBatteryConsumer extends BatteryConsumer implements Parcelable {

    private final double mConsumedPowerMah;

    public AggregateBatteryConsumer(@NonNull Builder builder) {
        super(builder.mPowerComponentsBuilder.build());
        mConsumedPowerMah = builder.mConsumedPowerMah;
    }

    private AggregateBatteryConsumer(@NonNull Parcel source) {
        super(new PowerComponents(source));
        mConsumedPowerMah = source.readDouble();
    }

    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        super.writeToParcel(dest, flags);
        dest.writeDouble(mConsumedPowerMah);
    }

    @Override
@@ -55,14 +60,29 @@ public final class AggregateBatteryConsumer extends BatteryConsumer implements P
                }
            };

    @Override
    public double getConsumedPower() {
        return mConsumedPowerMah;
    }

    /**
     * Builder for DeviceBatteryConsumer.
     */
    public static final class Builder extends BaseBuilder<AggregateBatteryConsumer.Builder> {
        private double mConsumedPowerMah;

        public Builder(@NonNull String[] customPowerComponentNames, boolean includePowerModels) {
            super(customPowerComponentNames, includePowerModels);
        }

        /**
         * Sets the total power included in this aggregate.
         */
        public Builder setConsumedPower(double consumedPowerMah) {
            mConsumedPowerMah = consumedPowerMah;
            return this;
        }

        /**
         * Creates a read-only object out of the Builder values.
         */
+20 −67
Original line number Diff line number Diff line
@@ -71,7 +71,6 @@ public final class BatteryUsageStats implements Parcelable {

    public static final int AGGREGATE_BATTERY_CONSUMER_SCOPE_COUNT = 2;

    private final double mConsumedPower;
    private final int mDischargePercentage;
    private final long mStatsStartTimestampMs;
    private final double mDischargedPowerLowerBound;
@@ -80,7 +79,6 @@ public final class BatteryUsageStats implements Parcelable {
    private final long mChargeTimeRemainingMs;
    private final String[] mCustomPowerComponentNames;
    private final List<UidBatteryConsumer> mUidBatteryConsumers;
    private final List<SystemBatteryConsumer> mSystemBatteryConsumers;
    private final List<UserBatteryConsumer> mUserBatteryConsumers;
    private final AggregateBatteryConsumer[] mAggregateBatteryConsumers;
    private final Parcel mHistoryBuffer;
@@ -97,14 +95,7 @@ public final class BatteryUsageStats implements Parcelable {
        mChargeTimeRemainingMs = builder.mChargeTimeRemainingMs;
        mCustomPowerComponentNames = builder.mCustomPowerComponentNames;

        mAggregateBatteryConsumers =
                new AggregateBatteryConsumer[AGGREGATE_BATTERY_CONSUMER_SCOPE_COUNT];
        for (int i = 0; i < AGGREGATE_BATTERY_CONSUMER_SCOPE_COUNT; i++) {
            mAggregateBatteryConsumers[i] = builder.mAggregateBatteryConsumersBuilders[i].build();
        }

        double totalPower = 0;

        double totalPowerMah = 0;
        final int uidBatteryConsumerCount = builder.mUidBatteryConsumerBuilders.size();
        mUidBatteryConsumers = new ArrayList<>(uidBatteryConsumerCount);
        for (int i = 0; i < uidBatteryConsumerCount; i++) {
@@ -112,30 +103,28 @@ public final class BatteryUsageStats implements Parcelable {
                    builder.mUidBatteryConsumerBuilders.valueAt(i);
            if (!uidBatteryConsumerBuilder.isExcludedFromBatteryUsageStats()) {
                final UidBatteryConsumer consumer = uidBatteryConsumerBuilder.build();
                totalPower += consumer.getConsumedPower();
                totalPowerMah += consumer.getConsumedPower();
                mUidBatteryConsumers.add(consumer);
            }
        }

        final int systemBatteryConsumerCount = builder.mSystemBatteryConsumerBuilders.size();
        mSystemBatteryConsumers = new ArrayList<>(systemBatteryConsumerCount);
        for (int i = 0; i < systemBatteryConsumerCount; i++) {
            final SystemBatteryConsumer consumer =
                    builder.mSystemBatteryConsumerBuilders.valueAt(i).build();
            totalPower += consumer.getConsumedPower() - consumer.getPowerConsumedByApps();
            mSystemBatteryConsumers.add(consumer);
        }

        final int userBatteryConsumerCount = builder.mUserBatteryConsumerBuilders.size();
        mUserBatteryConsumers = new ArrayList<>(userBatteryConsumerCount);
        for (int i = 0; i < userBatteryConsumerCount; i++) {
            final UserBatteryConsumer consumer =
                    builder.mUserBatteryConsumerBuilders.valueAt(i).build();
            totalPower += consumer.getConsumedPower();
            totalPowerMah += consumer.getConsumedPower();
            mUserBatteryConsumers.add(consumer);
        }

        mConsumedPower = totalPower;
        builder.getAggregateBatteryConsumerBuilder(AGGREGATE_BATTERY_CONSUMER_SCOPE_ALL_APPS)
                .setConsumedPower(totalPowerMah);

        mAggregateBatteryConsumers =
                new AggregateBatteryConsumer[AGGREGATE_BATTERY_CONSUMER_SCOPE_COUNT];
        for (int i = 0; i < AGGREGATE_BATTERY_CONSUMER_SCOPE_COUNT; i++) {
            mAggregateBatteryConsumers[i] = builder.mAggregateBatteryConsumersBuilders[i].build();
        }
    }

    /**
@@ -146,6 +135,15 @@ public final class BatteryUsageStats implements Parcelable {
        return mStatsStartTimestampMs;
    }

    /**
     * Total amount of battery charge drained since BatteryStats reset (e.g. due to being fully
     * charged), in mAh
     */
    public double getConsumedPower() {
        return mAggregateBatteryConsumers[AGGREGATE_BATTERY_CONSUMER_SCOPE_DEVICE]
                .getConsumedPower();
    }

    /**
     * Portion of battery charge drained since BatteryStats reset (e.g. due to being fully
     * charged), as percentage of the full charge in the range [0:100]
@@ -181,14 +179,6 @@ public final class BatteryUsageStats implements Parcelable {
        return mChargeTimeRemainingMs;
    }

    /**
     * Total amount of battery charge drained since BatteryStats reset (e.g. due to being fully
     * charged), in mAh
     */
    public double getConsumedPower() {
        return mConsumedPower;
    }

    /**
     * Returns a battery consumer for the specified battery consumer type.
     */
@@ -202,11 +192,6 @@ public final class BatteryUsageStats implements Parcelable {
        return mUidBatteryConsumers;
    }

    @NonNull
    public List<SystemBatteryConsumer> getSystemBatteryConsumers() {
        return mSystemBatteryConsumers;
    }

    @NonNull
    public List<UserBatteryConsumer> getUserBatteryConsumers() {
        return mUserBatteryConsumers;
@@ -232,7 +217,6 @@ public final class BatteryUsageStats implements Parcelable {

    private BatteryUsageStats(@NonNull Parcel source) {
        mStatsStartTimestampMs = source.readLong();
        mConsumedPower = source.readDouble();
        mDischargePercentage = source.readInt();
        mDischargedPowerLowerBound = source.readDouble();
        mDischargedPowerUpperBound = source.readDouble();
@@ -254,14 +238,6 @@ public final class BatteryUsageStats implements Parcelable {
            consumer.setCustomPowerComponentNames(mCustomPowerComponentNames);
            mUidBatteryConsumers.add(consumer);
        }
        int sysCount = source.readInt();
        mSystemBatteryConsumers = new ArrayList<>(sysCount);
        for (int i = 0; i < sysCount; i++) {
            final SystemBatteryConsumer consumer =
                    SystemBatteryConsumer.CREATOR.createFromParcel(source);
            consumer.setCustomPowerComponentNames(mCustomPowerComponentNames);
            mSystemBatteryConsumers.add(consumer);
        }
        int userCount = source.readInt();
        mUserBatteryConsumers = new ArrayList<>(userCount);
        for (int i = 0; i < userCount; i++) {
@@ -298,7 +274,6 @@ public final class BatteryUsageStats implements Parcelable {
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        dest.writeLong(mStatsStartTimestampMs);
        dest.writeDouble(mConsumedPower);
        dest.writeInt(mDischargePercentage);
        dest.writeDouble(mDischargedPowerLowerBound);
        dest.writeDouble(mDischargedPowerUpperBound);
@@ -312,10 +287,6 @@ public final class BatteryUsageStats implements Parcelable {
        for (int i = mUidBatteryConsumers.size() - 1; i >= 0; i--) {
            mUidBatteryConsumers.get(i).writeToParcel(dest, flags);
        }
        dest.writeInt(mSystemBatteryConsumers.size());
        for (int i = mSystemBatteryConsumers.size() - 1; i >= 0; i--) {
            mSystemBatteryConsumers.get(i).writeToParcel(dest, flags);
        }
        dest.writeInt(mUserBatteryConsumers.size());
        for (int i = mUserBatteryConsumers.size() - 1; i >= 0; i--) {
            mUserBatteryConsumers.get(i).writeToParcel(dest, flags);
@@ -367,8 +338,6 @@ public final class BatteryUsageStats implements Parcelable {
                new AggregateBatteryConsumer.Builder[AGGREGATE_BATTERY_CONSUMER_SCOPE_COUNT];
        private final SparseArray<UidBatteryConsumer.Builder> mUidBatteryConsumerBuilders =
                new SparseArray<>();
        private final SparseArray<SystemBatteryConsumer.Builder> mSystemBatteryConsumerBuilders =
                new SparseArray<>();
        private final SparseArray<UserBatteryConsumer.Builder> mUserBatteryConsumerBuilders =
                new SparseArray<>();
        private Parcel mHistoryBuffer;
@@ -482,22 +451,6 @@ public final class BatteryUsageStats implements Parcelable {
            return builder;
        }

        /**
         * Creates or returns a SystemBatteryConsumer, which represents battery attribution
         * data for a specific drain type.
         */
        @NonNull
        public SystemBatteryConsumer.Builder getOrCreateSystemBatteryConsumerBuilder(
                @SystemBatteryConsumer.DrainType int drainType) {
            SystemBatteryConsumer.Builder builder = mSystemBatteryConsumerBuilders.get(drainType);
            if (builder == null) {
                builder = new SystemBatteryConsumer.Builder(mCustomPowerComponentNames,
                        mIncludePowerModels, drainType);
                mSystemBatteryConsumerBuilders.put(drainType, builder);
            }
            return builder;
        }

        /**
         * Creates or returns a UserBatteryConsumer, which represents battery attribution
         * data for an individual {@link UserHandle}.
+0 −198
Original line number Diff line number Diff line
/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.os;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.util.Slog;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;


/**
 * Contains power consumption data attributed to a system-wide drain type.
 *
 * {@hide}
 */
public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable {
    private static final String TAG = "SystemBatteryConsumer";

    //                           ****************
    // This list must be kept current with atoms.proto (frameworks/base/cmds/statsd/src/atoms.proto)
    // so the constant values must never change.
    //                           ****************
    @IntDef(prefix = {"DRAIN_TYPE_"}, value = {
            DRAIN_TYPE_AMBIENT_DISPLAY,
            // Reserved: APP
            DRAIN_TYPE_BLUETOOTH,
            DRAIN_TYPE_CAMERA,
            DRAIN_TYPE_MOBILE_RADIO,
            DRAIN_TYPE_FLASHLIGHT,
            DRAIN_TYPE_IDLE,
            DRAIN_TYPE_MEMORY,
            // Reserved: OVERCOUNTED,
            DRAIN_TYPE_PHONE,
            DRAIN_TYPE_SCREEN,
            // Reserved: UNACCOUNTED,
            // Reserved: USER,
            DRAIN_TYPE_WIFI,
            DRAIN_TYPE_CUSTOM,
    })
    @Retention(RetentionPolicy.SOURCE)
    public static @interface DrainType {
    }

    public static final int DRAIN_TYPE_AMBIENT_DISPLAY = 0;
    public static final int DRAIN_TYPE_BLUETOOTH = 2;
    public static final int DRAIN_TYPE_CAMERA = 3;
    public static final int DRAIN_TYPE_MOBILE_RADIO = 4;
    public static final int DRAIN_TYPE_FLASHLIGHT = 5;
    public static final int DRAIN_TYPE_IDLE = 6;
    public static final int DRAIN_TYPE_MEMORY = 7;
    public static final int DRAIN_TYPE_PHONE = 9;
    public static final int DRAIN_TYPE_SCREEN = 10;
    public static final int DRAIN_TYPE_WIFI = 13;
    public static final int DRAIN_TYPE_CUSTOM = 14;

    @DrainType
    private final int mDrainType;

    private final double mPowerConsumedByAppsMah;

    @DrainType
    public int getDrainType() {
        return mDrainType;
    }

    private SystemBatteryConsumer(@NonNull SystemBatteryConsumer.Builder builder) {
        super(builder.mPowerComponentsBuilder.build());
        mDrainType = builder.mDrainType;
        mPowerConsumedByAppsMah = builder.mPowerConsumedByAppsMah;
        if (mPowerConsumedByAppsMah > getConsumedPower()) {
            Slog.wtf(TAG,
                    "Power attributed to apps exceeds total: drain type = " + mDrainType
                            + " total consumed power = " + getConsumedPower()
                            + " power consumed by apps = " + mPowerConsumedByAppsMah);
        }
    }

    private SystemBatteryConsumer(Parcel in) {
        super(new PowerComponents(in));
        mDrainType = in.readInt();
        mPowerConsumedByAppsMah = in.readDouble();
    }

    public double getPowerConsumedByApps() {
        return mPowerConsumedByAppsMah;
    }

    /**
     * Returns the amount of time this consumer was operating.
     */
    public long getUsageDurationMillis() {
        return mPowerComponents.getMaxComponentUsageDurationMillis();
    }

    /**
     * Writes the contents into a Parcel.
     */
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        super.writeToParcel(dest, flags);
        dest.writeInt(mDrainType);
        dest.writeDouble(mPowerConsumedByAppsMah);
    }

    public static final Creator<SystemBatteryConsumer> CREATOR =
            new Creator<SystemBatteryConsumer>() {
                @Override
                public SystemBatteryConsumer createFromParcel(Parcel in) {
                    return new SystemBatteryConsumer(in);
                }

                @Override
                public SystemBatteryConsumer[] newArray(int size) {
                    return new SystemBatteryConsumer[size];
                }
            };

    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * Builder for SystemBatteryConsumer.
     */
    public static final class Builder extends BaseBuilder<Builder> {
        @DrainType
        private final int mDrainType;
        private double mPowerConsumedByAppsMah;
        private List<UidBatteryConsumer.Builder> mUidBatteryConsumers;

        Builder(@NonNull String[] customPowerComponentNames,
                boolean includePowerModels, @DrainType int drainType) {
            super(customPowerComponentNames, includePowerModels);
            mDrainType = drainType;
        }

        /**
         * Sets the amount of power used by this system component that is attributed to apps.
         * It should not exceed the total consumed power.
         */
        public Builder setPowerConsumedByApps(double powerConsumedByAppsMah) {
            mPowerConsumedByAppsMah = powerConsumedByAppsMah;
            return this;
        }

        /**
         * Add a UidBatteryConsumer to this SystemBatteryConsumer. For example,
         * the UidBatteryConsumer with the UID == {@link Process#BLUETOOTH_UID} should
         * be added to the SystemBatteryConsumer with the drain type == {@link
         * #DRAIN_TYPE_BLUETOOTH}.
         * <p>
         * Calculated power and duration components of the added battery consumers
         * are aggregated at the time the SystemBatteryConsumer is built by the {@link #build()}
         * method.
         * </p>
         */
        public void addUidBatteryConsumer(UidBatteryConsumer.Builder uidBatteryConsumerBuilder) {
            if (mUidBatteryConsumers == null) {
                mUidBatteryConsumers = new ArrayList<>();
            }
            mUidBatteryConsumers.add(uidBatteryConsumerBuilder);
        }

        /**
         * Creates a read-only object out of the Builder values.
         */
        @NonNull
        public SystemBatteryConsumer build() {
            if (mUidBatteryConsumers != null) {
                for (int i = mUidBatteryConsumers.size() - 1; i >= 0; i--) {
                    UidBatteryConsumer.Builder uidBatteryConsumer = mUidBatteryConsumers.get(i);
                    mPowerComponentsBuilder.addPowerAndDuration(
                            uidBatteryConsumer.mPowerComponentsBuilder);
                }
            }
            return new SystemBatteryConsumer(this);
        }
    }
}
+0 −6
Original line number Diff line number Diff line
@@ -20,7 +20,6 @@ import android.os.BatteryConsumer;
import android.os.BatteryStats;
import android.os.BatteryUsageStats;
import android.os.BatteryUsageStatsQuery;
import android.os.SystemBatteryConsumer;
import android.os.UserHandle;
import android.util.SparseArray;

@@ -55,11 +54,6 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
                .setUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY, durationMs)
                .setConsumedPower(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY,
                        powerMah, powerModel);

        builder.getOrCreateSystemBatteryConsumerBuilder(
                SystemBatteryConsumer.DRAIN_TYPE_AMBIENT_DISPLAY)
                .setConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN, powerMah, powerModel)
                .setUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_SCREEN, durationMs);
    }

    /**
+11 −3
Original line number Diff line number Diff line
@@ -37,11 +37,14 @@ public class BatteryChargeCalculator extends PowerCalculator {
    @Override
    public void calculate(BatteryUsageStats.Builder builder, BatteryStats batteryStats,
            long rawRealtimeUs, long rawUptimeUs, BatteryUsageStatsQuery query) {
        final double dischargedPowerLowerBoundMah =
                batteryStats.getLowDischargeAmountSinceCharge() * mBatteryCapacity / 100;
        final double dischargedPowerUpperBoundMah =
                batteryStats.getHighDischargeAmountSinceCharge() * mBatteryCapacity / 100;
        builder.setDischargePercentage(
                        batteryStats.getDischargeAmount(BatteryStats.STATS_SINCE_CHARGED))
                .setDischargedPowerRange(
                        batteryStats.getLowDischargeAmountSinceCharge() * mBatteryCapacity / 100,
                        batteryStats.getHighDischargeAmountSinceCharge() * mBatteryCapacity / 100);
                .setDischargedPowerRange(dischargedPowerLowerBoundMah,
                        dischargedPowerUpperBoundMah);

        final long batteryTimeRemainingMs = batteryStats.computeBatteryTimeRemaining(rawRealtimeUs);
        if (batteryTimeRemainingMs != -1) {
@@ -52,6 +55,11 @@ public class BatteryChargeCalculator extends PowerCalculator {
        if (chargeTimeRemainingMs != -1) {
            builder.setChargeTimeRemainingMs(chargeTimeRemainingMs / 1000);
        }

        builder.getAggregateBatteryConsumerBuilder(
                BatteryUsageStats.AGGREGATE_BATTERY_CONSUMER_SCOPE_DEVICE)
                .setConsumedPower(
                        (dischargedPowerLowerBoundMah + dischargedPowerUpperBoundMah) / 2);
    }

    @Override
Loading