BatteryService：电池电量管理

最新推荐文章于 2023-08-23 15:14:07 发布
最新推荐文章于 2023-08-23 15:14:07 发布
阅读量5.4k 收藏 30
点赞数 9
分类专栏： 电源管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renshuguo123723/article/details/87431240
版权

前言：BatteryService用于获取电池信息、充电状态等，如果想对Android的功耗控制有更深入的了解，有必要分析一下BatteryService。

1.来看下BatteryService.java:

BatteryService.java

public BatteryService(Context context) {
    super(context);

    mContext = context;
    mHandler = new Handler(true /*async*/);

    //Led封装了LightsManager,不同电量下led灯的颜色就由它来控制
    mLed = new Led(context, getLocalService(LightsManager.class));

    //电池属性改变的时候,会将全部信息写到mBatteryStats中,app端从mBatteryStats中获取当前电池的电量以及状态
    mBatteryStats = BatteryStatsService.getService();
    mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);

    //以下是根据配置文件,定义不同电量对应的等级

    //电池危急的电量；当电池电量低于此值时,将强制关机,这里是5
    mCriticalBatteryLevel = mContext.getResources().getInteger(
            com.android.internal.R.integer.config_criticalBatteryWarningLevel);

    //低电警告的电量；当电池电量低于此值时,系统报警,例如闪烁LED灯等,这里是15
    mLowBatteryWarningLevel = mContext.getResources().getInteger(
            com.android.internal.R.integer.config_lowBatteryWarningLevel);

    //关闭低电警告的电量；当电池电量高于此值时,结束低电状态,停止警示灯,这里是20
    mLowBatteryCloseWarningLevel = mLowBatteryWarningLevel + mContext.getResources().getInteger(
            com.android.internal.R.integer.config_lowBatteryCloseWarningBump);

    //关闭电池的温度（温度失控，就会出现三星S7爆炸啥的......）
    mShutdownBatteryTemperature = mContext.getResources().getInteger(
            com.android.internal.R.integer.shutdownBatteryTemperature);

    // 监控终端是否连接不匹配的充电器
    if (new File("/sys/devices/virtual/switch/invalid_charger/state").exists()) {
        UEventObserver invalidChargerObserver = new UEventObserver() {
            @Override
            public void onUEvent(UEvent event) {
                final int invalidCharger = "1".equals(event.get("SWITCH_STATE")) ? 1 : 0;
                synchronized (mLock) {
                    if (mInvalidCharger != invalidCharger) {
                        mInvalidCharger = invalidCharger;
                    }
                }
            }
        };
        invalidChargerObserver.startObserving(
                "DEVPATH=/devices/virtual/switch/invalid_charger");
    }
}

(1)既然是服务，那就看下它的onStart()方法：

public void onStart() {
    //获取电源属性服务的BinderProxy对象，java层通过Binder直接与native层通信
    IBinder b = ServiceManager.getService("batteryproperties");
    final IBatteryPropertiesRegistrar batteryPropertiesRegistrar =
            IBatteryPropertiesRegistrar.Stub.asInterface(b);
    try {
        //向电源属性服务注册一个回调接口
        //当电源属性发生变化时，BatteryListener的batteryPropertiesChanged函数将被调用
        batteryPropertiesRegistrar.registerListener(new BatteryListener());
    } catch (RemoteException e) {
        // Should never happen.
    }

    mBinderService = new BinderService();
    //将自己注册到service manager进程中
    publishBinderService("battery", mBinderService);
    //以后BatteryManagerInternal接口类型的对象，只能有BatteryService的内部类LocalService一个
    publishLocalService(BatteryManagerInternal.class, new LocalService());
}

 我们使用BatteryListener监听了电池属性的变化，当电池属性改变时，native层会回调BatteryListener.batteryPropertiesChanged()方法：

private final class BatteryListener extends IBatteryPropertiesListener.Stub {
    @Override
    public void batteryPropertiesChanged(BatteryProperties props) {
        final long identity = Binder.clearCallingIdentity();
        try {
            //电源属性发生变化后,回调BatteryService的update函数
            BatteryService.this.update(props);
        } finally {
            Binder.restoreCallingIdentity(identity);
        }
    }
}

再来看下update()方法：

private void update(BatteryProperties props) {
    synchronized (mLock) {
        //从代码来看，mUpdatesStopped默认为false,通过调用onShellCommand()它的值才有可能改变
        if (!mUpdatesStopped) {
            //mBatteryProps包含了电池的所有信息,由底层传递过来
            mBatteryProps = props;
            //更新电源相关的信息
            processValuesLocked(false);
        } else {
            mLastBatteryProps.set(props);
        }
    }
}

