1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.android.settings.fuelgauge;
17 
18 import android.content.Context;
19 import android.content.pm.PackageManager;
20 import android.os.BatteryStats;
21 import android.os.SystemClock;
22 import android.support.annotation.IntDef;
23 import android.support.annotation.Nullable;
24 import android.support.annotation.VisibleForTesting;
25 import android.text.format.DateUtils;
26 import android.util.Log;
27 import android.util.SparseLongArray;
28 
29 import com.android.internal.os.BatterySipper;
30 import com.android.internal.os.BatteryStatsHelper;
31 import com.android.settings.overlay.FeatureFactory;
32 
33 import java.lang.annotation.Retention;
34 import java.lang.annotation.RetentionPolicy;
35 import java.util.Collections;
36 import java.util.Comparator;
37 import java.util.List;
38 
39 /**
40  * Utils for battery operation
41  */
42 public class BatteryUtils {
43     @Retention(RetentionPolicy.SOURCE)
44     @IntDef({StatusType.FOREGROUND,
45             StatusType.BACKGROUND,
46             StatusType.ALL
47     })
48     public @interface StatusType {
49         int FOREGROUND = 0;
50         int BACKGROUND = 1;
51         int ALL = 2;
52     }
53 
54     private static final String TAG = "BatteryUtils";
55 
56     private static final int MIN_POWER_THRESHOLD_MILLI_AMP = 5;
57     private static final int SECONDS_IN_HOUR = 60 * 60;
58     private static BatteryUtils sInstance;
59 
60     private PackageManager mPackageManager;
61     @VisibleForTesting
62     PowerUsageFeatureProvider mPowerUsageFeatureProvider;
63 
getInstance(Context context)64     public static BatteryUtils getInstance(Context context) {
65         if (sInstance == null || sInstance.isDataCorrupted()) {
66             sInstance = new BatteryUtils(context);
67         }
68         return sInstance;
69     }
70 
71     @VisibleForTesting
BatteryUtils(Context context)72     BatteryUtils(Context context) {
73         mPackageManager = context.getPackageManager();
74         mPowerUsageFeatureProvider = FeatureFactory.getFactory(
75                 context).getPowerUsageFeatureProvider(context);
76     }
77 
getProcessTimeMs(@tatusType int type, @Nullable BatteryStats.Uid uid, int which)78     public long getProcessTimeMs(@StatusType int type, @Nullable BatteryStats.Uid uid,
79             int which) {
80         if (uid == null) {
81             return 0;
82         }
83 
84         switch (type) {
85             case StatusType.FOREGROUND:
86                 return getProcessForegroundTimeMs(uid, which);
87             case StatusType.BACKGROUND:
88                 return getProcessBackgroundTimeMs(uid, which);
89             case StatusType.ALL:
90                 return getProcessForegroundTimeMs(uid, which)
91                         + getProcessBackgroundTimeMs(uid, which);
92         }
93         return 0;
94     }
95 
getProcessBackgroundTimeMs(BatteryStats.Uid uid, int which)96     private long getProcessBackgroundTimeMs(BatteryStats.Uid uid, int which) {
97         final long rawRealTimeUs = convertMsToUs(SystemClock.elapsedRealtime());
98         final long timeUs = uid.getProcessStateTime(
99                 BatteryStats.Uid.PROCESS_STATE_BACKGROUND, rawRealTimeUs, which);
100 
101         Log.v(TAG, "package: " + mPackageManager.getNameForUid(uid.getUid()));
102         Log.v(TAG, "background time(us): " + timeUs);
103         return convertUsToMs(timeUs);
104     }
105 
getProcessForegroundTimeMs(BatteryStats.Uid uid, int which)106     private long getProcessForegroundTimeMs(BatteryStats.Uid uid, int which) {
107         final long rawRealTimeUs = convertMsToUs(SystemClock.elapsedRealtime());
108         final int foregroundTypes[] = {BatteryStats.Uid.PROCESS_STATE_TOP};
109         Log.v(TAG, "package: " + mPackageManager.getNameForUid(uid.getUid()));
110 
111         long timeUs = 0;
112         for (int type : foregroundTypes) {
113             final long localTime = uid.getProcessStateTime(type, rawRealTimeUs, which);
114             Log.v(TAG, "type: " + type + " time(us): " + localTime);
115             timeUs += localTime;
116         }
117         Log.v(TAG, "foreground time(us): " + timeUs);
118 
119         return convertUsToMs(timeUs);
120     }
121 
122     /**
123      * Remove the {@link BatterySipper} that we should hide and smear the screen usage based on
124      * foreground activity time.
125      *
126      * @param sippers sipper list that need to check and remove
127      * @return the total power of the hidden items of {@link BatterySipper}
128      * for proportional smearing
129      */
removeHiddenBatterySippers(List<BatterySipper> sippers)130     public double removeHiddenBatterySippers(List<BatterySipper> sippers) {
131         double proportionalSmearPowerMah = 0;
132         BatterySipper screenSipper = null;
133         for (int i = sippers.size() - 1; i >= 0; i--) {
134             final BatterySipper sipper = sippers.get(i);
135             if (shouldHideSipper(sipper)) {
136                 sippers.remove(i);
137                 if (sipper.drainType != BatterySipper.DrainType.OVERCOUNTED
138                         && sipper.drainType != BatterySipper.DrainType.SCREEN
139                         && sipper.drainType != BatterySipper.DrainType.UNACCOUNTED
140                         && sipper.drainType != BatterySipper.DrainType.BLUETOOTH
141                         && sipper.drainType != BatterySipper.DrainType.WIFI) {
142                     // Don't add it if it is overcounted, unaccounted, wifi, bluetooth, or screen
143                     proportionalSmearPowerMah += sipper.totalPowerMah;
144                 }
145             }
146 
147             if (sipper.drainType == BatterySipper.DrainType.SCREEN) {
148                 screenSipper = sipper;
149             }
150         }
151 
152         smearScreenBatterySipper(sippers, screenSipper);
153 
154         return proportionalSmearPowerMah;
155     }
156 
157     /**
158      * Smear the screen on power usage among {@code sippers}, based on ratio of foreground activity
159      * time.
160      */
161     @VisibleForTesting
smearScreenBatterySipper(List<BatterySipper> sippers, BatterySipper screenSipper)162     void smearScreenBatterySipper(List<BatterySipper> sippers, BatterySipper screenSipper) {
163         final long rawRealtimeMs = SystemClock.elapsedRealtime();
164         long totalActivityTimeMs = 0;
165         final SparseLongArray activityTimeArray = new SparseLongArray();
166         for (int i = 0, size = sippers.size(); i < size; i++) {
167             final BatteryStats.Uid uid = sippers.get(i).uidObj;
168             if (uid != null) {
169                 final long timeMs = getForegroundActivityTotalTimeMs(uid, rawRealtimeMs);
170                 activityTimeArray.put(uid.getUid(), timeMs);
171                 totalActivityTimeMs += timeMs;
172             }
173         }
174 
175         if (totalActivityTimeMs >= 10 * DateUtils.MINUTE_IN_MILLIS) {
176             final double screenPowerMah = screenSipper.totalPowerMah;
177             for (int i = 0, size = sippers.size(); i < size; i++) {
178                 final BatterySipper sipper = sippers.get(i);
179                 sipper.totalPowerMah += screenPowerMah * activityTimeArray.get(sipper.getUid(), 0)
180                         / totalActivityTimeMs;
181             }
182         }
183     }
184 
185     /**
186      * Check whether we should hide the battery sipper.
187      */
shouldHideSipper(BatterySipper sipper)188     public boolean shouldHideSipper(BatterySipper sipper) {
189         final BatterySipper.DrainType drainType = sipper.drainType;
190 
191         return drainType == BatterySipper.DrainType.IDLE
192                 || drainType == BatterySipper.DrainType.CELL
193                 || drainType == BatterySipper.DrainType.SCREEN
194                 || drainType == BatterySipper.DrainType.UNACCOUNTED
195                 || drainType == BatterySipper.DrainType.OVERCOUNTED
196                 || drainType == BatterySipper.DrainType.BLUETOOTH
197                 || drainType == BatterySipper.DrainType.WIFI
198                 || (sipper.totalPowerMah * SECONDS_IN_HOUR) < MIN_POWER_THRESHOLD_MILLI_AMP
199                 || mPowerUsageFeatureProvider.isTypeService(sipper)
200                 || mPowerUsageFeatureProvider.isTypeSystem(sipper);
201     }
202 
203     /**
204      * Calculate the power usage percentage for an app
205      *
206      * @param powerUsageMah   power used by the app
207      * @param totalPowerMah   total power used in the system
208      * @param hiddenPowerMah  power used by no-actionable app that we want to hide, i.e. Screen,
209      *                        Android OS.
210      * @param dischargeAmount The discharge amount calculated by {@link BatteryStats}
211      * @return A percentage value scaled by {@paramref dischargeAmount}
212      * @see BatteryStats#getDischargeAmount(int)
213      */
calculateBatteryPercent(double powerUsageMah, double totalPowerMah, double hiddenPowerMah, int dischargeAmount)214     public double calculateBatteryPercent(double powerUsageMah, double totalPowerMah,
215             double hiddenPowerMah, int dischargeAmount) {
216         if (totalPowerMah == 0) {
217             return 0;
218         }
219 
220         return (powerUsageMah / (totalPowerMah - hiddenPowerMah)) * dischargeAmount;
221     }
222 
223     /**
224      * Sort the {@code usageList} based on {@link BatterySipper#totalPowerMah}
225      * @param usageList
226      */
sortUsageList(List<BatterySipper> usageList)227     public void sortUsageList(List<BatterySipper> usageList) {
228         Collections.sort(usageList, new Comparator<BatterySipper>() {
229             @Override
230             public int compare(BatterySipper a, BatterySipper b) {
231                 return Double.compare(b.totalPowerMah, a.totalPowerMah);
232             }
233         });
234     }
235 
236     /**
237      * Calculate the time since last full charge, including the device off time
238      *
239      * @param batteryStatsHelper utility class that contains the data
240      * @param currentTimeMs      current wall time
241      * @return time in millis
242      */
calculateLastFullChargeTime(BatteryStatsHelper batteryStatsHelper, long currentTimeMs)243     public long calculateLastFullChargeTime(BatteryStatsHelper batteryStatsHelper,
244             long currentTimeMs) {
245         return currentTimeMs - batteryStatsHelper.getStats().getStartClockTime();
246 
247     }
248 
convertUsToMs(long timeUs)249     private long convertUsToMs(long timeUs) {
250         return timeUs / 1000;
251     }
252 
convertMsToUs(long timeMs)253     private long convertMsToUs(long timeMs) {
254         return timeMs * 1000;
255     }
256 
isDataCorrupted()257     private boolean isDataCorrupted() {
258         return mPackageManager == null;
259     }
260 
261     @VisibleForTesting
getForegroundActivityTotalTimeMs(BatteryStats.Uid uid, long rawRealtimeMs)262     long getForegroundActivityTotalTimeMs(BatteryStats.Uid uid, long rawRealtimeMs) {
263         final BatteryStats.Timer timer = uid.getForegroundActivityTimer();
264         if (timer != null) {
265             return timer.getTotalTimeLocked(rawRealtimeMs, BatteryStats.STATS_SINCE_CHARGED);
266         }
267 
268         return 0;
269     }
270 
271 }
272 
273