2.电量统计服务的启动过程

BatteryStasService的主要功能是收集系统中各模块和应用进程的用电情况。因此，可以认为BatteryStatsService是Android中的“电表”。只不过这个电表比较智能，不是单纯地统计整体的耗电，而是分门别类的统计每个部分的耗电情况

2.1 BSS的创建

与一般的系统服务不太一样, BSS的创建和发布是在ActivityManagerService中进行的

代码路径： /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java (http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java)

2719    public ActivityManagerService(Context systemContext) {

       ...................................

2763        systemDir.mkdirs();

             //创建BSS对象，传入/data/system目录，同时传入ActivityManagerService的handler
2764        mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);

2765        mBatteryStatsService.getActiveStatistics().readLocked();//调用BSS中BatteryStatsImpl对象的readLocked方法
2766        mBatteryStatsService.scheduleWriteToDisk();//将初始化得到的信息写入disk
2767        mOnBattery = DEBUG_POWER ? true
2768                : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
2769        mBatteryStatsService.getActiveStatistics().setCallback(this);
2771        mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

2849    }

BSS的构造函数：

代码路径： /frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java (http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java)

222    BatteryStatsService(File systemDir, Handler handler) {
223        // Our handler here will be accessing the disk, use a different thread than
224        // what the ActivityManagerService gave us (no I/O on that one!).

            //创建一个本地服务线程，用于访问硬盘数据
225        final ServiceThread thread = new ServiceThread("batterystats-sync",

226                Process.THREAD_PRIORITY_DEFAULT, true);
227        thread.start();
228        mHandler = new BatteryStatsHandler(thread.getLooper());
230        //创建BatteryStatsImpl类
231        mStats = new BatteryStatsImpl(systemDir, handler, mHandler, this);
232    }

BSS维护的主要变量为一个BatteryStatsImpl对象，这个对象才是承担BSS实际工作的主体。

BatteryStatsImpl继承自BatteryStats，实现了Parcelable接口，因此可以通过Binder通信在进程间传递。实际上，从设置中查到的用电信息就是来自BatteryStatsImpl。

BSS的getStatistics函数提供了查询系统用电的接口

365    public byte[] getStatistics() {
366        mContext.enforceCallingPermission(
367                android.Manifest.permission.BATTERY_STATS, null);
368        //Slog.i("foo", "SENDING BATTERY INFO:");
369        //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo", Log.LOG_ID_SYSTEM));
370        Parcel out = Parcel.obtain();

          //更新系统中其它组件的耗电情况，记录于BatteryStatsImpl中
371        updateExternalStatsSync("get-stats", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL);
372        synchronized (mStats) {
373            mStats.writeToParcel(out, 0);//将BatteryServiceImpl中的信息写入到数据包中
374        }
375        byte[] data = out.marshall();
376        out.recycle();
377        return data;
378    }

电量统计的核心类是BatteryStatsImpl，后文中简写为BSImpl

2.2 BSS的发布

BSS创建完毕后，在ActivityManagerService的start函数中，BSS完成发布的工作

2863    private void start() {
2864        removeAllProcessGroups();
2865        mProcessCpuThread.start();
2867        mBatteryStatsService.publish(mContext);
2868        mAppOpsService.publish(mContext);
2869        Slog.d("AppOps", "AppOpsService published");
2870        LocalServices.addService(ActivityManagerInternal.class, new LocalService());
2871        // Wait for the synchronized block started in mProcessCpuThread,




    

2872        // so that any other acccess to mProcessCpuTracker from main thread
2873        // will be blocked during mProcessCpuTracker initialization.
2874        try {
2875            mProcessCpuInitLatch.await();
2876        } catch (InterruptedException e) {
2877            Slog.wtf(TAG, "Interrupted wait during start", e);
2878            Thread.currentThread().interrupt();
2879            throw new IllegalStateException("Interrupted wait during start");
2880        }
2881    }

在2867行调用BatteryStatsService的publish函数

BatteryStatsService.publish
代码路径：/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java)

234    public void publish(Context context) {
235        mContext = context;
236        synchronized (mStats) {
237            mStats.setRadioScanningTimeoutLocked(mContext.getResources().getInteger(
238                    com.android.internal.R.integer.config_radioScanningTimeout)
239                    * 1000L);//BSImpl设置mPhoneSignalScanningTimer的超时时间（用于统计搜索手机信号消耗的时间）
240            mStats.setPowerProfileLocked(new PowerProfile(context));//创建衡量硬件耗电能力的PowerProfile，并交给BSImpl使用
241        }
242        ServiceManager.addService(BatteryStats.SERVICE_NAME, asBinder());//注册到service manager进程中
243    }

BSS发布相关的代码比较简单，但BSImpl做了两件与发布服务无关的事。首先，BSImpl设置了mPhoneSignalScanningTimer的超时时间。mPhoneSignalScanningTimer是BSImpl的一个统计工具，实际类型为StopwatchTimer。BSImpl作为统计电量的实际类，定义了许多工具分别统计终端不同部分、场景的耗电情况。

BSImpl设置了PowerProfile相关的内容

代码路径： /frameworks/base/core/java/com/android/internal/os/PowerProfile.java (http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/PowerProfile.java)

在publish的240行中创建衡量硬件耗电能力的PowerProfile的构造函数

208    public PowerProfile(Context context) {
209        // Read the XML file for the given profile (normally only one per
210        // device)




    

211        if (sPowerMap.size() == 0) {
212            readPowerValuesFromXml(context);//从XML中得到设备硬件的配置情况
213        }
214        initCpuClusters();//得到CPU的性能指标
215    }

publish的240行中将创建衡量硬件耗电能力的PowerProfile文件交给BSImpl使用，实际使用的XML应该是和硬件相关的文件，存储各种操作的耗电情况(以mA.h为单位)。调用setPowerProfileLocked

BatteryStatsImpl.setPowerProfileLocked
代码路径：/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java)