这个processValuesLocked()函数会在后面重点分析;

 

(2)说完了BatteryService的启动过程，还需要看一下onBootPhase()函数，这个函数什么时候会被调用呢？

在SystemServiceManager中有一个startBootPhase(final int phase )函数，这个函数有啥作用呢？

android系统的启动，是分为几个阶段的，startBootPhase(final int phase)中的这个phase，就表示android系统的启动目前处于哪个阶段，SystemServiceManager将这个phase传递给每个系统服务，每个服务可以根据不同的阶段去做不同的事情;

来看下BatteryService在系统不同的启动阶段做了哪些事情：

public void onBootPhase(int phase) {
    //在PHASE_ACTIVITY_MANAGER_READY阶段后,进行部分初始化即
    if (phase == PHASE_ACTIVITY_MANAGER_READY) {
        // check our power situation now that it is safe to display the shutdown dialog.
        synchronized (mLock) {
            ContentObserver obs = new ContentObserver(mHandler) {
                @Override
                public void onChange(boolean selfChange) {
                    synchronized (mLock) {
                        updateBatteryWarningLevelLocked();
                    }
                }
            };
            final ContentResolver resolver = mContext.getContentResolver();
            //监听设置中低电量警告的电量值是否改变，改变时调用updateBatteryWarningLevelLocked函数
            resolver.registerContentObserver(Settings.Global.getUriFor(
                    Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL),
                    false, obs, UserHandle.USER_ALL);
            updateBatteryWarningLevelLocked();
        }
    }
}

onBootPhase()函数主要是注册一个监听器，检测低电量警告的电量值是否改变，然后调用updateBatteryWarningLevelLocked()函数。

接下来就开始分析processValuesLocked()和updateBatteryWarningLevelLocked()函数;

 

2.processValuesLocked()函数解析

