From a15a4c6849b17baaaf6719f9cf7ad3e06c5cac29 Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Mon, 15 Jun 2020 21:17:32 +0900 Subject: [PATCH] Change battery units in auto test 1. Add power_source, voltage, current and temperature in battery power_supply_type ex) power_source, voltage, current and temperature are updated by uevent. BUt they are not tested. 2. Add compare_power_supply to check set and get values. ex) pass and fail is only decided by returned value Add compare_power_supply to improve it. 3. Add vconf test ex) Add vconf test function to check it 4. Send battery parameters to battery_changed ex) Currently, battery parameters set by auto test are not delievered to battery_changed. So, battery related parameters and vconf values are not updated properly Change-Id: I90a98cccfc6f0421bf5762ef6b766876cf6b1e56 Signed-off-by: lokilee73 --- src/auto-test/battery.c | 610 +++++++++++++++++++++++++++++++++++---------- src/battery/power-supply.c | 140 +++++++---- src/core/udev.h | 1 + 3 files changed, 581 insertions(+), 170 deletions(-) diff --git a/src/auto-test/battery.c b/src/auto-test/battery.c index c688d4d..4193e2b 100644 --- a/src/auto-test/battery.c +++ b/src/auto-test/battery.c @@ -17,6 +17,7 @@ */ #include #include "test.h" +#include #define METHOD_BATTERY_TIMETOFULL "TimeToFull" #define METHOD_BATTERY_TIMETOEMPTY "TimeToEmpty" @@ -31,106 +32,189 @@ #define METHOD_BATTERY_HEALTH "GetHealth" #define METHOD_BATTERY_GETINFO "GetBatteryInfo" #define METHOD_BATTERY_POWERSUPPLY "power_supply" - -#define CHARGEFULL_NAME "Full" -#define CHARGENOW_NAME "Charging" -#define DISCHARGE_NAME "Discharging" -#define NOTCHARGE_NAME "Not charging" - -#define GOOD_NAME "Good" -#define OVERHEAT_NAME "Overheat" -#define TEMPCOLD_NAME "Cold" -#define OVERVOLT_NAME "Over voltage" - -#define POWER_SUPPLY_TYPE_BATTERY "1" -#define POWER_SUPPLY_TYPE_UPS "2" - +#define METHOD_BATTERY_GET_POWERSUPPLY "get_power_supply" + +//Charging Status +#define CHARGEFULL "Full" +#define CHARGENOW "Charging" +#define DISCHARGE "Discharging" +#define NOTCHARGE "Not charging" + +//Battery Health +#define GOOD "Good" +#define OVERHEAT "Overheat" +#define TEMPCOLD "Cold" +#define OVERVOLT "Over voltage" + +//Power Source +#define TYPE_UNKNOWN "0" +#define TYPE_BATTERY "1" +#define TYPE_UPS "2" +#define TYPE_MAINS "3" +#define TYPE_USB "4" + +//External Power Source +#define AC "ac" +#define USB "usb" +#define WIRELESS "wireless" +#define NONE "none" + +//Battery Voltage +#define VOLT_4P2 "4200000" +#define VOLT_3P6 "3700000" +#define VOLT_3P4 "3500000" +#define VOLT_3P2 "3200000" +#define VOLT_3P0 "3000000" + +//Battery Temperature +#define TEMP_800 "800" +#define TEMP_250 "250" +#define TEMP_0 "0" + +//Charging Current +#define CUR_0 "0" +#define CUR_100 "100" +#define CUR_300 "300" + +//Battery Present #define PRESENT_ABNORMAL "0" #define PRESENT_NORMAL "1" +//MISC #define MISC_ABNORMAL "1" #define MISC_NORMAL "0" -#define FREQ_STRENGTH_LEVEL_0 "0" -#define FREQ_STRENGTH_LEVEL_1 "50" -#define FREQ_STRENGTH_LEVEL_2 "100" - -#define DEFAULT_LOWBATLEVEL 15 +//Frequency Strength +#define LEVEL_0 "0" +#define LEVEL_1 "50" +#define LEVEL_2 "100" + +//Battery Level +#define DEFAULT_NORMAL 100 +#define DEFAULT_WARNING 15 +#define DEFAULT_CRITICAL 5 +#define DEFAULT_POWEROFF 1 +#define DEFAULT_REALOFF 0 + +//Charger Type +#define CHARGER_WIRELESS_TYPE_BT 10 +#define CHARGER_WIRELESS_TYPE_3G 22 +#define CHARGER_INCOMPATIBLE_TYPE 11 +#define CHARGER_D2D_TYPE 110 +#define WIRELESS_CHARGER_CONNECTED 2 #define S_ENTER 1 #define S_LEAVE 0 +enum charge_status_type { + CHARGE_STATUS_UNKNOWN, + CHARGE_STATUS_DISCONNECTED, + CHARGE_STATUS_CONNECTED, + CHARGE_STATUS_CHARGING, + CHARGE_STATUS_DISCHARGING, + CHARGE_STATUS_NOT_CHARGING, + CHARGE_STATUS_FULL, +}; + +enum charge_now_type { + CHARGER_ABNORMAL = -1, + CHARGER_DISCHARGING, + CHARGER_CHARGING, +}; + +enum health_type { + HEALTH_NO_OPT = -1, + HEALTH_GOOD, + HEALTH_LOW, + HEALTH_DEAD, + HEALTH_HIGH, + HEALTH_OVP, +}; + +enum charger_type { + CHARGER_TYPE_NONE = 0, + CHARGER_TYPE_WIRE, + CHARGER_TYPE_WIRELESS, + CHARGER_TYPE_INCOMPATIBLE, + CHARGER_TYPE_D2D, +}; + static struct power_supply_type { - char *scenario; - int status; - char *capacity; - char *charge_status; - char *health; - char *online; - char *present; - char *misc; - char *freq_strength; - char *name; + const char *scenario; + const int status; + const char *capacity; + const char *charge_status; + const char *health; + const char *online; + const char *present; + const char *power_source; + const char *voltage_now; + const char *voltage_avg; + const char *current_now; + const char *current_avg; + const char *temperature; + const char *misc; + const char *freq_strength; + const char *name; } power_supply_types[] = { - {"norm", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "CHARGE"}, - {"norm", S_ENTER, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"norm", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"heat1", S_ENTER, "100", DISCHARGE_NAME, OVERHEAT_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, - {"heat1", S_ENTER, "100", NOTCHARGE_NAME, OVERHEAT_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "HEALTH(H) BEFORE CHARGE"}, - {"heat1", S_LEAVE, "100", DISCHARGE_NAME, OVERHEAT_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"heat1", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"heat2", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, - {"heat2", S_ENTER, "100", NOTCHARGE_NAME, OVERHEAT_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "HEALTH(H) AFTER CHARGE"}, - {"heat2", S_LEAVE, "100", DISCHARGE_NAME, OVERHEAT_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"heat2", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"cold1", S_ENTER, "100", DISCHARGE_NAME, TEMPCOLD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, - {"cold1", S_ENTER, "100", NOTCHARGE_NAME, TEMPCOLD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "HEALTH(L) BEFORE CHARGE"}, - {"cold1", S_LEAVE, "100", DISCHARGE_NAME, TEMPCOLD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"cold1", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"cold2", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, - {"cold2", S_ENTER, "100", NOTCHARGE_NAME, TEMPCOLD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "HEALTH(L) AFTER CHARGE"}, - {"cold2", S_LEAVE, "100", DISCHARGE_NAME, TEMPCOLD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"cold2", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"ovp", S_ENTER, "100", DISCHARGE_NAME, OVERVOLT_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "OVP"}, - {"ovp", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"pres1", S_ENTER, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_ABNORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, - {"pres1", S_ENTER, "100", NOTCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_ABNORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "PRESENT BEFORE CHARGE"}, - {"pres1", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_ABNORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"pres1", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"pres2", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, - {"pres2", S_ENTER, "100", NOTCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_ABNORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "PRESENT AFTER CHARGE"}, - {"pres2", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_ABNORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, - {"pres2", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, NULL}, /* init */ - - {"bat15", S_ENTER, "15", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 15%"}, /* lowbat 15% */ - {"bat15", S_LEAVE, "15", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 15%"}, - {"bat5", S_ENTER, "5", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 5%"}, /* lowbat 5% */ - {"bat5", S_LEAVE, "5", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 5%"}, - {"bat3", S_ENTER, "3", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 3%"}, /* lowbat 3% */ - {"bat3", S_LEAVE, "3", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 3%"}, - {"bat1", S_ENTER, "1", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 1%"}, /* lowbat 1% */ - {"bat1", S_LEAVE, "1", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "LOWBAT 1%"}, - - {"ta", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "CHARGE"}, /* charging */ - {"ta", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"},/* discharging */ - - {"full", S_ENTER, "100", CHARGEFULL_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "CHARGE"}, /* full */ - {"full", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"},/* discharging */ - - {"capa", S_ENTER, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "CAPACITY"},/* discharging */ - {"capa", S_LEAVE, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "CAPACITY"},/* charging */ - - {"freq", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "CHARGE"}, - {"freq", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_1, "FREQ LEVEL 1 AFTER CHARGE"}, - {"freq", S_ENTER, "100", CHARGENOW_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_UPS, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_2, "FREQ LEVEL 2 AFTER CHARGE"}, - {"freq", S_LEAVE, "100", DISCHARGE_NAME, GOOD_NAME, POWER_SUPPLY_TYPE_BATTERY, PRESENT_NORMAL, MISC_NORMAL, FREQ_STRENGTH_LEVEL_0, "DISCHARGE"}, /* init */ + {"norm", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, "CHARGE"}, + {"norm", S_ENTER, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"norm", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + {"heat1", S_ENTER, "100", DISCHARGE, OVERHEAT, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, NULL}, + {"heat1", S_ENTER, "100", NOTCHARGE, OVERHEAT, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, "HEALTH(H) BEFORE CHARGE"}, + {"heat1", S_LEAVE, "100", DISCHARGE, OVERHEAT, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"heat1", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"heat2", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_300, CUR_300, TEMP_800, MISC_NORMAL, LEVEL_0, NULL}, + {"heat2", S_ENTER, "100", NOTCHARGE, OVERHEAT, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, "HEALTH(H) AFTER CHARGE"}, + {"heat2", S_LEAVE, "100", DISCHARGE, OVERHEAT, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"heat2", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_800, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"cold1", S_ENTER, "100", DISCHARGE, TEMPCOLD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, NULL}, + {"cold1", S_ENTER, "100", NOTCHARGE, TEMPCOLD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, "HEALTH(L) BEFORE CHARGE"}, + {"cold1", S_LEAVE, "100", DISCHARGE, TEMPCOLD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"cold1", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"cold2", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_300, CUR_300, TEMP_0, MISC_NORMAL, LEVEL_0, NULL}, + {"cold2", S_ENTER, "100", NOTCHARGE, TEMPCOLD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, "HEALTH(L) AFTER CHARGE"}, + {"cold2", S_LEAVE, "100", DISCHARGE, TEMPCOLD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"cold2", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_0, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"ovp", S_ENTER, "100", DISCHARGE, OVERVOLT, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "OVP"}, + {"ovp", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"pres1", S_ENTER, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_ABNORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, NULL}, + {"pres1", S_ENTER, "100", NOTCHARGE, GOOD, TYPE_UPS, PRESENT_ABNORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "PRESENT BEFORE CHARGE"}, + {"pres1", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_ABNORMAL, NONE, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"pres1", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"pres2", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, NULL}, + {"pres2", S_ENTER, "100", NOTCHARGE, GOOD, TYPE_UPS, PRESENT_ABNORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "PRESENT AFTER CHARGE"}, + {"pres2", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_ABNORMAL, NONE, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, + {"pres2", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, NULL}, /* init */ + + {"bat15", S_ENTER, "15", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_3P6, VOLT_3P6, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 15%"}, /* lowbat 15% */ + {"bat15", S_LEAVE, "15", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, NONE, VOLT_3P6, VOLT_3P6, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 15%"}, + {"bat5", S_ENTER, "5", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_3P4, VOLT_3P4, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 5%"}, /* lowbat 5% */ + {"bat5", S_LEAVE, "5", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, NONE, VOLT_3P4, VOLT_3P4, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 5%"}, + {"bat3", S_ENTER, "3", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_3P2, VOLT_3P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 3%"}, /* lowbat 3% */ + {"bat3", S_LEAVE, "3", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, NONE, VOLT_3P2, VOLT_3P2, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 3%"}, + {"bat1", S_ENTER, "1", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, NONE, VOLT_3P0, VOLT_3P0, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 1%"}, /* lowbat 1% */ + {"bat1", S_LEAVE, "1", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, NONE, VOLT_3P0, VOLT_3P0, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, "LOWBAT 1%"}, + + {"ta", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_300, CUR_300, TEMP_250, MISC_NORMAL, LEVEL_0, "CHARGE"}, /* charging */ + {"ta", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "DISCHARGE"},/* discharging */ + + {"full", S_ENTER, "100", CHARGEFULL, GOOD, TYPE_UPS, PRESENT_NORMAL, WIRELESS, VOLT_4P2, VOLT_4P2, CUR_100, CUR_100, TEMP_250, MISC_NORMAL, LEVEL_0, "CHARGE"}, /* full */ + {"full", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, WIRELESS, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "DISCHARGE"},/* discharging */ + + {"capa", S_ENTER, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "CAPACITY"},/* discharging */ + {"capa", S_LEAVE, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, USB, VOLT_4P2, VOLT_4P2, CUR_100, CUR_100, TEMP_250, MISC_NORMAL, LEVEL_0, "CAPACITY"},/* charging */ + + {"freq", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, WIRELESS, VOLT_4P2, VOLT_4P2, CUR_100, CUR_100, TEMP_250, MISC_NORMAL, LEVEL_0, "CHARGE"}, + {"freq", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, WIRELESS, VOLT_4P2, VOLT_4P2, CUR_100, CUR_100, TEMP_250, MISC_NORMAL, LEVEL_1, "FREQ LEVEL 1 AFTER CHARGE"}, + {"freq", S_ENTER, "100", CHARGENOW, GOOD, TYPE_UPS, PRESENT_NORMAL, WIRELESS, VOLT_4P2, VOLT_4P2, CUR_100, CUR_100, TEMP_250, MISC_NORMAL, LEVEL_2, "FREQ LEVEL 2 AFTER CHARGE"}, + {"freq", S_LEAVE, "100", DISCHARGE, GOOD, TYPE_BATTERY, PRESENT_NORMAL, WIRELESS, VOLT_4P2, VOLT_4P2, CUR_0, CUR_0, TEMP_250, MISC_NORMAL, LEVEL_0, "DISCHARGE"}, /* init */ }; static bool get_battery_method(const char *method, int *value) @@ -242,12 +326,12 @@ static bool set_battery_low_level(int newlevel) _E("Failed to call dbus method(%s): No message", METHOD_BATTERY_SETLOWBATLEVEL); goto out; } else { - if (newlevel <= DEFAULT_LOWBATLEVEL) { + if (newlevel <= DEFAULT_WARNING) { if (0 != val) { - _I("Success. Can't set low level(%d) smaller than default(%d).", newlevel, DEFAULT_LOWBATLEVEL); + _I("Success. Can't set low level(%d) smaller than default(%d).", newlevel, DEFAULT_WARNING); ret = TRUE; } else { - _E("Failed. Can't set low level(%d) smaller than default(%d), but returned success.", newlevel, DEFAULT_LOWBATLEVEL); + _E("Failed. Can't set low level(%d) smaller than default(%d), but returned success.", newlevel, DEFAULT_WARNING); } goto out; } else { @@ -357,28 +441,253 @@ static bool get_battery_info() return ret; } +static int change_charge_status_to_enum(const char *env_value) +{ + int len, ret; + + if (env_value == NULL) + return -1; + + len = strlen(env_value); + if (strncmp(env_value, CHARGEFULL, len) == 0) + ret = CHARGE_STATUS_FULL; + else if (strncmp(env_value, CHARGENOW, len) == 0) + ret = CHARGE_STATUS_CHARGING; + else if (strncmp(env_value, DISCHARGE, len) == 0) + ret = CHARGE_STATUS_DISCHARGING; + else if (strncmp(env_value, NOTCHARGE, len) == 0) + ret = CHARGE_STATUS_NOT_CHARGING; + else + ret = CHARGE_STATUS_UNKNOWN; + + return ret; +} + +static int change_health_status_to_enum(const char *env_value) +{ + int len, ret; + + if (env_value == NULL) + return -1; + + len = strlen(env_value); + if (strncmp(env_value, OVERHEAT, len) == 0) + ret = HEALTH_HIGH; + else if (strncmp(env_value, TEMPCOLD, len) == 0) + ret = HEALTH_LOW; + else if (strncmp(env_value, OVERVOLT, len) == 0) + ret = HEALTH_OVP; + else if (strncmp(env_value, GOOD, len) == 0) + ret = HEALTH_GOOD; + else + ret = HEALTH_NO_OPT; + + return ret; +} + +static bool compare_vconf(struct power_supply_type list) +{ + int value, ret, temp; + int capacity, online, charge_status; + + ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value); + if (ret < 0) { + _E("Failed to get vconf value for battery charge now: %d", vconf_get_ext_errno()); + return false; + } + if (!strcmp(list.charge_status, CHARGEFULL)) { + charge_status = CHARGE_STATUS_FULL; + temp = CHARGER_DISCHARGING; + } else if (!strcmp(list.charge_status, CHARGENOW)) { + charge_status = CHARGE_STATUS_CHARGING; + temp = CHARGER_CHARGING; + } else if (!strcmp(list.charge_status, DISCHARGE)) { + charge_status = CHARGE_STATUS_DISCHARGING; + temp = CHARGER_DISCHARGING; + } else if (!strcmp(list.charge_status, NOTCHARGE)) { + charge_status = CHARGE_STATUS_NOT_CHARGING; + temp = CHARGER_ABNORMAL; + } else { + charge_status = CHARGE_STATUS_UNKNOWN; + temp = CHARGER_DISCHARGING; + } + if (temp != value) + return false; + + capacity = atoi(list.capacity); + ret= vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &value); + if (ret < 0) { + _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + return false; + } + if (capacity <= DEFAULT_REALOFF) { + if (charge_status == CHARGE_STATUS_CHARGING) + temp = VCONFKEY_SYSMAN_BAT_POWER_OFF; + else + temp = VCONFKEY_SYSMAN_BAT_REAL_POWER_OFF; + } else if (capacity <= DEFAULT_POWEROFF) { + temp = VCONFKEY_SYSMAN_BAT_POWER_OFF; + } else if (capacity <= DEFAULT_CRITICAL) { + temp = VCONFKEY_SYSMAN_BAT_CRITICAL_LOW; + } else if (capacity <= DEFAULT_WARNING) { + temp = VCONFKEY_SYSMAN_BAT_WARNING_LOW; + } else if (capacity >= DEFAULT_NORMAL && + charge_status == CHARGE_STATUS_FULL) { + temp = VCONFKEY_SYSMAN_BAT_FULL; + } else { + temp = VCONFKEY_SYSMAN_BAT_NORMAL; + } + if (temp != value) + return false; + + ret = vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &value); + if (ret < 0) { + _E("Failed to get vconf value for charger status: %d", vconf_get_ext_errno()); + return false; + } + online = atoi(list.online); + if (online > atoi(TYPE_BATTERY)) + temp = VCONFKEY_SYSMAN_CHARGER_CONNECTED; + else + temp = VCONFKEY_SYSMAN_CHARGER_DISCONNECTED; + if (temp != value) + return false; + + ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &value); + if (ret < 0) { + _E("Failed to get vconf value for battery capacity: %d", vconf_get_ext_errno()); + return false; + } + if (value != capacity) + return false; + + ret = vconf_get_int(VCONFKEY_SYSMAN_CHARGER_TYPE, &value); + if (ret < 0) { + _E("Failed to get vconf value for charger type: %d", vconf_get_ext_errno()); + return false; + } + if (online <= POWER_SUPPLY_TYPE_BATTERY) + temp = CHARGER_TYPE_NONE; + else if (online == CHARGER_WIRELESS_TYPE_BT || + online == CHARGER_WIRELESS_TYPE_3G) + temp = CHARGER_TYPE_WIRELESS; + else if (online == CHARGER_INCOMPATIBLE_TYPE) + temp = CHARGER_TYPE_INCOMPATIBLE; + else if (online == CHARGER_D2D_TYPE) + temp = CHARGER_TYPE_D2D; + else + temp = CHARGER_TYPE_WIRE; + if (temp != value) + return false; + + return true; +} + +static bool compare_power_supply(struct power_supply_type list, int value[], const char *power_source) +{ + if (atoi(list.capacity) != value[0]) { + _E("Different capacity : %d %d", atoi(list.capacity), value[0]); + return false; + } + + if (change_charge_status_to_enum(list.charge_status) != value[1]) { + _E("Different charge_status : %d %d", change_charge_status_to_enum(list.charge_status), value[1]); + return false; + } + + if (change_health_status_to_enum(list.health) != value[2]) { + _E("Different health : %d %d", change_health_status_to_enum(list.health), value[2]); + return false; + } + + if (atoi(list.online) != value[3]) { + _E("Different online : %d %d", atoi(list.online), value[3]); + return false; + } + + if (atoi(list.present) != value[4]) { + _E("Different present : %d %d", atoi(list.present), value[4]); + return false; + } + + if (atoi(list.misc) != value[5]) { + _E("Different misc : %d %d", atoi(list.misc), value[5]); + return false; + } + + if (atoi(list.freq_strength) != value[6]) { + _E("Different freq_strength : %d %d", atoi(list.freq_strength), value[6]); + return false; + } + + if (strcmp(list.power_source, power_source)) { + _E("Different power_source : %s %s", list.power_source, power_source); + return false; + } + + if (atoi(list.voltage_now) != value[7]) { + _E("Different voltage_now : %d %d", atoi(list.voltage_now), value[7]); + return false; + } + + if (atoi(list.voltage_avg) != value[8]) { + _E("Different voltage_avg : %d %d", atoi(list.voltage_avg), value[8]); + return false; + } + + if (atoi(list.current_now) != value[9]) { + _E("Different current_now : %d %d", atoi(list.current_now), value[9]); + return false; + } + + if (atoi(list.current_avg) != value[10]) { + _E("Different current_avg : %d %d", atoi(list.current_avg), value[10]); + return false; + } + + if (atoi(list.temperature) != value[11]) { + _E("Different temperature : %d %d", atoi(list.temperature), value[11]); + return false; + } + + return true; +} + static bool set_battery_power_supply(int index) { - GVariant *msg; + GVariant *msg, *var; int val; bool ret = FALSE; - GVariant *var; - var = g_variant_new("(sisssssss)", POWER_SUBSYSTEM, - 7, + var = g_variant_new("(sisssssssssssss)", POWER_SUBSYSTEM, + 13, power_supply_types[index].capacity, power_supply_types[index].charge_status, power_supply_types[index].health, power_supply_types[index].online, power_supply_types[index].present, power_supply_types[index].misc, - power_supply_types[index].freq_strength); - _I("C(%s , %s) P(%s) STATUS(%s) HEALTH(%s)", + power_supply_types[index].freq_strength, + power_supply_types[index].power_source, + power_supply_types[index].voltage_now, + power_supply_types[index].voltage_avg, + power_supply_types[index].current_now, + power_supply_types[index].current_avg, + power_supply_types[index].temperature); + _I("C(%s) S(%s) H(%s) O(%s) P(%s) M(%s) F(%s) SRC(%s) Vol(%s %s) Cur(%s %s) T(%s)", power_supply_types[index].capacity, + power_supply_types[index].charge_status, + power_supply_types[index].health, power_supply_types[index].online, power_supply_types[index].present, - power_supply_types[index].charge_status, - power_supply_types[index].health); + power_supply_types[index].misc, + power_supply_types[index].freq_strength, + power_supply_types[index].power_source, + power_supply_types[index].voltage_now, + power_supply_types[index].voltage_avg, + power_supply_types[index].current_now, + power_supply_types[index].current_avg, + power_supply_types[index].temperature); msg = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME, DEVICED_PATH_BATTERY, @@ -394,45 +703,70 @@ static bool set_battery_power_supply(int index) val = -EBADMSG; } else { if (val < 0) { - _E("Failed to call dbus method(%s): Return fail", POWER_SUBSYSTEM); + _E("Failed to call dbus method(%s): Return fail(%d)", POWER_SUBSYSTEM, val); } else { _I("Success. val=%d", val); ret = TRUE; } } - /* - if (power_supply_types[index].name != NULL) - _I("++++++++++[START] %s ++++++++++", power_supply_types[index].name); - _I("C(%s , %s) P(%s) STATUS(%s) HEALTH(%s)", - power_supply_types[index].capacity, - power_supply_types[index].online, - power_supply_types[index].present, - power_supply_types[index].charge_status, - power_supply_types[index].health); - if (power_supply_types[index].name != NULL) - _I("++++++++++[END] %s ++++++++++", power_supply_types[index].name); - if (val < 0) - _R("[NG] ---- %s", __func__); - else - _R("[OK] ---- %s : C(%s , %s) P(%s) S(%s) H(%s)", - __func__, - power_supply_types[index].capacity, - power_supply_types[index].online, - power_supply_types[index].present, - power_supply_types[index].charge_status, - power_supply_types[index].health); - */ g_variant_unref(msg); sleep(TEST_WAIT_TIME_INTERVAL); return ret; } +static bool get_battery_power_supply(int rsp[], char **power_source) +{ + GVariant *msg; + int val; + bool ret = FALSE; + + msg = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME, + DEVICED_PATH_BATTERY, + DEVICED_INTERFACE_BATTERY, + METHOD_BATTERY_GET_POWERSUPPLY, NULL); + if (!msg) { + _E("Failed to call dbus method(%s): No reply", METHOD_BATTERY_GET_POWERSUPPLY); + return ret; + } + + if (!dh_get_param_from_var(msg, "(iiiiiiiisiiiii)", &val, //return value + &rsp[0], //capacity + &rsp[1], //charge_status + &rsp[2], //health + &rsp[3], //online + &rsp[4], //present + &rsp[5], //misc + &rsp[6], //freq_strength + power_source, //power_source + &rsp[7], //voltage_now + &rsp[8], //voltagge_avg + &rsp[9], //current_now + &rsp[10], //current_avg + &rsp[11])) { //temperature + _E("Failed to call dbus method(%s): No message", METHOD_BATTERY_GET_POWERSUPPLY); + } else { + if (val < 0) { + _E("Failed to call dbus method(%s): Return fail(%d)", METHOD_BATTERY_GET_POWERSUPPLY, val); + } else { + _I("Success : C(%d) S(%d) H(%d) O(%d) P(%d) M(%d) F(%d) SRC(%s) Vol(%d %d) Cur(%d %d) Temp(%d)", + rsp[0], rsp[1], rsp[2], rsp[3], rsp[4], rsp[5], rsp[6], *power_source, rsp[7], rsp[8], rsp[9], rsp[10], rsp[11]); + ret = true; + } + } + + g_variant_unref(msg); + + return ret; +} + static void full_scenario(char *unit, char *capacity, int status) { int index; int len; + int rsp[12]; + char *power_source = NULL; if (!unit || !capacity) return; @@ -448,6 +782,9 @@ static void full_scenario(char *unit, char *capacity, int status) power_supply_types[index].capacity = capacity; _D("%s", power_supply_types[index].capacity); set_battery_power_supply(index); + get_battery_power_supply(rsp, &power_source); + compare_power_supply(power_supply_types[index], rsp, power_source); + compare_vconf(power_supply_types[index]); } } @@ -456,7 +793,9 @@ static void battery_scenario(char *unit, int status) int index; int found = 0; int unit_len; - char *scenario = NULL; + int rsp[12]; + char *power_source = NULL; + const char *scenario = NULL; if (!unit) return; @@ -472,6 +811,9 @@ static void battery_scenario(char *unit, int status) continue; found = 1; set_battery_power_supply(index); + get_battery_power_supply(rsp, &power_source); + compare_power_supply(power_supply_types[index], rsp, power_source); + compare_vconf(power_supply_types[index]); } if (found) @@ -492,6 +834,9 @@ static void battery_scenario(char *unit, int status) power_supply_types[index].capacity = unit; _D("%s", power_supply_types[index].capacity); set_battery_power_supply(index); + get_battery_power_supply(rsp, &power_source); + compare_power_supply(power_supply_types[index], rsp, power_source); + compare_vconf(power_supply_types[index]); } } @@ -499,6 +844,8 @@ void battery_test_all(int *success, int *fail) { int s = 0; int f = 0; + int rsp[12]; + char *power_source = NULL; (get_battery_time_to_full()) ? s++ : f++; (get_battery_time_to_empty()) ? s++ : f++; @@ -514,8 +861,12 @@ void battery_test_all(int *success, int *fail) (get_battery_health()) ? s++ : f++; (get_battery_info()) ? s++ : f++; - for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) - (set_battery_power_supply(index)) ? s++ : f++; + for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) { + (set_battery_power_supply(index) && + get_battery_power_supply(rsp, &power_source) && + compare_power_supply(power_supply_types[index], rsp, power_source) && + compare_vconf(power_supply_types[index])) ? s++ : f++; + } if (NULL != success) *success = s; if (NULL != fail) *fail = f; @@ -541,6 +892,9 @@ static void battery_exit(void *data) static int battery_unit(int argc, char **argv) { + int rsp[12]; + char *power_source = NULL; + if (argc < 4) { int success = 0; int fail = 0; @@ -572,8 +926,12 @@ static int battery_unit(int argc, char **argv) } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETINFO)) { get_battery_info(); } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_POWERSUPPLY)) { - for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) + for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) { set_battery_power_supply(index); + get_battery_power_supply(rsp, &power_source); + compare_power_supply(power_supply_types[index], rsp, power_source); + compare_vconf(power_supply_types[index]); + } } else if (argc > 4 && argv[4] && !strncmp("enter", argv[4], 5)) { battery_scenario(argv[3], S_ENTER); } else if (argc > 4 && argv[4] && !strncmp("leave", argv[4], 5)) { diff --git a/src/battery/power-supply.c b/src/battery/power-supply.c index d153b95..6960ba6 100644 --- a/src/battery/power-supply.c +++ b/src/battery/power-supply.c @@ -670,15 +670,6 @@ static void check_misc_status(const char *env_value) battery.misc = atoi(env_value); } -static void check_freq_strength_status(const char *env_value) -{ - if (env_value == NULL) { - battery.freq_strength = 0; - return; - } - battery.freq_strength = atoi(env_value); -} - static void check_online_status(const char *env_value) { if (env_value == NULL) @@ -1213,25 +1204,51 @@ static GVariant *dbus_get_freq_strength(GDBusConnection *conn, return g_variant_new("(i)", battery.freq_strength); } +static GVariant *dbus_get_power_supply_handler(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + return g_variant_new("(iiiiiiiisiiiii)", 0, + battery.capacity, + battery.charge_status, + battery.health, + battery.online, + battery.present, + battery.misc, + battery.freq_strength, + battery.power_source_s, + battery.voltage_now, + battery.voltage_average, + battery.current_now, + battery.current_average, + battery.temperature); +} + static GVariant *dbus_power_supply_handler(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { pid_t pid; - int ret = 0; - int argc = 0; + int ret = 0, argc = 0; char *type_str; - char *argv[7]; - - g_variant_get(param, "(sisssssss)", &type_str, - &argc, - &argv[0], - &argv[1], - &argv[2], - &argv[3], - &argv[4], - &argv[5], - &argv[6]); + char *argv[13]; + struct battery_info info = {0, }; + + g_variant_get(param, "(sisssssssssssss)", &type_str, + &argc, + &argv[0], + &argv[1], + &argv[2], + &argv[3], + &argv[4], + &argv[5], + &argv[6], + &argv[7], + &argv[8], + &argv[9], + &argv[10], + &argv[11], + &argv[12]); if (argc < 0) { _E("Message is invalid."); @@ -1245,21 +1262,32 @@ static GVariant *dbus_power_supply_handler(GDBusConnection *conn, ret = -ESRCH; goto out; } - check_capacity_status(argv[0]); - check_charge_status(argv[1]); - check_health_status(argv[2]); - check_online_status(argv[3]); - check_present_status(argv[4]); + + info.capacity = atoi(argv[0]); + info.status = strdup(argv[1]); + info.health = strdup(argv[2]); + info.online = atoi(argv[3]); + info.present = atoi(argv[4]); check_misc_status(argv[5]); - check_freq_strength_status(argv[6]); + info.freq_strength = atoi(argv[6]); + info.power_source = strdup(argv[7]); + info.voltage_now = atoi(argv[8]); + info.voltage_average = atoi(argv[9]); + info.current_now = atoi(argv[10]); + info.current_average = atoi(argv[11]); + info.temperature = atoi(argv[12]); + _D("C(%d) S(%s) H(%s) O(%d) P(%d) F(%d) SRC(%s) Vol(%d %d) Cur(%d %d) T(%d)", + info.capacity, info.status, info.health, info.online, info.present, info.freq_strength, info.power_source, info.voltage_now, info.voltage_average, info.current_now, info.current_average, info.temperature); + if (battery_dev) - battery_changed(NULL, NULL); + battery_changed(&info, NULL); + snprintf(battery.status_s, sizeof(battery.status_s), "%s", (battery.charge_now == CHARGER_CHARGING) ? "Charging" : (battery.charge_now == CHARGER_ABNORMAL) ? "Not Charging" : (battery.charge_full == CHARGING_FULL) ? "Full" : "Discharging"); - _I("%s(%d) %s(f:%d n:%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d)", + _I("%s(%d) %s(f:%d n:%d) %s(%d) %s(%d) %s(%d) %s(%d)", argv[0], battery.capacity, argv[1], @@ -1272,9 +1300,22 @@ static GVariant *dbus_power_supply_handler(GDBusConnection *conn, argv[4], battery.present, argv[5], - battery.misc, + battery.misc); + _I("%s(%d) %s(%s) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d)", argv[6], - battery.freq_strength); + battery.freq_strength, + argv[7], + battery.power_source_s, + argv[8], + battery.voltage_now, + argv[9], + battery.voltage_average, + argv[10], + battery.current_now, + argv[11], + battery.current_average, + argv[12], + battery.temperature); if (battery.online > POWER_SUPPLY_TYPE_BATTERY) power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_ON); @@ -1291,6 +1332,16 @@ out: g_free(argv[4]); g_free(argv[5]); g_free(argv[6]); + g_free(argv[7]); + g_free(argv[8]); + g_free(argv[9]); + g_free(argv[10]); + g_free(argv[11]); + g_free(argv[12]); + + free(info.status); + free(info.health); + free(info.power_source); return g_variant_new("(i)", ret); } @@ -1354,17 +1405,17 @@ static GVariant *dbus_get_battery_info(GDBusConnection *conn, out: return g_variant_new("(isssiiiiiiii)", ret, - battery.status_s, - battery.health_s, - battery.power_source_s, - battery.online, - battery.present, - battery.capacity, - battery.current_now, - battery.current_average, - battery.voltage_now, - battery.voltage_average, - battery.temperature); + battery.status_s, + battery.health_s, + battery.power_source_s, + battery.online, + battery.present, + battery.capacity, + battery.current_now, + battery.current_average, + battery.voltage_now, + battery.voltage_average, + battery.temperature); } static void update_battery_props(void) @@ -1396,7 +1447,8 @@ static const dbus_method_s dbus_methods[] = { { CHARGE_CAPACITY_LAW_SIGNAL, NULL, "i", dbus_get_percent_raw }, { CHARGE_FULL_SIGNAL, NULL, "i", dbus_is_full }, { CHARGE_HEALTH_SIGNAL, NULL, "s", dbus_get_health }, - { POWER_SUBSYSTEM, "sisssssss", "i", dbus_power_supply_handler }, + { POWER_SUBSYSTEM, "sisssssssssssss", "i", dbus_power_supply_handler }, + { GET_POWER_SUBSYSTEM, NULL, "iiiiiiiisiiiii", dbus_get_power_supply_handler }, { "GetBatteryInfo", NULL, "isssiiiiiiii", dbus_get_battery_info }, { CHARGER_TYPE_SIGNAL, NULL, "i", dbus_get_charger_type }, { "ChargerCharging", "i", "i", dbus_charger_charging }, diff --git a/src/core/udev.h b/src/core/udev.h index 8375c1f..f45d03e 100644 --- a/src/core/udev.h +++ b/src/core/udev.h @@ -31,6 +31,7 @@ /* battery device */ #define POWER_SUBSYSTEM "power_supply" +#define GET_POWER_SUBSYSTEM "get_power_supply" #define POWER_PATH "/sys/class/power_supply/battery" #define POWER_SUPPLY_UEVENT POWER_PATH"/uevent" #define CAPACITY "POWER_SUPPLY_CAPACITY" -- 2.7.4