8709    public void setPowerProfileLocked(PowerProfile profile) {
8710        mPowerProfile = profile;
8712        // We need to initialize the KernelCpuSpeedReaders to read from
8713        // the first cpu of each core. Once we have the PowerProfile, we have access to this
8714        // information.
8715        final int numClusters = mPowerProfile.getNumCpuClusters();//构造每个CPU集群对应的KernelCpuSpeedReader
8716        mKernelCpuSpeedReaders = new KernelCpuSpeedReader[numClusters];
8717        int firstCpuOfCluster = 0;
8718        for (int i = 0; i < numClusters; i++) {//轮询每个集群
8719            final int numSpeedSteps = mPowerProfile.getNumSpeedStepsInCpuCluster(i);//得到CPU支持的频率值
8720            mKernelCpuSpeedReaders[i] = new KernelCpuSpeedReader(firstCpuOfCluster,
8721                    numSpeedSteps);//创建KernelCpuSpeedReader
8722            firstCpuOfCluster += mPowerProfile.getNumCoresInCpuCluster(i);//当前CPU集群的核数
8723        }
8724        //得到当前评估出的平均电量
8725        if (mEstimatedBatteryCapacity == -1) {
8726            // Initialize the estimated battery capacity to a known preset one.
8727            mEstimatedBatteryCapacity = (int) mPowerProfile.getBatteryCapacity();
8728        }
8729    }

在BSS发布之前，它持有的BSImpl对象已经得到整个终端电量相关的硬件信息

SystemServer调用了ActivityManagerService的initPowerManagement函数
代码路径：/frameworks/base/services/java/com/android/server/SystemServer.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/java/com/android/server/SystemServer.java)

491    private void startBootstrapServices() {

         ..................................

529        traceBeginAndSlog("InitPowerManagement");
530        mActivityManagerService.initPowerManagement();
531        traceEnd();

         ..................................

638    }

在ActivityManagerService中
代码路径：/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java)

2887    public void initPowerManagement() {
2888        mStackSupervisor.initPowerManagement();
2889        mBatteryStatsService.initPowerManagement();
2890        mLocalPowerManager = LocalServices.getService(PowerManagerInternal.class);
2891        PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
2892        mVoiceWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*voice*");
2893        mVoiceWakeLock.setReferenceCounted(false);
2894    }

在2889行调用BSS的initPowerManagement函数

BSS的initPowerManagement函数:

249    public void initPowerManagement() {

250        final PowerManagerInternal powerMgr = LocalServices.getService(PowerManagerInternal.class);

           //向PowerManagerService注册低电模式的回调接口，即进入或退出低电模式时

           //调用BSS的onLowPowerModeChanged函数，在该函数中将调用BSImpl的notePowerSaveMode函数
251        powerMgr.registerLowPowerModeObserver(this);
252        synchronized (mStats) {
253            mStats.notePowerSaveModeLocked(
254                    powerMgr.getLowPowerState(ServiceType.BATTERY_STATS)
255                            .batterySaverEnabled);
256        }
257        (new WakeupReasonThread()).start();//启动WakeupReasonThread
258    }

WakeupReasonThread

代码路径：/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java)

1082    final class WakeupReasonThread extends Thread {
       .........................................
1092        public void run() {
           .............................................
1104            try {
1105                String reason;
1106                while ((reason = waitWakeup()) != null) {//等待终端被唤醒
1107                    synchronized (mStats) {
1108                        mStats.noteWakeupReasonLocked(reason);//记录终端变为唤醒状态的原因
1109                    }
1110                }
1111            } catch (RuntimeException e) {
1112                Slog.e(TAG, "Failure reading wakeup reasons"




    
, e);
1113            }
1114        }
1116        private String waitWakeup() {
................................
1121            int bytesWritten = nativeWaitWakeup(mUtf8Buffer);
1122            if (bytesWritten < 0) {
1123                return null;
1124            } else if (bytesWritten == 0) {
1125                return "unknown";
1126            }
.....................................
1138        }
1139    }

WakeupReasonThread就是负责监控终端的状态，当终端变为唤醒状态时，利用BSImpl记录唤醒的原因

代码路径：/frameworks/base/services/core/jni/com_android_server_am_BatteryStatsService.cpp (http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/jni/com_android_server_am_BatteryStatsService.cpp)

74static jint nativeWaitWakeup(JNIEnv *env, jobject clazz, jobject outBuf)
76    if (outBuf == NULL) {
77        jniThrowException(env, "java/lang/NullPointerException", "null argument");
78        return -1;
81    // Register our wakeup callback if not yet done.
82    if (!wakeup_init) {
83        wakeup_init = true;
84        ALOGV("Creating semaphore...");
85        int ret = sem_init(&wakeup_sem, 0, 0);//创建旗语
86        if (ret < 0) {
87            char buf[80




    
];
88            strerror_r(errno, buf, sizeof(buf));
89            ALOGE("Error creating semaphore: %s\n", buf);
90            jniThrowException(env, "java/lang/IllegalStateException", buf);
91            return -1;
93        ALOGV("Registering callback...");
94        set_wakeup_callback(&wakeup_callback);//从挂起变为唤醒时，wakeup_callback将调用sem_post向wakeup_sem写入数据
97    // Wait for wakeup.
98    ALOGV("Waiting for wakeup...");
99    int ret = sem_wait(&wakeup_sem);//唤醒时，结束等待
100    if (ret < 0) {
101        char buf[80];
102        strerror_r(errno, buf, sizeof(buf));
103        ALOGE("Error waiting on semaphore: %s\n", buf);
104        // Return 0 here to let it continue looping but not return results.
105        return 0;
106    }
108    FILE *fp = fopen(LAST_RESUME_REASON, "r");//打开文件
109    if (fp == NULL) {
110        ALOGE("Failed to open %s", LAST_RESUME_REASON);
111        return -1;
112    }
114    char* mergedreason = (char*)env->GetDirectBufferAddress(outBuf);
115    int remainreasonlen = (int)env->GetDirectBufferCapacity(outBuf);
117    ALOGV("Reading wakeup reasons");
118    char* mergedreasonpos = mergedreason;
119    char reasonline[128];
120    int i = 0;
121    while (fgets(reasonline, sizeof(reasonline), fp) != NULL) {//读取内容
122        char* pos = reasonline;
123        char* endPos;
124        int len;
125        // First field is the index or 'Abort'.




    

126        int irq = (int)strtol(pos, &endPos, 10);
127        if (pos != endPos) {
128            // Write the irq number to the merged reason string.
129            len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "%d" : ":%d", irq);
130        } else {
131            // The first field is not an irq, it may be the word Abort.
132            const size_t abortPrefixLen = strlen("Abort:");
133            if (strncmp(pos, "Abort:", abortPrefixLen) != 0) {
134                // Ooops.
135                ALOGE("Bad reason line: %s", reasonline);
136                continue;
137            }
139            // Write 'Abort' to the merged reason string.
140            len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "Abort" : ":Abort");
141            endPos = pos + abortPrefixLen;
142        }
143        pos = endPos;
145        if (len >= 0 && len < remainreasonlen) {
146            mergedreasonpos += len;
147            remainreasonlen -= len;
148        }
150        // Skip whitespace; rest of the buffer is the reason string.
151        while (*pos == ' ') {
152            pos++;
153        }
155        // Chop newline at end.
156        char* endpos = pos;
157        while (*endpos != 0) {
158            if (*endpos == '\n') {
159                *endpos = 0;
160                break;
161            }
162            endpos++;
163        }
165        len = snprintf(mergedreasonpos, remainreasonlen, ":%s"




    
, pos);
166        if (len >= 0 && len < remainreasonlen) {
167            mergedreasonpos += len;
168            remainreasonlen -= len;
169        }
170        i++;
171    }
173    ALOGV("Got %d reasons", i);
174    if (i > 0) {
175        *mergedreasonpos = 0;
176    }
178    if (fclose(fp) != 0) {//关闭文件
179        ALOGE("Failed to close %s", LAST_RESUME_REASON);
180        return -1;
181    }
182    return mergedreasonpos - mergedreason;
183}

