1 /* 2 * Copyright (C) 2006-2007 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.server.am; 18 19 import static android.Manifest.permission.BATTERY_STATS; 20 import static android.Manifest.permission.DEVICE_POWER; 21 import static android.Manifest.permission.NETWORK_STACK; 22 import static android.Manifest.permission.POWER_SAVER; 23 import static android.Manifest.permission.UPDATE_DEVICE_STATS; 24 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED; 25 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR; 26 import static android.net.NetworkCapabilities.TRANSPORT_WIFI; 27 import static android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK; 28 import static android.os.BatteryStats.POWER_DATA_UNAVAILABLE; 29 30 import static com.android.internal.util.ConcurrentUtils.DIRECT_EXECUTOR; 31 32 import android.annotation.EnforcePermission; 33 import android.annotation.NonNull; 34 import android.annotation.RequiresNoPermission; 35 import android.annotation.SuppressLint; 36 import android.app.AlarmManager; 37 import android.app.StatsManager; 38 import android.app.usage.NetworkStatsManager; 39 import android.bluetooth.BluetoothActivityEnergyInfo; 40 import android.content.ContentResolver; 41 import android.content.Context; 42 import android.content.pm.ApplicationInfo; 43 import android.content.pm.PackageManager; 44 import android.hardware.Sensor; 45 import android.hardware.SensorManager; 46 import android.hardware.power.stats.PowerEntity; 47 import android.hardware.power.stats.State; 48 import android.hardware.power.stats.StateResidency; 49 import android.hardware.power.stats.StateResidencyResult; 50 import android.net.ConnectivityManager; 51 import android.net.INetworkManagementEventObserver; 52 import android.net.Network; 53 import android.net.NetworkCapabilities; 54 import android.os.BatteryConsumer; 55 import android.os.BatteryManagerInternal; 56 import android.os.BatteryStats; 57 import android.os.BatteryStatsInternal; 58 import android.os.BatteryStatsInternal.CpuWakeupSubsystem; 59 import android.os.BatteryUsageStats; 60 import android.os.BatteryUsageStatsQuery; 61 import android.os.Binder; 62 import android.os.BluetoothBatteryStats; 63 import android.os.Bundle; 64 import android.os.Handler; 65 import android.os.HandlerThread; 66 import android.os.IBinder; 67 import android.os.INetworkManagementService; 68 import android.os.Parcel; 69 import android.os.ParcelFormatException; 70 import android.os.PowerManager.ServiceType; 71 import android.os.PowerManagerInternal; 72 import android.os.PowerSaveState; 73 import android.os.Process; 74 import android.os.RemoteException; 75 import android.os.ResultReceiver; 76 import android.os.ServiceManager; 77 import android.os.SystemClock; 78 import android.os.Trace; 79 import android.os.UserHandle; 80 import android.os.WakeLockStats; 81 import android.os.WorkSource; 82 import android.os.connectivity.CellularBatteryStats; 83 import android.os.connectivity.GpsBatteryStats; 84 import android.os.connectivity.WifiActivityEnergyInfo; 85 import android.os.connectivity.WifiBatteryStats; 86 import android.os.health.HealthStatsParceler; 87 import android.os.health.HealthStatsWriter; 88 import android.os.health.UidHealthStats; 89 import android.power.PowerStatsInternal; 90 import android.provider.DeviceConfig; 91 import android.provider.Settings; 92 import android.telephony.DataConnectionRealTimeInfo; 93 import android.telephony.ModemActivityInfo; 94 import android.telephony.NetworkRegistrationInfo; 95 import android.telephony.SignalStrength; 96 import android.telephony.TelephonyManager; 97 import android.util.AtomicFile; 98 import android.util.IndentingPrintWriter; 99 import android.util.Slog; 100 import android.util.StatsEvent; 101 102 import com.android.internal.R; 103 import com.android.internal.annotations.GuardedBy; 104 import com.android.internal.app.IBatteryStats; 105 import com.android.internal.os.BinderCallsStats; 106 import com.android.internal.os.Clock; 107 import com.android.internal.os.CpuScalingPolicies; 108 import com.android.internal.os.CpuScalingPolicyReader; 109 import com.android.internal.os.MonotonicClock; 110 import com.android.internal.os.PowerProfile; 111 import com.android.internal.os.RailStats; 112 import com.android.internal.os.RpmStats; 113 import com.android.internal.util.DumpUtils; 114 import com.android.internal.util.FrameworkStatsLog; 115 import com.android.internal.util.ParseUtils; 116 import com.android.internal.util.function.pooled.PooledLambda; 117 import com.android.modules.utils.build.SdkLevel; 118 import com.android.net.module.util.NetworkCapabilitiesUtils; 119 import com.android.server.LocalServices; 120 import com.android.server.Watchdog; 121 import com.android.server.net.BaseNetworkObserver; 122 import com.android.server.pm.UserManagerInternal; 123 import com.android.server.power.optimization.Flags; 124 import com.android.server.power.stats.AggregatedPowerStatsConfig; 125 import com.android.server.power.stats.AudioPowerStatsProcessor; 126 import com.android.server.power.stats.BatteryExternalStatsWorker; 127 import com.android.server.power.stats.BatteryStatsDumpHelperImpl; 128 import com.android.server.power.stats.BatteryStatsImpl; 129 import com.android.server.power.stats.BatteryUsageStatsProvider; 130 import com.android.server.power.stats.BluetoothPowerStatsProcessor; 131 import com.android.server.power.stats.CameraPowerStatsProcessor; 132 import com.android.server.power.stats.CpuPowerStatsProcessor; 133 import com.android.server.power.stats.FlashlightPowerStatsProcessor; 134 import com.android.server.power.stats.GnssPowerStatsProcessor; 135 import com.android.server.power.stats.MobileRadioPowerStatsProcessor; 136 import com.android.server.power.stats.PhoneCallPowerStatsProcessor; 137 import com.android.server.power.stats.PowerStatsAggregator; 138 import com.android.server.power.stats.PowerStatsExporter; 139 import com.android.server.power.stats.PowerStatsScheduler; 140 import com.android.server.power.stats.PowerStatsStore; 141 import com.android.server.power.stats.PowerStatsUidResolver; 142 import com.android.server.power.stats.SystemServerCpuThreadReader.SystemServiceCpuThreadTimes; 143 import com.android.server.power.stats.VideoPowerStatsProcessor; 144 import com.android.server.power.stats.WifiPowerStatsProcessor; 145 import com.android.server.power.stats.wakeups.CpuWakeupStats; 146 147 import java.io.File; 148 import java.io.FileDescriptor; 149 import java.io.FileOutputStream; 150 import java.io.IOException; 151 import java.io.InputStream; 152 import java.io.PrintWriter; 153 import java.nio.ByteBuffer; 154 import java.nio.CharBuffer; 155 import java.nio.charset.CharsetDecoder; 156 import java.nio.charset.CodingErrorAction; 157 import java.nio.charset.StandardCharsets; 158 import java.util.Arrays; 159 import java.util.Collection; 160 import java.util.HashMap; 161 import java.util.List; 162 import java.util.Map; 163 import java.util.Objects; 164 import java.util.Properties; 165 import java.util.concurrent.CancellationException; 166 import java.util.concurrent.CountDownLatch; 167 import java.util.concurrent.ExecutionException; 168 import java.util.concurrent.Future; 169 import java.util.concurrent.TimeUnit; 170 import java.util.regex.Matcher; 171 import java.util.regex.Pattern; 172 173 /** 174 * All information we are collecting about things that can happen that impact 175 * battery life. 176 */ 177 public final class BatteryStatsService extends IBatteryStats.Stub 178 implements PowerManagerInternal.LowPowerModeListener, 179 BatteryStatsImpl.PlatformIdleStateCallback, 180 BatteryStatsImpl.EnergyStatsRetriever, 181 Watchdog.Monitor { 182 static final String TAG = "BatteryStatsService"; 183 static final String TRACE_TRACK_WAKEUP_REASON = "wakeup_reason"; 184 static final boolean DBG = false; 185 186 private static IBatteryStats sService; 187 188 private final PowerProfile mPowerProfile; 189 private final CpuScalingPolicies mCpuScalingPolicies; 190 private final MonotonicClock mMonotonicClock; 191 private final BatteryStatsImpl.BatteryStatsConfig mBatteryStatsConfig; 192 final BatteryStatsImpl mStats; 193 final CpuWakeupStats mCpuWakeupStats; 194 private final PowerStatsStore mPowerStatsStore; 195 private final PowerStatsScheduler mPowerStatsScheduler; 196 private final BatteryStatsImpl.UserInfoProvider mUserManagerUserInfoProvider; 197 private final Context mContext; 198 private final BatteryExternalStatsWorker mWorker; 199 private final BatteryUsageStatsProvider mBatteryUsageStatsProvider; 200 private final AtomicFile mConfigFile; 201 private final BatteryStats.BatteryStatsDumpHelper mDumpHelper; 202 private final PowerStatsUidResolver mPowerStatsUidResolver = new PowerStatsUidResolver(); 203 private final AggregatedPowerStatsConfig mAggregatedPowerStatsConfig; 204 205 private volatile boolean mMonitorEnabled = true; 206 getRailEnergyPowerStats(RailStats railStats)207 private native void getRailEnergyPowerStats(RailStats railStats); 208 private CharsetDecoder mDecoderStat = StandardCharsets.UTF_8 209 .newDecoder() 210 .onMalformedInput(CodingErrorAction.REPLACE) 211 .onUnmappableCharacter(CodingErrorAction.REPLACE) 212 .replaceWith("?"); 213 private static final int MAX_LOW_POWER_STATS_SIZE = 32768; 214 private static final int POWER_STATS_QUERY_TIMEOUT_MILLIS = 2000; 215 private static final String DEVICE_CONFIG_NAMESPACE = "backstage_power"; 216 private static final String MIN_CONSUMED_POWER_THRESHOLD_KEY = "min_consumed_power_threshold"; 217 private static final String EMPTY = "Empty"; 218 219 private final HandlerThread mHandlerThread; 220 private final Handler mHandler; 221 private final Object mLock = new Object(); 222 223 private final Object mPowerStatsLock = new Object(); 224 @GuardedBy("mPowerStatsLock") 225 private PowerStatsInternal mPowerStatsInternal = null; 226 @GuardedBy("mPowerStatsLock") 227 private Map<Integer, String> mEntityNames = new HashMap(); 228 @GuardedBy("mPowerStatsLock") 229 private Map<Integer, Map<Integer, String>> mStateNames = new HashMap(); 230 231 @GuardedBy("mStats") 232 private int mLastPowerStateFromRadio = DataConnectionRealTimeInfo.DC_POWER_STATE_LOW; 233 @GuardedBy("mStats") 234 private int mLastPowerStateFromWifi = DataConnectionRealTimeInfo.DC_POWER_STATE_LOW; 235 private final INetworkManagementEventObserver mActivityChangeObserver = 236 new BaseNetworkObserver() { 237 @Override 238 public void interfaceClassDataActivityChanged(int transportType, boolean active, 239 long tsNanos, int uid) { 240 final int powerState = active 241 ? DataConnectionRealTimeInfo.DC_POWER_STATE_HIGH 242 : DataConnectionRealTimeInfo.DC_POWER_STATE_LOW; 243 final long timestampNanos; 244 if (tsNanos <= 0) { 245 timestampNanos = SystemClock.elapsedRealtimeNanos(); 246 } else { 247 timestampNanos = tsNanos; 248 } 249 250 switch (transportType) { 251 case NetworkCapabilities.TRANSPORT_CELLULAR: 252 noteMobileRadioPowerState(powerState, timestampNanos, uid); 253 break; 254 case NetworkCapabilities.TRANSPORT_WIFI: 255 noteWifiRadioPowerState(powerState, timestampNanos, uid); 256 break; 257 default: 258 Slog.d(TAG, "Received unexpected transport in " 259 + "interfaceClassDataActivityChanged unexpected type: " 260 + transportType); 261 } 262 } 263 }; 264 265 private BatteryManagerInternal mBatteryManagerInternal; 266 populatePowerEntityMaps()267 private void populatePowerEntityMaps() { 268 PowerEntity[] entities = mPowerStatsInternal.getPowerEntityInfo(); 269 if (entities == null) { 270 return; 271 } 272 273 for (int i = 0; i < entities.length; i++) { 274 final PowerEntity entity = entities[i]; 275 Map<Integer, String> states = new HashMap(); 276 for (int j = 0; j < entity.states.length; j++) { 277 final State state = entity.states[j]; 278 states.put(state.id, state.name); 279 } 280 281 mEntityNames.put(entity.id, entity.name); 282 mStateNames.put(entity.id, states); 283 } 284 } 285 286 /** 287 * Replaces the information in the given rpmStats with up-to-date information. 288 */ 289 @Override fillLowPowerStats(RpmStats rpmStats)290 public void fillLowPowerStats(RpmStats rpmStats) { 291 synchronized (mPowerStatsLock) { 292 if (mPowerStatsInternal == null || mEntityNames.isEmpty() || mStateNames.isEmpty()) { 293 return; 294 } 295 } 296 297 final StateResidencyResult[] results; 298 try { 299 results = mPowerStatsInternal.getStateResidencyAsync(new int[0]) 300 .get(POWER_STATS_QUERY_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS); 301 } catch (Exception e) { 302 Slog.e(TAG, "Failed to getStateResidencyAsync", e); 303 return; 304 } 305 306 if (results == null) return; 307 308 for (int i = 0; i < results.length; i++) { 309 final StateResidencyResult result = results[i]; 310 RpmStats.PowerStateSubsystem subsystem = 311 rpmStats.getSubsystem(mEntityNames.get(result.id)); 312 313 for (int j = 0; j < result.stateResidencyData.length; j++) { 314 final StateResidency stateResidency = result.stateResidencyData[j]; 315 subsystem.putState(mStateNames.get(result.id).get(stateResidency.id), 316 stateResidency.totalTimeInStateMs, 317 (int) stateResidency.totalStateEntryCount); 318 } 319 } 320 } 321 322 @Override fillRailDataStats(RailStats railStats)323 public void fillRailDataStats(RailStats railStats) { 324 if (DBG) Slog.d(TAG, "begin getRailEnergyPowerStats"); 325 try { 326 getRailEnergyPowerStats(railStats); 327 } finally { 328 if (DBG) Slog.d(TAG, "end getRailEnergyPowerStats"); 329 } 330 } 331 332 @Override getSubsystemLowPowerStats()333 public String getSubsystemLowPowerStats() { 334 synchronized (mPowerStatsLock) { 335 if (mPowerStatsInternal == null || mEntityNames.isEmpty() || mStateNames.isEmpty()) { 336 return EMPTY; 337 } 338 } 339 340 final StateResidencyResult[] results; 341 try { 342 results = mPowerStatsInternal.getStateResidencyAsync(new int[0]) 343 .get(POWER_STATS_QUERY_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS); 344 } catch (Exception e) { 345 Slog.e(TAG, "Failed to getStateResidencyAsync", e); 346 return EMPTY; 347 } 348 349 if (results == null || results.length == 0) return EMPTY; 350 351 int charsLeft = MAX_LOW_POWER_STATS_SIZE; 352 StringBuilder builder = new StringBuilder("SubsystemPowerState"); 353 for (int i = 0; i < results.length; i++) { 354 final StateResidencyResult result = results[i]; 355 StringBuilder subsystemBuilder = new StringBuilder(); 356 subsystemBuilder.append(" subsystem_" + i); 357 subsystemBuilder.append(" name=" + mEntityNames.get(result.id)); 358 359 for (int j = 0; j < result.stateResidencyData.length; j++) { 360 final StateResidency stateResidency = result.stateResidencyData[j]; 361 subsystemBuilder.append(" state_" + j); 362 subsystemBuilder.append(" name=" + mStateNames.get(result.id).get( 363 stateResidency.id)); 364 subsystemBuilder.append(" time=" + stateResidency.totalTimeInStateMs); 365 subsystemBuilder.append(" count=" + stateResidency.totalStateEntryCount); 366 subsystemBuilder.append(" last entry=" + stateResidency.lastEntryTimestampMs); 367 } 368 369 if (subsystemBuilder.length() <= charsLeft) { 370 charsLeft -= subsystemBuilder.length(); 371 builder.append(subsystemBuilder); 372 } else { 373 Slog.e(TAG, "getSubsystemLowPowerStats: buffer not enough"); 374 break; 375 } 376 } 377 378 return builder.toString(); 379 } 380 381 private ConnectivityManager.NetworkCallback mNetworkCallback = 382 new ConnectivityManager.NetworkCallback() { 383 @Override 384 public void onCapabilitiesChanged(@NonNull Network network, 385 @NonNull NetworkCapabilities networkCapabilities) { 386 final String state = networkCapabilities.hasCapability(NET_CAPABILITY_NOT_SUSPENDED) 387 ? "CONNECTED" : "SUSPENDED"; 388 noteConnectivityChanged(NetworkCapabilitiesUtils.getDisplayTransport( 389 networkCapabilities.getTransportTypes()), state); 390 } 391 392 @Override 393 public void onLost(Network network) { 394 noteConnectivityChanged(-1, "DISCONNECTED"); 395 } 396 }; 397 BatteryStatsService(Context context, File systemDir)398 BatteryStatsService(Context context, File systemDir) { 399 mContext = context; 400 mUserManagerUserInfoProvider = new BatteryStatsImpl.UserInfoProvider() { 401 private UserManagerInternal umi; 402 @Override 403 public int[] getUserIds() { 404 if (umi == null) { 405 umi = LocalServices.getService(UserManagerInternal.class); 406 } 407 return (umi != null) ? umi.getUserIds() : null; 408 } 409 }; 410 mHandlerThread = new HandlerThread("batterystats-handler"); 411 mHandlerThread.start(); 412 mHandler = new Handler(mHandlerThread.getLooper()); 413 414 mMonotonicClock = new MonotonicClock(new File(systemDir, "monotonic_clock.xml")); 415 mPowerProfile = new PowerProfile(context); 416 mCpuScalingPolicies = new CpuScalingPolicyReader().read(); 417 418 final boolean resetOnUnplugHighBatteryLevel = context.getResources().getBoolean( 419 com.android.internal.R.bool.config_batteryStatsResetOnUnplugHighBatteryLevel); 420 final boolean resetOnUnplugAfterSignificantCharge = context.getResources().getBoolean( 421 com.android.internal.R.bool.config_batteryStatsResetOnUnplugAfterSignificantCharge); 422 BatteryStatsImpl.BatteryStatsConfig.Builder batteryStatsConfigBuilder = 423 new BatteryStatsImpl.BatteryStatsConfig.Builder() 424 .setResetOnUnplugHighBatteryLevel(resetOnUnplugHighBatteryLevel) 425 .setResetOnUnplugAfterSignificantCharge( 426 resetOnUnplugAfterSignificantCharge); 427 setPowerStatsThrottlePeriods(batteryStatsConfigBuilder, context.getResources().getString( 428 com.android.internal.R.string.config_powerStatsThrottlePeriods)); 429 mBatteryStatsConfig = batteryStatsConfigBuilder.build(); 430 mStats = new BatteryStatsImpl(mBatteryStatsConfig, Clock.SYSTEM_CLOCK, mMonotonicClock, 431 systemDir, mHandler, this, this, mUserManagerUserInfoProvider, mPowerProfile, 432 mCpuScalingPolicies, mPowerStatsUidResolver); 433 mWorker = new BatteryExternalStatsWorker(context, mStats); 434 mStats.setExternalStatsSyncLocked(mWorker); 435 mStats.setRadioScanningTimeoutLocked(mContext.getResources().getInteger( 436 com.android.internal.R.integer.config_radioScanningTimeout) * 1000L); 437 if (!Flags.disableSystemServicePowerAttr()) { 438 mStats.startTrackingSystemServerCpuTime(); 439 } 440 441 mAggregatedPowerStatsConfig = createAggregatedPowerStatsConfig(); 442 mPowerStatsStore = new PowerStatsStore(systemDir, mHandler, mAggregatedPowerStatsConfig); 443 mPowerStatsScheduler = createPowerStatsScheduler(mContext); 444 PowerStatsExporter powerStatsExporter = 445 new PowerStatsExporter(mPowerStatsStore, 446 new PowerStatsAggregator(mAggregatedPowerStatsConfig, mStats.getHistory())); 447 mBatteryUsageStatsProvider = new BatteryUsageStatsProvider(context, 448 powerStatsExporter, mPowerProfile, mCpuScalingPolicies, 449 mPowerStatsStore, Clock.SYSTEM_CLOCK); 450 mStats.saveBatteryUsageStatsOnReset(mBatteryUsageStatsProvider, mPowerStatsStore); 451 mDumpHelper = new BatteryStatsDumpHelperImpl(mBatteryUsageStatsProvider); 452 mCpuWakeupStats = new CpuWakeupStats(context, R.xml.irq_device_map, mHandler); 453 mConfigFile = new AtomicFile(new File(systemDir, "battery_usage_stats_config")); 454 } 455 createPowerStatsScheduler(Context context)456 private PowerStatsScheduler createPowerStatsScheduler(Context context) { 457 final long aggregatedPowerStatsSpanDuration = context.getResources().getInteger( 458 com.android.internal.R.integer.config_aggregatedPowerStatsSpanDuration); 459 final long powerStatsAggregationPeriod = context.getResources().getInteger( 460 com.android.internal.R.integer.config_powerStatsAggregationPeriod); 461 PowerStatsScheduler.AlarmScheduler alarmScheduler = 462 (triggerAtMillis, tag, onAlarmListener, aHandler) -> { 463 AlarmManager alarmManager = mContext.getSystemService(AlarmManager.class); 464 alarmManager.set(AlarmManager.ELAPSED_REALTIME, triggerAtMillis, tag, 465 onAlarmListener, aHandler); 466 }; 467 return new PowerStatsScheduler(mStats::schedulePowerStatsSampleCollection, 468 new PowerStatsAggregator(mAggregatedPowerStatsConfig, 469 mStats.getHistory()), aggregatedPowerStatsSpanDuration, 470 powerStatsAggregationPeriod, mPowerStatsStore, alarmScheduler, Clock.SYSTEM_CLOCK, 471 mMonotonicClock, () -> mStats.getHistory().getStartTime(), mHandler); 472 } 473 createAggregatedPowerStatsConfig()474 private AggregatedPowerStatsConfig createAggregatedPowerStatsConfig() { 475 AggregatedPowerStatsConfig config = new AggregatedPowerStatsConfig(); 476 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_CPU) 477 .trackDeviceStates( 478 AggregatedPowerStatsConfig.STATE_POWER, 479 AggregatedPowerStatsConfig.STATE_SCREEN) 480 .trackUidStates( 481 AggregatedPowerStatsConfig.STATE_POWER, 482 AggregatedPowerStatsConfig.STATE_SCREEN, 483 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 484 .setProcessor( 485 new CpuPowerStatsProcessor(mPowerProfile, mCpuScalingPolicies)); 486 487 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO) 488 .trackDeviceStates( 489 AggregatedPowerStatsConfig.STATE_POWER, 490 AggregatedPowerStatsConfig.STATE_SCREEN) 491 .trackUidStates( 492 AggregatedPowerStatsConfig.STATE_POWER, 493 AggregatedPowerStatsConfig.STATE_SCREEN, 494 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 495 .setProcessor( 496 new MobileRadioPowerStatsProcessor(mPowerProfile)); 497 498 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_PHONE, 499 BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO) 500 .setProcessor(new PhoneCallPowerStatsProcessor()); 501 502 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_WIFI) 503 .trackDeviceStates( 504 AggregatedPowerStatsConfig.STATE_POWER, 505 AggregatedPowerStatsConfig.STATE_SCREEN) 506 .trackUidStates( 507 AggregatedPowerStatsConfig.STATE_POWER, 508 AggregatedPowerStatsConfig.STATE_SCREEN, 509 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 510 .setProcessor( 511 new WifiPowerStatsProcessor(mPowerProfile)); 512 513 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_BLUETOOTH) 514 .trackDeviceStates( 515 AggregatedPowerStatsConfig.STATE_POWER, 516 AggregatedPowerStatsConfig.STATE_SCREEN) 517 .trackUidStates( 518 AggregatedPowerStatsConfig.STATE_POWER, 519 AggregatedPowerStatsConfig.STATE_SCREEN, 520 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 521 .setProcessor( 522 new BluetoothPowerStatsProcessor(mPowerProfile)); 523 524 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_AUDIO) 525 .trackDeviceStates( 526 AggregatedPowerStatsConfig.STATE_POWER, 527 AggregatedPowerStatsConfig.STATE_SCREEN) 528 .trackUidStates( 529 AggregatedPowerStatsConfig.STATE_POWER, 530 AggregatedPowerStatsConfig.STATE_SCREEN, 531 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 532 .setProcessor( 533 new AudioPowerStatsProcessor(mPowerProfile, mPowerStatsUidResolver)); 534 535 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_VIDEO) 536 .trackDeviceStates( 537 AggregatedPowerStatsConfig.STATE_POWER, 538 AggregatedPowerStatsConfig.STATE_SCREEN) 539 .trackUidStates( 540 AggregatedPowerStatsConfig.STATE_POWER, 541 AggregatedPowerStatsConfig.STATE_SCREEN, 542 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 543 .setProcessor(new VideoPowerStatsProcessor(mPowerProfile, mPowerStatsUidResolver)); 544 545 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_FLASHLIGHT) 546 .trackDeviceStates( 547 AggregatedPowerStatsConfig.STATE_POWER, 548 AggregatedPowerStatsConfig.STATE_SCREEN) 549 .trackUidStates( 550 AggregatedPowerStatsConfig.STATE_POWER, 551 AggregatedPowerStatsConfig.STATE_SCREEN, 552 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 553 .setProcessor( 554 new FlashlightPowerStatsProcessor(mPowerProfile, mPowerStatsUidResolver)); 555 556 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_CAMERA) 557 .trackDeviceStates( 558 AggregatedPowerStatsConfig.STATE_POWER, 559 AggregatedPowerStatsConfig.STATE_SCREEN) 560 .trackUidStates( 561 AggregatedPowerStatsConfig.STATE_POWER, 562 AggregatedPowerStatsConfig.STATE_SCREEN, 563 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 564 .setProcessor( 565 new CameraPowerStatsProcessor(mPowerProfile, mPowerStatsUidResolver)); 566 567 config.trackPowerComponent(BatteryConsumer.POWER_COMPONENT_GNSS) 568 .trackDeviceStates( 569 AggregatedPowerStatsConfig.STATE_POWER, 570 AggregatedPowerStatsConfig.STATE_SCREEN) 571 .trackUidStates( 572 AggregatedPowerStatsConfig.STATE_POWER, 573 AggregatedPowerStatsConfig.STATE_SCREEN, 574 AggregatedPowerStatsConfig.STATE_PROCESS_STATE) 575 .setProcessor( 576 new GnssPowerStatsProcessor(mPowerProfile, mPowerStatsUidResolver)); 577 return config; 578 } 579 setPowerStatsThrottlePeriods(BatteryStatsImpl.BatteryStatsConfig.Builder builder, String configString)580 private void setPowerStatsThrottlePeriods(BatteryStatsImpl.BatteryStatsConfig.Builder builder, 581 String configString) { 582 Matcher matcher = Pattern.compile("([^:]+):(\\d+)\\s*").matcher(configString); 583 while (matcher.find()) { 584 String powerComponentName = matcher.group(1); 585 long throttlePeriod; 586 try { 587 throttlePeriod = Long.parseLong(matcher.group(2)); 588 } catch (NumberFormatException nfe) { 589 throw new IllegalArgumentException( 590 "Invalid config_powerStatsThrottlePeriods format: " + configString); 591 } 592 if (powerComponentName.equals("*")) { 593 builder.setDefaultPowerStatsThrottlePeriodMillis(throttlePeriod); 594 } else { 595 builder.setPowerStatsThrottlePeriodMillis(powerComponentName, throttlePeriod); 596 } 597 } 598 } 599 600 /** 601 * Creates an instance of BatteryStatsService and restores data from stored state. 602 */ create(Context context, File systemDir, Handler handler, BatteryStatsImpl.BatteryCallback callback)603 public static BatteryStatsService create(Context context, File systemDir, Handler handler, 604 BatteryStatsImpl.BatteryCallback callback) { 605 BatteryStatsService service = new BatteryStatsService(context, systemDir); 606 service.mStats.setCallback(callback); 607 synchronized (service.mStats) { 608 service.mStats.readLocked(); 609 } 610 service.scheduleWriteToDisk(); 611 return service; 612 } 613 publish()614 public void publish() { 615 LocalServices.addService(BatteryStatsInternal.class, new LocalService()); 616 ServiceManager.addService(BatteryStats.SERVICE_NAME, asBinder()); 617 } 618 systemServicesReady()619 public void systemServicesReady() { 620 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_CPU, 621 Flags.streamlinedBatteryStats()); 622 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 623 BatteryConsumer.POWER_COMPONENT_CPU, 624 Flags.streamlinedBatteryStats()); 625 626 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO, 627 Flags.streamlinedConnectivityBatteryStats()); 628 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 629 BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO, 630 Flags.streamlinedConnectivityBatteryStats()); 631 632 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_WIFI, 633 Flags.streamlinedConnectivityBatteryStats()); 634 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 635 BatteryConsumer.POWER_COMPONENT_WIFI, 636 Flags.streamlinedConnectivityBatteryStats()); 637 638 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_BLUETOOTH, 639 Flags.streamlinedConnectivityBatteryStats()); 640 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 641 BatteryConsumer.POWER_COMPONENT_BLUETOOTH, 642 Flags.streamlinedConnectivityBatteryStats()); 643 644 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_AUDIO, 645 Flags.streamlinedMiscBatteryStats()); 646 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 647 BatteryConsumer.POWER_COMPONENT_AUDIO, 648 Flags.streamlinedMiscBatteryStats()); 649 650 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_VIDEO, 651 Flags.streamlinedMiscBatteryStats()); 652 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 653 BatteryConsumer.POWER_COMPONENT_VIDEO, 654 Flags.streamlinedMiscBatteryStats()); 655 656 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_FLASHLIGHT, 657 Flags.streamlinedMiscBatteryStats()); 658 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 659 BatteryConsumer.POWER_COMPONENT_FLASHLIGHT, 660 Flags.streamlinedMiscBatteryStats()); 661 662 mStats.setPowerStatsCollectorEnabled(BatteryConsumer.POWER_COMPONENT_CAMERA, 663 Flags.streamlinedMiscBatteryStats()); 664 mBatteryUsageStatsProvider.setPowerStatsExporterEnabled( 665 BatteryConsumer.POWER_COMPONENT_CAMERA, 666 Flags.streamlinedMiscBatteryStats()); 667 668 mWorker.systemServicesReady(); 669 mStats.systemServicesReady(mContext); 670 mCpuWakeupStats.systemServicesReady(); 671 final INetworkManagementService nms = INetworkManagementService.Stub.asInterface( 672 ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE)); 673 final ConnectivityManager cm = mContext.getSystemService(ConnectivityManager.class); 674 try { 675 if (!SdkLevel.isAtLeastV()) { 676 // On V+ devices, ConnectivityService calls BatteryStats API to update 677 // RadioPowerState change. So BatteryStatsService registers the callback only on 678 // pre V devices. 679 nms.registerObserver(mActivityChangeObserver); 680 } 681 cm.registerDefaultNetworkCallback(mNetworkCallback); 682 } catch (RemoteException e) { 683 Slog.e(TAG, "Could not register INetworkManagement event observer " + e); 684 } 685 686 synchronized (mPowerStatsLock) { 687 mPowerStatsInternal = LocalServices.getService(PowerStatsInternal.class); 688 if (mPowerStatsInternal != null) { 689 populatePowerEntityMaps(); 690 } else { 691 Slog.e(TAG, "Could not register PowerStatsInternal"); 692 } 693 } 694 mBatteryManagerInternal = LocalServices.getService(BatteryManagerInternal.class); 695 696 Watchdog.getInstance().addMonitor(this); 697 698 final DataConnectionStats dataConnectionStats = new DataConnectionStats(mContext, mHandler); 699 dataConnectionStats.startMonitoring(); 700 701 registerStatsCallbacks(); 702 } 703 704 /** 705 * Notifies BatteryStatsService that the system server is ready. 706 */ onSystemReady()707 public void onSystemReady() { 708 mStats.onSystemReady(mContext); 709 mPowerStatsScheduler.start(Flags.streamlinedBatteryStats()); 710 } 711 712 private final class LocalService extends BatteryStatsInternal { 713 @Override getWifiIfaces()714 public String[] getWifiIfaces() { 715 return mStats.getWifiIfaces().clone(); 716 } 717 718 @Override getMobileIfaces()719 public String[] getMobileIfaces() { 720 return mStats.getMobileIfaces().clone(); 721 } 722 723 @Override getSystemServiceCpuThreadTimes()724 public SystemServiceCpuThreadTimes getSystemServiceCpuThreadTimes() { 725 return mStats.getSystemServiceCpuThreadTimes(); 726 } 727 728 @Override getBatteryUsageStats(List<BatteryUsageStatsQuery> queries)729 public List<BatteryUsageStats> getBatteryUsageStats(List<BatteryUsageStatsQuery> queries) { 730 return BatteryStatsService.this.getBatteryUsageStats(queries); 731 } 732 733 @Override noteJobsDeferred(int uid, int numDeferred, long sinceLast)734 public void noteJobsDeferred(int uid, int numDeferred, long sinceLast) { 735 if (DBG) Slog.d(TAG, "Jobs deferred " + uid + ": " + numDeferred + " " + sinceLast); 736 BatteryStatsService.this.noteJobsDeferred(uid, numDeferred, sinceLast); 737 } 738 transportToSubsystem(NetworkCapabilities nc)739 private int transportToSubsystem(NetworkCapabilities nc) { 740 if (nc.hasTransport(TRANSPORT_WIFI)) { 741 return CPU_WAKEUP_SUBSYSTEM_WIFI; 742 } else if (nc.hasTransport(TRANSPORT_CELLULAR)) { 743 return CPU_WAKEUP_SUBSYSTEM_CELLULAR_DATA; 744 } 745 return CPU_WAKEUP_SUBSYSTEM_UNKNOWN; 746 } 747 748 @Override noteCpuWakingNetworkPacket(Network network, long elapsedMillis, int uid)749 public void noteCpuWakingNetworkPacket(Network network, long elapsedMillis, int uid) { 750 if (uid < 0) { 751 Slog.e(TAG, "Invalid uid for waking network packet: " + uid); 752 return; 753 } 754 final ConnectivityManager cm = mContext.getSystemService(ConnectivityManager.class); 755 final NetworkCapabilities nc = cm.getNetworkCapabilities(network); 756 final int subsystem = transportToSubsystem(nc); 757 758 if (subsystem == CPU_WAKEUP_SUBSYSTEM_UNKNOWN) { 759 Slog.wtf(TAG, "Could not map transport for network: " + network 760 + " while attributing wakeup by packet sent to uid: " + uid); 761 return; 762 } 763 noteCpuWakingActivity(subsystem, elapsedMillis, uid); 764 } 765 766 @Override noteBinderCallStats(int workSourceUid, long incrementatCallCount, Collection<BinderCallsStats.CallStat> callStats)767 public void noteBinderCallStats(int workSourceUid, long incrementatCallCount, 768 Collection<BinderCallsStats.CallStat> callStats) { 769 synchronized (BatteryStatsService.this.mLock) { 770 mHandler.sendMessage(PooledLambda.obtainMessage( 771 mStats::noteBinderCallStats, workSourceUid, incrementatCallCount, callStats, 772 SystemClock.elapsedRealtime(), SystemClock.uptimeMillis())); 773 } 774 } 775 776 @Override noteBinderThreadNativeIds(int[] binderThreadNativeTids)777 public void noteBinderThreadNativeIds(int[] binderThreadNativeTids) { 778 synchronized (BatteryStatsService.this.mLock) { 779 mStats.noteBinderThreadNativeIds(binderThreadNativeTids); 780 } 781 } 782 783 @Override noteWakingSoundTrigger(long elapsedMillis, int uid)784 public void noteWakingSoundTrigger(long elapsedMillis, int uid) { 785 noteCpuWakingActivity(CPU_WAKEUP_SUBSYSTEM_SOUND_TRIGGER, elapsedMillis, uid); 786 } 787 788 @Override noteWakingAlarmBatch(long elapsedMillis, int... uids)789 public void noteWakingAlarmBatch(long elapsedMillis, int... uids) { 790 noteCpuWakingActivity(CPU_WAKEUP_SUBSYSTEM_ALARM, elapsedMillis, uids); 791 } 792 } 793 794 /** 795 * Reports any activity that could potentially have caused the CPU to wake up. 796 * Accepts a timestamp to allow free ordering between the event and its reporting. 797 * 798 * <p> 799 * This method can be called multiple times for the same wakeup and then all attribution 800 * reported will be unioned as long as all reports are made within a small amount of cpu uptime 801 * after the wakeup is reported to batterystats. 802 * 803 * @param subsystem The subsystem this activity should be attributed to. 804 * @param elapsedMillis The time when this activity happened in the elapsed timebase. 805 * @param uids The uid (or uids) that should be blamed for this activity. 806 */ noteCpuWakingActivity(@puWakeupSubsystem int subsystem, long elapsedMillis, int... uids)807 void noteCpuWakingActivity(@CpuWakeupSubsystem int subsystem, long elapsedMillis, int... uids) { 808 Objects.requireNonNull(uids); 809 mHandler.post(() -> mCpuWakeupStats.noteWakingActivity(subsystem, elapsedMillis, uids)); 810 } 811 812 @Override monitor()813 public void monitor() { 814 if (!mMonitorEnabled) { 815 return; 816 } 817 synchronized (mLock) { 818 } 819 synchronized (mStats) { 820 } 821 } 822 awaitUninterruptibly(Future<?> future)823 private static void awaitUninterruptibly(Future<?> future) { 824 while (true) { 825 try { 826 future.get(); 827 return; 828 } catch (ExecutionException | CancellationException e) { 829 return; 830 } catch (InterruptedException e) { 831 // Keep looping 832 } 833 } 834 } 835 syncStats(String reason, int flags)836 private void syncStats(String reason, int flags) { 837 awaitUninterruptibly(mWorker.scheduleSync(reason, flags)); 838 } 839 awaitCompletion()840 private void awaitCompletion() { 841 final CountDownLatch latch = new CountDownLatch(1); 842 mHandler.post(() -> { 843 latch.countDown(); 844 }); 845 try { 846 latch.await(); 847 } catch (InterruptedException e) { 848 } 849 } 850 851 /** 852 * At the time when the constructor runs, the power manager has not yet been 853 * initialized. So we initialize the low power observer later. 854 */ initPowerManagement()855 public void initPowerManagement() { 856 final PowerManagerInternal powerMgr = LocalServices.getService(PowerManagerInternal.class); 857 powerMgr.registerLowPowerModeObserver(this); 858 synchronized (mStats) { 859 mStats.notePowerSaveModeLockedInit( 860 powerMgr.getLowPowerState(ServiceType.BATTERY_STATS).batterySaverEnabled, 861 SystemClock.elapsedRealtime(), SystemClock.uptimeMillis()); 862 } 863 (new WakeupReasonThread()).start(); 864 } 865 shutdown()866 public void shutdown() { 867 Slog.w("BatteryStats", "Writing battery stats before shutdown..."); 868 869 // Drain the handler queue to make sure we've handled all pending works. 870 awaitCompletion(); 871 872 syncStats("shutdown", BatteryExternalStatsWorker.UPDATE_ALL); 873 874 synchronized (mStats) { 875 mStats.shutdownLocked(); 876 } 877 878 // Shutdown the thread we made. 879 mWorker.shutdown(); 880 881 // To insure continuity, write the monotonic timeshift after writing the last history event 882 mMonotonicClock.write(); 883 } 884 getService()885 public static IBatteryStats getService() { 886 if (sService != null) { 887 return sService; 888 } 889 IBinder b = ServiceManager.getService(BatteryStats.SERVICE_NAME); 890 sService = asInterface(b); 891 return sService; 892 } 893 894 @Override getServiceType()895 public int getServiceType() { 896 return ServiceType.BATTERY_STATS; 897 } 898 899 @Override onLowPowerModeChanged(final PowerSaveState result)900 public void onLowPowerModeChanged(final PowerSaveState result) { 901 synchronized (mLock) { 902 final long elapsedRealtime = SystemClock.elapsedRealtime(); 903 final long uptime = SystemClock.uptimeMillis(); 904 mHandler.post(() -> { 905 synchronized (mStats) { 906 mStats.notePowerSaveModeLocked(result.batterySaverEnabled, 907 elapsedRealtime, uptime); 908 } 909 }); 910 } 911 } 912 913 /** 914 * @return the current statistics object, which may be modified 915 * to reflect events that affect battery usage. You must lock the 916 * stats object before doing anything with it. 917 */ getActiveStatistics()918 public BatteryStatsImpl getActiveStatistics() { 919 return mStats; 920 } 921 922 /** 923 * Schedules a write to disk to occur. This will cause the BatteryStatsImpl 924 * object to update with the latest info, then write to disk. 925 */ scheduleWriteToDisk()926 public void scheduleWriteToDisk() { 927 synchronized (mLock) { 928 // We still schedule it on the handler so we'll have all existing pending works done. 929 mHandler.post(() -> { 930 mWorker.scheduleWrite(); 931 }); 932 } 933 } 934 935 // These are for direct use by the activity manager... 936 937 /** 938 * Remove a UID from the BatteryStats and BatteryStats' external dependencies. 939 */ removeUid(final int uid)940 void removeUid(final int uid) { 941 synchronized (mLock) { 942 final long elapsedRealtime = SystemClock.elapsedRealtime(); 943 mHandler.post(() -> { 944 mCpuWakeupStats.onUidRemoved(uid); 945 synchronized (mStats) { 946 mStats.removeUidStatsLocked(uid, elapsedRealtime); 947 } 948 }); 949 } 950 } 951 onCleanupUser(final int userId)952 void onCleanupUser(final int userId) { 953 synchronized (mLock) { 954 final long elapsedRealtime = SystemClock.elapsedRealtime(); 955 mHandler.post(() -> { 956 synchronized (mStats) { 957 mStats.onCleanupUserLocked(userId, elapsedRealtime); 958 } 959 }); 960 } 961 } 962 onUserRemoved(final int userId)963 void onUserRemoved(final int userId) { 964 synchronized (mLock) { 965 mHandler.post(() -> { 966 synchronized (mStats) { 967 mStats.onUserRemovedLocked(userId); 968 } 969 }); 970 } 971 } 972 addIsolatedUid(final int isolatedUid, final int appUid)973 void addIsolatedUid(final int isolatedUid, final int appUid) { 974 mPowerStatsUidResolver.noteIsolatedUidAdded(isolatedUid, appUid); 975 FrameworkStatsLog.write(FrameworkStatsLog.ISOLATED_UID_CHANGED, appUid, isolatedUid, 976 FrameworkStatsLog.ISOLATED_UID_CHANGED__EVENT__CREATED); 977 } 978 removeIsolatedUid(final int isolatedUid, final int appUid)979 void removeIsolatedUid(final int isolatedUid, final int appUid) { 980 mPowerStatsUidResolver.noteIsolatedUidRemoved(isolatedUid, appUid); 981 FrameworkStatsLog.write(FrameworkStatsLog.ISOLATED_UID_CHANGED, -1, isolatedUid, 982 FrameworkStatsLog.ISOLATED_UID_CHANGED__EVENT__REMOVED); 983 } 984 noteProcessStart(final String name, final int uid)985 void noteProcessStart(final String name, final int uid) { 986 synchronized (mLock) { 987 final long elapsedRealtime = SystemClock.elapsedRealtime(); 988 final long uptime = SystemClock.uptimeMillis(); 989 mHandler.post(() -> { 990 synchronized (mStats) { 991 mStats.noteProcessStartLocked(name, uid, elapsedRealtime, uptime); 992 } 993 }); 994 } 995 FrameworkStatsLog.write(FrameworkStatsLog.PROCESS_LIFE_CYCLE_STATE_CHANGED, uid, name, 996 FrameworkStatsLog.PROCESS_LIFE_CYCLE_STATE_CHANGED__STATE__STARTED); 997 } 998 noteProcessCrash(String name, int uid)999 void noteProcessCrash(String name, int uid) { 1000 synchronized (mLock) { 1001 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1002 final long uptime = SystemClock.uptimeMillis(); 1003 mHandler.post(() -> { 1004 synchronized (mStats) { 1005 mStats.noteProcessCrashLocked(name, uid, elapsedRealtime, uptime); 1006 } 1007 }); 1008 } 1009 FrameworkStatsLog.write(FrameworkStatsLog.PROCESS_LIFE_CYCLE_STATE_CHANGED, uid, name, 1010 FrameworkStatsLog.PROCESS_LIFE_CYCLE_STATE_CHANGED__STATE__CRASHED); 1011 } 1012 noteProcessAnr(String name, int uid)1013 void noteProcessAnr(String name, int uid) { 1014 synchronized (mLock) { 1015 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1016 final long uptime = SystemClock.uptimeMillis(); 1017 mHandler.post(() -> { 1018 synchronized (mStats) { 1019 mStats.noteProcessAnrLocked(name, uid, elapsedRealtime, uptime); 1020 } 1021 }); 1022 } 1023 } 1024 noteProcessFinish(String name, int uid)1025 void noteProcessFinish(String name, int uid) { 1026 synchronized (mLock) { 1027 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1028 final long uptime = SystemClock.uptimeMillis(); 1029 mHandler.post(() -> { 1030 synchronized (mStats) { 1031 mStats.noteProcessFinishLocked(name, uid, elapsedRealtime, uptime); 1032 } 1033 }); 1034 } 1035 FrameworkStatsLog.write(FrameworkStatsLog.PROCESS_LIFE_CYCLE_STATE_CHANGED, uid, name, 1036 FrameworkStatsLog.PROCESS_LIFE_CYCLE_STATE_CHANGED__STATE__FINISHED); 1037 } 1038 1039 /** @param state Process state from ActivityManager.java. */ noteUidProcessState(int uid, int state)1040 void noteUidProcessState(int uid, int state) { 1041 synchronized (mLock) { 1042 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1043 final long uptime = SystemClock.uptimeMillis(); 1044 mHandler.post(() -> { 1045 mCpuWakeupStats.noteUidProcessState(uid, state); 1046 synchronized (mStats) { 1047 mStats.noteUidProcessStateLocked(uid, state, elapsedRealtime, uptime); 1048 } 1049 }); 1050 } 1051 } 1052 1053 // Public interface... 1054 1055 /** 1056 * Returns BatteryUsageStats, which contains power attribution data on a per-subsystem 1057 * and per-UID basis. 1058 */ 1059 @Override 1060 @EnforcePermission(BATTERY_STATS) getBatteryUsageStats(List<BatteryUsageStatsQuery> queries)1061 public List<BatteryUsageStats> getBatteryUsageStats(List<BatteryUsageStatsQuery> queries) { 1062 super.getBatteryUsageStats_enforcePermission(); 1063 1064 awaitCompletion(); 1065 1066 if (BatteryUsageStatsProvider.shouldUpdateStats(queries, 1067 SystemClock.elapsedRealtime(), 1068 mWorker.getLastCollectionTimeStamp())) { 1069 syncStats("get-stats", BatteryExternalStatsWorker.UPDATE_ALL); 1070 if (Flags.streamlinedBatteryStats()) { 1071 mStats.collectPowerStatsSamples(); 1072 } 1073 } 1074 1075 return mBatteryUsageStatsProvider.getBatteryUsageStats(mStats, queries); 1076 } 1077 1078 /** Register callbacks for statsd pulled atoms. */ registerStatsCallbacks()1079 private void registerStatsCallbacks() { 1080 final StatsManager statsManager = mContext.getSystemService(StatsManager.class); 1081 final StatsPullAtomCallbackImpl pullAtomCallback = new StatsPullAtomCallbackImpl(); 1082 1083 statsManager.setPullAtomCallback( 1084 FrameworkStatsLog.BATTERY_USAGE_STATS_SINCE_RESET, 1085 null, // use default PullAtomMetadata values 1086 DIRECT_EXECUTOR, pullAtomCallback); 1087 statsManager.setPullAtomCallback( 1088 FrameworkStatsLog.BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL, 1089 null, // use default PullAtomMetadata values 1090 DIRECT_EXECUTOR, pullAtomCallback); 1091 statsManager.setPullAtomCallback( 1092 FrameworkStatsLog.BATTERY_USAGE_STATS_BEFORE_RESET, 1093 null, // use default PullAtomMetadata values 1094 DIRECT_EXECUTOR, pullAtomCallback); 1095 } 1096 1097 /** StatsPullAtomCallback for pulling BatteryUsageStats data. */ 1098 private class StatsPullAtomCallbackImpl implements StatsManager.StatsPullAtomCallback { 1099 @Override onPullAtom(int atomTag, List<StatsEvent> data)1100 public int onPullAtom(int atomTag, List<StatsEvent> data) { 1101 final BatteryUsageStats bus; 1102 switch (atomTag) { 1103 case FrameworkStatsLog.BATTERY_USAGE_STATS_SINCE_RESET: 1104 @SuppressLint("MissingPermission") 1105 final double minConsumedPowerThreshold = 1106 DeviceConfig.getFloat(DEVICE_CONFIG_NAMESPACE, 1107 MIN_CONSUMED_POWER_THRESHOLD_KEY, 0); 1108 final BatteryUsageStatsQuery querySinceReset = 1109 new BatteryUsageStatsQuery.Builder() 1110 .setMaxStatsAgeMs(0) 1111 .includeProcessStateData() 1112 .includeVirtualUids() 1113 .includePowerModels() 1114 .setMinConsumedPowerThreshold(minConsumedPowerThreshold) 1115 .build(); 1116 bus = getBatteryUsageStats(List.of(querySinceReset)).get(0); 1117 break; 1118 case FrameworkStatsLog.BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL: 1119 final BatteryUsageStatsQuery queryPowerProfile = 1120 new BatteryUsageStatsQuery.Builder() 1121 .setMaxStatsAgeMs(0) 1122 .includeProcessStateData() 1123 .includeVirtualUids() 1124 .powerProfileModeledOnly() 1125 .includePowerModels() 1126 .build(); 1127 bus = getBatteryUsageStats(List.of(queryPowerProfile)).get(0); 1128 break; 1129 case FrameworkStatsLog.BATTERY_USAGE_STATS_BEFORE_RESET: 1130 final long sessionStart = 1131 getLastBatteryUsageStatsBeforeResetAtomPullTimestamp(); 1132 final long sessionEnd; 1133 synchronized (mStats) { 1134 sessionEnd = mStats.getStartClockTime(); 1135 } 1136 final BatteryUsageStatsQuery queryBeforeReset = 1137 new BatteryUsageStatsQuery.Builder() 1138 .setMaxStatsAgeMs(0) 1139 .includeProcessStateData() 1140 .includeVirtualUids() 1141 .aggregateSnapshots(sessionStart, sessionEnd) 1142 .build(); 1143 bus = getBatteryUsageStats(List.of(queryBeforeReset)).get(0); 1144 setLastBatteryUsageStatsBeforeResetAtomPullTimestamp(sessionEnd); 1145 break; 1146 default: 1147 throw new UnsupportedOperationException("Unknown tagId=" + atomTag); 1148 } 1149 final byte[] statsProto = bus.getStatsProto(); 1150 1151 data.add(FrameworkStatsLog.buildStatsEvent(atomTag, statsProto)); 1152 1153 return StatsManager.PULL_SUCCESS; 1154 } 1155 } 1156 1157 @Override 1158 @RequiresNoPermission isCharging()1159 public boolean isCharging() { 1160 synchronized (mStats) { 1161 return mStats.isCharging(); 1162 } 1163 } 1164 1165 @Override 1166 @RequiresNoPermission computeBatteryTimeRemaining()1167 public long computeBatteryTimeRemaining() { 1168 synchronized (mStats) { 1169 long time = mStats.computeBatteryTimeRemaining(SystemClock.elapsedRealtime()); 1170 return time >= 0 ? (time/1000) : time; 1171 } 1172 } 1173 1174 @Override 1175 @RequiresNoPermission computeChargeTimeRemaining()1176 public long computeChargeTimeRemaining() { 1177 synchronized (mStats) { 1178 long time = mStats.computeChargeTimeRemaining(SystemClock.elapsedRealtime()); 1179 return time >= 0 ? (time/1000) : time; 1180 } 1181 } 1182 1183 @Override 1184 @EnforcePermission(BATTERY_STATS) computeBatteryScreenOffRealtimeMs()1185 public long computeBatteryScreenOffRealtimeMs() { 1186 super.computeBatteryScreenOffRealtimeMs_enforcePermission(); 1187 1188 synchronized (mStats) { 1189 final long curTimeUs = SystemClock.elapsedRealtimeNanos() / 1000; 1190 long timeUs = mStats.computeBatteryScreenOffRealtime(curTimeUs, 1191 BatteryStats.STATS_SINCE_CHARGED); 1192 return timeUs / 1000; 1193 } 1194 } 1195 1196 @Override 1197 @EnforcePermission(BATTERY_STATS) getScreenOffDischargeMah()1198 public long getScreenOffDischargeMah() { 1199 super.getScreenOffDischargeMah_enforcePermission(); 1200 1201 synchronized (mStats) { 1202 long dischargeUah = mStats.getUahDischargeScreenOff(BatteryStats.STATS_SINCE_CHARGED); 1203 return dischargeUah / 1000; 1204 } 1205 } 1206 1207 @Override 1208 @EnforcePermission(UPDATE_DEVICE_STATS) noteEvent(final int code, final String name, final int uid)1209 public void noteEvent(final int code, final String name, final int uid) { 1210 super.noteEvent_enforcePermission(); 1211 1212 if (name == null) { 1213 // TODO(b/194733136): Replace with an IllegalArgumentException throw. 1214 Slog.wtfStack(TAG, "noteEvent called with null name. code = " + code); 1215 return; 1216 } 1217 1218 synchronized (mLock) { 1219 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1220 final long uptime = SystemClock.uptimeMillis(); 1221 mHandler.post(() -> { 1222 synchronized (mStats) { 1223 mStats.noteEventLocked(code, name, uid, elapsedRealtime, uptime); 1224 } 1225 }); 1226 } 1227 } 1228 1229 @Override 1230 @EnforcePermission(UPDATE_DEVICE_STATS) noteSyncStart(final String name, final int uid)1231 public void noteSyncStart(final String name, final int uid) { 1232 super.noteSyncStart_enforcePermission(); 1233 1234 synchronized (mLock) { 1235 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1236 final long uptime = SystemClock.uptimeMillis(); 1237 mHandler.post(() -> { 1238 synchronized (mStats) { 1239 mStats.noteSyncStartLocked(name, uid, elapsedRealtime, uptime); 1240 } 1241 }); 1242 } 1243 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.SYNC_STATE_CHANGED, uid, null, 1244 name, FrameworkStatsLog.SYNC_STATE_CHANGED__STATE__ON); 1245 } 1246 1247 @Override 1248 @EnforcePermission(UPDATE_DEVICE_STATS) noteSyncFinish(final String name, final int uid)1249 public void noteSyncFinish(final String name, final int uid) { 1250 super.noteSyncFinish_enforcePermission(); 1251 1252 synchronized (mLock) { 1253 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1254 final long uptime = SystemClock.uptimeMillis(); 1255 mHandler.post(() -> { 1256 synchronized (mStats) { 1257 mStats.noteSyncFinishLocked(name, uid, elapsedRealtime, uptime); 1258 } 1259 }); 1260 } 1261 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.SYNC_STATE_CHANGED, uid, null, 1262 name, FrameworkStatsLog.SYNC_STATE_CHANGED__STATE__OFF); 1263 } 1264 1265 /** A scheduled job was started. */ 1266 @Override 1267 @EnforcePermission(UPDATE_DEVICE_STATS) noteJobStart(final String name, final int uid)1268 public void noteJobStart(final String name, final int uid) { 1269 super.noteJobStart_enforcePermission(); 1270 1271 synchronized (mLock) { 1272 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1273 final long uptime = SystemClock.uptimeMillis(); 1274 mHandler.post(() -> { 1275 synchronized (mStats) { 1276 mStats.noteJobStartLocked(name, uid, elapsedRealtime, uptime); 1277 } 1278 }); 1279 } 1280 } 1281 1282 /** A scheduled job was finished. */ 1283 @Override 1284 @EnforcePermission(UPDATE_DEVICE_STATS) noteJobFinish(final String name, final int uid, final int stopReason)1285 public void noteJobFinish(final String name, final int uid, final int stopReason) { 1286 super.noteJobFinish_enforcePermission(); 1287 1288 synchronized (mLock) { 1289 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1290 final long uptime = SystemClock.uptimeMillis(); 1291 mHandler.post(() -> { 1292 synchronized (mStats) { 1293 mStats.noteJobFinishLocked(name, uid, stopReason, elapsedRealtime, uptime); 1294 } 1295 }); 1296 } 1297 } 1298 noteJobsDeferred(final int uid, final int numDeferred, final long sinceLast)1299 void noteJobsDeferred(final int uid, final int numDeferred, final long sinceLast) { 1300 // No need to enforce calling permission, as it is called from an internal interface 1301 synchronized (mLock) { 1302 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1303 final long uptime = SystemClock.uptimeMillis(); 1304 mHandler.post(() -> { 1305 synchronized (mStats) { 1306 mStats.noteJobsDeferredLocked(uid, numDeferred, sinceLast, 1307 elapsedRealtime, uptime); 1308 } 1309 }); 1310 } 1311 } 1312 noteWakupAlarm(final String name, final int uid, final WorkSource workSource, final String tag)1313 public void noteWakupAlarm(final String name, final int uid, final WorkSource workSource, 1314 final String tag) { 1315 mContext.enforceCallingOrSelfPermission(UPDATE_DEVICE_STATS, "noteWakupAlarm"); 1316 final WorkSource localWs = workSource != null ? new WorkSource(workSource) : null; 1317 synchronized (mLock) { 1318 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1319 final long uptime = SystemClock.uptimeMillis(); 1320 mHandler.post(() -> { 1321 synchronized (mStats) { 1322 mStats.noteWakupAlarmLocked(name, uid, localWs, tag, 1323 elapsedRealtime, uptime); 1324 } 1325 }); 1326 } 1327 } 1328 noteAlarmStart(final String name, final WorkSource workSource, final int uid)1329 public void noteAlarmStart(final String name, final WorkSource workSource, final int uid) { 1330 mContext.enforceCallingOrSelfPermission(UPDATE_DEVICE_STATS, "noteAlarmStart"); 1331 final WorkSource localWs = workSource != null ? new WorkSource(workSource) : null; 1332 synchronized (mLock) { 1333 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1334 final long uptime = SystemClock.uptimeMillis(); 1335 mHandler.post(() -> { 1336 synchronized (mStats) { 1337 mStats.noteAlarmStartLocked(name, localWs, uid, elapsedRealtime, uptime); 1338 } 1339 }); 1340 } 1341 } 1342 noteAlarmFinish(final String name, final WorkSource workSource, final int uid)1343 public void noteAlarmFinish(final String name, final WorkSource workSource, final int uid) { 1344 mContext.enforceCallingOrSelfPermission(UPDATE_DEVICE_STATS, "noteAlarmFinish"); 1345 final WorkSource localWs = workSource != null ? new WorkSource(workSource) : null; 1346 synchronized (mLock) { 1347 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1348 final long uptime = SystemClock.uptimeMillis(); 1349 mHandler.post(() -> { 1350 synchronized (mStats) { 1351 mStats.noteAlarmFinishLocked(name, localWs, uid, elapsedRealtime, uptime); 1352 } 1353 }); 1354 } 1355 } 1356 1357 @Override 1358 @EnforcePermission(UPDATE_DEVICE_STATS) noteStartWakelock(final int uid, final int pid, final String name, final String historyName, final int type, final boolean unimportantForLogging)1359 public void noteStartWakelock(final int uid, final int pid, final String name, 1360 final String historyName, final int type, final boolean unimportantForLogging) { 1361 super.noteStartWakelock_enforcePermission(); 1362 1363 synchronized (mLock) { 1364 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1365 final long uptime = SystemClock.uptimeMillis(); 1366 mHandler.post(() -> { 1367 synchronized (mStats) { 1368 mStats.noteStartWakeLocked(uid, pid, null, name, historyName, type, 1369 unimportantForLogging, elapsedRealtime, uptime); 1370 } 1371 }); 1372 } 1373 } 1374 1375 @Override 1376 @EnforcePermission(UPDATE_DEVICE_STATS) noteStopWakelock(final int uid, final int pid, final String name, final String historyName, final int type)1377 public void noteStopWakelock(final int uid, final int pid, final String name, 1378 final String historyName, final int type) { 1379 super.noteStopWakelock_enforcePermission(); 1380 1381 synchronized (mLock) { 1382 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1383 final long uptime = SystemClock.uptimeMillis(); 1384 mHandler.post(() -> { 1385 synchronized (mStats) { 1386 mStats.noteStopWakeLocked(uid, pid, null, name, historyName, type, 1387 elapsedRealtime, uptime); 1388 } 1389 }); 1390 } 1391 } 1392 1393 @Override 1394 @EnforcePermission(UPDATE_DEVICE_STATS) noteStartWakelockFromSource(final WorkSource ws, final int pid, final String name, final String historyName, final int type, final boolean unimportantForLogging)1395 public void noteStartWakelockFromSource(final WorkSource ws, final int pid, final String name, 1396 final String historyName, final int type, final boolean unimportantForLogging) { 1397 super.noteStartWakelockFromSource_enforcePermission(); 1398 1399 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 1400 synchronized (mLock) { 1401 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1402 final long uptime = SystemClock.uptimeMillis(); 1403 mHandler.post(() -> { 1404 synchronized (mStats) { 1405 mStats.noteStartWakeFromSourceLocked(localWs, pid, name, historyName, 1406 type, unimportantForLogging, elapsedRealtime, uptime); 1407 } 1408 }); 1409 } 1410 } 1411 1412 @Override 1413 @EnforcePermission(UPDATE_DEVICE_STATS) noteChangeWakelockFromSource(final WorkSource ws, final int pid, final String name, final String historyName, final int type, final WorkSource newWs, final int newPid, final String newName, final String newHistoryName, final int newType, final boolean newUnimportantForLogging)1414 public void noteChangeWakelockFromSource(final WorkSource ws, final int pid, final String name, 1415 final String historyName, final int type, final WorkSource newWs, final int newPid, 1416 final String newName, final String newHistoryName, final int newType, 1417 final boolean newUnimportantForLogging) { 1418 super.noteChangeWakelockFromSource_enforcePermission(); 1419 1420 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 1421 final WorkSource localNewWs = newWs != null ? new WorkSource(newWs) : null; 1422 synchronized (mLock) { 1423 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1424 final long uptime = SystemClock.uptimeMillis(); 1425 mHandler.post(() -> { 1426 synchronized (mStats) { 1427 mStats.noteChangeWakelockFromSourceLocked(localWs, pid, name, historyName, type, 1428 localNewWs, newPid, newName, newHistoryName, newType, 1429 newUnimportantForLogging, elapsedRealtime, uptime); 1430 } 1431 }); 1432 } 1433 } 1434 1435 @Override 1436 @EnforcePermission(UPDATE_DEVICE_STATS) noteStopWakelockFromSource(final WorkSource ws, final int pid, final String name, final String historyName, final int type)1437 public void noteStopWakelockFromSource(final WorkSource ws, final int pid, final String name, 1438 final String historyName, final int type) { 1439 super.noteStopWakelockFromSource_enforcePermission(); 1440 1441 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 1442 synchronized (mLock) { 1443 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1444 final long uptime = SystemClock.uptimeMillis(); 1445 mHandler.post(() -> { 1446 synchronized (mStats) { 1447 mStats.noteStopWakeFromSourceLocked(localWs, pid, name, historyName, type, 1448 elapsedRealtime, uptime); 1449 } 1450 }); 1451 } 1452 } 1453 1454 @Override 1455 @EnforcePermission(UPDATE_DEVICE_STATS) noteLongPartialWakelockStart(final String name, final String historyName, final int uid)1456 public void noteLongPartialWakelockStart(final String name, final String historyName, 1457 final int uid) { 1458 super.noteLongPartialWakelockStart_enforcePermission(); 1459 1460 synchronized (mLock) { 1461 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1462 final long uptime = SystemClock.uptimeMillis(); 1463 mHandler.post(() -> { 1464 synchronized (mStats) { 1465 mStats.noteLongPartialWakelockStart(name, historyName, uid, 1466 elapsedRealtime, uptime); 1467 } 1468 }); 1469 } 1470 } 1471 1472 @Override 1473 @EnforcePermission(UPDATE_DEVICE_STATS) noteLongPartialWakelockStartFromSource(final String name, final String historyName, final WorkSource workSource)1474 public void noteLongPartialWakelockStartFromSource(final String name, final String historyName, 1475 final WorkSource workSource) { 1476 super.noteLongPartialWakelockStartFromSource_enforcePermission(); 1477 1478 final WorkSource localWs = workSource != null ? new WorkSource(workSource) : null; 1479 synchronized (mLock) { 1480 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1481 final long uptime = SystemClock.uptimeMillis(); 1482 mHandler.post(() -> { 1483 synchronized (mStats) { 1484 mStats.noteLongPartialWakelockStartFromSource(name, historyName, localWs, 1485 elapsedRealtime, uptime); 1486 } 1487 }); 1488 } 1489 } 1490 1491 @Override 1492 @EnforcePermission(UPDATE_DEVICE_STATS) noteLongPartialWakelockFinish(final String name, final String historyName, final int uid)1493 public void noteLongPartialWakelockFinish(final String name, final String historyName, 1494 final int uid) { 1495 super.noteLongPartialWakelockFinish_enforcePermission(); 1496 1497 synchronized (mLock) { 1498 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1499 final long uptime = SystemClock.uptimeMillis(); 1500 mHandler.post(() -> { 1501 synchronized (mStats) { 1502 mStats.noteLongPartialWakelockFinish(name, historyName, uid, 1503 elapsedRealtime, uptime); 1504 } 1505 }); 1506 } 1507 } 1508 1509 @Override 1510 @EnforcePermission(UPDATE_DEVICE_STATS) noteLongPartialWakelockFinishFromSource(final String name, final String historyName, final WorkSource workSource)1511 public void noteLongPartialWakelockFinishFromSource(final String name, final String historyName, 1512 final WorkSource workSource) { 1513 super.noteLongPartialWakelockFinishFromSource_enforcePermission(); 1514 1515 final WorkSource localWs = workSource != null ? new WorkSource(workSource) : null; 1516 synchronized (mLock) { 1517 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1518 final long uptime = SystemClock.uptimeMillis(); 1519 mHandler.post(() -> { 1520 synchronized (mStats) { 1521 mStats.noteLongPartialWakelockFinishFromSource(name, historyName, localWs, 1522 elapsedRealtime, uptime); 1523 } 1524 }); 1525 } 1526 } 1527 1528 @Override 1529 @EnforcePermission(UPDATE_DEVICE_STATS) noteStartSensor(final int uid, final int sensor)1530 public void noteStartSensor(final int uid, final int sensor) { 1531 super.noteStartSensor_enforcePermission(); 1532 1533 synchronized (mLock) { 1534 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1535 final long uptime = SystemClock.uptimeMillis(); 1536 mHandler.post(() -> { 1537 synchronized (mStats) { 1538 mStats.noteStartSensorLocked(uid, sensor, elapsedRealtime, uptime); 1539 } 1540 }); 1541 } 1542 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.SENSOR_STATE_CHANGED, uid, 1543 null, sensor, FrameworkStatsLog.SENSOR_STATE_CHANGED__STATE__ON); 1544 } 1545 1546 @Override noteWakeupSensorEvent(long elapsedNanos, int uid, int sensorHandle)1547 public void noteWakeupSensorEvent(long elapsedNanos, int uid, int sensorHandle) { 1548 final int callingUid = Binder.getCallingUid(); 1549 if (callingUid != Process.SYSTEM_UID) { 1550 throw new SecurityException("Calling uid " + callingUid + " is not system uid"); 1551 } 1552 final long elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos); 1553 1554 final SensorManager sm = mContext.getSystemService(SensorManager.class); 1555 final Sensor sensor = sm.getSensorByHandle(sensorHandle); 1556 if (sensor == null) { 1557 Slog.w(TAG, "Unknown sensor handle " + sensorHandle 1558 + " received in noteWakeupSensorEvent"); 1559 return; 1560 } 1561 if (uid < 0) { 1562 Slog.wtf(TAG, "Invalid uid " + uid + " for sensor event with sensor: " + sensor); 1563 return; 1564 } 1565 // TODO (b/278319756): Also pipe in Sensor type for more usefulness. 1566 noteCpuWakingActivity(BatteryStatsInternal.CPU_WAKEUP_SUBSYSTEM_SENSOR, elapsedMillis, uid); 1567 } 1568 1569 @Override 1570 @EnforcePermission(UPDATE_DEVICE_STATS) noteStopSensor(final int uid, final int sensor)1571 public void noteStopSensor(final int uid, final int sensor) { 1572 super.noteStopSensor_enforcePermission(); 1573 1574 synchronized (mLock) { 1575 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1576 final long uptime = SystemClock.uptimeMillis(); 1577 mHandler.post(() -> { 1578 synchronized (mStats) { 1579 mStats.noteStopSensorLocked(uid, sensor, elapsedRealtime, uptime); 1580 } 1581 }); 1582 } 1583 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.SENSOR_STATE_CHANGED, uid, 1584 null, sensor, FrameworkStatsLog.SENSOR_STATE_CHANGED__STATE__OFF); 1585 } 1586 1587 @Override 1588 @EnforcePermission(UPDATE_DEVICE_STATS) noteVibratorOn(final int uid, final long durationMillis)1589 public void noteVibratorOn(final int uid, final long durationMillis) { 1590 super.noteVibratorOn_enforcePermission(); 1591 1592 synchronized (mLock) { 1593 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1594 final long uptime = SystemClock.uptimeMillis(); 1595 mHandler.post(() -> { 1596 synchronized (mStats) { 1597 mStats.noteVibratorOnLocked(uid, durationMillis, elapsedRealtime, uptime); 1598 } 1599 }); 1600 } 1601 } 1602 1603 @Override 1604 @EnforcePermission(UPDATE_DEVICE_STATS) noteVibratorOff(final int uid)1605 public void noteVibratorOff(final int uid) { 1606 super.noteVibratorOff_enforcePermission(); 1607 1608 synchronized (mLock) { 1609 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1610 final long uptime = SystemClock.uptimeMillis(); 1611 mHandler.post(() -> { 1612 synchronized (mStats) { 1613 mStats.noteVibratorOffLocked(uid, elapsedRealtime, uptime); 1614 } 1615 }); 1616 } 1617 } 1618 1619 @Override 1620 @EnforcePermission(UPDATE_DEVICE_STATS) noteGpsChanged(final WorkSource oldWs, final WorkSource newWs)1621 public void noteGpsChanged(final WorkSource oldWs, final WorkSource newWs) { 1622 super.noteGpsChanged_enforcePermission(); 1623 1624 final WorkSource localOldWs = oldWs != null ? new WorkSource(oldWs) : null; 1625 final WorkSource localNewWs = newWs != null ? new WorkSource(newWs) : null; 1626 synchronized (mLock) { 1627 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1628 final long uptime = SystemClock.uptimeMillis(); 1629 mHandler.post(() -> { 1630 synchronized (mStats) { 1631 mStats.noteGpsChangedLocked(localOldWs, localNewWs, elapsedRealtime, uptime); 1632 } 1633 }); 1634 } 1635 } 1636 1637 @Override 1638 @EnforcePermission(UPDATE_DEVICE_STATS) noteGpsSignalQuality(final int signalLevel)1639 public void noteGpsSignalQuality(final int signalLevel) { 1640 super.noteGpsSignalQuality_enforcePermission(); 1641 1642 synchronized (mLock) { 1643 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1644 final long uptime = SystemClock.uptimeMillis(); 1645 mHandler.post(() -> { 1646 synchronized (mStats) { 1647 mStats.noteGpsSignalQualityLocked(signalLevel, elapsedRealtime, uptime); 1648 } 1649 }); 1650 } 1651 } 1652 1653 @Override 1654 @EnforcePermission(UPDATE_DEVICE_STATS) noteScreenState(final int state)1655 public void noteScreenState(final int state) { 1656 super.noteScreenState_enforcePermission(); 1657 1658 synchronized (mLock) { 1659 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1660 final long uptime = SystemClock.uptimeMillis(); 1661 final long currentTime = System.currentTimeMillis(); 1662 mHandler.post(() -> { 1663 if (DBG) Slog.d(TAG, "begin noteScreenState"); 1664 synchronized (mStats) { 1665 mStats.noteScreenStateLocked(0, state, elapsedRealtime, uptime, currentTime); 1666 } 1667 if (DBG) Slog.d(TAG, "end noteScreenState"); 1668 }); 1669 } 1670 FrameworkStatsLog.write(FrameworkStatsLog.SCREEN_STATE_CHANGED, state); 1671 } 1672 1673 @Override 1674 @EnforcePermission(UPDATE_DEVICE_STATS) noteScreenBrightness(final int brightness)1675 public void noteScreenBrightness(final int brightness) { 1676 super.noteScreenBrightness_enforcePermission(); 1677 1678 synchronized (mLock) { 1679 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1680 final long uptime = SystemClock.uptimeMillis(); 1681 mHandler.post(() -> { 1682 synchronized (mStats) { 1683 mStats.noteScreenBrightnessLocked(0, brightness, elapsedRealtime, uptime); 1684 } 1685 }); 1686 } 1687 FrameworkStatsLog.write(FrameworkStatsLog.SCREEN_BRIGHTNESS_CHANGED, brightness); 1688 } 1689 1690 @Override 1691 @EnforcePermission(UPDATE_DEVICE_STATS) noteUserActivity(final int uid, final int event)1692 public void noteUserActivity(final int uid, final int event) { 1693 super.noteUserActivity_enforcePermission(); 1694 1695 synchronized (mLock) { 1696 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1697 final long uptime = SystemClock.uptimeMillis(); 1698 mHandler.post(() -> { 1699 synchronized (mStats) { 1700 mStats.noteUserActivityLocked(uid, event, elapsedRealtime, uptime); 1701 } 1702 }); 1703 } 1704 } 1705 1706 @Override 1707 @EnforcePermission(UPDATE_DEVICE_STATS) noteWakeUp(final String reason, final int reasonUid)1708 public void noteWakeUp(final String reason, final int reasonUid) { 1709 super.noteWakeUp_enforcePermission(); 1710 1711 synchronized (mLock) { 1712 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1713 final long uptime = SystemClock.uptimeMillis(); 1714 mHandler.post(() -> { 1715 synchronized (mStats) { 1716 mStats.noteWakeUpLocked(reason, reasonUid, elapsedRealtime, uptime); 1717 } 1718 }); 1719 } 1720 } 1721 1722 @Override 1723 @EnforcePermission(UPDATE_DEVICE_STATS) noteInteractive(final boolean interactive)1724 public void noteInteractive(final boolean interactive) { 1725 super.noteInteractive_enforcePermission(); 1726 1727 synchronized (mLock) { 1728 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1729 mHandler.post(() -> { 1730 synchronized (mStats) { 1731 mStats.noteInteractiveLocked(interactive, elapsedRealtime); 1732 } 1733 }); 1734 } 1735 } 1736 1737 @Override 1738 @EnforcePermission(UPDATE_DEVICE_STATS) noteConnectivityChanged(final int type, final String extra)1739 public void noteConnectivityChanged(final int type, final String extra) { 1740 super.noteConnectivityChanged_enforcePermission(); 1741 1742 synchronized (mLock) { 1743 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1744 final long uptime = SystemClock.uptimeMillis(); 1745 mHandler.post(() -> { 1746 synchronized (mStats) { 1747 mStats.noteConnectivityChangedLocked(type, extra, elapsedRealtime, uptime); 1748 } 1749 }); 1750 } 1751 } 1752 1753 @Override 1754 @EnforcePermission(UPDATE_DEVICE_STATS) noteMobileRadioPowerState(final int powerState, final long timestampNs, final int uid)1755 public void noteMobileRadioPowerState(final int powerState, final long timestampNs, 1756 final int uid) { 1757 super.noteMobileRadioPowerState_enforcePermission(); 1758 1759 synchronized (mLock) { 1760 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1761 final long uptime = SystemClock.uptimeMillis(); 1762 mHandler.post(() -> { 1763 synchronized (mStats) { 1764 // Ignore if no power state change. 1765 if (mLastPowerStateFromRadio == powerState) return; 1766 1767 mLastPowerStateFromRadio = powerState; 1768 mStats.noteMobileRadioPowerStateLocked(powerState, timestampNs, uid, 1769 elapsedRealtime, uptime); 1770 } 1771 }); 1772 } 1773 FrameworkStatsLog.write_non_chained( 1774 FrameworkStatsLog.MOBILE_RADIO_POWER_STATE_CHANGED, uid, null, powerState); 1775 } 1776 1777 @Override 1778 @EnforcePermission(UPDATE_DEVICE_STATS) notePhoneOn()1779 public void notePhoneOn() { 1780 super.notePhoneOn_enforcePermission(); 1781 1782 synchronized (mLock) { 1783 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1784 final long uptime = SystemClock.uptimeMillis(); 1785 mHandler.post(() -> { 1786 synchronized (mStats) { 1787 mStats.notePhoneOnLocked(elapsedRealtime, uptime); 1788 } 1789 }); 1790 } 1791 } 1792 1793 @Override 1794 @EnforcePermission(UPDATE_DEVICE_STATS) notePhoneOff()1795 public void notePhoneOff() { 1796 super.notePhoneOff_enforcePermission(); 1797 1798 synchronized (mLock) { 1799 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1800 final long uptime = SystemClock.uptimeMillis(); 1801 mHandler.post(() -> { 1802 synchronized (mStats) { 1803 mStats.notePhoneOffLocked(elapsedRealtime, uptime); 1804 } 1805 }); 1806 } 1807 } 1808 1809 @Override 1810 @EnforcePermission(UPDATE_DEVICE_STATS) notePhoneSignalStrength(final SignalStrength signalStrength)1811 public void notePhoneSignalStrength(final SignalStrength signalStrength) { 1812 super.notePhoneSignalStrength_enforcePermission(); 1813 1814 synchronized (mLock) { 1815 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1816 final long uptime = SystemClock.uptimeMillis(); 1817 mHandler.post(() -> { 1818 synchronized (mStats) { 1819 mStats.notePhoneSignalStrengthLocked(signalStrength, elapsedRealtime, uptime); 1820 } 1821 }); 1822 } 1823 } 1824 1825 @Override 1826 @EnforcePermission(UPDATE_DEVICE_STATS) notePhoneDataConnectionState(final int dataType, final boolean hasData, final int serviceType, @NetworkRegistrationInfo.NRState final int nrState, final int nrFrequency)1827 public void notePhoneDataConnectionState(final int dataType, final boolean hasData, 1828 final int serviceType, @NetworkRegistrationInfo.NRState final int nrState, 1829 final int nrFrequency) { 1830 super.notePhoneDataConnectionState_enforcePermission(); 1831 1832 synchronized (mLock) { 1833 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1834 final long uptime = SystemClock.uptimeMillis(); 1835 mHandler.post(() -> { 1836 synchronized (mStats) { 1837 mStats.notePhoneDataConnectionStateLocked(dataType, hasData, serviceType, 1838 nrState, nrFrequency, elapsedRealtime, uptime); 1839 } 1840 }); 1841 } 1842 } 1843 1844 @Override 1845 @EnforcePermission(UPDATE_DEVICE_STATS) notePhoneState(final int state)1846 public void notePhoneState(final int state) { 1847 super.notePhoneState_enforcePermission(); 1848 1849 synchronized (mLock) { 1850 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1851 final long uptime = SystemClock.uptimeMillis(); 1852 mHandler.post(() -> { 1853 int simState = mContext.getSystemService(TelephonyManager.class).getSimState(); 1854 synchronized (mStats) { 1855 mStats.notePhoneStateLocked(state, simState, elapsedRealtime, uptime); 1856 } 1857 }); 1858 } 1859 } 1860 1861 @Override 1862 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiOn()1863 public void noteWifiOn() { 1864 super.noteWifiOn_enforcePermission(); 1865 1866 synchronized (mLock) { 1867 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1868 final long uptime = SystemClock.uptimeMillis(); 1869 mHandler.post(() -> { 1870 synchronized (mStats) { 1871 mStats.noteWifiOnLocked(elapsedRealtime, uptime); 1872 } 1873 }); 1874 } 1875 FrameworkStatsLog.write(FrameworkStatsLog.WIFI_ENABLED_STATE_CHANGED, 1876 FrameworkStatsLog.WIFI_ENABLED_STATE_CHANGED__STATE__ON); 1877 } 1878 1879 @Override 1880 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiOff()1881 public void noteWifiOff() { 1882 super.noteWifiOff_enforcePermission(); 1883 1884 synchronized (mLock) { 1885 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1886 final long uptime = SystemClock.uptimeMillis(); 1887 mHandler.post(() -> { 1888 synchronized (mStats) { 1889 mStats.noteWifiOffLocked(elapsedRealtime, uptime); 1890 } 1891 }); 1892 } 1893 FrameworkStatsLog.write(FrameworkStatsLog.WIFI_ENABLED_STATE_CHANGED, 1894 FrameworkStatsLog.WIFI_ENABLED_STATE_CHANGED__STATE__OFF); 1895 } 1896 1897 @Override 1898 @EnforcePermission(UPDATE_DEVICE_STATS) noteStartAudio(final int uid)1899 public void noteStartAudio(final int uid) { 1900 super.noteStartAudio_enforcePermission(); 1901 1902 synchronized (mLock) { 1903 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1904 final long uptime = SystemClock.uptimeMillis(); 1905 mHandler.post(() -> { 1906 synchronized (mStats) { 1907 mStats.noteAudioOnLocked(uid, elapsedRealtime, uptime); 1908 } 1909 }); 1910 } 1911 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.AUDIO_STATE_CHANGED, uid, 1912 null, FrameworkStatsLog.AUDIO_STATE_CHANGED__STATE__ON); 1913 } 1914 1915 @Override 1916 @EnforcePermission(UPDATE_DEVICE_STATS) noteStopAudio(final int uid)1917 public void noteStopAudio(final int uid) { 1918 super.noteStopAudio_enforcePermission(); 1919 1920 synchronized (mLock) { 1921 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1922 final long uptime = SystemClock.uptimeMillis(); 1923 mHandler.post(() -> { 1924 synchronized (mStats) { 1925 mStats.noteAudioOffLocked(uid, elapsedRealtime, uptime); 1926 } 1927 }); 1928 } 1929 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.AUDIO_STATE_CHANGED, uid, 1930 null, FrameworkStatsLog.AUDIO_STATE_CHANGED__STATE__OFF); 1931 } 1932 1933 @Override 1934 @EnforcePermission(UPDATE_DEVICE_STATS) noteStartVideo(final int uid)1935 public void noteStartVideo(final int uid) { 1936 super.noteStartVideo_enforcePermission(); 1937 1938 synchronized (mLock) { 1939 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1940 final long uptime = SystemClock.uptimeMillis(); 1941 mHandler.post(() -> { 1942 synchronized (mStats) { 1943 mStats.noteVideoOnLocked(uid, elapsedRealtime, uptime); 1944 } 1945 }); 1946 } 1947 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.MEDIA_CODEC_STATE_CHANGED, 1948 uid, null, FrameworkStatsLog.MEDIA_CODEC_STATE_CHANGED__STATE__ON); 1949 } 1950 1951 @Override 1952 @EnforcePermission(UPDATE_DEVICE_STATS) noteStopVideo(final int uid)1953 public void noteStopVideo(final int uid) { 1954 super.noteStopVideo_enforcePermission(); 1955 1956 synchronized (mLock) { 1957 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1958 final long uptime = SystemClock.uptimeMillis(); 1959 mHandler.post(() -> { 1960 synchronized (mStats) { 1961 mStats.noteVideoOffLocked(uid, elapsedRealtime, uptime); 1962 } 1963 }); 1964 } 1965 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.MEDIA_CODEC_STATE_CHANGED, 1966 uid, null, FrameworkStatsLog.MEDIA_CODEC_STATE_CHANGED__STATE__OFF); 1967 } 1968 1969 @Override 1970 @EnforcePermission(UPDATE_DEVICE_STATS) noteResetAudio()1971 public void noteResetAudio() { 1972 super.noteResetAudio_enforcePermission(); 1973 1974 synchronized (mLock) { 1975 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1976 final long uptime = SystemClock.uptimeMillis(); 1977 mHandler.post(() -> { 1978 synchronized (mStats) { 1979 mStats.noteResetAudioLocked(elapsedRealtime, uptime); 1980 } 1981 }); 1982 } 1983 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.AUDIO_STATE_CHANGED, -1, null, 1984 FrameworkStatsLog.AUDIO_STATE_CHANGED__STATE__RESET); 1985 } 1986 1987 @Override 1988 @EnforcePermission(UPDATE_DEVICE_STATS) noteResetVideo()1989 public void noteResetVideo() { 1990 super.noteResetVideo_enforcePermission(); 1991 1992 synchronized (mLock) { 1993 final long elapsedRealtime = SystemClock.elapsedRealtime(); 1994 final long uptime = SystemClock.uptimeMillis(); 1995 mHandler.post(() -> { 1996 synchronized (mStats) { 1997 mStats.noteResetVideoLocked(elapsedRealtime, uptime); 1998 } 1999 }); 2000 } 2001 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.MEDIA_CODEC_STATE_CHANGED, -1, 2002 null, FrameworkStatsLog.MEDIA_CODEC_STATE_CHANGED__STATE__RESET); 2003 } 2004 2005 @Override 2006 @EnforcePermission(UPDATE_DEVICE_STATS) noteFlashlightOn(final int uid)2007 public void noteFlashlightOn(final int uid) { 2008 super.noteFlashlightOn_enforcePermission(); 2009 2010 synchronized (mLock) { 2011 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2012 final long uptime = SystemClock.uptimeMillis(); 2013 mHandler.post(() -> { 2014 synchronized (mStats) { 2015 mStats.noteFlashlightOnLocked(uid, elapsedRealtime, uptime); 2016 } 2017 }); 2018 } 2019 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.FLASHLIGHT_STATE_CHANGED, uid, 2020 null, FrameworkStatsLog.FLASHLIGHT_STATE_CHANGED__STATE__ON); 2021 } 2022 2023 @Override 2024 @EnforcePermission(UPDATE_DEVICE_STATS) noteFlashlightOff(final int uid)2025 public void noteFlashlightOff(final int uid) { 2026 super.noteFlashlightOff_enforcePermission(); 2027 2028 synchronized (mLock) { 2029 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2030 final long uptime = SystemClock.uptimeMillis(); 2031 mHandler.post(() -> { 2032 synchronized (mStats) { 2033 mStats.noteFlashlightOffLocked(uid, elapsedRealtime, uptime); 2034 } 2035 }); 2036 } 2037 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.FLASHLIGHT_STATE_CHANGED, uid, 2038 null, FrameworkStatsLog.FLASHLIGHT_STATE_CHANGED__STATE__OFF); 2039 } 2040 2041 @Override 2042 @EnforcePermission(UPDATE_DEVICE_STATS) noteStartCamera(final int uid)2043 public void noteStartCamera(final int uid) { 2044 super.noteStartCamera_enforcePermission(); 2045 2046 if (DBG) Slog.d(TAG, "begin noteStartCamera"); 2047 synchronized (mLock) { 2048 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2049 final long uptime = SystemClock.uptimeMillis(); 2050 mHandler.post(() -> { 2051 synchronized (mStats) { 2052 mStats.noteCameraOnLocked(uid, elapsedRealtime, uptime); 2053 } 2054 }); 2055 } 2056 if (DBG) Slog.d(TAG, "end noteStartCamera"); 2057 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.CAMERA_STATE_CHANGED, uid, 2058 null, FrameworkStatsLog.CAMERA_STATE_CHANGED__STATE__ON); 2059 } 2060 2061 @Override 2062 @EnforcePermission(UPDATE_DEVICE_STATS) noteStopCamera(final int uid)2063 public void noteStopCamera(final int uid) { 2064 super.noteStopCamera_enforcePermission(); 2065 2066 synchronized (mLock) { 2067 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2068 final long uptime = SystemClock.uptimeMillis(); 2069 mHandler.post(() -> { 2070 synchronized (mStats) { 2071 mStats.noteCameraOffLocked(uid, elapsedRealtime, uptime); 2072 } 2073 }); 2074 } 2075 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.CAMERA_STATE_CHANGED, uid, 2076 null, FrameworkStatsLog.CAMERA_STATE_CHANGED__STATE__OFF); 2077 } 2078 2079 @Override 2080 @EnforcePermission(UPDATE_DEVICE_STATS) noteResetCamera()2081 public void noteResetCamera() { 2082 super.noteResetCamera_enforcePermission(); 2083 2084 synchronized (mLock) { 2085 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2086 final long uptime = SystemClock.uptimeMillis(); 2087 mHandler.post(() -> { 2088 synchronized (mStats) { 2089 mStats.noteResetCameraLocked(elapsedRealtime, uptime); 2090 } 2091 }); 2092 } 2093 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.CAMERA_STATE_CHANGED, -1, 2094 null, FrameworkStatsLog.CAMERA_STATE_CHANGED__STATE__RESET); 2095 } 2096 2097 @Override 2098 @EnforcePermission(UPDATE_DEVICE_STATS) noteResetFlashlight()2099 public void noteResetFlashlight() { 2100 super.noteResetFlashlight_enforcePermission(); 2101 2102 synchronized (mLock) { 2103 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2104 final long uptime = SystemClock.uptimeMillis(); 2105 mHandler.post(() -> { 2106 synchronized (mStats) { 2107 mStats.noteResetFlashlightLocked(elapsedRealtime, uptime); 2108 } 2109 }); 2110 } 2111 FrameworkStatsLog.write_non_chained(FrameworkStatsLog.FLASHLIGHT_STATE_CHANGED, -1, 2112 null, FrameworkStatsLog.FLASHLIGHT_STATE_CHANGED__STATE__RESET); 2113 } 2114 2115 @Override 2116 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiRadioPowerState(final int powerState, final long tsNanos, final int uid)2117 public void noteWifiRadioPowerState(final int powerState, final long tsNanos, final int uid) { 2118 super.noteWifiRadioPowerState_enforcePermission(); 2119 2120 synchronized (mLock) { 2121 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2122 final long uptime = SystemClock.uptimeMillis(); 2123 mHandler.post(() -> { 2124 // There was a change in WiFi power state. 2125 // Collect data now for the past activity. 2126 synchronized (mStats) { 2127 // Ignore if no power state change. 2128 if (mLastPowerStateFromWifi == powerState) return; 2129 2130 mLastPowerStateFromWifi = powerState; 2131 if (mStats.isOnBattery()) { 2132 final String type = 2133 (powerState == DataConnectionRealTimeInfo.DC_POWER_STATE_HIGH 2134 || powerState == DataConnectionRealTimeInfo.DC_POWER_STATE_MEDIUM) 2135 ? "active" : "inactive"; 2136 mWorker.scheduleSync("wifi-data: " + type, 2137 BatteryExternalStatsWorker.UPDATE_WIFI); 2138 } 2139 mStats.noteWifiRadioPowerState(powerState, tsNanos, uid, 2140 elapsedRealtime, uptime); 2141 } 2142 }); 2143 } 2144 FrameworkStatsLog.write_non_chained( 2145 FrameworkStatsLog.WIFI_RADIO_POWER_STATE_CHANGED, uid, null, powerState); 2146 } 2147 2148 @Override 2149 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiRunning(final WorkSource ws)2150 public void noteWifiRunning(final WorkSource ws) { 2151 super.noteWifiRunning_enforcePermission(); 2152 2153 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2154 synchronized (mLock) { 2155 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2156 final long uptime = SystemClock.uptimeMillis(); 2157 mHandler.post(() -> { 2158 synchronized (mStats) { 2159 mStats.noteWifiRunningLocked(localWs, elapsedRealtime, uptime); 2160 } 2161 }); 2162 } 2163 // TODO: Log WIFI_RUNNING_STATE_CHANGED in a better spot to include Hotspot too. 2164 FrameworkStatsLog.write(FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED, 2165 ws, FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED__STATE__ON); 2166 } 2167 2168 @Override 2169 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiRunningChanged(final WorkSource oldWs, final WorkSource newWs)2170 public void noteWifiRunningChanged(final WorkSource oldWs, final WorkSource newWs) { 2171 super.noteWifiRunningChanged_enforcePermission(); 2172 2173 final WorkSource localOldWs = oldWs != null ? new WorkSource(oldWs) : null; 2174 final WorkSource localNewWs = newWs != null ? new WorkSource(newWs) : null; 2175 synchronized (mLock) { 2176 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2177 final long uptime = SystemClock.uptimeMillis(); 2178 mHandler.post(() -> { 2179 synchronized (mStats) { 2180 mStats.noteWifiRunningChangedLocked( 2181 localOldWs, localNewWs, elapsedRealtime, uptime); 2182 } 2183 }); 2184 } 2185 FrameworkStatsLog.write(FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED, 2186 newWs, FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED__STATE__ON); 2187 FrameworkStatsLog.write(FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED, 2188 oldWs, FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED__STATE__OFF); 2189 } 2190 2191 @Override 2192 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiStopped(final WorkSource ws)2193 public void noteWifiStopped(final WorkSource ws) { 2194 super.noteWifiStopped_enforcePermission(); 2195 2196 final WorkSource localWs = ws != null ? new WorkSource(ws) : ws; 2197 synchronized (mLock) { 2198 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2199 final long uptime = SystemClock.uptimeMillis(); 2200 mHandler.post(() -> { 2201 synchronized (mStats) { 2202 mStats.noteWifiStoppedLocked(localWs, elapsedRealtime, uptime); 2203 } 2204 }); 2205 } 2206 FrameworkStatsLog.write(FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED, 2207 ws, FrameworkStatsLog.WIFI_RUNNING_STATE_CHANGED__STATE__OFF); 2208 } 2209 2210 @Override 2211 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiState(final int wifiState, final String accessPoint)2212 public void noteWifiState(final int wifiState, final String accessPoint) { 2213 super.noteWifiState_enforcePermission(); 2214 2215 synchronized (mLock) { 2216 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2217 mHandler.post(() -> { 2218 synchronized (mStats) { 2219 mStats.noteWifiStateLocked(wifiState, accessPoint, elapsedRealtime); 2220 } 2221 }); 2222 } 2223 } 2224 2225 @Override 2226 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiSupplicantStateChanged(final int supplState, final boolean failedAuth)2227 public void noteWifiSupplicantStateChanged(final int supplState, final boolean failedAuth) { 2228 super.noteWifiSupplicantStateChanged_enforcePermission(); 2229 2230 synchronized (mLock) { 2231 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2232 final long uptime = SystemClock.uptimeMillis(); 2233 mHandler.post(() -> { 2234 synchronized (mStats) { 2235 mStats.noteWifiSupplicantStateChangedLocked(supplState, failedAuth, 2236 elapsedRealtime, uptime); 2237 } 2238 }); 2239 } 2240 } 2241 2242 @Override 2243 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiRssiChanged(final int newRssi)2244 public void noteWifiRssiChanged(final int newRssi) { 2245 super.noteWifiRssiChanged_enforcePermission(); 2246 2247 synchronized (mLock) { 2248 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2249 final long uptime = SystemClock.uptimeMillis(); 2250 mHandler.post(() -> { 2251 synchronized (mStats) { 2252 mStats.noteWifiRssiChangedLocked(newRssi, elapsedRealtime, uptime); 2253 } 2254 }); 2255 } 2256 } 2257 2258 @Override 2259 @EnforcePermission(UPDATE_DEVICE_STATS) noteFullWifiLockAcquired(final int uid)2260 public void noteFullWifiLockAcquired(final int uid) { 2261 super.noteFullWifiLockAcquired_enforcePermission(); 2262 2263 synchronized (mLock) { 2264 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2265 final long uptime = SystemClock.uptimeMillis(); 2266 mHandler.post(() -> { 2267 synchronized (mStats) { 2268 mStats.noteFullWifiLockAcquiredLocked(uid, elapsedRealtime, uptime); 2269 } 2270 }); 2271 } 2272 } 2273 2274 @Override 2275 @EnforcePermission(UPDATE_DEVICE_STATS) noteFullWifiLockReleased(final int uid)2276 public void noteFullWifiLockReleased(final int uid) { 2277 super.noteFullWifiLockReleased_enforcePermission(); 2278 2279 synchronized (mLock) { 2280 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2281 final long uptime = SystemClock.uptimeMillis(); 2282 mHandler.post(() -> { 2283 synchronized (mStats) { 2284 mStats.noteFullWifiLockReleasedLocked(uid, elapsedRealtime, uptime); 2285 } 2286 }); 2287 } 2288 } 2289 2290 @Override 2291 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiScanStarted(final int uid)2292 public void noteWifiScanStarted(final int uid) { 2293 super.noteWifiScanStarted_enforcePermission(); 2294 2295 synchronized (mLock) { 2296 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2297 final long uptime = SystemClock.uptimeMillis(); 2298 mHandler.post(() -> { 2299 synchronized (mStats) { 2300 mStats.noteWifiScanStartedLocked(uid, elapsedRealtime, uptime); 2301 } 2302 }); 2303 } 2304 } 2305 2306 @Override 2307 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiScanStopped(final int uid)2308 public void noteWifiScanStopped(final int uid) { 2309 super.noteWifiScanStopped_enforcePermission(); 2310 2311 synchronized (mLock) { 2312 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2313 final long uptime = SystemClock.uptimeMillis(); 2314 mHandler.post(() -> { 2315 synchronized (mStats) { 2316 mStats.noteWifiScanStoppedLocked(uid, elapsedRealtime, uptime); 2317 } 2318 }); 2319 } 2320 } 2321 2322 @Override 2323 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiMulticastEnabled(final int uid)2324 public void noteWifiMulticastEnabled(final int uid) { 2325 super.noteWifiMulticastEnabled_enforcePermission(); 2326 2327 synchronized (mLock) { 2328 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2329 final long uptime = SystemClock.uptimeMillis(); 2330 mHandler.post(() -> { 2331 synchronized (mStats) { 2332 mStats.noteWifiMulticastEnabledLocked(uid, elapsedRealtime, uptime); 2333 } 2334 }); 2335 } 2336 } 2337 2338 @Override 2339 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiMulticastDisabled(final int uid)2340 public void noteWifiMulticastDisabled(final int uid) { 2341 super.noteWifiMulticastDisabled_enforcePermission(); 2342 2343 synchronized (mLock) { 2344 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2345 final long uptime = SystemClock.uptimeMillis(); 2346 mHandler.post(() -> { 2347 synchronized (mStats) { 2348 mStats.noteWifiMulticastDisabledLocked(uid, elapsedRealtime, uptime); 2349 } 2350 }); 2351 } 2352 } 2353 2354 @Override 2355 @EnforcePermission(UPDATE_DEVICE_STATS) noteFullWifiLockAcquiredFromSource(final WorkSource ws)2356 public void noteFullWifiLockAcquiredFromSource(final WorkSource ws) { 2357 super.noteFullWifiLockAcquiredFromSource_enforcePermission(); 2358 2359 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2360 synchronized (mLock) { 2361 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2362 final long uptime = SystemClock.uptimeMillis(); 2363 mHandler.post(() -> { 2364 synchronized (mStats) { 2365 mStats.noteFullWifiLockAcquiredFromSourceLocked( 2366 localWs, elapsedRealtime, uptime); 2367 } 2368 }); 2369 } 2370 } 2371 2372 @Override 2373 @EnforcePermission(UPDATE_DEVICE_STATS) noteFullWifiLockReleasedFromSource(final WorkSource ws)2374 public void noteFullWifiLockReleasedFromSource(final WorkSource ws) { 2375 super.noteFullWifiLockReleasedFromSource_enforcePermission(); 2376 2377 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2378 synchronized (mLock) { 2379 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2380 final long uptime = SystemClock.uptimeMillis(); 2381 mHandler.post(() -> { 2382 synchronized (mStats) { 2383 mStats.noteFullWifiLockReleasedFromSourceLocked( 2384 localWs, elapsedRealtime, uptime); 2385 } 2386 }); 2387 } 2388 } 2389 2390 @Override 2391 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiScanStartedFromSource(final WorkSource ws)2392 public void noteWifiScanStartedFromSource(final WorkSource ws) { 2393 super.noteWifiScanStartedFromSource_enforcePermission(); 2394 2395 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2396 synchronized (mLock) { 2397 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2398 final long uptime = SystemClock.uptimeMillis(); 2399 mHandler.post(() -> { 2400 synchronized (mStats) { 2401 mStats.noteWifiScanStartedFromSourceLocked(localWs, elapsedRealtime, uptime); 2402 } 2403 }); 2404 } 2405 } 2406 2407 @Override 2408 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiScanStoppedFromSource(final WorkSource ws)2409 public void noteWifiScanStoppedFromSource(final WorkSource ws) { 2410 super.noteWifiScanStoppedFromSource_enforcePermission(); 2411 2412 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2413 synchronized (mLock) { 2414 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2415 final long uptime = SystemClock.uptimeMillis(); 2416 mHandler.post(() -> { 2417 synchronized (mStats) { 2418 mStats.noteWifiScanStoppedFromSourceLocked(localWs, elapsedRealtime, uptime); 2419 } 2420 }); 2421 } 2422 } 2423 2424 @Override 2425 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiBatchedScanStartedFromSource(final WorkSource ws, final int csph)2426 public void noteWifiBatchedScanStartedFromSource(final WorkSource ws, final int csph) { 2427 super.noteWifiBatchedScanStartedFromSource_enforcePermission(); 2428 2429 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2430 synchronized (mLock) { 2431 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2432 final long uptime = SystemClock.uptimeMillis(); 2433 mHandler.post(() -> { 2434 synchronized (mStats) { 2435 mStats.noteWifiBatchedScanStartedFromSourceLocked(localWs, csph, 2436 elapsedRealtime, uptime); 2437 } 2438 }); 2439 } 2440 } 2441 2442 @Override 2443 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiBatchedScanStoppedFromSource(final WorkSource ws)2444 public void noteWifiBatchedScanStoppedFromSource(final WorkSource ws) { 2445 super.noteWifiBatchedScanStoppedFromSource_enforcePermission(); 2446 2447 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2448 synchronized (mLock) { 2449 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2450 final long uptime = SystemClock.uptimeMillis(); 2451 mHandler.post(() -> { 2452 synchronized (mStats) { 2453 mStats.noteWifiBatchedScanStoppedFromSourceLocked( 2454 localWs, elapsedRealtime, uptime); 2455 } 2456 }); 2457 } 2458 } 2459 2460 @Override 2461 @EnforcePermission(anyOf = {NETWORK_STACK, PERMISSION_MAINLINE_NETWORK_STACK}) noteNetworkInterfaceForTransports(final String iface, int[] transportTypes)2462 public void noteNetworkInterfaceForTransports(final String iface, int[] transportTypes) { 2463 super.noteNetworkInterfaceForTransports_enforcePermission(); 2464 2465 synchronized (mLock) { 2466 mHandler.post(() -> { 2467 mStats.noteNetworkInterfaceForTransports(iface, transportTypes); 2468 }); 2469 } 2470 } 2471 2472 @Override 2473 @EnforcePermission(UPDATE_DEVICE_STATS) noteNetworkStatsEnabled()2474 public void noteNetworkStatsEnabled() { 2475 // During device boot, qtaguid isn't enabled until after the inital 2476 // loading of battery stats. Now that they're enabled, take our initial 2477 // snapshot for future delta calculation. 2478 super.noteNetworkStatsEnabled_enforcePermission(); 2479 2480 synchronized (mLock) { 2481 // Still schedule it on the handler to make sure we have existing pending works done 2482 mHandler.post(() -> { 2483 mWorker.scheduleSync("network-stats-enabled", 2484 BatteryExternalStatsWorker.UPDATE_RADIO 2485 | BatteryExternalStatsWorker.UPDATE_WIFI); 2486 }); 2487 } 2488 } 2489 2490 @Override 2491 @EnforcePermission(UPDATE_DEVICE_STATS) noteDeviceIdleMode(final int mode, final String activeReason, final int activeUid)2492 public void noteDeviceIdleMode(final int mode, final String activeReason, final int activeUid) { 2493 super.noteDeviceIdleMode_enforcePermission(); 2494 2495 synchronized (mLock) { 2496 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2497 final long uptime = SystemClock.uptimeMillis(); 2498 mHandler.post(() -> { 2499 synchronized (mStats) { 2500 mStats.noteDeviceIdleModeLocked(mode, activeReason, activeUid, 2501 elapsedRealtime, uptime); 2502 } 2503 }); 2504 } 2505 } 2506 notePackageInstalled(final String pkgName, final long versionCode)2507 public void notePackageInstalled(final String pkgName, final long versionCode) { 2508 synchronized (mLock) { 2509 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2510 final long uptime = SystemClock.uptimeMillis(); 2511 mHandler.post(() -> { 2512 synchronized (mStats) { 2513 mStats.notePackageInstalledLocked(pkgName, versionCode, 2514 elapsedRealtime, uptime); 2515 } 2516 }); 2517 } 2518 } 2519 notePackageUninstalled(final String pkgName)2520 public void notePackageUninstalled(final String pkgName) { 2521 synchronized (mLock) { 2522 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2523 final long uptime = SystemClock.uptimeMillis(); 2524 mHandler.post(() -> { 2525 synchronized (mStats) { 2526 mStats.notePackageUninstalledLocked(pkgName, elapsedRealtime, uptime); 2527 } 2528 }); 2529 } 2530 } 2531 2532 @Override 2533 @EnforcePermission(UPDATE_DEVICE_STATS) noteBleScanStarted(final WorkSource ws, final boolean isUnoptimized)2534 public void noteBleScanStarted(final WorkSource ws, final boolean isUnoptimized) { 2535 super.noteBleScanStarted_enforcePermission(); 2536 2537 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2538 synchronized (mLock) { 2539 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2540 final long uptime = SystemClock.uptimeMillis(); 2541 mHandler.post(() -> { 2542 synchronized (mStats) { 2543 mStats.noteBluetoothScanStartedFromSourceLocked(localWs, isUnoptimized, 2544 elapsedRealtime, uptime); 2545 } 2546 }); 2547 } 2548 } 2549 2550 @Override 2551 @EnforcePermission(UPDATE_DEVICE_STATS) noteBleScanStopped(final WorkSource ws, final boolean isUnoptimized)2552 public void noteBleScanStopped(final WorkSource ws, final boolean isUnoptimized) { 2553 super.noteBleScanStopped_enforcePermission(); 2554 2555 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2556 synchronized (mLock) { 2557 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2558 final long uptime = SystemClock.uptimeMillis(); 2559 mHandler.post(() -> { 2560 synchronized (mStats) { 2561 mStats.noteBluetoothScanStoppedFromSourceLocked(localWs, isUnoptimized, 2562 elapsedRealtime, uptime); 2563 } 2564 }); 2565 } 2566 } 2567 2568 @Override 2569 @EnforcePermission(UPDATE_DEVICE_STATS) noteBleScanReset()2570 public void noteBleScanReset() { 2571 super.noteBleScanReset_enforcePermission(); 2572 2573 synchronized (mLock) { 2574 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2575 final long uptime = SystemClock.uptimeMillis(); 2576 mHandler.post(() -> { 2577 synchronized (mStats) { 2578 mStats.noteResetBluetoothScanLocked(elapsedRealtime, uptime); 2579 } 2580 }); 2581 } 2582 } 2583 2584 @Override 2585 @EnforcePermission(UPDATE_DEVICE_STATS) noteBleScanResults(final WorkSource ws, final int numNewResults)2586 public void noteBleScanResults(final WorkSource ws, final int numNewResults) { 2587 super.noteBleScanResults_enforcePermission(); 2588 2589 final WorkSource localWs = ws != null ? new WorkSource(ws) : null; 2590 synchronized (mLock) { 2591 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2592 final long uptime = SystemClock.uptimeMillis(); 2593 mHandler.post(() -> { 2594 synchronized (mStats) { 2595 mStats.noteBluetoothScanResultsFromSourceLocked(localWs, numNewResults, 2596 elapsedRealtime, uptime); 2597 } 2598 }); 2599 } 2600 } 2601 2602 @Override 2603 @EnforcePermission(UPDATE_DEVICE_STATS) noteWifiControllerActivity(final WifiActivityEnergyInfo info)2604 public void noteWifiControllerActivity(final WifiActivityEnergyInfo info) { 2605 super.noteWifiControllerActivity_enforcePermission(); 2606 2607 if (info == null || !info.isValid()) { 2608 Slog.e(TAG, "invalid wifi data given: " + info); 2609 return; 2610 } 2611 2612 synchronized (mLock) { 2613 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2614 final long uptime = SystemClock.uptimeMillis(); 2615 final NetworkStatsManager networkStatsManager = mContext.getSystemService( 2616 NetworkStatsManager.class); 2617 mHandler.post(() -> { 2618 mStats.updateWifiState(info, POWER_DATA_UNAVAILABLE, elapsedRealtime, uptime, 2619 networkStatsManager); 2620 }); 2621 } 2622 } 2623 2624 @Override 2625 @EnforcePermission(UPDATE_DEVICE_STATS) noteBluetoothControllerActivity(final BluetoothActivityEnergyInfo info)2626 public void noteBluetoothControllerActivity(final BluetoothActivityEnergyInfo info) { 2627 super.noteBluetoothControllerActivity_enforcePermission(); 2628 2629 if (info == null || !info.isValid()) { 2630 Slog.e(TAG, "invalid bluetooth data given: " + info); 2631 return; 2632 } 2633 2634 synchronized (mLock) { 2635 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2636 final long uptime = SystemClock.uptimeMillis(); 2637 mHandler.post(() -> { 2638 synchronized (mStats) { 2639 mStats.updateBluetoothStateLocked( 2640 info, POWER_DATA_UNAVAILABLE, elapsedRealtime, uptime); 2641 } 2642 }); 2643 } 2644 } 2645 2646 @Override 2647 @EnforcePermission(UPDATE_DEVICE_STATS) noteModemControllerActivity(final ModemActivityInfo info)2648 public void noteModemControllerActivity(final ModemActivityInfo info) { 2649 super.noteModemControllerActivity_enforcePermission(); 2650 2651 if (info == null) { 2652 Slog.e(TAG, "invalid modem data given: " + info); 2653 return; 2654 } 2655 2656 synchronized (mLock) { 2657 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2658 final long uptime = SystemClock.uptimeMillis(); 2659 final NetworkStatsManager networkStatsManager = mContext.getSystemService( 2660 NetworkStatsManager.class); 2661 mHandler.post(() -> { 2662 mStats.noteModemControllerActivity(info, POWER_DATA_UNAVAILABLE, elapsedRealtime, 2663 uptime, networkStatsManager); 2664 }); 2665 } 2666 } 2667 isOnBattery()2668 public boolean isOnBattery() { 2669 return mStats.isOnBattery(); 2670 } 2671 2672 @Override 2673 @EnforcePermission(UPDATE_DEVICE_STATS) setBatteryState(final int status, final int health, final int plugType, final int level, final int temp, final int volt, final int chargeUAh, final int chargeFullUAh, final long chargeTimeToFullSeconds)2674 public void setBatteryState(final int status, final int health, final int plugType, 2675 final int level, final int temp, final int volt, final int chargeUAh, 2676 final int chargeFullUAh, final long chargeTimeToFullSeconds) { 2677 super.setBatteryState_enforcePermission(); 2678 2679 synchronized (mLock) { 2680 final long elapsedRealtime = SystemClock.elapsedRealtime(); 2681 final long uptime = SystemClock.uptimeMillis(); 2682 final long currentTime = System.currentTimeMillis(); 2683 // We still schedule this task over the handler thread to make sure we've had 2684 // all existing pending work handled before setting the battery state 2685 mHandler.post(() -> { 2686 // BatteryService calls us here and we may update external state. It would be wrong 2687 // to block such a low level service like BatteryService on external stats like WiFi 2688 mWorker.scheduleRunnable(() -> { 2689 synchronized (mStats) { 2690 final boolean onBattery = BatteryStatsImpl.isOnBattery(plugType, status); 2691 if (mStats.isOnBattery() == onBattery) { 2692 // The battery state has not changed, so we don't need to sync external 2693 // stats immediately. 2694 mStats.setBatteryStateLocked(status, health, plugType, level, temp, 2695 volt, chargeUAh, chargeFullUAh, chargeTimeToFullSeconds, 2696 elapsedRealtime, uptime, currentTime); 2697 return; 2698 } 2699 } 2700 2701 // Sync external stats first as the battery has changed states. If we don't sync 2702 // before changing the state, we may not collect the relevant data later. 2703 // Order here is guaranteed since we're scheduling from the same thread and we 2704 // are using a single threaded executor. 2705 mWorker.scheduleSync("battery-state", BatteryExternalStatsWorker.UPDATE_ALL); 2706 mWorker.scheduleRunnable(() -> { 2707 synchronized (mStats) { 2708 mStats.setBatteryStateLocked(status, health, plugType, level, temp, 2709 volt, chargeUAh, chargeFullUAh, chargeTimeToFullSeconds, 2710 elapsedRealtime, uptime, currentTime); 2711 } 2712 }); 2713 }); 2714 }); 2715 } 2716 } 2717 2718 @Override 2719 @EnforcePermission(BATTERY_STATS) getAwakeTimeBattery()2720 public long getAwakeTimeBattery() { 2721 super.getAwakeTimeBattery_enforcePermission(); 2722 2723 return mStats.getAwakeTimeBattery(); 2724 } 2725 2726 @Override 2727 @EnforcePermission(BATTERY_STATS) getAwakeTimePlugged()2728 public long getAwakeTimePlugged() { 2729 super.getAwakeTimePlugged_enforcePermission(); 2730 2731 return mStats.getAwakeTimePlugged(); 2732 } 2733 2734 final class WakeupReasonThread extends Thread { 2735 private static final int MAX_REASON_SIZE = 512; 2736 private CharsetDecoder mDecoder; 2737 private ByteBuffer mUtf8Buffer; 2738 private CharBuffer mUtf16Buffer; 2739 WakeupReasonThread()2740 WakeupReasonThread() { 2741 super("BatteryStats_wakeupReason"); 2742 } 2743 run()2744 public void run() { 2745 Process.setThreadPriority(Process.THREAD_PRIORITY_FOREGROUND); 2746 2747 mDecoder = StandardCharsets.UTF_8 2748 .newDecoder() 2749 .onMalformedInput(CodingErrorAction.REPLACE) 2750 .onUnmappableCharacter(CodingErrorAction.REPLACE) 2751 .replaceWith("?"); 2752 2753 mUtf8Buffer = ByteBuffer.allocateDirect(MAX_REASON_SIZE); 2754 mUtf16Buffer = CharBuffer.allocate(MAX_REASON_SIZE); 2755 2756 try { 2757 String reason; 2758 while ((reason = waitWakeup()) != null) { 2759 final long nowElapsed = SystemClock.elapsedRealtime(); 2760 final long nowUptime = SystemClock.uptimeMillis(); 2761 2762 Trace.instantForTrack(Trace.TRACE_TAG_POWER, TRACE_TRACK_WAKEUP_REASON, 2763 nowElapsed + " " + reason); 2764 2765 // Wait for the completion of pending works if there is any 2766 awaitCompletion(); 2767 mCpuWakeupStats.noteWakeupTimeAndReason(nowElapsed, nowUptime, reason); 2768 synchronized (mStats) { 2769 mStats.noteWakeupReasonLocked(reason, nowElapsed, nowUptime); 2770 } 2771 } 2772 } catch (RuntimeException e) { 2773 Slog.e(TAG, "Failure reading wakeup reasons", e); 2774 } 2775 } 2776 waitWakeup()2777 private String waitWakeup() { 2778 mUtf8Buffer.clear(); 2779 mUtf16Buffer.clear(); 2780 mDecoder.reset(); 2781 2782 int bytesWritten = nativeWaitWakeup(mUtf8Buffer); 2783 if (bytesWritten < 0) { 2784 return null; 2785 } else if (bytesWritten == 0) { 2786 return "unknown"; 2787 } 2788 2789 // Set the buffer's limit to the number of bytes written. 2790 mUtf8Buffer.limit(bytesWritten); 2791 2792 // Decode the buffer from UTF-8 to UTF-16. 2793 // Unmappable characters will be replaced. 2794 mDecoder.decode(mUtf8Buffer, mUtf16Buffer, true); 2795 mUtf16Buffer.flip(); 2796 2797 // Create a String from the UTF-16 buffer. 2798 return mUtf16Buffer.toString(); 2799 } 2800 } 2801 nativeWaitWakeup(ByteBuffer outBuffer)2802 private static native int nativeWaitWakeup(ByteBuffer outBuffer); 2803 dumpHelp(PrintWriter pw)2804 private void dumpHelp(PrintWriter pw) { 2805 pw.println("Battery stats (batterystats) dump options:"); 2806 pw.println(" [--checkin] [--proto] [--history] [--history-start] [--charged] [-c]"); 2807 pw.println(" [--daily] [--reset] [--reset-all] [--write] [--new-daily] [--read-daily]"); 2808 pw.println(" [-h] [<package.name>]"); 2809 pw.println(" --checkin: generate output for a checkin report; will write (and clear) the"); 2810 pw.println(" last old completed stats when they had been reset."); 2811 pw.println(" -c: write the current stats in checkin format."); 2812 pw.println(" --proto: write the current aggregate stats (without history) in proto format."); 2813 pw.println(" --history: show only history data."); 2814 pw.println(" --history-start <num>: show only history data starting at given time offset."); 2815 pw.println(" --history-create-events <num>: create <num> of battery history events."); 2816 pw.println(" --charged: only output data since last charged."); 2817 pw.println(" --daily: only output full daily data."); 2818 pw.println(" --reset: reset the stats, clearing all current data."); 2819 pw.println(" --reset-all: reset the stats, clearing all current and past data."); 2820 pw.println(" --write: force write current collected stats to disk."); 2821 pw.println(" --new-daily: immediately create and write new daily stats record."); 2822 pw.println(" --read-daily: read-load last written daily stats."); 2823 pw.println(" --settings: dump the settings key/values related to batterystats"); 2824 pw.println(" --cpu: dump cpu stats for debugging purpose"); 2825 pw.println(" --wakeups: dump CPU wakeup history and attribution."); 2826 pw.println(" --power-profile: dump the power profile constants"); 2827 pw.println(" --usage: write battery usage stats. Optional arguments:"); 2828 pw.println(" --proto: output as a binary protobuffer"); 2829 pw.println(" --model power-profile: use the power profile model" 2830 + " even if measured energy is available"); 2831 if (Flags.streamlinedBatteryStats()) { 2832 pw.println(" --sample: collect and dump a sample of stats for debugging purpose"); 2833 } 2834 pw.println(" <package.name>: optional name of package to filter output by."); 2835 pw.println(" -h: print this help text."); 2836 pw.println("Battery stats (batterystats) commands:"); 2837 pw.println(" enable|disable <option>"); 2838 pw.println(" Enable or disable a running option. Option state is not saved across boots."); 2839 pw.println(" Options are:"); 2840 pw.println(" full-history: include additional detailed events in battery history:"); 2841 pw.println(" wake_lock_in, alarms and proc events"); 2842 pw.println(" no-auto-reset: don't automatically reset stats when unplugged"); 2843 pw.println(" pretend-screen-off: pretend the screen is off, even if screen state changes"); 2844 } 2845 dumpSettings(PrintWriter pw)2846 private void dumpSettings(PrintWriter pw) { 2847 // Wait for the completion of pending works if there is any 2848 awaitCompletion(); 2849 synchronized (mStats) { 2850 mStats.dumpConstantsLocked(pw); 2851 2852 pw.println("Flags:"); 2853 pw.println(" " + Flags.FLAG_STREAMLINED_BATTERY_STATS 2854 + ": " + Flags.streamlinedBatteryStats()); 2855 } 2856 } 2857 dumpCpuStats(PrintWriter pw)2858 private void dumpCpuStats(PrintWriter pw) { 2859 // Wait for the completion of pending works if there is any 2860 awaitCompletion(); 2861 synchronized (mStats) { 2862 mStats.dumpCpuStatsLocked(pw); 2863 } 2864 } 2865 dumpStatsSample(PrintWriter pw)2866 private void dumpStatsSample(PrintWriter pw) { 2867 mStats.dumpStatsSample(pw); 2868 } 2869 dumpAggregatedStats(PrintWriter pw)2870 private void dumpAggregatedStats(PrintWriter pw) { 2871 mPowerStatsScheduler.aggregateAndDumpPowerStats(pw); 2872 } 2873 dumpPowerStatsStore(PrintWriter pw)2874 private void dumpPowerStatsStore(PrintWriter pw) { 2875 mPowerStatsStore.dump(new IndentingPrintWriter(pw, " ")); 2876 } 2877 dumpPowerStatsStoreTableOfContents(PrintWriter pw)2878 private void dumpPowerStatsStoreTableOfContents(PrintWriter pw) { 2879 mPowerStatsStore.dumpTableOfContents(new IndentingPrintWriter(pw, " ")); 2880 } 2881 dumpMeasuredEnergyStats(PrintWriter pw)2882 private void dumpMeasuredEnergyStats(PrintWriter pw) { 2883 // Wait for the completion of pending works if there is any 2884 awaitCompletion(); 2885 syncStats("dump", BatteryExternalStatsWorker.UPDATE_ALL); 2886 synchronized (mStats) { 2887 mStats.dumpEnergyConsumerStatsLocked(pw); 2888 } 2889 } 2890 dumpPowerProfile(PrintWriter pw)2891 private void dumpPowerProfile(PrintWriter pw) { 2892 synchronized (mStats) { 2893 mStats.dumpPowerProfileLocked(pw); 2894 } 2895 } 2896 dumpUsageStats(FileDescriptor fd, PrintWriter pw, int model, boolean proto)2897 private void dumpUsageStats(FileDescriptor fd, PrintWriter pw, int model, 2898 boolean proto) { 2899 awaitCompletion(); 2900 syncStats("dump", BatteryExternalStatsWorker.UPDATE_ALL); 2901 2902 BatteryUsageStatsQuery.Builder builder = new BatteryUsageStatsQuery.Builder() 2903 .setMaxStatsAgeMs(0) 2904 .includeProcessStateData() 2905 .includePowerModels(); 2906 if (model == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { 2907 builder.powerProfileModeledOnly(); 2908 } 2909 BatteryUsageStatsQuery query = builder.build(); 2910 synchronized (mStats) { 2911 mStats.prepareForDumpLocked(); 2912 } 2913 if (Flags.streamlinedBatteryStats()) { 2914 // Important: perform this operation outside the mStats lock, because it will 2915 // need to access BatteryStats from a handler thread 2916 mStats.collectPowerStatsSamples(); 2917 } 2918 2919 BatteryUsageStats batteryUsageStats = 2920 mBatteryUsageStatsProvider.getBatteryUsageStats(mStats, query); 2921 if (proto) { 2922 batteryUsageStats.dumpToProto(fd); 2923 } else { 2924 batteryUsageStats.dump(pw, ""); 2925 } 2926 } 2927 doEnableOrDisable(PrintWriter pw, int i, String[] args, boolean enable)2928 private int doEnableOrDisable(PrintWriter pw, int i, String[] args, boolean enable) { 2929 i++; 2930 if (i >= args.length) { 2931 pw.println("Missing option argument for " + (enable ? "--enable" : "--disable")); 2932 dumpHelp(pw); 2933 return -1; 2934 } 2935 if ("full-wake-history".equals(args[i]) || "full-history".equals(args[i])) { 2936 // Wait for the completion of pending works if there is any 2937 awaitCompletion(); 2938 synchronized (mStats) { 2939 mStats.setRecordAllHistoryLocked(enable); 2940 } 2941 } else if ("no-auto-reset".equals(args[i])) { 2942 // Wait for the completion of pending works if there is any 2943 awaitCompletion(); 2944 synchronized (mStats) { 2945 mStats.setNoAutoReset(enable); 2946 } 2947 } else if ("pretend-screen-off".equals(args[i])) { 2948 // Wait for the completion of pending works if there is any 2949 awaitCompletion(); 2950 synchronized (mStats) { 2951 mStats.setPretendScreenOff(enable); 2952 } 2953 } else { 2954 pw.println("Unknown enable/disable option: " + args[i]); 2955 dumpHelp(pw); 2956 return -1; 2957 } 2958 return i; 2959 } 2960 2961 2962 @Override dump(FileDescriptor fd, PrintWriter pw, String[] args)2963 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 2964 // If the monitor() method is already holding a lock on mStats, no harm done: we will 2965 // just wait for mStats in the dumpUnmonitored method below. In fact, we would want 2966 // Watchdog to catch the service in the act in that situation. We just don't want the 2967 // dump method itself to be blamed for holding the lock for too long. 2968 mMonitorEnabled = false; 2969 try { 2970 dumpUnmonitored(fd, pw, args); 2971 } finally { 2972 mMonitorEnabled = true; 2973 } 2974 } 2975 dumpUnmonitored(FileDescriptor fd, PrintWriter pw, String[] args)2976 private void dumpUnmonitored(FileDescriptor fd, PrintWriter pw, String[] args) { 2977 if (!DumpUtils.checkDumpAndUsageStatsPermission(mContext, TAG, pw)) return; 2978 2979 int flags = 0; 2980 boolean useCheckinFormat = false; 2981 boolean toProto = false; 2982 boolean isRealCheckin = false; 2983 boolean noOutput = false; 2984 boolean writeData = false; 2985 long historyStart = -1; 2986 int reqUid = -1; 2987 if (args != null) { 2988 for (int i=0; i<args.length; i++) { 2989 String arg = args[i]; 2990 if ("--checkin".equals(arg)) { 2991 useCheckinFormat = true; 2992 isRealCheckin = true; 2993 } else if ("--history".equals(arg)) { 2994 flags |= BatteryStats.DUMP_HISTORY_ONLY; 2995 } else if ("--history-start".equals(arg)) { 2996 flags |= BatteryStats.DUMP_HISTORY_ONLY; 2997 i++; 2998 if (i >= args.length) { 2999 pw.println("Missing time argument for --history-since"); 3000 dumpHelp(pw); 3001 return; 3002 } 3003 historyStart = ParseUtils.parseLong(args[i], 0); 3004 writeData = true; 3005 } else if ("--history-create-events".equals(arg)) { 3006 i++; 3007 if (i >= args.length) { 3008 pw.println("Missing events argument for --history-create-events"); 3009 dumpHelp(pw); 3010 return; 3011 } 3012 final long events = ParseUtils.parseLong(args[i], 0); 3013 awaitCompletion(); 3014 synchronized (mStats) { 3015 mStats.createFakeHistoryEvents(events); 3016 pw.println("Battery history create events started."); 3017 noOutput = true; 3018 } 3019 } else if ("-c".equals(arg)) { 3020 useCheckinFormat = true; 3021 flags |= BatteryStats.DUMP_INCLUDE_HISTORY; 3022 } else if ("--proto".equals(arg)) { 3023 toProto = true; 3024 } else if ("--charged".equals(arg)) { 3025 flags |= BatteryStats.DUMP_CHARGED_ONLY; 3026 } else if ("--daily".equals(arg)) { 3027 flags |= BatteryStats.DUMP_DAILY_ONLY; 3028 } else if ("--reset-all".equals(arg)) { 3029 awaitCompletion(); 3030 synchronized (mStats) { 3031 mStats.resetAllStatsAndHistoryLocked( 3032 BatteryStatsImpl.RESET_REASON_ADB_COMMAND); 3033 mPowerStatsStore.reset(); 3034 pw.println("Battery stats and history reset."); 3035 noOutput = true; 3036 } 3037 } else if ("--reset".equals(arg)) { 3038 awaitCompletion(); 3039 synchronized (mStats) { 3040 mStats.resetAllStatsAndHistoryLocked( 3041 BatteryStatsImpl.RESET_REASON_ADB_COMMAND); 3042 pw.println("Battery stats reset."); 3043 noOutput = true; 3044 } 3045 } else if ("--write".equals(arg)) { 3046 awaitCompletion(); 3047 syncStats("dump", BatteryExternalStatsWorker.UPDATE_ALL); 3048 synchronized (mStats) { 3049 mStats.writeSyncLocked(); 3050 pw.println("Battery stats written."); 3051 noOutput = true; 3052 } 3053 } else if ("--new-daily".equals(arg)) { 3054 awaitCompletion(); 3055 synchronized (mStats) { 3056 mStats.recordDailyStatsLocked(); 3057 pw.println("New daily stats written."); 3058 noOutput = true; 3059 } 3060 } else if ("--read-daily".equals(arg)) { 3061 awaitCompletion(); 3062 synchronized (mStats) { 3063 mStats.readDailyStatsLocked(); 3064 pw.println("Last daily stats read."); 3065 noOutput = true; 3066 } 3067 } else if ("--enable".equals(arg) || "enable".equals(arg)) { 3068 i = doEnableOrDisable(pw, i, args, true); 3069 if (i < 0) { 3070 return; 3071 } 3072 pw.println("Enabled: " + args[i]); 3073 return; 3074 } else if ("--disable".equals(arg) || "disable".equals(arg)) { 3075 i = doEnableOrDisable(pw, i, args, false); 3076 if (i < 0) { 3077 return; 3078 } 3079 pw.println("Disabled: " + args[i]); 3080 return; 3081 } else if ("-h".equals(arg)) { 3082 dumpHelp(pw); 3083 return; 3084 } else if ("--settings".equals(arg)) { 3085 dumpSettings(pw); 3086 return; 3087 } else if ("--cpu".equals(arg)) { 3088 dumpCpuStats(pw); 3089 return; 3090 } else if ("--measured-energy".equals(arg)) { 3091 dumpMeasuredEnergyStats(pw); 3092 return; 3093 } else if ("--power-profile".equals(arg)) { 3094 dumpPowerProfile(pw); 3095 return; 3096 } else if ("--usage".equals(arg)) { 3097 int model = BatteryConsumer.POWER_MODEL_UNDEFINED; 3098 boolean proto = false; 3099 for (int j = i + 1; j < args.length; j++) { 3100 switch (args[j]) { 3101 case "--proto": 3102 proto = true; 3103 break; 3104 case "--model": { 3105 if (j + 1 < args.length) { 3106 j++; 3107 if ("power-profile".equals(args[j])) { 3108 model = BatteryConsumer.POWER_MODEL_POWER_PROFILE; 3109 } else { 3110 pw.println("Unknown power model: " + args[j]); 3111 dumpHelp(pw); 3112 return; 3113 } 3114 } else { 3115 pw.println("--model without a value"); 3116 dumpHelp(pw); 3117 return; 3118 } 3119 break; 3120 } 3121 } 3122 } 3123 dumpUsageStats(fd, pw, model, proto); 3124 return; 3125 } else if ("--wakeups".equals(arg)) { 3126 mCpuWakeupStats.dump(new IndentingPrintWriter(pw, " "), 3127 SystemClock.elapsedRealtime()); 3128 return; 3129 } else if (Flags.streamlinedBatteryStats() && "--sample".equals(arg)) { 3130 dumpStatsSample(pw); 3131 return; 3132 } else if (Flags.streamlinedBatteryStats() && "--aggregated".equals(arg)) { 3133 dumpAggregatedStats(pw); 3134 return; 3135 } else if ("--store".equals(arg)) { 3136 dumpPowerStatsStore(pw); 3137 return; 3138 } else if ("--store-toc".equals(arg)) { 3139 dumpPowerStatsStoreTableOfContents(pw); 3140 return; 3141 } else if ("-a".equals(arg)) { 3142 flags |= BatteryStats.DUMP_VERBOSE; 3143 } else if (arg.length() > 0 && arg.charAt(0) == '-'){ 3144 pw.println("Unknown option: " + arg); 3145 dumpHelp(pw); 3146 return; 3147 } else { 3148 // Not an option, last argument must be a package name. 3149 try { 3150 reqUid = mContext.getPackageManager().getPackageUidAsUser(arg, 3151 UserHandle.getCallingUserId()); 3152 } catch (PackageManager.NameNotFoundException e) { 3153 pw.println("Unknown package: " + arg); 3154 dumpHelp(pw); 3155 return; 3156 } 3157 } 3158 } 3159 } 3160 if (noOutput) { 3161 return; 3162 } 3163 3164 final long ident = Binder.clearCallingIdentity(); 3165 try { 3166 if (BatteryStats.checkWifiOnly(mContext)) { 3167 flags |= BatteryStats.DUMP_DEVICE_WIFI_ONLY; 3168 } 3169 awaitCompletion(); 3170 // Fetch data from external sources and update the BatteryStatsImpl object with them. 3171 syncStats("dump", BatteryExternalStatsWorker.UPDATE_ALL); 3172 } finally { 3173 Binder.restoreCallingIdentity(ident); 3174 } 3175 3176 if (reqUid >= 0) { 3177 // By default, if the caller is only interested in a specific package, then 3178 // we only dump the aggregated data since charged. 3179 if ((flags&(BatteryStats.DUMP_HISTORY_ONLY|BatteryStats.DUMP_CHARGED_ONLY)) == 0) { 3180 flags |= BatteryStats.DUMP_CHARGED_ONLY; 3181 // Also if they are doing -c, we don't want history. 3182 flags &= ~BatteryStats.DUMP_INCLUDE_HISTORY; 3183 } 3184 } 3185 3186 if (toProto) { 3187 List<ApplicationInfo> apps = mContext.getPackageManager().getInstalledApplications( 3188 PackageManager.MATCH_ANY_USER | PackageManager.MATCH_ALL); 3189 if (isRealCheckin) { 3190 // For a real checkin, first we want to prefer to use the last complete checkin 3191 // file if there is one. 3192 synchronized (mStats.mCheckinFile) { 3193 if (mStats.mCheckinFile.exists()) { 3194 try { 3195 byte[] raw = mStats.mCheckinFile.readFully(); 3196 if (raw != null) { 3197 Parcel in = Parcel.obtain(); 3198 in.unmarshall(raw, 0, raw.length); 3199 in.setDataPosition(0); 3200 BatteryStatsImpl checkinStats = new BatteryStatsImpl( 3201 mBatteryStatsConfig, Clock.SYSTEM_CLOCK, mMonotonicClock, 3202 null, mStats.mHandler, null, null, 3203 mUserManagerUserInfoProvider, mPowerProfile, 3204 mCpuScalingPolicies, new PowerStatsUidResolver()); 3205 checkinStats.readSummaryFromParcel(in); 3206 in.recycle(); 3207 checkinStats.dumpProtoLocked(mContext, fd, apps, flags, 3208 historyStart, mDumpHelper); 3209 mStats.mCheckinFile.delete(); 3210 return; 3211 } 3212 } catch (IOException | ParcelFormatException e) { 3213 Slog.w(TAG, "Failure reading checkin file " 3214 + mStats.mCheckinFile.getBaseFile(), e); 3215 } 3216 } 3217 } 3218 } 3219 if (DBG) Slog.d(TAG, "begin dumpProtoLocked from UID " + Binder.getCallingUid()); 3220 awaitCompletion(); 3221 synchronized (mStats) { 3222 mStats.dumpProtoLocked(mContext, fd, apps, flags, historyStart, mDumpHelper); 3223 if (writeData) { 3224 mStats.writeAsyncLocked(); 3225 } 3226 } 3227 if (DBG) Slog.d(TAG, "end dumpProtoLocked"); 3228 } else if (useCheckinFormat) { 3229 List<ApplicationInfo> apps = mContext.getPackageManager().getInstalledApplications( 3230 PackageManager.MATCH_ANY_USER | PackageManager.MATCH_ALL); 3231 if (isRealCheckin) { 3232 // For a real checkin, first we want to prefer to use the last complete checkin 3233 // file if there is one. 3234 synchronized (mStats.mCheckinFile) { 3235 if (mStats.mCheckinFile.exists()) { 3236 try { 3237 byte[] raw = mStats.mCheckinFile.readFully(); 3238 if (raw != null) { 3239 Parcel in = Parcel.obtain(); 3240 in.unmarshall(raw, 0, raw.length); 3241 in.setDataPosition(0); 3242 BatteryStatsImpl checkinStats = new BatteryStatsImpl( 3243 mBatteryStatsConfig, Clock.SYSTEM_CLOCK, mMonotonicClock, 3244 null, mStats.mHandler, null, null, 3245 mUserManagerUserInfoProvider, mPowerProfile, 3246 mCpuScalingPolicies, new PowerStatsUidResolver()); 3247 checkinStats.readSummaryFromParcel(in); 3248 in.recycle(); 3249 checkinStats.dumpCheckin(mContext, pw, apps, flags, 3250 historyStart, mDumpHelper); 3251 mStats.mCheckinFile.delete(); 3252 return; 3253 } 3254 } catch (IOException | ParcelFormatException e) { 3255 Slog.w(TAG, "Failure reading checkin file " 3256 + mStats.mCheckinFile.getBaseFile(), e); 3257 } 3258 } 3259 } 3260 } 3261 if (DBG) Slog.d(TAG, "begin dumpCheckin from UID " + Binder.getCallingUid()); 3262 awaitCompletion(); 3263 mStats.dumpCheckin(mContext, pw, apps, flags, historyStart, mDumpHelper); 3264 if (writeData) { 3265 mStats.writeAsyncLocked(); 3266 } 3267 if (DBG) Slog.d(TAG, "end dumpCheckin"); 3268 } else { 3269 if (DBG) Slog.d(TAG, "begin dump from UID " + Binder.getCallingUid()); 3270 awaitCompletion(); 3271 3272 mStats.dump(mContext, pw, flags, reqUid, historyStart, mDumpHelper); 3273 if (writeData) { 3274 mStats.writeAsyncLocked(); 3275 } 3276 pw.println(); 3277 mCpuWakeupStats.dump(new IndentingPrintWriter(pw, " "), SystemClock.elapsedRealtime()); 3278 3279 if (DBG) Slog.d(TAG, "end dump"); 3280 } 3281 } 3282 3283 /** 3284 * Gets a snapshot of cellular stats 3285 * @hide 3286 */ 3287 @Override 3288 @EnforcePermission(anyOf = {UPDATE_DEVICE_STATS, BATTERY_STATS}) getCellularBatteryStats()3289 public CellularBatteryStats getCellularBatteryStats() { 3290 // Wait for the completion of pending works if there is any 3291 super.getCellularBatteryStats_enforcePermission(); 3292 3293 awaitCompletion(); 3294 synchronized (mStats) { 3295 return mStats.getCellularBatteryStats(); 3296 } 3297 } 3298 3299 /** 3300 * Gets a snapshot of Wifi stats 3301 * @hide 3302 */ 3303 @Override 3304 @EnforcePermission(anyOf = {UPDATE_DEVICE_STATS, BATTERY_STATS}) getWifiBatteryStats()3305 public WifiBatteryStats getWifiBatteryStats() { 3306 // Wait for the completion of pending works if there is any 3307 super.getWifiBatteryStats_enforcePermission(); 3308 3309 awaitCompletion(); 3310 synchronized (mStats) { 3311 return mStats.getWifiBatteryStats(); 3312 } 3313 } 3314 3315 /** 3316 * Gets a snapshot of Gps stats 3317 * @hide 3318 */ 3319 @Override 3320 @EnforcePermission(BATTERY_STATS) getGpsBatteryStats()3321 public GpsBatteryStats getGpsBatteryStats() { 3322 // Wait for the completion of pending works if there is any 3323 super.getGpsBatteryStats_enforcePermission(); 3324 3325 awaitCompletion(); 3326 synchronized (mStats) { 3327 return mStats.getGpsBatteryStats(); 3328 } 3329 } 3330 3331 /** 3332 * Gets a snapshot of wake lock stats 3333 * @hide 3334 */ 3335 @Override 3336 @EnforcePermission(BATTERY_STATS) getWakeLockStats()3337 public WakeLockStats getWakeLockStats() { 3338 // Wait for the completion of pending works if there is any 3339 super.getWakeLockStats_enforcePermission(); 3340 3341 awaitCompletion(); 3342 synchronized (mStats) { 3343 return mStats.getWakeLockStats(); 3344 } 3345 } 3346 3347 /** 3348 * Gets a snapshot of Bluetooth stats 3349 * @hide 3350 */ 3351 @Override 3352 @EnforcePermission(BATTERY_STATS) getBluetoothBatteryStats()3353 public BluetoothBatteryStats getBluetoothBatteryStats() { 3354 // Wait for the completion of pending works if there is any 3355 super.getBluetoothBatteryStats_enforcePermission(); 3356 3357 awaitCompletion(); 3358 synchronized (mStats) { 3359 return mStats.getBluetoothBatteryStats(); 3360 } 3361 } 3362 3363 /** 3364 * Gets a snapshot of the system health for a particular uid. 3365 */ 3366 @Override takeUidSnapshot(int requestUid)3367 public HealthStatsParceler takeUidSnapshot(int requestUid) { 3368 if (requestUid != Binder.getCallingUid()) { 3369 mContext.enforceCallingOrSelfPermission( 3370 android.Manifest.permission.BATTERY_STATS, null); 3371 } 3372 final long ident = Binder.clearCallingIdentity(); 3373 try { 3374 // Wait for the completion of pending works if there is any 3375 awaitCompletion(); 3376 if (shouldCollectExternalStats()) { 3377 syncStats("get-health-stats-for-uids", BatteryExternalStatsWorker.UPDATE_ALL); 3378 } 3379 synchronized (mStats) { 3380 return getHealthStatsForUidLocked(requestUid); 3381 } 3382 } catch (Exception ex) { 3383 Slog.w(TAG, "Crashed while writing for takeUidSnapshot(" + requestUid + ")", ex); 3384 throw ex; 3385 } finally { 3386 Binder.restoreCallingIdentity(ident); 3387 } 3388 } 3389 3390 /** 3391 * Gets a snapshot of the system health for a number of uids. 3392 */ 3393 @Override takeUidSnapshots(int[] requestUids)3394 public HealthStatsParceler[] takeUidSnapshots(int[] requestUids) { 3395 if (!onlyCaller(requestUids)) { 3396 mContext.enforceCallingOrSelfPermission( 3397 android.Manifest.permission.BATTERY_STATS, null); 3398 } 3399 final long ident = Binder.clearCallingIdentity(); 3400 int i=-1; 3401 try { 3402 // Wait for the completion of pending works if there is any 3403 awaitCompletion(); 3404 if (shouldCollectExternalStats()) { 3405 syncStats("get-health-stats-for-uids", BatteryExternalStatsWorker.UPDATE_ALL); 3406 } 3407 synchronized (mStats) { 3408 final int N = requestUids.length; 3409 final HealthStatsParceler[] results = new HealthStatsParceler[N]; 3410 for (i=0; i<N; i++) { 3411 results[i] = getHealthStatsForUidLocked(requestUids[i]); 3412 } 3413 return results; 3414 } 3415 } catch (Exception ex) { 3416 if (DBG) Slog.d(TAG, "Crashed while writing for takeUidSnapshots(" 3417 + Arrays.toString(requestUids) + ") i=" + i, ex); 3418 throw ex; 3419 } finally { 3420 Binder.restoreCallingIdentity(ident); 3421 } 3422 } 3423 3424 /** 3425 * Gets a snapshot of the system health for a number of uids. 3426 */ 3427 @Override takeUidSnapshotsAsync(int[] requestUids, ResultReceiver resultReceiver)3428 public void takeUidSnapshotsAsync(int[] requestUids, ResultReceiver resultReceiver) { 3429 if (!onlyCaller(requestUids)) { 3430 mContext.enforceCallingOrSelfPermission( 3431 android.Manifest.permission.BATTERY_STATS, null); 3432 } 3433 3434 Future future; 3435 if (shouldCollectExternalStats()) { 3436 future = mWorker.scheduleSync("get-health-stats-for-uids", 3437 BatteryExternalStatsWorker.UPDATE_ALL); 3438 } else { 3439 future = null; 3440 } 3441 3442 mHandler.post(() -> { 3443 if (future != null) { 3444 try { 3445 // Worker uses a separate thread pool, so waiting here won't cause a deadlock 3446 future.get(); 3447 } catch (InterruptedException | ExecutionException e) { 3448 Slog.e(TAG, "Sync failed", e); 3449 } 3450 } 3451 3452 final long ident = Binder.clearCallingIdentity(); 3453 int i = -1; 3454 try { 3455 final int count = requestUids.length; 3456 final HealthStatsParceler[] results = new HealthStatsParceler[count]; 3457 synchronized (mStats) { 3458 for (i = 0; i < count; i++) { 3459 results[i] = getHealthStatsForUidLocked(requestUids[i]); 3460 } 3461 } 3462 Bundle resultData = new Bundle(1); 3463 resultData.putParcelableArray(IBatteryStats.KEY_UID_SNAPSHOTS, results); 3464 resultReceiver.send(0, resultData); 3465 } catch (Exception ex) { 3466 if (DBG) { 3467 Slog.d(TAG, "Crashed while returning results for takeUidSnapshots(" 3468 + Arrays.toString(requestUids) + ") i=" + i, ex); 3469 } 3470 throw ex; 3471 } finally { 3472 Binder.restoreCallingIdentity(ident); 3473 } 3474 }); 3475 } 3476 shouldCollectExternalStats()3477 private boolean shouldCollectExternalStats() { 3478 return (SystemClock.elapsedRealtime() - mWorker.getLastCollectionTimeStamp()) 3479 > mStats.getExternalStatsCollectionRateLimitMs(); 3480 } 3481 3482 /** 3483 * Returns whether the Binder.getCallingUid is the only thing in requestUids. 3484 */ onlyCaller(int[] requestUids)3485 private static boolean onlyCaller(int[] requestUids) { 3486 final int caller = Binder.getCallingUid(); 3487 final int N = requestUids.length; 3488 for (int i=0; i<N; i++) { 3489 if (requestUids[i] != caller) { 3490 return false; 3491 } 3492 } 3493 return true; 3494 } 3495 3496 /** 3497 * Gets a HealthStatsParceler for the given uid. You should probably call 3498 * updateExternalStatsSync first. 3499 */ getHealthStatsForUidLocked(int requestUid)3500 HealthStatsParceler getHealthStatsForUidLocked(int requestUid) { 3501 final HealthStatsBatteryStatsWriter writer = new HealthStatsBatteryStatsWriter(); 3502 final HealthStatsWriter uidWriter = new HealthStatsWriter(UidHealthStats.CONSTANTS); 3503 final BatteryStats.Uid uid = mStats.getUidStats().get(requestUid); 3504 if (uid != null) { 3505 writer.writeUid(uidWriter, mStats, uid); 3506 } 3507 return new HealthStatsParceler(uidWriter); 3508 } 3509 3510 /** 3511 * Delay for sending ACTION_CHARGING after device is plugged in. 3512 * 3513 * @hide 3514 */ 3515 @EnforcePermission(POWER_SAVER) setChargingStateUpdateDelayMillis(int delayMillis)3516 public boolean setChargingStateUpdateDelayMillis(int delayMillis) { 3517 super.setChargingStateUpdateDelayMillis_enforcePermission(); 3518 3519 final long ident = Binder.clearCallingIdentity(); 3520 3521 try { 3522 final ContentResolver contentResolver = mContext.getContentResolver(); 3523 return Settings.Global.putLong(contentResolver, 3524 Settings.Global.BATTERY_CHARGING_STATE_UPDATE_DELAY, 3525 delayMillis); 3526 } finally { 3527 Binder.restoreCallingIdentity(ident); 3528 } 3529 } 3530 updateForegroundTimeIfOnBattery(final String packageName, final int uid, final long cpuTimeDiff)3531 void updateForegroundTimeIfOnBattery(final String packageName, final int uid, 3532 final long cpuTimeDiff) { 3533 synchronized (mLock) { 3534 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3535 final long uptime = SystemClock.uptimeMillis(); 3536 mHandler.post(() -> { 3537 if (!isOnBattery()) { 3538 return; 3539 } 3540 synchronized (mStats) { 3541 final BatteryStatsImpl.Uid.Proc ps = 3542 mStats.getProcessStatsLocked(uid, packageName, elapsedRealtime, uptime); 3543 if (ps != null) { 3544 ps.addForegroundTimeLocked(cpuTimeDiff); 3545 } 3546 } 3547 }); 3548 } 3549 } 3550 noteCurrentTimeChanged()3551 void noteCurrentTimeChanged() { 3552 synchronized (mLock) { 3553 final long currentTime = System.currentTimeMillis(); 3554 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3555 final long uptime = SystemClock.uptimeMillis(); 3556 mHandler.post(() -> { 3557 synchronized (mStats) { 3558 mStats.noteCurrentTimeChangedLocked(currentTime, elapsedRealtime, uptime); 3559 } 3560 }); 3561 } 3562 } 3563 updateBatteryStatsOnActivityUsage(final String packageName, final String className, final int uid, final int userId, final boolean resumed)3564 void updateBatteryStatsOnActivityUsage(final String packageName, final String className, 3565 final int uid, final int userId, final boolean resumed) { 3566 synchronized (mLock) { 3567 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3568 final long uptime = SystemClock.uptimeMillis(); 3569 mHandler.post(() -> { 3570 synchronized (mStats) { 3571 if (resumed) { 3572 mStats.noteActivityResumedLocked(uid, elapsedRealtime, uptime); 3573 } else { 3574 mStats.noteActivityPausedLocked(uid, elapsedRealtime, uptime); 3575 } 3576 } 3577 }); 3578 } 3579 FrameworkStatsLog.write(FrameworkStatsLog.ACTIVITY_FOREGROUND_STATE_CHANGED, 3580 uid, packageName, className, 3581 resumed 3582 ? FrameworkStatsLog.ACTIVITY_FOREGROUND_STATE_CHANGED__STATE__FOREGROUND 3583 : FrameworkStatsLog.ACTIVITY_FOREGROUND_STATE_CHANGED__STATE__BACKGROUND); 3584 } 3585 noteProcessDied(final int uid, final int pid)3586 void noteProcessDied(final int uid, final int pid) { 3587 synchronized (mLock) { 3588 mHandler.post(() -> { 3589 synchronized (mStats) { 3590 mStats.noteProcessDiedLocked(uid, pid); 3591 } 3592 }); 3593 } 3594 } 3595 reportExcessiveCpu(final int uid, final String processName, final long uptimeSince, long cputimeUsed)3596 void reportExcessiveCpu(final int uid, final String processName, final long uptimeSince, 3597 long cputimeUsed) { 3598 synchronized (mLock) { 3599 mHandler.post(() -> { 3600 synchronized (mStats) { 3601 mStats.reportExcessiveCpuLocked(uid, processName, uptimeSince, cputimeUsed); 3602 } 3603 }); 3604 } 3605 } 3606 noteServiceStartRunning(int uid, String pkg, String name)3607 void noteServiceStartRunning(int uid, String pkg, String name) { 3608 synchronized (mLock) { 3609 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3610 final long uptime = SystemClock.uptimeMillis(); 3611 mHandler.post(() -> { 3612 synchronized (mStats) { 3613 final BatteryStatsImpl.Uid.Pkg.Serv stats = mStats.getServiceStatsLocked(uid, 3614 pkg, name, elapsedRealtime, uptime); 3615 stats.startRunningLocked(uptime); 3616 } 3617 }); 3618 } 3619 } 3620 noteServiceStopRunning(int uid, String pkg, String name)3621 void noteServiceStopRunning(int uid, String pkg, String name) { 3622 synchronized (mLock) { 3623 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3624 final long uptime = SystemClock.uptimeMillis(); 3625 mHandler.post(() -> { 3626 synchronized (mStats) { 3627 final BatteryStatsImpl.Uid.Pkg.Serv stats = mStats.getServiceStatsLocked(uid, 3628 pkg, name, elapsedRealtime, uptime); 3629 stats.stopRunningLocked(uptime); 3630 } 3631 }); 3632 } 3633 } 3634 noteServiceStartLaunch(int uid, String pkg, String name)3635 void noteServiceStartLaunch(int uid, String pkg, String name) { 3636 synchronized (mLock) { 3637 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3638 final long uptime = SystemClock.uptimeMillis(); 3639 mHandler.post(() -> { 3640 synchronized (mStats) { 3641 final BatteryStatsImpl.Uid.Pkg.Serv stats = mStats.getServiceStatsLocked(uid, 3642 pkg, name, elapsedRealtime, uptime); 3643 stats.startLaunchedLocked(uptime); 3644 } 3645 }); 3646 } 3647 } 3648 noteServiceStopLaunch(int uid, String pkg, String name)3649 void noteServiceStopLaunch(int uid, String pkg, String name) { 3650 synchronized (mLock) { 3651 final long elapsedRealtime = SystemClock.elapsedRealtime(); 3652 final long uptime = SystemClock.uptimeMillis(); 3653 mHandler.post(() -> { 3654 synchronized (mStats) { 3655 final BatteryStatsImpl.Uid.Pkg.Serv stats = mStats.getServiceStatsLocked(uid, 3656 pkg, name, elapsedRealtime, uptime); 3657 stats.stopLaunchedLocked(uptime); 3658 } 3659 }); 3660 } 3661 } 3662 3663 private static final String BATTERY_USAGE_STATS_BEFORE_RESET_TIMESTAMP_PROPERTY = 3664 "BATTERY_USAGE_STATS_BEFORE_RESET_TIMESTAMP"; 3665 3666 /** 3667 * Saves the supplied timestamp of the BATTERY_USAGE_STATS_BEFORE_RESET statsd atom pull 3668 * in persistent file. 3669 */ setLastBatteryUsageStatsBeforeResetAtomPullTimestamp(long timestamp)3670 public void setLastBatteryUsageStatsBeforeResetAtomPullTimestamp(long timestamp) { 3671 synchronized (mConfigFile) { 3672 Properties props = new Properties(); 3673 try (InputStream in = mConfigFile.openRead()) { 3674 props.load(in); 3675 } catch (IOException e) { 3676 Slog.e(TAG, "Cannot load config file " + mConfigFile, e); 3677 } 3678 props.put(BATTERY_USAGE_STATS_BEFORE_RESET_TIMESTAMP_PROPERTY, 3679 String.valueOf(timestamp)); 3680 FileOutputStream out = null; 3681 try { 3682 out = mConfigFile.startWrite(); 3683 props.store(out, "Statsd atom pull timestamps"); 3684 mConfigFile.finishWrite(out); 3685 } catch (IOException e) { 3686 mConfigFile.failWrite(out); 3687 Slog.e(TAG, "Cannot save config file " + mConfigFile, e); 3688 } 3689 } 3690 } 3691 3692 /** 3693 * Retrieves the previously saved timestamp of the last BATTERY_USAGE_STATS_BEFORE_RESET 3694 * statsd atom pull. 3695 */ getLastBatteryUsageStatsBeforeResetAtomPullTimestamp()3696 public long getLastBatteryUsageStatsBeforeResetAtomPullTimestamp() { 3697 synchronized (mConfigFile) { 3698 Properties props = new Properties(); 3699 try (InputStream in = mConfigFile.openRead()) { 3700 props.load(in); 3701 } catch (IOException e) { 3702 Slog.e(TAG, "Cannot load config file " + mConfigFile, e); 3703 } 3704 return Long.parseLong( 3705 props.getProperty(BATTERY_USAGE_STATS_BEFORE_RESET_TIMESTAMP_PROPERTY, "0")); 3706 } 3707 } 3708 3709 /** 3710 * Sets battery AC charger to enabled/disabled, and freezes the battery state. 3711 */ 3712 @Override 3713 @EnforcePermission(DEVICE_POWER) setChargerAcOnline(boolean online, boolean forceUpdate)3714 public void setChargerAcOnline(boolean online, boolean forceUpdate) { 3715 super.setChargerAcOnline_enforcePermission(); 3716 3717 mBatteryManagerInternal.setChargerAcOnline(online, forceUpdate); 3718 } 3719 3720 /** 3721 * Sets battery level, and freezes the battery state. 3722 */ 3723 @Override 3724 @EnforcePermission(DEVICE_POWER) setBatteryLevel(int level, boolean forceUpdate)3725 public void setBatteryLevel(int level, boolean forceUpdate) { 3726 super.setBatteryLevel_enforcePermission(); 3727 3728 mBatteryManagerInternal.setBatteryLevel(level, forceUpdate); 3729 } 3730 3731 /** 3732 * Unplugs battery, and freezes the battery state. 3733 */ 3734 @Override 3735 @EnforcePermission(DEVICE_POWER) unplugBattery(boolean forceUpdate)3736 public void unplugBattery(boolean forceUpdate) { 3737 super.unplugBattery_enforcePermission(); 3738 3739 mBatteryManagerInternal.unplugBattery(forceUpdate); 3740 } 3741 3742 /** 3743 * Unfreezes battery state, returning to current hardware values. 3744 */ 3745 @Override 3746 @EnforcePermission(DEVICE_POWER) resetBattery(boolean forceUpdate)3747 public void resetBattery(boolean forceUpdate) { 3748 super.resetBattery_enforcePermission(); 3749 3750 mBatteryManagerInternal.resetBattery(forceUpdate); 3751 } 3752 3753 /** 3754 * Suspend charging even if plugged in. 3755 */ 3756 @Override 3757 @EnforcePermission(DEVICE_POWER) suspendBatteryInput()3758 public void suspendBatteryInput() { 3759 super.suspendBatteryInput_enforcePermission(); 3760 3761 mBatteryManagerInternal.suspendBatteryInput(); 3762 } 3763 } 3764