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