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 android.bluetooth.BluetoothHeadset; 20 import android.content.Context; 21 import android.os.Binder; 22 import android.os.IBinder; 23 import android.os.Parcel; 24 import android.os.Process; 25 import android.os.ServiceManager; 26 import android.os.WorkSource; 27 import android.telephony.SignalStrength; 28 import android.util.Slog; 29 30 import com.android.internal.app.IBatteryStats; 31 import com.android.internal.os.BatteryStatsImpl; 32 import com.android.internal.os.PowerProfile; 33 34 import java.io.FileDescriptor; 35 import java.io.PrintWriter; 36 37 /** 38 * All information we are collecting about things that can happen that impact 39 * battery life. 40 */ 41 public final class BatteryStatsService extends IBatteryStats.Stub { 42 static IBatteryStats sService; 43 44 final BatteryStatsImpl mStats; 45 Context mContext; 46 47 BatteryStatsService(String filename) { 48 mStats = new BatteryStatsImpl(filename); 49 } 50 51 public void publish(Context context) { 52 mContext = context; 53 ServiceManager.addService("batteryinfo", asBinder()); 54 mStats.setNumSpeedSteps(new PowerProfile(mContext).getNumSpeedSteps()); 55 mStats.setRadioScanningTimeout(mContext.getResources().getInteger( 56 com.android.internal.R.integer.config_radioScanningTimeout) 57 * 1000L); 58 } 59 60 public void shutdown() { 61 Slog.w("BatteryStats", "Writing battery stats before shutdown..."); 62 synchronized (mStats) { 63 mStats.shutdownLocked(); 64 } 65 } 66 67 public static IBatteryStats getService() { 68 if (sService != null) { 69 return sService; 70 } 71 IBinder b = ServiceManager.getService("batteryinfo"); 72 sService = asInterface(b); 73 return sService; 74 } 75 76 /** 77 * @return the current statistics object, which may be modified 78 * to reflect events that affect battery usage. You must lock the 79 * stats object before doing anything with it. 80 */ 81 public BatteryStatsImpl getActiveStatistics() { 82 return mStats; 83 } 84 85 public byte[] getStatistics() { 86 mContext.enforceCallingPermission( 87 android.Manifest.permission.BATTERY_STATS, null); 88 //Slog.i("foo", "SENDING BATTERY INFO:"); 89 //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo", Log.LOG_ID_SYSTEM)); 90 Parcel out = Parcel.obtain(); 91 mStats.writeToParcel(out, 0); 92 byte[] data = out.marshall(); 93 out.recycle(); 94 return data; 95 } 96 97 public void noteStartWakelock(int uid, int pid, String name, int type) { 98 enforceCallingPermission(); 99 synchronized (mStats) { 100 mStats.noteStartWakeLocked(uid, pid, name, type); 101 } 102 } 103 104 public void noteStopWakelock(int uid, int pid, String name, int type) { 105 enforceCallingPermission(); 106 synchronized (mStats) { 107 mStats.noteStopWakeLocked(uid, pid, name, type); 108 } 109 } 110 111 public void noteStartWakelockFromSource(WorkSource ws, int pid, String name, int type) { 112 enforceCallingPermission(); 113 synchronized (mStats) { 114 mStats.noteStartWakeFromSourceLocked(ws, pid, name, type); 115 } 116 } 117 118 public void noteStopWakelockFromSource(WorkSource ws, int pid, String name, int type) { 119 enforceCallingPermission(); 120 synchronized (mStats) { 121 mStats.noteStopWakeFromSourceLocked(ws, pid, name, type); 122 } 123 } 124 125 public void noteStartSensor(int uid, int sensor) { 126 enforceCallingPermission(); 127 synchronized (mStats) { 128 mStats.noteStartSensorLocked(uid, sensor); 129 } 130 } 131 132 public void noteStopSensor(int uid, int sensor) { 133 enforceCallingPermission(); 134 synchronized (mStats) { 135 mStats.noteStopSensorLocked(uid, sensor); 136 } 137 } 138 139 public void noteStartGps(int uid) { 140 enforceCallingPermission(); 141 synchronized (mStats) { 142 mStats.noteStartGpsLocked(uid); 143 } 144 } 145 146 public void noteStopGps(int uid) { 147 enforceCallingPermission(); 148 synchronized (mStats) { 149 mStats.noteStopGpsLocked(uid); 150 } 151 } 152 153 public void noteScreenOn() { 154 enforceCallingPermission(); 155 synchronized (mStats) { 156 mStats.noteScreenOnLocked(); 157 } 158 } 159 160 public void noteScreenBrightness(int brightness) { 161 enforceCallingPermission(); 162 synchronized (mStats) { 163 mStats.noteScreenBrightnessLocked(brightness); 164 } 165 } 166 167 public void noteScreenOff() { 168 enforceCallingPermission(); 169 synchronized (mStats) { 170 mStats.noteScreenOffLocked(); 171 } 172 } 173 174 public void noteInputEvent() { 175 enforceCallingPermission(); 176 mStats.noteInputEventAtomic(); 177 } 178 179 public void noteUserActivity(int uid, int event) { 180 enforceCallingPermission(); 181 synchronized (mStats) { 182 mStats.noteUserActivityLocked(uid, event); 183 } 184 } 185 186 public void notePhoneOn() { 187 enforceCallingPermission(); 188 synchronized (mStats) { 189 mStats.notePhoneOnLocked(); 190 } 191 } 192 193 public void notePhoneOff() { 194 enforceCallingPermission(); 195 synchronized (mStats) { 196 mStats.notePhoneOffLocked(); 197 } 198 } 199 200 public void notePhoneSignalStrength(SignalStrength signalStrength) { 201 enforceCallingPermission(); 202 synchronized (mStats) { 203 mStats.notePhoneSignalStrengthLocked(signalStrength); 204 } 205 } 206 207 public void notePhoneDataConnectionState(int dataType, boolean hasData) { 208 enforceCallingPermission(); 209 synchronized (mStats) { 210 mStats.notePhoneDataConnectionStateLocked(dataType, hasData); 211 } 212 } 213 214 public void notePhoneState(int state) { 215 enforceCallingPermission(); 216 synchronized (mStats) { 217 mStats.notePhoneStateLocked(state); 218 } 219 } 220 221 public void noteWifiOn() { 222 enforceCallingPermission(); 223 synchronized (mStats) { 224 mStats.noteWifiOnLocked(); 225 } 226 } 227 228 public void noteWifiOff() { 229 enforceCallingPermission(); 230 synchronized (mStats) { 231 mStats.noteWifiOffLocked(); 232 } 233 } 234 235 public void noteStartAudio(int uid) { 236 enforceCallingPermission(); 237 synchronized (mStats) { 238 mStats.noteAudioOnLocked(uid); 239 } 240 } 241 242 public void noteStopAudio(int uid) { 243 enforceCallingPermission(); 244 synchronized (mStats) { 245 mStats.noteAudioOffLocked(uid); 246 } 247 } 248 249 public void noteStartVideo(int uid) { 250 enforceCallingPermission(); 251 synchronized (mStats) { 252 mStats.noteVideoOnLocked(uid); 253 } 254 } 255 256 public void noteStopVideo(int uid) { 257 enforceCallingPermission(); 258 synchronized (mStats) { 259 mStats.noteVideoOffLocked(uid); 260 } 261 } 262 263 public void noteWifiRunning(WorkSource ws) { 264 enforceCallingPermission(); 265 synchronized (mStats) { 266 mStats.noteWifiRunningLocked(ws); 267 } 268 } 269 270 public void noteWifiRunningChanged(WorkSource oldWs, WorkSource newWs) { 271 enforceCallingPermission(); 272 synchronized (mStats) { 273 mStats.noteWifiRunningChangedLocked(oldWs, newWs); 274 } 275 } 276 277 public void noteWifiStopped(WorkSource ws) { 278 enforceCallingPermission(); 279 synchronized (mStats) { 280 mStats.noteWifiStoppedLocked(ws); 281 } 282 } 283 284 public void noteBluetoothOn() { 285 enforceCallingPermission(); 286 BluetoothHeadset headset = new BluetoothHeadset(mContext, null); 287 synchronized (mStats) { 288 mStats.noteBluetoothOnLocked(); 289 mStats.setBtHeadset(headset); 290 } 291 } 292 293 public void noteBluetoothOff() { 294 enforceCallingPermission(); 295 synchronized (mStats) { 296 mStats.noteBluetoothOffLocked(); 297 } 298 } 299 300 public void noteFullWifiLockAcquired(int uid) { 301 enforceCallingPermission(); 302 synchronized (mStats) { 303 mStats.noteFullWifiLockAcquiredLocked(uid); 304 } 305 } 306 307 public void noteFullWifiLockReleased(int uid) { 308 enforceCallingPermission(); 309 synchronized (mStats) { 310 mStats.noteFullWifiLockReleasedLocked(uid); 311 } 312 } 313 314 public void noteScanWifiLockAcquired(int uid) { 315 enforceCallingPermission(); 316 synchronized (mStats) { 317 mStats.noteScanWifiLockAcquiredLocked(uid); 318 } 319 } 320 321 public void noteScanWifiLockReleased(int uid) { 322 enforceCallingPermission(); 323 synchronized (mStats) { 324 mStats.noteScanWifiLockReleasedLocked(uid); 325 } 326 } 327 328 public void noteWifiMulticastEnabled(int uid) { 329 enforceCallingPermission(); 330 synchronized (mStats) { 331 mStats.noteWifiMulticastEnabledLocked(uid); 332 } 333 } 334 335 public void noteWifiMulticastDisabled(int uid) { 336 enforceCallingPermission(); 337 synchronized (mStats) { 338 mStats.noteWifiMulticastDisabledLocked(uid); 339 } 340 } 341 342 public void noteFullWifiLockAcquiredFromSource(WorkSource ws) { 343 enforceCallingPermission(); 344 synchronized (mStats) { 345 mStats.noteFullWifiLockAcquiredFromSourceLocked(ws); 346 } 347 } 348 349 public void noteFullWifiLockReleasedFromSource(WorkSource ws) { 350 enforceCallingPermission(); 351 synchronized (mStats) { 352 mStats.noteFullWifiLockReleasedFromSourceLocked(ws); 353 } 354 } 355 356 public void noteScanWifiLockAcquiredFromSource(WorkSource ws) { 357 enforceCallingPermission(); 358 synchronized (mStats) { 359 mStats.noteScanWifiLockAcquiredFromSourceLocked(ws); 360 } 361 } 362 363 public void noteScanWifiLockReleasedFromSource(WorkSource ws) { 364 enforceCallingPermission(); 365 synchronized (mStats) { 366 mStats.noteScanWifiLockReleasedFromSourceLocked(ws); 367 } 368 } 369 370 public void noteWifiMulticastEnabledFromSource(WorkSource ws) { 371 enforceCallingPermission(); 372 synchronized (mStats) { 373 mStats.noteWifiMulticastEnabledFromSourceLocked(ws); 374 } 375 } 376 377 public void noteWifiMulticastDisabledFromSource(WorkSource ws) { 378 enforceCallingPermission(); 379 synchronized (mStats) { 380 mStats.noteWifiMulticastDisabledFromSourceLocked(ws); 381 } 382 } 383 384 public boolean isOnBattery() { 385 return mStats.isOnBattery(); 386 } 387 388 public void setBatteryState(int status, int health, int plugType, int level, 389 int temp, int volt) { 390 enforceCallingPermission(); 391 mStats.setBatteryState(status, health, plugType, level, temp, volt); 392 } 393 394 public long getAwakeTimeBattery() { 395 mContext.enforceCallingOrSelfPermission( 396 android.Manifest.permission.BATTERY_STATS, null); 397 return mStats.getAwakeTimeBattery(); 398 } 399 400 public long getAwakeTimePlugged() { 401 mContext.enforceCallingOrSelfPermission( 402 android.Manifest.permission.BATTERY_STATS, null); 403 return mStats.getAwakeTimePlugged(); 404 } 405 406 public void enforceCallingPermission() { 407 if (Binder.getCallingPid() == Process.myPid()) { 408 return; 409 } 410 mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS, 411 Binder.getCallingPid(), Binder.getCallingUid(), null); 412 } 413 414 @Override 415 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 416 synchronized (mStats) { 417 boolean isCheckin = false; 418 if (args != null) { 419 for (String arg : args) { 420 if ("--checkin".equals(arg)) { 421 isCheckin = true; 422 } else if ("--reset".equals(arg)) { 423 mStats.resetAllStatsLocked(); 424 } 425 } 426 } 427 if (isCheckin) mStats.dumpCheckinLocked(pw, args); 428 else mStats.dumpLocked(pw); 429 } 430 } 431 } 432