#include "bm_plugin_manager.h"
#include "bm_server_db.h"
#include "bm_private.h"
+#include "bd_private.h"
#include "bm_util.h"
bm_feature_data_h bm_data_handle = NULL;
GSList *bt_data_iterator = NULL;
GSList *bt_atm_iterator = NULL;
-
void *prv_data = NULL;
void *prv_app_id = NULL;
-
int ret_val = BATTERY_MONITOR_ERROR_NONE;
/* creating hash-map with (key, value) = (app-id, data) */
long int edTime = 0, stTime = 0;
int sesTime = 0, scTime = 0, conTime = 0, RX = 0, TX = 0, onTime = 0;
-
/* iterating over list for data accumulation */
for (bt_data_iterator = handle->bt_data_list; bt_data_iterator; bt_data_iterator = bt_data_iterator->next) {
-
bm_bluetooth_st *datalistnode = (bm_bluetooth_st *)(bt_data_iterator->data);
-
edTime = datalistnode->stopTime;
stTime = datalistnode->startTime;
scTime += datalistnode->scanTime;
conTime += datalistnode->connectedTime;
sesTime += (edTime-stTime);
-
- //bt_atm_iterator = ((bm_bluetooth_st *)(bt_data_iterator->data))->atm_list;
bt_atm_iterator = datalistnode->atm_list;
-
for ( ; bt_atm_iterator; bt_atm_iterator = bt_atm_iterator->next) {
-
app_time_map_st2 *bt_atm_node = NULL;
bt_atm_node = bt_atm_iterator->data;
-
if (!bt_atm_node) {
_DBG("no data available");
continue;
}
-
_DBG("bt data available");
-
RX += bt_atm_node->rx;
TX += bt_atm_node->tx;
onTime += bt_atm_node->time;
-
prv_data = NULL;
prv_app_id = NULL;
-
if (g_hash_table_lookup_extended(hash, bt_atm_node->app_id, &prv_app_id, &prv_data) == true) {
-
_DBG("previous app_id = %s", (char *)prv_app_id);
-
app_time_map_st2 *temp = (app_time_map_st2 *)prv_data;
-
bt_atm_node->time += temp->time;
bt_atm_node->rx += temp->rx;
bt_atm_node->tx += temp->tx;
-
_DBG("update - app_id(%s), time(%d), rx(%d), tx(%d)", bt_atm_node->app_id,
bt_atm_node->time, bt_atm_node->rx, bt_atm_node->tx);
-
_INFO("updated - %d", g_hash_table_replace(hash, bt_atm_node->app_id, bt_atm_node));
-
} else {
-
_DBG("insert - app_id(%s), time(%d), rx(%d), tx(%d)", bt_atm_node->app_id,
bt_atm_node->time, bt_atm_node->rx, bt_atm_node->tx);
-
_INFO("inserted - %d", g_hash_table_insert(hash, bt_atm_node->app_id, bt_atm_node));
}
}
_DBG("received bt power params - idle[%d], scan[%d], connected[%d], rx[%d], tx[%d]",
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 */
int P_power_bt = 0, P_power_data = 0, P_power_conn = 0;
-
P_power_conn = ((sP_power_bt_idle) * (sesTime - (scTime + conTime))) + ((sP_power_bt_scan) * (scTime)) + ((sP_power_bt_conn) * (conTime));
-
P_power_data = ((sP_power_bt_tx) * TX) + ((sP_power_bt_rx) * RX);
-
P_power_bt = P_power_conn + P_power_data;
_DBG("Calculated Power for Bluetooth P_power_bt(%d), P_power_conn (%d), P_power_data(%d)", P_power_bt, P_power_conn, P_power_data);
-
/* BT power consumption Level - 2 at the Application Level */
GHashTableIter iter;
gpointer key, value;
-
g_hash_table_iter_init(&iter, hash);
int P_power_app_bt = 0, P_power_app_data = 0, P_power_app_conn = 0;
char *appid = NULL;
int apprx = 0, apptx = 0, apptime = 0;
-
+ long int rx_t = 0, tx_t = 0;
long int ret_time = bm_get_log_time();
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
}
while (g_hash_table_iter_next(&iter, &key, &value)) {
-
- P_power_app_bt = 0; P_power_app_data = 0 ; P_power_app_conn = 0;
+ P_power_app_bt = 0, P_power_app_data = 0, P_power_app_conn = 0;
apprx = 0, apptx = 0, apptime = 0;
-
app_time_map_st2 *temp = (app_time_map_st2 *)value;
-
appid = temp->app_id;
- apprx = temp->rx;
- apptx = temp->tx;
+ apprx = temp->rx; rx_t += apprx;
+ apptx = temp->tx; tx_t += apptx;
apptime = temp->time;
-
P_power_app_data = ((sP_power_bt_tx) * apptx) + ((sP_power_bt_rx) * apprx);
-
if (onTime != 0)
P_power_app_conn = (P_power_conn * apptime)/onTime; //check for 0 denominator & same units
P_power_app_bt = P_power_app_data + P_power_app_conn;
app_usage->AppId = appid;
app_usage->rId_ble = P_power_app_bt;
app_usage->log_time = ret_time;
-
/* Call Insert Function */
_DBG("Calculated Power for Appid(%s) - P_power_app_bt(%d), P_power_app_conn(%d), P_power_app_data(%d)",
appid, P_power_app_bt, P_power_app_conn, P_power_app_data);
-
if (mode) {
ret_val = bm_server_appid_insert_to_db(app_usage->AppId);
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
ret_val = bm_server_app_usage_insert_to_db(app_usage);
} else/* Call Global Hash */
ret_val = bm_appid_session_usage_map(g_strdup(app_usage->AppId), app_usage->rId_ble, BM_PLUGIN_ID_BLE);
-
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of BT App failed ");
else
res_usage->usage = P_power_bt;
ret_val = bm_server_resource_usage_insert_to_db(res_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of BT resource failed ");
- else
- _DBG("Insert successful");
bm_appid_usage_free(app_usage);
bm_resourceid_usage_free(res_usage);
+ bd_gl_ble_stat_s *gble_st = (bd_gl_ble_stat_s *)calloc(1, sizeof(bd_gl_ble_stat_s));
+ if (gble_st == NULL) {
+ _ERR("memory allocation failed");
+ return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ }
+ gble_st->time_s = ret_time; gble_st->ble_idle_time = (sesTime - (scTime + conTime));
+ if (tx_t != 0 || rx_t != 0) {
+ gble_st->ble_rx_time = (conTime * rx_t) / (rx_t + tx_t);
+ gble_st->ble_tx_time = (conTime * tx_t) / (rx_t + tx_t);
+ }
+ gble_st->ble_pwi_val = P_power_bt;
+
+ ret_val = bm_server_battery_dump_insert_to_db(gble_st, 0);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Insert of GBLE failed ");
+ else
+ _DBG("Insert successful");
+ BM_FREE(gble_st);
+ //Add bst times
/* Free the hash map */
g_hash_table_destroy(hash);
GSList *wifi_data_iterator = NULL;
GSList *wifi_atm_iterator = NULL;
-
void *prv_data = NULL;
void *prv_app_id = NULL;
-
int ret_val = BATTERY_MONITOR_ERROR_NONE;
/* creating hash-map with (key, value) = (app-id, data) */
GHashTable *hash = g_hash_table_new_full(g_str_hash, g_str_equal, bm_data_free, bm_atm_st2_free);
- long int edTime = 0;
- long int stTime = 0;
- int sesTime = 0;
- int scTime = 0;
+ long int edTime = 0, stTime = 0;
+ int sesTime = 0, scTime = 0, onTime = 0 /*applications*/, tl_total = 0;
int tl0 = 0, tl1 = 0, tl2 = 0, tl3 = 0, tl4 = 0;
- int RX = 0, TX = 0;
- int onTime = 0;
-
+ long int RX = 0, TX = 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;
tl2 += datalistnode->time_level_2;
tl3 += datalistnode->time_level_3;
tl4 += datalistnode->time_level_4;
-
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;
wifi_atm_node = wifi_atm_iterator->data;
-
if (!wifi_atm_node) {
_DBG("no data available");
continue;
}
-
_DBG("wifi data available");
-
RX += wifi_atm_node->rx;
TX += wifi_atm_node->tx;
onTime += wifi_atm_node->time;
-
prv_app_id = NULL;
prv_data = NULL;
-
if (g_hash_table_lookup_extended(hash, wifi_atm_node->app_id, &prv_app_id, &prv_data) == true) {
-
_DBG("previous app_id = %s", (char *)prv_app_id);
-
app_time_map_st2 *temp = (app_time_map_st2 *)prv_data;
-
wifi_atm_node->time += temp->time;
wifi_atm_node->rx += temp->rx;
wifi_atm_node->tx += temp->tx;
-
_DBG("update - app_id(%s), time(%d), rx(%d), tx(%d)", wifi_atm_node->app_id,
wifi_atm_node->time, wifi_atm_node->rx, wifi_atm_node->tx);
-
_INFO("updated - %d", g_hash_table_replace(hash, wifi_atm_node->app_id, wifi_atm_node));
-
} else {
-
_DBG("insert - app_id(%s), time(%d), rx(%d), tx(%d)", wifi_atm_node->app_id,
wifi_atm_node->time, wifi_atm_node->rx, wifi_atm_node->tx);
-
_INFO("inserted - %d", g_hash_table_insert(hash, wifi_atm_node->app_id, wifi_atm_node));
}
}
idle[%d], rx[%d], tx[%d]", 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);
- int tl_total = 0;
-
tl_total = tl0 + tl1 + tl2 + tl3 + tl4;
-
/* Wifi power consumption Level - 1 at the Resource Level */
int P_power_wifi = 0; int P_power_data = 0; int P_power_conn = 0;
-
P_power_conn = ((sP_power_wf_tl0 * tl0) + (sP_power_wf_tl1 * tl1) +
(sP_power_wf_tl2 * tl2) + (sP_power_wf_tl3 * tl3) +
(sP_power_wf_tl4 * tl4) + (sP_power_wf_scan * scTime) +
- (sP_power_wf_idle * tl_total));
-
+ (sP_power_wf_idle * (sesTime - (tl_total + scTime))));
P_power_data = ((sP_power_wf_tx) * TX) + ((sP_power_wf_rx) * RX);
-
P_power_wifi = P_power_conn + P_power_data;
_DBG("Calculated Power for Wifi P_power_wifi(%d), P_power_conn (%d), P_power_data(%d)", P_power_wifi, P_power_conn, P_power_data);
-
/* Wifi power consumption Level - 2 at the Application Level */
GHashTableIter iter;
gpointer key, value;
-
g_hash_table_iter_init(&iter, hash);
int P_power_app_wifi = 0, P_power_app_data = 0, P_power_app_conn = 0;
char *appid = NULL;
int apprx = 0, apptx = 0, apptime = 0;
-
+ long int rx_t = 0, tx_t = 0;
long int ret_time = bm_get_log_time();
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
}
while (g_hash_table_iter_next(&iter, &key, &value)) {
- P_power_app_wifi = 0; P_power_app_data = 0 ; P_power_app_conn = 0;
+ P_power_app_wifi = 0; P_power_app_data = 0; P_power_app_conn = 0;
apprx = 0, apptx = 0, apptime = 0;
-
app_time_map_st2 *temp = (app_time_map_st2 *)value;
-
appid = temp->app_id;
- apprx = temp->rx;
- apptx = temp->tx;
+ apprx = temp->rx; rx_t += apprx;
+ apptx = temp->tx; tx_t += apptx;
apptime = temp->time;
-
P_power_app_data = ((sP_power_wf_tx) * apptx) + ((sP_power_wf_rx) * apprx);
if (onTime != 0)
app_usage->AppId = appid;
app_usage->rId_wifi = P_power_app_wifi;
app_usage->log_time = ret_time;
-
/* Call Insert Function */
_DBG("Calculated Power for Appid(%s) - P_power_app_wifi(%d), P_power_app_conn(%d), P_power_app_data(%d)",
appid, P_power_app_wifi, P_power_app_conn, P_power_app_data);
ret_val = bm_server_app_usage_insert_to_db(app_usage);
} else/* Call Global Hash */
ret_val = bm_appid_session_usage_map(g_strdup(app_usage->AppId), app_usage->rId_wifi, BM_PLUGIN_ID_WIFI);
-
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of Wifi App failed ");
else
res_usage->usage = P_power_wifi;
ret_val = bm_server_resource_usage_insert_to_db(res_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of Wifi resource failed ");
else
bm_appid_usage_free(app_usage);
bm_resourceid_usage_free(res_usage);
+ bd_gl_wifi_stat_s *gwfl_st = (bd_gl_wifi_stat_s *)calloc(1, sizeof(bd_gl_wifi_stat_s));
+ if (gwfl_st == NULL) {
+ _ERR("memory allocation failed");
+ return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ }
+ gwfl_st->time_s = ret_time; gwfl_st->wifi_on_time = sesTime;
+ gwfl_st->wifi_conn_time = tl_total; gwfl_st->wifi_idle_time = (sesTime - (tl_total + scTime));
+ if (tx_t != 0 || rx_t != 0) {
+ gwfl_st->wifi_rx_time = (tl_total * rx_t) / (rx_t + tx_t);
+ gwfl_st->wifi_tx_time = (tl_total * tx_t) / (rx_t + tx_t);
+ }
+ ret_val = bm_server_battery_dump_insert_to_db(gwfl_st, 1);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Insert of GWFL failed ");
+ else
+ _DBG("Insert successful");
+ BM_FREE(gwfl_st);
+ bd_gl_wst_stat_s *gwst_st = (bd_gl_wst_stat_s *)calloc(1, sizeof(bd_gl_wst_stat_s));
+ if (gwst_st == NULL) {
+ _ERR("memory allocation failed");
+ return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ }
+ gwst_st->time_s = ret_time; gwst_st->wscan_time = scTime;
+ gwst_st->wnone_time = tl0; gwst_st->wpoor_time = tl1; gwst_st->wmed_time = tl2;
+ gwst_st->wgood_time = tl3; gwst_st->wgrt_time = tl4;
+ ret_val = bm_server_battery_dump_insert_to_db(gwst_st, 5);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Insert of GWFL failed ");
+ else
+ _DBG("Insert successful");
+ BM_FREE(gwst_st);
+
/* Free the Hash Map */
g_hash_table_destroy(hash);
GSList *cpu_data_iterator = NULL;
GSList *cpu_atm_iterator = NULL;
-
void *prv_data = NULL;
void *prv_app_id = NULL;
-
int ret_val = BATTERY_MONITOR_ERROR_NONE;
/* creating hash-map with (key, value) = (app-id, data) */
int fgTime = 0;
int bgTime = 0;
int onTime = 0;
-
/* iterating over list for data accumulation */
for (cpu_data_iterator = handle->cpu_data_list; cpu_data_iterator; cpu_data_iterator = cpu_data_iterator->next) {
-
bm_cpu_st *datalistnode = (bm_cpu_st *)(cpu_data_iterator->data);
fgTime += datalistnode->cpuTimeForeground;
bgTime += datalistnode->cpuTimeBackground;
-
cpu_atm_iterator = datalistnode->atm_list;
-
for ( ; cpu_atm_iterator; cpu_atm_iterator = cpu_atm_iterator->next) {
app_time_map_st1 *cpu_atm_node = (app_time_map_st1 *)cpu_atm_iterator->data;
if (!cpu_atm_node) {
_DBG("no data available");
continue;
}
-
_DBG("cpu data available");
-
onTime += cpu_atm_node->time;
-
prv_app_id = NULL;
prv_data = NULL;
-
if (g_hash_table_lookup_extended(hash, cpu_atm_node->app_id, &prv_app_id, &prv_data) == true) {
-
_DBG("previous app_id = %s", (char *)prv_app_id);
-
app_time_map_st1 *cpu_atm_prv_node = (app_time_map_st1 *)prv_data;
-
cpu_atm_node->time += cpu_atm_prv_node->time;
-
_DBG("update - app_id(%s), time(%d)", cpu_atm_node->app_id, cpu_atm_node->time);
-
_INFO("updated - %d", g_hash_table_replace(hash, cpu_atm_node->app_id, cpu_atm_node));
-
} else {
-
_DBG("insert - app_id(%s), time(%d)", cpu_atm_node->app_id, cpu_atm_node->time);
-
_INFO("inserted - %d", g_hash_table_insert(hash, cpu_atm_node->app_id, cpu_atm_node));
}
}
_DBG("received cpu power params - fg[%d]\n, bg[%d]\n", sP_power_cpu_fg, sP_power_cpu_bg);
/* CPU power consumption Level - 1 at the Resource Level */
int P_power_cpu = 0, P_power_fg = 0, P_power_bg = 0;
-
P_power_fg = ((sP_power_cpu_fg * fgTime));
P_power_bg = ((sP_power_cpu_bg * bgTime));
-
P_power_cpu = P_power_bg + P_power_fg;
_DBG("Calculated Power for CPU P_power_cpu (%d), P_power_bg (%d), P_power_fg (%d)", P_power_cpu, P_power_bg, P_power_fg);
-
/* CPU power consumption Level - 2 at the Application Level */
GHashTableIter iter;
gpointer key, value;
-
g_hash_table_iter_init(&iter, hash);
int P_power_app_cpu = 0, P_power_app_use = 0;
char *appid = NULL;
int apptime = 0;
-
long int ret_time = bm_get_log_time();
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
while (g_hash_table_iter_next(&iter, &key, &value)) {
P_power_app_cpu = 0; P_power_app_use = 0;
apptime = 0;
-
app_time_map_st1 *temp = (app_time_map_st1 *)value;
-
appid = temp->app_id;
apptime = temp->time;
-
if (onTime != 0)
P_power_app_use = (P_power_cpu * apptime)/onTime; //check for 0 denominator & same units
P_power_app_cpu = P_power_app_use;
app_usage->AppId = appid;
app_usage->rId_cpu = P_power_app_cpu;
app_usage->log_time = ret_time;
-
/* Call Insert Function */
_DBG("Calculated Power for Appid (%s) P_power_app_cpu (%d), P_power_app_use (%d)", appid, P_power_app_cpu, P_power_app_use);
_DBG("Insert successful");
}
- /* commit to database the output after power calculation */
resourceid_usage_s *res_usage = (resourceid_usage_s *)calloc(1, sizeof(resourceid_usage_s));
if (res_usage == NULL) {
_ERR("memory allocation failed");
res_usage->usage = P_power_cpu;
ret_val = bm_server_resource_usage_insert_to_db(res_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of CPU resource failed ");
- else
- _DBG("Insert successful");
bm_appid_usage_free(app_usage);
bm_resourceid_usage_free(res_usage);
GSList *dp_data_iterator = NULL;
GSList *dp_atm_iterator = NULL;
-
void *prv_data = NULL;
void *prv_app_id = NULL;
-
int ret_val = BATTERY_MONITOR_ERROR_NONE;
/* creating hash-map with (key, value) = (app-id, data) */
long int edTime = 0;
long int stTime = 0;
- int sesTime = 0;
-
+ int sesTime = 0, onTime = 0;
int highTime = 0, medTime = 0, lowTime = 0;
- int onTime = 0;
-
/* iterating over list for data accumulation */
for (dp_data_iterator = handle->display_list; dp_data_iterator; dp_data_iterator = dp_data_iterator->next) {
-
bm_display_st *datalistnode = (bm_display_st *)(dp_data_iterator->data);
edTime = datalistnode->stop;
stTime = datalistnode->start;
medTime += datalistnode->med;
lowTime += datalistnode->low;
sesTime += edTime - stTime;
-
dp_atm_iterator = datalistnode->atm_list;
-
for ( ; dp_atm_iterator; dp_atm_iterator = dp_atm_iterator->next) {
-
app_time_map_st1 *dp_atm_node = (app_time_map_st1 *)dp_atm_iterator->data;
-
if (!dp_atm_node) {
_DBG("no data available");
continue;
}
-
_DBG("display data available");
-
onTime += dp_atm_node->time;
-
prv_data = NULL;
prv_app_id = NULL;
-
if (g_hash_table_lookup_extended(hash, dp_atm_node->app_id, &prv_app_id, &prv_data) == true) {
-
_DBG("previous app_id = %s", (char *)prv_app_id);
-
app_time_map_st1 *dp_atm_prv_node = (app_time_map_st1 *)prv_data;
-
dp_atm_node->time += dp_atm_prv_node->time;
-
_DBG("update - app_id(%s), time(%d)", dp_atm_node->app_id, dp_atm_node->time);
-
_INFO("updated - %d", g_hash_table_replace(hash, dp_atm_node->app_id, dp_atm_node));
-
} else {
-
_DBG("insert - app_id(%s), time(%d)", dp_atm_node->app_id, dp_atm_node->time);
-
_INFO("inserted - %d", g_hash_table_insert(hash, dp_atm_node->app_id, dp_atm_node));
}
}
_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);
-
/* Display power consumption Level - 1 at the Resource Level */
int P_power_disp = 0, P_power_on = 0;
P_power_on = ((sP_power_dp_low * lowTime) + (sP_power_dp_med * medTime) * (sP_power_dp_high * highTime));
-
P_power_disp = P_power_on;
_DBG("Calculated Power for Display P_power_disp (%d), P_power_on (%d)", P_power_disp, P_power_on);
-
/* Display power consumption Level - 2 at the Application Level */
GHashTableIter iter;
gpointer key, value;
-
g_hash_table_iter_init(&iter, hash);
int P_power_app_disp = 0, P_power_app_on = 0;
char *appid = NULL;
int apptime = 0;
-
long int ret_time = bm_get_log_time();
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
while (g_hash_table_iter_next(&iter, &key, &value)) {
P_power_app_disp = 0; P_power_app_on = 0;
apptime = 0;
-
app_time_map_st1 *temp = (app_time_map_st1 *)value;
-
appid = temp->app_id;
apptime = temp->time;
app_usage->AppId = appid;
app_usage->rId_display = P_power_app_disp;
app_usage->log_time = ret_time;
-
/* Call Insert Function */
_DBG("Calculated Power for Appid (%s) P_power_app_disp(%d), P_power_app_on (%d)", appid, P_power_app_disp, P_power_app_on);
if (mode) {
res_usage->usage = P_power_disp;
ret_val = bm_server_resource_usage_insert_to_db(res_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of Display resource failed ");
else
_DBG("Insert successful");
-
bm_appid_usage_free(app_usage);
bm_resourceid_usage_free(res_usage);
+ bd_gl_sbr_stat_s *gbr_st = (bd_gl_sbr_stat_s *)calloc(1, sizeof(bd_gl_sbr_stat_s));
+ if (gbr_st == NULL) {
+ _ERR("memory allocation failed");
+ return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ }
+
+ gbr_st->time_s = ret_time; gbr_st->dark = BATTERY_MONITOR_GET_DATA_JOB_PERIOD;
+ gbr_st->dark -= sesTime; gbr_st->dim = lowTime; gbr_st->medium = medTime;
+ gbr_st->bright = highTime;
+
+ ret_val = bm_server_battery_dump_insert_to_db(gbr_st, 3);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Insert of GBR failed ");
+ else
+ _DBG("Insert GBR successful");
+ BM_FREE(gbr_st);
/* Free the Hash Map */
g_hash_table_destroy(hash);
GSList *dn_data_iterator = NULL;
GSList *dn_atm_iterator = NULL;
-
void *prv_data = NULL;
void *prv_app_id = NULL;
-
int ret_val = BATTERY_MONITOR_ERROR_NONE;
/* creating hash-map with (key, value) = (app-id, data) */
GHashTable *hash = g_hash_table_new_full(g_str_hash, g_str_equal, bm_data_free, bm_atm_st2_free);
- /* Session variables for Data accumulation */
int tl0 = 0, tl1 = 0, tl2 = 0, tl3 = 0, tl4 = 0, tl5 = 0, tl6 = 0;
- int RX = 0, TX = 0;
-
+ long int RX = 0, TX = 0, tl_total = 0;
/* iterating over list for data accumulation */
for (dn_data_iterator = handle->dn_data_list; dn_data_iterator; dn_data_iterator = dn_data_iterator->next) {
-
bm_device_network_st *datalistnode = (bm_device_network_st *)(dn_data_iterator->data);
tl0 += datalistnode->time_level_0;
tl1 += datalistnode->time_level_1;
tl4 += datalistnode->time_level_4;
tl5 += datalistnode->time_level_5;
tl6 += datalistnode->time_level_6;
-
dn_atm_iterator = datalistnode->atm_list;
-
for ( ; dn_atm_iterator; dn_atm_iterator = dn_atm_iterator->next) {
-
app_time_map_st2 *dn_atm_node = (app_time_map_st2 *)dn_atm_iterator->data;
-
if (!dn_atm_node) {
_DBG("no data available");
continue;
}
-
_DBG("device-network data available");
-
RX += dn_atm_node->rx;
TX += dn_atm_node->tx;
-
prv_data = NULL;
prv_app_id = NULL;
-
if (g_hash_table_lookup_extended(hash, dn_atm_node->app_id, &prv_app_id, &prv_data) == true) {
-
_DBG("previous app_id = %s", (char *)prv_app_id);
-
app_time_map_st2 *dn_atm_prv_node = (app_time_map_st2 *)prv_data;
-
dn_atm_node->time += dn_atm_prv_node->time;
dn_atm_node->rx += dn_atm_prv_node->rx;
dn_atm_node->tx += dn_atm_prv_node->tx;
-
_DBG("update - app_id(%s), time(%d), rx(%d), tx(%d)", dn_atm_node->app_id,
dn_atm_node->time, dn_atm_node->rx, dn_atm_node->tx);
-
_INFO("updated - %d", g_hash_table_replace(hash, dn_atm_node->app_id, dn_atm_node));
-
} else {
-
_DBG("insert - app_id(%s), time(%d), rx(%d), tx(%d)", dn_atm_node->app_id,
dn_atm_node->time, dn_atm_node->rx, dn_atm_node->tx);
-
_INFO("inserted - %d", g_hash_table_insert(hash, dn_atm_node->app_id, dn_atm_node));
}
}
&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",
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);
- int tl_total = 0;
tl_total = tl0 + tl1 + tl2 + tl3 + tl4 + tl5 + tl6;
-
/* Device Network power consumption Level - 1 at the Resource Level */
int P_power_dntw = 0, P_power_data = 0, P_power_conn = 0;
P_power_conn = ((sP_power_dn_tl0 * tl0) + (sP_power_dn_tl1 * tl1) + (sP_power_dn_tl2 * tl2) + (sP_power_dn_tl3 * tl3) + (sP_power_dn_tl4 * tl4) + (sP_power_dn_tl5 * tl5) + (sP_power_dn_tl6 * tl6));
P_power_data = ((sP_power_dn_tx) * TX) + ((sP_power_dn_rx) * RX);
-
P_power_dntw = P_power_conn + P_power_data;
_DBG("Calculated Power for Device Network P_power_ntw(%d), P_power_conn (%d), P_power_data(%d)", P_power_dntw, P_power_conn, P_power_data);
-
/* Device Network power consumption Level - 2 at the Application Level */
GHashTableIter iter;
gpointer key, value;
-
g_hash_table_iter_init(&iter, hash);
int P_power_app_dntw = 0, P_power_app_data = 0, P_power_app_conn = 0;
char *appid = NULL;
int apprx = 0, apptx = 0, apptime = 0;
-
long int ret_time = bm_get_log_time();
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
while (g_hash_table_iter_next(&iter, &key, &value)) {
P_power_app_dntw = 0; P_power_app_data = 0 ; P_power_app_conn = 0;
apprx = 0, apptx = 0, apptime = 0;
-
app_time_map_st2 *temp = (app_time_map_st2 *)value;
-
appid = temp->app_id;
apprx = temp->rx;
apptx = temp->tx;
apptime = temp->time;
-
P_power_app_data = ((sP_power_dn_tx) * apptx) + ((sP_power_dn_rx) * apprx);
if (tl_total != 0)
P_power_app_conn = (P_power_conn * apptime)/tl_total; //check for 0 denominator & same units
app_usage->AppId = appid;
app_usage->rId_device_network = P_power_app_dntw;
app_usage->log_time = ret_time;
-
/* Call Insert Function */
_DBG("Calculated Power for Appid (%s) P_power_app_dntw(%d), P_power_app_conn (%d), P_power_app_data(%d)", appid, P_power_app_dntw, P_power_app_conn, P_power_app_data);
if (mode) {
ret_val = bm_server_app_usage_insert_to_db(app_usage);
} else
ret_val = bm_appid_session_usage_map(g_strdup(app_usage->AppId), app_usage->rId_device_network, BM_PLUGIN_ID_DEVICE_NETWORK);
-
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of Data Ntwk App failed ");
else
res_usage->usage = P_power_dntw;
ret_val = bm_server_resource_usage_insert_to_db(res_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of Data Network resource failed ");
else
_DBG("Insert successful");
-
bm_appid_usage_free(app_usage);
bm_resourceid_usage_free(res_usage);
+ bd_gl_sgt_stat_s *gst_st = (bd_gl_sgt_stat_s *)calloc(1, sizeof(bd_gl_sgt_stat_s));
+ if (gst_st == NULL) {
+ _ERR("memory allocation failed");
+ return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ }
+
+ gst_st->time_s = ret_time; gst_st->scan_time = tl0; gst_st->none_time = tl1;
+ gst_st->poor_time = tl2; gst_st->med_time = tl3 + tl4;
+ gst_st->good_time = tl5; gst_st->grt_time = tl6;
+ ret_val = bm_server_battery_dump_insert_to_db(gst_st, 4);
+ if (ret_val != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Insert of GWFL failed ");
+ else
+ _DBG("Insert successful");
+ BM_FREE(gst_st);
+
/* Free the Hash Map */
g_hash_table_destroy(hash);
GSList *gps_data_iterator = NULL;
GSList *gps_atm_iterator = NULL;
-
void *prv_data = NULL;
void *prv_app_id = NULL;
-
int ret_val = BATTERY_MONITOR_ERROR_NONE;
/* creating hash-map with (key, value) = (app-id, data) */
long int stTime = 0;
int sesTime = 0;
int onTime = 0;
-
/* iterating over list for data accumulation */
for (gps_data_iterator = handle->gps_data_list; gps_data_iterator; gps_data_iterator = gps_data_iterator->next) {
-
bm_gps_st *datalistnode = (bm_gps_st *)(gps_data_iterator->data);
-
edTime = datalistnode->connStartTime;
stTime = datalistnode->connStopTime;
sesTime = edTime - stTime;
-
gps_atm_iterator = datalistnode->atm_list;
-// gps_atm_iterator = ((bm_gps_st *)(gps_data_iterator->data))->atm_list;
-
for ( ; gps_atm_iterator; gps_atm_iterator = gps_atm_iterator->next) {
-
app_time_map_st1 *gps_atm_node = (app_time_map_st1 *)gps_atm_iterator->data;
-
if (!gps_atm_node) {
_DBG("no bt data available");
continue;
}
-
_DBG("gps data available");
-
onTime += gps_atm_node->time;
-
prv_app_id = NULL;
prv_data = NULL;
-
if (g_hash_table_lookup_extended(hash, gps_atm_node->app_id, &prv_app_id, &prv_data) == true) {
-
_DBG("previous app_id = %s", (char *)prv_app_id);
-
app_time_map_st1 *gps_atm_prv_node = (app_time_map_st1 *)prv_data;
-
gps_atm_node->time += gps_atm_prv_node->time;
-
_DBG("update - app_id(%s), time(%d)", gps_atm_node->app_id, gps_atm_node->time);
-
_INFO("updated - %d", g_hash_table_replace(hash, gps_atm_node->app_id, gps_atm_node));
-
} else {
-
_DBG("insert - app_id(%s), time(%d)", gps_atm_node->app_id, gps_atm_node->time);
-
_INFO("inserted - %d", g_hash_table_insert(hash, gps_atm_node->app_id, gps_atm_node));
}
}
_ERR("failed to get gps-sensor power params");
_DBG("gps-sensor power params - gps[%d]", 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));
/* GPS power consumption Level - 2 at the Application Level */
GHashTableIter iter;
gpointer key, value;
-
g_hash_table_iter_init(&iter, hash);
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();
appid_usage_s *app_usage = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
while (g_hash_table_iter_next(&iter, &key, &value)) {
P_power_app_gps = 0; P_power_app_conn = 0;
apptime = 0;
-
app_time_map_st1 *temp = (app_time_map_st1 *)value;
-
appid = temp->app_id;
apptime = temp->time;
app_usage->AppId = appid;
app_usage->rId_gps = P_power_app_gps;
app_usage->log_time = ret_time;
-
/* Call Insert Function */
_DBG("Calculated Power for Appid (%s) P_power_app_gps (%d), P_power_app_conn (%d)", appid, P_power_app_gps, P_power_app_conn);
ret_val = bm_server_app_usage_insert_to_db(app_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of GPS App failed ");
else
res_usage->usage = P_power_gps;
ret_val = bm_server_resource_usage_insert_to_db(res_usage);
- /* Error Check */
if (ret_val != BATTERY_MONITOR_ERROR_NONE)
_ERR("Insert of GPS resource failed ");
else
#include <tzplatform_config.h>
#include "bm_private.h"
+#include "bd_private.h"
#include "bm_server_db.h"
#include "bm_common.h"
#include "bm_dbg.h"
_ERR("NULL query\n");
return BATTERY_MONITOR_ERROR_QUERY_SYNTAX_ERROR;
}
-
if (!bm_db_handle) {
_ERR("DB is not opened\n");
return BATTERY_MONITOR_ERROR_DB_NOT_OPENED;
return BATTERY_MONITOR_ERROR_DB_FAILED;
}
+ EXIT;
return BATTERY_MONITOR_ERROR_NONE;
}
ret = bm_execute_query(bm_db_handle, "ROLLBACK TRANSACTION");
_DBG("bm_end_transaction ROLLBACK");
}
-
if (ret == SQLITE_PERM) {
_ERR("Battery Monitor permission denied :: %d", ret);
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
-
if (ret == SQLITE_BUSY) {
_DBG(" sqlite3 busy = %d", ret);
return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
}
-
if (ret != SQLITE_OK) {
_ERR("bm_svc_end_transaction fail :: %d", ret);
return BATTERY_MONITOR_ERROR_DB_FAILED;
_ERR("statement is null");
return -1;
}
-
if (pos < 0) {
_ERR("invalid pos");
return -1;
_ERR("statement is null");
return -1;
}
-
if (str) {
_INFO("sqlite3_bind_text");
return sqlite3_bind_text(pStmt, pos, (const char *)str, strlen(str), SQLITE_STATIC);
_INFO("sqlite3_bind_null");
return sqlite3_bind_null(pStmt, pos);
}
+
+ EXIT;
}
static int bm_query_table_column_int(bm_stmt pStmt, int pos)
_ERR("statement is null");
return -1;
}
-
if (pos < 0) {
_ERR("invalid pos");
return -1;
_ERR("statement is null");
return NULL;
}
-
if (pos < 0) {
_ERR("invalid pos");
return NULL;
ENTER;
int count = 1;
-
- /* Caution : Keep insert query orders. */
-
bm_query_bind_text(hstmt, count++, app_id);
EXIT;
ENTER;
int count = 1;
-
- /* Caution : Keep insert query orders. */
-
bm_query_bind_text(hstmt, count++, (char *)bm_app_type->AppId);
-
bm_query_bind_int(hstmt, count++, bm_app_type->log_time);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_ble);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_wifi);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_cpu);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_display);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_device_network);
#ifdef DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN
bm_query_bind_int(hstmt, count++, bm_app_type->rId_gps);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_hrm);
-
bm_query_bind_int(hstmt, count++, bm_app_type->rId_battery);
#endif
EXIT;
ENTER;
int count = 1;
+ bm_query_bind_text(hstmt, count++, (char *)bm_resource_type->ResourceId);
+ bm_query_bind_int(hstmt, count++, bm_resource_type->log_time);
+ bm_query_bind_int(hstmt, count++, bm_resource_type->usage);
- /* Caution : Keep insert query orders. */
+ EXIT;
+ return count;
+}
- bm_query_bind_text(hstmt, count++, (char *)bm_resource_type->ResourceId);
+static int bm_gl_ble_stat_convert_to_sql(bd_gl_ble_stat_s *gble_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
- bm_query_bind_int(hstmt, count++, bm_resource_type->log_time);
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gble_st->time_s);
+ bm_query_bind_int(hstmt, count++, gble_st->ble_idle_time);
+ bm_query_bind_int(hstmt, count++, gble_st->ble_rx_time);
+ bm_query_bind_int(hstmt, count++, gble_st->ble_tx_time);
+ bm_query_bind_int(hstmt, count++, gble_st->ble_pwi_val);
- bm_query_bind_int(hstmt, count++, bm_resource_type->usage);
+ EXIT;
+ return count;
+}
+
+static int bm_gl_wifi_stat_convert_to_sql(bd_gl_wifi_stat_s *gwfl_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gwfl_st->time_s);
+ bm_query_bind_int(hstmt, count++, gwfl_st->wifi_on_time);
+ bm_query_bind_int(hstmt, count++, gwfl_st->wifi_conn_time);
+ bm_query_bind_int(hstmt, count++, gwfl_st->wifi_idle_time);
+ bm_query_bind_int(hstmt, count++, gwfl_st->wifi_rx_time);
+ bm_query_bind_int(hstmt, count++, gwfl_st->wifi_tx_time);
+ bm_query_bind_int(hstmt, count++, gwfl_st->wifi_pwi_val);
EXIT;
+ return count;
+}
+
+static int bm_gl_ntw_stat_convert_to_sql(bd_gl_ntw_stat_s *gn_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gn_st->time_s);
+ bm_query_bind_int(hstmt, count++, gn_st->dn_rx_byt);
+ bm_query_bind_int(hstmt, count++, gn_st->dn_tx_byt);
+ bm_query_bind_int(hstmt, count++, gn_st->wifi_rx_byt);
+ bm_query_bind_int(hstmt, count++, gn_st->wifi_tx_byt);
+ bm_query_bind_int(hstmt, count++, gn_st->dn_rx_pkt);
+ bm_query_bind_int(hstmt, count++, gn_st->dn_tx_pkt);
+ bm_query_bind_int(hstmt, count++, gn_st->wifi_rx_pkt);
+ bm_query_bind_int(hstmt, count++, gn_st->wifi_tx_pkt);
+
+ EXIT;
+ return count;
+}
+
+static int bm_gl_sbr_stat_convert_to_sql(bd_gl_sbr_stat_s *gbr_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gbr_st->time_s);
+ bm_query_bind_int(hstmt, count++, gbr_st->dark);
+ bm_query_bind_int(hstmt, count++, gbr_st->dim);
+ bm_query_bind_int(hstmt, count++, gbr_st->medium);
+ bm_query_bind_int(hstmt, count++, gbr_st->light);
+ bm_query_bind_int(hstmt, count++, gbr_st->bright);
+
+ EXIT;
+ return count;
+}
+
+static int bm_gl_sgt_stat_convert_to_sql(bd_gl_sgt_stat_s *gst_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gst_st->time_s);
+ bm_query_bind_int(hstmt, count++, gst_st->scan_time);
+ bm_query_bind_int(hstmt, count++, gst_st->none_time);
+ bm_query_bind_int(hstmt, count++, gst_st->poor_time);
+ bm_query_bind_int(hstmt, count++, gst_st->med_time);
+ bm_query_bind_int(hstmt, count++, gst_st->good_time);
+ bm_query_bind_int(hstmt, count++, gst_st->grt_time);
+
+ EXIT;
+ return count;
+}
+
+static int bm_gl_wst_stat_convert_to_sql(bd_gl_wst_stat_s *gwst_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gwst_st->time_s);
+ bm_query_bind_int(hstmt, count++, gwst_st->wscan_time);
+ bm_query_bind_int(hstmt, count++, gwst_st->wnone_time);
+ bm_query_bind_int(hstmt, count++, gwst_st->wpoor_time);
+ bm_query_bind_int(hstmt, count++, gwst_st->wmed_time);
+ bm_query_bind_int(hstmt, count++, gwst_st->wgood_time);
+ bm_query_bind_int(hstmt, count++, gwst_st->wgrt_time);
+
+ EXIT;
+ return count;
+}
+
+static int bm_gl_bst_stat_convert_to_sql(bd_gl_bst_stat_s *gbst_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gbst_st->time_s);
+ bm_query_bind_int(hstmt, count++, gbst_st->off_time);
+ bm_query_bind_int(hstmt, count++, gbst_st->low_time);
+ bm_query_bind_int(hstmt, count++, gbst_st->med_time);
+ bm_query_bind_int(hstmt, count++, gbst_st->high_time);
+ EXIT;
return count;
}
ENTER;
const char *textbuf = NULL;
-
textbuf = bm_query_table_column_text(hstmt, BM_RESOURCEUSAGE_FIELD_RESID);
bm_db_data_to_text(textbuf, &(bm_resource_type->ResourceId));
-
_DBG("bm_resource_type->ResourceId =[%s]", bm_resource_type->ResourceId);
-
bm_resource_type->log_time = -1;
-
bm_resource_type->usage = bm_query_table_column_int(hstmt, BM_RESOURCEUSAGE_FIELD_USAGE);
EXIT;
ENTER;
const char *textbuf = NULL;
-
textbuf = bm_query_table_column_text(hstmt, BM_APPUSAGE_FIELD_APPID);
bm_db_data_to_text(textbuf, &(bm_app_type->AppId));
-
_DBG("bm_app_type->AppId =[%s]", bm_app_type->AppId);
-
bm_app_type->log_time = -1;
-
bm_app_type->rId_ble = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_BLE);
-
bm_app_type->rId_wifi = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_WIFI);
-
bm_app_type->rId_cpu = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_CPU);
-
bm_app_type->rId_display = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_DISPLAY);
-
bm_app_type->rId_device_network = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_DEV_NTW);
#ifdef DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN
bm_app_type->rId_gps = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_GPS);
-
bm_app_type->rId_hrm = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_HRM);
-
bm_app_type->rId_battery = -1;
#endif
EXIT;
char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0,};
BM_MEMSET(query, 0, sizeof(query));
- BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s', '%s', '%s')",
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in \
+ ('%s', '%s', '%s', '%s','%s', '%s', '%s', '%s','%s', '%s')",
BATTERY_MONITOR_APP_ID_MAP_TABLE, BATTERY_MONITOR_APP_ID_USAGE_TABLE,
- BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
+ BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE, BATTERY_MONITOR_GBL_BLE_STAT_TABLE,
+ BATTERY_MONITOR_GBL_WFL_STAT_TABLE, BATTERY_MONITOR_GBL_NT_STAT_TABLE,
+ BATTERY_MONITOR_GBL_BR_STAT_TABLE, BATTERY_MONITOR_GBL_SGT_STAT_TABLE,
+ BATTERY_MONITOR_GBL_WST_STAT_TABLE, BATTERY_MONITOR_GBL_BST_STAT_TABLE);
rc = bm_get_record_count(bm_db_handle, query);
int rc = -1;
int error_code = BATTERY_MONITOR_ERROR_NONE;
-
- _INFO("Create all tables - BEGIN");
-
char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
BM_MEMSET(query, 0, sizeof(query));
/* Create the appid map table */
BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
BATTERY_MONITOR_APP_ID_MAP_TABLE);
-
rc = bm_get_record_count(bm_db_handle, query);
-
if (rc <= 0) {
rc = bm_execute_query(bm_db_handle, APP_ID_MAP_SCHEMA);
-
if (rc == SQLITE_BUSY)
return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
-
BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
APP_ID_MAP_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
}
-
/* Create the app based usage table */
BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
BATTERY_MONITOR_APP_ID_USAGE_TABLE);
-
rc = bm_get_record_count(bm_db_handle, query);
-
if (rc <= 0) {
rc = bm_execute_query(bm_db_handle, APP_ID_USAGE_SCHEMA);
-
if (rc == SQLITE_BUSY)
return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
-
BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
APP_ID_USAGE_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
}
-
/* Create the resource based usage table */
BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
-
rc = bm_get_record_count(bm_db_handle, query);
-
if (rc <= 0) {
rc = bm_execute_query(bm_db_handle, RESOURCE_ID_USAGE_SCHEMA);
-
if (rc == SQLITE_BUSY)
return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
-
BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
RESOURCE_ID_USAGE_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
}
+ /* Battery Dump Tables */
+ /* Create the global bluetooth stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_BLE_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_BLE_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_BLE_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+ /* Create the global wifi stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_WFL_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_WFL_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_WFL_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+ /* Create the global network stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_NT_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_NT_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_NT_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+ /* Create the global brightness stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_BR_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_BR_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_BR_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+ /* Create the global signal stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_SGT_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_SGT_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_SGT_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+ /* Create the global wifi signal stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_WST_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_WST_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_WST_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+ /* Create the global bt signal stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_BST_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_BST_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_BST_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
+
EXIT;
return error_code;
}
#endif
hstmt = bm_prepare_query(bm_db_handle, query);
-
if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
_ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
return error_code;
}
+static int bm_battery_stat_insert_to_db(sqlite3 *bm_db_handle, void *str_data, int type)
+{
+ ENTER;
+
+ int rc = 0;
+ char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
+ int error_code = BATTERY_MONITOR_ERROR_NONE;
+ bm_stmt hstmt = NULL;
+
+ BM_MEMSET(query, 0x00, sizeof(query));
+
+ switch (type) {
+ case 0: //;GBLE DATA
+ _DBG("GBLE_DATA");
+ bd_gl_ble_stat_s *gble_st = (bd_gl_ble_stat_s *)str_data;
+ _DBG("time %ld idle_time %ld rx_time %ld tx_time %ld pwi %ld", gble_st->time_s, gble_st->ble_idle_time,
+ gble_st->ble_rx_time, gble_st->ble_tx_time, gble_st->ble_pwi_val);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, ble_idle_time, ble_rx_time, \
+ ble_tx_time, ble_pwi_val) values " "(?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_BLE_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_ble_stat_convert_to_sql(gble_st, hstmt, query);
+ break;
+ case 1:
+ _DBG("GWFL_DATA");
+ bd_gl_wifi_stat_s *gwfl_st = (bd_gl_wifi_stat_s *)str_data;
+ _DBG("time %ld on_time %ld conn_time %ld idle_time %ld rx_time %ld tx_time %ld pwi %ld", gwfl_st->time_s,
+ gwfl_st->wifi_on_time, gwfl_st->wifi_conn_time, gwfl_st->wifi_idle_time, gwfl_st->wifi_rx_time,
+ gwfl_st->wifi_tx_time, gwfl_st->wifi_pwi_val);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, wifi_on_time, wifi_conn_time, wifi_idle_time, \
+ wifi_rx_time, wifi_tx_time, wifi_pwi_val) values" "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_WFL_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_wifi_stat_convert_to_sql(gwfl_st, hstmt, query);
+ break;
+ case 2:
+ _DBG("GNTW_DATA");
+ bd_gl_ntw_stat_s *gn_st = (bd_gl_ntw_stat_s *)str_data;
+ _DBG("time %ld dn_rx %ld dn_tx %ld wifi_rx %ld wifi_tx %ld dn_rx_pkt %ld dn_tx_pkt %ld wifi_rx_pkt %ld wifi_tx_pkt %ld",
+ gn_st->time_s, gn_st->dn_rx_byt, gn_st->dn_tx_byt, gn_st->wifi_rx_byt, gn_st->wifi_tx_byt,
+ gn_st->dn_rx_pkt, gn_st->dn_tx_pkt, gn_st->wifi_rx_pkt, gn_st->wifi_tx_pkt);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, dn_rx_byt, dn_tx_byt, wifi_rx_byt, wifi_tx_byt, \
+ dn_rx_pkt, dn_tx_pkt, wifi_rx_pkt, wifi_tx_pkt) values" "(?, ?, ?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_NT_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_ntw_stat_convert_to_sql(gn_st, hstmt, query);
+ break;
+ case 3:
+ _DBG("GSBR_DATA");
+ bd_gl_sbr_stat_s *gbr_st = (bd_gl_sbr_stat_s *)str_data;
+ _DBG("time %ld dark %ld dim %ld medium %ld light %ld bright %ld", gbr_st->time_s,
+ gbr_st->dark, gbr_st->dim, gbr_st->medium, gbr_st->light, gbr_st->bright);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, dark, dim, medium, light, bright) values" \
+ "(?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_BR_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_sbr_stat_convert_to_sql(gbr_st, hstmt, query);
+ break;
+ case 4:
+ _DBG("GSGT_DATA");
+ bd_gl_sgt_stat_s *gst_st = (bd_gl_sgt_stat_s *)str_data;
+ _DBG("time %ld scan %ld no %ld poor %ld med %ld good %ld great %ld", gst_st->time_s, gst_st->scan_time,
+ gst_st->none_time, gst_st->poor_time, gst_st->med_time, gst_st->good_time, gst_st->grt_time);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, scan_time, none_time, poor_time, med_time, good_time, \
+ grt_time) values" "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_SGT_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_sgt_stat_convert_to_sql(gst_st, hstmt, query);
+ break;
+ case 5:
+ _DBG("GWST_DATA");
+ bd_gl_wst_stat_s *gwst_st = (bd_gl_wst_stat_s *)str_data;
+ _DBG("time %ld wscan %ld wno %ld wpoor %ld wmed %ld wgood %ld wgreat %ld", gwst_st->time_s, gwst_st->wscan_time,
+ gwst_st->wnone_time, gwst_st->wpoor_time, gwst_st->wmed_time, gwst_st->wgood_time, gwst_st->wgrt_time);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, wscan_time, wnone_time, wpoor_time, wmed_time, wgood_time, \
+ wgrt_time) values" "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_WST_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_wst_stat_convert_to_sql(gwst_st, hstmt, query);
+ break;
+ case 6:
+ _DBG("GBST_DATA");
+ bd_gl_bst_stat_s *gbst_st = (bd_gl_bst_stat_s *)str_data;
+ _DBG("time %ld off %ld low %ld med %ld high %ld", gbst_st->time_s, gbst_st->off_time, gbst_st->low_time,
+ gbst_st->med_time, gbst_st->high_time);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, off_time, low_time, med_time, high_time) values "\
+ "(?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_BST_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_bst_stat_convert_to_sql(gbst_st, hstmt, query);
+ break;
+ default:
+ break;
+ }
+
+ rc = bm_query_step(hstmt);
+ if (rc == SQLITE_BUSY) {
+ _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
+ error_code = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ } else if (rc != SQLITE_DONE) {
+ _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
+ error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
+ }
+
+ rc = bm_query_finalize(hstmt);
+ BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
+ hstmt = NULL;
+
+ EXIT;
+ return error_code;
+}
+
static int bm_resourceid_usage_insert_to_db(sqlite3 *bm_db_handle, resourceid_usage_s *bm_resource_type)
{
ENTER;
return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
BM_MEMSET(query, 0x00, sizeof(query));
-
BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s( ResourceId, log_time, usage ) values " "(?, ?, ?)", BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
hstmt = bm_prepare_query(bm_db_handle, query);
-
if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
_ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
bm_resourceid_usage_convert_to_sql(bm_resource_type, hstmt, query);
-
rc = bm_query_step(hstmt);
if (rc == SQLITE_BUSY) {
_ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
"(?)", BATTERY_MONITOR_APP_ID_MAP_TABLE);
hstmt = bm_prepare_query(bm_db_handle, query);
-
if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
_ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
long int duration = 0;
duration = bm_get_time_bias(period_type);
-
if (duration == 0) {
_ERR("Invalid period_type [%d]", period_type);
return NULL;
}
-
_DBG("Value for duration is [%ld]", duration);
bm_stmt hstmt = NULL;
BM_RETURN_VAL((app_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; },
NULL, ("APP ID IS NULL"));
-
BM_RETURN_VAL((bm_db_handle != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; },
NULL, ("The database isn't connected."));
-
BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
#ifdef DISABLE_FEATURE_DATA_FROM_GPS_HRM_PLUGIN
#endif
hstmt = bm_prepare_query(bm_db_handle, query);
-
if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
_ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
*error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
appid_usage_s *bm_app_type = NULL;
-
rc = bm_query_step(hstmt);
BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND,
("The record isn't found.(%s)\n", app_id));
rc = bm_query_finalize(hstmt);
BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
hstmt = NULL;
-
*error_code = BATTERY_MONITOR_ERROR_NONE;
CATCH:
}
hstmt = NULL;
}
-
if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_app_type) {
BM_FREE(bm_app_type);
bm_app_type = NULL;
}
-
if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_app_type != NULL) {
_INFO("Returning appid usage");
return bm_app_type;
BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppName = ?", table);
hstmt = bm_prepare_query(bm_db_handle, query);
-
bm_query_bind_text(hstmt, binding_count++, app_id);
-
if (hstmt == NULL) {
_ERR("bm_svc_query_prepare(%s) failed(%s).\n", query, bm_db_err_msg(bm_db_handle));
error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
hstmt = NULL;
_INFO("bm_delete_table end");
-END:
+END:
EXIT;
return error_code;
}
BM_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppName = '%s'", BATTERY_MONITOR_APP_ID_MAP_TABLE, AppId);
count = bm_get_record_count(bm_db_handle, query);
-
if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
_ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
/* transaction control required */
ret_transaction = bm_begin_transaction(bm_db_handle);
-
if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
_ERR("database busy(%s)", bm_db_err_msg(bm_db_handle));
return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
}
ret_transaction = bm_end_transaction(bm_db_handle, is_success);
-
if (ret_transaction != BATTERY_MONITOR_ERROR_NONE)
_ERR("bm_svc_delete:bm_svc_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success);
{
ENTER;
- _INFO("bm_delete_table start - table[%s]", table);
+ _DBG("bm_delete_table start - table[%s]", table);
int error_code = BATTERY_MONITOR_ERROR_NONE;
int rc = 0;
char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
long int duration = bm_get_time_bias(1);
-
bm_stmt hstmt = NULL;
BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
BM_RETURN_VAL((table != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("table is null!"));
- if ((g_strcmp0(table, BATTERY_MONITOR_APP_ID_USAGE_TABLE) == 0))
- BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE log_time <= %ld", table, duration);
- else if (g_strcmp0(table, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE) == 0)
+ if ((g_strcmp0(table, BATTERY_MONITOR_APP_ID_USAGE_TABLE) == 0 || g_strcmp0(table, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE) == 0))
BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE log_time <= %ld", table, duration);
+ else
+ BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE time_s <= %ld", table, duration);
hstmt = bm_prepare_query(bm_db_handle, query);
-
if (hstmt == NULL) {
_ERR("bm_svc_query_prepare(%s) failed(%s).\n", query, bm_db_err_msg(bm_db_handle));
error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
hstmt = NULL;
EXIT;
-END:
+END:
return error_code;
}
-/*
-Manager Functions
->-------To be called by bm-engine & bm-server.
->-------Only these will be exposed for other files to use.
-*/
-
+/* Manager Functions */
int bm_server_appid_insert_to_db(const char* app_id)
{
ENTER;
/* Transaction Control Required */
ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
-
if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
pthread_mutex_unlock(&battery_monitor_mutex);
_ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
-
if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
_ERR("AppId map table insert:bm_begin_transaction fail %d\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
}
error_code = bm_appid_map_insert_to_db(g_hBatteryMonitorDB, app_id);
-
if (error_code != BATTERY_MONITOR_ERROR_NONE) {
ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
_ERR("INSERT appid fail, rollback insert query(%d)!!!!\n", ret_transaction);
/* Transaction Control Required */
ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
-
if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
pthread_mutex_unlock(&battery_monitor_mutex);
_ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
-
if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
_ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
}
error_code = bm_resourceid_usage_insert_to_db(g_hBatteryMonitorDB, bm_resource_type);
-
if (error_code != BATTERY_MONITOR_ERROR_NONE) {
ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
_ERR("INSERT resource usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
return error_code;
}
-
pthread_mutex_unlock(&battery_monitor_mutex);
bm_end_transaction(g_hBatteryMonitorDB, true);
/* Transaction Control Required */
ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
-
if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
pthread_mutex_unlock(&battery_monitor_mutex);
_ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
-
if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
_ERR("App Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
}
error_code = bm_appid_usage_insert_to_db(g_hBatteryMonitorDB, bm_app_type);
-
if (error_code != BATTERY_MONITOR_ERROR_NONE) {
ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
_ERR("INSERT app usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
BM_RETURN_VAL((app_id != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("Application Id is NULL"));
BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
-
pthread_mutex_lock(&battery_monitor_mutex);
error_code = bm_delete_table_by_app_id(g_hBatteryMonitorDB, app_id);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE)
+ _ERR("Delete of table by app_id failed");
pthread_mutex_unlock(&battery_monitor_mutex);
int ret_transaction = 0;
BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
-
pthread_mutex_lock(&battery_monitor_mutex);
/* Transaction Control Required */
ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
-
if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
pthread_mutex_unlock(&battery_monitor_mutex);
_ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
-
if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
_ERR("Usage Delete:bm_begin_transaction fail %d\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
pthread_mutex_unlock(&battery_monitor_mutex);
return ret_transaction;
}
-
error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
-
if (error_code != BATTERY_MONITOR_ERROR_NONE) {
ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
_ERR("Delete old resource usage fail, rollback delete query(%d)!!!!\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
return error_code;
}
-
error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_APP_ID_USAGE_TABLE);
-
if (error_code != BATTERY_MONITOR_ERROR_NONE) {
ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
_ERR("Delete old app usage fail, rollback delete query(%d)!!!!\n", ret_transaction);
pthread_mutex_unlock(&battery_monitor_mutex);
return error_code;
}
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_BLE_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete ble_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_WFL_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete wifi_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_NT_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete nt_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_BR_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete sbr_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_SGT_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete sgt_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_WST_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete wst_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+ error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_BST_STAT_TABLE);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("Delete bst_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
pthread_mutex_unlock(&battery_monitor_mutex);
bm_end_transaction(g_hBatteryMonitorDB, true);
return BATTERY_MONITOR_ERROR_NONE;
}
+// Battery Dump DB Operations
+int bm_server_battery_dump_insert_to_db(void *str_data, int type)
+{
+ ENTER;
+
+ int error_code = BATTERY_MONITOR_ERROR_NONE;
+ int ret_transaction = 0;
+
+ BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
+ BM_RETURN_VAL((str_data != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The Battery Dump Data is NULL"));
+
+ pthread_mutex_lock(&battery_monitor_mutex);
+
+ /* Transaction Control Required */
+ ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
+ if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ }
+ if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
+ _ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return ret_transaction;
+ }
+ error_code = bm_battery_stat_insert_to_db(g_hBatteryMonitorDB, str_data, type);
+ if (error_code != BATTERY_MONITOR_ERROR_NONE) {
+ ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
+ _ERR("INSERT resource usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ return error_code;
+ }
+
+ pthread_mutex_unlock(&battery_monitor_mutex);
+ bm_end_transaction(g_hBatteryMonitorDB, true);
+
+ EXIT;
+ return BATTERY_MONITOR_ERROR_NONE;
+}
+
+int bm_server_battery_dump_query_from_db(void *str_data, int type)
+{
+ ENTER;
+
+ EXIT;
+ return BATTERY_MONITOR_ERROR_NONE;
+}
+
int initialize_database(void)
{
ENTER;
}
EXIT;
-
return BATTERY_MONITOR_ERROR_NONE;
}
}
EXIT;
-
return BATTERY_MONITOR_ERROR_NONE;
}
projects / platform / core / system / batterymonitor.git / commitdiff