android 添加低电流提醒

特殊需求，检测电流是否正常。

方法调用：

./com/android/systemui/BatteryMeterView.java

    private static LowElectricityRemind mLowElectricityRemind;

    public void setBatteryController(BatteryController batteryController) {
        mBatteryController = batteryController;
        mPowerSaveEnabled = mBatteryController.isPowerSave();
    }

    @Override
    public void onBatteryLevelChanged(int level, boolean pluggedIn, boolean charging) {
        // TODO: Use this callback instead of own broadcast receiver.
    }

    @Override
    public void onPowerSaveChanged() {
        mPowerSaveEnabled = mBatteryController.isPowerSave();
        invalidate();
    }

    @Override
    public void onAttachedToWindow() {
        super.onAttachedToWindow();

        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_BATTERY_CHANGED);
        filter.addAction(ACTION_LEVEL_TEST);
        final Intent sticky = getContext().registerReceiver(mTracker, filter);
        if (sticky != null) {
            // preload the battery level
            mTracker.onReceive(getContext(), sticky);
        }
        mBatteryController.addStateChangedCallback(this);  //added
    }

    @Override
    public void onDetachedFromWindow() {
        super.onDetachedFromWindow();

        getContext().unregisterReceiver(mTracker);
        mBatteryController.removeStateChangedCallback(this);  //added
    }

监听如下广播：

private class BatteryTracker extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();
            if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
                //...
                plugType = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);
                //modify start by fanlj@20170218
                if(mLowElectricityRemind == null){
                    mLowElectricityRemind = new LowElectricityRemind(BatteryMeterView.this.getContext());
                }
                mLowElectricityRemind.changePlugType(plugType);
                //...         

　　

添加LowElectricityRemind类

package com.android.systemui;

import android.content.Context;
import android.content.DialogInterface;
import android.os.BatteryManager;
import android.os.Handler;
import android.util.Slog;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

import com.android.systemui.statusbar.phone.SystemUIDialog;

/**
 * add low electricity remind
 * Created by fanlj on 2017-2-18.
 */
public class LowElectricityRemind {

    private static final String TAG = LowElectricityRemind.class.getSimpleName();

    private static final int LOW_ELECTRICITY_REMIND_DELAYED = 50000;

    private static final long REMIND_INTERVAL = 3 * 1000 * 60;  //Three minutes

    private static final int MAX_CURRENT_COUNT = 3;

    private static final boolean DEBUG = true;

    private boolean isFirstInitialize = true;

    private Context mContext;

    private Handler mHandler;

    private int[] mCurrent = new int[MAX_CURRENT_COUNT];

    private File mCurrentNowFile = null;

    private SystemUIDialog mRemidDialog;

    private long mLastPlugCurrent = 0;
    private long mLastRemindTime = 0; //if mRemidDialog is showed, mLastRemindTime != 0

    private boolean isIgnore = false;

    LowElectricityRemind(Context context){
        mContext = context;
        mHandler = new Handler();

        mCurrentNowFile = new File("/sys/class/power_supply/battery/current_now");
    }

    public void changePlugType(int type){
        if(DEBUG) {
            Slog.e(TAG, "change plug type to " + type);
        }

        mHandler.removeCallbacks(lowElectricityRemindRunnable);

        if(type == BatteryManager.BATTERY_PLUGGED_AC || (DEBUG && type == BatteryManager.BATTERY_PLUGGED_USB)){
            if(DEBUG) {
                Slog.e(TAG, "start runnable");
            }
            
            if(isFirstInitialize){
                isFirstInitialize = false;
            }
            
            mHandler.postDelayed(lowElectricityRemindRunnable, LOW_ELECTRICITY_REMIND_DELAYED);
        } else {
            cleanAllCache();
        }
    }