在BSS中，initPowerManagement的工作主要包括两个：

一是监控终端低电模式的状态，当发生改变时进行相应的记录；二是监控终端从挂起状态变为唤醒状态，并记录唤醒的原因

2.3 BSImpl的构造函数

BatteryStatsImpl.BatteryStatsImpl
代码路径：/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java)

8602    public BatteryStatsImpl(Clocks clocks, File systemDir, Handler handler,
8603            ExternalStatsSync externalSync, PlatformIdleStateCallback cb) {
8604        init(clocks);

2.3.1、init初始化

首先BSImpl在构造函数中，调用init进行初始化工作

637    private void init(Clocks clocks) {
638        mClocks = clocks;
639    }

2.3.2、创建统计所需要的文件

8606 if ( systemDir != null ) { 8607 mFile = new JournaledFile (new File ( systemDir , "batterystats.bin" ), 8608 new File ( systemDir , "batterystats.bin.tmp" ));//创建于data/system/目录下的文件，分别作为原始文件和临时文件 8609 } else { 8610 mFile = null ; 8611 } 8612 mCheckinFile = new AtomicFile (new File ( systemDir , "batterystats-checkin.bin" ));/mCheckinFile存储BSImpl的snapShot,当充电状态从充电变为未充电，且电池累积耗电量足够大时，会将snapShot写入"batterystats-checkin.bin" 8613 mDailyFile = new AtomicFile (new File ( systemDir , " batterystats-daily.xml " ));//mDailyFile应该是用于记录每天的电量统计信息 8614 mExternalSync = externalSync ; 8615 mHandler = new MyHandler ( handler . getLooper ()); 8616 mStartCount ++;

上述代码首先创建了一个JournaledFile，其内部包含两个创建于data/system/目录下的文件，分别作为原始文件和临时文件。这么做的目的是进行备份， 防止在读写过程中文件信息丢失或出错。 这部分文件用于保存BatteryStats电量的统计信息。系统会不定时的将电量统计信息BatteryStats写入到文件中。从代码中操作mDailyFile的接口来看，mDailyFile应该是用于记录每天的电量统计信息。 
2.3.3、创建各模块电量的统计工具 
8617        mScreenOnTimer = new StopwatchTimer(mClocks, null, -1, null, mOnBatteryTimeBase);
8618        for (int i=0; i<NUM_SCREEN_BRIGHTNESS_BINS; i++) {
8619            mScreenBrightnessTimer[i] = new StopwatchTimer(mClocks, null, -100-i, null,
8620                    mOnBatteryTimeBase);
8621        }
8622        mInteractiveTimer = new StopwatchTimer(mClocks, null, -10, null, mOnBatteryTimeBase);
8623        mPowerSaveModeEnabledTimer = new StopwatchTimer(mClocks, null, -2, null,
8624                mOnBatteryTimeBase);
8625        mDeviceIdleModeLightTimer = new StopwatchTimer(mClocks, null, -11, null,
8626                mOnBatteryTimeBase);
8627        mDeviceIdleModeFullTimer = new StopwatchTimer(mClocks, null, -14, null, mOnBatteryTimeBase);
8628        mDeviceLightIdlingTimer = new StopwatchTimer(mClocks, null, -15, null, mOnBatteryTimeBase);
8629        mDeviceIdlingTimer = new StopwatchTimer(mClocks, null, -12




    
, null, mOnBatteryTimeBase);
8630        mPhoneOnTimer = new StopwatchTimer(mClocks, null, -3, null, mOnBatteryTimeBase);
8631        for (int i=0; i<SignalStrength.NUM_SIGNAL_STRENGTH_BINS; i++) {
8632            mPhoneSignalStrengthsTimer[i] = new StopwatchTimer(mClocks, null, -200-i, null,
8633                    mOnBatteryTimeBase);
8634        }
8635        mPhoneSignalScanningTimer = new StopwatchTimer(mClocks, null, -200+1, null,
8636                mOnBatteryTimeBase);
8637        for (int i=0; i<NUM_DATA_CONNECTION_TYPES; i++) {
8638            mPhoneDataConnectionsTimer[i] = new StopwatchTimer(mClocks, null, -300-i, null,
8639                    mOnBatteryTimeBase);
8640        }
8641        for (int i = 0; i < NUM_NETWORK_ACTIVITY_TYPES; i++) {
8642            mNetworkByteActivityCounters[i] = new LongSamplingCounter(mOnBatteryTimeBase);
8643            mNetworkPacketActivityCounters[i] = new LongSamplingCounter(mOnBatteryTimeBase);
8644        }
8645        mWifiActivity = new ControllerActivityCounterImpl(mOnBatteryTimeBase, NUM_WIFI_TX_LEVELS);
8646        mBluetoothActivity = new ControllerActivityCounterImpl(mOnBatteryTimeBase,
8647                NUM_BT_TX_LEVELS);
8648        mModemActivity = new ControllerActivityCounterImpl(mOnBatteryTimeBase,
8649                ModemActivityInfo.TX_POWER_LEVELS);
8650        mMobileRadioActiveTimer = new StopwatchTimer(mClocks, null, -400, null, mOnBatteryTimeBase);
8651        mMobileRadioActivePerAppTimer = new StopwatchTimer(mClocks, null, -401, null,
8652                mOnBatteryTimeBase);
8653        mMobileRadioActiveAdjustedTime = new LongSamplingCounter(mOnBatteryTimeBase);
8654        mMobileRadioActiveUnknownTime = new LongSamplingCounter(mOnBatteryTimeBase);
8655        mMobileRadioActiveUnknownCount = new LongSamplingCounter(mOnBatteryTimeBase);
8656        mWifiOnTimer = new StopwatchTimer(mClocks, null, -4




    
, null, mOnBatteryTimeBase);
8657        mGlobalWifiRunningTimer = new StopwatchTimer(mClocks, null, -5, null, mOnBatteryTimeBase);
8658        for (int i=0; i<NUM_WIFI_STATES; i++) {
8659            mWifiStateTimer[i] = new StopwatchTimer(mClocks, null, -600-i, null,
8660                    mOnBatteryTimeBase);
8661        }
8662        for (int i=0; i<NUM_WIFI_SUPPL_STATES; i++) {
8663            mWifiSupplStateTimer[i] = new StopwatchTimer(mClocks, null, -700-i, null,
8664                    mOnBatteryTimeBase);
8665        }
8666        for (int i=0; i<NUM_WIFI_SIGNAL_STRENGTH_BINS; i++) {
8667            mWifiSignalStrengthsTimer[i] = new StopwatchTimer(mClocks, null, -800-i, null,
8668                    mOnBatteryTimeBase);
8669        }
8670        mAudioOnTimer = new StopwatchTimer(mClocks, null, -7, null, mOnBatteryTimeBase);
8671        mVideoOnTimer = new StopwatchTimer(mClocks, null, -8, null, mOnBatteryTimeBase);
8672        mFlashlightOnTimer = new StopwatchTimer(mClocks, null, -9, null, mOnBatteryTimeBase);
8673        mCameraOnTimer = new StopwatchTimer(mClocks, null, -13, null, mOnBatteryTimeBase);
8674        mBluetoothScanTimer = new StopwatchTimer(mClocks, null, -14, null, mOnBatteryTimeBase);
8675        mDischargeScreenOffCounter = new LongSamplingCounter(mOnBatteryScreenOffTimeBase);
8676        mDischargeCounter = new LongSamplingCounter(mOnBatteryTimeBase); 
BSImpl需要统计各个模块的耗电情况，甚至需要统计一个模块在不同场景下的耗电情况。 




    
 
BSImpl在其构造函数中创建了许多对象进行分类统计。 BSImpl在构造函数中创建的工具类就有三种，即StopwatchTimer、LongSamplingCounter和ControllerActivityCounterImpl。 
ControllerActivityCounterImpl包含了多个LongSamplingCounter对象。 
Counter相关的主要用于计数，Timer相关的用于计时。 电量的统计主要依赖于Timer；Counter相关的对象，多进行统计发包数量、分组数量这样的工作。 
 
在Android系统中，手机的电压是一定的，具体操作的耗电量在构造PowerProfile时已经得到了，因此手机中各模块的电量计算，就是利用模块使用时间*模块对应操作的单位耗电量。 
耗电量 = 单位时间的耗电量(w) × 使用时间(t) = 电压(U) × 单位时间电流量(I) × 使用时间(t)
 
这些工具类均实现了TimeBaseObs接口定义的onTimeStarted函数和onTimeStopped。  
2.3.4、初始化剩余变量 
8677        mOnBattery = mOnBatteryInternal = false;
8678        long uptime = mClocks.uptimeMillis() * 1000;
8679        long realtime = mClocks.elapsedRealtime() * 1000;
8680        initTimes(uptime, realtime);//初始化统计时间
8681        mStartPlatformVersion = mEndPlatformVersion = Build.ID;
8682        mDischargeStartLevel = 0;
8683        mDischargeUnplugLevel = 0;
8684        mDischargePlugLevel = -1;
8685        mDischargeCurrentLevel = 0;
8686        mCurrentBatteryLevel = 0;
8687        initDischarge();
8688        clearHistoryLocked();//删除用电统计的记录
8689        updateDailyDeadlineLocked();
8690        mPlatformIdleStateCallback = cb;
8691    } 
BSImpl的构造函数最后会初始化大量的变量。
 
系统时间分为uptime和realtime。uptime和realtime的时间起点都从系统启动开始算， 但是uptime不包括系统休眠时间，而realtime包括系统休眠时间。
 
2.4 、BSS及BSImpl主要流程分析 
 
2.4.1、BSImpl的readLocked  
代码路径：/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java)
 
