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

Commit 2b060022 authored by Dmitri Plotnikov's avatar Dmitri Plotnikov
Browse files

Reduce locking of BatteryStats during reset

Also, impose minimum battery session duration between auto-resets

Bug: 381940953
Flag: com.android.server.power.optimization.extended_battery_history_continuous_collection_enabled
Test: atest PowerStatsTests;atest PowerStatsTestsRavenwood

Change-Id: I0263a24c55d5155700573f8d6cfb46beba0215e1
parent fa12661e
Loading
Loading
Loading
Loading
+116 −15
Original line number Diff line number Diff line
@@ -225,11 +225,19 @@ public class BatteryStatsImpl extends BatteryStats {
    @VisibleForTesting
    public static final int WAKE_LOCK_WEIGHT = 50;
    /**
     * Minimum duration of a battery session. Attempt to automatically start a new
     * session within this interval are ignored. Explicit resets (e.g. with an adb command) are
     * not affected by this restriction.
     */
    private static final long MIN_BATTERY_SESSION_DURATION_MILLIS = 60000;
    public static final int RESET_REASON_CORRUPT_FILE = 1;
    public static final int RESET_REASON_ADB_COMMAND = 2;
    public static final int RESET_REASON_FULL_CHARGE = 3;
    public static final int RESET_REASON_ENERGY_CONSUMER_BUCKETS_CHANGE = 4;
    public static final int RESET_REASON_PLUGGED_IN_FOR_LONG_DURATION = 5;
    @NonNull
    private final MonotonicClock mMonotonicClock;
@@ -305,6 +313,81 @@ public class BatteryStatsImpl extends BatteryStats {
    private final SparseBooleanArray mPowerStatsCollectorEnabled = new SparseBooleanArray();
    private boolean mMoveWscLoggingToNotifierEnabled = false;
    static class BatteryStatsSession {
        private final BatteryStatsHistory mHistory;
        private final long mMonotonicStartTime;
        private final long mStartClockTime;
        private final long mEstimatedBatteryCapacityMah;
        private final long mBatteryTimeRemainingMs;
        private final long mChargeTimeRemainingMs;
        private final String[] mCustomEnergyConsumerNames;
        private final BatteryStatsImpl mBatteryStats;
        BatteryStatsSession(BatteryStatsHistory history, long monotonicStartTime,
                long startClockTime, long batteryTimeRemainingMs, long chargeTimeRemainingMs,
                long estimatedBatteryCapacityMah, String[] customEnergyConsumerNames,
                BatteryStatsImpl batteryStats) {
            mHistory = history;
            mMonotonicStartTime = monotonicStartTime;
            mStartClockTime = startClockTime;
            mEstimatedBatteryCapacityMah = estimatedBatteryCapacityMah;
            mBatteryTimeRemainingMs = batteryTimeRemainingMs;
            mChargeTimeRemainingMs = chargeTimeRemainingMs;
            mCustomEnergyConsumerNames = customEnergyConsumerNames;
            mBatteryStats = batteryStats;
        }
        BatteryStatsHistory getHistory() {
            return mHistory;
        }
        long getMonotonicStartTime() {
            return mMonotonicStartTime;
        }
        long getStartClockTime() {
            return mStartClockTime;
        }
        long getBatteryTimeRemainingMs() {
            return mBatteryTimeRemainingMs;
        }
        long getChargeTimeRemainingMs() {
            return mChargeTimeRemainingMs;
        }
        double getEstimatedBatteryCapacity() {
            return mEstimatedBatteryCapacityMah;
        }
        String[] getCustomEnergyConsumerNames() {
            return mCustomEnergyConsumerNames;
        }
        /** @deprecated This method will be removed once PowerCalculators are removed from the
         * code base. */
        @Deprecated
        public BatteryStatsImpl getBatteryStats() {
            return mBatteryStats;
        }
    }
    BatteryStatsSession getBatteryStatsSession() {
        synchronized (this) {
            long elapsedTimeUs = mClock.elapsedRealtime() * 1000;
            long batteryTimeRemainingUs = computeBatteryTimeRemaining(elapsedTimeUs);
            long batteryTimeRemainingMs =
                    batteryTimeRemainingUs >= 0 ? batteryTimeRemainingUs / 1000 : -1;
            long chargeTimeRemainingUs = computeChargeTimeRemaining(elapsedTimeUs);
            long chargeTimeRemainingMs =
                    chargeTimeRemainingUs >= 0 ? chargeTimeRemainingUs / 1000 : -1;
            return new BatteryStatsSession(mHistory, getMonotonicStartTime(), getStartClockTime(),
                    batteryTimeRemainingMs, chargeTimeRemainingMs, getEstimatedBatteryCapacity(),
                    getCustomEnergyConsumerNames(), this);
        }
    }
    private ScreenPowerStatsCollector.ScreenUsageTimeRetriever mScreenUsageTimeRetriever =
            new ScreenPowerStatsCollector.ScreenUsageTimeRetriever() {
@@ -1753,8 +1836,7 @@ public class BatteryStatsImpl extends BatteryStats {
     */
    private LongSamplingCounterArray mBinderThreadCpuTimesUs;
    @VisibleForTesting
    protected PowerProfile mPowerProfile;
    private final PowerProfile mPowerProfile;
    @VisibleForTesting
    @GuardedBy("this")
@@ -11627,10 +11709,6 @@ public class BatteryStatsImpl extends BatteryStats {
        setDisplayCountLocked(mPowerProfile.getNumDisplays());
    }
    PowerProfile getPowerProfile() {
        return mPowerProfile;
    }
    /**
     * Starts tracking CPU time-in-state for threads of the system server process,
     * keeping a separate account of threads receiving incoming binder calls.
@@ -12107,11 +12185,29 @@ public class BatteryStatsImpl extends BatteryStats {
        initActiveHistoryEventsLocked(mSecRealtime, mSecUptime);
    }
    /**
     * Starts a new battery stats session, resetting counters and timers. If this method is called
     * before MIN_BATTERY_SESSION_DURATION_MILLIS from the beginning of the current session, the
     * call is ignored.
     */
    public void startNewSession(int reason) {
        if (mMonotonicClock.monotonicTime()
                < mMonotonicStartTime + MIN_BATTERY_SESSION_DURATION_MILLIS) {
            Slog.i(TAG, "Battery session session duration is too short, ignoring reset request");
            return;
        }
        mHandler.post(()-> {
            saveBatteryUsageStatsOnReset();
            synchronized (BatteryStatsImpl.this) {
                resetAllStatsLocked(mClock.uptimeMillis(), mClock.elapsedRealtime(), reason);
            }
        });
    }
    @GuardedBy("this")
    private void resetAllStatsLocked(long uptimeMillis, long elapsedRealtimeMillis,
            int resetReason) {
        saveBatteryUsageStatsOnReset(resetReason);
        final long uptimeUs = uptimeMillis * 1000;
        final long elapsedRealtimeUs = elapsedRealtimeMillis * 1000;
        mStartCount = 0;
@@ -12266,14 +12362,14 @@ public class BatteryStatsImpl extends BatteryStats {
        mHandler.sendEmptyMessage(MSG_REPORT_RESET_STATS);
    }
    private void saveBatteryUsageStatsOnReset(int resetReason) {
        if (!mSaveBatteryUsageStatsOnReset
                || resetReason == BatteryStatsImpl.RESET_REASON_CORRUPT_FILE) {
    private void saveBatteryUsageStatsOnReset() {
        if (!mSaveBatteryUsageStatsOnReset) {
            return;
        }
        if (mAccumulateBatteryUsageStats) {
            mBatteryUsageStatsProvider.accumulateBatteryUsageStats(this);
            mBatteryUsageStatsProvider.accumulateBatteryUsageStats(getBatteryStatsSession(),
                    mHandler);
        } else {
            final BatteryUsageStats batteryUsageStats;
            synchronized (this) {
@@ -14926,7 +15022,7 @@ public class BatteryStatsImpl extends BatteryStats {
                    "Resetting due to long plug in duration. elapsed time = " + elapsedRealtimeMs
                            + " ms, last plug in time = " + mBatteryPluggedInRealTimeMs
                            + " ms, last reset time = " + mRealtimeStartUs / 1000);
            resetAllStatsAndHistoryLocked(RESET_REASON_PLUGGED_IN_FOR_LONG_DURATION);
            startNewSession(RESET_REASON_PLUGGED_IN_FOR_LONG_DURATION);
        }
        scheduleNextResetWhilePluggedInCheck();
@@ -15064,7 +15160,7 @@ public class BatteryStatsImpl extends BatteryStats {
                    });
                }
                doWrite = true;
                resetAllStatsLocked(mSecUptime, mSecRealtime, RESET_REASON_FULL_CHARGE);
                startNewSession(RESET_REASON_FULL_CHARGE);
                if (chargeUah > 0 && level > 0) {
                    // Only use the reported coulomb charge value if it is supported and reported.
                    mEstimatedBatteryCapacityMah = (int) ((chargeUah / 1000) / (level / 100.0));
@@ -15980,6 +16076,8 @@ public class BatteryStatsImpl extends BatteryStats {
            if (mEnergyConsumerStatsConfig != null
                    &&  !mEnergyConsumerStatsConfig.isCompatible(config)) {
                // Supported power buckets changed since last boot.
                // Save accumulated battery usage stats before resetting
                saveBatteryUsageStatsOnReset();
                // Existing data is no longer reliable.
                resetAllStatsLocked(SystemClock.uptimeMillis(), SystemClock.elapsedRealtime(),
                        RESET_REASON_ENERGY_CONSUMER_BUCKETS_CHANGE);
@@ -15999,7 +16097,10 @@ public class BatteryStatsImpl extends BatteryStats {
            }
        } else {
            if (mEnergyConsumerStatsConfig != null) {
                // EnergyConsumer no longer supported, wipe out the existing data.
                // EnergyConsumer no longer supported
                // Save accumulated battery usage stats before resetting
                saveBatteryUsageStatsOnReset();
                // Wipe out the current battery session data.
                resetAllStatsLocked(SystemClock.uptimeMillis(), SystemClock.elapsedRealtime(),
                        RESET_REASON_ENERGY_CONSUMER_BUCKETS_CHANGE);
            }
+139 −110
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@
package com.android.server.power.stats;

import android.annotation.NonNull;
import android.annotation.UserIdInt;
import android.content.Context;
import android.hardware.SensorManager;
import android.os.BatteryConsumer;
@@ -25,6 +26,8 @@ import android.os.BatteryUsageStats;
import android.os.BatteryUsageStatsQuery;
import android.os.Handler;
import android.os.Process;
import android.os.UidBatteryConsumer;
import android.os.UserHandle;
import android.util.Log;
import android.util.LogWriter;
import android.util.Slog;
@@ -34,6 +37,8 @@ import com.android.internal.os.Clock;
import com.android.internal.os.CpuScalingPolicies;
import com.android.internal.os.MonotonicClock;
import com.android.internal.os.PowerProfile;
import com.android.internal.util.ArrayUtils;
import com.android.server.power.stats.BatteryStatsImpl.BatteryStatsSession;

import java.io.PrintWriter;
import java.util.ArrayList;
@@ -58,7 +63,6 @@ public class BatteryUsageStatsProvider {
    private final MonotonicClock mMonotonicClock;
    private final Object mLock = new Object();
    private List<PowerCalculator> mPowerCalculators;
    private UserPowerCalculator mUserPowerCalculator;
    private long mLastAccumulationMonotonicHistorySize;

    private static class AccumulatedBatteryUsageStats {
@@ -81,7 +85,6 @@ public class BatteryUsageStatsProvider {
        mAccumulatedBatteryUsageStatsSpanSize = accumulatedBatteryUsageStatsSpanSize;
        mClock = clock;
        mMonotonicClock = monotonicClock;
        mUserPowerCalculator = new UserPowerCalculator();

        mPowerStatsStore.addSectionReader(new BatteryUsageStatsSection.Reader());
        mPowerStatsStore.addSectionReader(new AccumulatedBatteryUsageStatsSection.Reader());
@@ -195,22 +198,20 @@ public class BatteryUsageStatsProvider {
            mLastAccumulationMonotonicHistorySize = historySize;
        }

        BatteryStatsSession session = stats.getBatteryStatsSession();

        // No need to store the accumulated stats asynchronously, as the entire accumulation
        // operation is async
        handler.post(() -> accumulateBatteryUsageStats(stats, false));
        handler.post(() -> accumulateBatteryUsageStats(session, handler));
    }

    /**
     * Computes BatteryUsageStats for the period since the last accumulated stats were stored,
     * adds them to the accumulated stats and asynchronously saves the result.
     * adds them to the accumulated stats and saves the result on the handler thread.
     */
    public void accumulateBatteryUsageStats(BatteryStatsImpl stats) {
        accumulateBatteryUsageStats(stats, true);
    }

    private void accumulateBatteryUsageStats(BatteryStatsImpl stats, boolean storeAsync) {
    public void accumulateBatteryUsageStats(BatteryStatsSession session, Handler handler) {
        AccumulatedBatteryUsageStats accumulatedStats = loadAccumulatedBatteryUsageStats();
        updateAccumulatedBatteryUsageStats(accumulatedStats, stats);
        updateAccumulatedBatteryUsageStats(accumulatedStats, session);

        PowerStatsSpan powerStatsSpan = new PowerStatsSpan(AccumulatedBatteryUsageStatsSection.ID);
        powerStatsSpan.addSection(
@@ -219,12 +220,12 @@ public class BatteryUsageStatsProvider {
                accumulatedStats.startWallClockTime,
                accumulatedStats.endMonotonicTime - accumulatedStats.startMonotonicTime);
        mMonotonicClock.write();
        if (storeAsync) {
            mPowerStatsStore.storePowerStatsSpanAsync(powerStatsSpan,
                    accumulatedStats.builder::discard);
        } else {
        if (handler.getLooper().isCurrentThread()) {
            mPowerStatsStore.storePowerStatsSpan(powerStatsSpan);
            accumulatedStats.builder.discard();
        } else {
            mPowerStatsStore.storePowerStatsSpanAsync(powerStatsSpan,
                    accumulatedStats.builder::discard);
        }
    }

@@ -252,9 +253,10 @@ public class BatteryUsageStatsProvider {
        synchronized (stats) {
            stats.prepareForDumpLocked();
        }
        BatteryStatsSession session = stats.getBatteryStatsSession();
        final long currentTimeMillis = mClock.currentTimeMillis();
        for (int i = 0; i < queries.size(); i++) {
            results.add(getBatteryUsageStats(stats, queries.get(i), currentTimeMillis));
            results.add(getBatteryUsageStats(session, queries.get(i), currentTimeMillis));
        }

        return results;
@@ -265,22 +267,23 @@ public class BatteryUsageStatsProvider {
     */
    public BatteryUsageStats getBatteryUsageStats(BatteryStatsImpl stats,
            BatteryUsageStatsQuery query) {
        return getBatteryUsageStats(stats, query, mClock.currentTimeMillis());
        return getBatteryUsageStats(stats.getBatteryStatsSession(), query,
                mClock.currentTimeMillis());
    }

    private BatteryUsageStats getBatteryUsageStats(BatteryStatsImpl stats,
    private BatteryUsageStats getBatteryUsageStats(BatteryStatsSession session,
            BatteryUsageStatsQuery query, long currentTimeMs) {
        BatteryUsageStats batteryUsageStats;
        if ((query.getFlags()
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_ACCUMULATED) != 0) {
            batteryUsageStats = getAccumulatedBatteryUsageStats(stats, query);
            batteryUsageStats = getAccumulatedBatteryUsageStats(session, query);
        } else if (query.getAggregatedToTimestamp() == 0) {
            BatteryUsageStats.Builder builder = computeBatteryUsageStats(stats, query,
            BatteryUsageStats.Builder builder = computeBatteryUsageStats(session, query,
                    query.getMonotonicStartTime(),
                    query.getMonotonicEndTime(), currentTimeMs);
            batteryUsageStats = builder.build();
        } else {
            batteryUsageStats = getAggregatedBatteryUsageStats(stats, query);
            batteryUsageStats = getAggregatedBatteryUsageStats(session, query);
        }
        if (DEBUG) {
            Slog.d(TAG, "query = " + query);
@@ -291,13 +294,13 @@ public class BatteryUsageStatsProvider {
        return batteryUsageStats;
    }

    private BatteryUsageStats getAccumulatedBatteryUsageStats(BatteryStatsImpl stats,
    private BatteryUsageStats getAccumulatedBatteryUsageStats(BatteryStatsSession session,
            BatteryUsageStatsQuery query) {
        AccumulatedBatteryUsageStats accumulatedStats = loadAccumulatedBatteryUsageStats();
        if (accumulatedStats.endMonotonicTime == MonotonicClock.UNDEFINED
                || mMonotonicClock.monotonicTime() - accumulatedStats.endMonotonicTime
                > query.getMaxStatsAge()) {
            updateAccumulatedBatteryUsageStats(accumulatedStats, stats);
            updateAccumulatedBatteryUsageStats(accumulatedStats, session);
        }
        return accumulatedStats.builder.build();
    }
@@ -329,19 +332,19 @@ public class BatteryUsageStatsProvider {
    }

    private void updateAccumulatedBatteryUsageStats(AccumulatedBatteryUsageStats accumulatedStats,
            BatteryStatsImpl stats) {
            BatteryStatsSession session) {
        long startMonotonicTime = accumulatedStats.endMonotonicTime;
        if (startMonotonicTime == MonotonicClock.UNDEFINED) {
            startMonotonicTime = stats.getMonotonicStartTime();
            startMonotonicTime = session.getMonotonicStartTime();
        }
        long endWallClockTime = mClock.currentTimeMillis();
        long endMonotonicTime = mMonotonicClock.monotonicTime();

        if (accumulatedStats.builder == null) {
            accumulatedStats.builder = new BatteryUsageStats.Builder(
                    stats.getCustomEnergyConsumerNames(), true, true, true, 0);
            accumulatedStats.startWallClockTime = stats.getStartClockTime();
            accumulatedStats.startMonotonicTime = stats.getMonotonicStartTime();
                    session.getCustomEnergyConsumerNames(), true, true, true, 0);
            accumulatedStats.startWallClockTime = session.getStartClockTime();
            accumulatedStats.startMonotonicTime = session.getMonotonicStartTime();
            accumulatedStats.builder.setStatsStartTimestamp(accumulatedStats.startWallClockTime);
        }

@@ -350,32 +353,27 @@ public class BatteryUsageStatsProvider {
        accumulatedStats.builder.setStatsEndTimestamp(endWallClockTime);
        accumulatedStats.builder.setStatsDuration(endWallClockTime - startMonotonicTime);

        mPowerAttributor.estimatePowerConsumption(accumulatedStats.builder, stats.getHistory(),
        mPowerAttributor.estimatePowerConsumption(accumulatedStats.builder, session.getHistory(),
                startMonotonicTime, endMonotonicTime);

        populateGeneralInfo(accumulatedStats.builder, stats);
        populateBatterySessionInfo(accumulatedStats.builder, session);
    }

    private BatteryUsageStats.Builder computeBatteryUsageStats(BatteryStatsImpl stats,
    private BatteryUsageStats.Builder computeBatteryUsageStats(BatteryStatsSession session,
            BatteryUsageStatsQuery query, long monotonicStartTime, long monotonicEndTime,
            long currentTimeMs) {
        final boolean includeProcessStateData = ((query.getFlags()
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_PROCESS_STATE_DATA) != 0)
                && stats.isProcessStateDataAvailable();
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_PROCESS_STATE_DATA) != 0);
        final boolean includeVirtualUids = ((query.getFlags()
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_VIRTUAL_UIDS) != 0);
        final double minConsumedPowerThreshold = query.getMinConsumedPowerThreshold();

        String[] customEnergyConsumerNames;
        synchronized (stats) {
            customEnergyConsumerNames = stats.getCustomEnergyConsumerNames();
        }
        String[] customEnergyConsumerNames = session.getCustomEnergyConsumerNames();

        final BatteryUsageStats.Builder batteryUsageStatsBuilder = new BatteryUsageStats.Builder(
                customEnergyConsumerNames, includeProcessStateData, query.isScreenStateDataNeeded(),
                query.isPowerStateDataNeeded(), minConsumedPowerThreshold);

        synchronized (stats) {
        final List<PowerCalculator> powerCalculators = getPowerCalculators();
        boolean usePowerCalculators = !powerCalculators.isEmpty();
        if (usePowerCalculators
@@ -388,25 +386,49 @@ public class BatteryUsageStatsProvider {
        }

        if (monotonicStartTime == MonotonicClock.UNDEFINED) {
                monotonicStartTime = stats.getMonotonicStartTime();
            monotonicStartTime = session.getMonotonicStartTime();
        }
            batteryUsageStatsBuilder.setStatsStartTimestamp(stats.getStartClockTime()
                    + (monotonicStartTime - stats.getMonotonicStartTime()));
        batteryUsageStatsBuilder.setStatsStartTimestamp(session.getStartClockTime()
                + (monotonicStartTime - session.getMonotonicStartTime()));
        if (monotonicEndTime != MonotonicClock.UNDEFINED) {
                batteryUsageStatsBuilder.setStatsEndTimestamp(stats.getStartClockTime()
                        + (monotonicEndTime - stats.getMonotonicStartTime()));
            batteryUsageStatsBuilder.setStatsEndTimestamp(session.getStartClockTime()
                    + (monotonicEndTime - session.getMonotonicStartTime()));
        } else {
            batteryUsageStatsBuilder.setStatsEndTimestamp(currentTimeMs);
        }

        if (usePowerCalculators) {
            BatteryStatsImpl stats = session.getBatteryStats();
            applyPowerCalculators(batteryUsageStatsBuilder, stats, query, includeVirtualUids);
        }
        if ((query.getFlags()
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY) != 0) {
            batteryUsageStatsBuilder.setBatteryHistory(session.getHistory().copy());
        }

        mPowerAttributor.estimatePowerConsumption(batteryUsageStatsBuilder, session.getHistory(),
                monotonicStartTime, monotonicEndTime);

        // Combine apps by the user if necessary
        buildUserBatteryConsumers(batteryUsageStatsBuilder, query.getUserIds());

        populateBatterySessionInfo(batteryUsageStatsBuilder, session);
        return batteryUsageStatsBuilder;
    }

    private void applyPowerCalculators(BatteryUsageStats.Builder batteryUsageStatsBuilder,
            BatteryStatsImpl stats, BatteryUsageStatsQuery query,
            boolean includeVirtualUids) {
        synchronized (stats) {
            final List<PowerCalculator> powerCalculators = getPowerCalculators();
            final long realtimeUs = mClock.elapsedRealtime() * 1000;
            final long uptimeUs = mClock.uptimeMillis() * 1000;
            final int[] powerComponents = query.getPowerComponents();
            SparseArray<? extends BatteryStats.Uid> uidStats = stats.getUidStats();
            for (int i = uidStats.size() - 1; i >= 0; i--) {
                final BatteryStats.Uid uid = uidStats.valueAt(i);
                    if (!includeVirtualUids && uid.getUid() == Process.SDK_SANDBOX_VIRTUAL_UID) {
                if (!includeVirtualUids
                        && uid.getUid() == Process.SDK_SANDBOX_VIRTUAL_UID) {
                    continue;
                }

@@ -430,41 +452,19 @@ public class BatteryUsageStatsProvider {
                        query);
            }
        }
            if ((query.getFlags()
                    & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY) != 0) {
                batteryUsageStatsBuilder.setBatteryHistory(stats.copyHistory());
    }
        }

        mPowerAttributor.estimatePowerConsumption(batteryUsageStatsBuilder, stats.getHistory(),
                monotonicStartTime, monotonicEndTime);

        // Combine apps by the user if necessary
        mUserPowerCalculator.calculate(batteryUsageStatsBuilder, stats, 0, 0, query);

        populateGeneralInfo(batteryUsageStatsBuilder, stats);
        return batteryUsageStatsBuilder;
    }

    private void populateGeneralInfo(BatteryUsageStats.Builder builder, BatteryStatsImpl stats) {
        builder.setBatteryCapacity(stats.getEstimatedBatteryCapacity());
        final long batteryTimeRemainingMs = stats.computeBatteryTimeRemaining(
                mClock.elapsedRealtime() * 1000);
        if (batteryTimeRemainingMs != -1) {
            builder.setBatteryTimeRemainingMs(batteryTimeRemainingMs / 1000);
        }
        final long chargeTimeRemainingMs = stats.computeChargeTimeRemaining(
                mClock.elapsedRealtime() * 1000);
        if (chargeTimeRemainingMs != -1) {
            builder.setChargeTimeRemainingMs(chargeTimeRemainingMs / 1000);
        }
    private void populateBatterySessionInfo(BatteryUsageStats.Builder builder,
            BatteryStatsSession session) {
        builder.setBatteryCapacity(session.getEstimatedBatteryCapacity());
        builder.setBatteryTimeRemainingMs(session.getBatteryTimeRemainingMs());
        builder.setChargeTimeRemainingMs(session.getChargeTimeRemainingMs());
    }

    private BatteryUsageStats getAggregatedBatteryUsageStats(BatteryStatsImpl stats,
    private BatteryUsageStats getAggregatedBatteryUsageStats(BatteryStatsSession stats,
            BatteryUsageStatsQuery query) {
        final boolean includeProcessStateData = ((query.getFlags()
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_PROCESS_STATE_DATA) != 0)
                && stats.isProcessStateDataAvailable();
                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_PROCESS_STATE_DATA) != 0);
        final double minConsumedPowerThreshold = query.getMinConsumedPowerThreshold();

        final String[] customEnergyConsumerNames = stats.getCustomEnergyConsumerNames();
@@ -539,4 +539,33 @@ public class BatteryUsageStatsProvider {
        }
        return builder.build();
    }

    private void buildUserBatteryConsumers(BatteryUsageStats.Builder builder,
            @UserIdInt int[] userIds) {
        if (ArrayUtils.contains(userIds, UserHandle.USER_ALL)) {
            return;
        }

        SparseArray<UidBatteryConsumer.Builder> uidBatteryConsumerBuilders =
                builder.getUidBatteryConsumerBuilders();

        for (int i = uidBatteryConsumerBuilders.size() - 1; i >= 0; i--) {
            final UidBatteryConsumer.Builder uidBuilder = uidBatteryConsumerBuilders.valueAt(i);
            if (uidBuilder.isVirtualUid()) {
                continue;
            }

            final int uid = uidBuilder.getUid();
            if (UserHandle.getAppId(uid) < Process.FIRST_APPLICATION_UID) {
                continue;
            }

            final int userId = UserHandle.getUserId(uid);
            if (!ArrayUtils.contains(userIds, userId)) {
                uidBuilder.excludeFromBatteryUsageStats();
                builder.getOrCreateUserBatteryConsumerBuilder(userId)
                        .addUidBatteryConsumer(uidBuilder);
            }
        }
    }
}
+22 −13

File changed.

Preview size limit exceeded, changes collapsed.

+0 −70

File deleted.

Preview size limit exceeded, changes collapsed.

+3 −2

File changed.

Preview size limit exceeded, changes collapsed.

Loading