Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 26faecc8 authored by Todd Poynor's avatar Todd Poynor
Browse files

BatteryService use IBatteryProperties interfaces, drop JNI 

IBatteryPropertiesListener binder interface to deliver notifications of
changed battery/power status from healthd system health daemon.  healthd
watches uevents from power_supply.

Change-Id: I1ab38622baf28356a6627fe2354b77e2ef99d838
parent 0350f416

services/java/com/android/server/BatteryService.java

+117 −126
Original line number Diff line number Diff line
@@ -26,9 +26,12 @@ import android.content.Context; 
import android.content.Intent;

import android.content.pm.PackageManager;

import android.os.BatteryManager;

import android.os.BatteryProperties;

import android.os.Binder;

import android.os.FileUtils;

import android.os.Handler;

import android.os.IBatteryPropertiesListener;

import android.os.IBatteryPropertiesRegistrar;

import android.os.IBinder;

import android.os.DropBoxManager;

import android.os.RemoteException;
@@ -102,20 +105,8 @@ public final class BatteryService extends Binder { 


    private final Object mLock = new Object();



    /* Begin native fields: All of these fields are set by native code. */

    private boolean mAcOnline;

    private boolean mUsbOnline;

    private boolean mWirelessOnline;

    private int mBatteryStatus;

    private int mBatteryHealth;

    private boolean mBatteryPresent;

    private int mBatteryLevel;

    private int mBatteryVoltage;

    private int mBatteryTemperature;

    private String mBatteryTechnology;

    private BatteryProperties mBatteryProps;

    private boolean mBatteryLevelCritical;

    /* End native fields. */



    private int mLastBatteryStatus;

    private int mLastBatteryHealth;

    private boolean mLastBatteryPresent;
@@ -143,7 +134,8 @@ public final class BatteryService extends Binder { 


    private boolean mSentLowBatteryBroadcast = false;



    private native void native_update();

    private BatteryListener mBatteryPropertiesListener;

    private IBatteryPropertiesRegistrar mBatteryPropertiesRegistrar;



    public BatteryService(Context context, LightsService lights) {

        mContext = context;
@@ -160,17 +152,21 @@ public final class BatteryService extends Binder { 
        mShutdownBatteryTemperature = mContext.getResources().getInteger(

                com.android.internal.R.integer.config_shutdownBatteryTemperature);



        mPowerSupplyObserver.startObserving("SUBSYSTEM=power_supply");



        // watch for invalid charger messages if the invalid_charger switch exists

        if (new File("/sys/devices/virtual/switch/invalid_charger/state").exists()) {

            mInvalidChargerObserver.startObserving(

                    "DEVPATH=/devices/virtual/switch/invalid_charger");

        }



        // set initial status

        synchronized (mLock) {

            updateLocked();

        mBatteryPropertiesListener = new BatteryListener();



        IBinder b = ServiceManager.getService("batterypropreg");

        mBatteryPropertiesRegistrar = IBatteryPropertiesRegistrar.Stub.asInterface(b);



        try {

            mBatteryPropertiesRegistrar.registerListener(mBatteryPropertiesListener);

        } catch (RemoteException e) {

            // Should never happen.

        }

    }
@@ -194,16 +190,16 @@ public final class BatteryService extends Binder { 
    private boolean isPoweredLocked(int plugTypeSet) {

        // assume we are powered if battery state is unknown so

        // the "stay on while plugged in" option will work.

        if (mBatteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {

        if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {

            return true;

        }

        if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mAcOnline) {

        if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mBatteryProps.chargerAcOnline) {

            return true;

        }

        if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mUsbOnline) {

        if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mBatteryProps.chargerUsbOnline) {

            return true;

        }

        if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mWirelessOnline) {

        if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mBatteryProps.chargerWirelessOnline) {

            return true;

        }

        return false;
@@ -223,7 +219,7 @@ public final class BatteryService extends Binder { 
     */

    public int getBatteryLevel() {

        synchronized (mLock) {

            return mBatteryLevel;

            return mBatteryProps.batteryLevel;

        }

    }
@@ -232,7 +228,7 @@ public final class BatteryService extends Binder { 
     */

    public boolean isBatteryLow() {

        synchronized (mLock) {

            return mBatteryPresent && mBatteryLevel <= mLowBatteryWarningLevel;

            return mBatteryProps.batteryPresent && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel;

        }

    }
@@ -248,7 +244,7 @@ public final class BatteryService extends Binder { 
    private void shutdownIfNoPowerLocked() {

        // shut down gracefully if our battery is critically low and we are not powered.

        // wait until the system has booted before attempting to display the shutdown dialog.

        if (mBatteryLevel == 0 && !isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)) {

        if (mBatteryProps.batteryLevel == 0 && !isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)) {

            mHandler.post(new Runnable() {

                @Override

                public void run() {
@@ -267,7 +263,7 @@ public final class BatteryService extends Binder { 
        // shut down gracefully if temperature is too high (> 68.0C by default)

        // wait until the system has booted before attempting to display the

        // shutdown dialog.

        if (mBatteryTemperature > mShutdownBatteryTemperature) {

        if (mBatteryProps.batteryTemperature > mShutdownBatteryTemperature) {

            mHandler.post(new Runnable() {

                @Override

                public void run() {
@@ -282,26 +278,26 @@ public final class BatteryService extends Binder { 
        }

    }



    private void updateLocked() {

    private void update(BatteryProperties props) {

        synchronized (mLock) {

            if (!mUpdatesStopped) {

            // Update the values of mAcOnline, et. all.

            native_update();



                mBatteryProps = props;

                // Process the new values.

                processValuesLocked();

            }

        }

    }



    private void processValuesLocked() {

        boolean logOutlier = false;

        long dischargeDuration = 0;



        mBatteryLevelCritical = (mBatteryLevel <= mCriticalBatteryLevel);

        if (mAcOnline) {

        mBatteryLevelCritical = (mBatteryProps.batteryLevel <= mCriticalBatteryLevel);

        if (mBatteryProps.chargerAcOnline) {

            mPlugType = BatteryManager.BATTERY_PLUGGED_AC;

        } else if (mUsbOnline) {

        } else if (mBatteryProps.chargerUsbOnline) {

            mPlugType = BatteryManager.BATTERY_PLUGGED_USB;

        } else if (mWirelessOnline) {

        } else if (mBatteryProps.chargerWirelessOnline) {

            mPlugType = BatteryManager.BATTERY_PLUGGED_WIRELESS;

        } else {

            mPlugType = BATTERY_PLUGGED_NONE;
@@ -309,25 +305,25 @@ public final class BatteryService extends Binder { 


        if (DEBUG) {

            Slog.d(TAG, "Processing new values: "

                    + "mAcOnline=" + mAcOnline

                    + ", mUsbOnline=" + mUsbOnline

                    + ", mWirelessOnline=" + mWirelessOnline

                    + ", mBatteryStatus=" + mBatteryStatus

                    + ", mBatteryHealth=" + mBatteryHealth

                    + ", mBatteryPresent=" + mBatteryPresent

                    + ", mBatteryLevel=" + mBatteryLevel

                    + ", mBatteryTechnology=" + mBatteryTechnology

                    + ", mBatteryVoltage=" + mBatteryVoltage

                    + ", mBatteryTemperature=" + mBatteryTemperature

                    + "chargerAcOnline=" + mBatteryProps.chargerAcOnline

                    + ", chargerUsbOnline=" + mBatteryProps.chargerUsbOnline

                    + ", chargerWirelessOnline=" + mBatteryProps.chargerWirelessOnline

                    + ", batteryStatus=" + mBatteryProps.batteryStatus

                    + ", batteryHealth=" + mBatteryProps.batteryHealth

                    + ", batteryPresent=" + mBatteryProps.batteryPresent

                    + ", batteryLevel=" + mBatteryProps.batteryLevel

                    + ", batteryTechnology=" + mBatteryProps.batteryTechnology

                    + ", batteryVoltage=" + mBatteryProps.batteryVoltage

                    + ", batteryTemperature=" + mBatteryProps.batteryTemperature

                    + ", mBatteryLevelCritical=" + mBatteryLevelCritical

                    + ", mPlugType=" + mPlugType);

        }



        // Let the battery stats keep track of the current level.

        try {

            mBatteryStats.setBatteryState(mBatteryStatus, mBatteryHealth,

                    mPlugType, mBatteryLevel, mBatteryTemperature,

                    mBatteryVoltage);

            mBatteryStats.setBatteryState(mBatteryProps.batteryStatus, mBatteryProps.batteryHealth,

                    mPlugType, mBatteryProps.batteryLevel, mBatteryProps.batteryTemperature,

                    mBatteryProps.batteryVoltage);

        } catch (RemoteException e) {

            // Should never happen.

        }
@@ -335,13 +331,13 @@ public final class BatteryService extends Binder { 
        shutdownIfNoPowerLocked();

        shutdownIfOverTempLocked();



        if (mBatteryStatus != mLastBatteryStatus ||

                mBatteryHealth != mLastBatteryHealth ||

                mBatteryPresent != mLastBatteryPresent ||

                mBatteryLevel != mLastBatteryLevel ||

        if (mBatteryProps.batteryStatus != mLastBatteryStatus ||

                mBatteryProps.batteryHealth != mLastBatteryHealth ||

                mBatteryProps.batteryPresent != mLastBatteryPresent ||

                mBatteryProps.batteryLevel != mLastBatteryLevel ||

                mPlugType != mLastPlugType ||

                mBatteryVoltage != mLastBatteryVoltage ||

                mBatteryTemperature != mLastBatteryTemperature ||

                mBatteryProps.batteryVoltage != mLastBatteryVoltage ||

                mBatteryProps.batteryTemperature != mLastBatteryTemperature ||

                mInvalidCharger != mLastInvalidCharger) {



            if (mPlugType != mLastPlugType) {
@@ -350,33 +346,33 @@ public final class BatteryService extends Binder { 


                    // 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 != mBatteryLevel) {

                    if (mDischargeStartTime != 0 && mDischargeStartLevel != mBatteryProps.batteryLevel) {

                        dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;

                        logOutlier = true;

                        EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,

                                mDischargeStartLevel, mBatteryLevel);

                                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 = mBatteryLevel;

                    mDischargeStartLevel = mBatteryProps.batteryLevel;

                }

            }

            if (mBatteryStatus != mLastBatteryStatus ||

                    mBatteryHealth != mLastBatteryHealth ||

                    mBatteryPresent != mLastBatteryPresent ||

            if (mBatteryProps.batteryStatus != mLastBatteryStatus ||

                    mBatteryProps.batteryHealth != mLastBatteryHealth ||

                    mBatteryProps.batteryPresent != mLastBatteryPresent ||

                    mPlugType != mLastPlugType) {

                EventLog.writeEvent(EventLogTags.BATTERY_STATUS,

                        mBatteryStatus, mBatteryHealth, mBatteryPresent ? 1 : 0,

                        mPlugType, mBatteryTechnology);

                        mBatteryProps.batteryStatus, mBatteryProps.batteryHealth, mBatteryProps.batteryPresent ? 1 : 0,

                        mPlugType, mBatteryProps.batteryTechnology);

            }

            if (mBatteryLevel != mLastBatteryLevel) {

            if (mBatteryProps.batteryLevel != mLastBatteryLevel) {

                // Don't do this just from voltage or temperature changes, that is

                // too noisy.

                EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,

                        mBatteryLevel, mBatteryVoltage, mBatteryTemperature);

                        mBatteryProps.batteryLevel, mBatteryProps.batteryVoltage, mBatteryProps.batteryTemperature);

            }

            if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&

                    mPlugType == BATTERY_PLUGGED_NONE) {
@@ -396,8 +392,8 @@ public final class BatteryService extends Binder { 
             *   (becomes <= mLowBatteryWarningLevel).

             */

            final boolean sendBatteryLow = !plugged

                    && mBatteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN

                    && mBatteryLevel <= mLowBatteryWarningLevel

                    && mBatteryProps.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN

                    && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel

                    && (oldPlugged || mLastBatteryLevel > mLowBatteryWarningLevel);



            sendIntentLocked();
@@ -456,13 +452,13 @@ public final class BatteryService extends Binder { 
                logOutlierLocked(dischargeDuration);

            }



            mLastBatteryStatus = mBatteryStatus;

            mLastBatteryHealth = mBatteryHealth;

            mLastBatteryPresent = mBatteryPresent;

            mLastBatteryLevel = mBatteryLevel;

            mLastBatteryStatus = mBatteryProps.batteryStatus;

            mLastBatteryHealth = mBatteryProps.batteryHealth;

            mLastBatteryPresent = mBatteryProps.batteryPresent;

            mLastBatteryLevel = mBatteryProps.batteryLevel;

            mLastPlugType = mPlugType;

            mLastBatteryVoltage = mBatteryVoltage;

            mLastBatteryTemperature = mBatteryTemperature;

            mLastBatteryVoltage = mBatteryProps.batteryVoltage;

            mLastBatteryTemperature = mBatteryProps.batteryTemperature;

            mLastBatteryLevelCritical = mBatteryLevelCritical;

            mLastInvalidCharger = mInvalidCharger;

        }
@@ -474,29 +470,29 @@ public final class BatteryService extends Binder { 
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY

                | Intent.FLAG_RECEIVER_REPLACE_PENDING);



        int icon = getIconLocked(mBatteryLevel);

        int icon = getIconLocked(mBatteryProps.batteryLevel);



        intent.putExtra(BatteryManager.EXTRA_STATUS, mBatteryStatus);

        intent.putExtra(BatteryManager.EXTRA_HEALTH, mBatteryHealth);

        intent.putExtra(BatteryManager.EXTRA_PRESENT, mBatteryPresent);

        intent.putExtra(BatteryManager.EXTRA_LEVEL, mBatteryLevel);

        intent.putExtra(BatteryManager.EXTRA_STATUS, mBatteryProps.batteryStatus);

        intent.putExtra(BatteryManager.EXTRA_HEALTH, mBatteryProps.batteryHealth);

        intent.putExtra(BatteryManager.EXTRA_PRESENT, mBatteryProps.batteryPresent);

        intent.putExtra(BatteryManager.EXTRA_LEVEL, mBatteryProps.batteryLevel);

        intent.putExtra(BatteryManager.EXTRA_SCALE, BATTERY_SCALE);

        intent.putExtra(BatteryManager.EXTRA_ICON_SMALL, icon);

        intent.putExtra(BatteryManager.EXTRA_PLUGGED, mPlugType);

        intent.putExtra(BatteryManager.EXTRA_VOLTAGE, mBatteryVoltage);

        intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mBatteryTemperature);

        intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mBatteryTechnology);

        intent.putExtra(BatteryManager.EXTRA_VOLTAGE, mBatteryProps.batteryVoltage);

        intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mBatteryProps.batteryTemperature);

        intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mBatteryProps.batteryTechnology);

        intent.putExtra(BatteryManager.EXTRA_INVALID_CHARGER, mInvalidCharger);



        if (DEBUG) {

            Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED.  level:" + mBatteryLevel +

                    ", scale:" + BATTERY_SCALE + ", status:" + mBatteryStatus +

                    ", health:" + mBatteryHealth +  ", present:" + mBatteryPresent +

                    ", voltage: " + mBatteryVoltage +

                    ", temperature: " + mBatteryTemperature +

                    ", technology: " + mBatteryTechnology +

                    ", AC powered:" + mAcOnline + ", USB powered:" + mUsbOnline +

                    ", Wireless powered:" + mWirelessOnline +

            Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED.  level:" + mBatteryProps.batteryLevel +

                    ", scale:" + BATTERY_SCALE + ", status:" + mBatteryProps.batteryStatus +

                    ", health:" + mBatteryProps.batteryHealth +  ", present:" + mBatteryProps.batteryPresent +

                    ", voltage: " + mBatteryProps.batteryVoltage +

                    ", temperature: " + mBatteryProps.batteryTemperature +

                    ", technology: " + mBatteryProps.batteryTechnology +

                    ", AC powered:" + mBatteryProps.chargerAcOnline + ", USB powered:" + mBatteryProps.chargerUsbOnline +

                    ", Wireless powered:" + mBatteryProps.chargerWirelessOnline +

                    ", icon:" + icon  + ", invalid charger:" + mInvalidCharger);

        }
@@ -558,14 +554,14 @@ public final class BatteryService extends Binder { 
                long durationThreshold = Long.parseLong(durationThresholdString);

                int dischargeThreshold = Integer.parseInt(dischargeThresholdString);

                if (duration <= durationThreshold &&

                        mDischargeStartLevel - mBatteryLevel >= dischargeThreshold) {

                        mDischargeStartLevel - mBatteryProps.batteryLevel >= dischargeThreshold) {

                    // If the discharge cycle is bad enough we want to know about it.

                    logBatteryStatsLocked();

                }

                if (DEBUG) Slog.v(TAG, "duration threshold: " + durationThreshold +

                        " discharge threshold: " + dischargeThreshold);

                if (DEBUG) Slog.v(TAG, "duration: " + duration + " discharge: " +

                        (mDischargeStartLevel - mBatteryLevel));

                        (mDischargeStartLevel - mBatteryProps.batteryLevel));

            } catch (NumberFormatException e) {

                Slog.e(TAG, "Invalid DischargeThresholds GService string: " +

                        durationThresholdString + " or " + dischargeThresholdString);
@@ -575,14 +571,14 @@ public final class BatteryService extends Binder { 
    }



    private int getIconLocked(int level) {

        if (mBatteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {

        if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {

            return com.android.internal.R.drawable.stat_sys_battery_charge;

        } else if (mBatteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {

        } else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {

            return com.android.internal.R.drawable.stat_sys_battery;

        } else if (mBatteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING

                || mBatteryStatus == BatteryManager.BATTERY_STATUS_FULL) {

        } else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING

                || mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_FULL) {

            if (isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)

                    && mBatteryLevel >= 100) {

                    && mBatteryProps.batteryLevel >= 100) {

                return com.android.internal.R.drawable.stat_sys_battery_charge;

            } else {

                return com.android.internal.R.drawable.stat_sys_battery;
@@ -609,32 +605,32 @@ public final class BatteryService extends Binder { 
                if (mUpdatesStopped) {

                    pw.println("  (UPDATES STOPPED -- use 'reset' to restart)");

                }

                pw.println("  AC powered: " + mAcOnline);

                pw.println("  USB powered: " + mUsbOnline);

                pw.println("  Wireless powered: " + mWirelessOnline);

                pw.println("  status: " + mBatteryStatus);

                pw.println("  health: " + mBatteryHealth);

                pw.println("  present: " + mBatteryPresent);

                pw.println("  level: " + mBatteryLevel);

                pw.println("  AC powered: " + mBatteryProps.chargerAcOnline);

                pw.println("  USB powered: " + mBatteryProps.chargerUsbOnline);

                pw.println("  Wireless powered: " + mBatteryProps.chargerWirelessOnline);

                pw.println("  status: " + mBatteryProps.batteryStatus);

                pw.println("  health: " + mBatteryProps.batteryHealth);

                pw.println("  present: " + mBatteryProps.batteryPresent);

                pw.println("  level: " + mBatteryProps.batteryLevel);

                pw.println("  scale: " + BATTERY_SCALE);

                pw.println("  voltage:" + mBatteryVoltage);

                pw.println("  temperature: " + mBatteryTemperature);

                pw.println("  technology: " + mBatteryTechnology);

                pw.println("  voltage:" + mBatteryProps.batteryVoltage);

                pw.println("  temperature: " + mBatteryProps.batteryTemperature);

                pw.println("  technology: " + mBatteryProps.batteryTechnology);

            } else if (args.length == 3 && "set".equals(args[0])) {

                String key = args[1];

                String value = args[2];

                try {

                    boolean update = true;

                    if ("ac".equals(key)) {

                        mAcOnline = Integer.parseInt(value) != 0;

                        mBatteryProps.chargerAcOnline = Integer.parseInt(value) != 0;

                    } else if ("usb".equals(key)) {

                        mUsbOnline = Integer.parseInt(value) != 0;

                        mBatteryProps.chargerUsbOnline = Integer.parseInt(value) != 0;

                    } else if ("wireless".equals(key)) {

                        mWirelessOnline = Integer.parseInt(value) != 0;

                        mBatteryProps.chargerWirelessOnline = Integer.parseInt(value) != 0;

                    } else if ("status".equals(key)) {

                        mBatteryStatus = Integer.parseInt(value);

                        mBatteryProps.batteryStatus = Integer.parseInt(value);

                    } else if ("level".equals(key)) {

                        mBatteryLevel = Integer.parseInt(value);

                        mBatteryProps.batteryLevel = Integer.parseInt(value);

                    } else if ("invalid".equals(key)) {

                        mInvalidCharger = Integer.parseInt(value);

                    } else {
@@ -657,7 +653,6 @@ public final class BatteryService extends Binder { 
                long ident = Binder.clearCallingIdentity();

                try {

                    mUpdatesStopped = false;

                    updateLocked();

                } finally {

                    Binder.restoreCallingIdentity(ident);

                }
@@ -669,15 +664,6 @@ public final class BatteryService extends Binder { 
        }

    }



    private final UEventObserver mPowerSupplyObserver = new UEventObserver() {

        @Override

        public void onUEvent(UEventObserver.UEvent event) {

            synchronized (mLock) {

                updateLocked();

            }

        }

    };



    private final UEventObserver mInvalidChargerObserver = new UEventObserver() {

        @Override

        public void onUEvent(UEventObserver.UEvent event) {
@@ -685,7 +671,6 @@ public final class BatteryService extends Binder { 
            synchronized (mLock) {

                if (mInvalidCharger != invalidCharger) {

                    mInvalidCharger = invalidCharger;

                    updateLocked();

                }

            }

        }
@@ -719,8 +704,8 @@ public final class BatteryService extends Binder { 
         * Synchronize on BatteryService.

         */

        public void updateLightsLocked() {

            final int level = mBatteryLevel;

            final int status = mBatteryStatus;

            final int level = mBatteryProps.batteryLevel;

            final int status = mBatteryProps.batteryStatus;

            if (level < mLowBatteryWarningLevel) {

                if (status == BatteryManager.BATTERY_STATUS_CHARGING) {

                    // Solid red when battery is charging
@@ -745,4 +730,10 @@ public final class BatteryService extends Binder { 
            }

        }

    }



    private final class BatteryListener extends IBatteryPropertiesListener.Stub {

        public void batteryPropertiesChanged(BatteryProperties props) {

            BatteryService.this.update(props);

       }

    }

}

services/jni/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -4,7 +4,6 @@ include $(CLEAR_VARS) 
LOCAL_SRC_FILES:= \

    com_android_server_AlarmManagerService.cpp \

    com_android_server_AssetAtlasService.cpp \

    com_android_server_BatteryService.cpp \

    com_android_server_input_InputApplicationHandle.cpp \

    com_android_server_input_InputManagerService.cpp \

    com_android_server_input_InputWindowHandle.cpp \

services/jni/com_android_server_BatteryService.cpp

deleted100644 → 0
+0 −474

File deleted.

Preview size limit exceeded, changes collapsed.

services/jni/onload.cpp

+0 −2
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ 


namespace android {

int register_android_server_AlarmManagerService(JNIEnv* env);

int register_android_server_BatteryService(JNIEnv* env);

int register_android_server_InputApplicationHandle(JNIEnv* env);

int register_android_server_InputWindowHandle(JNIEnv* env);

int register_android_server_InputManager(JNIEnv* env);
@@ -57,7 +56,6 @@ extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved) 
    register_android_server_InputManager(env);

    register_android_server_LightsService(env);

    register_android_server_AlarmManagerService(env);

    register_android_server_BatteryService(env);

    register_android_server_UsbDeviceManager(env);

    register_android_server_UsbHostManager(env);

    register_android_server_VibratorService(env);