private void processValuesLocked(boolean force) {
    //force表示是否需要强制更新的意思

    boolean logOutlier = false;
    long dischargeDuration = 0;

    //判断当前电量是否危险,mBatteryProps包含了电池的所有信息,由底层传递过来,一旦小于等于5,就很危险了
    mBatteryLevelCritical = (mBatteryProps.batteryLevel <= mCriticalBatteryLevel);

    //得到当前的充电类型
    if (mBatteryProps.chargerUsbOnline) {
        //USB充电
        mPlugType = BatteryManager.BATTERY_PLUGGED_USB;
    } else if (mBatteryProps.chargerWirelessOnline) {
        //无限充电
        mPlugType = BatteryManager.BATTERY_PLUGGED_WIRELESS;
    } else if (mBatteryProps.chargerAcOnline) {
        //充电器充电
        mPlugType = BatteryManager.BATTERY_PLUGGED_AC;
    } else {
        //没有充电
        mPlugType = BATTERY_PLUGGED_NONE;
    }

    
    try {
        //电池属性改变的时候,会将全部信息写到mBatteryStats中,app端从mBatteryStats中获取当前电池的电量以及状态
        mBatteryStats.setBatteryState(mBatteryProps.batteryStatus, mBatteryProps.batteryHealth,
                mPlugType, mBatteryProps.batteryLevel, mBatteryProps.batteryTemperature,
                mBatteryProps.batteryVoltage, mBatteryProps.batteryChargeCounter,
                mBatteryProps.batteryFullCharge);
    } catch (RemoteException e) {
        // Should never happen.
    }

    //电池电量低(batteryLevel==0)且未充电时,弹出关机对话框
    shutdownIfNoPowerLocked();

    //电池温度过高(默认为68C),弹出关机对话框
    shutdownIfOverTempLocked();

    //强制更新,或电源相关属性发生变化时,进行对应操作
    if (force || (mBatteryProps.batteryStatus != mLastBatteryStatus ||
            mBatteryProps.batteryHealth != mLastBatteryHealth ||
            mBatteryProps.batteryPresent != mLastBatteryPresent ||
            mBatteryProps.batteryLevel != mLastBatteryLevel ||
            mPlugType != mLastPlugType ||
            mBatteryProps.batteryVoltage != mLastBatteryVoltage ||
            mBatteryProps.batteryTemperature != mLastBatteryTemperature ||
            mBatteryProps.maxChargingCurrent != mLastMaxChargingCurrent ||
            mBatteryProps.maxChargingVoltage != mLastMaxChargingVoltage ||
            mBatteryProps.batteryChargeCounter != mLastChargeCounter ||
            mInvalidCharger != mLastInvalidCharger)) {

        //充电状态发生变化
        if (mPlugType != mLastPlugType) {
            //上次是不充电状态,现在开始充电了,即由不充电变为充电状态
            if (mLastPlugType == BATTERY_PLUGGED_NONE) {
                // discharging -> charging

                // There's no value in this data unless we've discharged at least once and the
                // battery level has changed; so don't log until it does.
                //记录一下不充电待机的情况下，耗电量及耗电时长
                if (mDischargeStartTime != 0 && mDischargeStartLevel != mBatteryProps.batteryLevel) {
                    dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
                    logOutlier = true;
                    EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,
                            mDischargeStartLevel, mBatteryProps.batteryLevel);
                    // make sure we see a discharge event before logging again
                    mDischargeStartTime = 0;
                }
            } else if (mPlugType == BATTERY_PLUGGED_NONE) {//即由充电变为不充电状态
                // charging -> discharging or we just powered up
                //本次充电结束，重新开始计算耗电情况，于是初始化下面的变量
                mDischargeStartTime = SystemClock.elapsedRealtime();
                mDischargeStartLevel = mBatteryProps.batteryLevel;
            }
        }

        //以下是记录电源的状态信息和电量信息
        if (mBatteryProps.batteryStatus != mLastBatteryStatus ||
                mBatteryProps.batteryHealth != mLastBatteryHealth ||
                mBatteryProps.batteryPresent != mLastBatteryPresent ||
                mPlugType != mLastPlugType) {
            EventLog.writeEvent(EventLogTags.BATTERY_STATUS,
                    mBatteryProps.batteryStatus, mBatteryProps.batteryHealth, mBatteryProps.batteryPresent ? 1 : 0,
                    mPlugType, mBatteryProps.batteryTechnology);
        }
        if (mBatteryProps.batteryLevel != mLastBatteryLevel) {
            // Don't do this just from voltage or temperature changes, that is
            // too noisy.
            EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,
                    mBatteryProps.batteryLevel, mBatteryProps.batteryVoltage, mBatteryProps.batteryTemperature);
        }

        //电池电量低到危险的程度,且没充电，记录耗电时间
        if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&
                mPlugType == BATTERY_PLUGGED_NONE) {
            // We want to make sure we log discharge cycle outliers
            // if the battery is about to die.
            dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
            logOutlier = true;
        }

        //以下是判断电源是否处于低电模式

        if (!mBatteryLevelLow) {
            // Should we now switch in to low battery mode?
            // 当前未充电，且当前电量小于提醒电量，设置低电量为true
            if (mPlugType == BATTERY_PLUGGED_NONE
                    && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel) {
                mBatteryLevelLow = true;
            }
        } else {
            // Should we now switch out of low battery mode?
            if (mPlugType != BATTERY_PLUGGED_NONE) {
                //开始充电了，退出低电量模式
                mBatteryLevelLow = false;
            } else if (mBatteryProps.batteryLevel >= mLowBatteryCloseWarningLevel) {
                //电池电量充足，退出低电量模式
                mBatteryLevelLow = false;
            } else if (force && mBatteryProps.batteryLevel >= mLowBatteryWarningLevel) {
                // If being forced, the previous state doesn't matter, we will just
                // absolutely check to see if we are now above the warning level.
                // 强制刷新时，忽略之前的状态
                mBatteryLevelLow = false;
            }
        }

        mSequence++;

        // Separate broadcast is sent for power connected / not connected
        // since the standard intent will not wake any applications and some
        // applications may want to have smart behavior based on this.

        //以下是单独发送一些广播信息,通知外界电池属性的变化：
        //通知进入充电状态，或离开充电状态
        //通知电源进入低电模式，或离开低电模式
        if (mPlugType != 0 && mLastPlugType == 0) {
            final Intent statusIntent = new Intent(Intent.ACTION_POWER_CONNECTED);
            statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
            statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
                }
            });
        } else if (mPlugType == 0 && mLastPlugType != 0) {
            final Intent statusIntent = new Intent(Intent.ACTION_POWER_DISCONNECTED);
            statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
            statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
                }
            });
        }

        if (shouldSendBatteryLowLocked()) {
            mSentLowBatteryBroadcast = true;
            final Intent statusIntent = new Intent(Intent.ACTION_BATTERY_LOW);
            statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
            statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
                }
            });
        } else if (mSentLowBatteryBroadcast &&
                mBatteryProps.batteryLevel >= mLowBatteryCloseWarningLevel) {
            mSentLowBatteryBroadcast = false;
            final Intent statusIntent = new Intent(Intent.ACTION_BATTERY_OKAY);
            statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
            statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
                }
            });
        }
        
        //发送广播ACTION_BATTERY_CHANGED给外界,内含电源当前的全部信息
        sendIntentLocked();

        // 根据电源的电量和状态，改变LED灯的颜色
        mLed.updateLightsLocked();

        if (logOutlier && dischargeDuration != 0) {
            //利用BatteryInfoService记录耗电情况的dump文件
            logOutlierLocked(dischargeDuration);
        }

        //更新本地变量
        mLastBatteryStatus = mBatteryProps.batteryStatus;
        mLastBatteryHealth = mBatteryProps.batteryHealth;
        mLastBatteryPresent = mBatteryProps.batteryPresent;
        mLastBatteryLevel = mBatteryProps.batteryLevel;
        mLastPlugType = mPlugType;
        mLastBatteryVoltage = mBatteryProps.batteryVoltage;
        mLastBatteryTemperature = mBatteryProps.batteryTemperature;
        mLastMaxChargingCurrent = mBatteryProps.maxChargingCurrent;
        mLastMaxChargingVoltage = mBatteryProps.maxChargingVoltage;
        mLastChargeCounter = mBatteryProps.batteryChargeCounter;
        mLastBatteryLevelCritical = mBatteryLevelCritical;
        mLastInvalidCharger = mInvalidCharger;
    }
}

 

