#include "bm_server_db.h"
#include "bm_common.h"
#include "bm_dbg.h"
+#include "bm_util.h"
#define BM_DB_OPEN_READONLY 0
#define BM_DB_OPEN_READWRITE 1
BM_RETURN_VAL((query != NULL), {}, NULL, ("query is NULL"));
rc = sqlite3_prepare_v2(bm_db_handle, query, strlen(query), &pStmt, NULL);
-
BM_RETURN_VAL((SQLITE_OK == rc), {}, NULL, ("sqlite3_prepare_v2() failed(%s).",
bm_db_err_msg(bm_db_handle)));
return count;
}
-static int bm_gl_wifi_stat_convert_to_sql(bd_gl_wifi_stat_s *gwfl_st, bm_stmt hstmt, char *sql_value)
+static int bm_gl_wfl_stat_convert_to_sql(bd_gl_wifi_stat_s *gwfl_st, bm_stmt hstmt, char *sql_value)
{
ENTER;
}
+static void bm_convert_column_to_appid_map(bm_stmt hstmt, appid_map_s* gappid_map)
+{
+ ENTER;
+
+ const char *textbuf = NULL;
+ gappid_map->id = bm_query_table_column_int(hstmt, BM_APPIDMAP_FIELD_ID);
+ textbuf = bm_query_table_column_text(hstmt, BM_APPIDMAP_FIELD_APPID);
+ bm_db_data_to_text(textbuf, &(gappid_map->AppId));
+
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_ble_stat(bm_stmt hstmt, bd_gl_ble_stat_s *gble_st)
+{
+ ENTER;
+ gble_st->time_s = -1;
+ gble_st->ble_idle_time = bm_query_table_column_int(hstmt, BD_GBLESTAT_IDLE);
+ gble_st->ble_rx_time = bm_query_table_column_int(hstmt, BD_GBLESTAT_RX);
+ gble_st->ble_tx_time = bm_query_table_column_int(hstmt, BD_GBLESTAT_TX);
+ gble_st->ble_pwi_val = bm_query_table_column_int(hstmt, BD_GBLESTAT_PWI_VAL);
+
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_wfl_stat(bm_stmt hstmt, bd_gl_wifi_stat_s *gwfl_st)
+{
+ ENTER;
+ gwfl_st->time_s = -1;
+ gwfl_st->wifi_on_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_ON);
+ gwfl_st->wifi_conn_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_CON);
+ gwfl_st->wifi_idle_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_IDLE);
+ gwfl_st->wifi_rx_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_RX);
+ gwfl_st->wifi_tx_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_TX);
+ gwfl_st->wifi_pwi_val = bm_query_table_column_int(hstmt, BD_GWFLSTAT_PWI_VAL);
+
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_sbr_stat(bm_stmt hstmt, bd_gl_sbr_stat_s *gbr_st)
+{
+ ENTER;
+ gbr_st->time_s = -1;
+ gbr_st->dark = bm_query_table_column_int(hstmt, BD_GSBRSTAT_DARK);
+ gbr_st->dim = bm_query_table_column_int(hstmt, BD_GSBRSTAT_DIM);
+ gbr_st->medium = bm_query_table_column_int(hstmt, BD_GSBRSTAT_MEDIUM);
+ gbr_st->light = bm_query_table_column_int(hstmt, BD_GSBRSTAT_LIGHT);
+ gbr_st->bright = bm_query_table_column_int(hstmt, BD_GSBRSTAT_BRIGHT);
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_ntw_stat(bm_stmt hstmt, bd_gl_ntw_stat_s *gn_st)
+{
+ ENTER;
+ gn_st->time_s = -1;
+ gn_st->dn_rx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_RXB);
+ gn_st->dn_tx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_TXB);
+ gn_st->wifi_rx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_RXB);
+ gn_st->wifi_tx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_TXB);
+ gn_st->dn_rx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_RXP);
+ gn_st->dn_tx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_TXP);
+ gn_st->wifi_rx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_RXP);
+ gn_st->wifi_tx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_TXP);
+
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_sgt_stat(bm_stmt hstmt, bd_gl_sgt_stat_s *gst_st)
+{
+ ENTER;
+ gst_st->time_s = -1;
+ gst_st->scan_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_SCAN);
+ gst_st->none_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_NO);
+ gst_st->poor_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_POOR);
+ gst_st->med_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_MED);
+ gst_st->good_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GOOD);
+ gst_st->grt_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GRT);
+
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_wst_stat(bm_stmt hstmt, bd_gl_wst_stat_s *gwst_st)
+{
+ ENTER;
+ gwst_st->time_s = -1;
+ gwst_st->wscan_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_SCAN);
+ gwst_st->wnone_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_NO);
+ gwst_st->wpoor_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_POOR);
+ gwst_st->wmed_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_MED);
+ gwst_st->wgood_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GOOD);
+ gwst_st->wgrt_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GRT);
+
+ EXIT;
+ return;
+}
+
+static void bm_convert_column_to_gl_bst_stat(bm_stmt hstmt, bd_gl_bst_stat_s *gbst_st)
+{
+ ENTER;
+ gbst_st->time_s = -1;
+ gbst_st->off_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_OFF);
+ gbst_st->low_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_LOW);
+ gbst_st->med_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_MED);
+ gbst_st->high_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_HIGH);
+
+ EXIT;
+ return;
+}
+
static int bm_get_record_count(sqlite3 *bm_db_handle, const char *query)
{
ENTER;
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);
+ bm_gl_wfl_stat_convert_to_sql(gwfl_st, hstmt, query);
break;
case 2:
_DBG("GNTW_DATA");
return error_code;
}
+GSList* bm_query_appid_map(sqlite3 *bm_db_handle, int *error_code)
+{
+ bm_stmt hstmt = NULL;
+ char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
+ int rc = 0;
+ *error_code = BATTERY_MONITOR_ERROR_NONE;
+ GSList* appid_map_list = 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);
+ BM_SNPRINTF(query, sizeof(query), "SELECT * FROM %s", 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));
+ *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ return NULL;
+ }
+
+ appid_map_s *gappid_map = NULL;
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND,
+ ("The record isn't found.\n"));
+ while (rc == SQLITE_ROW) {
+ gappid_map = (appid_map_s *)calloc(1, sizeof(appid_map_s));
+ if (gappid_map == NULL) {
+ _ERR("Memory Allocation Failed");
+ *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ break;
+ }
+ bm_convert_column_to_appid_map(hstmt, gappid_map);
+ appid_map_list = g_slist_append(appid_map_list, gappid_map);
+ rc = bm_query_step(hstmt);
+ }
+
+ 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:
+ if (hstmt != NULL) {
+ rc = bm_query_finalize(hstmt);
+ if (rc != BATTERY_MONITOR_ERROR_NONE) {
+ *error_code = rc;
+ _ERR("finalize error");
+ }
+ hstmt = NULL;
+ }
+ if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && appid_map_list != NULL) {
+ bm_set_free_gslist_appid_map(appid_map_list);
+ }
+ if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && appid_map_list != NULL) {
+ _INFO("Returning appid map list");
+ return appid_map_list;
+ }
+ EXIT;
+ return NULL;
+}
+
static appid_usage_s* bm_query_usage_by_appid(sqlite3 *bm_db_handle, const char *app_id, int *error_code, int period_type)
{
ENTER;
return NULL;
}
+static int bm_battery_stat_query_from_db(sqlite3 *bm_db_handle, void* str_data, int type, long int duration)
+{
+ ENTER;
+
+ _DBG("Value for duration is [%ld]", duration);
+ bm_stmt hstmt = NULL;
+ char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
+ int rc = 0;
+ int error_code = BATTERY_MONITOR_ERROR_NONE;
+
+ BM_RETURN_VAL((bm_db_handle != NULL), { error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; },
+ error_code, ("The database isn't connected."));
+ BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
+
+ switch (type) {
+ case 0:
+ _DBG("GBLE_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(ble_idle_time), sum(ble_rx_time), sum(ble_tx_time), \
+ sum(ble_pwi_val) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_BLE_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_ble_stat(hstmt, str_data);
+ break;
+ case 1:
+ _DBG("GWFL_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(wifi_on_time), sum(wifi_conn_time), sum(wifi_idle_time), \
+ sum(wifi_rx_time), sum(wifi_tx_time), sum(wifi_pwi_val) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_WFL_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_wfl_stat(hstmt, str_data);
+ break;
+ case 2:
+ _DBG("GNTW_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(dn_rx_byt), sum(dn_tx_byt), sum(wifi_rx_byt), \
+ sum(wifi_tx_byt), sum(dn_rx_pkt), sum(dn_tx_pkt), sum(wifi_rx_pkt), sum(wifi_tx_pkt) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_NT_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_ntw_stat(hstmt, str_data);
+ break;
+ case 3:
+ _DBG("GSBR_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(dark), sum(dim), sum(medium), \
+ sum(light), sum(bright) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_BR_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_sbr_stat(hstmt, str_data);
+ break;
+ case 4:
+ _DBG("GSGT_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(scan_time), sum(none_time), sum(poor_time), \
+ sum(med_time), sum(good_time), sum(grt_time) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_SGT_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_sgt_stat(hstmt, str_data);
+ break;
+ case 5:
+ _DBG("GWST_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(wscan_time), sum(wnone_time), sum(wpoor_time), \
+ sum(wmed_time), sum(wgood_time), sum(wgrt_time) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_WST_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_wst_stat(hstmt, str_data);
+ break;
+ case 6:
+ _DBG("GBST_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(off_time), sum(low_time), sum(med_time), \
+ sum(high_time) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_BST_STAT_TABLE, duration);
+ 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;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_bst_stat(hstmt, str_data);
+ break;
+ default:
+ break;
+ }
+
+ rc = bm_query_finalize(hstmt);
+ BM_CATCH_ERROR((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
+ hstmt = NULL;
+ error_code = BATTERY_MONITOR_ERROR_NONE;
+CATCH:
+ if (hstmt != NULL) {
+ rc = bm_query_finalize(hstmt);
+ if (rc != BATTERY_MONITOR_ERROR_NONE) {
+ error_code = rc;
+ _ERR("finalize error");
+ }
+ hstmt = NULL;
+ }
+ if ((error_code != BATTERY_MONITOR_ERROR_NONE) && str_data) {
+ BM_FREE(str_data);
+ str_data = NULL;
+ }
+ if ((error_code == BATTERY_MONITOR_ERROR_NONE) && str_data != NULL) {
+ _INFO("Returning Battery Stat");
+ return error_code;
+ }
+
+ EXIT;
+ return error_code;
+}
+
static resourceid_usage_s* bm_query_usage_by_resourceid(sqlite3 *bm_db_handle, const char *resource_id, int *error_code, int period_type)
{
ENTER;
long int duration = 0;
duration = bm_get_time_bias(period_type);
-
if (duration == 0) {
_ERR("Invalid period_type [%d]", period_type);
return NULL;
BM_RETURN_VAL((resource_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; },
NULL, ("RESOURCE 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);
-
BM_SNPRINTF(query, sizeof(query), "SELECT ResourceId, sum(usage) FROM %s WHERE ResourceId = '%s' \
AND log_time >= %ld", BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE, resource_id, duration);
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;
}
hstmt = NULL;
}
-
if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_resource_type) {
BM_FREE(bm_resource_type);
bm_resource_type = NULL;
}
-
if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_resource_type != NULL) {
_INFO("Returning appid usage");
return bm_resource_type;
_ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
}
-
if (count <= 0) {
BM_SLOGE("App ID(%s) is not exist. count(%d)\n", AppId, count);
return BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND;
return bm_resource_type;
}
+GSList* bm_server_query_appid_map(int *error_code)
+{
+ ENTER;
+
+ GSList *list = NULL;
+ *error_code = BATTERY_MONITOR_ERROR_NONE;
+
+ BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
+ list = bm_query_appid_map(g_hBatteryMonitorDB, error_code);
+
+ EXIT;
+ return list;
+}
+
int bm_server_delete_table_by_appid(const char* app_id)
{
ENTER;
return BATTERY_MONITOR_ERROR_NONE;
}
-// Battery Dump DB Operations
+/* Battery Dump DB Operations */
int bm_server_battery_dump_insert_to_db(void *str_data, int type)
{
ENTER;
return BATTERY_MONITOR_ERROR_NONE;
}
-int bm_server_battery_dump_query_from_db(void *str_data, int type)
+int bm_server_battery_dump_query_from_db(void *str_data, int type, long int duration)
{
ENTER;
+ int ret = BATTERY_MONITOR_ERROR_NONE;
+
+ BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { ret = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, ret, ("The database isn't connected."));
+ BM_RETURN_VAL((str_data != NULL), { ret = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, ret, ("The Battery Dump Handle is NULL"));
+ ret = bm_battery_stat_query_from_db(g_hBatteryMonitorDB, str_data, type, duration);
EXIT;
- return BATTERY_MONITOR_ERROR_NONE;
+ return ret;
}
int initialize_database(void)
projects / platform / core / system / batterymonitor.git / commitdiff