com/android/server/am/BatteryExternalStatsWorker.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2017 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.server.am;

 import static android.net.wifi.WifiManager.WIFI_FEATURE_LINK_LAYER_STATS;

 import android.annotation.Nullable;
 import android.bluetooth.BluetoothActivityEnergyInfo;
 import android.bluetooth.BluetoothAdapter;
 import android.content.Context;
 import android.net.wifi.IWifiManager;
 import android.net.wifi.WifiActivityEnergyInfo;
 import android.os.BatteryStats;
 import android.os.Parcelable;
 import android.os.Process;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.os.SynchronousResultReceiver;
 import android.os.SystemClock;
 import android.os.ThreadLocalWorkSource;
 import android.telephony.ModemActivityInfo;
 import android.telephony.TelephonyManager;
 import android.util.IntArray;
 import android.util.Slog;
 import android.util.StatsLog;
 import android.util.TimeUtils;

 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.os.BatteryStatsImpl;
 import com.android.internal.util.function.pooled.PooledLambda;

 import libcore.util.EmptyArray;

 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;

 /**
  * A Worker that fetches data from external sources (WiFi controller, bluetooth chipset) on a
  * dedicated thread and updates BatteryStatsImpl with that information.
  *
  * As much work as possible is done without holding the BatteryStatsImpl lock, and only the
  * readily available data is pushed into BatteryStatsImpl with the lock held.
  */
 class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync {
     private static final String TAG = "BatteryExternalStatsWorker";
     private static final boolean DEBUG = false;

     /**
      * How long to wait on an individual subsystem to return its stats.
      */
     private static final long EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS = 2000;

     // There is some accuracy error in wifi reports so allow some slop in the results.
     private static final long MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS = 750;

     private final ScheduledExecutorService mExecutorService =
             Executors.newSingleThreadScheduledExecutor(
                     (ThreadFactory) r -> {
                         Thread t = new Thread(
                                 () -> {
                                     ThreadLocalWorkSource.setUid(Process.myUid());
                                     r.run();
                                 },
                                 "batterystats-worker");
                         t.setPriority(Thread.NORM_PRIORITY);
                         return t;
                     });

     private final Context mContext;
     private final BatteryStatsImpl mStats;

     @GuardedBy("this")
     private int mUpdateFlags = 0;

     @GuardedBy("this")
     private Future<?> mCurrentFuture = null;

     @GuardedBy("this")
     private String mCurrentReason = null;

     @GuardedBy("this")
     private boolean mOnBattery;

     @GuardedBy("this")
     private boolean mOnBatteryScreenOff;

     @GuardedBy("this")
     private boolean mUseLatestStates = true;

     @GuardedBy("this")
     private final IntArray mUidsToRemove = new IntArray();

     @GuardedBy("this")
     private Future<?> mWakelockChangesUpdate;

     @GuardedBy("this")
     private Future<?> mBatteryLevelSync;

     private final Object mWorkerLock = new Object();

     @GuardedBy("mWorkerLock")
     private IWifiManager mWifiManager = null;

     @GuardedBy("mWorkerLock")
     private TelephonyManager mTelephony = null;

     // WiFi keeps an accumulated total of stats, unlike Bluetooth.
     // Keep the last WiFi stats so we can compute a delta.
     @GuardedBy("mWorkerLock")
     private WifiActivityEnergyInfo mLastInfo =
             new WifiActivityEnergyInfo(0, 0, 0, new long[]{0}, 0, 0, 0, 0);

     /**
      * Timestamp at which all external stats were last collected in
      * {@link SystemClock#elapsedRealtime()} time base.
      */
     @GuardedBy("this")
     private long mLastCollectionTimeStamp;

     BatteryExternalStatsWorker(Context context, BatteryStatsImpl stats) {
         mContext = context;
         mStats = stats;
     }

     @Override
     public synchronized Future<?> scheduleSync(String reason, int flags) {
         return scheduleSyncLocked(reason, flags);
     }

     @Override
     public synchronized Future<?> scheduleCpuSyncDueToRemovedUid(int uid) {
         mUidsToRemove.add(uid);
         return scheduleSyncLocked("remove-uid", UPDATE_CPU);
     }

     @Override
     public synchronized Future<?> scheduleCpuSyncDueToSettingChange() {
         return scheduleSyncLocked("setting-change", UPDATE_CPU);
     }

     @Override
     public Future<?> scheduleReadProcStateCpuTimes(
             boolean onBattery, boolean onBatteryScreenOff, long delayMillis) {
         synchronized (mStats) {
             if (!mStats.trackPerProcStateCpuTimes()) {
                 return null;
             }
         }
         synchronized (BatteryExternalStatsWorker.this) {
             if (!mExecutorService.isShutdown()) {
                 return mExecutorService.schedule(PooledLambda.obtainRunnable(
                         BatteryStatsImpl::updateProcStateCpuTimes,
                         mStats, onBattery, onBatteryScreenOff).recycleOnUse(),
                         delayMillis, TimeUnit.MILLISECONDS);
             }
         }
         return null;
     }

     @Override
     public Future<?> scheduleCopyFromAllUidsCpuTimes(
             boolean onBattery, boolean onBatteryScreenOff) {
         synchronized (mStats) {
             if (!mStats.trackPerProcStateCpuTimes()) {
                 return null;
             }
         }
         synchronized (BatteryExternalStatsWorker.this) {
             if (!mExecutorService.isShutdown()) {
                 return mExecutorService.submit(PooledLambda.obtainRunnable(
                         BatteryStatsImpl::copyFromAllUidsCpuTimes,
                         mStats, onBattery, onBatteryScreenOff).recycleOnUse());
             }
         }
         return null;
     }

     @Override
     public Future<?> scheduleCpuSyncDueToScreenStateChange(
             boolean onBattery, boolean onBatteryScreenOff) {
         synchronized (BatteryExternalStatsWorker.this) {
             if (mCurrentFuture == null || (mUpdateFlags & UPDATE_CPU) == 0) {
                 mOnBattery = onBattery;
                 mOnBatteryScreenOff = onBatteryScreenOff;
                 mUseLatestStates = false;
             }
             return scheduleSyncLocked("screen-state", UPDATE_CPU);
         }
     }

     @Override
     public Future<?> scheduleCpuSyncDueToWakelockChange(long delayMillis) {
         synchronized (BatteryExternalStatsWorker.this) {
             mWakelockChangesUpdate = scheduleDelayedSyncLocked(mWakelockChangesUpdate,
                     () -> {
                         scheduleSync("wakelock-change", UPDATE_CPU);
                         scheduleRunnable(() -> mStats.postBatteryNeedsCpuUpdateMsg());
                     },
                     delayMillis);
             return mWakelockChangesUpdate;
         }
     }

     @Override
     public void cancelCpuSyncDueToWakelockChange() {
         synchronized (BatteryExternalStatsWorker.this) {
             if (mWakelockChangesUpdate != null) {
                 mWakelockChangesUpdate.cancel(false);
                 mWakelockChangesUpdate = null;
             }
         }
     }

     @Override
     public Future<?> scheduleSyncDueToBatteryLevelChange(long delayMillis) {
         synchronized (BatteryExternalStatsWorker.this) {
             mBatteryLevelSync = scheduleDelayedSyncLocked(mBatteryLevelSync,
                     () -> scheduleSync("battery-level", UPDATE_ALL),
                     delayMillis);
             return mBatteryLevelSync;
         }
     }

     @GuardedBy("this")
     private void cancelSyncDueToBatteryLevelChangeLocked() {
         if (mBatteryLevelSync != null) {
             mBatteryLevelSync.cancel(false);
             mBatteryLevelSync = null;
         }
     }

     /**
      * Schedule a sync {@param syncRunnable} with a delay. If there's already a scheduled sync, a
      * new sync won't be scheduled unless it is being scheduled to run immediately (delayMillis=0).
      *
      * @param lastScheduledSync the task which was earlier scheduled to run
      * @param syncRunnable the task that needs to be scheduled to run
      * @param delayMillis time after which {@param syncRunnable} needs to be scheduled
      * @return scheduled {@link Future} which can be used to check if task is completed or to
      *         cancel it if needed
      */
     @GuardedBy("this")
     private Future<?> scheduleDelayedSyncLocked(Future<?> lastScheduledSync, Runnable syncRunnable,
             long delayMillis) {
         if (mExecutorService.isShutdown()) {
             return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
         }

         if (lastScheduledSync != null) {
             // If there's already a scheduled task, leave it as is if we're trying to
             // re-schedule it again with a delay, otherwise cancel and re-schedule it.
             if (delayMillis == 0) {
                 lastScheduledSync.cancel(false);
             } else {
                 return lastScheduledSync;
             }
         }

         return mExecutorService.schedule(syncRunnable, delayMillis, TimeUnit.MILLISECONDS);
     }

     public synchronized Future<?> scheduleWrite() {
         if (mExecutorService.isShutdown()) {
             return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
         }

         scheduleSyncLocked("write", UPDATE_ALL);
         // Since we use a single threaded executor, we can assume the next scheduled task's
         // Future finishes after the sync.
         return mExecutorService.submit(mWriteTask);
     }

     /**
      * Schedules a task to run on the BatteryExternalStatsWorker thread. If scheduling more work
      * within the task, never wait on the resulting Future. This will result in a deadlock.
      */
     public synchronized void scheduleRunnable(Runnable runnable) {
         if (!mExecutorService.isShutdown()) {
             mExecutorService.submit(runnable);
         }
     }

     public void shutdown() {
         mExecutorService.shutdownNow();
     }

     @GuardedBy("this")
     private Future<?> scheduleSyncLocked(String reason, int flags) {
         if (mExecutorService.isShutdown()) {
             return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
         }

         if (mCurrentFuture == null) {
             mUpdateFlags = flags;
             mCurrentReason = reason;
             mCurrentFuture = mExecutorService.submit(mSyncTask);
         }
         mUpdateFlags |= flags;
         return mCurrentFuture;
     }

     long getLastCollectionTimeStamp() {
         synchronized (this) {
             return mLastCollectionTimeStamp;
         }
     }

     private final Runnable mSyncTask = new Runnable() {
         @Override
         public void run() {
             // Capture a snapshot of the state we are meant to process.
             final int updateFlags;
             final String reason;
             final int[] uidsToRemove;
             final boolean onBattery;
             final boolean onBatteryScreenOff;
             final boolean useLatestStates;
             synchronized (BatteryExternalStatsWorker.this) {
                 updateFlags = mUpdateFlags;
                 reason = mCurrentReason;
                 uidsToRemove = mUidsToRemove.size() > 0 ? mUidsToRemove.toArray() : EmptyArray.INT;
                 onBattery = mOnBattery;
                 onBatteryScreenOff = mOnBatteryScreenOff;
                 useLatestStates = mUseLatestStates;
                 mUpdateFlags = 0;
                 mCurrentReason = null;
                 mUidsToRemove.clear();
                 mCurrentFuture = null;
                 mUseLatestStates = true;
                 if ((updateFlags & UPDATE_ALL) != 0) {
                     cancelSyncDueToBatteryLevelChangeLocked();
                 }
                 if ((updateFlags & UPDATE_CPU) != 0) {
                     cancelCpuSyncDueToWakelockChange();
                 }
             }

             try {
                 synchronized (mWorkerLock) {
                     if (DEBUG) {
                         Slog.d(TAG, "begin updateExternalStatsSync reason=" + reason);
                     }
                     try {
                         updateExternalStatsLocked(reason, updateFlags, onBattery,
                                 onBatteryScreenOff, useLatestStates);
                     } finally {
                         if (DEBUG) {
                             Slog.d(TAG, "end updateExternalStatsSync");
                         }
                     }
                 }

                 if ((updateFlags & UPDATE_CPU) != 0) {
                     mStats.copyFromAllUidsCpuTimes();
                 }

                 // Clean up any UIDs if necessary.
                 synchronized (mStats) {
                     for (int uid : uidsToRemove) {
                         StatsLog.write(StatsLog.ISOLATED_UID_CHANGED, -1, uid,
                                 StatsLog.ISOLATED_UID_CHANGED__EVENT__REMOVED);
                         mStats.removeIsolatedUidLocked(uid);
                     }
                     mStats.clearPendingRemovedUids();
                 }
             } catch (Exception e) {
                 Slog.wtf(TAG, "Error updating external stats: ", e);
             }

             synchronized (BatteryExternalStatsWorker.this) {
                 mLastCollectionTimeStamp = SystemClock.elapsedRealtime();
             }
         }
     };

     private final Runnable mWriteTask = new Runnable() {
         @Override
         public void run() {
             synchronized (mStats) {
                 mStats.writeAsyncLocked();
             }
         }
     };

     @GuardedBy("mWorkerLock")
     private void updateExternalStatsLocked(final String reason, int updateFlags,
             boolean onBattery, boolean onBatteryScreenOff, boolean useLatestStates) {
         // We will request data from external processes asynchronously, and wait on a timeout.
         SynchronousResultReceiver wifiReceiver = null;
         SynchronousResultReceiver bluetoothReceiver = null;
         SynchronousResultReceiver modemReceiver = null;
         boolean railUpdated = false;

         if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_WIFI) != 0) {
             // We were asked to fetch WiFi data.
             if (mWifiManager == null) {
                 mWifiManager = IWifiManager.Stub.asInterface(ServiceManager.getService(
                         Context.WIFI_SERVICE));
             }

             if (mWifiManager != null) {
                 try {
                     // Only fetch WiFi power data if it is supported.
                     if ((mWifiManager.getSupportedFeatures() & WIFI_FEATURE_LINK_LAYER_STATS) != 0) {
                         wifiReceiver = new SynchronousResultReceiver("wifi");
                         mWifiManager.requestActivityInfo(wifiReceiver);
                     }
                 } catch (RemoteException e) {
                     // Oh well.
                 }
             }
             synchronized (mStats) {
                 mStats.updateRailStatsLocked();
             }
             railUpdated = true;
         }

         if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_BT) != 0) {
             // We were asked to fetch Bluetooth data.
             final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
             if (adapter != null) {
                 bluetoothReceiver = new SynchronousResultReceiver("bluetooth");
                 adapter.requestControllerActivityEnergyInfo(bluetoothReceiver);
             }
         }

         if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_RADIO) != 0) {
             // We were asked to fetch Telephony data.
             if (mTelephony == null) {
                 mTelephony = TelephonyManager.from(mContext);
             }

             if (mTelephony != null) {
                 modemReceiver = new SynchronousResultReceiver("telephony");
                 mTelephony.requestModemActivityInfo(modemReceiver);
             }
             if (!railUpdated) {
                 synchronized (mStats) {
                     mStats.updateRailStatsLocked();
                 }
             }
         }

         final WifiActivityEnergyInfo wifiInfo = awaitControllerInfo(wifiReceiver);
         final BluetoothActivityEnergyInfo bluetoothInfo = awaitControllerInfo(bluetoothReceiver);
         final ModemActivityInfo modemInfo = awaitControllerInfo(modemReceiver);

         synchronized (mStats) {
             mStats.addHistoryEventLocked(
                     SystemClock.elapsedRealtime(),
                     SystemClock.uptimeMillis(),
                     BatteryStats.HistoryItem.EVENT_COLLECT_EXTERNAL_STATS,
                     reason, 0);

             if ((updateFlags & UPDATE_CPU) != 0) {
                 if (useLatestStates) {
                     onBattery = mStats.isOnBatteryLocked();
                     onBatteryScreenOff = mStats.isOnBatteryScreenOffLocked();
                 }
                 mStats.updateCpuTimeLocked(onBattery, onBatteryScreenOff);
             }

             if ((updateFlags & UPDATE_ALL) != 0) {
                 mStats.updateKernelWakelocksLocked();
                 mStats.updateKernelMemoryBandwidthLocked();
             }

             if ((updateFlags & UPDATE_RPM) != 0) {
                 mStats.updateRpmStatsLocked();
             }

             if (bluetoothInfo != null) {
                 if (bluetoothInfo.isValid()) {
                     mStats.updateBluetoothStateLocked(bluetoothInfo);
                 } else {
                     Slog.w(TAG, "bluetooth info is invalid: " + bluetoothInfo);
                 }
             }
         }

         // WiFi and Modem state are updated without the mStats lock held, because they
         // do some network stats retrieval before internally grabbing the mStats lock.

         if (wifiInfo != null) {
             if (wifiInfo.isValid()) {
                 mStats.updateWifiState(extractDeltaLocked(wifiInfo));
             } else {
                 Slog.w(TAG, "wifi info is invalid: " + wifiInfo);
             }
         }

         if (modemInfo != null) {
             if (modemInfo.isValid()) {
                 mStats.updateMobileRadioState(modemInfo);
             } else {
                 Slog.w(TAG, "modem info is invalid: " + modemInfo);
             }
         }
     }

     /**
      * Helper method to extract the Parcelable controller info from a
      * SynchronousResultReceiver.
      */
     private static <T extends Parcelable> T awaitControllerInfo(
             @Nullable SynchronousResultReceiver receiver) {
         if (receiver == null) {
             return null;
         }

         try {
             final SynchronousResultReceiver.Result result =
                     receiver.awaitResult(EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS);
             if (result.bundle != null) {
                 // This is the final destination for the Bundle.
                 result.bundle.setDefusable(true);

                 final T data = result.bundle.getParcelable(
                         BatteryStats.RESULT_RECEIVER_CONTROLLER_KEY);
                 if (data != null) {
                     return data;
                 }
             }
             Slog.e(TAG, "no controller energy info supplied for " + receiver.getName());
         } catch (TimeoutException e) {
             Slog.w(TAG, "timeout reading " + receiver.getName() + " stats");
         }
         return null;
     }

     @GuardedBy("mWorkerLock")
     private WifiActivityEnergyInfo extractDeltaLocked(WifiActivityEnergyInfo latest) {
         final long timePeriodMs = latest.mTimestamp - mLastInfo.mTimestamp;
         final long lastScanMs = mLastInfo.mControllerScanTimeMs;
         final long lastIdleMs = mLastInfo.mControllerIdleTimeMs;
         final long lastTxMs = mLastInfo.mControllerTxTimeMs;
         final long lastRxMs = mLastInfo.mControllerRxTimeMs;
         final long lastEnergy = mLastInfo.mControllerEnergyUsed;

         // We will modify the last info object to be the delta, and store the new
         // WifiActivityEnergyInfo object as our last one.
         final WifiActivityEnergyInfo delta = mLastInfo;
         delta.mTimestamp = latest.getTimeStamp();
         delta.mStackState = latest.getStackState();

         final long txTimeMs = latest.mControllerTxTimeMs - lastTxMs;
         final long rxTimeMs = latest.mControllerRxTimeMs - lastRxMs;
         final long idleTimeMs = latest.mControllerIdleTimeMs - lastIdleMs;
         final long scanTimeMs = latest.mControllerScanTimeMs - lastScanMs;

         if (txTimeMs < 0 || rxTimeMs < 0 || scanTimeMs < 0 || idleTimeMs < 0) {
             // The stats were reset by the WiFi system (which is why our delta is negative).
             // Returns the unaltered stats. The total on time should not exceed the time
             // duartion between reports.
             final long totalOnTimeMs = latest.mControllerTxTimeMs + latest.mControllerRxTimeMs
                         + latest.mControllerIdleTimeMs;
             if (totalOnTimeMs <= timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) {
                 delta.mControllerEnergyUsed = latest.mControllerEnergyUsed;
                 delta.mControllerRxTimeMs = latest.mControllerRxTimeMs;
                 delta.mControllerTxTimeMs = latest.mControllerTxTimeMs;
                 delta.mControllerIdleTimeMs = latest.mControllerIdleTimeMs;
                 delta.mControllerScanTimeMs = latest.mControllerScanTimeMs;
             } else {
                 delta.mControllerEnergyUsed = 0;
                 delta.mControllerRxTimeMs = 0;
                 delta.mControllerTxTimeMs = 0;
                 delta.mControllerIdleTimeMs = 0;
                 delta.mControllerScanTimeMs = 0;
             }
             Slog.v(TAG, "WiFi energy data was reset, new WiFi energy data is " + delta);
         } else {
             final long totalActiveTimeMs = txTimeMs + rxTimeMs;
             long maxExpectedIdleTimeMs;
             if (totalActiveTimeMs > timePeriodMs) {
                 // Cap the max idle time at zero since the active time consumed the whole time
                 maxExpectedIdleTimeMs = 0;
                 if (totalActiveTimeMs > timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) {
                     StringBuilder sb = new StringBuilder();
                     sb.append("Total Active time ");
                     TimeUtils.formatDuration(totalActiveTimeMs, sb);
                     sb.append(" is longer than sample period ");
                     TimeUtils.formatDuration(timePeriodMs, sb);
                     sb.append(".\n");
                     sb.append("Previous WiFi snapshot: ").append("idle=");
                     TimeUtils.formatDuration(lastIdleMs, sb);
                     sb.append(" rx=");
                     TimeUtils.formatDuration(lastRxMs, sb);
                     sb.append(" tx=");
                     TimeUtils.formatDuration(lastTxMs, sb);
                     sb.append(" e=").append(lastEnergy);
                     sb.append("\n");
                     sb.append("Current WiFi snapshot: ").append("idle=");
                     TimeUtils.formatDuration(latest.mControllerIdleTimeMs, sb);
                     sb.append(" rx=");
                     TimeUtils.formatDuration(latest.mControllerRxTimeMs, sb);
                     sb.append(" tx=");
                     TimeUtils.formatDuration(latest.mControllerTxTimeMs, sb);
                     sb.append(" e=").append(latest.mControllerEnergyUsed);
                     Slog.wtf(TAG, sb.toString());
                 }
             } else {
                 maxExpectedIdleTimeMs = timePeriodMs - totalActiveTimeMs;
             }
             // These times seem to be the most reliable.
             delta.mControllerTxTimeMs = txTimeMs;
             delta.mControllerRxTimeMs = rxTimeMs;
             delta.mControllerScanTimeMs = scanTimeMs;
             // WiFi calculates the idle time as a difference from the on time and the various
             // Rx + Tx times. There seems to be some missing time there because this sometimes
             // becomes negative. Just cap it at 0 and ensure that it is less than the expected idle
             // time from the difference in timestamps.
             // b/21613534
             delta.mControllerIdleTimeMs = Math.min(maxExpectedIdleTimeMs, Math.max(0, idleTimeMs));
             delta.mControllerEnergyUsed = Math.max(0, latest.mControllerEnergyUsed - lastEnergy);
         }

         mLastInfo = latest;
         return delta;
     }
 }
	/*
	* Copyright (C) 2017 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.server.am;

	import static android.net.wifi.WifiManager.WIFI_FEATURE_LINK_LAYER_STATS;

	import android.annotation.Nullable;
	import android.bluetooth.BluetoothActivityEnergyInfo;
	import android.bluetooth.BluetoothAdapter;
	import android.content.Context;
	import android.net.wifi.IWifiManager;
	import android.net.wifi.WifiActivityEnergyInfo;
	import android.os.BatteryStats;
	import android.os.Parcelable;
	import android.os.Process;
	import android.os.RemoteException;
	import android.os.ServiceManager;
	import android.os.SynchronousResultReceiver;
	import android.os.SystemClock;
	import android.os.ThreadLocalWorkSource;
	import android.telephony.ModemActivityInfo;
	import android.telephony.TelephonyManager;
	import android.util.IntArray;
	import android.util.Slog;
	import android.util.StatsLog;
	import android.util.TimeUtils;

	import com.android.internal.annotations.GuardedBy;
	import com.android.internal.os.BatteryStatsImpl;
	import com.android.internal.util.function.pooled.PooledLambda;

	import libcore.util.EmptyArray;

	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.Executors;
	import java.util.concurrent.Future;
	import java.util.concurrent.ScheduledExecutorService;
	import java.util.concurrent.ThreadFactory;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;

	/**
	* A Worker that fetches data from external sources (WiFi controller, bluetooth chipset) on a
	* dedicated thread and updates BatteryStatsImpl with that information.
	*
	* As much work as possible is done without holding the BatteryStatsImpl lock, and only the
	* readily available data is pushed into BatteryStatsImpl with the lock held.
	*/
	class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync {
	private static final String TAG = "BatteryExternalStatsWorker";
	private static final boolean DEBUG = false;

	/**
	* How long to wait on an individual subsystem to return its stats.
	*/
	private static final long EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS = 2000;

	// There is some accuracy error in wifi reports so allow some slop in the results.
	private static final long MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS = 750;

	private final ScheduledExecutorService mExecutorService =
	Executors.newSingleThreadScheduledExecutor(
	(ThreadFactory) r -> {
	Thread t = new Thread(
	() -> {
	ThreadLocalWorkSource.setUid(Process.myUid());
	r.run();
	},
	"batterystats-worker");
	t.setPriority(Thread.NORM_PRIORITY);
	return t;
	});

	private final Context mContext;
	private final BatteryStatsImpl mStats;

	@GuardedBy("this")
	private int mUpdateFlags = 0;

	@GuardedBy("this")
	private Future<?> mCurrentFuture = null;

	@GuardedBy("this")
	private String mCurrentReason = null;

	@GuardedBy("this")
	private boolean mOnBattery;

	@GuardedBy("this")
	private boolean mOnBatteryScreenOff;

	@GuardedBy("this")
	private boolean mUseLatestStates = true;

	@GuardedBy("this")
	private final IntArray mUidsToRemove = new IntArray();

	@GuardedBy("this")
	private Future<?> mWakelockChangesUpdate;

	@GuardedBy("this")
	private Future<?> mBatteryLevelSync;

	private final Object mWorkerLock = new Object();

	@GuardedBy("mWorkerLock")
	private IWifiManager mWifiManager = null;

	@GuardedBy("mWorkerLock")
	private TelephonyManager mTelephony = null;

	// WiFi keeps an accumulated total of stats, unlike Bluetooth.
	// Keep the last WiFi stats so we can compute a delta.
	@GuardedBy("mWorkerLock")
	private WifiActivityEnergyInfo mLastInfo =
	new WifiActivityEnergyInfo(0, 0, 0, new long[]{0}, 0, 0, 0, 0);

	/**
	* Timestamp at which all external stats were last collected in
	* {@link SystemClock#elapsedRealtime()} time base.
	*/
	@GuardedBy("this")
	private long mLastCollectionTimeStamp;

	BatteryExternalStatsWorker(Context context, BatteryStatsImpl stats) {
	mContext = context;
	mStats = stats;
	}

	@Override
	public synchronized Future<?> scheduleSync(String reason, int flags) {
	return scheduleSyncLocked(reason, flags);
	}

	@Override
	public synchronized Future<?> scheduleCpuSyncDueToRemovedUid(int uid) {
	mUidsToRemove.add(uid);
	return scheduleSyncLocked("remove-uid", UPDATE_CPU);
	}

	@Override
	public synchronized Future<?> scheduleCpuSyncDueToSettingChange() {
	return scheduleSyncLocked("setting-change", UPDATE_CPU);
	}

	@Override
	public Future<?> scheduleReadProcStateCpuTimes(
	boolean onBattery, boolean onBatteryScreenOff, long delayMillis) {
	synchronized (mStats) {
	if (!mStats.trackPerProcStateCpuTimes()) {
	return null;
	}
	}
	synchronized (BatteryExternalStatsWorker.this) {
	if (!mExecutorService.isShutdown()) {
	return mExecutorService.schedule(PooledLambda.obtainRunnable(
	BatteryStatsImpl::updateProcStateCpuTimes,
	mStats, onBattery, onBatteryScreenOff).recycleOnUse(),
	delayMillis, TimeUnit.MILLISECONDS);
	}
	}
	return null;
	}

	@Override
	public Future<?> scheduleCopyFromAllUidsCpuTimes(
	boolean onBattery, boolean onBatteryScreenOff) {
	synchronized (mStats) {
	if (!mStats.trackPerProcStateCpuTimes()) {
	return null;
	}
	}
	synchronized (BatteryExternalStatsWorker.this) {
	if (!mExecutorService.isShutdown()) {
	return mExecutorService.submit(PooledLambda.obtainRunnable(
	BatteryStatsImpl::copyFromAllUidsCpuTimes,
	mStats, onBattery, onBatteryScreenOff).recycleOnUse());
	}
	}
	return null;
	}

	@Override
	public Future<?> scheduleCpuSyncDueToScreenStateChange(
	boolean onBattery, boolean onBatteryScreenOff) {
	synchronized (BatteryExternalStatsWorker.this) {
	if (mCurrentFuture == null \|\| (mUpdateFlags & UPDATE_CPU) == 0) {
	mOnBattery = onBattery;
	mOnBatteryScreenOff = onBatteryScreenOff;
	mUseLatestStates = false;
	}
	return scheduleSyncLocked("screen-state", UPDATE_CPU);
	}
	}

	@Override
	public Future<?> scheduleCpuSyncDueToWakelockChange(long delayMillis) {
	synchronized (BatteryExternalStatsWorker.this) {
	mWakelockChangesUpdate = scheduleDelayedSyncLocked(mWakelockChangesUpdate,
	() -> {
	scheduleSync("wakelock-change", UPDATE_CPU);
	scheduleRunnable(() -> mStats.postBatteryNeedsCpuUpdateMsg());
	},
	delayMillis);
	return mWakelockChangesUpdate;
	}
	}

	@Override
	public void cancelCpuSyncDueToWakelockChange() {
	synchronized (BatteryExternalStatsWorker.this) {
	if (mWakelockChangesUpdate != null) {
	mWakelockChangesUpdate.cancel(false);
	mWakelockChangesUpdate = null;
	}
	}
	}

	@Override
	public Future<?> scheduleSyncDueToBatteryLevelChange(long delayMillis) {
	synchronized (BatteryExternalStatsWorker.this) {
	mBatteryLevelSync = scheduleDelayedSyncLocked(mBatteryLevelSync,
	() -> scheduleSync("battery-level", UPDATE_ALL),
	delayMillis);
	return mBatteryLevelSync;
	}
	}

	@GuardedBy("this")
	private void cancelSyncDueToBatteryLevelChangeLocked() {
	if (mBatteryLevelSync != null) {
	mBatteryLevelSync.cancel(false);
	mBatteryLevelSync = null;
	}
	}

	/**
	* Schedule a sync {@param syncRunnable} with a delay. If there's already a scheduled sync, a
	* new sync won't be scheduled unless it is being scheduled to run immediately (delayMillis=0).
	*
	* @param lastScheduledSync the task which was earlier scheduled to run
	* @param syncRunnable the task that needs to be scheduled to run
	* @param delayMillis time after which {@param syncRunnable} needs to be scheduled
	* @return scheduled {@link Future} which can be used to check if task is completed or to
	* cancel it if needed
	*/
	@GuardedBy("this")
	private Future<?> scheduleDelayedSyncLocked(Future<?> lastScheduledSync, Runnable syncRunnable,
	long delayMillis) {
	if (mExecutorService.isShutdown()) {
	return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
	}

	if (lastScheduledSync != null) {
	// If there's already a scheduled task, leave it as is if we're trying to
	// re-schedule it again with a delay, otherwise cancel and re-schedule it.
	if (delayMillis == 0) {
	lastScheduledSync.cancel(false);
	} else {
	return lastScheduledSync;
	}
	}

	return mExecutorService.schedule(syncRunnable, delayMillis, TimeUnit.MILLISECONDS);
	}

	public synchronized Future<?> scheduleWrite() {
	if (mExecutorService.isShutdown()) {
	return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
	}

	scheduleSyncLocked("write", UPDATE_ALL);
	// Since we use a single threaded executor, we can assume the next scheduled task's
	// Future finishes after the sync.
	return mExecutorService.submit(mWriteTask);
	}

	/**
	* Schedules a task to run on the BatteryExternalStatsWorker thread. If scheduling more work
	* within the task, never wait on the resulting Future. This will result in a deadlock.
	*/
	public synchronized void scheduleRunnable(Runnable runnable) {
	if (!mExecutorService.isShutdown()) {
	mExecutorService.submit(runnable);
	}
	}

	public void shutdown() {
	mExecutorService.shutdownNow();
	}

	@GuardedBy("this")
	private Future<?> scheduleSyncLocked(String reason, int flags) {
	if (mExecutorService.isShutdown()) {
	return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
	}

	if (mCurrentFuture == null) {
	mUpdateFlags = flags;
	mCurrentReason = reason;
	mCurrentFuture = mExecutorService.submit(mSyncTask);
	}
	mUpdateFlags \|= flags;
	return mCurrentFuture;
	}

	long getLastCollectionTimeStamp() {
	synchronized (this) {
	return mLastCollectionTimeStamp;
	}
	}

	private final Runnable mSyncTask = new Runnable() {
	@Override
	public void run() {
	// Capture a snapshot of the state we are meant to process.
	final int updateFlags;
	final String reason;
	final int[] uidsToRemove;
	final boolean onBattery;
	final boolean onBatteryScreenOff;
	final boolean useLatestStates;
	synchronized (BatteryExternalStatsWorker.this) {
	updateFlags = mUpdateFlags;
	reason = mCurrentReason;
	uidsToRemove = mUidsToRemove.size() > 0 ? mUidsToRemove.toArray() : EmptyArray.INT;
	onBattery = mOnBattery;
	onBatteryScreenOff = mOnBatteryScreenOff;
	useLatestStates = mUseLatestStates;
	mUpdateFlags = 0;
	mCurrentReason = null;
	mUidsToRemove.clear();
	mCurrentFuture = null;
	mUseLatestStates = true;
	if ((updateFlags & UPDATE_ALL) != 0) {
	cancelSyncDueToBatteryLevelChangeLocked();
	}
	if ((updateFlags & UPDATE_CPU) != 0) {
	cancelCpuSyncDueToWakelockChange();
	}
	}

	try {
	synchronized (mWorkerLock) {
	if (DEBUG) {
	Slog.d(TAG, "begin updateExternalStatsSync reason=" + reason);
	}
	try {
	updateExternalStatsLocked(reason, updateFlags, onBattery,
	onBatteryScreenOff, useLatestStates);
	} finally {
	if (DEBUG) {
	Slog.d(TAG, "end updateExternalStatsSync");
	}
	}
	}

	if ((updateFlags & UPDATE_CPU) != 0) {
	mStats.copyFromAllUidsCpuTimes();
	}

	// Clean up any UIDs if necessary.
	synchronized (mStats) {
	for (int uid : uidsToRemove) {
	StatsLog.write(StatsLog.ISOLATED_UID_CHANGED, -1, uid,
	StatsLog.ISOLATED_UID_CHANGED__EVENT__REMOVED);
	mStats.removeIsolatedUidLocked(uid);
	}
	mStats.clearPendingRemovedUids();
	}
	} catch (Exception e) {
	Slog.wtf(TAG, "Error updating external stats: ", e);
	}

	synchronized (BatteryExternalStatsWorker.this) {
	mLastCollectionTimeStamp = SystemClock.elapsedRealtime();
	}
	}
	};

	private final Runnable mWriteTask = new Runnable() {
	@Override
	public void run() {
	synchronized (mStats) {
	mStats.writeAsyncLocked();
	}
	}
	};

	@GuardedBy("mWorkerLock")
	private void updateExternalStatsLocked(final String reason, int updateFlags,
	boolean onBattery, boolean onBatteryScreenOff, boolean useLatestStates) {
	// We will request data from external processes asynchronously, and wait on a timeout.
	SynchronousResultReceiver wifiReceiver = null;
	SynchronousResultReceiver bluetoothReceiver = null;
	SynchronousResultReceiver modemReceiver = null;
	boolean railUpdated = false;

	if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_WIFI) != 0) {
	// We were asked to fetch WiFi data.
	if (mWifiManager == null) {
	mWifiManager = IWifiManager.Stub.asInterface(ServiceManager.getService(
	Context.WIFI_SERVICE));
	}

	if (mWifiManager != null) {
	try {
	// Only fetch WiFi power data if it is supported.
	if ((mWifiManager.getSupportedFeatures() & WIFI_FEATURE_LINK_LAYER_STATS) != 0) {
	wifiReceiver = new SynchronousResultReceiver("wifi");
	mWifiManager.requestActivityInfo(wifiReceiver);
	}
	} catch (RemoteException e) {
	// Oh well.
	}
	}
	synchronized (mStats) {
	mStats.updateRailStatsLocked();
	}
	railUpdated = true;
	}

	if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_BT) != 0) {
	// We were asked to fetch Bluetooth data.
	final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
	if (adapter != null) {
	bluetoothReceiver = new SynchronousResultReceiver("bluetooth");
	adapter.requestControllerActivityEnergyInfo(bluetoothReceiver);
	}
	}

	if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_RADIO) != 0) {
	// We were asked to fetch Telephony data.
	if (mTelephony == null) {
	mTelephony = TelephonyManager.from(mContext);
	}

	if (mTelephony != null) {
	modemReceiver = new SynchronousResultReceiver("telephony");
	mTelephony.requestModemActivityInfo(modemReceiver);
	}
	if (!railUpdated) {
	synchronized (mStats) {
	mStats.updateRailStatsLocked();
	}
	}
	}

	final WifiActivityEnergyInfo wifiInfo = awaitControllerInfo(wifiReceiver);
	final BluetoothActivityEnergyInfo bluetoothInfo = awaitControllerInfo(bluetoothReceiver);
	final ModemActivityInfo modemInfo = awaitControllerInfo(modemReceiver);

	synchronized (mStats) {
	mStats.addHistoryEventLocked(
	SystemClock.elapsedRealtime(),
	SystemClock.uptimeMillis(),
	BatteryStats.HistoryItem.EVENT_COLLECT_EXTERNAL_STATS,
	reason, 0);

	if ((updateFlags & UPDATE_CPU) != 0) {
	if (useLatestStates) {
	onBattery = mStats.isOnBatteryLocked();
	onBatteryScreenOff = mStats.isOnBatteryScreenOffLocked();
	}
	mStats.updateCpuTimeLocked(onBattery, onBatteryScreenOff);
	}

	if ((updateFlags & UPDATE_ALL) != 0) {
	mStats.updateKernelWakelocksLocked();
	mStats.updateKernelMemoryBandwidthLocked();
	}

	if ((updateFlags & UPDATE_RPM) != 0) {
	mStats.updateRpmStatsLocked();
	}

	if (bluetoothInfo != null) {
	if (bluetoothInfo.isValid()) {
	mStats.updateBluetoothStateLocked(bluetoothInfo);
	} else {
	Slog.w(TAG, "bluetooth info is invalid: " + bluetoothInfo);
	}
	}
	}

	// WiFi and Modem state are updated without the mStats lock held, because they
	// do some network stats retrieval before internally grabbing the mStats lock.

	if (wifiInfo != null) {
	if (wifiInfo.isValid()) {
	mStats.updateWifiState(extractDeltaLocked(wifiInfo));
	} else {
	Slog.w(TAG, "wifi info is invalid: " + wifiInfo);
	}
	}

	if (modemInfo != null) {
	if (modemInfo.isValid()) {
	mStats.updateMobileRadioState(modemInfo);
	} else {
	Slog.w(TAG, "modem info is invalid: " + modemInfo);
	}
	}
	}

	/**
	* Helper method to extract the Parcelable controller info from a
	* SynchronousResultReceiver.
	*/
	private static <T extends Parcelable> T awaitControllerInfo(
	@Nullable SynchronousResultReceiver receiver) {
	if (receiver == null) {
	return null;
	}

	try {
	final SynchronousResultReceiver.Result result =
	receiver.awaitResult(EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS);
	if (result.bundle != null) {
	// This is the final destination for the Bundle.
	result.bundle.setDefusable(true);

	final T data = result.bundle.getParcelable(
	BatteryStats.RESULT_RECEIVER_CONTROLLER_KEY);
	if (data != null) {
	return data;
	}
	}
	Slog.e(TAG, "no controller energy info supplied for " + receiver.getName());
	} catch (TimeoutException e) {
	Slog.w(TAG, "timeout reading " + receiver.getName() + " stats");
	}
	return null;
	}

	@GuardedBy("mWorkerLock")
	private WifiActivityEnergyInfo extractDeltaLocked(WifiActivityEnergyInfo latest) {
	final long timePeriodMs = latest.mTimestamp - mLastInfo.mTimestamp;
	final long lastScanMs = mLastInfo.mControllerScanTimeMs;
	final long lastIdleMs = mLastInfo.mControllerIdleTimeMs;
	final long lastTxMs = mLastInfo.mControllerTxTimeMs;
	final long lastRxMs = mLastInfo.mControllerRxTimeMs;
	final long lastEnergy = mLastInfo.mControllerEnergyUsed;

	// We will modify the last info object to be the delta, and store the new
	// WifiActivityEnergyInfo object as our last one.
	final WifiActivityEnergyInfo delta = mLastInfo;
	delta.mTimestamp = latest.getTimeStamp();
	delta.mStackState = latest.getStackState();

	final long txTimeMs = latest.mControllerTxTimeMs - lastTxMs;
	final long rxTimeMs = latest.mControllerRxTimeMs - lastRxMs;
	final long idleTimeMs = latest.mControllerIdleTimeMs - lastIdleMs;
	final long scanTimeMs = latest.mControllerScanTimeMs - lastScanMs;

	if (txTimeMs < 0 \|\| rxTimeMs < 0 \|\| scanTimeMs < 0 \|\| idleTimeMs < 0) {
	// The stats were reset by the WiFi system (which is why our delta is negative).
	// Returns the unaltered stats. The total on time should not exceed the time
	// duartion between reports.
	final long totalOnTimeMs = latest.mControllerTxTimeMs + latest.mControllerRxTimeMs
	+ latest.mControllerIdleTimeMs;
	if (totalOnTimeMs <= timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) {
	delta.mControllerEnergyUsed = latest.mControllerEnergyUsed;
	delta.mControllerRxTimeMs = latest.mControllerRxTimeMs;
	delta.mControllerTxTimeMs = latest.mControllerTxTimeMs;
	delta.mControllerIdleTimeMs = latest.mControllerIdleTimeMs;
	delta.mControllerScanTimeMs = latest.mControllerScanTimeMs;
	} else {
	delta.mControllerEnergyUsed = 0;
	delta.mControllerRxTimeMs = 0;
	delta.mControllerTxTimeMs = 0;
	delta.mControllerIdleTimeMs = 0;
	delta.mControllerScanTimeMs = 0;
	}
	Slog.v(TAG, "WiFi energy data was reset, new WiFi energy data is " + delta);
	} else {
	final long totalActiveTimeMs = txTimeMs + rxTimeMs;
	long maxExpectedIdleTimeMs;
	if (totalActiveTimeMs > timePeriodMs) {
	// Cap the max idle time at zero since the active time consumed the whole time
	maxExpectedIdleTimeMs = 0;
	if (totalActiveTimeMs > timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) {
	StringBuilder sb = new StringBuilder();
	sb.append("Total Active time ");
	TimeUtils.formatDuration(totalActiveTimeMs, sb);
	sb.append(" is longer than sample period ");
	TimeUtils.formatDuration(timePeriodMs, sb);
	sb.append(".\n");
	sb.append("Previous WiFi snapshot: ").append("idle=");
	TimeUtils.formatDuration(lastIdleMs, sb);
	sb.append(" rx=");
	TimeUtils.formatDuration(lastRxMs, sb);
	sb.append(" tx=");
	TimeUtils.formatDuration(lastTxMs, sb);
	sb.append(" e=").append(lastEnergy);
	sb.append("\n");
	sb.append("Current WiFi snapshot: ").append("idle=");
	TimeUtils.formatDuration(latest.mControllerIdleTimeMs, sb);
	sb.append(" rx=");
	TimeUtils.formatDuration(latest.mControllerRxTimeMs, sb);
	sb.append(" tx=");
	TimeUtils.formatDuration(latest.mControllerTxTimeMs, sb);
	sb.append(" e=").append(latest.mControllerEnergyUsed);
	Slog.wtf(TAG, sb.toString());
	}
	} else {
	maxExpectedIdleTimeMs = timePeriodMs - totalActiveTimeMs;
	}
	// These times seem to be the most reliable.
	delta.mControllerTxTimeMs = txTimeMs;
	delta.mControllerRxTimeMs = rxTimeMs;
	delta.mControllerScanTimeMs = scanTimeMs;
	// WiFi calculates the idle time as a difference from the on time and the various
	// Rx + Tx times. There seems to be some missing time there because this sometimes
	// becomes negative. Just cap it at 0 and ensure that it is less than the expected idle
	// time from the difference in timestamps.
	// b/21613534
	delta.mControllerIdleTimeMs = Math.min(maxExpectedIdleTimeMs, Math.max(0, idleTimeMs));
	delta.mControllerEnergyUsed = Math.max(0, latest.mControllerEnergyUsed - lastEnergy);
	}

	mLastInfo = latest;
	return delta;
	}
	}