sqlite3
db-util
capi-system-info
+ capi-system-runtime-info
cynara-client
cynara-session
cynara-creds-gdbus
--- /dev/null
+{
+ "job_scheduler": {
+ "data_collection_period": 600000,
+ "data_collection_try_period": 1000,
+ "data_collection_accept_count": 5,
+ "delete_db_period": 86400000
+ },
+ "cpu_usage_checker": {
+ "timeout": 60000,
+ "initial_threshold": 0.60,
+ "minimum_threshold": 0.50,
+ "threshold_reduction": 0.00
+ }
+}
{
"wifi": {
- "p_wifi_rssi_0": 10,
- "p_wifi_rssi_1": 20,
- "p_wifi_rssi_2": 30,
- "p_wifi_rssi_3": 40,
- "p_wifi_rssi_4": 50,
- "p_wifi_scan": 60,
- "p_wifi_idle": 70,
- "p_wifi_rx": 80,
- "p_wifi_tx": 90
+ "p_wifi_rssi_0": 10.12345,
+ "p_wifi_rssi_1": 20.12345,
+ "p_wifi_rssi_2": 30.12345,
+ "p_wifi_rssi_3": 40.12345,
+ "p_wifi_rssi_4": 50.12345,
+ "p_wifi_scan": 60.12345,
+ "p_wifi_idle": 70.12345,
+ "p_wifi_rx": 80.12345,
+ "p_wifi_tx": 90.12345
},
"bluetooth": {
- "p_bt_idle": 10,
- "p_bt_scan": 12,
- "p_bt_connected": 13,
- "p_bt_rx": 14,
- "p_bt_tx": 15
+ "p_bt_idle": 10.12345,
+ "p_bt_scan": 12.12345,
+ "p_bt_connected": 13.12345,
+ "p_bt_rx": 14.12345,
+ "p_bt_tx": 15.12345
},
"device_network": {
- "p_dnw_sig_strength_0": 20,
- "p_dnw_sig_strength_1": 21,
- "p_dnw_sig_strength_2": 22,
- "p_dnw_sig_strength_3": 23,
- "p_dnw_sig_strength_4": 24,
- "p_dnw_sig_strength_5": 25,
- "p_dnw_sig_strength_6": 26,
- "p_dnw_rx": 21,
- "p_dnw_tx": 22
+ "p_dnw_sig_strength_0": 20.12345,
+ "p_dnw_sig_strength_1": 21.12345,
+ "p_dnw_sig_strength_2": 22.12345,
+ "p_dnw_sig_strength_3": 23.12345,
+ "p_dnw_sig_strength_4": 24.12345,
+ "p_dnw_sig_strength_5": 25.12345,
+ "p_dnw_sig_strength_6": 26.12345,
+ "p_dnw_rx": 21.12345,
+ "p_dnw_tx": 22.12345
},
"display": {
- "p_dp_high": 30,
- "p_dp_medium": 31,
- "p_dp_low": 32
+ "p_dp_high": 30.12345,
+ "p_dp_medium": 31.12345,
+ "p_dp_low": 32.12345
},
"gps_sensor": {
- "p_gps_inuse": 40
+ "p_gps_inuse": 40.12345
},
"hrm_Sensor": {
- "p_hrm_inuse": 50
+ "p_hrm_inuse": 50.12345
},
"cpu": {
- "p_cpu_user": 60,
- "p_cpu_system": 61
+ "p_cpu_user": 60.12345,
+ "p_cpu_system": 61.12345
},
"battery": {
"p_battery": 500
#define BM_ENUM_ID_TO_STR(x) case (x): EXIT; return (#x);
#define BM_RESOURCE_ID_TO_STR(x, y) case (x): EXIT; return (y);
-/* job-scheduler macros */
-#define BATTERY_MONITOR_GET_DATA_JOB_PERIOD 180000 /* (3*60*1000) interval of 3mins */
-#define BATTERY_MONITOR_DELETE_DB_JOB_PERIOD 86400000 /* (24*60*60*1000) interval of 24hrs */
-
#define BM_PLUGIN_CONST_BATTERY 7
-/* power-param config file macro */
-#define BATTERY_MONITOR_CONFIG_FILE_PATH "/usr/etc/batterymonitor/config/bm_power_profile_params.json"
+/* config file macro */
+#define BATTERY_MONITOR_CONFIG_FILE_PATH "/usr/etc/batterymonitor/config/bm_params.json"
+#define BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH "/usr/etc/batterymonitor/config/bm_power_profile_params.json"
/* privilege macro */
#define BATTERY_MONITOR_PRIVILEGE "http://tizen.org/privilege/systemmonitor"
extern "C" {
#endif
-int bm_get_wifi_power_params(int *rssi_l0, int *rssi_l1, int *rssi_l2, int *rssi_l3, int *rssi_l4,
- int *scan, int *idle, int *rx, int *tx);
+int bm_get_wifi_power_params(double *rssi_l0, double *rssi_l1, double *rssi_l2, double *rssi_l3, double *rssi_l4,
+ double *scan, double *idle, double *rx, double *tx);
-int bm_get_blutooth_power_params(int *idle, int *scan, int *connected, int *rx, int *tx);
+int bm_get_blutooth_power_params(double *idle, double *scan, double *connected, double *rx, double *tx);
-int bm_get_device_network_power_params(int *signal_strength0, int *signal_strength1, int *signal_strength2,
- int *signal_strength3, int *signal_strength4, int *signal_strength5,
- int *signal_strength6, int *rx, int *tx);
+int bm_get_device_network_power_params(double *signal_strength0, double *signal_strength1, double *signal_strength2,
+ double *signal_strength3, double *signal_strength4, double *signal_strength5,
+ double *signal_strength6, double *rx, double *tx);
-int bm_get_display_power_params(int *high, int *medium, int *low);
+int bm_get_display_power_params(double *high, double *medium, double *low);
#ifdef DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN
-int bm_get_gps_sensor_power_params(int *gps_use);
+int bm_get_gps_sensor_power_params(double *gps_use);
-int bm_get_hrm_sensor_power_params(int *hrm_use);
+int bm_get_hrm_sensor_power_params(double *hrm_use);
#endif /* DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN */
-int bm_get_cpu_power_params(int *fg, int *bg);
+int bm_get_cpu_power_params(double *fg, double *bg);
int bm_get_battery_power_params(int *battery);
+int bm_get_job_scheduler_params(int *data_collection_period, int *data_collection_try_period, int *data_collection_accept_count, int *delete_db_period);
+
+int bm_get_cpu_usage_checker_params(int *timeout, double *initial_threshold, double *minimum_threshold, double *threshold_reduction);
+
#ifdef __cplusplus
}
#endif
#define BM_SLOGE(fmt, arg...) SECURE_LOGE(": " fmt "\n", ##arg);
+#if 0
#define ENTER dlog_print(DLOG_DEBUG, LOG_TAG, "%s : %s(%d) >>>>>>>> CALLED", rindex(__FILE__, '/') + 1, __func__, __LINE__)
-
#define EXIT dlog_print(DLOG_DEBUG, LOG_TAG, "%s : %s(%d) <<<<<<<< ENDED", rindex(__FILE__, '/') + 1, __func__, __LINE__)
+#else
+#define ENTER
+#define EXIT
+#endif
#ifdef __cplusplus
}
uint time_level_2; /**< Total time in milliseconds during which rssi was on level 2 */
uint time_level_3; /**< Total time in milliseconds during which rssi was on level 3 */
uint time_level_4; /**< Total time in milliseconds during which rssi was on level 4 */
+ uint rxTime; /**< Total time in milliseconds (RX) mode */
+ uint txTime; /**< Total time in milliseconds (TX) mode */
time_t startTime; /**< start time of feature data collection session */
time_t endTime; /**< end time of feature data collection session */
uint scanTime; /**< Total time spent by the resource in (scan) mode during the session */
void bm_resourceid_usage_free(resourceid_usage_s *data);
-long int bm_get_log_time();
+long int bm_get_log_time(int bias);
void bm_set_free_atm_st2_list(GSList *atm_list);
BuildRequires: cmake
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(capi-system-info)
+BuildRequires: pkgconfig(capi-system-runtime-info)
BuildRequires: pkgconfig(glib-2.0) >= 2.26
BuildRequires: pkgconfig(gio-2.0)
BuildRequires: pkgconfig(gio-unix-2.0)
%install
%make_install
mkdir -p %{buildroot}/usr/etc/batterymonitor/config
+cp config/bm_params.json %{buildroot}%{power_profile_config_path}/bm_params.json
cp config/bm_power_profile_params.json %{buildroot}%{power_profile_config_path}/bm_power_profile_params.json
mkdir -p %{buildroot}%{_sysconfdir}/dbus-1/system.d
%defattr(-,root,root)
%attr(755,-,-) %{_bindir}/batterymonitor-svcd
%config %{_sysconfdir}/dbus-1/system.d/org.tizen.battery.monitor.conf
+%config %attr(755,root,root) %{power_profile_config_path}/bm_params.json
%config %attr(755,root,root) %{power_profile_config_path}/bm_power_profile_params.json
%attr(644,root,root) %{_datadir}/dbus-1/system-services/*
%attr(644,root,root) %{_unitdir}/batterymonitor.service
</policy>
<policy context="default">
<deny own="org.tizen.battery.monitor"/>
- <deny send_destination="org.tizen.battery.monitor"/>
+ <deny send_destination="org.tizen.battery.monitor" send_interface="org.tizen.battery.monitor"/>
+ <allow send_destination="org.tizen.battery.monitor" send_type="signal" />
<check send_destination="org.tizen.battery.monitor" send_interface="org.tizen.battery.monitor"
send_member="get_mah_usage_by_app_id_for_resource_id_custom_interval" privilege="http://tizen.org/privilege/systemmonitor"/>
dump_p = g_string_sized_new(30);
BM_CHECK_MEM_ALLOC(dump_p, {});
+
g_string_append(dump_p, TIZEN_DUMP_VERSION);
// Power Capacity
g_string_append_printf(dump_p, ",0,l,pws,%d,0,0,0", battery_capacity);
g_string_append(dump_p, "\n");
+
_DBG("%s", dump_p->str);
+
if (write(fd, dump_p->str, dump_p->len) < 0)
_WARN("write error");
+
g_string_free(dump_p, TRUE);
g_hash_table_iter_init(&iter, app_map);
return ret;
}
-static int bd_get_and_print_gn_stat_entry_from_dump(int fd, long int duration)
+static int bd_get_and_print_misc_stat_entry_from_dump(int fd, long int duration)
{
ENTER;
+ //Dump screen on and off time
+ //Modify m - field accordingly.
+ bd_gl_sbr_stat_s *gbr_stat = (bd_gl_sbr_stat_s *)calloc(1, sizeof(bd_gl_sbr_stat_s));
+ BM_CHECK_MEM_ALLOC(gbr_stat, {});
int ret = BATTERY_MONITOR_ERROR_NONE;
+ ret = bm_server_battery_dump_query_from_db(gbr_stat, 3, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("Unable to fetch data from DB");
+ BM_FREE(gbr_stat);
+ return ret;
+ }
+
+ GString *dump_p = g_string_sized_new(30);
+ BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gbr_stat); });
+ g_string_append(dump_p, TIZEN_DUMP_VERSION);
+ g_string_append(dump_p, ",0,l,");
+ g_string_append(dump_p, "m,");
+ long int off_time = gbr_stat->dark;
+ long int on_time = (gbr_stat->dim + gbr_stat->medium + gbr_stat->bright);
+ g_string_append_printf(dump_p, "%ld,", on_time);
+ g_string_append_printf(dump_p, "%ld", off_time);
+ g_string_append(dump_p, "\n");
+ _DBG("%s", dump_p->str);
+ if (write(fd, dump_p->str, dump_p->len) < 0)
+ _WARN("write error");
+ g_string_free(dump_p, TRUE);
+ BM_FREE(gbr_stat);
+
+ EXIT;
+ return ret;
+}
+
+static int bd_get_and_print_gn_stat_entry_from_dump(int fd, long int duration)
+{
+ ENTER;
// Dump Network Data
bd_gl_ntw_stat_s *gn_stat = (bd_gl_ntw_stat_s *)calloc(1, sizeof(bd_gl_ntw_stat_s));
BM_CHECK_MEM_ALLOC(gn_stat, {});
-
+ int ret = BATTERY_MONITOR_ERROR_NONE;
ret = bm_server_battery_dump_query_from_db(gn_stat, 2, duration);
if (ret != BATTERY_MONITOR_ERROR_NONE) {
_ERR("Unable to fetch data from DB");
g_string_append(dump_p, "\n");
_DBG("%s", dump_p->str);//write
-
if (write(fd, dump_p->str, dump_p->len) < 0)
_WARN("write error");
static int bd_get_and_print_gcpu_stat_entry_from_dump(int fd, long int duration)
{
ENTER;
- bd_gl_cpu_stat_s *gcpu_stat = (bd_gl_cpu_stat_s *)calloc(1, sizeof(bd_gl_cpu_stat_s));
- BM_CHECK_MEM_ALLOC(gcpu_stat, {});
int ret = BATTERY_MONITOR_ERROR_NONE;
const char *rid_str = NULL; int usage = 0;
bm_server_query_resource_usage_resourceid(rid_str, 1, &ret);
if (res_use == NULL || ret != BATTERY_MONITOR_ERROR_NONE) {
_ERR("For resourceid %s", rid_str);
- _DBG("Dump only system stats");
+ return ret;
}
usage = res_use->usage;
float usagemah = (float)usage/3600;
+ bd_gl_cpu_stat_s *gcpu_stat = (bd_gl_cpu_stat_s *)calloc(1, sizeof(bd_gl_cpu_stat_s));
+ BM_CHECK_MEM_ALLOC(gcpu_stat, {BM_FREE(res_use); });
ret = bm_server_battery_dump_query_from_db(gcpu_stat, 7, duration);
if (ret != BATTERY_MONITOR_ERROR_NONE) {
_ERR("Unable to fetch data from DB");
BM_FREE(res_use);
return ret;
}
+
GString *dump_p = g_string_sized_new(30);
- BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gcpu_stat); BM_FREE(res_use);});
+ BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gcpu_stat); BM_FREE(res_use); });
g_string_append(dump_p, TIZEN_DUMP_VERSION);
g_string_append(dump_p, ",0,l,");
g_string_append(dump_p, "cpu,");
_DBG("%s", dump_p->str);
if (write(fd, dump_p->str, dump_p->len) < 0)
_WARN("write error");
+
g_string_free(dump_p, TRUE);
+ BM_FREE(gcpu_stat);
EXIT;
return ret;
if (write(fd, dump_tmp_p->str, dump_tmp_p->len) < 0)
_WARN("write error");
- g_free(dump_tmp_p->str);
+ g_string_free(dump_tmp_p, TRUE);
- //Dump i & l values after this
- ret = bd_get_and_print_uid_info_entry_from_dump(fd);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("UID data dump failed");
- // Get Last charge time to dump "l" field
- // for the time being dumping all data
- long int duration = 0; //Time of last charge
- ret = bd_get_and_print_gn_stat_entry_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("GN dump failed");
- ret = bd_get_and_print_gwf_stat_entry_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("GWF data dump failed");
- ret = bd_get_and_print_gble_stat_entry_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("GBL data dump failed");
- ret = bd_get_and_print_gbr_stat_entry_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("GBR data dump failed");
- ret = bd_get_and_print_gst_stat_entry_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("GST data dump failed");
- ret = bd_get_and_print_gwst_stat_entry_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("GWST data dump failed");
- ret = bd_get_and_print_gcpu_stat_entry_from_dump(fd, duration);
- _ERR("GCPU data dump failed");
- // Battery Usage Dump
- // Add usage for each of the resource
- // and each of the application
- ret = bd_get_and_print_battery_usage_from_dump(fd, duration);
- if (ret != BATTERY_MONITOR_ERROR_NONE)
- _ERR("Battery Usage failed");
+ //Dump i & l values after this
+ ret = bd_get_and_print_uid_info_entry_from_dump(fd);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("UID data dump failed");
+ // Get Last charge time to dump "l" field
+ // for the time being dumping all data
+ long int duration = 0; //Time of last charge
+ ret = bd_get_and_print_gn_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GN dump failed");
+ ret = bd_get_and_print_gwf_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GWF data dump failed");
+ ret = bd_get_and_print_gble_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GBL data dump failed");
+ ret = bd_get_and_print_gbr_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GBR data dump failed");
+ ret = bd_get_and_print_gst_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GST data dump failed");
+ ret = bd_get_and_print_gwst_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GWST data dump failed");
+ ret = bd_get_and_print_gcpu_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("GCPU data dump failed");
+ ret = bd_get_and_print_misc_stat_entry_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("MISc data dump failed");
+ // Battery Usage Dump
+ // Add usage for each of the resource
+ // and each of the application
+ ret = bd_get_and_print_battery_usage_from_dump(fd, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Battery Usage failed");
- _DBG("DUMP COMPLETED/DELETE HASH TABLE");
+ _DBG("DUMP COMPLETED/DELETE HASH TABLE");
- g_hash_table_destroy(app_map);
- h_flag = true;
- EXIT;
- return BATTERY_MONITOR_ERROR_NONE;
+ g_hash_table_destroy(app_map);
+ h_flag = true;
+
+ EXIT;
+ return BATTERY_MONITOR_ERROR_NONE;
}
static int bd_dump_data_item_reset(dump_data_s* old_state)
goto END;
}
- _INFO("read [%zd] bytes from [%s]", len, file_name);
+ _DBG("read [%zd] bytes from [%s]", len, file_name);
EXIT;
return (char *)contents;
return NULL;
}
-int bm_get_wifi_power_params(int *rssi_l0, int *rssi_l1, int *rssi_l2, int *rssi_l3,
- int *rssi_l4, int *scan, int *idle, int *rx, int *tx)
+int bm_get_wifi_power_params(double *rssi_l0, double *rssi_l1, double *rssi_l2, double *rssi_l3,
+ double *rssi_l4, double *scan, double *idle, double *rx, double *tx)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(rssi_l0);
BM_CHECK_INPUT_PARAM(rssi_l1);
BM_CHECK_INPUT_PARAM(rx);
BM_CHECK_INPUT_PARAM(tx);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_wifi_rssi_0", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_rssi_0", &jdouble);
+ if (!jdouble)
goto END;
- *rssi_l0 = json_object_get_int(jint);
+ *rssi_l0 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_rssi_1", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_rssi_1", &jdouble);
+ if (!jdouble)
goto END;
- *rssi_l1 = json_object_get_int(jint);
+ *rssi_l1 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_rssi_2", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_rssi_2", &jdouble);
+ if (!jdouble)
goto END;
- *rssi_l2 = json_object_get_int(jint);
+ *rssi_l2 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_rssi_3", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_rssi_3", &jdouble);
+ if (!jdouble)
goto END;
- *rssi_l3 = json_object_get_int(jint);
+ *rssi_l3 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_rssi_4", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_rssi_4", &jdouble);
+ if (!jdouble)
goto END;
- *rssi_l4 = json_object_get_int(jint);
+ *rssi_l4 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_scan", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_scan", &jdouble);
+ if (!jdouble)
goto END;
- *scan = json_object_get_int(jint);
+ *scan = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_idle", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_idle", &jdouble);
+ if (!jdouble)
goto END;
- *idle = json_object_get_int(jint);
+ *idle = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_rx", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_rx", &jdouble);
+ if (!jdouble)
goto END;
- *rx = json_object_get_int(jint);
+ *rx = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_wifi_tx", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_wifi_tx", &jdouble);
+ if (!jdouble)
goto END;
- *tx = json_object_get_int(jint);
+ *tx = json_object_get_double(jdouble);
- _DBG("wifi power params - rssi_0[%d], rssi_1[%d], rssi_2[%d], \
- rssi_3[%d], rssi_4[%d], scan[%d], idle[%d], rx[%d], tx[%d]", \
+ _DBG("wifi power params - rssi_0[%lf], rssi_1[%lf], rssi_2[%lf], \
+ rssi_3[%lf], rssi_4[%lf], scan[%lf], idle[%lf], rx[%lf], tx[%lf]", \
*rssi_l0, *rssi_l1, *rssi_l2, *rssi_l3, *rssi_l4, *scan, \
*idle, *rx, *tx);
return ret;
}
-int bm_get_blutooth_power_params(int *idle, int *scan, int *connected, int *rx, int *tx)
+int bm_get_blutooth_power_params(double *idle, double *scan, double *connected,
+ double *rx, double *tx)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(idle);
BM_CHECK_INPUT_PARAM(scan);
BM_CHECK_INPUT_PARAM(rx);
BM_CHECK_INPUT_PARAM(tx);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_bt_idle", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_bt_idle", &jdouble);
+ if (!jdouble)
goto END;
- *idle = json_object_get_int(jint);
+ *idle = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_bt_scan", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_bt_scan", &jdouble);
+ if (!jdouble)
goto END;
- *scan = json_object_get_int(jint);
+ *scan = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_bt_connected", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_bt_connected", &jdouble);
+ if (!jdouble)
goto END;
- *connected = json_object_get_int(jint);
+ *connected = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_bt_rx", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_bt_rx", &jdouble);
+ if (!jdouble)
goto END;
- *rx = json_object_get_int(jint);
+ *rx = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_bt_tx", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_bt_tx", &jdouble);
+ if (!jdouble)
goto END;
- *tx = json_object_get_int(jint);
+ *tx = json_object_get_double(jdouble);
- _DBG("bluetooth power params - idle[%d], scan[%d], connected[%d], \
- rx[%d], tx[%d]", *idle, *scan, *connected, *rx, *tx);
+ _DBG("bluetooth power params - idle[%lf], scan[%lf], connected[%lf], \
+ rx[%lf], tx[%lf]", *idle, *scan, *connected, *rx, *tx);
ret = BATTERY_MONITOR_ERROR_NONE;
END:
return ret;
}
-int bm_get_device_network_power_params(int *signal_strength0, int *signal_strength1, int *signal_strength2,
- int *signal_strength3, int *signal_strength4, int *signal_strength5,
- int *signal_strength6, int *rx, int *tx)
+int bm_get_device_network_power_params(double *signal_strength0, double *signal_strength1,
+ double *signal_strength2, double *signal_strength3, double *signal_strength4,
+ double *signal_strength5, double *signal_strength6, double *rx, double *tx)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(signal_strength0);
BM_CHECK_INPUT_PARAM(signal_strength1);
BM_CHECK_INPUT_PARAM(rx);
BM_CHECK_INPUT_PARAM(tx);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_0", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_0", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength0 = json_object_get_int(jint);
+ *signal_strength0 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_1", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_1", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength1 = json_object_get_int(jint);
+ *signal_strength1 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_2", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_2", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength2 = json_object_get_int(jint);
+ *signal_strength2 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_3", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_3", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength3 = json_object_get_int(jint);
+ *signal_strength3 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_4", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_4", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength4 = json_object_get_int(jint);
+ *signal_strength4 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_5", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_5", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength5 = json_object_get_int(jint);
+ *signal_strength5 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_sig_strength_6", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_sig_strength_6", &jdouble);
+ if (!jdouble)
goto END;
- *signal_strength6 = json_object_get_int(jint);
+ *signal_strength6 = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_rx", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_rx", &jdouble);
+ if (!jdouble)
goto END;
- *rx = json_object_get_int(jint);
+ *rx = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dnw_tx", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dnw_tx", &jdouble);
+ if (!jdouble)
goto END;
- *tx = json_object_get_int(jint);
+ *tx = json_object_get_double(jdouble);
- _DBG("device-network power params - signal_strength0[%d], signal_strength1[%d], signal_strength2[%d], \
- signal_strength3[%d], signal_strength4[%d], signal_strength5[%d], signal_strength6[%d], rx[%d], \
- tx[%d]", *signal_strength0, *signal_strength1, *signal_strength2, *signal_strength3, \
- *signal_strength4, *signal_strength5, *signal_strength6, *rx, *tx);
+ _DBG("device-network params - signal_strength [%lf, %lf, %lf, %lf, %lf, %lf, %lf], \
+ rx[%lf], tx[%lf]", *signal_strength0, *signal_strength1, *signal_strength2,
+ *signal_strength3, *signal_strength4, *signal_strength5, *signal_strength6,
+ *rx, *tx);
ret = BATTERY_MONITOR_ERROR_NONE;
END:
return ret;
}
-int bm_get_display_power_params(int *high, int *medium, int *low)
+int bm_get_display_power_params(double *high, double *medium, double *low)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(high);
BM_CHECK_INPUT_PARAM(medium);
BM_CHECK_INPUT_PARAM(low);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_dp_high", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dp_high", &jdouble);
+ if (!jdouble)
goto END;
- *high = json_object_get_int(jint);
+ *high = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dp_medium", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dp_medium", &jdouble);
+ if (!jdouble)
goto END;
- *medium = json_object_get_int(jint);
+ *medium = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_dp_low", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_dp_low", &jdouble);
+ if (!jdouble)
goto END;
- *low = json_object_get_int(jint);
+ *low = json_object_get_double(jdouble);
- _DBG("display power params - high[%d], medium[%d], low[%d]",
- *high, *medium, *low);
+ _DBG("display power params - high[%lf], medium[%lf], low[%lf]",
+ *high, *medium, *low);
ret = BATTERY_MONITOR_ERROR_NONE;
END:
}
#ifdef DISABLE_FEATURE_DATA_FROM_GPS_HRM
-int bm_get_gps_sensor_power_params(int *gps_use)
+int bm_get_gps_sensor_power_params(double *gps_use)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(gps_use);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_gps_inuse", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_gps_inuse", &jdouble);
+ if (!jdouble)
goto END;
- *gps_use = json_object_get_int(jint);
+ *gps_use = json_object_get_double(jdouble);
- _DBG("gps-sensor power params - gps[%d]", *gps_use);
+ _DBG("gps-sensor power params - gps[%lf]", *gps_use);
ret = BATTERY_MONITOR_ERROR_NONE;
END:
return ret;
}
-int bm_get_hrm_sensor_power_params(int *hrm_use)
+int bm_get_hrm_sensor_power_params(double *hrm_use)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(hrm_use);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_hrm_inuse", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_hrm_inuse", &jdouble);
+ if (!jdouble)
goto END;
- *hrm_use = json_object_get_int(jint);
+ *hrm_use = json_object_get_double(jdouble);
- _DBG("hrm-sensor power params - gps[%d]", *hrm_use);
+ _DBG("hrm-sensor power params - gps[%lf]", *hrm_use);
ret = BATTERY_MONITOR_ERROR_NONE;
END:
}
#endif /* DISABLE_FEATURE_DATA_FROM_GPS_HRM */
-int bm_get_cpu_power_params(int *user, int *system)
+int bm_get_cpu_power_params(double *user, double *system)
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_INTERNAL;
char *contents = NULL;
- json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+ json_object *jmain = NULL, *jdouble = NULL, *jvalue = NULL;
BM_CHECK_INPUT_PARAM(user);
BM_CHECK_INPUT_PARAM(system);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
if (!jvalue)
goto END;
- json_object_object_get_ex(jvalue, "p_cpu_user", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_cpu_user", &jdouble);
+ if (!jdouble)
goto END;
- *user = json_object_get_int(jint);
+ *user = json_object_get_double(jdouble);
- json_object_object_get_ex(jvalue, "p_cpu_system", &jint);
- if (!jint)
+ json_object_object_get_ex(jvalue, "p_cpu_system", &jdouble);
+ if (!jdouble)
goto END;
- *system = json_object_get_int(jint);
+ *system = json_object_get_double(jdouble);
- _DBG("cpu power params - user[%d], system[%d]", *user, *system);
+ _DBG("cpu power params - user[%lf], system[%lf]", *user, *system);
ret = BATTERY_MONITOR_ERROR_NONE;
END:
BM_CHECK_INPUT_PARAM(battery);
- contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+ contents = bm_read_content_from_file(BATTERY_MONITOR_POWER_PROFILE_CONFIG_FILE_PATH);
BM_RETURN_VAL((contents != NULL), {},
BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
EXIT;
return ret;
}
+
+int bm_get_job_scheduler_params(int *data_collection_period, int *data_collection_try_period,
+ int *data_collection_accept_count, int *delete_db_period)
+{
+ ENTER;
+
+ int ret = BATTERY_MONITOR_ERROR_INTERNAL;
+
+ char *contents = NULL;
+ json_object *jmain = NULL, *jint = NULL, *jvalue = NULL;
+
+ BM_CHECK_INPUT_PARAM(data_collection_period);
+ BM_CHECK_INPUT_PARAM(data_collection_try_period);
+ BM_CHECK_INPUT_PARAM(data_collection_accept_count);
+ BM_CHECK_INPUT_PARAM(delete_db_period);
+
+ contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+
+ BM_RETURN_VAL((contents != NULL), {},
+ BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
+
+ jmain = json_tokener_parse(contents);
+ if (!jmain)
+ goto END;
+
+ json_object_object_get_ex(jmain, "job_scheduler", &jvalue);
+ if (!jvalue)
+ goto END;
+
+ json_object_object_get_ex(jvalue, "data_collection_period", &jint);
+ if (!jint)
+ goto END;
+ *data_collection_period = json_object_get_int(jint);
+
+ json_object_object_get_ex(jvalue, "data_collection_try_period", &jint);
+ if (!jint)
+ goto END;
+ *data_collection_try_period = json_object_get_int(jint);
+
+ json_object_object_get_ex(jvalue, "data_collection_accept_count", &jint);
+ if (!jint)
+ goto END;
+ *data_collection_accept_count = json_object_get_int(jint);
+
+ json_object_object_get_ex(jvalue, "delete_db_period", &jint);
+ if (!jint)
+ goto END;
+ *delete_db_period = json_object_get_int(jint);
+
+ _DBG("job scheduler params - data_collection_period[%d], data_collection_try_period[%d], \
+ data_collection_accept_count[%d], delete_db_period[%d]", *data_collection_period,
+ *data_collection_try_period, *data_collection_accept_count, *delete_db_period);
+
+ ret = BATTERY_MONITOR_ERROR_NONE;
+END:
+ g_free(contents);
+ if (jmain)
+ json_object_put(jmain);
+
+ EXIT;
+ return ret;
+}
+
+int bm_get_cpu_usage_checker_params(int *timeout, double *initial_threshold,
+ double *minimum_threshold, double *threshold_reduction)
+{
+ ENTER;
+
+ int ret = BATTERY_MONITOR_ERROR_INTERNAL;
+
+ char *contents = NULL;
+ json_object *jmain = NULL, *jint = NULL, *jdouble = NULL, *jvalue = NULL;
+
+ BM_CHECK_INPUT_PARAM(timeout);
+ BM_CHECK_INPUT_PARAM(initial_threshold);
+ BM_CHECK_INPUT_PARAM(minimum_threshold);
+ BM_CHECK_INPUT_PARAM(threshold_reduction);
+
+ contents = bm_read_content_from_file(BATTERY_MONITOR_CONFIG_FILE_PATH);
+
+ BM_RETURN_VAL((contents != NULL), {},
+ BATTERY_MONITOR_ERROR_NO_DATA, "failed to read from file");
+
+ jmain = json_tokener_parse(contents);
+ if (!jmain)
+ goto END;
+
+ json_object_object_get_ex(jmain, "cpu_usage_checker", &jvalue);
+ if (!jvalue)
+ goto END;
+
+ json_object_object_get_ex(jvalue, "timeout", &jint);
+ if (!jint)
+ goto END;
+ *timeout = json_object_get_int(jint);
+
+ json_object_object_get_ex(jvalue, "initial_threshold", &jdouble);
+ if (!jdouble)
+ goto END;
+ *initial_threshold = json_object_get_double(jdouble);
+
+ json_object_object_get_ex(jvalue, "minimum_threshold", &jdouble);
+ if (!jdouble)
+ goto END;
+ *minimum_threshold = json_object_get_double(jdouble);
+
+ json_object_object_get_ex(jvalue, "threshold_reduction", &jdouble);
+ if (!jdouble)
+ goto END;
+ *threshold_reduction = json_object_get_double(jdouble);
+
+ _DBG("data collection params - timeout[%d], initial_threshold[%lf], \
+ minimum_threshold[%lf], threshold_reduction[%lf]", *timeout, *initial_threshold,
+ *minimum_threshold, *threshold_reduction);
+
+ ret = BATTERY_MONITOR_ERROR_NONE;
+END:
+ g_free(contents);
+ if (jmain)
+ json_object_put(jmain);
+
+ EXIT;
+ return ret;
+}
const bm_callbacks_st hrm_cb;
#endif
-void bm_populate_callbacks(void)
+inline void bm_populate_callbacks(void)
{
- ENTER;
-
bm_receiver_callbacks[BM_DATA_TYPE_BLE] = &ble_cb;
bm_receiver_callbacks[BM_DATA_TYPE_WIFI] = &wifi_cb;
bm_receiver_callbacks[BM_DATA_TYPE_CPU] = &cpu_cb;
bm_receiver_callbacks[BM_DATA_TYPE_HRM_SENSOR] = &hrm_cb;
#endif /* DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN */
- EXIT;
return;
}
bm_plugin_info_h *bm_plugin = NULL;
const bm_callbacks_st *bm_cb = NULL;
- _INFO("populate callbacks");
-
bm_populate_callbacks();
#ifdef DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN
for (id = BM_PLUGIN_ID_BLE; id < BM_PLUGIN_ID_MAX; ++id) {
#include <device/battery.h>
#include <device/callback.h>
+#include <runtime_info.h>
#include "bm_power_engine.h"
#include "bm_dbg.h"
const double cmah = 3600;
int battery_capacity = 500;
int gtimeo_id[2];
+static int data_collection_period = 600000;
int bm_engine_get_mah_usage_by_app_id_for_resource_id_ci(const gchar* app_id, gint resource_id, gint64 start_time, gint64 end_time, double *battery_usage)
{
BM_RETURN_VAL((resource_id < BM_PLUGIN_ID_MAX), {},
BATTERY_MONITOR_ERROR_INVALID_PARAMETER, "invalid resource-id param");
_DBG("usage requested - app-id[%s], resource_id[%d], start_time [%ld] end_time[%ld]",
- app_id, resource_id, (long int)start_time,(long int)end_time);
+ app_id, resource_id, (long int)start_time, (long int)end_time);
int error = BATTERY_MONITOR_ERROR_NONE;
appid_usage_s *app_usage = bm_server_query_app_usage_by_appid_ci(app_id, start_time, end_time, &error);
EXIT;
return BATTERY_MONITOR_ERROR_NONE;
- EXIT;
}
void bm_engine_set_req_flag_handle(bm_plugin_id_e req_plugin_id, bool value)
int ret_val = BATTERY_MONITOR_ERROR_NONE;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
g_hash_table_iter_init(&iter, gl_hash);
}
}
}
+ // startTime and stopTime use seconds. So, we don't have to convert sesTime
+ conTime /= 1000; rx_time /= 1000; tx_time /= 1000;
/* Read standard Rated Values from Device Spec File/Power Profile File */
- int sP_power_bt_idle = 0, sP_power_bt_scan = 0, sP_power_bt_conn = 0, sP_power_bt_tx = 0, sP_power_bt_rx = 0;
+ double sP_power_bt_idle = 0, sP_power_bt_scan = 0, sP_power_bt_conn = 0, sP_power_bt_tx = 0, sP_power_bt_rx = 0;
ret_val = bm_get_blutooth_power_params(&sP_power_bt_idle, &sP_power_bt_scan, &sP_power_bt_conn, &sP_power_bt_rx, &sP_power_bt_tx);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get bt power params");
- _DBG("received bt power params - idle[%d], scan[%d], connected[%d], rx[%d], tx[%d]",
+ _DBG("received bt power params - idle[%lf], scan[%lf], connected[%lf], rx[%lf], tx[%lf]",
sP_power_bt_idle, sP_power_bt_scan, sP_power_bt_conn, sP_power_bt_tx, sP_power_bt_rx);
/* BT power consumption Level - 1 at the Resource Level */
long int P_power_bt = 0, P_power_data = 0, P_power_conn = 0;
long int P_power_app_bt = 0, P_power_app_data = 0, P_power_app_conn = 0;
char *appid = NULL;
long int apprx = 0, apptx = 0;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
/* Coefficient to divide the rx and tx time wrt rx and tx bytes */
double crtx_t = 0;
_ERR("memory allocation failed");
return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
}
- gbst_st->time_s = ret_time; gbst_st->off_time = BATTERY_MONITOR_GET_DATA_JOB_PERIOD/1000;
+ gbst_st->time_s = ret_time; gbst_st->off_time = data_collection_period / 1000;
gbst_st->off_time -= sesTime; gbst_st->low_time = 0/*(sesTime - (scTime + conTime))*/;
gbst_st->med_time = 0/*scTime*/; gbst_st->high_time = 0/*conTime*/;
ret_val = bm_server_battery_dump_insert_to_db(gbst_st, 6);
g_hash_table_destroy(hash);
/* Dump resource usage */
- _DBG("BLE usage : %ld", RX_system + TX_system + RX_app + TX_app);
+ _DBG("BLE usage : %ld bytes", RX_system + TX_system + RX_app + TX_app);
if (RX_system > 0 || TX_system > 0 || RX_app > 0 || TX_app > 0) {
history_item_s hi;
bd_print_history_item_reset(&hi);
hi.cmd_s = CM_USAGE;
hi.usage_type = USAGE_BLUETOOTH;
- hi.usage = RX_system + TX_system + RX_app + TX_app;
+ hi.usage = (RX_system + TX_system + RX_app + TX_app) / ((double)data_collection_period / 60000); // bytes / minute
bd_store_history_item(&hi);
}
long int sesTime = 0, scTime = 0, tl_total = 0;
long int tl0 = 0, tl1 = 0, tl2 = 0, tl3 = 0, tl4 = 0;
double onTime = 0;
- long int RX = 0, TX = 0;
+ long int RX = 0, TX = 0, rx_time = 0, tx_time = 0;
/* iterating over list for data accumulation */
for (wifi_data_iterator = handle->wifi_data_list; wifi_data_iterator; wifi_data_iterator = wifi_data_iterator->next) {
bm_wifi_st *datalistnode = (bm_wifi_st *)(wifi_data_iterator->data);
edTime = datalistnode->endTime;
stTime = datalistnode->startTime;
- sesTime += edTime - stTime;
+ sesTime += (edTime - stTime);
scTime += datalistnode->scanTime;
- tl0 += datalistnode->time_level_0;
- tl1 += datalistnode->time_level_1;
- tl2 += datalistnode->time_level_2;
- tl3 += datalistnode->time_level_3;
+ tl0 += datalistnode->time_level_0; tl1 += datalistnode->time_level_1;
+ tl2 += datalistnode->time_level_2; tl3 += datalistnode->time_level_3;
tl4 += datalistnode->time_level_4;
+ rx_time += datalistnode->rxTime; tx_time += datalistnode->txTime;
wifi_atm_iterator = datalistnode->atm_list;
for ( ; wifi_atm_iterator; wifi_atm_iterator = wifi_atm_iterator->next) {
app_time_map_st2 *wifi_atm_node = NULL;
}
/* Read standard Rated Values from Device Spec File/Power Profile File */
- int sP_power_wf_idle = 0, sP_power_wf_scan = 0, sP_power_wf_tl0 = 0, sP_power_wf_tl1 = 0, sP_power_wf_tl2 = 0;
- int sP_power_wf_tl3 = 0, sP_power_wf_tl4 = 0, sP_power_wf_tx = 0, sP_power_wf_rx = 0;
+ double sP_power_wf_idle = 0, sP_power_wf_scan = 0, sP_power_wf_tl0 = 0, sP_power_wf_tl1 = 0, sP_power_wf_tl2 = 0;
+ double sP_power_wf_tl3 = 0, sP_power_wf_tl4 = 0, sP_power_wf_tx = 0, sP_power_wf_rx = 0;
ret_val = bm_get_wifi_power_params(&sP_power_wf_tl0, &sP_power_wf_tl1, &sP_power_wf_tl2, &sP_power_wf_tl3,
&sP_power_wf_tl4, &sP_power_wf_scan, &sP_power_wf_idle, &sP_power_wf_rx, &sP_power_wf_tx);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get wifi power params");
- _DBG("received wifi power params - rssi_0[%d], rssi_1[%d], rssi_2[%d], rssi_3[%d], rssi_4[%d], scan[%d], \
- idle[%d], rx[%d], tx[%d]", sP_power_wf_tl0, sP_power_wf_tl1, sP_power_wf_tl2, sP_power_wf_tl3,
+ _DBG("received wifi power params - rssi_0[%lf], rssi_1[%lf], rssi_2[%lf], rssi_3[%lf], rssi_4[%lf], scan[%lf], \
+ idle[%lf], rx[%lf], tx[%lf]", sP_power_wf_tl0, sP_power_wf_tl1, sP_power_wf_tl2, sP_power_wf_tl3,
sP_power_wf_tl4, sP_power_wf_scan, sP_power_wf_idle, sP_power_wf_rx, sP_power_wf_tx);
tl0 /= 1000; tl1 /= 1000; tl2 /= 1000; tl3 /= 1000; tl4 /= 1000;
- scTime /= 1000; sesTime /= 1000; onTime /= 1000;
+ onTime /= 1000;
+ rx_time /= 1000; tx_time /= 1000;
tl_total = tl0 + tl1 + tl2 + tl3 + tl4;
/* Wifi power consumption Level - 1 at the Resource Level */
long int P_power_wifi = 0, P_power_data = 0, P_power_conn = 0;
(sP_power_wf_tl2 * tl2) + (sP_power_wf_tl3 * tl3) +
(sP_power_wf_tl4 * tl4) + (sP_power_wf_scan * scTime) +
(sP_power_wf_idle * (sesTime - (tl_total + scTime))));
- P_power_data = ((sP_power_wf_tx) * TX) + ((sP_power_wf_rx) * RX);
+ /* Amount based usage calculation */
+// P_power_data = ((sP_power_wf_tx) * TX) + ((sP_power_wf_rx) * RX);
+
+ /* Use rx and tx time to calculate the usage */
+ P_power_data = ((sP_power_wf_tx * tx_time) + (sP_power_wf_rx * rx_time));
P_power_wifi = P_power_conn + P_power_data;
_DBG("Calculated Power for Wifi P_power_wifi(%ld), P_power_conn (%ld), P_power_data(%ld)", P_power_wifi, P_power_conn, P_power_data);
long int P_power_app_wifi = 0, P_power_app_data = 0, P_power_app_conn = 0;
char *appid = NULL;
long int apprx = 0, apptx = 0;
- double apptime = 0;
+ double apptime = 0, crx_t = 0, ctx_t = 0;
long int rx_t = 0, tx_t = 0;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
+
+ /* Coefficient to divide the rx and tx time wrt rx and tx bytes */
+ if (RX != 0)
+ crx_t = (double)rx_time/RX;
+ if (TX != 0)
+ ctx_t = (double)tx_time/TX;
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
if (app_usage == NULL) {
apptx = temp->tx; tx_t += apptx;
apptime = temp->time;
apptime /= 1000;
- P_power_app_data = ((sP_power_wf_tx) * apptx) + ((sP_power_wf_rx) * apprx);
+ P_power_app_data = (sP_power_wf_tx * (ctx_t * apptx)) + (sP_power_wf_rx * (crx_t * apprx));
if (onTime != 0)
P_power_app_conn = (P_power_conn * apptime)/onTime; //check for 0 denominator & same units
g_hash_table_destroy(hash);
/* Dump resource usage */
- _DBG("Wi-Fi usage : %ld", RX + TX);
+ _DBG("Wi-Fi usage : %ld bytes", RX + TX);
if (RX > 0 || TX > 0) {
history_item_s hi;
bd_print_history_item_reset(&hi);
- struct timeval tv;
- gettimeofday(&tv, NULL);
-
- hi.time_s = ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000);
-
hi.cmd_s = CM_USAGE;
hi.usage_type = USAGE_WIFI;
- hi.usage = RX + TX;
+ hi.usage = (RX + TX) / ((double)data_collection_period / 60000); // bytes / minute
bd_store_history_item(&hi);
}
}
}
/* Read standard Rated Values from Device Spec File/Power Profile File */
- int sP_power_cpu_user = 0, sP_power_cpu_system = 0;
+ double sP_power_cpu_user = 0, sP_power_cpu_system = 0;
ret_val = bm_get_cpu_power_params(&sP_power_cpu_user, &sP_power_cpu_system);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get cpu power params");
- _DBG("received cpu power params - user[%d]\n, system[%d]\n", sP_power_cpu_user, sP_power_cpu_system);
+ _DBG("received cpu power params - user[%lf]\n, system[%lf]\n", sP_power_cpu_user, sP_power_cpu_system);
/* CPU power consumption Level - 1 at the Resource Level */
long int P_power_cpu = 0, P_power_user = 0, P_power_system = 0;
_DBG("%ld %ld %lf", uTime, sTime, onTime);
long int P_power_app_cpu = 0, P_power_app_use = 0;
double apptime = 0;
char *appid = NULL;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
if (app_usage == NULL) {
}
/* Read standard Rated Values from Device Spec File/Power Profile File */
- int sP_power_dp_low = 0, sP_power_dp_med = 0, sP_power_dp_high = 0;
+ double sP_power_dp_low = 0, sP_power_dp_med = 0, sP_power_dp_high = 0;
ret_val = bm_get_display_power_params(&sP_power_dp_high, &sP_power_dp_med, &sP_power_dp_low);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get cpu power params");
- _DBG("received display power params - high[%d], medium[%d], low[%d]", sP_power_dp_high, sP_power_dp_med, sP_power_dp_low);
+ _DBG("received display power params - high[%lf], medium[%lf], low[%lf]", sP_power_dp_high, sP_power_dp_med, sP_power_dp_low);
/* Display power consumption Level - 1 at the Resource Level */
lowTime /= 1000; medTime /= 1000; highTime /= 1000; onTime /= 1000;
long int P_power_disp = 0, P_power_on = 0;
long int P_power_app_disp = 0, P_power_app_on = 0;
char *appid = NULL;
double apptime = 0;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
if (app_usage == NULL) {
return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
}
- gbr_st->time_s = ret_time; gbr_st->dark = (BATTERY_MONITOR_GET_DATA_JOB_PERIOD/1000);
+ gbr_st->time_s = ret_time; gbr_st->dark = (data_collection_period / 1000);
gbr_st->dark -= sesTime; gbr_st->dim = lowTime; gbr_st->medium = medTime;
gbr_st->bright = highTime;
}
/* Read standard Rated Values from Device Spec File/Power Profile File */
- int sP_power_dn_tl0 = 0, sP_power_dn_tl1 = 0, sP_power_dn_tl2 = 0, sP_power_dn_tl3 = 0, sP_power_dn_tl4 = 0,
+ double sP_power_dn_tl0 = 0, sP_power_dn_tl1 = 0, sP_power_dn_tl2 = 0, sP_power_dn_tl3 = 0, sP_power_dn_tl4 = 0,
sP_power_dn_tl5 = 0, sP_power_dn_tl6 = 0, sP_power_dn_tx = 0, sP_power_dn_rx = 0;
ret_val = bm_get_device_network_power_params(&sP_power_dn_tl0, &sP_power_dn_tl1, &sP_power_dn_tl2, &sP_power_dn_tl3,
&sP_power_dn_tl4, &sP_power_dn_tl5, &sP_power_dn_tl6, &sP_power_dn_rx, &sP_power_dn_tx);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get cpu power params");
- _DBG("received device-network power params - signal_0[%d]\n, signal_1[%d]\n, signal_2[%d]\n, \
- signal_3[%d]\n, signal_4[%d]\n, signal_5[%d]\n, signal_6[%d]\n, rx[%d]\n, tx[%d]\n",
+ _DBG("received device-network power params - signal_0[%lf]\n, signal_1[%lf]\n, signal_2[%lf]\n, \
+ signal_3[%lf]\n, signal_4[%lf]\n, signal_5[%lf]\n, signal_6[%lf]\n, rx[%lf]\n, tx[%lf]\n",
sP_power_dn_tl0, sP_power_dn_tl1, sP_power_dn_tl2, sP_power_dn_tl3, sP_power_dn_tl4, sP_power_dn_tl5,
sP_power_dn_tl6, sP_power_dn_rx, sP_power_dn_tx);
char *appid = NULL;
long int apprx = 0, apptx = 0;
double apptime = 0;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
if (app_usage == NULL) {
}
/* Read standard Rated Values from Device Spec File/Power Profile File */
- int sP_power_gps_conn = 0;
+ double sP_power_gps_conn = 0;
ret_val = bm_get_gps_sensor_power_params(&sP_power_gps_conn);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get gps-sensor power params");
- _DBG("gps-sensor power params - gps[%d]", sP_power_gps_conn);
+ _DBG("gps-sensor power params - gps[%lf]", sP_power_gps_conn);
/* GPS power consumption Level - 1 at the Resource Level */
int P_power_gps = 0, P_power_conn = 0;
P_power_conn = ((sP_power_gps_conn * sesTime));
int P_power_app_gps = 0, P_power_app_conn = 0;
char *appid = NULL;
int apptime = 0;
- long int ret_time = bm_get_log_time();
+ long int ret_time = bm_get_log_time(data_collection_period);
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
if (app_usage == NULL) {
}
}
- int sP_power_hrm_conn = 0;
+ double sP_power_hrm_conn = 0;
/* read hrm-sensor power params */
ret_val = bm_get_hrm_sensor_power_params(&sP_power_hrm_conn);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("failed to get hrm-sensor power params");
- _DBG("hrm-sensor power params - gps[%d]", sP_power_hrm_conn);
+ _DBG("hrm-sensor power params - gps[%lf]", sP_power_hrm_conn);
/* apply power calculation on the hash-map data*/
}
}
- /* parse data which is received through handles */
- ret_val = bm_get_data_from_handles();
- BM_RETURN_VAL((ret_val == BATTERY_MONITOR_ERROR_NONE), {},
- BATTERY_MONITOR_ERROR_INTERNAL, "error in parsing data from handles");
-
EXIT;
return ret_val;
}
return ret_val;
}
+/**
+ * We don't use idle time because it can be decreased
+ * when CPU core is inactive.
+ *
+ * Instead, we will use uptime to calculate CPU usage
+ * CPU_USAGE = (CT_USER + CT_NICE + CT_SYSTEM) / (NUM_CORE * UPTIME)
+ */
+enum cpu_time {
+ CT_USER = 0,
+ CT_NICE,
+ CT_SYSTEM,
+// CT_IDLE,
+ CT_NUM
+};
+
+static int data_collection_try_period = 1000;
+static int data_collection_accept_count = 5;
+static double up_time_last;
+static unsigned long long cpu_time_last[CT_NUM];
+
+int bm_get_cpu_time(unsigned long long cpu_time[CT_NUM])
+{
+ int ret_val = 0;
+ FILE *fp = NULL;
+
+ fp = fopen("/proc/stat", "r");
+ if (!fp) {
+ _ERR("fopen failed : %m");
+ return BATTERY_MONITOR_ERROR_NO_DATA;
+ }
+
+ ret_val = fscanf(fp, "%*s %llu %llu %llu", &cpu_time[CT_USER], &cpu_time[CT_NICE], &cpu_time[CT_SYSTEM]);
+ fclose(fp);
+
+ if (ret_val < CT_NUM) {
+ _ERR("fscanf failed : %m");
+ return BATTERY_MONITOR_ERROR_NO_DATA;
+ }
+
+ return BATTERY_MONITOR_ERROR_NONE;
+}
+
+int bm_get_up_time(double *up_time)
+{
+ int ret_val = 0;
+ FILE *fp = NULL;
+
+ fp = fopen("/proc/uptime", "r");
+ if (!fp) {
+ _ERR("fopen failed : %m");
+ return BATTERY_MONITOR_ERROR_NO_DATA;
+ }
+
+ ret_val = fscanf(fp, "%lf", up_time);
+ fclose(fp);
+
+ if (ret_val < 1) {
+ _ERR("fscanf failed : %m");
+ return BATTERY_MONITOR_ERROR_NO_DATA;
+ }
+
+ return BATTERY_MONITOR_ERROR_NONE;
+}
+
+gboolean is_cpu_idle(void)
+{
+ static gboolean is_parameter_loaded = FALSE;
+ static int timeout = 60000;
+ static double initial_threshold = 0.60;
+ static double minimum_threshold = 0.50;
+ static double threshold_reduction = 0.0;
+ static int num_cpu_core = 1;
+
+ static int remaining_timeout = 60000;
+ static double usage_ratio_threshold = 0.60;
+
+ int idx;
+ unsigned long long cpu_time_cur[CT_NUM];
+ unsigned long long cpu_time_diff[CT_NUM];
+ double up_time_cur;
+ double up_time_diff;
+ double usage_ratio;
+
+ if (!is_parameter_loaded) {
+ if (bm_get_cpu_usage_checker_params(&timeout, &initial_threshold, &minimum_threshold, &threshold_reduction) != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error getting cpu usage checker parameters");
+ return FALSE;
+ }
+ remaining_timeout = timeout;
+ usage_ratio_threshold = initial_threshold;
+
+ if (runtime_info_get_processor_count(&num_cpu_core) != RUNTIME_INFO_ERROR_NONE) {
+ _ERR("error getting the number of cpu core");
+ return FALSE;
+ }
+
+ is_parameter_loaded = TRUE;
+ }
+
+ if (remaining_timeout <= 0) {
+ _DBG("timeout!");
+ goto satisfy;
+ }
+
+ // Get CPU time
+ if (bm_get_cpu_time(cpu_time_cur) != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error getting CPU time");
+ goto unsatisfy;
+ }
+
+ for (idx = 0; idx < CT_NUM; idx++) {
+ if (cpu_time_last[idx] > cpu_time_cur[idx]) {
+ _ERR("error invalid CPU time");
+ goto unsatisfy;
+ }
+ cpu_time_diff[idx] = cpu_time_cur[idx] - cpu_time_last[idx];
+ }
+
+ for (idx = 0; idx < CT_NUM; idx++)
+ cpu_time_last[idx] = cpu_time_cur[idx];
+
+ // Get uptime
+ if (bm_get_up_time(&up_time_cur) != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error getting uptime");
+ goto unsatisfy;
+ }
+
+ if (up_time_last >= up_time_cur) {
+ _ERR("error invalid uptime");
+ goto unsatisfy;
+ }
+
+ up_time_diff = up_time_cur - up_time_last;
+ up_time_last = up_time_cur;
+
+ // Calculate CPU usage
+ usage_ratio = ((double)cpu_time_diff[CT_USER] + cpu_time_diff[CT_NICE] + cpu_time_diff[CT_SYSTEM]) / (up_time_diff * num_cpu_core * 100);
+ if (usage_ratio > 1.0)
+ usage_ratio = 1.0;
+ if (usage_ratio > usage_ratio_threshold) {
+ _WARN("CPU usage = %.2lf%% (BUSY, criteria[%.2lf%%])", usage_ratio * 100, usage_ratio_threshold * 100);
+ goto unsatisfy;
+ }
+
+ _DBG("CPU usage = %.2lf%% (IDLE)", usage_ratio * 100);
+
+satisfy:
+ remaining_timeout = timeout;
+ usage_ratio_threshold = initial_threshold;
+
+ return TRUE;
+
+unsatisfy:
+ remaining_timeout -= data_collection_try_period;
+ if (usage_ratio_threshold > minimum_threshold)
+ usage_ratio_threshold -= threshold_reduction;
+
+ return FALSE;
+}
+
+gboolean bm_try_request_feature_data(gpointer data)
+{
+ enum status {
+ GET_DATA = 0,
+ CALC_AND_STORE,
+ };
+
+ static enum status status = GET_DATA;
+ static int idle_count = 0;
+ int ret_val;
+
+ if (!is_cpu_idle())
+ return G_SOURCE_CONTINUE;
+
+ idle_count++;
+ _DBG("Idle count(%d/%d)", idle_count, data_collection_accept_count);
+ if (idle_count < data_collection_accept_count)
+ return G_SOURCE_CONTINUE;
+
+ idle_count = 0;
+
+ switch (status) {
+ case GET_DATA: // Request data to plugin
+ ret_val = bm_start_getting_feature_data();
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error requesting feature data");
+ return G_SOURCE_CONTINUE;
+ }
+
+ status = CALC_AND_STORE;
+ return G_SOURCE_CONTINUE;
+ case CALC_AND_STORE: // Calculate power consumption and restore to DB
+ ret_val = bm_get_data_from_handles();
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error in parsing data from handles");
+ return G_SOURCE_CONTINUE;
+ }
+
+ status = GET_DATA;
+ return G_SOURCE_REMOVE;
+ default:
+ _ERR("error invalid status");
+ status = GET_DATA;
+ return G_SOURCE_CONTINUE;
+ }
+}
+
gboolean bm_request_feature_data(gpointer data)
{
ENTER;
- int ret_val = BATTERY_MONITOR_ERROR_NONE;
+ int ret_val;
- ret_val = bm_start_getting_feature_data();
- if (ret_val != BATTERY_MONITOR_ERROR_NONE)
- _ERR("error requesting feature data");
+ ret_val = bm_get_cpu_time(cpu_time_last);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error getting cpu time");
+ return G_SOURCE_CONTINUE;
+ }
+
+ ret_val = bm_get_up_time(&up_time_last);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error getting uptime");
+ return G_SOURCE_CONTINUE;
+ }
+
+ g_timeout_add(data_collection_try_period, bm_try_request_feature_data, NULL);
EXIT;
- return true;
+ return G_SOURCE_CONTINUE;
}
gboolean bm_delete_data_from_db(gpointer data)
_ERR("error cleaning database");
EXIT;
- return true;
+ return G_SOURCE_CONTINUE;
}
int initialize_power_engine(void)
ENTER;
int ret_val = BATTERY_MONITOR_ERROR_NONE;
+ int delete_db_period = 86400000;
bm_req_flag_h = (struct bm_req_feature_data_handle_flag_s *)
calloc(1, sizeof(struct bm_req_feature_data_handle_flag_s));
bm_set_req_flag_handles(true);
+ ret_val = bm_get_job_scheduler_params(&data_collection_period, &data_collection_try_period, &data_collection_accept_count, &delete_db_period);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("error getting job scheduler parameters");
+ return ret_val;
+ }
+
+ BM_RETURN_VAL((data_collection_period > 0), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, "invalid data collection period");
+ BM_RETURN_VAL((data_collection_try_period > 0), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, "invalid data collection try period");
+ BM_RETURN_VAL((data_collection_accept_count > 0), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, "invalid data collection accept count");
+ BM_RETURN_VAL((delete_db_period > 0), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, "invalid delete db period");
+
gtimeo_id[0] = 0; gtimeo_id[1] = 0;
- gtimeo_id[0] = g_timeout_add(BATTERY_MONITOR_GET_DATA_JOB_PERIOD, bm_request_feature_data, NULL);
- gtimeo_id[1] = g_timeout_add(BATTERY_MONITOR_DELETE_DB_JOB_PERIOD, bm_delete_data_from_db, NULL);
+ gtimeo_id[0] = g_timeout_add(data_collection_period, bm_request_feature_data, NULL);
+ gtimeo_id[1] = g_timeout_add(delete_db_period, bm_delete_data_from_db, NULL);
_DBG("timeout with id %d and %d added", gtimeo_id[0], gtimeo_id[1]);
ret_val = bm_clean_db_table_for_job_id();
/* plugin-manager de-initialization */
deinitialize_plugin_manager();
- /* cynara deinitialization */
+ /* cynara de-initialization */
deinitialize_cynara();
/* database de-initialization */
return;
}
-long int bm_get_log_time()
+long int bm_get_log_time(int bias)
{
ENTER;
time_t curr_time;
time(&curr_time);
-
- ret = curr_time;
+ bias /= 1000;
+ ret = (curr_time - bias);
EXIT;
return ret;
projects / platform / core / system / batterymonitor.git / commitdiff