2761        File dataDir = Environment.getDataDirectory();
2762        File systemDir = new File(dataDir, "system"




    
);
2763        systemDir.mkdirs();
2764        mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
2765        mBatteryStatsService.getActiveStatistics().readLocked();//getActiveStatistics返回BSImpl
2766        mBatteryStatsService.scheduleWriteToDisk(); 
ActivityManagerService创建出BatteryStatsService后 
2.4.2、BSImpl.readLocked 
代码路径：/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java)
 
11133
11134    public void readLocked() {
11135        if (mDailyFile != null) {
11136            readDailyStatsLocked();//读取BSImpl维护的mDailyFile，解析其中的数据保存到mDailyItems中
11137        }
11138        //mFile为"batterystats.bin"对应的JournaledFile
11139        if (mFile == null) {
11140            Slog.w("BatteryStats", "readLocked: no file associated with this instance");
11141            return;
11142        }
11143        //mUidStats保存了BatteryStatsImpl.Uid,BSImpl定义的数据结构，继承BSS.Uid，记录每个uid对应的耗电情况
11144        mUidStats.clear();
11145
11146        try {
11147            File file = mFile.chooseForRead();//从JournaledFile选择实际文件和备份文件中的一个读取
11148            if (!file.exists()) {
11149                return;
11150            }
11151            FileInputStream stream = new FileInputStream(file);
11152
11153            byte[] raw = BatteryStatsHelper.readFully(stream);
11154            Parcel in = Parcel.obtain();
11155            in.unmarshall(raw, 0, raw.length);
11156            in.setDataPosition(0);
11157            stream.close();
11158
11159            readSummaryFromParcel(in);//利用从"batterystats.bin"中读取的数据初始化BSImpl的变量
11160        } catch(Exception e) {
11161            Slog.e("BatteryStats"




    
, "Error reading battery statistics", e);
11162            resetAllStatsLocked();
11163        }
11164
11165        mEndPlatformVersion = Build.ID;
11166        //开始记录历史信息
11167        if (mHistoryBuffer.dataPosition() > 0) {
11168            mRecordingHistory = true;
11169            final long elapsedRealtime = mClocks.elapsedRealtime();
11170            final long uptime = mClocks.uptimeMillis();
11171            if (USE_OLD_HISTORY) {
11172                addHistoryRecordLocked(elapsedRealtime, uptime, HistoryItem.CMD_START, mHistoryCur);
11173            }
11174            addHistoryBufferLocked(elapsedRealtime, uptime, HistoryItem.CMD_START, mHistoryCur);
11175            startRecordingHistory(elapsedRealtime, uptime, false);
11176        }
11177
11178        recordDailyStatsIfNeededLocked(false);//当时间满足条件时，记录每日的信息
11179    } 
readLocked主要的功能是读取之前的统计信息，然后初始化BSImpl对象。 
BSImpl中的Uid类继承自BatteryStats的Uid类。 其中： 
    WakeLock用于统计该Uid对应进程使用某个WakeLock的用电情况； 
    Proc用于统计该Uid对应的某个进程的用电情况； 
    Pkg用于统计某个Pacakge的电量使用情况，其内部类Serv用于统计该Package内某个服务的用电情况； 
    Sensor用于统计传感器的用电情况
 
