src/battery_dump/bd_history_item.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 <dumpsys-system.h>
  19 #include <string.h>
  20 #include <stdlib.h>
  21 #include <sys/time.h>
  22 #include <glib/gprintf.h>
  23 #include <stdio.h>
  24 #include <unistd.h>
  25 #include "bd_history_item.h"
  26 #include "bm_util.h"
  27 #include "bm_dbg.h"
  28 #include "bm_common.h"
  29 #include "bm_server_db.h"
  30 #include "bm_private.h"
  31 #include "bd_private.h"
  32 #include "bm_config_parser.h"
  33
  34 //#define DUMP_DUMMY 1
  35 #ifdef DUMP_DUMMY
  36 #include "bd_history_item_dummy.h"
  37 #endif
  38
  39 dump_data_s history_data[HISTORY_SIZE_MAX];
  40 int h_count = 0; int h_flag = false;
  41 char state1_map[32][4] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Wm",
  42         "", "Sd", "BP", "S", "Psc", "a", "s", "", "Pr", "Wr", "Ws", "Wl", "g", "w", "r"};
  43 char state2_map[32][5] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
  44         "", "Ud", "Chtp", "bles", "ca", "b", "Pcl", "ch", "", "", "fl", "W", "Ww", "v", "ps"};
  45 char event_map[32][4] = {"Enl", "Epr", "Efg", "Etp", "Esy", "Ewl", "Ejb", "Eur", "Euf", "Ecn",
  46         "Eac", "Epi", "Epu", "Eal", "Est", "Eai", "Eaa", "Etw", "Esw", "Ewa", "Elw", "Eec"};
  47 char usage_map[32][4] = {"Bu", "Wu", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
  48         "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""};
  49 GHashTable *app_map = NULL;
  50 static long int lst_charge = -1;
  51
  52 static int bd_print_pool_entry(int fd, int idx, int pc, history_tag_s *pool_info)
  53 {
  54         ENTER;
  55
  56         BM_CHECK_INPUT_PARAM(pool_info);
  57         _DBG("Value from history data %d", idx);
  58
  59         GString *dump_p = g_string_sized_new(30);
  60         BM_CHECK_MEM_ALLOC(dump_p, {});
  61
  62         g_string_append(dump_p, TIZEN_DUMP_VERSION);
  63         g_string_append_c(dump_p, ',');
  64         g_string_append(dump_p, DUMP_DATA_TAG_1);
  65         g_string_append_c(dump_p, ',');
  66         g_string_append_printf(dump_p, "%d,", pc);
  67         g_string_append_printf(dump_p, "%d,", pool_info->uid);
  68         g_string_append(dump_p, "\"");
  69
  70         if (pool_info->string_info != NULL) {
  71                 gchar *temp = g_strdup(pool_info->string_info->str);
  72                 g_string_append(dump_p, temp);
  73                 g_free(temp);
  74         }
  75
  76         g_string_append(dump_p, "\"");
  77         g_string_append(dump_p, "\n");
  78
  79         _DBG("%s", dump_p->str);
  80
  81         if (write(fd, dump_p->str, dump_p->len) < 0)
  82                 _WARN("write error");
  83
  84         g_string_free(dump_p, TRUE);
  85
  86         EXIT;
  87         return BATTERY_MONITOR_ERROR_NONE;
  88 }
  89
  90 static int bd_get_pool_entry_from_dump(int fd)
  91 {
  92         ENTER;
  93
  94         GString *dump_p = g_string_sized_new(30);
  95         BM_CHECK_MEM_ALLOC(dump_p, {});
  96
  97         g_string_append(dump_p, TIZEN_DUMP_VERSION);
  98         g_string_append(dump_p, ",0");
  99         g_string_append(dump_p, ",i");
 100         g_string_append(dump_p, ",vers");
 101         g_string_append(dump_p, ",19,150,NMF26V,NMF26V");
 102         g_string_append(dump_p, "\n");
 103
 104         _DBG("%s", dump_p->str);
 105
 106         if (write(fd, dump_p->str, dump_p->len) < 0)
 107                 _WARN("write error");
 108         g_string_free(dump_p, TRUE);
 109
 110         int ret = BATTERY_MONITOR_ERROR_NONE;
 111         int log_count = h_count; int pool_count = 0;
 112         for (int i = 0; i < log_count; i++) {
 113                 history_tag_s *pool_info = NULL;
 114                 if (history_data[i].event_tag != NULL && (history_data[i].event_code & ET_FLAG_START)) {
 115                         pool_info = history_data[i].event_tag;
 116                                 ret = bd_print_pool_entry(fd, i, pool_count, pool_info);
 117                                 pool_count++;
 118                                 if (ret != BATTERY_MONITOR_ERROR_NONE)
 119                                         return BATTERY_MONITOR_ERROR_INTERNAL;
 120                 }
 121                 if (history_data[i].wakelock_tag != NULL) {
 122                         pool_info = history_data[i].wakelock_tag;
 123                                 ret = bd_print_pool_entry(fd, i, pool_count, pool_info);
 124                                 pool_count++;
 125                                 if (ret != BATTERY_MONITOR_ERROR_NONE)
 126                                         return BATTERY_MONITOR_ERROR_INTERNAL;
 127                 }
 128                 if (history_data[i].wakereason_tag != NULL) {
 129                         pool_info = history_data[i].wakereason_tag;
 130                                 ret = bd_print_pool_entry(fd, i, pool_count, pool_info);
 131                                 pool_count++;
 132                                 if (ret != BATTERY_MONITOR_ERROR_NONE)
 133                                         return BATTERY_MONITOR_ERROR_INTERNAL;
 134                 }
 135         }
 136
 137         EXIT;
 138         return BATTERY_MONITOR_ERROR_NONE;
 139 }
 140
 141 static int bd_get_and_print_system_base_battery_usage_from_dump(int fd, long int duration)
 142 {
 143         ENTER;
 144
 145         int ret = BATTERY_MONITOR_ERROR_NONE;
 146         float usage_mah = 0;
 147         time_t crr_time = 0; time(&crr_time);
 148         int uid_n = 1000; //For Tizen
 149         // Base Resource usage;
 150         const char *rid_str = NULL;
 151         for (int i = 0; i < 6; i++) {
 152                 rid_str = bm_get_resource_id_string(i);
 153                 if (g_strcmp0(rid_str, "UNKNOWN RESOURCE-ID") == 0) {
 154                         _ERR("invalid resource-id");
 155                         return BATTERY_MONITOR_ERROR_INTERNAL;
 156                 }
 157                 resourceid_usage_s *res_use =
 158                         bm_server_query_resource_base_usage_resourceid_ci(rid_str, duration, crr_time, &ret);
 159                 if (res_use == NULL || ret != BATTERY_MONITOR_ERROR_NONE) {
 160                         _ERR("For resourceid %s", rid_str);
 161                         continue;
 162                 }
 163                 usage_mah += res_use->usage;
 164                 bm_resourceid_usage_free(res_use);
 165         }
 166         usage_mah /= 3600;
 167         GString *dump_p = NULL;
 168         dump_p = g_string_sized_new(30);
 169         BM_CHECK_MEM_ALLOC(dump_p, {});
 170         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 171         g_string_append_printf(dump_p, ",%d,l,pwi,uid,", uid_n);
 172         g_string_append_printf(dump_p, "%0.2f", usage_mah);
 173         g_string_append(dump_p, "\n");
 174         _DBG("%s", dump_p->str);
 175         if (write(fd, dump_p->str, dump_p->len) < 0)
 176                 _WARN("write error");
 177         g_string_free(dump_p, TRUE);
 178
 179         EXIT;
 180         return ret;
 181 }
 182
 183 static int bd_get_and_print_battery_usage_from_dump(int fd, long int duration)
 184 {
 185         ENTER;
 186         int ret = BATTERY_MONITOR_ERROR_NONE;
 187         // Application usage;
 188         GHashTableIter iter;
 189         gpointer key, value; GString *dump_p = NULL;
 190         char *appid = NULL; int *uid_n = NULL;
 191         time_t crr_time = 0; time(&crr_time);
 192         long int end_t = crr_time;
 193         float usageMAh = 0; int battery_capacity = 500;//default
 194
 195         ret = bm_get_battery_power_params(&battery_capacity);
 196         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 197                 _ERR("unable read read battery capacity");
 198                 battery_capacity = 500;
 199         }
 200
 201         dump_p = g_string_sized_new(30);
 202         BM_CHECK_MEM_ALLOC(dump_p, {});
 203
 204         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 205         // Power Capacity
 206         g_string_append_printf(dump_p, ",0,l,pws,%d,0,0,0", battery_capacity);
 207         g_string_append(dump_p, "\n");
 208
 209         _DBG("%s", dump_p->str);
 210
 211         if (write(fd, dump_p->str, dump_p->len) < 0)
 212                 _WARN("write error");
 213
 214         g_string_free(dump_p, TRUE);
 215
 216         g_hash_table_iter_init(&iter, app_map);
 217         while (g_hash_table_iter_next(&iter, &key, &value)) {
 218                 uid_n = (int *)key; appid = (char *)value;
 219                 _DBG("%d %s", *uid_n, appid); usageMAh = 0;
 220                 // Currently giving app usage of last one week;
 221                 // Modify it wrt to time
 222                 appid_usage_s *app_use = bm_server_query_app_usage_by_appid_ci(appid, duration, end_t, &ret);
 223                 if (app_use == NULL || ret != BATTERY_MONITOR_ERROR_NONE) {
 224                         _ERR("For appid %s", appid);
 225                         continue;
 226                 }
 227                 usageMAh = (app_use->rId_ble + app_use->rId_wifi + app_use->rId_cpu +
 228                                 app_use->rId_display + app_use->rId_device_network +
 229                                 app_use->rId_gps + app_use->rId_hrm);
 230                 // usage stored as mAs changed to mAh
 231                 usageMAh = (usageMAh/3600);
 232                 dump_p = g_string_sized_new(30);
 233                 BM_CHECK_MEM_ALLOC(dump_p, { BM_FREE(app_use); });
 234                 g_string_append(dump_p, TIZEN_DUMP_VERSION);
 235                 g_string_append_printf(dump_p, ",%d,l,pwi,uid,", *uid_n);
 236                 g_string_append_printf(dump_p, "%0.2f", usageMAh);
 237                 g_string_append(dump_p, "\n");
 238                 bm_appid_usage_free(app_use);
 239                 _DBG("%s", dump_p->str);
 240                 if (write(fd, dump_p->str, dump_p->len) < 0)
 241                         _WARN("write error");
 242                 g_string_free(dump_p, TRUE);
 243         }
 244         // Resource usage;
 245         const char *rid_str = NULL;
 246         for (int i = 0; i < 6; i++) {
 247                 int usage = 0;
 248                 rid_str = bm_get_resource_id_string(i);
 249                 if (g_strcmp0(rid_str, "UNKNOWN RESOURCE-ID") == 0) {
 250                         _ERR("invalid resource-id");
 251                         return BATTERY_MONITOR_ERROR_INTERNAL;
 252                 }
 253                 resourceid_usage_s *res_use =
 254                         bm_server_query_resource_usage_resourceid_ci(rid_str, duration, end_t, &ret);
 255                 if (res_use == NULL || ret != BATTERY_MONITOR_ERROR_NONE) {
 256                         _ERR("For resourceid %s", rid_str);
 257                         continue;
 258                 }
 259                 dump_p = g_string_sized_new(30);
 260                 BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(res_use); });
 261                 usage = res_use->usage;
 262                 // usage stored as mAs changed to mAh
 263                 usageMAh = (float)usage/3600;
 264                 g_string_append(dump_p, TIZEN_DUMP_VERSION);
 265                 switch (i) {
 266                 case 0://BT
 267                         g_string_append(dump_p, ",0,l,pwi,blue,");
 268                         break;
 269                 case 1://WIFI
 270                         g_string_append(dump_p, ",0,l,pwi,wifi,");
 271                         break;
 272                 case 2://CPU
 273                         g_string_append(dump_p, ",0,l,pwi,phone,");
 274                         break;
 275                 case 3://DISP
 276                         g_string_append(dump_p, ",0,l,pwi,scrn,");
 277                         break;
 278                 case 4://DEVICE NT
 279                         g_string_append(dump_p, ",0,l,pwi,cell,");
 280                         break;
 281                 default://GPS HRM
 282                         g_string_append(dump_p, ",0,l,pwi,unacc,");
 283                         break;
 284                 }
 285                 g_string_append_printf(dump_p, "%0.2f", usageMAh);
 286                 g_string_append(dump_p, "\n");
 287                 bm_resourceid_usage_free(res_use);
 288                 _DBG("%s", dump_p->str);
 289                 if (write(fd, dump_p->str, dump_p->len) < 0)
 290                         _WARN("write error");
 291                 g_string_free(dump_p, TRUE);
 292         }
 293
 294         ret = bd_get_and_print_system_base_battery_usage_from_dump(fd, duration);
 295         if (ret != BATTERY_MONITOR_ERROR_NONE)
 296                 _ERR("Base usage dump failed");
 297
 298         EXIT;
 299         return ret;
 300 }
 301
 302 static int bd_get_and_print_gbr_stat_entry_from_dump(int fd, long int duration)
 303 {
 304         ENTER;
 305         // Dump brightness Data
 306         bd_gl_sbr_stat_s *gbr_stat = (bd_gl_sbr_stat_s *)calloc(1, sizeof(bd_gl_sbr_stat_s));
 307         BM_CHECK_MEM_ALLOC(gbr_stat, {});
 308
 309         int ret = BATTERY_MONITOR_ERROR_NONE;
 310         ret = bm_server_battery_dump_query_from_db(gbr_stat, 3, duration);
 311         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 312                 _ERR("Unable to fetch data from DB");
 313                 BM_FREE(gbr_stat);
 314                 return ret;
 315         }
 316
 317         GString *dump_p = g_string_sized_new(30);
 318         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gbr_stat); });
 319         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 320         g_string_append(dump_p, ",0,l,");
 321         g_string_append(dump_p, "br,");
 322         g_string_append_printf(dump_p, "%ld,", gbr_stat->dark); //OFF
 323         g_string_append_printf(dump_p, "%ld,", gbr_stat->dim); // All are time values
 324         g_string_append_printf(dump_p, "%ld,", gbr_stat->medium);
 325         g_string_append_printf(dump_p, "%ld,", gbr_stat->light); //DEF: 0
 326         g_string_append_printf(dump_p, "%ld", gbr_stat->bright);
 327         g_string_append(dump_p, "\n");
 328         _DBG("%s", dump_p->str);//write
 329         if (write(fd, dump_p->str, dump_p->len) < 0)
 330                 _WARN("write error");
 331         g_string_free(dump_p, TRUE);
 332         BM_FREE(gbr_stat);
 333
 334         EXIT;
 335         return ret;
 336 }
 337
 338 static int bd_get_and_print_misc_stat_entry_from_dump(int fd, long int duration)
 339 {
 340         ENTER;
 341         //Dump screen on and off time
 342         //Modify m - field accordingly.
 343         bd_gl_sbr_stat_s *gbr_stat = (bd_gl_sbr_stat_s *)calloc(1, sizeof(bd_gl_sbr_stat_s));
 344         BM_CHECK_MEM_ALLOC(gbr_stat, {});
 345
 346         int ret = BATTERY_MONITOR_ERROR_NONE;
 347         ret = bm_server_battery_dump_query_from_db(gbr_stat, 3, duration);
 348         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 349                 _ERR("Unable to fetch data from DB");
 350                 BM_FREE(gbr_stat);
 351                 return ret;
 352         }
 353
 354         GString *dump_p = g_string_sized_new(30);
 355         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gbr_stat); });
 356         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 357         g_string_append(dump_p, ",0,l,");
 358         g_string_append(dump_p, "m,");
 359         long int off_time = gbr_stat->dark;
 360         long int on_time = (gbr_stat->dim + gbr_stat->medium + gbr_stat->bright);
 361         g_string_append_printf(dump_p, "%ld,", on_time);
 362         g_string_append_printf(dump_p, "%ld", off_time);
 363         g_string_append(dump_p, "\n");
 364
 365         _DBG("%s", dump_p->str);
 366         if (write(fd, dump_p->str, dump_p->len) < 0)
 367                 _WARN("write error");
 368         g_string_free(dump_p, TRUE);
 369         BM_FREE(gbr_stat);
 370
 371         EXIT;
 372         return ret;
 373 }
 374
 375 static int bd_get_and_print_gn_stat_entry_from_dump(int fd, long int duration)
 376 {
 377         ENTER;
 378
 379         // Dump Network Data
 380         bd_gl_ntw_stat_s *gn_stat = (bd_gl_ntw_stat_s *)calloc(1, sizeof(bd_gl_ntw_stat_s));
 381         BM_CHECK_MEM_ALLOC(gn_stat, {});
 382         int ret = BATTERY_MONITOR_ERROR_NONE;
 383         ret = bm_server_battery_dump_query_from_db(gn_stat, 2, duration);
 384         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 385                 _ERR("Unable to fetch data from DB");
 386                 BM_FREE(gn_stat);
 387                 return ret;
 388         }
 389
 390         GString *dump_p = g_string_sized_new(30);
 391         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gn_stat); });
 392
 393         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 394         g_string_append(dump_p, ",0,l,");
 395         g_string_append(dump_p, "gn,");
 396         g_string_append_printf(dump_p, "%ld,", gn_stat->dn_rx_byt);
 397         g_string_append_printf(dump_p, "%ld,", gn_stat->dn_tx_byt);
 398         g_string_append_printf(dump_p, "%ld,", gn_stat->wifi_rx_byt);
 399         g_string_append_printf(dump_p, "%ld,", gn_stat->wifi_tx_byt);
 400         g_string_append_printf(dump_p, "%ld,", gn_stat->dn_rx_pkt);
 401         g_string_append_printf(dump_p, "%ld,", gn_stat->dn_tx_pkt);
 402         g_string_append_printf(dump_p, "%ld,", gn_stat->wifi_rx_pkt);
 403         g_string_append_printf(dump_p, "%ld,", gn_stat->wifi_tx_pkt);
 404         g_string_append_printf(dump_p, "%d,", 0); //add this to struct as well
 405         g_string_append_printf(dump_p, "%d", 0);
 406         g_string_append(dump_p, "\n");
 407
 408         /*_DBG("%s", dump_p->str);//write
 409         if (write(fd, dump_p->str, dump_p->len) < 0)
 410                 _WARN("write error");*/
 411         g_string_free(dump_p, TRUE);
 412         BM_FREE(gn_stat);
 413
 414         EXIT;
 415         return ret;
 416 }
 417
 418 static int bd_get_and_print_gwf_stat_entry_from_dump(int fd, long int duration)
 419 {
 420         ENTER;
 421         // Dump Wifi Stats
 422         bd_gl_wifi_stat_s *gwfl_stat = (bd_gl_wifi_stat_s *)calloc(1, sizeof(bd_gl_wifi_stat_s));
 423         BM_CHECK_MEM_ALLOC(gwfl_stat, {});
 424
 425         int ret = BATTERY_MONITOR_ERROR_NONE;
 426         ret = bm_server_battery_dump_query_from_db(gwfl_stat, 1, duration);
 427         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 428                 _ERR("Unable to fetch data from DB");
 429                 BM_FREE(gwfl_stat);
 430                 return ret;
 431         }
 432
 433         GString *dump_p = g_string_sized_new(30);
 434         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gwfl_stat); });
 435         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 436         g_string_append(dump_p, ",0,l,");
 437         g_string_append(dump_p, "gwfl,");
 438         g_string_append_printf(dump_p, "%ld,", gwfl_stat->wifi_on_time);
 439         g_string_append_printf(dump_p, "%ld,", gwfl_stat->wifi_conn_time);
 440         g_string_append(dump_p, "0,0,0");//legacy
 441
 442         g_string_append(dump_p, "\n");
 443         _DBG("%s", dump_p->str);//write
 444         if (write(fd, dump_p->str, dump_p->len) < 0)
 445                 _WARN("write error");
 446         g_string_free(dump_p, TRUE);
 447
 448         dump_p = g_string_sized_new(30);
 449         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gwfl_stat); });
 450         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 451         g_string_append(dump_p, ",0,l,");
 452         g_string_append(dump_p, "gwfcd,");
 453         //idle rx pwi tx
 454         float usage_mah = (float)gwfl_stat->wifi_pwi_val/3600;
 455         g_string_append_printf(dump_p, "%ld,", gwfl_stat->wifi_idle_time);
 456         g_string_append_printf(dump_p, "%ld,", gwfl_stat->wifi_rx_time);
 457         g_string_append_printf(dump_p, "%0.2f,", usage_mah);
 458         g_string_append_printf(dump_p, "%ld", gwfl_stat->wifi_tx_time);
 459         g_string_append(dump_p, "\n");
 460         _DBG("%s", dump_p->str);//write
 461         if (write(fd, dump_p->str, dump_p->len) < 0)
 462                 _WARN("write error");
 463         g_string_free(dump_p, TRUE);
 464         BM_FREE(gwfl_stat);
 465
 466         EXIT;
 467         return ret;
 468 }
 469
 470 static int bd_get_and_print_gble_stat_entry_from_dump(int fd, long int duration)
 471 {
 472         ENTER;
 473         // Dump bt Data
 474         bd_gl_ble_stat_s *gble_stat = (bd_gl_ble_stat_s *)calloc(1, sizeof(bd_gl_ble_stat_s));
 475         BM_CHECK_MEM_ALLOC(gble_stat, {});
 476
 477         int ret = BATTERY_MONITOR_ERROR_NONE;
 478         ret = bm_server_battery_dump_query_from_db(gble_stat, 0, duration);
 479         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 480                 _ERR("Unable to fetch data from DB");
 481                 BM_FREE(gble_stat);
 482                 return ret;
 483         }
 484
 485         GString *dump_p = g_string_sized_new(30);
 486         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gble_stat); });
 487         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 488         g_string_append(dump_p, ",0,l,");
 489         g_string_append(dump_p, "gble,");
 490         float usage_mah = (float)gble_stat->ble_pwi_val/3600;
 491         g_string_append_printf(dump_p, "%ld,", gble_stat->ble_idle_time);
 492         g_string_append_printf(dump_p, "%ld,", gble_stat->ble_rx_time);
 493         g_string_append_printf(dump_p, "%ld,", gble_stat->ble_tx_time);
 494         g_string_append_printf(dump_p, "%0.2f", usage_mah);
 495         g_string_append(dump_p, "\n");
 496
 497         _DBG("%s", dump_p->str);//write
 498         if (write(fd, dump_p->str, dump_p->len) < 0)
 499                 _WARN("write error");
 500         g_string_free(dump_p, TRUE);
 501         BM_FREE(gble_stat);
 502
 503         EXIT;
 504         return ret;
 505 }
 506
 507 static int bd_get_and_print_gst_stat_entry_from_dump(int fd, long int duration)
 508 {
 509         ENTER;
 510
 511         int ret = BATTERY_MONITOR_ERROR_NONE;
 512
 513         bd_gl_sgt_stat_s *gst_stat = (bd_gl_sgt_stat_s *)calloc(1, sizeof(bd_gl_sgt_stat_s));
 514         BM_CHECK_MEM_ALLOC(gst_stat, {});
 515
 516         ret = bm_server_battery_dump_query_from_db(gst_stat, 4, duration);
 517         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 518                 _ERR("Unable to fetch data from DB");
 519                 BM_FREE(gst_stat);
 520                 return ret;
 521         }
 522
 523         GString *dump_p = g_string_sized_new(30);
 524         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gst_stat); });
 525
 526         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 527         g_string_append(dump_p, ",0,l,");
 528         g_string_append(dump_p, "sgt,");
 529         g_string_append_printf(dump_p, "%ld,", gst_stat->none_time);
 530         g_string_append_printf(dump_p, "%ld,", gst_stat->poor_time);
 531         g_string_append_printf(dump_p, "%ld,", gst_stat->med_time);
 532         g_string_append_printf(dump_p, "%ld,", gst_stat->good_time);
 533         g_string_append_printf(dump_p, "%ld", gst_stat->grt_time);
 534         g_string_append(dump_p, "\n");
 535
 536         _DBG("%s", dump_p->str);//write
 537
 538         if (write(fd, dump_p->str, dump_p->len) < 0)
 539                 _WARN("write error");
 540         g_string_free(dump_p, TRUE);
 541
 542         dump_p = g_string_sized_new(30);
 543         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gst_stat); });
 544
 545         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 546         g_string_append(dump_p, ",0,l,");
 547         g_string_append(dump_p, "sst,");
 548         g_string_append_printf(dump_p, "%ld", gst_stat->scan_time);
 549
 550         g_string_append(dump_p, "\n");
 551         _DBG("%s", dump_p->str);//write
 552         if (write(fd, dump_p->str, dump_p->len) < 0)
 553                 _WARN("write error");
 554
 555         g_string_free(dump_p, TRUE);
 556         BM_FREE(gst_stat);
 557
 558         EXIT;
 559         return ret;
 560 }
 561
 562 static int bd_get_and_print_gwst_stat_entry_from_dump(int fd, long int duration)
 563 {
 564         ENTER;
 565         bd_gl_wst_stat_s *gwst_stat = (bd_gl_wst_stat_s *)calloc(1, sizeof(bd_gl_wst_stat_s));
 566         BM_CHECK_MEM_ALLOC(gwst_stat, {});
 567
 568         int ret = BATTERY_MONITOR_ERROR_NONE;
 569         ret = bm_server_battery_dump_query_from_db(gwst_stat, 5, duration);
 570         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 571                 _ERR("Unable to fetch data from DB");
 572                 BM_FREE(gwst_stat);
 573                 return ret;
 574         }
 575
 576         GString *dump_p = g_string_sized_new(30);
 577         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gwst_stat); });
 578         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 579         g_string_append(dump_p, ",0,l,");
 580         g_string_append(dump_p, "wsgt,");
 581 //      g_string_append_printf(dump_p, "%ld,", gwst_stat->wscan_time);
 582         g_string_append_printf(dump_p, "%ld,", gwst_stat->wnone_time);
 583         g_string_append_printf(dump_p, "%ld,", gwst_stat->wpoor_time);
 584         g_string_append_printf(dump_p, "%ld,", gwst_stat->wmed_time);
 585         g_string_append_printf(dump_p, "%ld,", gwst_stat->wgood_time);
 586         g_string_append_printf(dump_p, "%ld", gwst_stat->wgrt_time);
 587         g_string_append(dump_p, "\n");
 588         _DBG("%s", dump_p->str);//write
 589         if (write(fd, dump_p->str, dump_p->len) < 0)
 590                 _WARN("write error");
 591         g_string_free(dump_p, TRUE);
 592         BM_FREE(gwst_stat);
 593
 594         EXIT;
 595         return ret;
 596 }
 597
 598 static int bd_get_and_print_gcpu_stat_entry_from_dump(int fd, long int duration)
 599 {
 600         ENTER;
 601
 602         int ret = BATTERY_MONITOR_ERROR_NONE;
 603         const char *rid_str = NULL; int usage = 0;
 604         time_t crr_time = 0; time(&crr_time);
 605         long int end_t = crr_time;
 606         rid_str = bm_get_resource_id_string(2);
 607         resourceid_usage_s *res_use =
 608                 bm_server_query_resource_usage_resourceid_ci(rid_str, duration, end_t, &ret);
 609         if (res_use == NULL || ret != BATTERY_MONITOR_ERROR_NONE) {
 610                 _ERR("For resourceid %s", rid_str);
 611                 return ret;
 612         }
 613         usage = res_use->usage;
 614         float usagemah = (float)usage/3600;
 615         bd_gl_cpu_stat_s *gcpu_stat = (bd_gl_cpu_stat_s *)calloc(1, sizeof(bd_gl_cpu_stat_s));
 616         BM_CHECK_MEM_ALLOC(gcpu_stat, {BM_FREE(res_use); });
 617         ret = bm_server_battery_dump_query_from_db(gcpu_stat, 7, duration);
 618         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 619                 _ERR("Unable to fetch data from DB");
 620                 BM_FREE(gcpu_stat);
 621                 BM_FREE(res_use);
 622                 return ret;
 623         }
 624
 625         GString *dump_p = g_string_sized_new(30);
 626         BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gcpu_stat); BM_FREE(res_use); });
 627         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 628         g_string_append(dump_p, ",0,l,");
 629         g_string_append(dump_p, "cpu,");
 630         g_string_append_printf(dump_p, "%ld,", gcpu_stat->usr_time);
 631         g_string_append_printf(dump_p, "%ld,", gcpu_stat->sys_time);
 632         g_string_append_printf(dump_p, "%0.2f", usagemah);
 633         g_string_append(dump_p, "\n");
 634         bm_resourceid_usage_free(res_use);
 635         _DBG("%s", dump_p->str);
 636         if (write(fd, dump_p->str, dump_p->len) < 0)
 637                 _WARN("write error");
 638
 639         g_string_free(dump_p, TRUE);
 640         BM_FREE(gcpu_stat);
 641
 642         EXIT;
 643         return ret;
 644 }
 645
 646 static int bd_get_and_print_uid_info_entry_from_dump(int fd)
 647 {
 648         ENTER;
 649         // Dump UID entry
 650         int ret = BATTERY_MONITOR_ERROR_NONE;
 651         GSList *list = bm_server_query_appid_map(&ret);
 652         if (list == NULL) {
 653                 _ERR("NO LIST DATA FOUND");
 654                 return ret;
 655         }
 656         app_map = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
 657         GSList *iter = NULL; GString *dump_p = NULL;
 658         dump_p = g_string_sized_new(30);
 659         BM_CHECK_MEM_ALLOC(dump_p, {bm_set_free_gslist_appid_map(list); });
 660         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 661         g_string_append(dump_p, ",0,i,uid,1000,Tizen\n");
 662         if (write(fd, dump_p->str, dump_p->len) < 0)
 663                 _WARN("write error");
 664         g_string_free(dump_p, TRUE);
 665
 666         for (iter = list; iter != NULL; iter = g_slist_next(iter)) {
 667                 dump_p = g_string_sized_new(30);
 668                 BM_CHECK_MEM_ALLOC(dump_p, {bm_set_free_gslist_appid_map(list); });
 669                 g_string_append(dump_p, TIZEN_DUMP_VERSION);
 670                 g_string_append(dump_p, ",0");
 671                 g_string_append(dump_p, ",i");
 672                 g_string_append(dump_p, ",uid,");
 673                 appid_map_s *amap_data = (appid_map_s *)iter->data;
 674                 g_string_append_printf(dump_p, "%d,", (amap_data->id+10000));
 675                 gchar *temp_str = g_strdup(amap_data->AppId);
 676                 g_string_append(dump_p, amap_data->AppId);
 677                 g_string_append(dump_p, "\n");
 678                 _DBG("%s", dump_p->str);//write
 679                 if (write(fd, dump_p->str, dump_p->len) < 0)
 680                         _WARN("write error");
 681                 g_string_free(dump_p, TRUE);
 682                 int *temp_id = (int *)calloc(1, sizeof(int));
 683                 if (temp_id != NULL) {
 684                         *temp_id = (amap_data->id + 10000);
 685                         _DBG("Insert id %d, str %s, res %d", *temp_id, temp_str,
 686                         g_hash_table_insert(app_map, temp_id, temp_str));
 687                 } else {
 688                         _WARN("Memory Allocation Failed");
 689                         g_free(temp_str);
 690                 }
 691         }
 692         bm_set_free_gslist_appid_map(list);
 693
 694         EXIT;
 695         return ret;
 696 }
 697
 698 static int bd_get_history_detail_from_dump(int index, history_item_s* dump_node)
 699 {
 700         ENTER;
 701         BM_CHECK_INPUT_PARAM(dump_node);
 702
 703         if (h_count >= HISTORY_SIZE_MAX || index > h_count) {
 704                 _ERR("Some Error occured with global index");
 705                 return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
 706         }
 707
 708         _DBG("Value of index %d", index);
 709         _DBG("Value of h_count %d", h_count);
 710
 711         long long dvar1 = 0, dvar2 = 0;
 712         dvar1 = history_data[index].dump_1;
 713         dvar2 = history_data[index].dump_2;
 714
 715         _DBG("Value of encoded value 1 %lld", dvar1);
 716         _DBG("Value of encoded value 2 %lld", dvar2);
 717
 718         dump_node->cmd_s = ((dvar1) & 0xff);
 719         _DBG("cmd_s %d", dump_node->cmd_s);
 720
 721         dump_node->battery_level = ((dvar1>>8) & 0xff);
 722         _DBG("battery_level %d", dump_node->battery_level);
 723
 724         dump_node->battery_status = ((dvar1>>16) & 0xf);
 725         _DBG("battery_status %d", dump_node->battery_status);
 726
 727         dump_node->battery_health = ((dvar1>>20) & 0xf);
 728         _DBG("battery_health %d", dump_node->battery_health);
 729
 730         dump_node->battery_plugtype = ((dvar1>>24) & 0xf);
 731         _DBG("battery_plugtype %d", dump_node->battery_plugtype);
 732
 733         dump_node->battery_temperature = (dvar2 & 0xffffffff);
 734         _DBG("battery_temperature %d", dump_node->battery_temperature);
 735
 736         dump_node->battery_voltage = ((dvar2>>32) & 0x0fffffff);
 737         _DBG("battery_voltage %d", dump_node->battery_voltage);
 738
 739         dump_node->battery_charge = history_data[index].battery_chargeUAh;
 740         _DBG("battery_charge %d", dump_node->battery_charge);
 741
 742         dump_node->event_code = history_data[index].event_code;
 743         _DBG("eventcode %d", dump_node->event_code);
 744
 745         dump_node->state_1 = history_data[index].state_1;
 746         _DBG("state_1 %d", dump_node->state_1);
 747
 748         dump_node->state_2 = history_data[index].state_2;
 749         _DBG("state_2 %d", dump_node->state_2);
 750
 751         dump_node->event_tag = history_data[index].event_tag;
 752         if (dump_node->event_tag == NULL)
 753                 _DBG("Event_Tag_NULL");
 754         dump_node->wakelock_tag = history_data[index].wakelock_tag;
 755         if (dump_node->wakelock_tag == NULL)
 756                 _DBG("Wakelock_Tag_NULL");
 757         dump_node->wakereason_tag = history_data[index].wakereason_tag;
 758         //:Not supported
 759         if (dump_node->wakereason_tag == NULL)
 760                 _DBG("Wakereason_Tag_NULL");
 761
 762         dump_node->time_s = history_data[index].time_s;
 763         _DBG("TIME_S is %lld", dump_node->time_s);
 764
 765         dump_node->time_current = history_data[index].time_current;
 766         _DBG("C TIME is %lld", dump_node->time_current);
 767
 768         dump_node->usage_type = history_data[index].usage_type;
 769         _DBG("Usage type is %d", dump_node->usage_type);
 770
 771         dump_node->usage = history_data[index].usage;
 772         _DBG("Usage is %d", dump_node->usage);
 773
 774         EXIT;
 775         return BATTERY_MONITOR_ERROR_NONE;
 776 }
 777
 778 static void bd_get_last_charge_time(long int def_time, int *ret)
 779 {
 780         ENTER;
 781
 782         if (lst_charge < 0) {
 783                 char *str = "battery";
 784                 resourceid_usage_s *bat_use = bm_server_query_battery_last_charge(str, ret);
 785                 if (*ret == BATTERY_MONITOR_ERROR_NONE) {
 786                         if (bat_use->log_time > 0)
 787                                 lst_charge = bat_use->log_time;
 788                         else
 789                                 lst_charge = def_time;
 790                         _DBG("LC [%ld]", lst_charge);
 791                         BM_FREE(bat_use);
 792                 } else {
 793                         _ERR("LAST CHG time failed");
 794                         lst_charge = def_time;
 795                 }
 796         }
 797
 798         EXIT;
 799         return;
 800 }
 801
 802 int bd_print_history_item_reset(history_item_s* old_state)
 803 {
 804         ENTER;
 805         BM_CHECK_INPUT_PARAM(old_state);
 806
 807         old_state->time_s = -1;
 808         old_state->state_1 = 0;
 809         old_state->state_2 = 0;
 810         old_state->usage_type = 0;
 811         old_state->usage = 0;
 812         old_state->battery_level = -1;
 813         old_state->battery_status = -1;
 814         old_state->battery_health = -1;
 815         old_state->battery_plugtype = -1;
 816         old_state->battery_temperature = -1;
 817         old_state->battery_voltage = -1;
 818         old_state->battery_charge = -1;
 819         old_state->event_code = 0;
 820         old_state->event_tag = NULL;
 821         old_state->wakelock_tag = NULL;
 822         old_state->wakereason_tag = NULL;
 823
 824         EXIT;
 825         return BATTERY_MONITOR_ERROR_NONE;
 826 }
 827
 828 int bd_get_base_time_from_dump(long long *base_time)
 829 {
 830         ENTER;
 831
 832         *base_time = history_data[0].time_s;
 833
 834         EXIT;
 835         return BATTERY_MONITOR_ERROR_NONE;
 836 }
 837
 838 int bd_print_history_item_main(int fd, int num_h_items, long long base_time, bool chkin)
 839 {
 840         ENTER;
 841
 842         if (fd < 0) {
 843                 _ERR("Invalid fd");
 844                 return BATTERY_MONITOR_ERROR_INVALID_PARAMETER;
 845         }
 846
 847         if (h_count >= HISTORY_SIZE_MAX) {
 848                 _ERR("Some Error occured with global index");
 849                 return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
 850         }
 851
 852         int ret = BATTERY_MONITOR_ERROR_NONE;
 853         h_flag = false; //Lock
 854
 855         history_item_s new_state;
 856         history_item_s old_state;
 857
 858         ret = bd_print_history_item_reset(&old_state);
 859         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 860                 _ERR("Old State reset failed");
 861                 return ret;
 862         }
 863
 864         ret = bd_get_pool_entry_from_dump(fd);
 865         if (ret != BATTERY_MONITOR_ERROR_NONE)
 866                 _ERR("S pool data dump failed");
 867
 868         ret = bd_get_base_time_from_dump(&base_time);
 869         if (ret != BATTERY_MONITOR_ERROR_NONE)
 870                 _ERR("Base time error");
 871
 872         int log_count = h_count; GString *dump_p = NULL;
 873         for (int i = 0; i < log_count; i++) {
 874                 ret = bd_get_history_detail_from_dump(i, &new_state);
 875                 if (ret != BATTERY_MONITOR_ERROR_NONE) {
 876                         _ERR("Decode Failed");
 877                         return ret;
 878                 }
 879                 dump_p = g_string_sized_new(30);
 880                 BM_CHECK_MEM_ALLOC(dump_p, {});
 881                 if (chkin) {
 882                         g_string_append(dump_p, TIZEN_DUMP_VERSION);
 883                         g_string_append_c(dump_p, ',');
 884                         _DBG("value %s", dump_p->str);
 885                         g_string_append(dump_p, DUMP_DATA_TAG);
 886                         g_string_append_c(dump_p, ',');
 887                         _DBG("value %s", dump_p->str);
 888                         if (old_state.time_s < 0) {
 889                                 g_string_append_printf(dump_p, "%lld",
 890                                                 (new_state.time_s - base_time));
 891                                 _DBG("value %s", dump_p->str);
 892                         } else {
 893                                 g_string_append_printf(dump_p, "%lld",
 894                                                 (new_state.time_s - old_state.time_s));
 895                                 _DBG("value %s", dump_p->str);
 896                         }
 897                         old_state.time_s = new_state.time_s;
 898                         _DBG("Value old_state.time_s %lld", old_state.time_s);
 899                 } else { //: Let's skip the NC mode in initial version
 900                 }
 901                 if (new_state.cmd_s == CM_ST) {
 902                         if (chkin) {
 903                                 g_string_append_c(dump_p, ':');
 904                                 _DBG("value %s", dump_p->str);
 905                         } else {
 906                                 //NC
 907                         }
 908                         g_string_append(dump_p, "START\n");
 909                         _DBG("value %s", dump_p->str);
 910                         bd_print_history_item_reset(&old_state);
 911                 } else if (new_state.cmd_s == CM_CRR_TIME || new_state.cmd_s == CM_RST) {
 912                         if (chkin) {
 913                                 g_string_append_c(dump_p, ':');
 914                                 _DBG("value %s", dump_p->str);
 915                         }
 916                         if (new_state.cmd_s == CM_RST) {
 917                                 g_string_append(dump_p, "RESET:");
 918                                 _DBG("value %s", dump_p->str);
 919                                 bd_print_history_item_reset(&old_state);
 920                         }
 921                         g_string_append(dump_p, "TIME:");
 922                         _DBG("value %s", dump_p->str);
 923                         if (chkin) {
 924                                 g_string_append_printf(dump_p, "%lld", new_state.time_current);
 925                                 _DBG("value %s", dump_p->str);
 926                                 g_string_append(dump_p, "\n");
 927                                 _DBG("value %s", dump_p->str);
 928                         } else {
 929                                 //NC
 930                         }
 931                 } else if (new_state.cmd_s == CM_SHTDN) {
 932                         if (chkin) {
 933                                 g_string_append_c(dump_p, ':');
 934                                 _DBG("value %s", dump_p->str);
 935                         } else {
 936                                 //NC
 937                         }
 938                         g_string_append(dump_p, "SHUTDOWN\n");
 939                         _DBG("value %s", dump_p->str);
 940                 } else if (new_state.cmd_s == CM_OVRFL) {
 941                         if (chkin) {
 942                                 g_string_append_c(dump_p, ':');
 943                                 _DBG("value %s", dump_p->str);
 944                         }
 945                         g_string_append(dump_p, "*OVERFLOW*\n");
 946                         _DBG("value %s", dump_p->str);
 947                 } else if (new_state.cmd_s == CM_USAGE) {
 948                         for (int i = 0; i < 32; i++) {
 949                                 if (new_state.usage_type == (1 << i)) {
 950                                         g_string_append(dump_p, ",");
 951                                         g_string_append_printf(dump_p, "%s", usage_map[i]);
 952                                         g_string_append(dump_p, "=");
 953                                         g_string_append_printf(dump_p, "%d", new_state.usage);
 954                                         g_string_append(dump_p, "\n");
 955                                         _DBG("value %d", new_state.usage);
 956                                 }
 957                         }
 958                 } else {
 959                         if (!chkin) {
 960                                 //NC
 961                         } else {
 962                                 if (old_state.battery_level != new_state.battery_level) {
 963                                         old_state.battery_level = new_state.battery_level;
 964                                         g_string_append(dump_p, ",Bl=");
 965                                         _DBG("value %s", dump_p->str);
 966                                         g_string_append_printf(dump_p, "%d",
 967                                                         new_state.battery_level);
 968                                         _DBG("value %s", dump_p->str);
 969                                 }
 970                         }
 971                         if (old_state.battery_status != new_state.battery_status) {
 972                                 old_state.battery_status = new_state.battery_status;
 973                                 g_string_append(dump_p, ",Bs="); //:for NC
 974                                 _DBG("value %s", dump_p->str);
 975                                 switch (old_state.battery_status) {
 976                                 case BD_BSTA_UNKN:
 977                                         g_string_append_c(dump_p, '?');
 978                                         break;
 979                                 case BD_BSTA_CHAR:
 980                                         g_string_append_c(dump_p, 'c');
 981                                         break;
 982                                 case BD_BSTA_DISC:
 983                                         g_string_append_c(dump_p, 'd');
 984                                         break;
 985                                 case BD_BSTA_NCHA:
 986                                         g_string_append_c(dump_p, 'n');
 987                                         break;
 988                                 case BD_BSTA_FULL:
 989                                         g_string_append_c(dump_p, 'f');
 990                                         break;
 991                                 default:
 992                                         g_string_append_c(dump_p, '?');
 993                                         _DBG("value %s", dump_p->str);
 994                                         break;
 995                                 }
 996                         }
 997                         if (old_state.battery_health != new_state.battery_health) {
 998                                 old_state.battery_health = new_state.battery_health;
 999                                 g_string_append(dump_p, ",Bh="); //:for NC
1000                                 _DBG("value %s", dump_p->str);
1001                                 switch (old_state.battery_health) {
1002                                 case BD_BHLT_GOOD:
1003                                         g_string_append_c(dump_p, 'g');
1004                                         break;
1005                                 case BD_BHLT_UNKN:
1006                                         g_string_append_c(dump_p, '?');
1007                                         break;
1008                                 case BD_BHLT_OVRH:
1009                                         g_string_append_c(dump_p, 'h');
1010                                         break;
1011                                 case BD_BHLT_DEAD:
1012                                         g_string_append_c(dump_p, 'd');
1013                                         break;
1014                                 case BD_BHLT_OVRV:
1015                                         g_string_append_c(dump_p, 'v');
1016                                         break;
1017                                 case BD_BHLT_UNSP:
1018                                         g_string_append_c(dump_p, 'f');
1019                                         break;
1020                                 case BD_BHLT_CLD:
1021                                         g_string_append_c(dump_p, 'c');
1022                                         break;
1023                                 default:
1024                                         g_string_append_c(dump_p, '?');
1025                                         _DBG("value %s", dump_p->str);
1026                                         break;
1027                                 }
1028                         }
1029                         if (old_state.battery_plugtype != new_state.battery_plugtype) {
1030                                 old_state.battery_plugtype = new_state.battery_plugtype;
1031                                 g_string_append(dump_p, ",Bp="); //:for NC
1032                                 _DBG("value %s", dump_p->str);
1033                                 switch (old_state.battery_plugtype) {
1034                                 case BD_BPLT_DIS:
1035                                         g_string_append_c(dump_p, 'n');
1036                                         break;
1037                                 case BD_BPLT_AC:
1038                                         g_string_append_c(dump_p, 'a');
1039                                         break;
1040                                 case BD_BPLT_USB:
1041                                         g_string_append_c(dump_p, 'u');
1042                                         break;
1043                                 case BD_BPLT_WL:
1044                                         g_string_append_c(dump_p, 'w');
1045                                         break;
1046                                 default:
1047                                         g_string_append_c(dump_p, 'n');
1048                                         _DBG("value %s", dump_p->str);
1049                                         break;
1050                                 }
1051                         }
1052                         if (old_state.battery_temperature != new_state.battery_temperature) {
1053                                 old_state.battery_temperature = new_state.battery_temperature;
1054                                 g_string_append(dump_p, ",Bt="); //:for NC
1055                                 g_string_append_printf(dump_p, "%d",
1056                                                 new_state.battery_temperature);
1057                                 _DBG("value %s", dump_p->str);
1058                         }
1059                         if (old_state.battery_voltage != new_state.battery_voltage) {
1060                                 old_state.battery_voltage = new_state.battery_voltage;
1061                                 g_string_append(dump_p, ",Bv="); //:for NC
1062                                 _DBG("value %s", dump_p->str);
1063                                 g_string_append_printf(dump_p, "%d", new_state.battery_voltage);
1064                                 _DBG("value %s", dump_p->str);
1065                         }
1066                         if (old_state.battery_charge != new_state.battery_charge) {
1067                                 old_state.battery_charge = new_state.battery_charge;
1068                                 g_string_append(dump_p, ",Bcc=");
1069                                 _DBG("value %s", dump_p->str);
1070                                 //Charge in MAh
1071                                 g_string_append_printf(dump_p, "%d", (new_state.battery_charge/1000));
1072                                 _DBG("value %s", dump_p->str);
1073                         }
1074                         int change = (old_state.state_1 ^ new_state.state_1);
1075                         if (change != 0) {
1076                                 bool wake_fl = false; int k = 0;
1077                                 if ((change & ST1_BRIGHTNESS_MASK) != 0) {
1078                                         k = (new_state.state_1 & ST1_BRIGHTNESS_MASK);
1079                                         g_string_append(dump_p, ",Sb=");
1080                                         k = k >> ST1_BRIGHTNESS_SHIFT;
1081                                         _DBG("Sb = %d", k);
1082                                         g_string_append_printf(dump_p, "%d", k);
1083                                         k = 0;
1084                                 }
1085                                 if ((change & ST1_PHONE_SIGNAL_STRENGTH_MASK) != 0) {
1086                                         k = (new_state.state_1 & ST1_PHONE_SIGNAL_STRENGTH_MASK);
1087                                         g_string_append(dump_p, ",Pss=");
1088                                         k = k >> ST1_PHONE_SIGNAL_STRENGTH_SHIFT;
1089                                         _DBG("Pss = %d", k);
1090                                         g_string_append_printf(dump_p, "%d", k);
1091                                         k = 0;
1092                                 }
1093                                 int shifts = (1 << 14);
1094                                 for (int i = 14; i < 32; i++) {
1095                                         if ((change & shifts) != 0) {
1096                                                 g_string_append_c(dump_p, ',');
1097                                                 //Considering only -ve shift cases
1098                                                 int shift = -1;
1099                                                 if (shift < 0) {
1100                                                         if ((new_state.state_1 & (1 << i)) != 0)
1101                                                                 g_string_append_c(dump_p, '+');
1102                                                         else
1103                                                                 g_string_append_c(dump_p, '-');
1104                                                         gchar *temp = g_strdup(state1_map[i]);
1105                                                         g_string_append(dump_p, temp);
1106                                                         g_free(temp);
1107                                                         //_DBG("value %s", dump_p->str);
1108                                                         if ((1 << i) == ST1_WAKE_LOCK_FLAG &&
1109                                                                 new_state.wakelock_tag != NULL) {
1110                                                                 wake_fl = true;
1111                                                                 g_string_append_c(dump_p, '=');
1112                                                                 //_DBG("value %s", dump_p->str);
1113                                                                 if (chkin)
1114                                                                         g_string_append_printf(dump_p,
1115                                                                 "%d", new_state.wakelock_tag->sp_idx);
1116                                                                 else {
1117                                                                         //: NC
1118                                                                 }
1119                                                                 //_DBG("value %s", dump_p->str);
1120                                                         }
1121                                                 } else {
1122                                                 //With non-negative shift
1123                                                 }
1124                                         }
1125                                         shifts = (shifts << 1);
1126                                 }
1127                                 if (!wake_fl && new_state.wakelock_tag != NULL) {
1128                                         g_string_append(dump_p, ",w=");
1129                                         if (chkin) {
1130                                                 g_string_append_printf(dump_p, "%d",
1131                                                 new_state.wakelock_tag->sp_idx);
1132                                                 _DBG("value %s", dump_p->str);
1133                                         } else {
1134                                         }
1135                                 }
1136                         }
1137                         change = (old_state.state_2 ^ new_state.state_2);
1138                         if (change != 0) {
1139                                 int shifts = 1;
1140                                 for (int i = 0; i < 32; i++) {
1141                                         if ((change & shifts) != 0) {
1142                                                 g_string_append_c(dump_p, ',');
1143                                                 //_DBG("value %s", dump_p->str);
1144                                                 int shift = -1;
1145                                                 if (shift < 0) {
1146                                                         if ((new_state.state_2 & (1 << i) & change) != 0)
1147                                                                 g_string_append_c(dump_p, '+');
1148                                                         else
1149                                                                 g_string_append_c(dump_p, '-');
1150                                                         //_DBG("value %s", dump_p->str);
1151                                                         gchar *temp = g_strdup(state2_map[i]);
1152                                                         g_string_append(dump_p, temp);
1153                                                         g_free(temp);
1154                                                         _DBG("value %s", dump_p->str);
1155                                                 }
1156                                         }
1157                                         shifts = (shifts << 1);
1158                                 }
1159                         }
1160                         if (new_state.wakereason_tag != NULL) {
1161                                 if (chkin) {
1162                                         g_string_append(dump_p, ",wr=");
1163                                         _DBG("value %s", dump_p->str);
1164                                         g_string_append_printf(dump_p, "%d",
1165                                         new_state.wakereason_tag->sp_idx);
1166                                         _DBG("value %s", dump_p->str);
1167                                 }
1168                         } else {
1169                                 //: for NC
1170                         }
1171                         if (new_state.event_code != ET_NONE) {
1172                                 g_string_append_c(dump_p, ',');
1173                                 _DBG("value %s", dump_p->str);
1174                                 if ((new_state.event_code & ET_FLAG_START) != 0)
1175                                         g_string_append_c(dump_p, '+');
1176                                 else if ((new_state.event_code & ET_FLAG_FINISH) != 0)
1177                                         g_string_append_c(dump_p, '-');
1178                                 _DBG("value %s", dump_p->str);
1179                                 int k = new_state.event_code & ~(ET_FLAG_START | ET_FLAG_FINISH);
1180                                 if (k >= 0 && k < 32) {
1181                                         gchar* temp = g_strdup(event_map[k]);
1182                                         g_string_append(dump_p, temp);
1183                                         _DBG("value %s", dump_p->str);
1184                                         g_free(temp);
1185                                 } else {
1186                                         g_string_append(dump_p, "Ev");
1187                                         g_string_append_printf(dump_p, "%d", k);
1188                                         _DBG("value %s", dump_p->str);
1189                                 }
1190                                 g_string_append_c(dump_p, '=');
1191                                 _DBG("value %s", dump_p->str);
1192                                 if (chkin) {
1193                                         g_string_append_printf(dump_p, "%d",
1194                                                 new_state.event_tag->sp_idx);
1195                                         //:Free sp memory.
1196                                 } else {
1197                                         //: for NC
1198                                 }
1199                         }
1200                         g_string_append(dump_p, "\n");
1201                         //: step details
1202                         old_state.state_1 = new_state.state_1;
1203                         old_state.state_2 = new_state.state_2;
1204                 }
1205                 _DBG("State assigned");
1206                 _DBG("%s", dump_p->str);
1207                 if (write(fd, dump_p->str, dump_p->len) < 0)
1208                         _WARN("write error");
1209                 g_string_free(dump_p, TRUE);
1210         }
1211
1212         // Dump the elapsed time from last event
1213         // It should be dumped without storing
1214         GString *dump_tmp_p = g_string_sized_new(30);
1215         BM_CHECK_MEM_ALLOC(dump_tmp_p, {});
1216         struct timeval tv;
1217         gettimeofday(&tv, NULL);
1218
1219         g_string_append(dump_tmp_p, TIZEN_DUMP_VERSION);
1220         g_string_append_c(dump_tmp_p, ',');
1221         g_string_append(dump_tmp_p, DUMP_DATA_TAG);
1222         g_string_append_c(dump_tmp_p, ',');
1223         g_string_append_printf(dump_tmp_p, "%lld",
1224                         ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000) - old_state.time_s);
1225         g_string_append(dump_tmp_p, "\n");
1226
1227         if (write(fd, dump_tmp_p->str, dump_tmp_p->len) < 0)
1228                 _WARN("write error");
1229         g_string_free(dump_tmp_p, TRUE);
1230
1231         //Dump i & l values after this
1232         ret = bd_get_and_print_uid_info_entry_from_dump(fd);
1233         if (ret != BATTERY_MONITOR_ERROR_NONE)
1234                 _ERR("UID data dump failed");
1235         // Get Last charge time to dump "l" field
1236         long int duration = 0;
1237         bd_get_last_charge_time(base_time/1000, &ret);
1238         duration = lst_charge;
1239
1240         ret = bd_get_and_print_gn_stat_entry_from_dump(fd, duration);
1241         if (ret != BATTERY_MONITOR_ERROR_NONE)
1242                 _ERR("GN dump failed");
1243         ret = bd_get_and_print_gwf_stat_entry_from_dump(fd, duration);
1244         if (ret != BATTERY_MONITOR_ERROR_NONE)
1245                 _ERR("GWF data dump failed");
1246         ret = bd_get_and_print_gble_stat_entry_from_dump(fd, duration);
1247         if (ret != BATTERY_MONITOR_ERROR_NONE)
1248                 _ERR("GBL data dump failed");
1249         ret = bd_get_and_print_gbr_stat_entry_from_dump(fd, duration);
1250         if (ret != BATTERY_MONITOR_ERROR_NONE)
1251                 _ERR("GBR data dump failed");
1252         ret = bd_get_and_print_gst_stat_entry_from_dump(fd, duration);
1253         if (ret != BATTERY_MONITOR_ERROR_NONE)
1254                 _ERR("GST data dump failed");
1255         ret = bd_get_and_print_gwst_stat_entry_from_dump(fd, duration);
1256         if (ret != BATTERY_MONITOR_ERROR_NONE)
1257                 _ERR("GWST data dump failed");
1258         ret = bd_get_and_print_gcpu_stat_entry_from_dump(fd, duration);
1259         if (ret != BATTERY_MONITOR_ERROR_NONE)
1260                 _ERR("GCPU data dump failed");
1261         ret = bd_get_and_print_misc_stat_entry_from_dump(fd, duration);
1262         if (ret != BATTERY_MONITOR_ERROR_NONE)
1263                 _ERR("MISc data dump failed");
1264         // Battery Usage Dump
1265         ret = bd_get_and_print_battery_usage_from_dump(fd, duration);
1266         if (ret != BATTERY_MONITOR_ERROR_NONE)
1267                 _ERR("Battery Usage failed");
1268
1269         _DBG("DUMP COMPLETED/DELETE HASH TABLE");
1270
1271         g_hash_table_destroy(app_map);
1272         h_flag = true;
1273
1274         EXIT;
1275         return BATTERY_MONITOR_ERROR_NONE;
1276 }
1277
1278 static int bd_dump_data_item_reset(dump_data_s* old_state)
1279 {
1280         ENTER;
1281         BM_CHECK_INPUT_PARAM(old_state);
1282
1283         old_state->time_s = -1;
1284         old_state->time_current = -1;
1285         old_state->dump_1 = 0;
1286         old_state->dump_2 = 0;
1287         old_state->state_1 = 0;
1288         old_state->state_2 = 0;
1289         old_state->battery_chargeUAh = 0;
1290         old_state->usage_type = 0;
1291         old_state->usage = 0;
1292         old_state->event_code = ET_NONE;
1293         old_state->event_tag = NULL;
1294         old_state->wakelock_tag = NULL;
1295         old_state->wakereason_tag = NULL;
1296
1297         EXIT;
1298         return BATTERY_MONITOR_ERROR_NONE;
1299 }
1300
1301 static int bd_free_history_data_memory()
1302 {
1303         ENTER;
1304
1305         int ret = BATTERY_MONITOR_ERROR_NONE;
1306         h_flag = false; //Lock
1307         _DBG("Free History Data Memory");
1308         for (int i = 0; i < h_count; i++) {
1309                 if (history_data[i].wakelock_tag != NULL) {
1310                         g_string_free(history_data[i].wakelock_tag->string_info, TRUE);
1311                         free(history_data[i].wakelock_tag);
1312                 }
1313                 if (history_data[i].wakereason_tag != NULL) {
1314                         g_string_free(history_data[i].wakereason_tag->string_info, TRUE);
1315                         free(history_data[i].wakereason_tag);
1316                 }
1317                 if (history_data[i].event_tag != NULL) {
1318                         g_string_free(history_data[i].event_tag->string_info, TRUE);
1319                         free(history_data[i].event_tag);
1320                 }
1321                 ret = bd_dump_data_item_reset(&history_data[i]);
1322                 if (ret != BATTERY_MONITOR_ERROR_NONE)
1323                         _ERR("Internal error %d while freeing at idx %d", ret , i);
1324         }
1325
1326         h_count = 0; h_flag = true;
1327         EXIT;
1328         return ret;
1329 }
1330
1331 static int bd_set_history_from_listener(history_item_s* nrec)
1332 {
1333         ENTER;
1334         BM_CHECK_INPUT_PARAM(nrec);
1335
1336         long long dvar1 = 0, dvar2 = 0;
1337         struct timeval tv;
1338         gettimeofday(&tv, NULL);
1339
1340 //      time_t current_time = tv.tv_sec;
1341
1342 #ifdef DUMP_DUMMY
1343         history_data[h_count].time_s = nrec->time_s;
1344 #else
1345         history_data[h_count].time_s = ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000);
1346 #endif
1347
1348         if (nrec->battery_plugtype == BD_BPLT_AC || nrec->battery_plugtype == BD_BPLT_WL)
1349                 lst_charge = tv.tv_sec;
1350
1351         dvar1 = ((nrec->cmd_s) & 0xff) | ((nrec->battery_level << 8) & 0xff00) |
1352                 ((nrec->battery_status << 16) & 0xf0000) |
1353                 ((nrec->battery_health << 20) & 0xf00000) |
1354                 ((nrec->battery_plugtype << 24) & 0xf000000) |
1355                 ((nrec->wakelock_tag != NULL) ? 0x10000000 : 0) |
1356                 ((nrec->wakereason_tag != NULL) ? 0x20000000 : 0) |
1357                 ((nrec->event_code != ET_NONE) ? 0x40000000 : 0);
1358
1359         dvar2 = ((nrec->battery_voltage) & 0x0fffffff);
1360         dvar2 = ((dvar2 << 32) | (nrec->battery_temperature & 0xffffffff));
1361
1362         _DBG("Value of encoded value 1 %lld", dvar1);
1363         _DBG("Value of encoded value 2 %lld", dvar2);
1364
1365         history_data[h_count].dump_1 = dvar1;
1366         history_data[h_count].dump_2 = dvar2;
1367         history_data[h_count].battery_chargeUAh = nrec->battery_charge;
1368
1369         if (nrec->wakelock_tag != NULL)
1370                 history_data[h_count].wakelock_tag = nrec->wakelock_tag;
1371         if (nrec->wakereason_tag != NULL)
1372                 history_data[h_count].wakereason_tag = nrec->wakereason_tag;
1373         if (nrec->event_code != ET_NONE) {
1374                 if (nrec->event_tag == NULL) {
1375                         _ERR("ET is NULL but Event Code is not");
1376                         BM_FREE(history_data[h_count].wakelock_tag);
1377                         BM_FREE(history_data[h_count].wakereason_tag);
1378                         bd_dump_data_item_reset(&history_data[h_count]);
1379                         return BATTERY_MONITOR_ERROR_NO_DATA;
1380                 }
1381                 history_data[h_count].event_code = nrec->event_code;
1382                 history_data[h_count].event_tag = nrec->event_tag;
1383         }
1384         if (nrec->cmd_s == CM_CRR_TIME || nrec->cmd_s == CM_RST)
1385                 history_data[h_count].time_current = ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000);
1386
1387         history_data[h_count].state_1 = nrec->state_1;
1388         history_data[h_count].state_2 = nrec->state_2;
1389
1390         history_data[h_count].usage_type = nrec->usage_type;
1391         history_data[h_count].usage = nrec->usage;
1392
1393         nrec->event_tag = NULL; nrec->wakereason_tag = NULL;
1394         nrec->wakelock_tag = NULL;
1395         if (h_count < HISTORY_SIZE_MAX - 1)
1396                 h_count++;
1397         else {
1398                 // FIXME modify 1st argument (fd)
1399 /*              int ret = bd_print_history_item_main(-1, 0, current_time, 1);
1400                 if (ret != BATTERY_MONITOR_ERROR_NONE) {
1401                         h_count = 0;
1402                         return ret;
1403                 }
1404 */
1405                 int ret = bd_free_history_data_memory();
1406                 if (ret != BATTERY_MONITOR_ERROR_NONE) {
1407                         _WARN("Error while memory free %x", ret);
1408                         return ret;
1409                 }
1410                 history_item_s ts;
1411                 ret = bd_print_history_item_reset(&ts);
1412                 if (ret == BATTERY_MONITOR_ERROR_NONE) {
1413                         ts.cmd_s = CM_CRR_TIME;
1414                         ret = bd_store_history_item(&ts);
1415                         if (ret != BATTERY_MONITOR_ERROR_NONE)
1416                                 _WARN("Init Node addition failed");
1417                 }
1418         }
1419
1420         EXIT;
1421         return BATTERY_MONITOR_ERROR_NONE;
1422 }
1423
1424 int bd_store_history_item(history_item_s* nrec)
1425 {
1426         ENTER;
1427         BM_CHECK_INPUT_PARAM(nrec);
1428
1429         if (!h_flag) {
1430                 _ERR("Data Dump in progress");
1431                 return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
1432         }
1433         int ret = BATTERY_MONITOR_ERROR_NONE;
1434         ret = bd_set_history_from_listener(nrec);
1435         if (ret != BATTERY_MONITOR_ERROR_NONE) {
1436                 _ERR("Failed to store history");
1437                 return BATTERY_MONITOR_ERROR_INTERNAL;
1438         }
1439
1440         EXIT;
1441         return BATTERY_MONITOR_ERROR_NONE;
1442 }
1443
1444 static int *dumpsys_handler;
1445
1446 int bd_callback(const int fd, const int argc, char **argv)
1447 {
1448         int ret;
1449         int opt;
1450         bool checkin = false;
1451
1452         /**
1453          * We must reset optind because it isn't initialized
1454          * on subsequent getopt calls
1455          */
1456         optind = 1;
1457         while ((opt = getopt(argc, argv, "c")) != -1) {
1458                 switch (opt) {
1459                 case 'c':
1460                         checkin = true;
1461                         break;
1462                 default:
1463                         break;
1464                 }
1465         }
1466
1467         checkin = true;
1468         ret = bd_print_history_item_main(fd, -1, 0, checkin);
1469         if (ret != BATTERY_MONITOR_ERROR_NONE) {
1470                 _ERR("bd_print_history_item_main failed (%x)", ret);
1471                 return 0;
1472         }
1473
1474         return 0;
1475 }
1476
1477 int bd_initialize_battery_dump()
1478 {
1479         ENTER;
1480
1481         int ret = BATTERY_MONITOR_ERROR_NONE;
1482
1483         h_count = 0; h_flag = true;
1484         lst_charge = -1;
1485 #ifdef DUMP_DUMMY
1486         bd_dummy_test_fn();
1487 #else
1488         history_item_s ts;
1489         ret = bd_print_history_item_reset(&ts);
1490         if (ret == BATTERY_MONITOR_ERROR_NONE) {
1491                 ts.cmd_s = CM_CRR_TIME;
1492                 ret = bd_store_history_item(&ts);
1493                 if (ret != BATTERY_MONITOR_ERROR_NONE)
1494                         _WARN("Init Node addition failed");
1495         }
1496 #endif
1497
1498         ret = dumpsys_system_register_dump_cb(bd_callback, "batterystats", (void **)&dumpsys_handler);
1499         if (ret != TIZEN_ERROR_NONE) {
1500                 _ERR("dumpsys_system_register_dump_cb failed (%x)", ret);
1501                 return BATTERY_MONITOR_ERROR_NOT_INITIALIZED;
1502         }
1503
1504         _INFO("Battery Dump Init Successful");
1505
1506         EXIT;
1507         return BATTERY_MONITOR_ERROR_NONE;
1508 }
1509
1510 int bd_deinitialize_battery_dump()
1511 {
1512         ENTER;
1513
1514         int ret;
1515
1516         ret = dumpsys_system_unregister_dump_cb(dumpsys_handler);
1517         if (ret != TIZEN_ERROR_NONE) {
1518                 _WARN("dumpsys_system_unregister_dump_cb failed (%x)", ret);
1519                 return BATTERY_MONITOR_ERROR_NOT_INITIALIZED;
1520         }
1521
1522         if (lst_charge != -1) {
1523                 resourceid_usage_s battery_use;
1524                 battery_use.ResourceId = "battery";
1525                 battery_use.log_time = lst_charge;
1526                 battery_use.usage = 0;
1527                 ret = bm_server_resource_base_usage_insert_to_db(&battery_use);
1528                 if (ret != BATTERY_MONITOR_ERROR_NONE)
1529                         _WARN("Battery Time Insert fail");
1530         }
1531
1532         ret = bd_free_history_data_memory();
1533         if (ret != BATTERY_MONITOR_ERROR_NONE)
1534                 _WARN("memory free failed (%x)", ret);
1535
1536         _INFO("Battery Dump De-Init Successful");
1537
1538         EXIT;
1539         return BATTERY_MONITOR_ERROR_NONE;
1540 }