    private Runnable lowElectricityRemindRunnable = new Runnable() {
        @Override
        public void run() {
            if(!needShowRemindDialog(true)){
                postDelayed();
                return;
            }

            boolean isFull = true;
            int cbattNow = readCurrent();
            if(mLastPlugCurrent == cbattNow){
                postDelayed();
                return;
            }

            mLastPlugCurrent = cbattNow;

            if(mCurrent[MAX_CURRENT_COUNT - 1] != 0){
                int minIndex = 0;
                int maxIndex = 0;
                
                for (int i = MAX_CURRENT_COUNT; i > 1; i--){
                    int curr = mCurrent[i];
                    if(mCurrent[minIndex] > curr){
                        minIndex = i;
                    } 
                    
                    if(mCurrent[maxIndex] < curr){
                        maxIndex = i;
                    }
                }
                
                if(cbattNow < 0){  //In the charging
                    int min = mCurrent[minIndex];
                    int max = mCurrent[maxIndex];
                    
                    if((min < 0 && min < cbattNow) || (min > 0 && min > cbattNow)){ //-1600 <  -1400  900 > 800 if true, replace min value.
                        mCurrent[minIndex] = cbattNow;
                    } else if((max < 0 && max < cbattNow) || (max > 0 && max > cbattNow)){ //-1600 <  -1400  900 > 800
                        mCurrent[maxIndex] = cbattNow;
                    }
                }
            } else {
                for (int i = 0; i < MAX_CURRENT_COUNT; i++){
                    if(mCurrent[i] == 0){
                        mCurrent[i] = cbattNow;

                        if(i != MAX_CURRENT_COUNT - 1) {
                            isFull = false;
                        } else {
                            isFull = true;
                        }
                        break;
                    }
                }
            }

            //if(isFull && needShowRemindDialog(false)){
            if(isFull && needShowRemindDialog(true)){
                if(mRemidDialog == null){
                    mRemidDialog = new SystemUIDialog(mContext);
                    mRemidDialog.setTitle(R.string.charge_current_warning_title);
                    mRemidDialog.setPositiveButton(R.string.charge_current_warning_yes, null);
                    mRemidDialog.setNegativeButton(R.string.charge_current_warning_ignore, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            isIgnore = true;
                        }
                    });
                }
                
                if(DEBUG && mRemidDialog.isShowing()){
                    mRemidDialog.dismiss();
                }
                
                if(!mRemidDialog.isShowing()){
                    String message = mContext.getString(R.string.charge_current_warning_content);
                    
                    if(DEBUG){
                        message += "\n";
                        for (int i = 0; i < MAX_CURRENT_COUNT; i++){
                            message += mCurrent[i];
                            message += "    ";
                        }
                    }
                    
                    mRemidDialog.setMessage(message);
                    mRemidDialog.show();
                }
                
                //clean all save
                cleanAllCache();

                mLastRemindTime = System.currentTimeMillis();
            }

            postDelayed();
        }
    };

    private void postDelayed(){
        mHandler.removeCallbacks(lowElectricityRemindRunnable);
        mHandler.postDelayed(lowElectricityRemindRunnable, LOW_ELECTRICITY_REMIND_DELAYED);
    }

    private void cleanAllCache(){
        for (int i = 0; i < MAX_CURRENT_COUNT; i++){
            mCurrent[i] = 0;
        }

        mLastPlugCurrent = 0;
    }

    /**
     * read battery current
     * @return battery current
     */
    private int readCurrent(){
        int cbattNow = 0;
        FileReader fileReader;
        BufferedReader br;

        try {
            fileReader = new FileReader(mCurrentNowFile);
            br = new BufferedReader(fileReader);
            cbattNow =  Integer.parseInt(br.readLine());
            cbattNow =  cbattNow / 1000;   //uA to mA
            br.close();
            fileReader.close();

            if(DEBUG) {
                Slog.e(TAG, "last plug current : " + cbattNow);
            }
        } catch (FileNotFoundException e) {
            Slog.e(TAG, "Failure in reading battery current", e);
        } catch (IOException e) {
            Slog.e(TAG, "Failure in reading battery current", e);
        }

        return cbattNow;
    }

    private boolean needShowRemindDialog(boolean filterData){
        if(isIgnore){
            return false;
        }

        boolean isNeedShow = true;

        if(!filterData){
            for (int i = 0; i < MAX_CURRENT_COUNT; i++){
                if(mCurrent[i] <= 0){
                    isNeedShow = false;
                    break;
                }
            }
        }

        if(isNeedShow){
            long currTime = System.currentTimeMillis();
            
            if(DEBUG){
                Slog.e(TAG, "mLastRemindTime = " + mLastRemindTime + "   currTime = " + currTime);
            }

            if(mLastRemindTime == 0){
                isNeedShow = true;
            } else if(mLastRemindTime + REMIND_INTERVAL <= currTime){
                isNeedShow = true;
            } else{
                isNeedShow = false;
            }
        }
        
        if(DEBUG){
            Slog.e(TAG, "need show remind dialog = " + isNeedShow);
        }

        return isNeedShow;
    }
}