Home | History | Annotate | Download | only in am 
      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