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