2.4.3 BSS的scheduleWriteToDisk  
代码路径：/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java) 
306    public void scheduleWriteToDisk() {
307        mHandler.sendEmptyMessage(BatteryStatsHandler.MSG_WRITE_TO_DISK);
308    } 
MSG_WRITE_TO_DISK对应的处理流程为 
 class BatteryStatsHandler extends Handler implements BatteryStatsImpl.ExternalStatsSync { 
           ..............................................
121        public static final int MSG_WRITE_TO_DISK = 2;
           ..........................................
126        public BatteryStatsHandler(Looper looper) {
127            super(looper);
128        }
130        @Override
131        public void handleMessage(Message msg) {
132            switch (msg.what) {
            ..................................
156                case MSG_WRITE_TO_DISK:
157                    updateExternalStatsSync("write"




    
, UPDATE_ALL);//进行信息更新
158                    if (DBG) Slog.d(TAG, "begin writeAsyncLocked");
159                    synchronized (mStats) {
160                        mStats.writeAsyncLocked();//完成信息写入
161                    }
162                    if (DBG) Slog.d(TAG, "end writeAsyncLocked");
163                    break;
164            }
165        }
             .........................................
188    } 
2.4.3.1 updateExternalStatsSync信息更新 
代码路径：/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java)
 
1484    void updateExternalStatsSync(final String reason, int updateFlags) {
1485        SynchronousResultReceiver wifiReceiver = null;//SynchronousResultReceiver用于接收消息
1486        SynchronousResultReceiver bluetoothReceiver = null;
1487        SynchronousResultReceiver modemReceiver = null;
1489        if (DBG) Slog.d(TAG, "begin updateExternalStatsSync reason=" + reason);
1490        synchronized (mExternalStatsLock) {
1491            if (mContext == null) {
1492                // Don't do any work yet.
1493                if (DBG) Slog.d(TAG, "end updateExternalStatsSync");
1494                return;
1495            }
1497            if ((updateFlags & UPDATE_WIFI) != 0) {
1498                if (mWifiManager == null) {
1499                    mWifiManager = IWifiManager.Stub.asInterface(
1500                            ServiceManager.getService(Context.WIFI_SERVICE));
1501                }
1503                if (mWifiManager != null) {
1504                    try {
1505                        wifiReceiver = new SynchronousResultReceiver();//获取WiFi的信息，传入SynchronousResultReceiver对象
1506                        mWifiManager.requestActivityInfo(wifiReceiver);
1507                    } catch (RemoteException e) {
1508                        // Oh well.




    

1509                    }
1510                }
1511            }
1513            if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_BT) != 0) {
1514                final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
1515                if (adapter != null) {
1516                    bluetoothReceiver = new SynchronousResultReceiver();//获取蓝牙的信息，传入SynchronousResultReceiver对象
1517                    adapter.requestControllerActivityEnergyInfo(bluetoothReceiver);
1518                }
1519            }
1521            if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_RADIO) != 0) {
1522                if (mTelephony == null) {
1523                    mTelephony = TelephonyManager.from(mContext);
1524                }
1526                if (mTelephony != null) {
1527                    modemReceiver = new SynchronousResultReceiver();//获取modem的信息，传入SynchronousResultReceiver对象
1528                    mTelephony.requestModemActivityInfo(modemReceiver);//对于Telephony而言，就是通过RIL发送消息给modem，获取返回结果
1529                }
1530            }
1532            WifiActivityEnergyInfo wifiInfo = null;
1533            BluetoothActivityEnergyInfo bluetoothInfo = null;
1534            ModemActivityInfo modemInfo = null;
1535            try {
1536                wifiInfo = awaitControllerInfo(wifiReceiver);//awaitControllerInfo内部调用SynchronousResultReceiver对象的awaitResult函数,在获得消息前，会等待一段时间直到超时,获取到结果时，退出等待
1537            } catch (TimeoutException e) {
1538                Slog.w(TAG, "Timeout reading wifi stats"




    
);
1539            }
1541            try {
1542                bluetoothInfo = awaitControllerInfo(bluetoothReceiver);
1543            } catch (TimeoutException e) {
1544                Slog.w(TAG, "Timeout reading bt stats");
1545            }
1547            try {
1548                modemInfo = awaitControllerInfo(modemReceiver);
1549            } catch (TimeoutException e) {
1550                Slog.w(TAG, "Timeout reading modem stats");
1551            }
1553            synchronized (mStats) {//更新相关的信息
1554                mStats.addHistoryEventLocked(
1555                        SystemClock.elapsedRealtime(),
1556                        SystemClock.uptimeMillis(),
1557                        BatteryStats.HistoryItem.EVENT_COLLECT_EXTERNAL_STATS,
1558                        reason, 0);
1560                if ((updateFlags & UPDATE_CPU) != 0) {
1561                    mStats.updateCpuTimeLocked(true /* updateCpuFreqData */);
1562                }
1563                mStats.updateKernelWakelocksLocked();
1564                mStats.updateKernelMemoryBandwidthLocked();
1566                if (bluetoothInfo != null) {
1567                    if (bluetoothInfo.isValid()) {
1568                        mStats.updateBluetoothStateLocked(bluetoothInfo);//更新蓝牙的耗电情况
1569                    } else {
1570                        Slog.e(TAG, "bluetooth info is invalid: " + bluetoothInfo);
1571                    }
1572                }
1573            }
1575            if (wifiInfo != null) {
1576                if (wifiInfo.isValid()) {
1577                    mStats.updateWifiState(extractDelta(wifiInfo));//更新WiFi的耗电情况
1578                } else {
1579                    Slog.e(TAG, "wifi info is invalid: "




    
 + wifiInfo);
1580                }
1581            }
1583            if (modemInfo != null) {
1584                if (modemInfo.isValid()) {
1585                    mStats.updateMobileRadioState(modemInfo);
1586                } else {
1587                    Slog.e(TAG, "modem info is invalid: " + modemInfo);
1588                }
1589            }
1590        }
1591        if (DBG) Slog.d(TAG, "end updateExternalStatsSync");
1592    } 
updateExternalStatsSync函数用于同步当前终端的信息， 主要是获取WiFi、BT和modem的耗电情况，并保存到BSImpl中。 
2.4.3.2 BSImpl的writeAsyncLocked函数 
代码路径：/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java)
 