3.再来看下updateBatteryWarningLevelLocked()函数：

private void updateBatteryWarningLevelLocked() {
    final ContentResolver resolver = mContext.getContentResolver();

    //获取XML中配置的默认警告电量值
    int defWarnLevel = mContext.getResources().getInteger(
            com.android.internal.R.integer.config_lowBatteryWarningLevel);

    //获取设置中用户定义的电量警告值
    mLowBatteryWarningLevel = Settings.Global.getInt(resolver,
            Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, defWarnLevel);

    //用户没有定义，则使用默认的
    if (mLowBatteryWarningLevel == 0) {
        mLowBatteryWarningLevel = defWarnLevel;
    }

    //警告值不能低于危险值
    if (mLowBatteryWarningLevel < mCriticalBatteryLevel) {
        mLowBatteryWarningLevel = mCriticalBatteryLevel;
    }

    //计算出关闭警告的电量值
    mLowBatteryCloseWarningLevel = mLowBatteryWarningLevel + mContext.getResources().getInteger(
            com.android.internal.R.integer.config_lowBatteryCloseWarningBump);

    //更新电池信息
    processValuesLocked(true);
}

 

4.看下充电时的led灯变化

日常开发中，关于充电时的led灯的bug比较多，这里简单的说下，Led是BatteryService的内部类：

private final class Led {
    private final Light mBatteryLight;

    private final int mBatteryLowARGB;
    private final int mBatteryMediumARGB;
    private final int mBatteryFullARGB;
    private final int mBatteryLedOn;
    private final int mBatteryLedOff;

    public Led(Context context, LightsManager lights) {
        //获取充电led灯,这个在LightService中说明过
        mBatteryLight = lights.getLight(LightsManager.LIGHT_ID_BATTERY);

        //以下是不同电量状态时的led灯颜色
        mBatteryLowARGB = context.getResources().getInteger(
                com.android.internal.R.integer.config_notificationsBatteryLowARGB);
        mBatteryMediumARGB = context.getResources().getInteger(
                com.android.internal.R.integer.config_notificationsBatteryMediumARGB);
        mBatteryFullARGB = context.getResources().getInteger(
                com.android.internal.R.integer.config_notificationsBatteryFullARGB);
        mBatteryLedOn = context.getResources().getInteger(
                com.android.internal.R.integer.config_notificationsBatteryLedOn);
        mBatteryLedOff = context.getResources().getInteger(
                com.android.internal.R.integer.config_notificationsBatteryLedOff);
    }

