src/auto-test/battery.c

   1 /*
   2  * test
   3  *
   4  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 #include <stdio.h>
  19 #include "test.h"
  20 #include <vconf.h>
  21 #include <device/battery-internal.h>
  22
  23 #define METHOD_BATTERY_TIMETOFULL       "TimeToFull"
  24 #define METHOD_BATTERY_TIMETOEMPTY      "TimeToEmpty"
  25 #define METHOD_BATTERY_SETLOWBATLEVEL   "SetLowbatLevel"
  26 #define METHOD_BATTERY_GETLOWBATLEVEL   "GetLowbatLevel"
  27 #define METHOD_BATTERY_CHARGERSTATUS    "ChargerStatus"
  28 #define METHOD_BATTERY_CHARGENOW        "ChargeNow"
  29 #define METHOD_BATTERY_STATUSLOW        "BatteryStatusLow"
  30 #define METHOD_BATTERY_GETPERCENT       "GetPercent"
  31 #define METHOD_BATTERY_GETPERCENTRAW    "GetPercentRaw"
  32 #define METHOD_BATTERY_ISFULL           "IsFull"
  33 #define METHOD_BATTERY_HEALTH           "GetHealth"
  34 #define METHOD_BATTERY_GETINFO          "GetBatteryInfo"
  35 #define METHOD_BATTERY_GETINFO_DIRECT   "GetBatteryInfoDirect"
  36 #define METHOD_BATTERY_POWERSUPPLY      "power_supply"
  37 #define METHOD_BATTERY_GET_POWERSUPPLY  "get_power_supply"
  38
  39 //Charging Status
  40 #define CHARGEFULL     "Full"
  41 #define CHARGENOW      "Charging"
  42 #define DISCHARGE      "Discharging"
  43 #define NOTCHARGE      "Not charging"
  44
  45 //Battery Health
  46 #define GOOD           "Good"
  47 #define OVERHEAT       "Overheat"
  48 #define TEMPCOLD       "Cold"
  49 #define OVERVOLT       "Over voltage"
  50
  51 //Power Source
  52 #define TYPE_UNKNOWN   "0"
  53 #define TYPE_BATTERY   "1"
  54 #define TYPE_UPS       "2"
  55 #define TYPE_MAINS     "3"
  56 #define TYPE_USB       "4"
  57
  58 //External Power Source
  59 #define AC              "ac"
  60 #define USB             "usb"
  61 #define WIRELESS        "wireless"
  62 #define NONE            "none"
  63
  64 //Battery Voltage
  65 #define VOLT_4P2        "4200000"
  66 #define VOLT_3P6        "3700000"
  67 #define VOLT_3P4        "3500000"
  68 #define VOLT_3P2        "3200000"
  69 #define VOLT_3P0        "3000000"
  70
  71 //Battery Temperature
  72 #define TEMP_800        "800"
  73 #define TEMP_250        "250"
  74 #define TEMP_0          "0"
  75
  76 //Charging Current
  77 #define CUR_0           "0"
  78 #define CUR_100         "100"
  79 #define CUR_300         "300"
  80
  81 //Battery Present
  82 #define PRESENT_ABNORMAL    "0"
  83 #define PRESENT_NORMAL      "1"
  84
  85 //MISC
  86 #define MISC_ABNORMAL       "1"
  87 #define MISC_NORMAL         "0"
  88
  89 //Frequency Strength
  90 #define LEVEL_0         "0"
  91 #define LEVEL_1         "50"
  92 #define LEVEL_2         "100"
  93
  94 //Battery Level
  95 #define DEFAULT_NORMAL          100
  96 #define DEFAULT_WARNING         15
  97 #define DEFAULT_CRITICAL        5
  98 #define DEFAULT_POWEROFF        1
  99 #define DEFAULT_REALOFF         0
 100
 101 //Charger Type
 102 #define CHARGER_WIRELESS_TYPE_BT    10
 103 #define CHARGER_WIRELESS_TYPE_3G    22
 104 #define CHARGER_INCOMPATIBLE_TYPE   11
 105 #define CHARGER_D2D_TYPE            110
 106 #define WIRELESS_CHARGER_CONNECTED  2
 107
 108 #define S_ENTER 1
 109 #define S_LEAVE 0
 110
 111 enum charge_status_type {
 112         CHARGE_STATUS_UNKNOWN,
 113         CHARGE_STATUS_DISCONNECTED,
 114         CHARGE_STATUS_CONNECTED,
 115         CHARGE_STATUS_CHARGING,
 116         CHARGE_STATUS_DISCHARGING,
 117         CHARGE_STATUS_NOT_CHARGING,
 118         CHARGE_STATUS_FULL,
 119 };
 120
 121 enum charge_now_type {
 122         CHARGER_ABNORMAL = -1,
 123         CHARGER_DISCHARGING,
 124         CHARGER_CHARGING,
 125 };
 126
 127 enum health_type {
 128         HEALTH_NO_OPT = -1,
 129         HEALTH_GOOD,
 130         HEALTH_LOW,
 131         HEALTH_DEAD,
 132         HEALTH_HIGH,
 133         HEALTH_OVP,
 134 };
 135
 136 enum charger_type {
 137         CHARGER_TYPE_NONE = 0,
 138         CHARGER_TYPE_WIRE,
 139         CHARGER_TYPE_WIRELESS,
 140         CHARGER_TYPE_INCOMPATIBLE,
 141         CHARGER_TYPE_D2D,
 142 };
 143
 144 static struct power_supply_type {
 145         const char *scenario;
 146         const int status;
 147         const char *capacity;
 148         const char *charge_status;
 149         const char *health;
 150         const char *online;
 151         const char *present;
 152         const char *power_source;
 153         const char *voltage_now;
 154         const char *voltage_avg;
 155         const char *current_now;
 156         const char *current_avg;
 157         const char *temperature;
 158         const char *misc;
 159         const char *freq_strength;
 160         const char *name;
 161 } power_supply_types[] = {
 162         {"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"},
 163         {"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"},
 164         {"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 */
 165         {"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},
 166         {"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"},
 167         {"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"},
 168         {"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 */
 169
 170         {"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},
 171         {"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"},
 172         {"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"},
 173         {"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 */
 174
 175         {"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},
 176         {"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"},
 177         {"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"},
 178         {"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 */
 179
 180         {"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},
 181         {"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"},
 182         {"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"},
 183         {"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 */
 184
 185         {"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"},
 186         {"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 */
 187
 188         {"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},
 189         {"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"},
 190         {"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"},
 191         {"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 */
 192
 193         {"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},
 194         {"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"},
 195         {"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"},
 196         {"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 */
 197
 198         {"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% */
 199         {"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%"},
 200         {"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% */
 201         {"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%"},
 202         {"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% */
 203         {"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%"},
 204         {"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% */
 205         {"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%"},
 206
 207         {"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 */
 208         {"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 */
 209
 210         {"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 */
 211         {"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 */
 212
 213         {"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 */
 214         {"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 */
 215
 216         {"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"},
 217         {"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"},
 218         {"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"},
 219         {"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 */
 220 };
 221
 222 static bool get_battery_method(const char *method, int *value)
 223 {
 224         GVariant *msg = NULL;
 225         int val = 0, err;
 226         char* health = NULL;
 227         bool ret = FALSE;
 228
 229         err = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
 230                         DEVICED_PATH_BATTERY,
 231                         DEVICED_INTERFACE_BATTERY,
 232                         method, NULL, &msg);
 233         if (err < 0) {
 234                 _E("Failed to call dbus method(%s): No reply.", method);
 235                 return ret;
 236         }
 237
 238         if (!strncmp(method, METHOD_BATTERY_HEALTH, strlen(METHOD_BATTERY_HEALTH))) {
 239                 if (!g_variant_get_safe(msg, "(s)", &health)) {
 240                         _E("Failed to call dbus method(%s): No message.", METHOD_BATTERY_HEALTH);
 241                 } else {
 242                         _I("Success. %s=%s", METHOD_BATTERY_HEALTH, health);
 243                         ret = TRUE;
 244                 }
 245         }
 246         else
 247         {
 248                 if (!g_variant_get_safe(msg, "(i)", &val)) {
 249                         _E("Failed to call dbus method(%s): No message.", method);
 250                 } else {
 251                         _I("Success. %s=%d", method, val);
 252                         ret = TRUE;
 253                         if (NULL != value)
 254                                 *value = val;
 255                 }
 256         }
 257
 258         if (health)
 259                 g_free(health);
 260         g_variant_unref(msg);
 261
 262         return ret;
 263 }
 264
 265 static bool get_battery_method_vconf(const char *method)
 266 {
 267         GVariant *msg = NULL;
 268         int val, err;
 269         bool ret = FALSE;
 270
 271         err = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
 272                         DEVICED_PATH_BATTERY,
 273                         DEVICED_INTERFACE_BATTERY,
 274                         method, NULL, &msg);
 275         if (err < 0) {
 276                 _E("Failed to call dbus method(%s): No reply.", method);
 277                 return ret;
 278         }
 279
 280         if (!g_variant_get_safe(msg, "(i)", &val))
 281                 _E("Failed to call dbus method(%s): No message.", method);
 282         else {
 283                 if (val == -EIO) {
 284                         _E("Failed to call dbus method(%s): Return fail.", method);
 285                 } else {
 286                         _I("Success. %s=%d", method, val);
 287                         ret = TRUE;
 288                 }
 289         }
 290
 291         g_variant_unref(msg);
 292         return ret;
 293 }
 294
 295 static bool get_battery_time_to_full(void)
 296 {
 297         return get_battery_method(METHOD_BATTERY_TIMETOFULL, NULL);
 298 }
 299
 300 static bool get_battery_time_to_empty(void)
 301 {
 302         return get_battery_method(METHOD_BATTERY_TIMETOEMPTY, NULL);
 303 }
 304
 305 static bool get_battery_low_level(int *value)
 306 {
 307         return get_battery_method(METHOD_BATTERY_GETLOWBATLEVEL, value);
 308 }
 309
 310 static bool set_battery_low_level(int newlevel)
 311 {
 312         GVariant *msg;
 313         int getlevel = -1;
 314         int val = -1;
 315         int err;
 316         bool ret = FALSE;
 317
 318         err = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
 319                         DEVICED_PATH_BATTERY,
 320                         DEVICED_INTERFACE_BATTERY,
 321                         METHOD_BATTERY_SETLOWBATLEVEL, g_variant_new("(i)", newlevel),
 322                         &msg);
 323
 324         if (err < 0) {
 325                 _E("Failed to call dbus method(%s): No reply", METHOD_BATTERY_SETLOWBATLEVEL);
 326                 return ret;
 327         }
 328
 329         if (!g_variant_get_safe(msg, "(i)", &val)) {
 330                 _E("Failed to call dbus method(%s): No message", METHOD_BATTERY_SETLOWBATLEVEL);
 331                 goto out;
 332         } else {
 333                 if (newlevel <= DEFAULT_WARNING) {
 334                         if (0 != val) {
 335                                 _I("Success. Can't set low level(%d) smaller than default(%d).", newlevel, DEFAULT_WARNING);
 336                                 ret = TRUE;
 337                         } else {
 338                                 _E("Failed. Can't set low level(%d) smaller than default(%d), but returned success.", newlevel, DEFAULT_WARNING);
 339                         }
 340                         goto out;
 341                 } else {
 342                         if (0 != val) {
 343                                 _E("Failed to call dbus method(%s): Return fail.", METHOD_BATTERY_SETLOWBATLEVEL);
 344                                 goto out;
 345                         }
 346                 }
 347         }
 348
 349         if (!get_battery_low_level(&getlevel))   {
 350                 _E("Failed to get battery low level.");
 351         } else {
 352                 if (getlevel == newlevel) {
 353                         _I("Success : battery low level=%d", newlevel);
 354                         ret = TRUE;
 355                 } else {
 356                         _E("Failed to set low level(%d). Current low level is %d.", newlevel, getlevel);
 357                 }
 358         }
 359 out:
 360         g_variant_unref(msg);
 361         return ret;
 362 }
 363
 364 static bool get_battery_charger_status()
 365 {
 366         return get_battery_method_vconf(METHOD_BATTERY_CHARGERSTATUS);
 367 }
 368
 369 static bool get_battery_charge_now()
 370 {
 371         return get_battery_method(METHOD_BATTERY_CHARGENOW, NULL);
 372 }
 373
 374 static bool get_battery_status_low()
 375 {
 376         return get_battery_method_vconf(METHOD_BATTERY_STATUSLOW);
 377 }
 378
 379 static bool get_battery_percent()
 380 {
 381         return get_battery_method(METHOD_BATTERY_GETPERCENT, NULL);
 382 }
 383
 384 static bool get_battery_percent_raw()
 385 {
 386         return get_battery_method(METHOD_BATTERY_GETPERCENTRAW, NULL);
 387 }
 388
 389 static bool get_battery_is_full()
 390 {
 391         return get_battery_method(METHOD_BATTERY_ISFULL, NULL);
 392 }
 393
 394 static bool get_battery_health()
 395 {
 396         return get_battery_method(METHOD_BATTERY_HEALTH, NULL);
 397 }
 398
 399 static bool get_battery_info()
 400 {
 401         GVariant *msg;
 402         int val[9];
 403         int err;
 404         bool ret = FALSE;
 405         char *argv[3];
 406
 407         err = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
 408                         DEVICED_PATH_BATTERY,
 409                         DEVICED_INTERFACE_BATTERY,
 410                         METHOD_BATTERY_GETINFO, NULL, &msg);
 411         if (err < 0) {
 412                 _E("Failed to call dbus method(%s): No reply", METHOD_BATTERY_GETINFO);
 413                 return ret;
 414         }
 415
 416         if (!g_variant_get_safe(msg, "(isssiiiiiiii)", &val[0],  //return value
 417                                                         &argv[0],//status
 418                                                         &argv[1],//health
 419                                                         &argv[2],//power source
 420                                                         &val[1],  //online
 421                                                         &val[2],  //present
 422                                                         &val[3],  //capacity
 423                                                         &val[4],  //current_now
 424                                                         &val[5], //current_average
 425                                                         &val[6], //voltage_now
 426                                                         &val[7], //voltage_average
 427                                                         &val[8])) //temperature
 428                 _E("Failed to call dbus method(%s): No message", METHOD_BATTERY_GETINFO);
 429         else {
 430                 if (val[0] < 0) {
 431                         _E("Failed to call dbus method(%s): Return fail", METHOD_BATTERY_GETINFO);
 432                 } else {
 433                         _I("Success: %s %s %s %d %d %d %d %d %d %d %d",
 434                                         argv[0], argv[1], argv[2], val[1], val[2],
 435                                         val[3], val[4], val[5], val[6], val[7],
 436                                         val[8]);
 437                         ret = TRUE;
 438                 }
 439                 g_free(argv[0]);
 440                 g_free(argv[1]);
 441                 g_free(argv[2]);
 442         }
 443
 444         g_variant_unref(msg);
 445
 446         return ret;
 447 }
 448
 449 static bool get_battery_info_direct(struct device_battery_info *info)
 450 {
 451         int ret;
 452
 453         ret = device_battery_get_info_direct(info);
 454
 455         return capi_result(METHOD_BATTERY_GETINFO_DIRECT, ret);
 456 }
 457
 458 static int change_charge_status_to_enum(const char *env_value)
 459 {
 460         int len, ret;
 461
 462         if (env_value == NULL)
 463                 return -1;
 464
 465         len = strlen(env_value);
 466         if (strncmp(env_value, CHARGEFULL, len) == 0)
 467                 ret = CHARGE_STATUS_FULL;
 468         else if (strncmp(env_value, CHARGENOW, len) == 0)
 469                 ret = CHARGE_STATUS_CHARGING;
 470         else if (strncmp(env_value, DISCHARGE, len) == 0)
 471                 ret = CHARGE_STATUS_DISCHARGING;
 472         else if (strncmp(env_value, NOTCHARGE, len) == 0)
 473                 ret = CHARGE_STATUS_NOT_CHARGING;
 474         else
 475                 ret = CHARGE_STATUS_UNKNOWN;
 476
 477         return ret;
 478 }
 479
 480 static int change_health_status_to_enum(const char *env_value)
 481 {
 482         int len, ret;
 483
 484         if (env_value == NULL)
 485                 return -1;
 486
 487         len = strlen(env_value);
 488         if (strncmp(env_value, OVERHEAT, len) == 0)
 489                 ret = HEALTH_HIGH;
 490         else if (strncmp(env_value, TEMPCOLD, len) == 0)
 491                 ret = HEALTH_LOW;
 492         else if (strncmp(env_value, OVERVOLT, len) == 0)
 493                 ret = HEALTH_OVP;
 494         else if (strncmp(env_value, GOOD, len) == 0)
 495                 ret = HEALTH_GOOD;
 496         else
 497                 ret = HEALTH_NO_OPT;
 498
 499         return ret;
 500 }
 501
 502 static bool compare_vconf(struct power_supply_type list)
 503 {
 504         int value, ret, temp;
 505         int capacity, online, charge_status;
 506
 507         ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value);
 508         if (ret < 0) {
 509                 _E("Failed to get vconf value for battery charge now: %d", vconf_get_ext_errno());
 510                 return false;
 511         }
 512         if (!strcmp(list.charge_status, CHARGEFULL)) {
 513                 charge_status = CHARGE_STATUS_FULL;
 514                 temp = CHARGER_DISCHARGING;
 515         } else if (!strcmp(list.charge_status, CHARGENOW)) {
 516                 charge_status = CHARGE_STATUS_CHARGING;
 517                 temp = CHARGER_CHARGING;
 518         } else if (!strcmp(list.charge_status, DISCHARGE)) {
 519                 charge_status = CHARGE_STATUS_DISCHARGING;
 520                 temp = CHARGER_DISCHARGING;
 521         } else if (!strcmp(list.charge_status, NOTCHARGE)) {
 522                 charge_status = CHARGE_STATUS_NOT_CHARGING;
 523                 temp = CHARGER_ABNORMAL;
 524         } else {
 525                 charge_status = CHARGE_STATUS_UNKNOWN;
 526                 temp = CHARGER_DISCHARGING;
 527         }
 528         if (temp != value)
 529                 return false;
 530
 531         capacity = atoi(list.capacity);
 532         ret= vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW,  &value);
 533         if (ret < 0) {
 534                 _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno());
 535                 return false;
 536         }
 537         if (capacity <= DEFAULT_REALOFF) {
 538                 if (charge_status == CHARGE_STATUS_CHARGING)
 539                         temp = VCONFKEY_SYSMAN_BAT_POWER_OFF;
 540                 else
 541                         temp = VCONFKEY_SYSMAN_BAT_REAL_POWER_OFF;
 542         } else if (capacity <= DEFAULT_POWEROFF) {
 543                 temp = VCONFKEY_SYSMAN_BAT_POWER_OFF;
 544         } else if (capacity <= DEFAULT_CRITICAL) {
 545                 temp = VCONFKEY_SYSMAN_BAT_CRITICAL_LOW;
 546         } else if (capacity <= DEFAULT_WARNING) {
 547                 temp = VCONFKEY_SYSMAN_BAT_WARNING_LOW;
 548         } else if (capacity >= DEFAULT_NORMAL &&
 549                 charge_status == CHARGE_STATUS_FULL) {
 550                 temp = VCONFKEY_SYSMAN_BAT_FULL;
 551         } else {
 552                 temp = VCONFKEY_SYSMAN_BAT_NORMAL;
 553         }
 554         if (temp != value)
 555                 return false;
 556
 557         ret = vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &value);
 558         if (ret < 0) {
 559                 _E("Failed to get vconf value for charger status: %d", vconf_get_ext_errno());
 560                 return false;
 561         }
 562         online = atoi(list.online);
 563         if (online > atoi(TYPE_BATTERY))
 564                 temp = VCONFKEY_SYSMAN_CHARGER_CONNECTED;
 565         else
 566                 temp = VCONFKEY_SYSMAN_CHARGER_DISCONNECTED;
 567         if (temp != value)
 568                 return false;
 569
 570         ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &value);
 571         if (ret < 0) {
 572                 _E("Failed to get vconf value for battery capacity: %d", vconf_get_ext_errno());
 573                 return false;
 574         }
 575         if (value != capacity)
 576                 return false;
 577
 578         ret = vconf_get_int(VCONFKEY_SYSMAN_CHARGER_TYPE, &value);
 579         if (ret < 0) {
 580                 _E("Failed to get vconf value for charger type: %d", vconf_get_ext_errno());
 581                 return false;
 582         }
 583         if (online <= POWER_SUPPLY_TYPE_BATTERY)
 584                 temp = CHARGER_TYPE_NONE;
 585         else if (online == CHARGER_WIRELESS_TYPE_BT ||
 586                 online == CHARGER_WIRELESS_TYPE_3G)
 587                 temp = CHARGER_TYPE_WIRELESS;
 588         else if (online == CHARGER_INCOMPATIBLE_TYPE)
 589                 temp = CHARGER_TYPE_INCOMPATIBLE;
 590         else if (online == CHARGER_D2D_TYPE)
 591                 temp = CHARGER_TYPE_D2D;
 592         else
 593                 temp = CHARGER_TYPE_WIRE;
 594         if (temp != value)
 595                 return false;
 596
 597         return true;
 598 }
 599
 600 static bool compare_power_supply(struct power_supply_type list, int value[], const char *power_source)
 601 {
 602         if (atoi(list.capacity) != value[0]) {
 603                 _E("Different capacity : %d %d", atoi(list.capacity), value[0]);
 604                 return false;
 605         }
 606
 607         if (change_charge_status_to_enum(list.charge_status) != value[1]) {
 608                 _E("Different charge_status : %d %d", change_charge_status_to_enum(list.charge_status), value[1]);
 609                 return false;
 610         }
 611
 612         if (change_health_status_to_enum(list.health) != value[2]) {
 613                 _E("Different health : %d %d", change_health_status_to_enum(list.health), value[2]);
 614                 return false;
 615         }
 616
 617         if (atoi(list.online) != value[3]) {
 618                 _E("Different online : %d %d", atoi(list.online), value[3]);
 619                 return false;
 620         }
 621
 622         if (atoi(list.present) != value[4]) {
 623                 _E("Different present : %d %d", atoi(list.present), value[4]);
 624                 return false;
 625         }
 626
 627         if (atoi(list.misc) != value[5]) {
 628                 _E("Different misc : %d %d", atoi(list.misc), value[5]);
 629                 return false;
 630         }
 631
 632         if (atoi(list.freq_strength) != value[6]) {
 633                 _E("Different freq_strength : %d %d", atoi(list.freq_strength), value[6]);
 634                 return false;
 635         }
 636
 637         if (strcmp(list.power_source, power_source)) {
 638                 _E("Different power_source : %s %s", list.power_source, power_source);
 639                 return false;
 640         }
 641
 642         if (atoi(list.voltage_now) != value[7]) {
 643                 _E("Different voltage_now : %d %d", atoi(list.voltage_now), value[7]);
 644                 return false;
 645         }
 646
 647         if (atoi(list.voltage_avg) != value[8]) {
 648                 _E("Different voltage_avg : %d %d", atoi(list.voltage_avg), value[8]);
 649                 return false;
 650         }
 651
 652         if (atoi(list.current_now) != value[9]) {
 653                 _E("Different current_now : %d %d", atoi(list.current_now), value[9]);
 654                 return false;
 655         }
 656
 657         if (atoi(list.current_avg) != value[10]) {
 658                 _E("Different current_avg : %d %d", atoi(list.current_avg), value[10]);
 659                 return false;
 660         }
 661
 662         if (atoi(list.temperature) != value[11]) {
 663                 _E("Different temperature : %d %d", atoi(list.temperature), value[11]);
 664                 return false;
 665         }
 666
 667         return true;
 668 }
 669
 670 static bool set_battery_power_supply(int index)
 671 {
 672         GVariant *msg, *var;
 673         int val, err;
 674         bool ret = FALSE;
 675
 676         var = g_variant_new("(sisssssssssssss)", POWER_SUBSYSTEM,
 677                                 13,
 678                                 power_supply_types[index].capacity,
 679                                 power_supply_types[index].charge_status,
 680                                 power_supply_types[index].health,
 681                                 power_supply_types[index].online,
 682                                 power_supply_types[index].present,
 683                                 power_supply_types[index].misc,
 684                                 power_supply_types[index].freq_strength,
 685                                 power_supply_types[index].power_source,
 686                                 power_supply_types[index].voltage_now,
 687                                 power_supply_types[index].voltage_avg,
 688                                 power_supply_types[index].current_now,
 689                                 power_supply_types[index].current_avg,
 690                                 power_supply_types[index].temperature);
 691                                 _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)",
 692                                 power_supply_types[index].capacity,
 693                                 power_supply_types[index].charge_status,
 694                                 power_supply_types[index].health,
 695                                 power_supply_types[index].online,
 696                                 power_supply_types[index].present,
 697                                 power_supply_types[index].misc,
 698                                 power_supply_types[index].freq_strength,
 699                                 power_supply_types[index].power_source,
 700                                 power_supply_types[index].voltage_now,
 701                                 power_supply_types[index].voltage_avg,
 702                                 power_supply_types[index].current_now,
 703                                 power_supply_types[index].current_avg,
 704                                 power_supply_types[index].temperature);
 705
 706         err = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
 707                                                 DEVICED_PATH_BATTERY,
 708                                                 DEVICED_INTERFACE_BATTERY,
 709                                                 POWER_SUBSYSTEM, var, &msg);
 710         if (err < 0) {
 711                 _E("Failed to call dbus method(%s): No reply", POWER_SUBSYSTEM);
 712                 return ret;
 713         }
 714
 715         if (!g_variant_get_safe(msg, "(i)", &val)) {
 716                 _E("Failed to call dbus method(%s): No message", POWER_SUBSYSTEM);
 717                 val = -EBADMSG;
 718         } else {
 719                 if (val < 0) {
 720                         _E("Failed to call dbus method(%s): Return fail(%d)", POWER_SUBSYSTEM, val);
 721                 } else {
 722                         _I("Success. val=%d", val);
 723                         ret = TRUE;
 724                 }
 725         }
 726
 727         g_variant_unref(msg);
 728         sleep(TEST_WAIT_TIME_INTERVAL);
 729
 730         return ret;
 731 }
 732
 733 static bool get_battery_power_supply(int rsp[], char **power_source)
 734 {
 735         GVariant *msg;
 736         int val, err;
 737         bool ret = FALSE;
 738
 739         err = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
 740                         DEVICED_PATH_BATTERY,
 741                         DEVICED_INTERFACE_BATTERY,
 742                         METHOD_BATTERY_GET_POWERSUPPLY, NULL, &msg);
 743         if (err < 0) {
 744                 _E("Failed to call dbus method(%s): No reply", METHOD_BATTERY_GET_POWERSUPPLY);
 745                 return ret;
 746         }
 747
 748         if (!g_variant_get_safe(msg, "(iiiiiiiisiiiii)", &val,  //return value
 749                                                         &rsp[0],        //capacity
 750                                                         &rsp[1],        //charge_status
 751                                                         &rsp[2],        //health
 752                                                         &rsp[3],        //online
 753                                                         &rsp[4],        //present
 754                                                         &rsp[5],        //misc
 755                                                         &rsp[6],        //freq_strength
 756                                                         power_source,   //power_source
 757                                                         &rsp[7],        //voltage_now
 758                                                         &rsp[8],        //voltagge_avg
 759                                                         &rsp[9],        //current_now
 760                                                         &rsp[10],       //current_avg
 761                                                         &rsp[11])) {    //temperature
 762                 _E("Failed to call dbus method(%s): No message", METHOD_BATTERY_GET_POWERSUPPLY);
 763         } else {
 764                 if (val < 0) {
 765                         _E("Failed to call dbus method(%s): Return fail(%d)", METHOD_BATTERY_GET_POWERSUPPLY, val);
 766                 } else {
 767                         _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)",
 768                                 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]);
 769                         ret = true;
 770                 }
 771         }
 772
 773         g_variant_unref(msg);
 774
 775         return ret;
 776 }
 777
 778 static void full_scenario(char *unit, char *capacity, int status)
 779 {
 780         int index;
 781         int len;
 782         int rsp[12];
 783         char *power_source = NULL;
 784
 785         if (!unit || !capacity)
 786                 return;
 787
 788         len = strlen(unit);
 789
 790         for (index = 0; index < ARRAY_SIZE(power_supply_types); index++) {
 791                 if (len != strlen(power_supply_types[index].scenario))
 792                         continue;
 793                 if (strncmp(unit, power_supply_types[index].scenario, len) != 0 ||
 794                     power_supply_types[index].status != status)
 795                         continue;
 796                 power_supply_types[index].capacity = capacity;
 797                 _D("%s", power_supply_types[index].capacity);
 798                 set_battery_power_supply(index);
 799                 get_battery_power_supply(rsp, &power_source);
 800                 compare_power_supply(power_supply_types[index], rsp, power_source);
 801                 compare_vconf(power_supply_types[index]);
 802         }
 803 }
 804
 805 void battery_scenario(char *unit, int status)
 806 {
 807         int index;
 808         int found = 0;
 809         int unit_len;
 810         int rsp[12];
 811         char *power_source = NULL;
 812         const char *scenario = NULL;
 813
 814         if (!unit)
 815                 return;
 816
 817         unit_len = strlen(unit);
 818
 819         for (index = 0; index < ARRAY_SIZE(power_supply_types); index++) {
 820                 if (unit_len != strlen(power_supply_types[index].scenario))
 821                         continue;
 822                 scenario = power_supply_types[index].scenario;
 823                 if (strncmp(unit, scenario, unit_len) != 0 ||
 824                     power_supply_types[index].status != status)
 825                         continue;
 826                 found = 1;
 827                 set_battery_power_supply(index);
 828                 get_battery_power_supply(rsp, &power_source);
 829                 compare_power_supply(power_supply_types[index], rsp, power_source);
 830                 compare_vconf(power_supply_types[index]);
 831         }
 832
 833         if (found)
 834                 return;
 835
 836         index = strlen(unit);
 837         if (index < 0 || index > 3)
 838                 return;
 839
 840         index = strtol(unit, NULL, 10);
 841         if (index < 0 || index > 100)
 842                 return;
 843
 844         for (index = 0; index < ARRAY_SIZE(power_supply_types); index++){
 845                 if (strncmp("capa", power_supply_types[index].scenario, 4) != 0 ||
 846                     power_supply_types[index].status != status)
 847                         continue;
 848                 power_supply_types[index].capacity = unit;
 849                 _D("%s", power_supply_types[index].capacity);
 850                 set_battery_power_supply(index);
 851                 get_battery_power_supply(rsp, &power_source);
 852                 compare_power_supply(power_supply_types[index], rsp, power_source);
 853                 compare_vconf(power_supply_types[index]);
 854         }
 855 }
 856
 857 void battery_test_all(int *success, int *fail)
 858 {
 859         int s = 0;
 860         int f = 0;
 861         int rsp[12];
 862         char *power_source = NULL;
 863         struct device_battery_info info;
 864
 865         (get_battery_time_to_full())    ? s++ : f++;
 866         (get_battery_time_to_empty())   ? s++ : f++;
 867         (get_battery_low_level(NULL))   ? s++ : f++;
 868         (set_battery_low_level(10))     ? s++ : f++;
 869         (set_battery_low_level(50))     ? s++ : f++;
 870         (get_battery_charger_status())  ? s++ : f++;
 871         (get_battery_charge_now())      ? s++ : f++;
 872         (get_battery_status_low())      ? s++ : f++;
 873         (get_battery_percent())         ? s++ : f++;
 874         (get_battery_percent_raw())     ? s++ : f++;
 875         (get_battery_is_full())         ? s++ : f++;
 876         (get_battery_health())          ? s++ : f++;
 877         (get_battery_info())            ? s++ : f++;
 878         (get_battery_info_direct(&info))     ? s++ : f++;
 879
 880         for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) {
 881                 (set_battery_power_supply(index) &&
 882                         get_battery_power_supply(rsp, &power_source) &&
 883                         compare_power_supply(power_supply_types[index], rsp, power_source) &&
 884                         compare_vconf(power_supply_types[index])) ? s++ : f++;
 885         }
 886
 887         if (NULL != success)    *success = s;
 888         if (NULL != fail)       *fail = f;
 889 }
 890
 891 static void battery_init(void *data)
 892 {
 893         int success = 0;
 894         int fail = 0;
 895
 896         _I("Start test.");
 897
 898         battery_test_all(&success, &fail);
 899
 900         _I("Total=%d Success=%d Fail=%d", success+fail, success, fail);
 901 }
 902
 903 static void battery_exit(void *data)
 904 {
 905         _I("End test.");
 906
 907 }
 908
 909 static int battery_unit(int argc, char **argv)
 910 {
 911         int rsp[12];
 912         char *power_source = NULL;
 913         struct device_battery_info info;
 914
 915         if (argc < 4) {
 916                 int success = 0;
 917                 int fail = 0;
 918                 _I("Start test.");
 919                 battery_test_all(&success, &fail);
 920                 _I("Total=%d Success=%d Fail=%d", success+fail, success, fail);
 921         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_TIMETOFULL)) {
 922                 get_battery_time_to_full();
 923         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_TIMETOEMPTY)) {
 924                 get_battery_time_to_empty();
 925         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETLOWBATLEVEL)) {
 926                 get_battery_low_level(NULL);
 927         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_SETLOWBATLEVEL)) {
 928                 set_battery_low_level(atoi(argv[4]));
 929         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_CHARGERSTATUS)) {
 930                 get_battery_charger_status();
 931         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_CHARGENOW)) {
 932                 get_battery_charge_now();
 933         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_STATUSLOW)) {
 934                 get_battery_status_low();
 935         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETPERCENT)) {
 936                 get_battery_percent();
 937         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETPERCENTRAW)) {
 938                 get_battery_percent_raw();
 939         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_ISFULL)) {
 940                 get_battery_is_full();
 941         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_HEALTH)) {
 942                 get_battery_health();
 943         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETINFO)) {
 944                 get_battery_info();
 945         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETINFO_DIRECT)) {
 946                 get_battery_info_direct(&info);
 947         } else if (0 == strcasecmp(argv[3], METHOD_BATTERY_POWERSUPPLY)) {
 948                 for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) {
 949                         set_battery_power_supply(index);
 950                         get_battery_power_supply(rsp, &power_source);
 951                         compare_power_supply(power_supply_types[index], rsp, power_source);
 952                         compare_vconf(power_supply_types[index]);
 953                 }
 954         } else if (argc > 4 && argv[4] && !strncmp("enter", argv[4], 5)) {
 955                         battery_scenario(argv[3], S_ENTER);
 956         } else if (argc > 4 && argv[4] && !strncmp("leave", argv[4], 5)) {
 957                         battery_scenario(argv[3], S_LEAVE);
 958         } else if (argc >5 && argv[5] && !strncmp("enter", argv[5], 5)) {
 959                         full_scenario(argv[3], argv[4], S_ENTER);
 960         } else if (argc >5 && argv[5] && !strncmp("leave", argv[5], 5)) {
 961                         full_scenario(argv[3], argv[5], S_LEAVE);
 962         } else {
 963                 _E("Unknown test case.");
 964         }
 965
 966         return 0;
 967 }
 968
 969 static const struct test_ops battery_test_ops = {
 970         .priority = TEST_PRIORITY_NORMAL,
 971         .name     = "battery",
 972         .init     = battery_init,
 973         .exit    = battery_exit,
 974         .unit    = battery_unit,
 975 };
 976
 977 TEST_OPS_REGISTER(&battery_test_ops)