11069    public void writeAsyncLocked() {
11070        writeLocked(false);//传入的值为false，表示异步
11071    }
11072
11073    public void writeSyncLocked() {
11074        writeLocked(true);
11075    }
11076
11077    void writeLocked(boolean sync) {
11078        if (mFile == null) {
11079            Slog.w("BatteryStats", "writeLocked: no file associated with this instance");
11080            return;
11081        }
11082
11083        if (mShuttingDown) {
11084            return;
11085        }
11086
11087        Parcel out = Parcel.obtain();
11088        writeSummaryToParcel(out, true);//将BSImpl中的信息写入到Parcel对象
11089        mLastWriteTime = mClocks.elapsedRealtime();
11090
11091        if (mPendingWrite != null) {
11092            mPendingWrite.recycle();
11093        }
11094        mPendingWrite = out;//Parcel对象保存到mPendingWrite
11095
11096        if (sync) {//同步时用主线程写
11097            commitPendingDataToDisk();
11098        } else {//异步时利用后台线程写
11099            BackgroundThread.getHandler().post(new Runnable() {
11100                @Override public void run() {
11101                    commitPendingDataToDisk();
11102                }
11103            });
11104        }
11105    } 
从11097行和11101行commitPendingDataToDisk才是进行实际的写操作




    

 
11107    public void commitPendingDataToDisk() {
11108        final Parcel next;
11109        synchronized (this) {
11110            next = mPendingWrite;
11111            mPendingWrite = null;
11112            if (next == null) {
11113                return;
11114            }
11115        }
11116
11117        mWriteLock.lock();
11118        try {
11119            FileOutputStream stream = new FileOutputStream(mFile.chooseForWrite());//写入的文件还是"batterystats.bin"
11120            stream.write(next.marshall()); //next为mPendingWrite，即当前待写入的内容
11121            stream.flush();
11122            FileUtils.sync(stream);
11123            stream.close();
11124            mFile.commit();
11125        } catch (IOException e) {
11126            Slog.w("BatteryStats"




    
, "Error writing battery statistics", e);
11127            mFile.rollback();
11128        } finally {
11129            next.recycle();
11130            mWriteLock.unlock();
11131        }
11132    } 
scheduleWriteToDisk的作用就是将手机中最新的信息保存到硬盘中 
3、BSImpl耗电时间统计 
了解BSS和BSImpl初始的一些流程后，我们来看看BSImpl到底是如何统计和计算电量的。 
3.1 楔子 
在BSS中定义了许多以note开头的方法，这些方法就是不同模块用于通知BSS记录用电信息的。 以数据业务为例，看看统计电量的过程。 
 代码路径： /frameworks/base/services/core/java/com/android/server/ConnectivityService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/ConnectivityService.java) 
3.1.1 ConnectivityService的构造函数： 
677    @VisibleForTesting
678    protected ConnectivityService(Context context, INetworkManagementService netManager,
679            INetworkStatsService statsService, INetworkPolicyManager policyManager,
680            IpConnectivityLog logger) {
            ...........................................
818        //创建出DataConnectionStats，该类继承自BroadcastReceiver
819        mDataConnectionStats = new DataConnectionStats(mContext);
820        mDataConnectionStats.startMonitoring();
            .....................................
841    } 
3.1.2DataConnectionStats类： 
代码路径：/frameworks/base/services/core/java/com/android/server/connectivity/DataConnectionStats.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/connectivity/DataConnectionStats.java)
 