    //更新led灯
    public void updateLightsLocked() {
        final int level = mBatteryProps.batteryLevel;
        final int status = mBatteryProps.batteryStatus;
        //电量低于BatteryWarning的电量
        if (level < mLowBatteryWarningLevel) {
            //已经连接上充电
            if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
                //指示灯显示红色
                mBatteryLight.setColor(mBatteryLowARGB);
            } else {
                //没有连接充电线，红灯闪烁
                mBatteryLight.setFlashing(mBatteryLowARGB, Light.LIGHT_FLASH_TIMED,
                        mBatteryLedOn, mBatteryLedOff);
            }
        } else if (status == BatteryManager.BATTERY_STATUS_CHARGING
                || status == BatteryManager.BATTERY_STATUS_FULL) {
            //当前正在充电或者当前电量已经充满
            if (status == BatteryManager.BATTERY_STATUS_FULL || level >= 90) {
                //当电池已经充满或者快要充满的时候指示灯显示绿色
                mBatteryLight.setColor(mBatteryFullARGB);
            } else {
                //当正在充电或者电量超过一半的时候，指示灯显示橘黄色
                mBatteryLight.setColor(mBatteryMediumARGB);
            }
        } else {
            //其他正常情况指示灯关闭
            mBatteryLight.turnOff();
        }
    }
}

 

5.电池属性改变的时候,为什么要将全部信息传递到mBatteryStats中？

IBatteryStats mBatteryStats = BatteryStatsService.getService();

IBatteryStats的实现类是BatteryStatsImpl，BatteryStatsImpl继承自BatteryStats，BatteryStats可以被app获取到，它的setBatteryState()方法会将电池属性写到历史记录，并且计算了电池的已用时间和可用时间，这样，当我们需要用到电池信息的时候，就可以先获取到当前的BatteryStats，然后再从BatteryStats中获取电池属性;

从上面可以看出，app端既可以从广播得到电池的当前属性，还可以通过BatteryStats得到电池的当前属性;

 

