下面列出了android.os.BatteryManager#BATTERY_PLUGGED_USB 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void getPlugState(Intent intent) {
String parse = null;
int plugged_state = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
Logger.d(LOG, String.format("GETTING PLUG STATE: %d", plugged_state));
switch(plugged_state) {
case BatteryManager.BATTERY_PLUGGED_AC:
parse = "battery plugged AC";
break;
case BatteryManager.BATTERY_PLUGGED_USB:
parse = "battery plugged USB";
break;
}
if(parse != null) {
ILogPack logPack = new ILogPack();
logPack.put(Keys.PLUG_EVENT_TYPE, parse);
logPack.put(Keys.PLUG_EVENT_CODE, plugged_state);
sendToBuffer(logPack);
}
}
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 (mHealthInfo.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {
return true;
}
if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mHealthInfo.chargerAcOnline) {
return true;
}
if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mHealthInfo.chargerUsbOnline) {
return true;
}
if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mHealthInfo.chargerWirelessOnline) {
return true;
}
return false;
}
private static String batteryPlugged(int status) {
String healthBat = BaseData.UNKNOWN_PARAM;
switch (status) {
case BatteryManager.BATTERY_PLUGGED_AC:
healthBat = "ac";
break;
case BatteryManager.BATTERY_PLUGGED_USB:
healthBat = "usb";
break;
case BatteryManager.BATTERY_PLUGGED_WIRELESS:
healthBat = "wireless";
break;
default:
break;
}
return healthBat;
}
public static String getBatteryInfo(Intent batteryIntent) {
int status = batteryIntent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
boolean isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
status == BatteryManager.BATTERY_STATUS_FULL;
int chargePlug = batteryIntent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
boolean usbCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
boolean acCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_AC;
int level = batteryIntent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = batteryIntent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
float batteryPct = level / (float) scale;
return "Battery Info: isCharging=" + isCharging
+ " usbCharge=" + usbCharge + " acCharge=" + acCharge
+ " batteryPct=" + batteryPct;
}
/**
* Update the preference switch for {@link Settings.Global#STAY_ON_WHILE_PLUGGED_IN} setting.
*
* <p>
* If either one of the {@link BatteryManager#BATTERY_PLUGGED_AC},
* {@link BatteryManager#BATTERY_PLUGGED_USB}, {@link BatteryManager#BATTERY_PLUGGED_WIRELESS}
* values is set, we toggle the preference to true and update the setting value to
* {@link #BATTERY_PLUGGED_ANY}
* </p>
*/
private void updateStayOnWhilePluggedInPreference() {
if (!mStayOnWhilePluggedInSwitchPreference.isEnabled()) {
return;
}
boolean checked = false;
final int currentState = Settings.Global.getInt(getActivity().getContentResolver(),
Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
checked = (currentState &
(BatteryManager.BATTERY_PLUGGED_AC |
BatteryManager.BATTERY_PLUGGED_USB |
BatteryManager.BATTERY_PLUGGED_WIRELESS)) != 0;
mDevicePolicyManager.setGlobalSetting(mAdminComponentName,
Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
checked ? BATTERY_PLUGGED_ANY : DONT_STAY_ON);
mStayOnWhilePluggedInSwitchPreference.setChecked(checked);
}
/**
* @return true is device is plugged at this moment, false otherwise.
* @see #isPlugged(android.content.Context)
*/
@SuppressLint("InlinedApi")
public static boolean isPlugged(@Nullable Intent intent) {
if (intent == null) {
return false;
}
final int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
return plugged == BatteryManager.BATTERY_PLUGGED_AC
|| plugged == BatteryManager.BATTERY_PLUGGED_USB
|| plugged == BatteryManager.BATTERY_PLUGGED_WIRELESS;
}
public static boolean isPluggedIn(Context context) {
Intent batteryStatus = registerBatteryUpdates(context);
if (batteryStatus == null) {
return false;
}
int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, DEFAULT_BATTERY_LEVEL);
final boolean pluggedIntoUSB = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
final boolean pluggedIntoAC = chargePlug == BatteryManager.BATTERY_PLUGGED_AC;
return pluggedIntoUSB || pluggedIntoAC;
}
@TargetApi(17)
private boolean isCharging_API17() {
Intent intent = mContext.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
return plugged == BatteryManager.BATTERY_PLUGGED_AC ||
plugged == BatteryManager.BATTERY_PLUGGED_USB ||
plugged == BatteryManager.BATTERY_PLUGGED_WIRELESS;
}
public static void onBatteryChargingChanged(Intent intent) {
if (sInstance == null) {
// We may be called by the framework intent-filter before being fully initialized. This
// is not a problem, since our constructor will check for the state later on.
return;
}
int chargePlug = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
// If we're not plugged, assume we're running on battery power.
sInstance.mIsBatteryPower = chargePlug != BatteryManager.BATTERY_PLUGGED_USB &&
chargePlug != BatteryManager.BATTERY_PLUGGED_AC;
nativeOnBatteryChargingChanged();
}
public void getBatteryReading(SensorDataListener listener){
IntentFilter intentFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
Intent batteryStatus = context.registerReceiver(null, intentFilter);
int batteryStatusIntExtra = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
boolean isCharging = batteryStatusIntExtra == BatteryManager.BATTERY_STATUS_CHARGING ||
batteryStatusIntExtra == BatteryManager.BATTERY_STATUS_FULL;
int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
boolean usbCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
boolean acCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_AC;
int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
float batteryPct = level / (float)scale;
Log.i(TAG, "AC connected: "+acCharge);
Log.i(TAG, "USB connected: "+usbCharge);
Log.i(TAG, "Battery charging: "+ isCharging);
Log.i(TAG, "Battery Level: "+ batteryPct);
ArrayMap<String, String> map = new ArrayMap<>(3);
map.put(SENSOR, "Battery");
map.put(VALUE, Integer.toString(level));
map.put(UNIT, BATTERYSENSOR_UNIT);
map.put("charging", Boolean.toString(isCharging));
map.put("acPlugged", Boolean.toString(acCharge));
map.put("usbPlugged", Boolean.toString(usbCharge));
listener.sensorData(map);
}
public static boolean isConnectedToCharger(Context context) {
Intent intent = context.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
if (intent != null) {
int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
return plugged == BatteryManager.BATTERY_PLUGGED_AC || plugged == BatteryManager.BATTERY_PLUGGED_USB || plugged == BatteryManager.BATTERY_PLUGGED_WIRELESS;
} else return false;
}
@Override
public void onReceive(Context context, Intent intent) {
int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0);
int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
boolean charging = plugged == BatteryManager.BATTERY_PLUGGED_AC || plugged == BatteryManager.BATTERY_PLUGGED_USB;
currentBattery = level;
Utils.logDebug(MAIN_SERVICE_LOG_TAG, "Battery level " + level);
if (batteryTV != null)
batteryTV.setText(String.valueOf(level) + "%");
if (batteryIV != null) {
int res;
if (charging)
res = R.drawable.ic_battery_charging;
else {
if (level > 90)
res = R.drawable.ic_battery_full;
else if (level > 70)
res = R.drawable.ic_battery_90;
else if (level > 50)
res = R.drawable.ic_battery_60;
else if (level > 30)
res = R.drawable.ic_battery_30;
else if (level > 20)
res = R.drawable.ic_battery_20;
else if (level > 0)
res = R.drawable.ic_battery_alert;
else
res = R.drawable.ic_battery_unknown;
}
batteryIV.setImageResource(res);
}
}
public static String translateBatteryPlugged(int batteryPlugged) {
switch (batteryPlugged) {
case 0:
return "UNPLUGGED";
case BatteryManager.BATTERY_PLUGGED_AC:
return "AC";
case BatteryManager.BATTERY_PLUGGED_USB:
return "USB";
case BatteryManager.BATTERY_PLUGGED_WIRELESS:
return "WIRELESS";
default:
return "UNKNOWN (" + batteryPlugged + ")";
}
}
private static boolean isCharging(Context context) {
Intent i = context.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
int plugged = i.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
return plugged == BatteryManager.BATTERY_PLUGGED_AC || plugged == BatteryManager.BATTERY_PLUGGED_USB;
}
@Override
public void onReceive (Context context, Intent intent)
{
if (MainActivity.mainActivity == null) return;
//
Boolean isNowCharging = false;
//
int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
int chargePlug = -1;
if(status != -1)
{
chargePlug = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
//
// BatteryManager.BATTERY_STATUS_CHARGING cannot be trusted. It happens on occasion, but it's thrown while the tablet is not charging
isNowCharging = (status == BatteryManager.BATTERY_STATUS_CHARGING || status == BatteryManager.BATTERY_STATUS_FULL )&& chargePlug > 0;
//
usbCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
acCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_AC;
//
batteryLevel = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
batteryScale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
//
MainActivity.log("OBBatteryReceiver.onReceive: battery level : " + batteryLevel + ", battery scale: " + batteryScale + " " + (isNowCharging ? "CHARGING " : ""));
}
//
MainActivity.log("OBBatteryReceiver.onReceive: " + printStatus());
//
if(MainActivity.mainActivity != null)
{
MainActivity.mainActivity.onBatteryStatusReceived(getBatteryLevel(),cablePluggedIn());
}
//
if (OBSystemsManager.sharedManager != null)
{
OBSystemsManager.sharedManager.refreshStatus();
//
MainActivity.log("OBBatteryReceiver.onReceive: chargePlug flag value: " + chargePlug + ", battery status: " + status);
//
Boolean actionIsRequired = !isCharging && isNowCharging;
isCharging = isNowCharging;
//
String chargerType = (usbCharge) ? OBAnalytics.Params.BATTERY_CHARGER_STATE_PLUGGED_USB : (acCharge) ? OBAnalytics.Params.BATTERY_CHARGER_STATE_PLUGGED_AC : "";
OBAnalyticsManager.sharedManager.batteryState(getBatteryLevel(), isCharging, chargerType);
OBAnalyticsManager.sharedManager.deviceGpsLocation();
OBAnalyticsManager.sharedManager.deviceStorageUse();
//
if (actionIsRequired)
{
MainActivity.log("OBBatteryReceiver.onReceive: it is now charging and/or plugged in. Action is required");
//
if (OBConfigManager.sharedManager.isBackupWhenChargingEnabled())
{
if (OBSystemsManager.sharedManager.isBackupRequired())
{
MainActivity.log("OBBatteryReceiver.onReceive: Backup is required. Synchronising time and data.");
OBSystemsManager.sharedManager.connectToWifiAndSynchronizeTimeAndData();
}
else
{
if (OBConfigManager.sharedManager.isTimeServerEnabled())
{
MainActivity.log("OBBatteryReceiver.onReceive: Backup is NOT required. Synchronising time");
OBSystemsManager.sharedManager.connectToWifiAndSynchronizeTime();
}
else
{
MainActivity.log("OBBatteryReceiver.onReceive: Time server is disabled. Suspending time synchronisation");
}
}
}
else
{
if (OBConfigManager.sharedManager.isTimeServerEnabled())
{
MainActivity.log("OBBatteryReceiver.onReceive: Shouldn't send backup when connecting, just synchronising time");
OBSystemsManager.sharedManager.connectToWifiAndSynchronizeTime();
}
else
{
MainActivity.log("OBBatteryReceiver.onReceive: Time server is disabled. Suspending time synchronisation");
}
}
}
else
{
MainActivity.log("OBBatteryReceiver.onReceive: State hasn't changed, No action is required for now");
}
}
else
{
MainActivity.log("OBBatteryReceiver:onReceive: OBSystemsManager hasn't been created yet. Aborting");
}
}
/**
* Gets a callback each time there is a change in the battery status
*
* @param callback
* @status TODO_EXAMPLE
*/
@PhonkMethod
public void battery(final ReturnInterface callback) {
batteryReceiver = new BroadcastReceiver() {
int scale = -1;
int level = -1;
int voltage = -1;
int temp = -1;
boolean isConnected = false;
private int status;
private final boolean alreadyKilled = false;
@Override
public void onReceive(Context context, Intent intent) {
level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
temp = intent.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, -1);
voltage = intent.getIntExtra(BatteryManager.EXTRA_VOLTAGE, -1);
// isCharging =
// intent.getBooleanExtra(BatteryManager.EXTRA_PLUGGED, false);
// status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
status = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
if (status == BatteryManager.BATTERY_PLUGGED_AC) {
isConnected = true;
} else isConnected = status == BatteryManager.BATTERY_PLUGGED_USB;
ReturnObject o = new ReturnObject();
o.put("level", level);
o.put("temperature", temp);
o.put("connected", isConnected);
o.put("scale", scale);
o.put("temperature", temp);
o.put("voltage", voltage);
callback.event(o);
}
};
IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
getContext().registerReceiver(batteryReceiver, filter);
}
/**
* Method to resolve the battery status
*/
private void getStatus() {
if (DEBUG) {
MyLog.i(CLS_NAME, "getStatus");
}
if (batteryIntent != null) {
final SaiyResources sr = new SaiyResources(mContext, sl);
final int status = batteryIntent.getIntExtra(BatteryManager.EXTRA_STATUS,
BatteryManager.BATTERY_STATUS_UNKNOWN);
switch (status) {
case BatteryManager.BATTERY_STATUS_CHARGING:
int plugged = batteryIntent.getIntExtra(BatteryManager.EXTRA_PLUGGED,
BatteryManager.BATTERY_STATUS_UNKNOWN);
switch (plugged) {
case BatteryManager.BATTERY_PLUGGED_AC:
setStatusResponse(sr.getString(ai.saiy.android.R.string.ac_charging));
break;
case BatteryManager.BATTERY_PLUGGED_USB:
setStatusResponse(sr.getString(ai.saiy.android.R.string.usb_charging));
break;
default:
setStatusResponse(sr.getString(ai.saiy.android.R.string.charging));
break;
}
break;
case BatteryManager.BATTERY_STATUS_DISCHARGING:
setStatusResponse(sr.getString(ai.saiy.android.R.string.discharging));
break;
case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
setStatusResponse(sr.getString(ai.saiy.android.R.string.discharging));
break;
case BatteryManager.BATTERY_STATUS_FULL:
setStatusResponse(sr.getString(ai.saiy.android.R.string.fully_charged));
break;
case BatteryManager.BATTERY_STATUS_UNKNOWN:
setStatusResponse(sr.getString(ai.saiy.android.R.string.currently_indeterminable));
break;
default:
setStatusResponse(sr.getString(ai.saiy.android.R.string.currently_indeterminable));
break;
}
sr.reset();
} else {
if (DEBUG) {
MyLog.w(CLS_NAME, "batteryIntent: null");
}
setAccessFailure();
}
}
/**
* バッテリーのIntentを設定.
*
* @param intent Batteryの変化で取得できたIntent
*/
private void setBatteryRequest(final Intent intent) {
String mAction = intent.getAction();
if (Intent.ACTION_BATTERY_CHANGED.equals(mAction) || Intent.ACTION_BATTERY_LOW.equals(mAction)
|| Intent.ACTION_BATTERY_OKAY.equals(mAction)) {
// バッテリーの変化を取得
int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
switch (status) {
case BatteryManager.BATTERY_STATUS_UNKNOWN:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_UNKNOWN;
break;
case BatteryManager.BATTERY_STATUS_CHARGING:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_CHARGING;
break;
case BatteryManager.BATTERY_STATUS_DISCHARGING:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_DISCHARGING;
break;
case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_NOT_CHARGING;
break;
case BatteryManager.BATTERY_STATUS_FULL:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_FULL;
break;
default:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_UNKNOWN;
break;
}
mValueLevel = intent.getIntExtra("level", 0);
mValueScale = intent.getIntExtra("scale", 0);
} else if (Intent.ACTION_POWER_CONNECTED.equals(mAction) || Intent.ACTION_POWER_DISCONNECTED.equals(mAction)) {
mChargingFlag = Intent.ACTION_POWER_CONNECTED.equals(mAction);
// プラグの状態を取得
int plugged = intent.getIntExtra("plugged", 0);
switch (plugged) {
case BatteryManager.BATTERY_PLUGGED_AC:
mStatusPlugged = BATTERY_PLUGGED_AC;
break;
case BatteryManager.BATTERY_PLUGGED_USB:
mStatusPlugged = BATTERY_PLUGGED_USB;
break;
default:
break;
}
}
}
/**
* バッテリーのIntentから情報を取得.
*/
public void getBatteryInfo() {
IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
Intent batteryStatus;
int i = 0;
do {
batteryStatus = getContext().registerReceiver(null, filter);
} while (i++ < 3 && batteryStatus == null);
if (batteryStatus == null) {
mStatusBattery = HostBatteryManager.BATTERY_STATUS_UNKNOWN;
mValueLevel = 0;
mValueScale = 0;
return;
}
// バッテリーの変化を取得
int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
switch (status) {
case BatteryManager.BATTERY_STATUS_UNKNOWN:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_UNKNOWN;
break;
case BatteryManager.BATTERY_STATUS_CHARGING:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_CHARGING;
break;
case BatteryManager.BATTERY_STATUS_DISCHARGING:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_DISCHARGING;
break;
case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_NOT_CHARGING;
break;
case BatteryManager.BATTERY_STATUS_FULL:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_FULL;
break;
default:
mStatusBattery = HostBatteryManager.BATTERY_STATUS_UNKNOWN;
break;
}
// プラグの状態を取得
int plugged = batteryStatus.getIntExtra("plugged", 0);
switch (plugged) {
case BatteryManager.BATTERY_PLUGGED_AC:
mStatusPlugged = BATTERY_PLUGGED_AC;
break;
case BatteryManager.BATTERY_PLUGGED_USB:
mStatusPlugged = BATTERY_PLUGGED_USB;
break;
default:
break;
}
// チャージングフラグ
mChargingFlag = (plugged != 0);
// バッテリー残量
mValueLevel = batteryStatus.getIntExtra("level", 0);
mValueScale = batteryStatus.getIntExtra("scale", 0);
}
static BatteryUsage getBatteryUsage(final Context context, Intent intent) {
BatteryUsage usage = new BatteryUsage();
BatteryDetails details = new BatteryDetails();
// Battery details
int health = intent.getIntExtra(BatteryManager.EXTRA_HEALTH, 0);
int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, 0);
int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);
String batteryTechnology = intent.getExtras().getString(BatteryManager.EXTRA_TECHNOLOGY);
String batteryHealth = "Unknown";
String batteryCharger = "unplugged";
String batteryStatus;
usage.timestamp = System.currentTimeMillis();
usage.id = String.valueOf(usage.timestamp).hashCode();
switch (health) {
case BatteryManager.BATTERY_HEALTH_DEAD:
batteryHealth = "Dead";
break;
case BatteryManager.BATTERY_HEALTH_GOOD:
batteryHealth = "Good";
break;
case BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:
batteryHealth = "Over voltage";
break;
case BatteryManager.BATTERY_HEALTH_OVERHEAT:
batteryHealth = "Overheat";
break;
case BatteryManager.BATTERY_HEALTH_UNKNOWN:
batteryHealth = "Unknown";
break;
case BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:
batteryHealth = "Unspecified failure";
break;
}
switch (status) {
case BatteryManager.BATTERY_STATUS_CHARGING:
batteryStatus = "Charging";
break;
case BatteryManager.BATTERY_STATUS_DISCHARGING:
batteryStatus = "Discharging";
break;
case BatteryManager.BATTERY_STATUS_FULL:
batteryStatus = "Full";
break;
case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
batteryStatus = "Not charging";
break;
case BatteryManager.BATTERY_STATUS_UNKNOWN:
batteryStatus = "Unknown";
break;
default:
batteryStatus = "Unknown";
}
switch (plugged) {
case BatteryManager.BATTERY_PLUGGED_AC:
batteryCharger = "ac";
break;
case BatteryManager.BATTERY_PLUGGED_USB:
batteryCharger = "usb";
break;
case BatteryManager.BATTERY_PLUGGED_WIRELESS:
batteryCharger = "wireless";
}
details.temperature =
((float) intent.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, 0)) / 10;
// current battery voltage in VOLTS
// (the unit of the returned value by BatteryManager is millivolts)
details.voltage =
((float) intent.getIntExtra(BatteryManager.EXTRA_VOLTAGE, 0)) / 1000;
details.charger = batteryCharger;
details.health = batteryHealth;
details.technology = batteryTechnology;
// Battery other values with API level limitations
details.capacity = Battery.getBatteryDesignCapacity(context);
details.chargeCounter = Battery.getBatteryChargeCounter(context);
details.currentAverage = Battery.getBatteryCurrentAverage(context);
details.currentNow = (int) Battery.getBatteryCurrentNow(context);
details.energyCounter = Battery.getBatteryEnergyCounter(context);
details.remainingCapacity = Battery.getBatteryRemainingCapacity(context);
usage.level = (float) sCurrentBatteryLevel;
usage.state = batteryStatus;
usage.screenOn = Screen.isOn(context);
usage.triggeredBy = intent.getAction();
usage.details = details;
return usage;
}