src/bm_server_db.c

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License")
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <sys/stat.h>
  22 #include <glib.h>
  23 #include <db-util.h>
  24 #include <pthread.h>
  25 #include <sqlite3.h>
  26 #include <time.h>
  27 #include <tzplatform_config.h>
  28
  29 #include "bm_private.h"
  30 #include "bd_private.h"
  31 #include "bm_server_db.h"
  32 #include "bm_common.h"
  33 #include "bm_dbg.h"
  34 #include "bm_util.h"
  35
  36 #define BM_DB_OPEN_READONLY 0
  37 #define BM_DB_OPEN_READWRITE 1
  38
  39 static sqlite3* g_hBatteryMonitorDB = NULL;
  40 static sqlite3* g_hBatteryMonitorDB2 = NULL;
  41
  42 pthread_mutex_t battery_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
  43
  44 static const char* bm_db_err_msg(sqlite3 *bm_db_handle)
  45 {
  46         return sqlite3_errmsg(bm_db_handle);
  47 }
  48
  49 static int bm_db_err_code(sqlite3 *bm_db_handle)
  50 {
  51         return sqlite3_errcode(bm_db_handle);
  52 }
  53
  54 char* bm_dup_text(const char *text_data)
  55 {
  56         ENTER;
  57
  58         char *text_value = NULL;
  59
  60         if (text_data != NULL)
  61                 text_value = strdup(text_data);
  62
  63         EXIT;
  64         return text_value;
  65 }
  66
  67 static bm_stmt bm_prepare_query(sqlite3 *bm_db_handle, char *query)
  68 {
  69         ENTER;
  70
  71         int rc = -1;
  72         bm_stmt pStmt = NULL;
  73
  74         BM_RETURN_VAL((query != NULL), {}, NULL, ("query is NULL"));
  75
  76         rc = sqlite3_prepare_v2(bm_db_handle, query, strlen(query), &pStmt, NULL);
  77         BM_RETURN_VAL((SQLITE_OK == rc), {}, NULL, ("sqlite3_prepare_v2() failed(%s).",
  78                                 bm_db_err_msg(bm_db_handle)));
  79
  80         EXIT;
  81         return pStmt;
  82 }
  83
  84 static int bm_execute_query(sqlite3 *bm_db_handle, const char *query)
  85 {
  86         ENTER;
  87
  88         int rc = -1;
  89         char *pszErrorMsg = NULL;
  90
  91         if (!query) {
  92                 _ERR("NULL query\n");
  93                 return BATTERY_MONITOR_ERROR_QUERY_SYNTAX_ERROR;
  94         }
  95         if (!bm_db_handle) {
  96                 _ERR("DB is not opened\n");
  97                 return BATTERY_MONITOR_ERROR_DB_NOT_OPENED;
  98         }
  99
 100         rc = sqlite3_exec(bm_db_handle, query, NULL, NULL, &pszErrorMsg);
 101         if (SQLITE_OK != rc) {
 102                 _ERR("sqlite3_exec rc(%d) failed(%s).", rc, pszErrorMsg);
 103                 sqlite3_free(pszErrorMsg);
 104         }
 105
 106         EXIT;
 107         return rc;
 108 }
 109
 110 static int bm_query_finalize(bm_stmt pStmt)
 111 {
 112         ENTER;
 113
 114         int rc = -1;
 115
 116         if (!pStmt) {
 117                 _ERR("pStmt is NULL");
 118                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
 119         }
 120
 121         rc = sqlite3_finalize(pStmt);
 122         if (rc == SQLITE_BUSY) {
 123                 _ERR(" sqlite3 busy = %d", rc);
 124                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 125         } else if (rc != SQLITE_OK) {
 126                 _ERR("sqlite3_finalize fail, rc : %d\n", rc);
 127                 return BATTERY_MONITOR_ERROR_DB_FAILED;
 128         }
 129
 130         EXIT;
 131         return BATTERY_MONITOR_ERROR_NONE;
 132 }
 133
 134 static int bm_query_step(bm_stmt pStmt)
 135 {
 136         ENTER;
 137
 138         if (!pStmt) {
 139                 _ERR("pStmt is NULL");
 140                 return -1;
 141         }
 142
 143         return sqlite3_step(pStmt);
 144 }
 145
 146 static int bm_begin_transaction(sqlite3 *bm_db_handle)
 147 {
 148         ENTER;
 149
 150         int ret = -1;
 151
 152         ret = bm_execute_query(bm_db_handle, "BEGIN IMMEDIATE TRANSACTION");
 153
 154         if (ret == SQLITE_BUSY) {
 155                 _ERR(" sqlite3 busy = %d", ret);
 156                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 157         } else if (ret != SQLITE_OK) {
 158                 _ERR("bm_svc_begin_transaction fail :: %d", ret);
 159                 return BATTERY_MONITOR_ERROR_DB_FAILED;
 160         }
 161
 162         EXIT;
 163         return BATTERY_MONITOR_ERROR_NONE;
 164 }
 165
 166 int bm_get_next_sequence(sqlite3 *bm_db_handle, const char *pszName)
 167 {
 168         ENTER;
 169
 170         int rc = 0;
 171         bm_stmt pStmt = NULL;
 172         int max_seq = 0;
 173
 174         char szQuery[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
 175         BM_MEMSET(szQuery, 0x00, sizeof(szQuery));
 176
 177         BM_SNPRINTF(szQuery, sizeof(szQuery), "SELECT max(seq) FROM %s where name = '%s'",
 178                                 BATTERY_MONITOR_SQLITE_SEQ, pszName);
 179
 180         rc = sqlite3_prepare_v2(bm_db_handle, szQuery, strlen(szQuery), &pStmt, NULL);
 181         if (SQLITE_OK != rc) {
 182                 BM_SLOGE("sqlite3_prepare_v2() failed(%d, %s).", rc, bm_db_err_msg(bm_db_handle));
 183                 sqlite3_finalize(pStmt);
 184                 return BATTERY_MONITOR_ERROR_DB_FAILED;
 185         }
 186
 187         rc = sqlite3_step(pStmt);
 188
 189         max_seq = sqlite3_column_int(pStmt, 0);
 190
 191         max_seq++;
 192
 193         rc = sqlite3_finalize(pStmt);
 194         pStmt = NULL;
 195
 196         EXIT;
 197         return max_seq;
 198 }
 199
 200 static int bm_end_transaction(sqlite3 *bm_db_handle, bool is_success)
 201 {
 202         ENTER;
 203
 204         int ret = -1;
 205
 206         if (is_success == true) {
 207                 ret = bm_execute_query(bm_db_handle, "COMMIT TRANSACTION");
 208                 _DBG("bm_end_transaction COMMIT");
 209         } else {
 210                 ret = bm_execute_query(bm_db_handle, "ROLLBACK TRANSACTION");
 211                 _DBG("bm_end_transaction ROLLBACK");
 212         }
 213         if (ret == SQLITE_PERM) {
 214                 _ERR("Battery Monitor permission denied :: %d", ret);
 215                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 216         }
 217         if (ret == SQLITE_BUSY) {
 218                 _DBG(" sqlite3 busy = %d", ret);
 219                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 220         }
 221         if (ret != SQLITE_OK) {
 222                 _ERR("bm_svc_end_transaction fail :: %d", ret);
 223                 return BATTERY_MONITOR_ERROR_DB_FAILED;
 224         }
 225
 226         EXIT;
 227         return BATTERY_MONITOR_ERROR_NONE;
 228 }
 229
 230 static int bm_query_bind_int(bm_stmt pStmt, int pos, int num)
 231 {
 232         ENTER;
 233
 234         if (!pStmt) {
 235                 _ERR("statement is null");
 236                 return -1;
 237         }
 238         if (pos < 0) {
 239                 _ERR("invalid pos");
 240                 return -1;
 241         }
 242
 243         EXIT;
 244         return sqlite3_bind_int(pStmt, pos, num);
 245 }
 246
 247 static int bm_query_bind_text(bm_stmt pStmt, int pos, const char *str)
 248 {
 249         ENTER;
 250
 251         if (!pStmt) {
 252                 _ERR("statement is null");
 253                 return -1;
 254         }
 255         if (str) {
 256                 _INFO("sqlite3_bind_text");
 257                 return sqlite3_bind_text(pStmt, pos, (const char *)str, strlen(str), SQLITE_STATIC);
 258         } else {
 259                 _INFO("sqlite3_bind_null");
 260                 return sqlite3_bind_null(pStmt, pos);
 261         }
 262 }
 263
 264 static int bm_query_table_column_int(bm_stmt pStmt, int pos)
 265 {
 266         ENTER;
 267
 268         if (!pStmt) {
 269                 _ERR("statement is null");
 270                 return -1;
 271         }
 272         if (pos < 0) {
 273                 _ERR("invalid pos");
 274                 return -1;
 275         }
 276
 277         return sqlite3_column_int(pStmt, pos);
 278 }
 279
 280 static const char* bm_query_table_column_text(bm_stmt pStmt, int pos)
 281 {
 282         ENTER;
 283
 284         if (!pStmt) {
 285                 _ERR("statement is null");
 286                 return NULL;
 287         }
 288         if (pos < 0) {
 289                 _ERR("invalid pos");
 290                 return NULL;
 291         }
 292
 293         return (const char *)sqlite3_column_text(pStmt, pos);
 294 }
 295
 296 static void bm_db_data_to_text(const char *textbuf, char **output)
 297 {
 298         ENTER;
 299
 300         if (textbuf) {
 301                 if (*output) {
 302                         free(*output);
 303                         *output = NULL;
 304                 }
 305                 *output = strdup(textbuf);
 306         }
 307
 308         EXIT;
 309 }
 310
 311 static int bm_db_handle_close(sqlite3 *bm_db_handle)
 312 {
 313         ENTER;
 314
 315         int rc = 0;
 316         int ret = BATTERY_MONITOR_ERROR_NONE;
 317
 318         if (bm_db_handle) {
 319                 rc = db_util_close(bm_db_handle);
 320                 if (rc == SQLITE_OK)
 321                         ret = BATTERY_MONITOR_ERROR_NONE;
 322                 else if (rc == SQLITE_PERM)
 323                         ret = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 324                 else if (rc == SQLITE_BUSY)
 325                         ret = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 326                 else
 327                         ret = BATTERY_MONITOR_ERROR_DB_FAILED;
 328         }
 329
 330         EXIT;
 331         return ret;
 332 }
 333
 334 static int bm_query_app_usage_convert_to_sql_ci(const char *str, long s_t, long e_t, bm_stmt hstmt)
 335 {
 336         ENTER;
 337
 338         int count = 1;
 339         bm_query_bind_text(hstmt, count++, str);
 340         bm_query_bind_int(hstmt, count++, s_t);
 341         bm_query_bind_int(hstmt, count++, e_t);
 342
 343         EXIT;
 344         return count;
 345 }
 346
 347 static int bm_appid_map_usage_convert_to_sql(const char* app_id, bm_stmt hstmt, char *sql_value)
 348 {
 349         ENTER;
 350
 351         int count = 1;
 352         bm_query_bind_text(hstmt, count++, app_id);
 353
 354         EXIT;
 355         return count;
 356 }
 357
 358 static int bm_appid_usage_convert_to_sql(appid_usage_s *bm_app_type, bm_stmt hstmt, char *sql_value)
 359 {
 360         ENTER;
 361
 362         int count = 1;
 363         bm_query_bind_text(hstmt, count++, (char *)bm_app_type->AppId);
 364         bm_query_bind_int(hstmt, count++, bm_app_type->log_time);
 365         bm_query_bind_int(hstmt, count++, bm_app_type->rId_ble);
 366         bm_query_bind_int(hstmt, count++, bm_app_type->rId_wifi);
 367         bm_query_bind_int(hstmt, count++, bm_app_type->rId_cpu);
 368         bm_query_bind_int(hstmt, count++, bm_app_type->rId_display);
 369         bm_query_bind_int(hstmt, count++, bm_app_type->rId_device_network);
 370 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
 371         bm_query_bind_int(hstmt, count++, bm_app_type->rId_gps);
 372         bm_query_bind_int(hstmt, count++, bm_app_type->rId_battery);
 373 #endif
 374         EXIT;
 375         return count;
 376 }
 377
 378 static int bm_resourceid_usage_convert_to_sql(resourceid_usage_s *bm_resource_type, bm_stmt hstmt, char *sql_value)
 379 {
 380         ENTER;
 381
 382         int count = 1;
 383         bm_query_bind_text(hstmt, count++, (char *)bm_resource_type->ResourceId);
 384         bm_query_bind_int(hstmt, count++, bm_resource_type->log_time);
 385         bm_query_bind_int(hstmt, count++, bm_resource_type->usage);
 386
 387         EXIT;
 388         return count;
 389 }
 390
 391 static int bm_gl_ble_stat_convert_to_sql(bd_gl_ble_stat_s *gble_st, bm_stmt hstmt, char *sql_value)
 392 {
 393         ENTER;
 394
 395         int count = 1;
 396         bm_query_bind_int(hstmt, count++, gble_st->time_s);
 397         bm_query_bind_int(hstmt, count++, gble_st->ble_idle_time);
 398         bm_query_bind_int(hstmt, count++, gble_st->ble_rx_time);
 399         bm_query_bind_int(hstmt, count++, gble_st->ble_tx_time);
 400         bm_query_bind_int(hstmt, count++, gble_st->ble_pwi_val);
 401
 402         EXIT;
 403         return count;
 404 }
 405
 406 static int bm_gl_wfl_stat_convert_to_sql(bd_gl_wifi_stat_s *gwfl_st, bm_stmt hstmt, char *sql_value)
 407 {
 408         ENTER;
 409
 410         int count = 1;
 411         bm_query_bind_int(hstmt, count++, gwfl_st->time_s);
 412         bm_query_bind_int(hstmt, count++, gwfl_st->wifi_on_time);
 413         bm_query_bind_int(hstmt, count++, gwfl_st->wifi_conn_time);
 414         bm_query_bind_int(hstmt, count++, gwfl_st->wifi_idle_time);
 415         bm_query_bind_int(hstmt, count++, gwfl_st->wifi_rx_time);
 416         bm_query_bind_int(hstmt, count++, gwfl_st->wifi_tx_time);
 417         bm_query_bind_int(hstmt, count++, gwfl_st->wifi_pwi_val);
 418
 419         EXIT;
 420         return count;
 421 }
 422
 423 static int bm_gl_ntw_stat_convert_to_sql(bd_gl_ntw_stat_s *gn_st, bm_stmt hstmt, char *sql_value)
 424 {
 425         ENTER;
 426
 427         int count = 1;
 428         bm_query_bind_int(hstmt, count++, gn_st->time_s);
 429         bm_query_bind_int(hstmt, count++, gn_st->dn_rx_byt);
 430         bm_query_bind_int(hstmt, count++, gn_st->dn_tx_byt);
 431         bm_query_bind_int(hstmt, count++, gn_st->wifi_rx_byt);
 432         bm_query_bind_int(hstmt, count++, gn_st->wifi_tx_byt);
 433         bm_query_bind_int(hstmt, count++, gn_st->dn_rx_pkt);
 434         bm_query_bind_int(hstmt, count++, gn_st->dn_tx_pkt);
 435         bm_query_bind_int(hstmt, count++, gn_st->wifi_rx_pkt);
 436         bm_query_bind_int(hstmt, count++, gn_st->wifi_tx_pkt);
 437         bm_query_bind_int(hstmt, count++, gn_st->bt_rx_byt);
 438         bm_query_bind_int(hstmt, count++, gn_st->bt_tx_byt);
 439
 440         EXIT;
 441         return count;
 442 }
 443
 444 static int bm_gl_sbr_stat_convert_to_sql(bd_gl_sbr_stat_s *gbr_st, bm_stmt hstmt, char *sql_value)
 445 {
 446         ENTER;
 447
 448         int count = 1;
 449         bm_query_bind_int(hstmt, count++, gbr_st->time_s);
 450         bm_query_bind_int(hstmt, count++, gbr_st->dark);
 451         bm_query_bind_int(hstmt, count++, gbr_st->dim);
 452         bm_query_bind_int(hstmt, count++, gbr_st->medium);
 453         bm_query_bind_int(hstmt, count++, gbr_st->light);
 454         bm_query_bind_int(hstmt, count++, gbr_st->bright);
 455
 456         EXIT;
 457         return count;
 458 }
 459
 460 static int bm_gl_sgt_stat_convert_to_sql(bd_gl_sgt_stat_s *gst_st, bm_stmt hstmt, char *sql_value)
 461 {
 462         ENTER;
 463
 464         int count = 1;
 465         bm_query_bind_int(hstmt, count++, gst_st->time_s);
 466         bm_query_bind_int(hstmt, count++, gst_st->scan_time);
 467         bm_query_bind_int(hstmt, count++, gst_st->none_time);
 468         bm_query_bind_int(hstmt, count++, gst_st->poor_time);
 469         bm_query_bind_int(hstmt, count++, gst_st->med_time);
 470         bm_query_bind_int(hstmt, count++, gst_st->good_time);
 471         bm_query_bind_int(hstmt, count++, gst_st->grt_time);
 472
 473         EXIT;
 474         return count;
 475 }
 476
 477 static int bm_gl_wst_stat_convert_to_sql(bd_gl_wst_stat_s *gwst_st, bm_stmt hstmt, char *sql_value)
 478 {
 479         ENTER;
 480
 481         int count = 1;
 482         bm_query_bind_int(hstmt, count++, gwst_st->time_s);
 483         bm_query_bind_int(hstmt, count++, gwst_st->wscan_time);
 484         bm_query_bind_int(hstmt, count++, gwst_st->wnone_time);
 485         bm_query_bind_int(hstmt, count++, gwst_st->wpoor_time);
 486         bm_query_bind_int(hstmt, count++, gwst_st->wmed_time);
 487         bm_query_bind_int(hstmt, count++, gwst_st->wgood_time);
 488         bm_query_bind_int(hstmt, count++, gwst_st->wgrt_time);
 489
 490         EXIT;
 491         return count;
 492 }
 493
 494 static int bm_gl_bst_stat_convert_to_sql(bd_gl_bst_stat_s *gbst_st, bm_stmt hstmt, char *sql_value)
 495 {
 496         ENTER;
 497
 498         int count = 1;
 499         bm_query_bind_int(hstmt, count++, gbst_st->time_s);
 500         bm_query_bind_int(hstmt, count++, gbst_st->off_time);
 501         bm_query_bind_int(hstmt, count++, gbst_st->low_time);
 502         bm_query_bind_int(hstmt, count++, gbst_st->med_time);
 503         bm_query_bind_int(hstmt, count++, gbst_st->high_time);
 504
 505         EXIT;
 506         return count;
 507 }
 508
 509 static int bm_gl_cpu_stat_convert_to_sql(bd_gl_cpu_stat_s *gcpu_st, bm_stmt hstmt, char *sql_value)
 510 {
 511         ENTER;
 512
 513         int count = 1;
 514         bm_query_bind_int(hstmt, count++, gcpu_st->time_s);
 515         bm_query_bind_int(hstmt, count++, gcpu_st->usr_time);
 516         bm_query_bind_int(hstmt, count++, gcpu_st->sys_time);
 517
 518         EXIT;
 519         return count;
 520 }
 521
 522 static void bm_convert_column_to_resourceid_usage(bm_stmt hstmt, resourceid_usage_s* bm_resource_type)
 523 {
 524         ENTER;
 525
 526         const char *textbuf = NULL;
 527         textbuf = bm_query_table_column_text(hstmt, BM_RESOURCEUSAGE_FIELD_RESID);
 528         bm_db_data_to_text(textbuf, &(bm_resource_type->ResourceId));
 529         _DBG("bm_resource_type->ResourceId =[%s]", bm_resource_type->ResourceId);
 530         bm_resource_type->log_time = -1;
 531         bm_resource_type->usage = bm_query_table_column_int(hstmt, BM_RESOURCEUSAGE_FIELD_USAGE);
 532
 533         EXIT;
 534         return;
 535 }
 536
 537 static void bm_convert_column_to_battery_last_charge(bm_stmt hstmt, resourceid_usage_s* bm_resource_type)
 538 {
 539         ENTER;
 540
 541         bm_resource_type->log_time = bm_query_table_column_int(hstmt, 0);
 542         _DBG("log-time %ld", bm_resource_type->log_time);
 543
 544         EXIT;
 545         return;
 546 }
 547
 548 static void bm_convert_column_to_appid_usage(bm_stmt hstmt, appid_usage_s* bm_app_type)
 549 {
 550         ENTER;
 551
 552         const char *textbuf = NULL;
 553         textbuf = bm_query_table_column_text(hstmt, BM_APPUSAGE_FIELD_APPID);
 554         bm_db_data_to_text(textbuf, &(bm_app_type->AppId));
 555         _DBG("bm_app_type->AppId =[%s]", bm_app_type->AppId);
 556         bm_app_type->log_time = -1;
 557         bm_app_type->rId_ble = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_BLE);
 558         bm_app_type->rId_wifi = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_WIFI);
 559         bm_app_type->rId_cpu = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_CPU);
 560         bm_app_type->rId_display = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_DISPLAY);
 561         bm_app_type->rId_device_network = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_DEV_NTW);
 562 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
 563         bm_app_type->rId_gps = bm_query_table_column_int(hstmt, BM_APPUSAGE_FIELD_RID_GPS);
 564         bm_app_type->rId_battery = -1;
 565 #endif
 566         EXIT;
 567         return;
 568
 569 }
 570
 571 static void bm_convert_column_to_appid_map(bm_stmt hstmt, appid_map_s* gappid_map)
 572 {
 573         ENTER;
 574
 575         const char *textbuf = NULL;
 576         gappid_map->id = bm_query_table_column_int(hstmt, BM_APPIDMAP_FIELD_ID);
 577         textbuf = bm_query_table_column_text(hstmt, BM_APPIDMAP_FIELD_APPID);
 578         bm_db_data_to_text(textbuf, &(gappid_map->AppId));
 579
 580         EXIT;
 581         return;
 582 }
 583
 584 static void bm_convert_column_to_gl_ble_stat(bm_stmt hstmt, bd_gl_ble_stat_s *gble_st)
 585 {
 586         ENTER;
 587         gble_st->time_s = -1;
 588         gble_st->ble_idle_time = bm_query_table_column_int(hstmt, BD_GBLESTAT_IDLE);
 589         gble_st->ble_rx_time = bm_query_table_column_int(hstmt, BD_GBLESTAT_RX);
 590         gble_st->ble_tx_time = bm_query_table_column_int(hstmt, BD_GBLESTAT_TX);
 591         gble_st->ble_pwi_val = bm_query_table_column_int(hstmt, BD_GBLESTAT_PWI_VAL);
 592
 593         EXIT;
 594         return;
 595 }
 596
 597 static void bm_convert_column_to_gl_wfl_stat(bm_stmt hstmt, bd_gl_wifi_stat_s *gwfl_st)
 598 {
 599         ENTER;
 600         gwfl_st->time_s = -1;
 601         gwfl_st->wifi_on_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_ON);
 602         gwfl_st->wifi_conn_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_CON);
 603         gwfl_st->wifi_idle_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_IDLE);
 604         gwfl_st->wifi_rx_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_RX);
 605         gwfl_st->wifi_tx_time = bm_query_table_column_int(hstmt, BD_GWFLSTAT_TX);
 606         gwfl_st->wifi_pwi_val = bm_query_table_column_int(hstmt, BD_GWFLSTAT_PWI_VAL);
 607
 608         EXIT;
 609         return;
 610 }
 611
 612 static void bm_convert_column_to_gl_sbr_stat(bm_stmt hstmt, bd_gl_sbr_stat_s *gbr_st)
 613 {
 614         ENTER;
 615         gbr_st->time_s = -1;
 616         gbr_st->dark = bm_query_table_column_int(hstmt, BD_GSBRSTAT_DARK);
 617         gbr_st->dim = bm_query_table_column_int(hstmt, BD_GSBRSTAT_DIM);
 618         gbr_st->medium = bm_query_table_column_int(hstmt, BD_GSBRSTAT_MEDIUM);
 619         gbr_st->light = bm_query_table_column_int(hstmt, BD_GSBRSTAT_LIGHT);
 620         gbr_st->bright = bm_query_table_column_int(hstmt, BD_GSBRSTAT_BRIGHT);
 621         EXIT;
 622         return;
 623 }
 624
 625 static void bm_convert_column_to_gl_ntw_stat(bm_stmt hstmt, bd_gl_ntw_stat_s *gn_st)
 626 {
 627         ENTER;
 628         gn_st->time_s = -1;
 629         gn_st->dn_rx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_RXB);
 630         gn_st->dn_tx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_TXB);
 631         gn_st->wifi_rx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_RXB);
 632         gn_st->wifi_tx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_TXB);
 633         gn_st->dn_rx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_RXP);
 634         gn_st->dn_tx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_DN_TXP);
 635         gn_st->wifi_rx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_RXP);
 636         gn_st->wifi_tx_pkt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_WIFI_TXP);
 637         gn_st->bt_rx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_BT_RXB);
 638         gn_st->bt_tx_byt = bm_query_table_column_int(hstmt, BD_GNTWSTAT_BT_TXB);
 639
 640         EXIT;
 641         return;
 642 }
 643
 644 static void bm_convert_column_to_gl_sgt_stat(bm_stmt hstmt, bd_gl_sgt_stat_s *gst_st)
 645 {
 646         ENTER;
 647         gst_st->time_s = -1;
 648         gst_st->scan_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_SCAN);
 649         gst_st->none_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_NO);
 650         gst_st->poor_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_POOR);
 651         gst_st->med_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_MED);
 652         gst_st->good_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GOOD);
 653         gst_st->grt_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GRT);
 654
 655         EXIT;
 656         return;
 657 }
 658
 659 static void bm_convert_column_to_gl_wst_stat(bm_stmt hstmt, bd_gl_wst_stat_s *gwst_st)
 660 {
 661         ENTER;
 662         gwst_st->time_s = -1;
 663         gwst_st->wscan_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_SCAN);
 664         gwst_st->wnone_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_NO);
 665         gwst_st->wpoor_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_POOR);
 666         gwst_st->wmed_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_MED);
 667         gwst_st->wgood_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GOOD);
 668         gwst_st->wgrt_time = bm_query_table_column_int(hstmt, BD_GSGTSTAT_GRT);
 669
 670         EXIT;
 671         return;
 672 }
 673
 674 static void bm_convert_column_to_gl_bst_stat(bm_stmt hstmt, bd_gl_bst_stat_s *gbst_st)
 675 {
 676         ENTER;
 677         gbst_st->time_s = -1;
 678         gbst_st->off_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_OFF);
 679         gbst_st->low_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_LOW);
 680         gbst_st->med_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_MED);
 681         gbst_st->high_time = bm_query_table_column_int(hstmt, BD_GBSTSTAT_HIGH);
 682
 683         EXIT;
 684         return;
 685 }
 686
 687 static void bm_convert_column_to_gl_cpu_stat(bm_stmt hstmt, bd_gl_cpu_stat_s *gcpu_st)
 688 {
 689         ENTER;
 690         gcpu_st->time_s = -1;
 691         gcpu_st->usr_time = bm_query_table_column_int(hstmt, BD_GCPUSTAT_USR);
 692         gcpu_st->sys_time = bm_query_table_column_int(hstmt, BD_GCPUSTAT_SYS);
 693
 694         EXIT;
 695         return;
 696 }
 697
 698 static int bm_get_record_count(sqlite3 *bm_db_handle, const char *query)
 699 {
 700         ENTER;
 701
 702         int rc = -1;
 703         int ncount = 0;
 704         bm_stmt pStmt = NULL;
 705
 706         if (!query) {
 707                 _ERR("NULL query\n");
 708                 return BATTERY_MONITOR_ERROR_QUERY_SYNTAX_ERROR;
 709         }
 710
 711         if (!bm_db_handle) {
 712                 _ERR("DB is not opened\n");
 713                 return BATTERY_MONITOR_ERROR_DB_NOT_OPENED;
 714         }
 715
 716         rc = sqlite3_prepare_v2(bm_db_handle, query, strlen(query), &pStmt, NULL);
 717
 718         if (SQLITE_BUSY == rc) {
 719                 _ERR("sqlite3_prepare_v2() failed(%d, %s).", rc, bm_db_err_msg(bm_db_handle));
 720                 sqlite3_finalize(pStmt);
 721                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 722         } else if (SQLITE_OK != rc) {
 723         _ERR("sqlite3_prepare_v2() failed(%d, %s).", rc, bm_db_err_msg(bm_db_handle));
 724                 sqlite3_finalize(pStmt);
 725                 return BATTERY_MONITOR_ERROR_DB_FAILED;
 726         }
 727
 728         rc = sqlite3_step(pStmt);
 729         if (SQLITE_BUSY == rc) {
 730                 _ERR("sqlite3_step() failed(%d, %s).", rc, bm_db_err_msg(bm_db_handle));
 731                 sqlite3_finalize(pStmt);
 732                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 733         } else if (SQLITE_ROW != rc) {
 734                 _ERR("sqlite3_step() failed(%d, %s).", rc, bm_db_err_msg(bm_db_handle));
 735                 sqlite3_finalize(pStmt);
 736                 return BATTERY_MONITOR_ERROR_DB_FAILED;
 737         }
 738
 739         ncount = sqlite3_column_int(pStmt, 0);
 740
 741         _INFO("bm record count [%d]", ncount);
 742         sqlite3_finalize(pStmt);
 743
 744         EXIT;
 745         return ncount;
 746 }
 747
 748 static int bm_check_is_all_table_exists(sqlite3 *bm_db_handle)
 749 {
 750         ENTER;
 751
 752         int rc = 0;
 753         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0,};
 754         BM_MEMSET(query, 0, sizeof(query));
 755
 756         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in \
 757                         ('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s')",
 758                         BATTERY_MONITOR_APP_ID_MAP_TABLE, BATTERY_MONITOR_APP_ID_USAGE_TABLE,
 759                         BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE, BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE,
 760                         BATTERY_MONITOR_GBL_BLE_STAT_TABLE, BATTERY_MONITOR_GBL_WFL_STAT_TABLE,
 761                         BATTERY_MONITOR_GBL_NT_STAT_TABLE, BATTERY_MONITOR_GBL_BR_STAT_TABLE,
 762                         BATTERY_MONITOR_GBL_SGT_STAT_TABLE, BATTERY_MONITOR_GBL_WST_STAT_TABLE,
 763                         BATTERY_MONITOR_GBL_BST_STAT_TABLE, BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
 764
 765         rc = bm_get_record_count(bm_db_handle, query);
 766
 767         if (rc != BATTERY_MONITOR_TABLE_COUNT)
 768                 _ERR("Table count is not matched rc = %d\n", rc);
 769
 770         EXIT;
 771         return rc;
 772 }
 773
 774 static int bm_create_all_tables(sqlite3 *bm_db_handle)
 775 {
 776         ENTER;
 777
 778         int rc = -1;
 779         int error_code = BATTERY_MONITOR_ERROR_NONE;
 780         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
 781         BM_MEMSET(query, 0, sizeof(query));
 782
 783         /* Create the appid map table */
 784         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 785                                                 BATTERY_MONITOR_APP_ID_MAP_TABLE);
 786         rc = bm_get_record_count(bm_db_handle, query);
 787         if (rc <= 0) {
 788                 rc = bm_execute_query(bm_db_handle, APP_ID_MAP_SCHEMA);
 789                 if (rc == SQLITE_BUSY)
 790                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 791                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 792                         ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 793                          APP_ID_MAP_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 794         }
 795         /* Create the app based usage table */
 796         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 797                                                 BATTERY_MONITOR_APP_ID_USAGE_TABLE);
 798         rc = bm_get_record_count(bm_db_handle, query);
 799         if (rc <= 0) {
 800                 rc = bm_execute_query(bm_db_handle, APP_ID_USAGE_SCHEMA);
 801                 if (rc == SQLITE_BUSY)
 802                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 803                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 804                         ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 805                          APP_ID_USAGE_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 806         }
 807         /* Create the resource based usage table */
 808         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 809                                                 BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
 810         rc = bm_get_record_count(bm_db_handle, query);
 811         if (rc <= 0) {
 812                 rc = bm_execute_query(bm_db_handle, RESOURCE_ID_USAGE_SCHEMA);
 813                 if (rc == SQLITE_BUSY)
 814                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 815                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 816                         ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 817                          RESOURCE_ID_USAGE_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 818         }
 819         /* Create the resource base usage table */
 820         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 821                                                 BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE);
 822         rc = bm_get_record_count(bm_db_handle, query);
 823         if (rc <= 0) {
 824                 rc = bm_execute_query(bm_db_handle, RES_ID_BASE_USAGE_SCHEMA);
 825                 if (rc == SQLITE_BUSY)
 826                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 827                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 828                         ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 829                         RES_ID_BASE_USAGE_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 830         }
 831
 832         /* Battery Dump Tables */
 833         /* Create the global bluetooth stats table */
 834         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 835                         BATTERY_MONITOR_GBL_BLE_STAT_TABLE);
 836         rc = bm_get_record_count(bm_db_handle, query);
 837         if (rc <= 0) {
 838                 rc = bm_execute_query(bm_db_handle, GBL_BLE_STAT_SCHEMA);
 839                 if (rc == SQLITE_BUSY)
 840                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 841                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 842                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 843                                  GBL_BLE_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 844         }
 845         /* Create the global wifi stats table */
 846         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 847                         BATTERY_MONITOR_GBL_WFL_STAT_TABLE);
 848         rc = bm_get_record_count(bm_db_handle, query);
 849         if (rc <= 0) {
 850                 rc = bm_execute_query(bm_db_handle, GBL_WFL_STAT_SCHEMA);
 851                 if (rc == SQLITE_BUSY)
 852                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 853                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 854                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 855                                  GBL_WFL_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 856         }
 857         /* Create the global network stats table */
 858         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 859                         BATTERY_MONITOR_GBL_NT_STAT_TABLE);
 860         rc = bm_get_record_count(bm_db_handle, query);
 861         if (rc <= 0) {
 862                 rc = bm_execute_query(bm_db_handle, GBL_NT_STAT_SCHEMA);
 863                 if (rc == SQLITE_BUSY)
 864                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 865                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 866                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 867                                  GBL_NT_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 868         }
 869         /* Create the global brightness stats table */
 870         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 871                         BATTERY_MONITOR_GBL_BR_STAT_TABLE);
 872         rc = bm_get_record_count(bm_db_handle, query);
 873         if (rc <= 0) {
 874                 rc = bm_execute_query(bm_db_handle, GBL_BR_STAT_SCHEMA);
 875                 if (rc == SQLITE_BUSY)
 876                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 877                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 878                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 879                                  GBL_BR_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 880         }
 881         /* Create the global signal stats table */
 882         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 883                         BATTERY_MONITOR_GBL_SGT_STAT_TABLE);
 884         rc = bm_get_record_count(bm_db_handle, query);
 885         if (rc <= 0) {
 886                 rc = bm_execute_query(bm_db_handle, GBL_SGT_STAT_SCHEMA);
 887                 if (rc == SQLITE_BUSY)
 888                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 889                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 890                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 891                                  GBL_SGT_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 892         }
 893         /* Create the global wifi signal stats table */
 894         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 895                         BATTERY_MONITOR_GBL_WST_STAT_TABLE);
 896         rc = bm_get_record_count(bm_db_handle, query);
 897         if (rc <= 0) {
 898                 rc = bm_execute_query(bm_db_handle, GBL_WST_STAT_SCHEMA);
 899                 if (rc == SQLITE_BUSY)
 900                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 901                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 902                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 903                                  GBL_WST_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 904         }
 905         /* Create the global bt signal stats table */
 906         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 907                         BATTERY_MONITOR_GBL_BST_STAT_TABLE);
 908         rc = bm_get_record_count(bm_db_handle, query);
 909         if (rc <= 0) {
 910                 rc = bm_execute_query(bm_db_handle, GBL_BST_STAT_SCHEMA);
 911                 if (rc == SQLITE_BUSY)
 912                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 913                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 914                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 915                                  GBL_BST_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 916         }
 917         /* Create the global cpu stats table */
 918         BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
 919                         BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
 920         rc = bm_get_record_count(bm_db_handle, query);
 921         if (rc <= 0) {
 922                 rc = bm_execute_query(bm_db_handle, GBL_CPU_STAT_SCHEMA);
 923                 if (rc == SQLITE_BUSY)
 924                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 925                 BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
 926                                 ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
 927                                  GBL_CPU_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
 928         }
 929
 930         EXIT;
 931         return error_code;
 932 }
 933
 934 static long int bm_get_time_bias(int period_type)
 935 {
 936         ENTER;
 937
 938         long int ret = 0;
 939         time_t curr_time;
 940
 941         time(&curr_time);
 942
 943         ret = curr_time;
 944
 945         if (period_type == 0) {
 946                 ret = ret - BM_DURATION_1DAY;
 947         } else if (period_type == 1) {
 948                 ret = ret - BM_DURATION_1WEEK;
 949         } else {
 950                 _ERR("Invalid value for period [%d]", period_type);
 951                 ret = 0;
 952         }
 953
 954         EXIT;
 955         return ret;
 956 }
 957
 958 static int bm_db_open(void)
 959 {
 960         ENTER;
 961
 962         int rc = 0;
 963         int ret = -1;
 964
 965         char bm_db_path[256] = {0, };
 966         BM_MEMSET(bm_db_path, 0x00, sizeof(bm_db_path));
 967
 968         BATTERY_MONITOR_GET_DB_PATH(bm_db_path, sizeof(bm_db_path));
 969
 970         if (g_hBatteryMonitorDB) {
 971                 _ERR("Battery Monitor database is using in another app.");
 972                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 973         }
 974
 975         ret = bm_db_handle_close(g_hBatteryMonitorDB2);
 976         if (ret != BATTERY_MONITOR_ERROR_NONE)
 977                 _DBG("db_util_close(g_hBatteryMonitorDB2) fail ret = %d", ret);
 978
 979         _DBG("before bm_db_open()");
 980 //      if (mode == BM_DB_OPEN_READWRITE)
 981                 rc = db_util_open(bm_db_path, &g_hBatteryMonitorDB, DB_UTIL_REGISTER_HOOK_METHOD);
 982 //      else if (mode == BM_DB_OPEN_READONLY)
 983 //      rc = db_util_open_with_options(bm_db_path, &g_hBatteryMonitorDB, SQLITE_OPEN_READONLY, NULL);
 984 //      else
 985 //              return _BATTERY_MONITOR_ERROR_DB_NOT_OPENED;
 986         _DBG("after bm_db_open() sqlite_rc = %d", rc);
 987
 988         if (rc == SQLITE_PERM || bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
 989                 _ERR("Battery Monitor permission denied");
 990                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 991         }
 992
 993         if (rc == SQLITE_BUSY) {
 994                 _ERR("busy handler fail.");
 995                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
 996         }
 997
 998         if (rc != SQLITE_OK) {
 999                 _ERR("The database isn't connected.");
1000                 return BATTERY_MONITOR_ERROR_DB_NOT_OPENED;
1001         }
1002
1003         rc = bm_check_is_all_table_exists(g_hBatteryMonitorDB);
1004
1005         if (rc < 0) {
1006                 _ERR("bm_check_is_all_table_exists rc=[%d]", rc);
1007                 return rc;
1008         } else if (rc == BATTERY_MONITOR_TABLE_COUNT) {
1009                 _INFO("Tables OK");
1010         } else {
1011                 int ret = bm_create_all_tables(g_hBatteryMonitorDB);
1012                 if (ret != BATTERY_MONITOR_ERROR_NONE) {
1013                         _ERR("bm_create_all_tables fail ret=[%d]", ret);
1014                         return ret;
1015                 }
1016         }
1017
1018         EXIT;
1019         return BATTERY_MONITOR_ERROR_NONE;
1020 }
1021
1022 static int bm_db_close(void)
1023 {
1024         ENTER;
1025
1026         int ret = -1;
1027
1028         ret = bm_db_handle_close(g_hBatteryMonitorDB);
1029         if (ret != BATTERY_MONITOR_ERROR_NONE) {
1030                 _ERR("db_util_close(g_hBatteryMonitorDB) fail ret = %d", ret);
1031                 g_hBatteryMonitorDB2 = g_hBatteryMonitorDB;
1032         }
1033
1034         g_hBatteryMonitorDB = NULL;
1035
1036         EXIT;
1037         return ret;
1038 }
1039
1040 static gboolean app_name_check_duplicated(sqlite3 *bm_db_handle, const char *app_id, int *error_code)
1041 {
1042         ENTER;
1043
1044         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1045         int count = 0;
1046         *error_code = BATTERY_MONITOR_ERROR_NONE;
1047
1048         BM_RETURN_VAL((bm_db_handle != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, false, ("The database isn't connected."));
1049         BM_RETURN_VAL((app_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, false, ("app_id is NULL."));
1050
1051         BM_MEMSET(query, 0x00, sizeof(query));
1052
1053         BM_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppId='%s'", BATTERY_MONITOR_APP_ID_MAP_TABLE, app_id);
1054
1055         count = bm_get_record_count(bm_db_handle, query);
1056         if (count > 0) {
1057                 _INFO("query=[%s]", query);
1058                 return true;
1059         }
1060
1061         EXIT;
1062         return false;
1063 }
1064
1065 static int bm_appid_usage_insert_to_db(sqlite3 *bm_db_handle, appid_usage_s *bm_app_type)
1066 {
1067         ENTER;
1068
1069         int rc = 0;
1070         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1071         int error_code = BATTERY_MONITOR_ERROR_NONE;
1072         bm_stmt hstmt = NULL;
1073
1074         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1075         BM_RETURN_VAL((bm_app_type != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The battery monitor handle is NULL"));
1076
1077         /* check mandatory field(app id)*/
1078         if (!bm_app_type->AppId)
1079                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
1080
1081         BM_MEMSET(query, 0x00, sizeof(query));
1082 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
1083         BM_SNPRINTF(query, sizeof(query), \
1084                 "INSERT INTO %s( AppId, log_time, rId_ble, rId_wifi, rId_cpu, rId_display, rId_device_network, rId_gps, rId_battery ) values "
1085                         "(?, ?, ?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_APP_ID_USAGE_TABLE);
1086 #else
1087         BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s( AppId, log_time, rId_ble, rId_wifi, rId_cpu, rId_display, rId_device_network) values "
1088                         "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_APP_ID_USAGE_TABLE);
1089 #endif
1090
1091         hstmt = bm_prepare_query(bm_db_handle, query);
1092         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1093                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1094                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1095         } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1096                 _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1097                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1098         }
1099
1100         BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1101
1102         bm_appid_usage_convert_to_sql(bm_app_type, hstmt, query);
1103
1104         rc = bm_query_step(hstmt);
1105         if (rc == SQLITE_BUSY) {
1106                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1107                 error_code = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1108         } else if (rc != SQLITE_DONE) {
1109                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1110                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
1111         }
1112
1113         rc = bm_query_finalize(hstmt);
1114         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1115         hstmt = NULL;
1116
1117         EXIT;
1118         return error_code;
1119 }
1120
1121 static int bm_battery_stat_insert_to_db(sqlite3 *bm_db_handle, void *str_data, int type)
1122 {
1123         ENTER;
1124
1125         if(str_data == NULL) {
1126                 _ERR("Invalid Stat");
1127                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
1128         }
1129         int rc = 0;
1130         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1131         int error_code = BATTERY_MONITOR_ERROR_NONE;
1132         bm_stmt hstmt = NULL;
1133
1134         BM_MEMSET(query, 0x00, sizeof(query));
1135
1136         switch (type) {
1137         case 0: //;GBLE DATA
1138                 _DBG("GBLE_DATA");
1139                 bd_gl_ble_stat_s *gble_st = (bd_gl_ble_stat_s *)str_data;
1140                 _DBG("time %ld idle_time %ld rx_time %ld tx_time %ld pwi %ld", gble_st->time_s, gble_st->ble_idle_time,
1141                                 gble_st->ble_rx_time, gble_st->ble_tx_time, gble_st->ble_pwi_val);
1142                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, ble_idle_time, ble_rx_time, \
1143                         ble_tx_time, ble_pwi_val) values " "(?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_BLE_STAT_TABLE);
1144                 hstmt = bm_prepare_query(bm_db_handle, query);
1145                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1146                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1147                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1148                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1149                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1150                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1151                 }
1152                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1153                 bm_gl_ble_stat_convert_to_sql(gble_st, hstmt, query);
1154                 break;
1155         case 1:
1156                 _DBG("GWFL_DATA");
1157                 bd_gl_wifi_stat_s *gwfl_st = (bd_gl_wifi_stat_s *)str_data;
1158                 _DBG("time %ld on_time %ld conn_time %ld idle_time %ld rx_time %ld tx_time %ld pwi %ld", gwfl_st->time_s,
1159                                 gwfl_st->wifi_on_time, gwfl_st->wifi_conn_time, gwfl_st->wifi_idle_time, gwfl_st->wifi_rx_time,
1160                                 gwfl_st->wifi_tx_time, gwfl_st->wifi_pwi_val);
1161                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, wifi_on_time, wifi_conn_time, wifi_idle_time, \
1162                         wifi_rx_time, wifi_tx_time, wifi_pwi_val) values" "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_WFL_STAT_TABLE);
1163                 hstmt = bm_prepare_query(bm_db_handle, query);
1164                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1165                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1166                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1167                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1168                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1169                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1170                 }
1171                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1172                 bm_gl_wfl_stat_convert_to_sql(gwfl_st, hstmt, query);
1173                 break;
1174         case 2:
1175                 _DBG("GNTW_DATA");
1176                 bd_gl_ntw_stat_s *gn_st = (bd_gl_ntw_stat_s *)str_data;
1177                 _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",
1178                                 gn_st->time_s, gn_st->dn_rx_byt, gn_st->dn_tx_byt, gn_st->wifi_rx_byt, gn_st->wifi_tx_byt,
1179                                 gn_st->dn_rx_pkt, gn_st->dn_tx_pkt, gn_st->wifi_rx_pkt, gn_st->wifi_tx_pkt);
1180                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, dn_rx_byt, dn_tx_byt, wifi_rx_byt, wifi_tx_byt, \
1181                         dn_rx_pkt, dn_tx_pkt, wifi_rx_pkt, wifi_tx_pkt, bt_rx_byt, bt_tx_byt) values" "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_NT_STAT_TABLE);
1182                 hstmt = bm_prepare_query(bm_db_handle, query);
1183                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1184                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1185                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1186                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1187                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1188                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1189                 }
1190                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1191                 bm_gl_ntw_stat_convert_to_sql(gn_st, hstmt, query);
1192                 break;
1193         case 3:
1194                 _DBG("GSBR_DATA");
1195                 bd_gl_sbr_stat_s *gbr_st = (bd_gl_sbr_stat_s *)str_data;
1196                 _DBG("time %ld dark %ld dim %ld medium %ld light %ld bright %ld", gbr_st->time_s,
1197                                 gbr_st->dark, gbr_st->dim, gbr_st->medium, gbr_st->light, gbr_st->bright);
1198                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, dark, dim, medium, light, bright) values" \
1199                                 "(?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_BR_STAT_TABLE);
1200                 hstmt = bm_prepare_query(bm_db_handle, query);
1201                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1202                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1203                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1204                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1205                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1206                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1207                 }
1208                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1209                 bm_gl_sbr_stat_convert_to_sql(gbr_st, hstmt, query);
1210                 break;
1211         case 4:
1212                 _DBG("GSGT_DATA");
1213                 bd_gl_sgt_stat_s *gst_st = (bd_gl_sgt_stat_s *)str_data;
1214                 _DBG("time %ld scan %ld no %ld poor %ld med %ld good %ld great %ld", gst_st->time_s, gst_st->scan_time,
1215                                 gst_st->none_time, gst_st->poor_time, gst_st->med_time, gst_st->good_time, gst_st->grt_time);
1216                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, scan_time, none_time, poor_time, med_time, good_time, \
1217                         grt_time) values" "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_SGT_STAT_TABLE);
1218                 hstmt = bm_prepare_query(bm_db_handle, query);
1219                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1220                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1221                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1222                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1223                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1224                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1225                 }
1226                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1227                 bm_gl_sgt_stat_convert_to_sql(gst_st, hstmt, query);
1228                 break;
1229         case 5:
1230                 _DBG("GWST_DATA");
1231                 bd_gl_wst_stat_s *gwst_st = (bd_gl_wst_stat_s *)str_data;
1232                 _DBG("time %ld wscan %ld wno %ld wpoor %ld wmed %ld wgood %ld wgreat %ld", gwst_st->time_s, gwst_st->wscan_time,
1233                                 gwst_st->wnone_time, gwst_st->wpoor_time, gwst_st->wmed_time, gwst_st->wgood_time, gwst_st->wgrt_time);
1234                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, wscan_time, wnone_time, wpoor_time, wmed_time, wgood_time, \
1235                         wgrt_time) values" "(?, ?, ?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_WST_STAT_TABLE);
1236                 hstmt = bm_prepare_query(bm_db_handle, query);
1237                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1238                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1239                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1240                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1241                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1242                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1243                 }
1244                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1245                 bm_gl_wst_stat_convert_to_sql(gwst_st, hstmt, query);
1246                 break;
1247         case 6:
1248                 _DBG("GBST_DATA");
1249                 bd_gl_bst_stat_s *gbst_st = (bd_gl_bst_stat_s *)str_data;
1250                 _DBG("time %ld off %ld low %ld med %ld high %ld", gbst_st->time_s, gbst_st->off_time, gbst_st->low_time,
1251                                 gbst_st->med_time, gbst_st->high_time);
1252                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, off_time, low_time, med_time, high_time) values "\
1253                                 "(?, ?, ?, ?, ?)", BATTERY_MONITOR_GBL_BST_STAT_TABLE);
1254                 hstmt = bm_prepare_query(bm_db_handle, query);
1255                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1256                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1257                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1258                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1259                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1260                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1261                 }
1262                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1263                 bm_gl_bst_stat_convert_to_sql(gbst_st, hstmt, query);
1264                 break;
1265         case 7:
1266                 _DBG("GCPU_DATA");
1267                 bd_gl_cpu_stat_s *gcpu_st = (bd_gl_cpu_stat_s *)str_data;
1268                 _DBG("time %ld usr %ld sys %ld", gcpu_st->time_s, gcpu_st->usr_time, gcpu_st->sys_time);
1269                 BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, usr_time, sys_time) values "\
1270                                 "(?, ?, ?)", BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
1271                 hstmt = bm_prepare_query(bm_db_handle, query);
1272                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1273                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1274                         return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1275                 } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1276                         _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1277                         return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1278                 }
1279                 BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1280                 bm_gl_cpu_stat_convert_to_sql(gcpu_st, hstmt, query);
1281                 break;
1282         default:
1283                 _ERR("Invalid Type");
1284                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
1285         }
1286
1287         rc = bm_query_step(hstmt);
1288         if (rc == SQLITE_BUSY) {
1289                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1290                 error_code = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1291         } else if (rc != SQLITE_DONE) {
1292                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1293                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
1294         }
1295
1296         rc = bm_query_finalize(hstmt);
1297         hstmt = NULL;
1298         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1299
1300         EXIT;
1301         return error_code;
1302 }
1303
1304 static int bm_resourceid_usage_insert_to_db(sqlite3 *bm_db_handle, resourceid_usage_s *bm_resource_type)
1305 {
1306         ENTER;
1307
1308         int rc = 0;
1309         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1310         int error_code = BATTERY_MONITOR_ERROR_NONE;
1311         bm_stmt hstmt = NULL;
1312
1313         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1314         BM_RETURN_VAL((bm_resource_type != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The battery monitor handle is NULL"));
1315
1316         /* check mandatory field(Resource id)*/
1317         if (!bm_resource_type->ResourceId)
1318                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
1319
1320         BM_MEMSET(query, 0x00, sizeof(query));
1321         BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s( ResourceId, log_time, usage ) values " "(?, ?, ?)", BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
1322
1323         hstmt = bm_prepare_query(bm_db_handle, query);
1324         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1325                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1326                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1327         } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1328                 _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1329                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1330         }
1331
1332         BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1333
1334         bm_resourceid_usage_convert_to_sql(bm_resource_type, hstmt, query);
1335         rc = bm_query_step(hstmt);
1336         if (rc == SQLITE_BUSY) {
1337                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1338                 error_code = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1339         } else if (rc != SQLITE_DONE) {
1340                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1341                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
1342         }
1343
1344         rc = bm_query_finalize(hstmt);
1345         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1346         hstmt = NULL;
1347
1348         EXIT;
1349         return error_code;
1350 }
1351
1352 static int bm_resourceid_base_usage_insert_to_db(sqlite3 *bm_db_handle, resourceid_usage_s *bm_resource_type)
1353 {
1354         ENTER;
1355
1356         int rc = 0;
1357         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1358         int error_code = BATTERY_MONITOR_ERROR_NONE;
1359         bm_stmt hstmt = NULL;
1360
1361         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1362         BM_RETURN_VAL((bm_resource_type != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The battery monitor handle is NULL"));
1363
1364         /* check mandatory field(Resource id)*/
1365         if (!bm_resource_type->ResourceId)
1366                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
1367
1368         BM_MEMSET(query, 0x00, sizeof(query));
1369         BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s( ResourceId, log_time, usage ) values " "(?, ?, ?)", BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE);
1370
1371         hstmt = bm_prepare_query(bm_db_handle, query);
1372         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1373                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1374                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1375         } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1376                 _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1377                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1378         }
1379
1380         BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1381
1382         bm_resourceid_usage_convert_to_sql(bm_resource_type, hstmt, query);
1383         rc = bm_query_step(hstmt);
1384         if (rc == SQLITE_BUSY) {
1385                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1386                 error_code = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1387         } else if (rc != SQLITE_DONE) {
1388                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1389                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
1390         }
1391
1392         rc = bm_query_finalize(hstmt);
1393         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1394         hstmt = NULL;
1395
1396         EXIT;
1397         return error_code;
1398 }
1399
1400 int bm_appid_map_insert_to_db(sqlite3 *bm_db_handle, const char *app_id)
1401 {
1402         ENTER;
1403
1404         int rc = 0;
1405         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1406         int error_code = BATTERY_MONITOR_ERROR_NONE;
1407         bm_stmt hstmt = NULL;
1408
1409         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1410
1411         /* check mandatory field(app id)*/
1412         if (!app_id)
1413                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
1414
1415         /* The AppId integer value should be auto increment */
1416         BM_MEMSET(query, 0x00, sizeof(query));
1417         BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s( AppId ) values "
1418                         "(?)", BATTERY_MONITOR_APP_ID_MAP_TABLE);
1419
1420         hstmt = bm_prepare_query(bm_db_handle, query);
1421         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1422                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1423                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1424         } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
1425                 _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
1426                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1427         }
1428
1429         BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
1430
1431         bm_appid_map_usage_convert_to_sql(app_id, hstmt, query);
1432
1433         rc = bm_query_step(hstmt);
1434         if (rc == SQLITE_BUSY) {
1435                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1436                 error_code = BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1437         } else if (rc != SQLITE_DONE) {
1438                 _ERR("bm_db_query_step() failed(%d, %s)", rc, bm_db_err_msg(bm_db_handle));
1439                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
1440         }
1441
1442         rc = bm_query_finalize(hstmt);
1443         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1444         hstmt = NULL;
1445
1446         EXIT;
1447         return error_code;
1448 }
1449
1450 GSList* bm_query_appid_map(sqlite3 *bm_db_handle, int *error_code)
1451 {
1452         bm_stmt hstmt = NULL;
1453         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1454         int rc = 0;
1455         *error_code = BATTERY_MONITOR_ERROR_NONE;
1456         GSList* appid_map_list = NULL;
1457
1458         BM_RETURN_VAL((bm_db_handle != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; },
1459                                                 NULL, ("The database isn't connected."));
1460         BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
1461         BM_SNPRINTF(query, sizeof(query), "SELECT * FROM %s", BATTERY_MONITOR_APP_ID_MAP_TABLE);
1462
1463         hstmt = bm_prepare_query(bm_db_handle, query);
1464         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1465                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1466                 *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1467                 return NULL;
1468         }
1469
1470         appid_map_s *gappid_map = NULL;
1471         rc = bm_query_step(hstmt);
1472         BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND,
1473                                 ("The record isn't found.\n"));
1474         while (rc == SQLITE_ROW) {
1475                 gappid_map = (appid_map_s *)calloc(1, sizeof(appid_map_s));
1476                 if (gappid_map == NULL) {
1477                         _ERR("Memory Allocation Failed");
1478                         *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
1479                         break;
1480                 }
1481                 bm_convert_column_to_appid_map(hstmt, gappid_map);
1482                 appid_map_list = g_slist_append(appid_map_list, gappid_map);
1483                 rc = bm_query_step(hstmt);
1484         }
1485
1486         rc = bm_query_finalize(hstmt);
1487         BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1488         hstmt = NULL;
1489
1490         *error_code = BATTERY_MONITOR_ERROR_NONE;
1491 CATCH:
1492         if (hstmt != NULL) {
1493                 rc = bm_query_finalize(hstmt);
1494                 if (rc != BATTERY_MONITOR_ERROR_NONE) {
1495                         *error_code = rc;
1496                         _ERR("finalize error");
1497                 }
1498                 hstmt = NULL;
1499         }
1500         if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && appid_map_list != NULL)
1501                 bm_set_free_gslist_appid_map(appid_map_list);
1502         if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && appid_map_list != NULL) {
1503                 _INFO("Returning appid map list");
1504                 return appid_map_list;
1505         }
1506         EXIT;
1507         return NULL;
1508 }
1509
1510 static appid_usage_s* bm_query_usage_by_appid_ci(sqlite3 *bm_db_handle, const char *app_id, long long s_time, long long e_time, int *error_code)
1511 {
1512         ENTER;
1513
1514         bm_stmt hstmt = NULL;
1515         int rc = 0;
1516         *error_code = BATTERY_MONITOR_ERROR_NONE;
1517
1518         long int s_t = (long)s_time;
1519         long int e_t = (long)e_time;
1520         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1521         BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
1522         BM_SNPRINTF(query, sizeof(query), "SELECT AppId, sum(rId_ble), sum(rId_wifi), sum(rId_cpu), \
1523                 sum(rId_display), sum(rId_device_network), sum(rId_gps) FROM %s WHERE \
1524                 AppId = ? AND log_time > ? AND log_time < ? ", BATTERY_MONITOR_APP_ID_USAGE_TABLE);
1525         hstmt = bm_prepare_query(bm_db_handle, query);
1526         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1527                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1528                 *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1529                 return NULL;
1530         }
1531
1532         bm_query_app_usage_convert_to_sql_ci(app_id, s_t, e_t, hstmt);
1533         appid_usage_s *bm_app_type = NULL;
1534         rc = bm_query_step(hstmt);
1535         BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND,
1536                         ("The record isn't found.(%s)\n", app_id));
1537         bm_app_type = (appid_usage_s *)calloc(1, sizeof(appid_usage_s));
1538         if (bm_app_type == NULL) {
1539                 _ERR("memory allocation failed");
1540                 if (hstmt != NULL) {
1541                         rc = bm_query_finalize(hstmt);
1542                         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), { *error_code = rc; },
1543                                         NULL, ("finalize error"));
1544                         hstmt = NULL;
1545                 }
1546                 *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
1547                 return NULL;
1548         }
1549         bm_convert_column_to_appid_usage(hstmt, bm_app_type);
1550         rc = bm_query_finalize(hstmt);
1551         BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1552         hstmt = NULL;
1553         *error_code = BATTERY_MONITOR_ERROR_NONE;
1554
1555 CATCH:
1556         if (hstmt != NULL) {
1557                 rc = bm_query_finalize(hstmt);
1558                 if (rc != BATTERY_MONITOR_ERROR_NONE) {
1559                         *error_code = rc;
1560                         _ERR("finalize error");
1561                 }
1562                 hstmt = NULL;
1563         }
1564         if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_app_type) {
1565                 BM_FREE(bm_app_type);
1566                 bm_app_type = NULL;
1567         }
1568         if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_app_type != NULL) {
1569                 _INFO("Returning appid usage");
1570                 return bm_app_type;
1571         }
1572
1573         EXIT;
1574         return NULL;
1575 }
1576
1577 static int bm_battery_stat_query_from_db(sqlite3 *bm_db_handle, void* str_data, int type, long int duration)
1578 {
1579         ENTER;
1580
1581         _DBG("Value for duration is [%ld]", duration);
1582         bm_stmt hstmt = NULL;
1583         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1584         int rc = 0;
1585         int error_code = BATTERY_MONITOR_ERROR_NONE;
1586
1587         BM_RETURN_VAL((bm_db_handle != NULL), { error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; },
1588                                 error_code, ("The database isn't connected."));
1589         BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
1590
1591         switch (type) {
1592         case 0:
1593                 _DBG("GBLE_DATA");
1594                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(ble_idle_time), sum(ble_rx_time), sum(ble_tx_time), \
1595                         sum(ble_pwi_val) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_BLE_STAT_TABLE, duration);
1596                 hstmt = bm_prepare_query(bm_db_handle, query);
1597                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1598                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1599                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1600                         return error_code;
1601                 }
1602                 rc = bm_query_step(hstmt);
1603                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1604                 bm_convert_column_to_gl_ble_stat(hstmt, str_data);
1605                 break;
1606         case 1:
1607                 _DBG("GWFL_DATA");
1608                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(wifi_on_time), sum(wifi_conn_time), sum(wifi_idle_time), \
1609                                 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);
1610                 hstmt = bm_prepare_query(bm_db_handle, query);
1611                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1612                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1613                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1614                         return error_code;
1615                 }
1616                 rc = bm_query_step(hstmt);
1617                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1618                 bm_convert_column_to_gl_wfl_stat(hstmt, str_data);
1619                 break;
1620         case 2:
1621                 _DBG("GNTW_DATA");
1622                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(dn_rx_byt), sum(dn_tx_byt), sum(wifi_rx_byt), \
1623                                 sum(wifi_tx_byt), sum(dn_rx_pkt), sum(dn_tx_pkt), sum(wifi_rx_pkt), sum(wifi_tx_pkt), \
1624                                 sum(bt_rx_byt), sum(bt_tx_byt) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_NT_STAT_TABLE, duration);
1625                 hstmt = bm_prepare_query(bm_db_handle, query);
1626                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1627                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1628                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1629                         return error_code;
1630                 }
1631                 rc = bm_query_step(hstmt);
1632                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1633                 bm_convert_column_to_gl_ntw_stat(hstmt, str_data);
1634                 break;
1635         case 3:
1636                 _DBG("GSBR_DATA");
1637                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(dark), sum(dim), sum(medium), \
1638                                 sum(light), sum(bright) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_BR_STAT_TABLE, duration);
1639                 hstmt = bm_prepare_query(bm_db_handle, query);
1640                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1641                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1642                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1643                         return error_code;
1644                 }
1645                 rc = bm_query_step(hstmt);
1646                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1647                 bm_convert_column_to_gl_sbr_stat(hstmt, str_data);
1648                 break;
1649         case 4:
1650                 _DBG("GSGT_DATA");
1651                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(scan_time), sum(none_time), sum(poor_time), \
1652                                 sum(med_time), sum(good_time), sum(grt_time) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_SGT_STAT_TABLE, duration);
1653                 hstmt = bm_prepare_query(bm_db_handle, query);
1654                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1655                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1656                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1657                         return error_code;
1658                 }
1659                 rc = bm_query_step(hstmt);
1660                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1661                 bm_convert_column_to_gl_sgt_stat(hstmt, str_data);
1662                 break;
1663         case 5:
1664                 _DBG("GWST_DATA");
1665                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(wscan_time), sum(wnone_time), sum(wpoor_time), \
1666                                 sum(wmed_time), sum(wgood_time), sum(wgrt_time) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_WST_STAT_TABLE, duration);
1667                 hstmt = bm_prepare_query(bm_db_handle, query);
1668                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1669                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1670                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1671                         return error_code;
1672                 }
1673                 rc = bm_query_step(hstmt);
1674                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1675                 bm_convert_column_to_gl_wst_stat(hstmt, str_data);
1676                 break;
1677         case 6:
1678                 _DBG("GBST_DATA");
1679                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(off_time), sum(low_time), sum(med_time), \
1680                 sum(high_time) FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_BST_STAT_TABLE, duration);
1681                 hstmt = bm_prepare_query(bm_db_handle, query);
1682                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1683                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1684                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1685                         return error_code;
1686                 }
1687                 rc = bm_query_step(hstmt);
1688                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1689                 bm_convert_column_to_gl_bst_stat(hstmt, str_data);
1690                 break;
1691         case 7:
1692                 _DBG("GCPU_DATA");
1693                 BM_SNPRINTF(query, sizeof(query), "SELECT sum(usr_time), sum(sys_time) \
1694                 FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_CPU_STAT_TABLE, duration);
1695                 hstmt = bm_prepare_query(bm_db_handle, query);
1696                 if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1697                         _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1698                         error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1699                         return error_code;
1700                 }
1701                 rc = bm_query_step(hstmt);
1702                 BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1703                 bm_convert_column_to_gl_cpu_stat(hstmt, str_data);
1704                 break;
1705         default:
1706                 break;
1707         }
1708
1709         rc = bm_query_finalize(hstmt);
1710         BM_CATCH_ERROR((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1711         hstmt = NULL;
1712         error_code = BATTERY_MONITOR_ERROR_NONE;
1713 CATCH:
1714         if (hstmt != NULL) {
1715                 rc = bm_query_finalize(hstmt);
1716                 if (rc != BATTERY_MONITOR_ERROR_NONE) {
1717                         error_code = rc;
1718                         _ERR("finalize error");
1719                 }
1720                 hstmt = NULL;
1721         }
1722
1723         if ((error_code == BATTERY_MONITOR_ERROR_NONE) && str_data != NULL) {
1724                 _INFO("Returning Battery Stat");
1725                 return error_code;
1726         }
1727
1728         EXIT;
1729         return error_code;
1730 }
1731
1732 static resourceid_usage_s* bm_query_usage_by_resourceid_ci(sqlite3 *bm_db_handle, const char *resource_id, long long s_time, long long e_time, int *error_code)
1733 {
1734         ENTER;
1735         bm_stmt hstmt = NULL;
1736         int rc = 0;
1737         *error_code = BATTERY_MONITOR_ERROR_NONE;
1738         long int s_t = (long)s_time;
1739         long int e_t = (long)e_time;
1740         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1741         BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
1742         BM_SNPRINTF(query, sizeof(query), "SELECT ResourceId, sum(usage) FROM %s WHERE ResourceId = '%s' \
1743                         AND log_time > %ld AND log_time < %ld", BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE, resource_id, s_t, e_t);
1744
1745         hstmt = bm_prepare_query(bm_db_handle, query);
1746         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1747                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1748                 *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1749                 return NULL;
1750         }
1751
1752         resourceid_usage_s *bm_resource_type = NULL;
1753         rc = bm_query_step(hstmt);
1754         BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.(%s)\n", resource_id));
1755
1756         bm_resource_type = (resourceid_usage_s *)calloc(1, sizeof(resourceid_usage_s));
1757         if (bm_resource_type == NULL) {
1758                 _ERR("memory allocation failed");
1759                 if (hstmt != NULL) {
1760                         rc = bm_query_finalize(hstmt);
1761                         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
1762                         hstmt = NULL;
1763                 }
1764                 *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
1765                 return NULL;
1766         }
1767         bm_convert_column_to_resourceid_usage(hstmt, bm_resource_type);
1768
1769         rc = bm_query_finalize(hstmt);
1770         BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1771         hstmt = NULL;
1772         *error_code = BATTERY_MONITOR_ERROR_NONE;
1773
1774 CATCH:
1775         if (hstmt != NULL) {
1776                 rc = bm_query_finalize(hstmt);
1777                 if (rc != BATTERY_MONITOR_ERROR_NONE) {
1778                         *error_code = rc;
1779                         _ERR("finalize error");
1780                 }
1781                 hstmt = NULL;
1782         }
1783         if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_resource_type) {
1784                 BM_FREE(bm_resource_type);
1785                 bm_resource_type = NULL;
1786         }
1787         if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_resource_type != NULL) {
1788                 _INFO("Returning appid usage");
1789                 return bm_resource_type;
1790         }
1791         EXIT;
1792         return NULL;
1793 }
1794
1795 static resourceid_usage_s* bm_query_base_usage_by_resourceid_ci(sqlite3 *bm_db_handle, const char *resource_id, long long s_time, long long e_time, int *error_code)
1796 {
1797         ENTER;
1798         bm_stmt hstmt = NULL;
1799         int rc = 0;
1800         *error_code = BATTERY_MONITOR_ERROR_NONE;
1801         long int s_t = (long)s_time;
1802         long int e_t = (long)e_time;
1803         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1804         BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
1805         BM_SNPRINTF(query, sizeof(query), "SELECT ResourceId, sum(usage) FROM %s WHERE ResourceId = '%s' \
1806                         AND log_time > %ld AND log_time < %ld", BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE, resource_id, s_t, e_t);
1807
1808         hstmt = bm_prepare_query(bm_db_handle, query);
1809         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1810                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1811                 *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1812                 return NULL;
1813         }
1814
1815         resourceid_usage_s *bm_resource_type = NULL;
1816         rc = bm_query_step(hstmt);
1817         BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.(%s)\n", resource_id));
1818
1819         bm_resource_type = (resourceid_usage_s *)calloc(1, sizeof(resourceid_usage_s));
1820         if (bm_resource_type == NULL) {
1821                 _ERR("memory allocation failed");
1822                 if (hstmt != NULL) {
1823                         rc = bm_query_finalize(hstmt);
1824                         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
1825                         hstmt = NULL;
1826                 }
1827                 *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
1828                 return NULL;
1829         }
1830         bm_convert_column_to_resourceid_usage(hstmt, bm_resource_type);
1831
1832         rc = bm_query_finalize(hstmt);
1833         BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1834         hstmt = NULL;
1835         *error_code = BATTERY_MONITOR_ERROR_NONE;
1836
1837 CATCH:
1838         if (hstmt != NULL) {
1839                 rc = bm_query_finalize(hstmt);
1840                 if (rc != BATTERY_MONITOR_ERROR_NONE) {
1841                         *error_code = rc;
1842                         _ERR("finalize error");
1843                 }
1844                 hstmt = NULL;
1845         }
1846         if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_resource_type) {
1847                 BM_FREE(bm_resource_type);
1848                 bm_resource_type = NULL;
1849         }
1850         if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_resource_type != NULL) {
1851                 _INFO("Returning appid usage");
1852                 return bm_resource_type;
1853         }
1854         EXIT;
1855         return NULL;
1856 }
1857
1858 static resourceid_usage_s* bm_query_battery_last_charge(sqlite3 *bm_db_handle, const char *resource_id, int *error_code)
1859 {
1860         ENTER;
1861         bm_stmt hstmt = NULL;
1862         int rc = 0;
1863         *error_code = BATTERY_MONITOR_ERROR_NONE;
1864         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1865         BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
1866         BM_SNPRINTF(query, sizeof(query), "SELECT MAX(log_time) FROM %s WHERE ResourceId = '%s'",
1867                         BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE, resource_id);
1868
1869         hstmt = bm_prepare_query(bm_db_handle, query);
1870         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1871                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1872                 *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1873                 return NULL;
1874         }
1875
1876         resourceid_usage_s *bm_resource_type = NULL;
1877         rc = bm_query_step(hstmt);
1878         BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.(%s)\n", resource_id));
1879
1880         bm_resource_type = (resourceid_usage_s *)calloc(1, sizeof(resourceid_usage_s));
1881         if (bm_resource_type == NULL) {
1882                 _ERR("memory allocation failed");
1883                 if (hstmt != NULL) {
1884                         rc = bm_query_finalize(hstmt);
1885                         BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
1886                         hstmt = NULL;
1887                 }
1888                 *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
1889                 return NULL;
1890         }
1891         bm_convert_column_to_battery_last_charge(hstmt, bm_resource_type);
1892
1893         rc = bm_query_finalize(hstmt);
1894         BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
1895         hstmt = NULL;
1896         *error_code = BATTERY_MONITOR_ERROR_NONE;
1897
1898 CATCH:
1899         if (hstmt != NULL) {
1900                 rc = bm_query_finalize(hstmt);
1901                 if (rc != BATTERY_MONITOR_ERROR_NONE) {
1902                         *error_code = rc;
1903                         _ERR("finalize error");
1904                 }
1905                 hstmt = NULL;
1906         }
1907         if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_resource_type) {
1908                 BM_FREE(bm_resource_type);
1909                 bm_resource_type = NULL;
1910         }
1911         if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_resource_type != NULL) {
1912                 _INFO("Returning battery plug time");
1913                 return bm_resource_type;
1914         }
1915         EXIT;
1916         return NULL;
1917 }
1918
1919 static int bm_delete_table(sqlite3 *bm_db_handle, bm_stmt *phstmt, int num_app_id, const char *app_id, const char* table)
1920 {
1921         ENTER;
1922
1923         _INFO("bm_delete_table start - table[%s]", table);
1924         int error_code = BATTERY_MONITOR_ERROR_NONE;
1925         int binding_count = 1;
1926         int rc = 0;
1927         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1928
1929         bm_stmt hstmt = *phstmt;
1930
1931         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1932         BM_RETURN_VAL((table != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("table is null!"));
1933
1934         if ((g_strcmp0(table, BATTERY_MONITOR_APP_ID_USAGE_TABLE) == 0))
1935                 BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId = ?", table);
1936         else if (g_strcmp0(table, BATTERY_MONITOR_APP_ID_MAP_TABLE) == 0)
1937                 BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppName = ?", table);
1938
1939         hstmt = bm_prepare_query(bm_db_handle, query);
1940         bm_query_bind_text(hstmt, binding_count++, app_id);
1941         if (hstmt == NULL) {
1942                 _ERR("bm_svc_query_prepare(%s) failed(%s).\n", query, bm_db_err_msg(bm_db_handle));
1943                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
1944                 goto END;
1945         }
1946
1947         rc = bm_query_step(hstmt);
1948         if (rc != SQLITE_DONE) {
1949                 _ERR("The record isn't found\n");
1950                 error_code = BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND;
1951                 goto END;
1952         }
1953
1954         rc = bm_query_finalize(hstmt);
1955         if (rc != BATTERY_MONITOR_ERROR_NONE) {
1956                 _ERR("finalize error");
1957                 error_code = rc;
1958                 goto END;
1959         }
1960
1961         hstmt =  NULL;
1962         _INFO("bm_delete_table end");
1963
1964 END:
1965         EXIT;
1966         return error_code;
1967 }
1968
1969 static int bm_delete_table_by_app_id(sqlite3 *bm_db_handle, const char *AppId)
1970 {
1971         ENTER;
1972
1973         int error_code = BATTERY_MONITOR_ERROR_NONE;
1974         bm_stmt hstmt = NULL;
1975         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
1976         int rc = 0;
1977         int count = -1;
1978         int ret_transaction = 0;
1979         bool is_success = FALSE;
1980         int num_AppId = -1;
1981
1982         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1983         BM_RETURN_VAL((AppId != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The database isn't connected."));
1984
1985         /* Check requested ID to delete */
1986         BM_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppName = '%s'", BATTERY_MONITOR_APP_ID_MAP_TABLE, AppId);
1987
1988         count = bm_get_record_count(bm_db_handle, query);
1989         if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
1990                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
1991                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
1992         }
1993         if (count <= 0) {
1994                 BM_SLOGE("App ID(%s) is not exist. count(%d)\n", AppId, count);
1995                 return BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND;
1996         }
1997
1998         /* transaction control required */
1999         ret_transaction = bm_begin_transaction(bm_db_handle);
2000         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2001                 _ERR("database busy(%s)", bm_db_err_msg(bm_db_handle));
2002                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2003         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2004                 _ERR("bm_delete:bm_begin_transaction fail %d\n", ret_transaction);
2005                 return ret_transaction;
2006         }
2007
2008         /*delete AppId Usage table*/
2009         error_code = bm_delete_table(bm_db_handle, &hstmt, num_AppId, AppId, BATTERY_MONITOR_APP_ID_USAGE_TABLE);
2010         if ((error_code == BATTERY_MONITOR_ERROR_DB_FAILED) || (error_code == BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND)) {
2011                 _ERR("bm appid_usage deletion failed - db error[%d]", error_code);
2012                 goto CATCH;
2013         } else if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2014                 _ERR("bm appid_usage deletion failed - error[%d]", error_code);
2015                 return error_code;
2016         }
2017
2018         /*delete AppId Map table*/
2019         error_code = bm_delete_table(bm_db_handle, &hstmt, num_AppId, AppId, BATTERY_MONITOR_APP_ID_MAP_TABLE);
2020         if ((error_code == BATTERY_MONITOR_ERROR_DB_FAILED) || (error_code == BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND)) {
2021                 _ERR("bm appid_map deletion failed - db error[%d]", error_code);
2022                 goto CATCH;
2023         } else if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2024                 _ERR("bm appid_map deletion failed - error[%d]", error_code);
2025                 return error_code;
2026         }
2027         is_success = TRUE;
2028
2029 CATCH:
2030         if (hstmt != NULL) {
2031                 rc = bm_query_finalize(hstmt);
2032                 BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
2033                 hstmt = NULL;
2034         }
2035
2036         ret_transaction = bm_end_transaction(bm_db_handle, is_success);
2037         if (ret_transaction != BATTERY_MONITOR_ERROR_NONE)
2038                 _ERR("bm_svc_delete:bm_svc_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success);
2039
2040         EXIT;
2041         return error_code;
2042 }
2043
2044 static int bm_delete_table_by_time_interval(sqlite3 *bm_db_handle, const char* table)
2045 {
2046         ENTER;
2047
2048         _DBG("bm_delete_table start - table[%s]", table);
2049         int error_code = BATTERY_MONITOR_ERROR_NONE;
2050         int rc = 0;
2051         char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
2052         long int duration = bm_get_time_bias(1);
2053         bm_stmt hstmt = NULL;
2054
2055         BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2056         BM_RETURN_VAL((table != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("table is null!"));
2057
2058         if ((g_strcmp0(table, BATTERY_MONITOR_APP_ID_USAGE_TABLE) == 0 || g_strcmp0(table, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE) == 0
2059                                 || g_strcmp0(table, BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE) == 0))
2060                 BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE log_time <= %ld", table, duration);
2061         else
2062                 BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE time_s <= %ld", table, duration);
2063
2064         hstmt = bm_prepare_query(bm_db_handle, query);
2065         if (bm_db_err_code(bm_db_handle) != SQLITE_OK || hstmt == NULL) {
2066                 _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
2067                 return BATTERY_MONITOR_ERROR_DB_FAILED;
2068         }
2069
2070         rc = bm_query_step(hstmt);
2071         if (rc != SQLITE_DONE) {
2072                 _ERR("Query Failed");
2073                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
2074         }
2075
2076         rc = bm_query_finalize(hstmt);
2077         if (rc != BATTERY_MONITOR_ERROR_NONE) {
2078                 _ERR("finalize error");
2079                 error_code = BATTERY_MONITOR_ERROR_DB_FAILED;
2080         }
2081
2082         hstmt =  NULL;
2083
2084         EXIT;
2085         return error_code;
2086 }
2087
2088 /* Manager Functions */
2089 int bm_server_appid_insert_to_db(const char* app_id)
2090 {
2091         ENTER;
2092
2093         int error_code = BATTERY_MONITOR_ERROR_NONE;
2094         int ret_transaction = 0;
2095         int to_insert = true;
2096
2097         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2098         BM_RETURN_VAL((app_id != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("Mandatory field app_id NULL"));
2099
2100         /* Checking if already inserted */
2101         to_insert = app_name_check_duplicated(g_hBatteryMonitorDB, app_id, &error_code);
2102         if (to_insert && error_code == BATTERY_MONITOR_ERROR_NONE) {
2103                 _DBG("AppID - [%s]  already exists", app_id);
2104                 return BATTERY_MONITOR_ERROR_NONE;
2105         } else if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2106                 _ERR("Duplicate check failed");
2107                 return error_code;
2108         }
2109
2110         pthread_mutex_lock(&battery_monitor_mutex);
2111
2112         /* Transaction Control Required */
2113         ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
2114         if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
2115                 pthread_mutex_unlock(&battery_monitor_mutex);
2116                 _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
2117                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
2118         }
2119         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2120                 _ERR("AppId map table insert:bm_begin_transaction fail %d\n", ret_transaction);
2121                 pthread_mutex_unlock(&battery_monitor_mutex);
2122                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2123         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2124                 _ERR("AppId map table insert:bm_begin_transaction fail %d\n", ret_transaction);
2125                 pthread_mutex_unlock(&battery_monitor_mutex);
2126                 return ret_transaction;
2127         }
2128
2129         error_code = bm_appid_map_insert_to_db(g_hBatteryMonitorDB, app_id);
2130         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2131                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2132                 _ERR("INSERT appid fail, rollback insert query(%d)!!!!\n", ret_transaction);
2133                 pthread_mutex_unlock(&battery_monitor_mutex);
2134                 return error_code;
2135         }
2136
2137         pthread_mutex_unlock(&battery_monitor_mutex);
2138         bm_end_transaction(g_hBatteryMonitorDB, true);
2139
2140         EXIT;
2141         return BATTERY_MONITOR_ERROR_NONE;
2142 }
2143
2144 int bm_server_resource_usage_insert_to_db(resourceid_usage_s *bm_resource_type)
2145 {
2146         ENTER;
2147
2148         int error_code = BATTERY_MONITOR_ERROR_NONE;
2149         int ret_transaction = 0;
2150
2151         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2152         BM_RETURN_VAL((bm_resource_type != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The Battery Monitor Handle is NULL"));
2153
2154         pthread_mutex_lock(&battery_monitor_mutex);
2155
2156         /* Transaction Control Required */
2157         ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
2158         if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
2159                 pthread_mutex_unlock(&battery_monitor_mutex);
2160                 _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
2161                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
2162         }
2163         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2164                 _ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2165                 pthread_mutex_unlock(&battery_monitor_mutex);
2166                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2167         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2168                 _ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2169                 pthread_mutex_unlock(&battery_monitor_mutex);
2170                 return ret_transaction;
2171         }
2172
2173         error_code = bm_resourceid_usage_insert_to_db(g_hBatteryMonitorDB, bm_resource_type);
2174         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2175                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2176                 _ERR("INSERT resource usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
2177                 pthread_mutex_unlock(&battery_monitor_mutex);
2178                 return error_code;
2179         }
2180         pthread_mutex_unlock(&battery_monitor_mutex);
2181         bm_end_transaction(g_hBatteryMonitorDB, true);
2182
2183         EXIT;
2184         return BATTERY_MONITOR_ERROR_NONE;
2185 }
2186
2187 int bm_server_resource_base_usage_insert_to_db(resourceid_usage_s *bm_resource_type)
2188 {
2189         ENTER;
2190
2191         int error_code = BATTERY_MONITOR_ERROR_NONE;
2192         int ret_transaction = 0;
2193
2194         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2195         BM_RETURN_VAL((bm_resource_type != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The Battery Monitor Handle is NULL"));
2196
2197         pthread_mutex_lock(&battery_monitor_mutex);
2198
2199         /* Transaction Control Required */
2200         ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
2201         if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
2202                 pthread_mutex_unlock(&battery_monitor_mutex);
2203                 _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
2204                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
2205         }
2206         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2207                 _ERR("Resource Base Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2208                 pthread_mutex_unlock(&battery_monitor_mutex);
2209                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2210         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2211                 _ERR("Resource Base Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2212                 pthread_mutex_unlock(&battery_monitor_mutex);
2213                 return ret_transaction;
2214         }
2215
2216         error_code = bm_resourceid_base_usage_insert_to_db(g_hBatteryMonitorDB, bm_resource_type);
2217         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2218                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2219                 _ERR("INSERT resource base usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
2220                 pthread_mutex_unlock(&battery_monitor_mutex);
2221                 return error_code;
2222         }
2223         pthread_mutex_unlock(&battery_monitor_mutex);
2224         bm_end_transaction(g_hBatteryMonitorDB, true);
2225
2226         EXIT;
2227         return BATTERY_MONITOR_ERROR_NONE;
2228 }
2229
2230 int bm_server_app_usage_insert_to_db(appid_usage_s *bm_app_type)
2231 {
2232         ENTER;
2233
2234         int error_code = BATTERY_MONITOR_ERROR_NONE;
2235         int ret_transaction = 0;
2236
2237         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2238         BM_RETURN_VAL((bm_app_type != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The Battery Monitor Handle is NULL"));
2239
2240         pthread_mutex_lock(&battery_monitor_mutex);
2241
2242         /* Transaction Control Required */
2243         ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
2244         if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
2245                 pthread_mutex_unlock(&battery_monitor_mutex);
2246                 _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
2247                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
2248         }
2249         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2250                 _ERR("App Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2251                 pthread_mutex_unlock(&battery_monitor_mutex);
2252                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2253         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2254                 _ERR("App Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2255                 pthread_mutex_unlock(&battery_monitor_mutex);
2256                 return ret_transaction;
2257         }
2258
2259         error_code = bm_appid_usage_insert_to_db(g_hBatteryMonitorDB, bm_app_type);
2260         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2261                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2262                 _ERR("INSERT app usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
2263                 pthread_mutex_unlock(&battery_monitor_mutex);
2264                 return error_code;
2265         }
2266
2267         pthread_mutex_unlock(&battery_monitor_mutex);
2268         bm_end_transaction(g_hBatteryMonitorDB, true);
2269
2270         EXIT;
2271         return BATTERY_MONITOR_ERROR_NONE;
2272 }
2273
2274 /* For App usage related queries */
2275 appid_usage_s *bm_server_query_app_usage_by_appid_ci(const char *app_id, long long s_time, long long e_time, int *error_code)
2276 {
2277         ENTER;
2278
2279         appid_usage_s *bm_app_type = NULL;
2280         *error_code = BATTERY_MONITOR_ERROR_NONE;
2281
2282         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code =  BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2283         BM_RETURN_VAL((app_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, NULL, ("The Battery Monitor Handle is NULL"));
2284
2285         bm_app_type = bm_query_usage_by_appid_ci(g_hBatteryMonitorDB, app_id, s_time, e_time, error_code);
2286
2287         EXIT;
2288         return bm_app_type;
2289 }
2290
2291 /* For Resource usage related queries */
2292 resourceid_usage_s *bm_server_query_resource_usage_resourceid_ci(const char *resource_id, long long s_time, long long e_time, int *error_code)
2293 {
2294         resourceid_usage_s *bm_resource_type = NULL;
2295         *error_code = BATTERY_MONITOR_ERROR_NONE;
2296
2297         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2298         BM_RETURN_VAL((resource_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, NULL, ("The Battery Monitor Handle is NULL"));
2299
2300         bm_resource_type = bm_query_usage_by_resourceid_ci(g_hBatteryMonitorDB, resource_id, s_time, e_time, error_code);
2301
2302         EXIT;
2303         return bm_resource_type;
2304 }
2305
2306 resourceid_usage_s *bm_server_query_resource_base_usage_resourceid_ci(const char *resource_id, long long s_time, long long e_time, int *error_code)
2307 {
2308         resourceid_usage_s *bm_resource_type = NULL;
2309         *error_code = BATTERY_MONITOR_ERROR_NONE;
2310
2311         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2312         BM_RETURN_VAL((resource_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, NULL, ("The Battery Monitor Handle is NULL"));
2313
2314         bm_resource_type = bm_query_base_usage_by_resourceid_ci(g_hBatteryMonitorDB, resource_id, s_time, e_time, error_code);
2315
2316         EXIT;
2317         return bm_resource_type;
2318 }
2319
2320 resourceid_usage_s *bm_server_query_battery_last_charge(const char *resource_id, int *error_code)
2321 {
2322         resourceid_usage_s *bm_resource_type = NULL;
2323         *error_code = BATTERY_MONITOR_ERROR_NONE;
2324
2325         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2326         BM_RETURN_VAL((resource_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, NULL, ("The Battery Monitor Handle is NULL"));
2327
2328         bm_resource_type = bm_query_battery_last_charge(g_hBatteryMonitorDB, resource_id, error_code);
2329
2330         EXIT;
2331         return bm_resource_type;
2332 }
2333
2334 GSList* bm_server_query_appid_map(int *error_code)
2335 {
2336         ENTER;
2337
2338         GSList *list = NULL;
2339         *error_code = BATTERY_MONITOR_ERROR_NONE;
2340
2341         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2342         list = bm_query_appid_map(g_hBatteryMonitorDB, error_code);
2343
2344         EXIT;
2345         return list;
2346 }
2347
2348 int bm_server_delete_table_by_appid(const char* app_id)
2349 {
2350         ENTER;
2351
2352         int error_code = BATTERY_MONITOR_ERROR_NONE;
2353
2354         BM_RETURN_VAL((app_id != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("Application Id is NULL"));
2355         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2356         pthread_mutex_lock(&battery_monitor_mutex);
2357
2358         error_code = bm_delete_table_by_app_id(g_hBatteryMonitorDB, app_id);
2359         if (error_code != BATTERY_MONITOR_ERROR_NONE)
2360                 _ERR("Delete of table by app_id failed");
2361
2362         pthread_mutex_unlock(&battery_monitor_mutex);
2363
2364         EXIT;
2365         return error_code;
2366 }
2367
2368 int bm_server_delete_table_by_time_interval(void)
2369 {
2370         ENTER;
2371
2372         int error_code = BATTERY_MONITOR_ERROR_NONE;
2373         int ret_transaction = 0;
2374
2375         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2376         pthread_mutex_lock(&battery_monitor_mutex);
2377
2378         /* Transaction Control Required */
2379         ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
2380         if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
2381                 pthread_mutex_unlock(&battery_monitor_mutex);
2382                 _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
2383                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
2384         }
2385         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2386                 _ERR("Usage Delete:bm_begin_transaction fail %d\n", ret_transaction);
2387                 pthread_mutex_unlock(&battery_monitor_mutex);
2388                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2389         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2390                 _ERR("Usage Delete:bm_begin_transaction fail %d\n", ret_transaction);
2391                 pthread_mutex_unlock(&battery_monitor_mutex);
2392                 return ret_transaction;
2393         }
2394         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE);
2395         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2396                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2397                 _ERR("Delete old resource usage fail, rollback delete query(%d)!!!!\n", ret_transaction);
2398                 pthread_mutex_unlock(&battery_monitor_mutex);
2399                 return error_code;
2400         }
2401         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_APP_ID_USAGE_TABLE);
2402         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2403                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2404                 _ERR("Delete old app usage fail, rollback delete query(%d)!!!!\n", ret_transaction);
2405                 pthread_mutex_unlock(&battery_monitor_mutex);
2406                 return error_code;
2407         }
2408         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE);
2409         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2410                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2411                 _ERR("Delete old resource base usage fail, rollback delete query(%d)!!!!\n", ret_transaction);
2412                 pthread_mutex_unlock(&battery_monitor_mutex);
2413                 return error_code;
2414         }
2415         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_BLE_STAT_TABLE);
2416         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2417                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2418                 _ERR("Delete ble_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2419                 pthread_mutex_unlock(&battery_monitor_mutex);
2420                 return error_code;
2421         }
2422         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_WFL_STAT_TABLE);
2423         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2424                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2425                 _ERR("Delete wifi_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2426                 pthread_mutex_unlock(&battery_monitor_mutex);
2427                 return error_code;
2428         }
2429         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
2430         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2431                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2432                 _ERR("Delete gcpu_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2433                 pthread_mutex_unlock(&battery_monitor_mutex);
2434                 return error_code;
2435         }
2436         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_BR_STAT_TABLE);
2437         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2438                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2439                 _ERR("Delete sbr_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2440                 pthread_mutex_unlock(&battery_monitor_mutex);
2441                 return error_code;
2442         }
2443         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_SGT_STAT_TABLE);
2444         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2445                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2446                 _ERR("Delete sgt_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2447                 pthread_mutex_unlock(&battery_monitor_mutex);
2448                 return error_code;
2449         }
2450         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_WST_STAT_TABLE);
2451         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2452                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2453                 _ERR("Delete wst_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2454                 pthread_mutex_unlock(&battery_monitor_mutex);
2455                 return error_code;
2456         }
2457         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_BST_STAT_TABLE);
2458         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2459                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2460                 _ERR("Delete bst_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2461                 pthread_mutex_unlock(&battery_monitor_mutex);
2462                 return error_code;
2463         }
2464         error_code = bm_delete_table_by_time_interval(g_hBatteryMonitorDB, BATTERY_MONITOR_GBL_NT_STAT_TABLE);
2465         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2466                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2467                 _ERR("Delete nt_stat fail, rollback delete query(%d)!!!!\n", ret_transaction);
2468                 pthread_mutex_unlock(&battery_monitor_mutex);
2469                 return error_code;
2470         }
2471
2472         pthread_mutex_unlock(&battery_monitor_mutex);
2473         bm_end_transaction(g_hBatteryMonitorDB, true);
2474
2475         EXIT;
2476         return BATTERY_MONITOR_ERROR_NONE;
2477 }
2478
2479 /* Battery Dump DB Operations */
2480 int bm_server_battery_dump_insert_to_db(void *str_data, int type)
2481 {
2482         ENTER;
2483
2484         int error_code = BATTERY_MONITOR_ERROR_NONE;
2485         int ret_transaction = 0;
2486
2487         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2488         BM_RETURN_VAL((str_data != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("The Battery Dump Data is NULL"));
2489
2490         pthread_mutex_lock(&battery_monitor_mutex);
2491
2492         /* Transaction Control Required */
2493         ret_transaction = bm_begin_transaction(g_hBatteryMonitorDB);
2494         if (bm_db_err_code(g_hBatteryMonitorDB) == SQLITE_PERM) {
2495         pthread_mutex_unlock(&battery_monitor_mutex);
2496                 _ERR("Access failed(%s)", bm_db_err_msg(g_hBatteryMonitorDB));
2497                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
2498         }
2499         if (ret_transaction == BATTERY_MONITOR_ERROR_DATABASE_BUSY) {
2500                 _ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2501                 pthread_mutex_unlock(&battery_monitor_mutex);
2502                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
2503         } else if (ret_transaction != BATTERY_MONITOR_ERROR_NONE) {
2504                 _ERR("Resource Usage insert:bm_begin_transaction fail %d\n", ret_transaction);
2505                 pthread_mutex_unlock(&battery_monitor_mutex);
2506                 return ret_transaction;
2507         }
2508         error_code = bm_battery_stat_insert_to_db(g_hBatteryMonitorDB, str_data, type);
2509         if (error_code != BATTERY_MONITOR_ERROR_NONE) {
2510                 ret_transaction = bm_end_transaction(g_hBatteryMonitorDB, false);
2511                 _ERR("INSERT resource usage fail, rollback insert query(%d)!!!!\n", ret_transaction);
2512                 pthread_mutex_unlock(&battery_monitor_mutex);
2513                 return error_code;
2514         }
2515
2516         pthread_mutex_unlock(&battery_monitor_mutex);
2517         bm_end_transaction(g_hBatteryMonitorDB, true);
2518
2519         EXIT;
2520         return BATTERY_MONITOR_ERROR_NONE;
2521 }
2522
2523 int bm_server_battery_dump_query_from_db(void *str_data, int type, long int duration)
2524 {
2525         ENTER;
2526         int ret = BATTERY_MONITOR_ERROR_NONE;
2527
2528         BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), \
2529                 { ret = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, ret, ("The database isn't connected."));
2530
2531         BM_RETURN_VAL((str_data != NULL), \
2532                 { ret  = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, ret, ("The Battery Dump Handle is NULL"));
2533
2534         ret = bm_battery_stat_query_from_db(g_hBatteryMonitorDB, str_data, type, duration);
2535
2536         EXIT;
2537         return ret;
2538 }
2539
2540 int initialize_database(void)
2541 {
2542         ENTER;
2543
2544         int return_code = BATTERY_MONITOR_ERROR_NONE;
2545
2546         return_code = bm_db_open();
2547         if (return_code != BATTERY_MONITOR_ERROR_NONE) {
2548                 _ERR("Battery Monitor DB Open Error");
2549                 return -1;
2550         }
2551
2552         EXIT;
2553         return BATTERY_MONITOR_ERROR_NONE;
2554 }
2555
2556 int deinitialize_database(void)
2557 {
2558         ENTER;
2559
2560         int return_code = BATTERY_MONITOR_ERROR_NONE;
2561
2562         return_code = bm_db_close();
2563         if (return_code != BATTERY_MONITOR_ERROR_NONE) {
2564                 _ERR("Battery Monitor DB Open Error");
2565                 return -1;
2566         }
2567
2568         EXIT;
2569         return BATTERY_MONITOR_ERROR_NONE;
2570 }