renshuguo123723
关注
  • 9
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android 13.0 SystemUI电池电量为0时延迟关机的解决方案
安卓兼职framework和app工程师的博客
12-03 645
在13.0系统rom定制化开发中，在系统开发中可能会遇到了在电池电量为0时这时未出现立即关机的情况，产生延时关机的问题，下面就来分析这个问题所产生的原因，然后解决这个问题
ble电池服务(Battery Service)文档BAS_SPEC_V10
08-17
BAS服务提供了一种标准方式，让设备能够向其他BLE设备报告其电池电量信息，这对于健康管理、智能家居、智能手表等设备来说尤其重要。 **2. BAS服务的UUID** BAS服务有一个特定的全局唯一标识符（UUID），即`180F`。...
Android 电池管理(BatteryService) 详解
weixin_42754390的博客
04-19 6444
SystemServer在启动BatteryService时，一次会调用它的构造函数，onStart，onBootPhase方法;解析来我们分析一下这些方法： 1.Constructor方法： public BatteryService(Context context) { super(context); mContext = context; mHandler = new Handler(true /*async*/); //电源呼吸灯 mLed = new Led
Android电池管理
学习笔记
06-12 1505
本文转自：http://blog.sina.com.cn/s/blog_66a6a5ec0100n6ej.html
Android Battery 架构
shichaog的专栏
12-28 9695
Android系统对电池的管理驱动继承了linux的power supply class。在用户层在BatteryService.java中通过广播的方式将电池相关的属性报给app使用，并且注册了uevent监听电池状态变化，以实时获取电池状态。 frameworks/base/services/core/java/com/android/server/BatteryService.java
android 4.4 电池电量显示分析（低电量提醒与电池图标）Java 层
热门推荐
daweibalang717的专栏
10-30 1万+
最近工作方面
PowerManagerService：电池电量管理
renshuguo123723的博客
02-19 2669
前言：手机电池的电量主要由两种元件消耗：CPU和显示屏，因此设法降低这两种元件的耗电量就是电源管理的关键;       针对CPU和显示屏，分别有两种节约能源的方案： (1)CPU:CPU大多有低频率和高频率两种工作频率，为了省电，大部分时间内cpu都工作在降低频率下，只有进行密集计算时，如视频解码才会切换到高频状态; (2)显示屏:显示屏省电的方法是尽量减少亮屏时间，但是显示屏的开关和应用有很...
java手机电池充电代码,android电池管理系统从上层的java到底层驱动的调用（转载）...
weixin_42573113的博客
03-22 888
1、概述随着移动智能设备的快速发屏，电池的续航能力在很大情况下诱导了大众消费者的购买选择，android系统对电源管理的合理与否直接影响到电池的续航能力，而电池系统作为其中的一部分，主要用于对电池状态的监控(电池电量、电池状态及电池温度等)。下面将详细分析android的电池系统架构。2、Android电池系统架构Android系统中对电池的管理驱动层继承了linux下的power supply ...
Android之 BatteryService
a3015440的专栏
06-12 648
<br />电池的信息，电压，温度，充电状态等等，都是由BatteryService来提供的。BatteryService是跑在system_process当中，在系统初始化的时候启动，如下<br />在BatteryService.java中：<br /> Log.i(TAG, “Starting Battery Service.”);<br /> BatteryService battery = new BatteryService(context);<br /> ServiceManager.a
BatteryService电池管理
xing176的专栏
02-16 1042
BatteryService电池管理 BatteryService负责监听充电状态和电量变化，当电量值或者充电类型改变时，会获取到底层healthd上报的电池状态信息， 并更新到BatteryStatsService中进行统计，同时会将这些值存储到Intent中， 以广播的形式发送到监听了ACTION_BATTERY_CHANGED的组件中， 其他组建可以通过Intent.getExtra()的方式获取到电池信息。 通过获取到的电量信息，上层可以做出低电警告、高温警告等行为 processValues
Android编程之电池电量信息更新的方法(基于BatteryService实现)
09-03
在Android系统中，获取电池电量信息是通过BatteryService这一核心服务来实现的。BatteryService是一个系统级别的服务，它运行在system_process进程中，并在系统启动时由SystemServer初始化并启动。在`SystemServer....
Android-电池管理-实时获取电池电量，温度...等属性。
04-20
实现一个电池属性实时监听器。这些属性包括温度，电池电量....等等。而且，使用Service，Broadcast，以及Thread的方式来实现。MyBatteryService后台获取Battery属性值，然后，在Activity中进行相关数据的显示。
battery:电池状态API
05-07
- **onlevelchange**：当电池电量水平改变时触发。 4. **使用场景**： - **优化性能**：根据电池状态，开发者可以调整应用的运行方式，比如降低动画帧率、减少网络请求频率等，以延长电池寿命。 - **提示用户**...
android电池电量消耗
05-15
在Android平台上，了解应用的电池电量消耗是开发者优化性能、提升用户体验的重要环节。本文将深入探讨如何测试Android设备的电池电量消耗，以及如何通过代码获取这些数据，以便为用户提供电量消耗排行榜。 首先，...
基于Android Q电池服务分析
q1210249579的博客
07-19 1150
基于Android Q的电池服务分析之充电类型判断 开局先说明一下我的需求和我遇到的难题 问题 插入充电没有提示音和图标更新 插入充电没有任何反应和提示，但是确实是在充电 需求 在设置的电池中增加充电类型判断并显示在UI上 1.造成问题的原因 驱动online节点无法正常读取，导致上层数据为空，造成的bug 涉及到的内容： 1.BatteryService.java 这里接收了health层发来的数据：充电广播，记录充电状态，低电量，电池高温，充电方式;发送充电广播产生充电提示音和更新充电图标 2
如何在qualcomm平台Android点亮一个LED工作流程分析
Winston
10-10 4754
前言： 本篇blog主要是为初次接触高通平台的新手 讲述如何在高通平台点亮一个LED的工作流程。 一、LED流程分层 二、代码分析     1.FW层代码分析 BatteryService.java public Led(Contextcontext, LightsManager lights) {             mBatteryLight =light
Android BatteryManager的使用及BatteryService源码分析
最新发布
weixin_44021334的博客
08-23 2133
当需要监控系统电量时，用 BatteryManager 来实现。参考官网。
android4.0电源管理详解
Focuse
12-15 1032
从PowerManager->PowerManagerService->power.java->power.c->kernel
Android 开发-电池（Battery）电量等数据的监听，用Service，Broadcaset，以及Thread的方式实现
记录和分享程序人生的点点滴滴
10-29 1853
实现一个电池属性实时监听器。这些熟悉包括温度，电池电量....等等。而且，使用Service，Broadcast，以及Thread的方式来实现。BatteryManager的使用。
TI锂离子电池充电技术详解：性能与管理策略
此外，低自放电特性使得锂离子电池即使在不使用时也能保持较长时间的电量。 充电算法是核心部分，包括理想的和实际的锂离子充电过程。理想状态下，电池会先进行预充电（Pre-charge或Trickle Charge），将电压提升到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

renshuguo123723

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值