1 /* 2 * Copyright (C) 2022 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 17 package com.android.settings.fuelgauge.batteryusage; 18 19 import android.content.BroadcastReceiver; 20 import android.content.Context; 21 import android.content.Intent; 22 import android.os.Build; 23 import android.os.SystemClock; 24 import android.util.Log; 25 26 import androidx.annotation.VisibleForTesting; 27 28 import com.android.settings.fuelgauge.BatteryUtils; 29 import com.android.settings.overlay.FeatureFactory; 30 import com.android.settingslib.fuelgauge.BatteryStatus; 31 32 import java.time.Duration; 33 import java.util.concurrent.ExecutorService; 34 import java.util.concurrent.Executors; 35 36 /** A {@link BatteryUsageBroadcastReceiver} for battery usage data requesting. */ 37 public final class BatteryUsageBroadcastReceiver extends BroadcastReceiver { 38 private static final String TAG = "BatteryUsageBroadcastReceiver"; 39 /** An intent action to request Settings to clear cache data. */ 40 public static final String ACTION_CLEAR_BATTERY_CACHE_DATA = 41 "com.android.settings.battery.action.CLEAR_BATTERY_CACHE_DATA"; 42 /** An intent action for power is plugging. */ 43 public static final String ACTION_BATTERY_PLUGGING = 44 "com.android.settings.battery.action.ACTION_BATTERY_PLUGGING"; 45 /** An intent action for power is unplugging. */ 46 public static final String ACTION_BATTERY_UNPLUGGING = 47 "com.android.settings.battery.action.ACTION_BATTERY_UNPLUGGING"; 48 49 @VisibleForTesting 50 static long sBroadcastDelayFromBoot = Duration.ofMinutes(40).toMillis(); 51 @VisibleForTesting 52 static boolean sIsDebugMode = Build.TYPE.equals("userdebug"); 53 54 @VisibleForTesting 55 boolean mFetchBatteryUsageData = false; 56 57 private final ExecutorService mExecutor = Executors.newSingleThreadExecutor(); 58 59 @Override onReceive(Context context, Intent intent)60 public void onReceive(Context context, Intent intent) { 61 if (intent == null || intent.getAction() == null) { 62 return; 63 } 64 final String action = intent.getAction(); 65 Log.d(TAG, "onReceive:" + action); 66 DatabaseUtils.recordDateTime(context, action); 67 final String fullChargeIntentAction = FeatureFactory.getFactory(context) 68 .getPowerUsageFeatureProvider(context) 69 .getFullChargeIntentAction(); 70 switch (action) { 71 case Intent.ACTION_BATTERY_LEVEL_CHANGED: 72 // Only when fullChargeIntentAction is ACTION_BATTERY_LEVEL_CHANGED, 73 // ACTION_BATTERY_LEVEL_CHANGED will be considered as the full charge event and then 74 // start usage events fetching. 75 if (Intent.ACTION_BATTERY_LEVEL_CHANGED.equals(fullChargeIntentAction)) { 76 Log.d(TAG, "fetch data because of event: ACTION_BATTERY_LEVEL_CHANGED"); 77 tryToFetchUsageData(context); 78 } 79 break; 80 case ACTION_BATTERY_PLUGGING: 81 sendBatteryEventData(context, BatteryEventType.POWER_CONNECTED); 82 break; 83 case ACTION_BATTERY_UNPLUGGING: 84 sendBatteryEventData(context, BatteryEventType.POWER_DISCONNECTED); 85 // Only when fullChargeIntentAction is ACTION_POWER_DISCONNECTED, 86 // ACTION_BATTERY_UNPLUGGING will be considered as the full charge event and then 87 // start usage events fetching. 88 if (Intent.ACTION_POWER_DISCONNECTED.equals(fullChargeIntentAction)) { 89 Log.d(TAG, "fetch data because of event: ACTION_POWER_DISCONNECTED"); 90 tryToFetchUsageData(context); 91 } 92 break; 93 case ACTION_CLEAR_BATTERY_CACHE_DATA: 94 if (sIsDebugMode) { 95 BatteryDiffEntry.clearCache(); 96 BatteryEntry.clearUidCache(); 97 } 98 break; 99 } 100 } 101 tryToFetchUsageData(Context context)102 private void tryToFetchUsageData(Context context) { 103 final Intent batteryIntent = BatteryUtils.getBatteryIntent(context); 104 // Returns when battery is not fully charged. 105 if (!BatteryStatus.isCharged(batteryIntent)) { 106 return; 107 } 108 109 final boolean delayHourlyJobWhenBooting = 110 FeatureFactory.getFactory(context) 111 .getPowerUsageFeatureProvider(context) 112 .delayHourlyJobWhenBooting(); 113 final long broadcastDelay = sBroadcastDelayFromBoot - SystemClock.elapsedRealtime(); 114 // If current boot time is smaller than expected delay, cancel sending the broadcast. 115 if (delayHourlyJobWhenBooting && broadcastDelay > 0) { 116 Log.d(TAG, "cancel sendBroadcastToFetchUsageData when broadcastDelay is " 117 + broadcastDelay + "ms."); 118 return; 119 } 120 121 mFetchBatteryUsageData = true; 122 BatteryUsageDataLoader.enqueueWork(context, /*isFullChargeStart=*/ true); 123 BootBroadcastReceiver.invokeJobRecheck(context); 124 } 125 sendBatteryEventData(Context context, BatteryEventType batteryEventType)126 private void sendBatteryEventData(Context context, BatteryEventType batteryEventType) { 127 final long timestamp = System.currentTimeMillis(); 128 final Intent intent = BatteryUtils.getBatteryIntent(context); 129 final int batteryLevel = BatteryStatus.getBatteryLevel(intent); 130 mExecutor.execute(() -> DatabaseUtils.sendBatteryEventData(context, 131 ConvertUtils.convertToBatteryEvent(timestamp, batteryEventType, batteryLevel))); 132 } 133 } 134