48    public DataConnectionStats(Context context) {
49        mContext = context;
50        mBatteryStats = BatteryStatsService.getService();//获取到BatteryStatsService的代理对象
53    public void startMonitoring() {
54        TelephonyManager phone =
55                (TelephonyManager)mContext.getSystemService(Context.TELEPHONY_SERVICE);
56        phone.listen(mPhoneStateListener,//listen phone状态的变化
57                PhoneStateListener.LISTEN_SERVICE_STATE
58              | PhoneStateListener.LISTEN_SIGNAL_STRENGTHS
59              | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE
60              | PhoneStateListener.LISTEN_DATA_ACTIVITY);
61        //监听以下广播
62        IntentFilter filter = new IntentFilter();
63        filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
64        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
65        filter.addAction(ConnectivityManager.INET_CONDITION_ACTION);
66        mContext.registerReceiver(this, filter);
69    @Override
70    public void onReceive(Context context, Intent intent) {
71        final String action = intent.getAction();
72        if (action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) {
73            updateSimState(intent);
74            notePhoneDataConnectionState(); //注意notePhoneDataConnectionState
75        } else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION) ||
76                action.equals(ConnectivityManager.INET_CONDITION_ACTION)) {
77            notePhoneDataConnectionState();
81    private void notePhoneDataConnectionState() {
82        if (mServiceState == null) {
83            return;
85        boolean simReadyOrUnknown = mSimState == IccCardConstants.State.READY
86                || mSimState == IccCardConstants.State.UNKNOWN;
87        boolean visible = (simReadyOrUnknown || isCdma()) // we only check the sim state for GSM




    

88                && hasService()
89                && mDataState == TelephonyManager.DATA_CONNECTED;
90        int networkType = mServiceState.getDataNetworkType();
91        if (DEBUG) Log.d(TAG, String.format("Noting data connection for network type %s: %svisible",
92                networkType, visible ? "" : "not "));
93        try {
94            mBatteryStats.notePhoneDataConnectionState(networkType, visible);
95        } catch (RemoteException e) {
96            Log.w(TAG, "Error noting data connection state", e);
            ................................................
131    private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
132        @Override
133        public void onSignalStrengthsChanged(SignalStrength signalStrength) {
134            mSignalStrength = signalStrength;
135        }
137        @Override
138        public void onServiceStateChanged(ServiceState state) {
139            mServiceState = state;
140            notePhoneDataConnectionState();//同样会有notePhoneDataConnectionState
141        }
143        @Override
144        public void onDataConnectionStateChanged(int state, int networkType) {
145            mDataState = state;
146            notePhoneDataConnectionState();//同样会有notePhoneDataConnectionState
147        }
149        @Override
150        public void onDataActivity(int direction) {
151            notePhoneDataConnectionState();//同样会有notePhoneDataConnectionState
152        }
153    };
154}
DataConnectionStats监控了整个终端中与数据相关的比较重要的状态，例如SIM State、Service State等。当状态发生变化时，就会调用notePhoneDataConnectionState函数。 
3.1.3 DataConnectionStats.notePhoneDataConnectionState： 
代码路径：/frameworks/base/services/core/java/com/android/server/connectivity/DataConnectionStats.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/connectivity/DataConnectionStats.java)





    
 
   81 private void notePhoneDataConnectionState() { 
82        if (mServiceState == null) {
83            return;
85        boolean simReadyOrUnknown = mSimState == IccCardConstants.State.READY
86                || mSimState == IccCardConstants.State.UNKNOWN;
87        boolean visible = (simReadyOrUnknown || isCdma()) //基本上可以简单的认为有服务并且数据脸上时，visible为true
88                && hasService()
89                && mDataState == TelephonyManager.DATA_CONNECTED;
90        int networkType = mServiceState.getDataNetworkType();
91        if (DEBUG) Log.d(TAG, String.format("Noting data connection for network type %s: %svisible",
92                networkType, visible ? "" : "not "));
93        try {
94            mBatteryStats.notePhoneDataConnectionState(networkType, visible);//进入到BSS中
95        } catch (RemoteException e) {
96            Log.w(TAG, "Error noting data connection state", e);
3.1.4 BatteryStatsService.notePhoneDataConnectionState 
代码路径：/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java)
 
646    public void notePhoneDataConnectionState(int dataType, boolean hasData) {
647        enforceCallingPermission();
648        synchronized (mStats) {
649            mStats.notePhoneDataConnectionStateLocked(dataType, hasData); //委托给BSImpl处理
650        }
651    } 
3.1.5 BSImpl.notePhoneDataConnectionStateLocked： 
代码路径：/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java
(http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java)




    

 
4512    public void notePhoneDataConnectionStateLocked(int dataType, boolean hasData) {
4513        int bin = DATA_CONNECTION_NONE;
4514        if (hasData) {//数据连接上时，hasData为true 
4515            switch (dataType) {//dataType对应与networkType
4516                case TelephonyManager.NETWORK_TYPE_EDGE://根据NetworkType， 给bin赋予不同的值
4517                    bin = DATA_CONNECTION_EDGE;
4518                    break;
        .......................................
4564            }
4565        }
4566        if (DEBUG) Log.i(TAG, "Phone Data Connection -> " + dataType + " = " + hasData);
4567        if (mPhoneDataConnectionType != bin) {//数据网络的类型发生改变时
4568            final long elapsedRealtime = mClocks.elapsedRealtime();//实际消逝的时间
4569            final long uptime = mClocks.uptimeMillis();//系统处于唤醒的状态消逝的时间
4570            mHistoryCur.states = (mHistoryCur.states&~HistoryItem.STATE_DATA_CONNECTION_MASK)
4571                    | (bin << HistoryItem.STATE_DATA_CONNECTION_SHIFT);
4572            if (DEBUG_HISTORY) Slog.v(TAG, "Data connection " + bin + " to: "
4573                    + Integer.toHexString(mHistoryCur.states));
4574            addHistoryRecordLocked(elapsedRealtime, uptime);//记录信息
4575            if (mPhoneDataConnectionType >= 0) {
4576                mPhoneDataConnectionsTimer[mPhoneDataConnectionType].stopRunningLocked(
4577                        elapsedRealtime);//旧networkType对应的StopWatchTime停止记录时间
4578            }
4579            mPhoneDataConnectionType = bin; 
                //新networkType对应的StopWatchTimer开始记录时间
4580            mPhoneDataConnectionsTimer[bin].startRunningLocked(elapsedRealtime);
4581        }
4582    } 
对于数据业务而言，BSImpl初始化时创建了一个StopWatchTimer数组mPhoneDataConnectionsTimer，用于记录不同NetworkType下，数据业务的耗电时间。 因此，每次NetworkType发生改变时，就停止旧有的NetworkType对应StopWatchTimer，这样就可以得到旧有NetworkType下耗电的时间。同时，启动新的NetworkType的StopWatchTimer，这样当下次NetworkType发生改变时，就可以得到数据业务在这个NetworkType下耗电的时间。 
3.2 StopWatchTimer的startRunningLocked 
代码路径：/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java




    

(http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/com/android/internal/os/BatteryStatsImpl.java)
 
2037        public void startRunningLocked(long elapsedRealtimeMs) {
2038            if (mNesting++ == 0) {
2039                final long batteryRealtime = mTimeBase.getRealtime(elapsedRealtimeMs * 1000);
2040                mUpdateTime = batteryRealtime;
2041                if (mTimerPool != null) {
2042                    // Accumulate time to all currently active timers before adding
2043                    // this new one to the pool.
2044                    refreshTimersLocked(batteryRealtime, mTimerPool, null);
2045                    // Add this timer to the active pool
2046                    mTimerPool.add(this);
2047                }
2048                if (mTimeBase.isRunning()) {
2049                    // Increment the count
2050                    mCount++;
2051                    mAcquireTime = mTotalTime;
2052                } else {
2053                    mAcquireTime = -1;
2054                }
2055                if (DEBUG && mType < 0) {
2056                    Log.v(TAG, "start #" + mType + ": mUpdateTime=" + mUpdateTime
2057                            + " mTotalTime=" + mTotalTime + " mCount=" + mCount
2058                            + " mAcquireTime=" + mAcquireTime);
2059                }
2060            }
2061        } 
在startRunningLocked函数中，我们只需要知道StopWatchTimer中的mUpdateTime记录者本次的启动时间。
 
 StopWatchTimer.stopRunningLocked 
2067        public void stopRunningLocked(long elapsedRealtimeMs) {
2068            // Ignore attempt to stop a timer that isn't running
2069            if (mNesting == 0) {
2070                return;
2071            }
2072            if (--mNesting == 0) {
2073                final long batteryRealtime = mTimeBase.getRealtime(elapsedRealtimeMs * 1000




    
);
2074                if (mTimerPool != null) {
2075                    // Accumulate time to all active counters, scaled by the total
2076                    // active in the pool, before taking this one out of the pool.
2077                    refreshTimersLocked(batteryRealtime, mTimerPool, null);
2078                    // Remove this timer from the active pool
2079                    mTimerPool.remove(this);
2080                } else {
2081                    mNesting = 1;
2082                    mTotalTime = computeRunTimeLocked(batteryRealtime);
2083                    mNesting = 0;
2084                }
2086                if (DEBUG && mType < 0) {
2087                    Log.v(TAG, "stop #" + mType + ": mUpdateTime=" + mUpdateTime
2088                            + " mTotalTime=" + mTotalTime + " mCount=" + mCount
2089                            + " mAcquireTime=" + mAcquireTime);
2090                }
2092                if (mAcquireTime >= 0 && mTotalTime == mAcquireTime) {
2093                    // If there was no change in the time, then discard this
2094                    // count.  A somewhat cheezy strategy, but hey.
2095                    mCount--;
2096                }
2097            }
2098        }        ............................................................................ 
2128        @Override
2129        protected long computeRunTimeLocked(long curBatteryRealtime) {
2130            if (mTimeout > 0 && curBatteryRealtime > mUpdateTime + mTimeout) {
2131                curBatteryRealtime = mUpdateTime + mTimeout;
2132            }
2133            return mTotalTime + (mNesting > 0
2134                    ? (curBatteryRealtime - mUpdateTime)
2135                            / (mTimerPool != null ? mTimerPool.size() : 1)
2136                    : 0);
2137        } 
BSS中整个耗电统计的架构，大概如下图所示： 

每个模块都会监控自己的关键状态。 当状态发生改变时，直接或间接地通知到BBS。 BSS收到通知后，通过各种以note开头的函数，将通知递交给BSImpl进行实际的处理。 BSImpl完成启动或停止对应模块的StopWatchTimer，完成对该模块耗电时间的统计。
                    1. 概要手机耗电量主要涵盖两个方面：硬件层面的功耗和软件层面的电量。本文介绍的电量统计的原理，并不涉及到硬件层面的功耗设计，仅从软件层面围绕以下几个问题进行分析：        Android如何启动电量统计服务？        电量统计涉及到哪一些硬件模块？        如何计算一个应用程序的耗电量？        电量统计需要完成哪些具体工作？手机有很多硬件模块：CPU，蓝牙，GPS，显示...
从BatteryStatsService的启动时序图可以看出，BatteryStatsService服务是在ActivityManagerService服务中启动的
1. 在SystemServer中startBoots
				SystemServer在启动BatteryService时，一次会调用它的构造函数，onStart，onBootPhase方法;解析来我们分析一下这些方法：
1.Constructor方法：
public BatteryService(Context context) {
    super(context);
    mContext = context;
    mHandler = new Handler(true /*async*/);
    //电源呼吸灯
    mLed = new Led
				BatteryStasService的主要功能是收集系统中各模块和应用进程的用电情况。 
因此，我们可以认为BatteryStatsService是Android中的“电表”。 
只不过这个电表比较智能，不是单纯地统计整体的耗电，而是分门别类的统计每个部分的耗电情况。 
接下来我们就分析一下BatteryStatsService的主要流程。
				--------- beginning of system
08-26 13:31:37.070 10872 10872 E VgcUtil : getFile name :theme_dir_pathnot exit in vgc_path_config.xml
08-30 15:34:43.657 20328 20328 E VgcUtil : getFile name :theme_dir_pathnot exit in vgc_path_config.xml
--------- beginning 
Java语言的执行环境是JVM（JAVA虚拟机），JVM其实是主机环境中的一个进程，每个JVM虚拟机进程在本地环境中都对应有一个JavaVM的结构体，用来记录当前JVM进程的相关环境数据。该结构体在创建Java虚拟机时被返回，在JNI中创建JVM的函数为JNI_CreateJavaVM。
在JNI的双向调用(JavaC/C++)过程中，JNIEnv是一个很
				文章目录Android性能优化——电量1. 理解电池消耗2. Battery Historian3. 充电状态和BatteryManager4. Wakelock和电池消耗5. 网络和电池消耗6. 使用JobScheduler
Android性能优化——电量
原Udacity视频链接
1. 理解电池消耗
手机各个硬件模块的耗电量是不一样的，有些模块非常耗电，而有些模块则相对显得耗电量小很多。
Android Framework 电源子系统 的分析主要分为以下部分：
Android Framework 电源子系统（01）PowerManagerService启动分析
Android Framework 电源子系统（02）系统休眠wakelock机制
Android Framework 电源子系统（03）核心方法updatePowerStateLoc...
				BatteryStatsHelper这个类主要是统计各个应用，多用户的每个用户，以及蓝牙，屏幕等耗电统计。
一般使用BatteryStatsHelper这个类，先要new一个实例，然后再调用create函数：
下面我们就先从create分析，两种create方法，其中sStatsXfer是静态的
[java] view
 plaincopy
				FusionCompute CNA-8.0.0-arm是华为公司推出的一款基于ARM架构的新一代云计算虚拟化平台，该平台具有稳定性高、性能强、适用范围广等优点，在云计算领域具有广泛的应用价值。该平台提供了高效的虚拟化能力，能够为企业客户提供更加安全和可靠的虚拟化解决方案。
作为一种云计算服务提供平台，FusionCompute CNA-8.0.0-arm具有一些独特的特点。首先，该平台采用最新的ARM架构，可以支持更加广泛的应用场景，具有很强的通用性和可扩展性。其次，该平台提供了高度智能化的管理功能，可以自动化分配计算资源，优化资源的运用效率，并且具有严格的安全保障机制，可以有效保护客户的数据安全。
同时，FusionCompute CNA-8.0.0-arm采用了独特的分布式架构，可以快速响应客户的需求，为客户提供更加优质的服务。其虚拟化能力卓越，可以满足客户在不同行业的需求，例如金融、交通、医疗、教育等领域的应用需求，并可提供高效的云计算解决方案。
总之，FusionCompute CNA-8.0.0-arm是一款非常优秀的云计算虚拟化平台，是企业客户在建立云计算服务时的绝佳选择。该平台采用最新的ARM架构，具有通用性和可扩展性，且具有优异的性能表现，可以满足各种不同行业的需求。同时，该平台具有智能化的管理功能和严格的安全保障机制，可以为企业客户提供更加安全可靠、高效的云计算服务。