src/battery_dump/bm_listeners.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 "bm_listeners.h"
  19 #include "bm_dbg.h"
  20 #include <bm_common.h>
  21 #include <bd_history_item.h>
  22 #include <vconf.h>
  23 #include <pthread.h>
  24 #include <sys/time.h>
  25 #include <TapiUtility.h>
  26 #include <ITapiNetwork.h>
  27 #include <glib.h>
  28 #include <device/battery-internal.h>
  29
  30 wifi_manager_h wifi = NULL;
  31 static bool display_on;
  32 static int brightness_val = 0;
  33 static int brightness_flag = 0;
  34 static int ss_val = 0;
  35 static int ss_flag = -1;
  36 static history_item_s *data_obj = NULL;
  37 struct timeval prev_event_time;
  38
  39 display_state_e display_flag = DISPLAY_STATE_SCREEN_OFF;
  40 static int listener_hsp = -1;
  41 static int bt_adaptor = 0;
  42 static int location_flag = 0;
  43 static int bt_hsp = 0;
  44 static int bt_connected_hsp = 0;
  45 static int bt_scan_hsp = 0;
  46 static int bt_discovery_state = 1;
  47 static int bt_flag = 0;
  48 static int wifi_flag = 0;
  49 static int wifi_hsp = 0;
  50 static int wifi_scan_hsp = 0;
  51 static int wifi_connected_hsp = 0;
  52 static int display_hsp = 0;
  53 static int gps_hsp = 0;
  54 static int lock_hsp = 0;
  55 static int app_hsp = 0;
  56 static int wakeup_hsp = 0;
  57 static int modem_hsp = 0;
  58 static int modem_flag = 0;
  59 static int prev_wakeup = 0;
  60 static int prev_lock = 0;
  61 static int prev_battery_level = 0;
  62 static event_pool events_buf[10];
  63 static int buff_count = 0;
  64 static pthread_attr_t attr;
  65 static pthread_cond_t fill = PTHREAD_COND_INITIALIZER;
  66 static pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
  67 static pthread_mutex_t battery_lister_mutex = PTHREAD_MUTEX_INITIALIZER;
  68 static int fill_ptr = 0;
  69 static int use_ptr = 0;
  70 static TapiHandle *handle = NULL;
  71 GHashTable *app_list = NULL;
  72
  73 #define DBUS_DEVICED "org.tizen.system.deviced"
  74 #define DBUS_DEVICED_PATH "/Org/Tizen/System/DeviceD/Display"
  75 #define DBUS_DEVICED_IFACE "org.tizen.system.deviced.display"
  76 #define DBUS_DEVICED_PL_MEMBER "PowerLock"
  77 #define DBUS_DEVICED_PU_MEMBER "PowerUnlock"
  78 #define DBUS_DEVICED_SLEEP_MEMBER "sleep"
  79 #define DBUS_DEVICED_WAKEUP_MEMBER "wakeup"
  80
  81 static GDBusConnection *dbus_connection;
  82
  83 static int bm_listener_dbus_init(void)
  84 {
  85         ENTER;
  86
  87         GDBusConnection *conn;
  88         GError *err = NULL;
  89
  90         if (dbus_connection) {
  91                 _DBG("dbus connection already initialized");
  92                 return 0;
  93         }
  94
  95         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
  96         if (!conn || err) {
  97                 _ERR("failed to get dbus connection:%s", err->message);
  98                 g_error_free(err);
  99                 conn = NULL;
 100                 return -1;
 101         }
 102
 103         dbus_connection = conn;
 104
 105         EXIT;
 106         return 0;
 107 }
 108
 109 int bm_listener_dbus_deinit()
 110 {
 111         ENTER;
 112
 113         if (dbus_connection)
 114                 g_object_unref(dbus_connection);
 115         dbus_connection = NULL;
 116
 117         EXIT;
 118         return BATTERY_MONITOR_ERROR_NONE;
 119 }
 120
 121 static int fill_AppId_info(char *app_id)
 122 {
 123         ENTER;
 124         int ret = 0;
 125         data_obj->event_tag->uid = 1000;
 126         data_obj->event_tag->string_info = g_string_sized_new(7);
 127         if (!data_obj->event_tag->string_info) {
 128                 _ERR("memory allocation  failed ");
 129                 ret = 1;
 130                 return ret;
 131         }
 132         g_string_append_printf(data_obj->event_tag->string_info, "%s", app_id);
 133         EXIT;
 134         return ret;
 135 }
 136
 137 static int fill_battery_info()
 138 {
 139         ENTER;
 140         struct battery_info info;
 141         int ret = device_battery_get_info(&info);
 142         if (ret == DEVICE_ERROR_NONE) {
 143                 data_obj->battery_level = info.capacity;
 144                 if (data_obj->battery_level < 0)
 145                         _ERR("Failed to get  ts->battery_level = %d ", data_obj->battery_level);
 146
 147                 size_t len = strlen(info.status);
 148                 if (!strncmp(info.status, "Charging", len))
 149                         data_obj->battery_status = BD_BSTA_CHAR;
 150                 else if (!strncmp(info.status, "Discharging", len))
 151                         data_obj->battery_status = BD_BSTA_DISC;
 152                 else if (!strncmp(info.status, "Full", len))
 153                         data_obj->battery_status = BD_BSTA_FULL;
 154                 else if (!strncmp(info.status, "Not charging", len))
 155                         data_obj->battery_status = BD_BSTA_NCHA;
 156                 else {
 157                         _ERR("Failed to get info.status = %s ", info.status);
 158                         data_obj->battery_status = BD_BSTA_UNKN;
 159                 }
 160
 161                 len = strlen(info.health);
 162                 if (!strncmp(info.health, "Good", len))
 163                         data_obj->battery_health = BD_BHLT_GOOD;
 164                 else if (!strncmp(info.health, "Cold", len))
 165                         data_obj->battery_health = BD_BHLT_CLD;
 166                 else if (!strncmp(info.health, "Dead", len))
 167                         data_obj->battery_health = BD_BHLT_DEAD;
 168                 else if (!strncmp(info.health, "Overheat", len))
 169                         data_obj->battery_health = BD_BHLT_OVRH;
 170                 else if (!strncmp(info.health, "Over voltage", len))
 171                         data_obj->battery_health = BD_BHLT_OVRV;
 172                 else
 173                         data_obj->battery_health = BD_BHLT_UNKN;
 174
 175                 len = strlen(info.power_source);
 176                 if (!strncmp(info.power_source, "ac", len))
 177                         data_obj->battery_plugtype = BD_BPLT_AC;
 178                 else if (!strncmp(info.power_source, "usb", len))
 179                         data_obj->battery_plugtype = BD_BPLT_USB;
 180                 else if (!strncmp(info.power_source, "wireless", len))
 181                         data_obj->battery_plugtype = BD_BPLT_WL;
 182                 else
 183                         data_obj->battery_plugtype = BD_BPLT_NONE;
 184
 185                 _INFO("battery_level = %d, battery_status = %d, battery_health = %d, battery_plugtype = %d",
 186                         data_obj->battery_level, data_obj->battery_status, data_obj->battery_health, data_obj->battery_plugtype);
 187
 188                 data_obj->battery_temperature = info.temperature;
 189                 data_obj->battery_voltage = info.voltage_now;
 190
 191                 _INFO("battery_voltage = %d, battery_temperature = %d", data_obj->battery_voltage, data_obj->battery_temperature);
 192         } else {
 193                 _ERR("Failed to get battery info (%d)", ret);
 194         }
 195
 196         EXIT;
 197         return ret;
 198 }
 199
 200 static void fill_bt_adapter_state_changed_data(int adapter_state)
 201 {
 202         ENTER;
 203
 204         _WARN("state: %s", (adapter_state == BT_ADAPTER_ENABLED) ? "ENABLED" : "DISABLED");
 205         int bt_state;
 206         if (adapter_state == BT_ADAPTER_ENABLED)
 207                 bt_state = 1;
 208         else
 209                 bt_state = 0;
 210
 211         _INFO("__bm_bt_adapter_state_changed_cb  bt_state = %d ", bt_state);
 212
 213         if (data_obj) {
 214                 if (adapter_state == BT_ADAPTER_ENABLED) {
 215                         data_obj->event_code = ET_NONE;
 216                         data_obj->event_code |= ET_ACTIVE;
 217                         data_obj->event_code |= ET_FLAG_START;
 218                         data_obj->event_tag = NULL;
 219                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 220                         if (data_obj->event_tag) {
 221                                 listener_hsp++;
 222                                 bt_hsp = listener_hsp;
 223                                 _INFO("event Tag creation succeeded \n");
 224                                 data_obj->event_tag->sp_idx = bt_hsp;
 225                         } else {
 226                                 _ERR("  data_obj->event_tag object creation fails ");
 227                                 return;
 228                         }
 229                         data_obj->state_2 |= ST2_BLUETOOTH_ON_FLAG;
 230                 } else {
 231                         data_obj->event_code = ET_NONE;
 232                         data_obj->event_code |= ET_ACTIVE;
 233                         data_obj->event_code |= ET_FLAG_FINISH;
 234                         data_obj->event_tag = NULL;
 235                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 236                         if (data_obj->event_tag) {
 237                                 _INFO("event Tag creation succeeded \n");
 238                                 data_obj->event_tag->sp_idx = bt_hsp;
 239                         } else {
 240                                 _ERR("  data_obj->event_tag object creation fails ");
 241                                 return;
 242                         }
 243                         data_obj->state_2 &= ~(ST2_BLUETOOTH_ON_FLAG);
 244                 }
 245         }
 246
 247         EXIT;
 248         return;
 249 }
 250
 251 static void fill_bt_device_discovery_state_changed_data(int discovery_state)
 252 {
 253         ENTER;
 254
 255         _WARN(" discovery_state = %d", discovery_state);
 256
 257         if (data_obj) {
 258                 switch (discovery_state) {
 259                 case BT_ADAPTER_DEVICE_DISCOVERY_STARTED:
 260                         data_obj->event_code = ET_NONE;
 261                         data_obj->event_code = ET_CONNECTIVITY_CHANGED;
 262                         data_obj->event_code |= ET_FLAG_START;
 263                         data_obj->event_tag = NULL;
 264                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 265                         if (data_obj->event_tag) {
 266                                 if (!bt_flag) {
 267                                         listener_hsp++;
 268                                         bt_scan_hsp = listener_hsp;
 269                                         bt_flag = 1;
 270                                 }
 271                                 _INFO("event Tag creation succeeded \n");
 272                                 data_obj->event_tag->sp_idx = bt_scan_hsp;
 273                         } else {
 274                                 _ERR("  data_obj->event_tag object creation fails ");
 275                                 return;
 276                         }
 277                         data_obj->state_2 |= ST2_BLUETOOTH_SCAN_FLAG;
 278                         break;
 279                 case BT_ADAPTER_DEVICE_DISCOVERY_FINISHED:
 280                         data_obj->event_code = ET_NONE;
 281                         data_obj->event_code = ET_CONNECTIVITY_CHANGED;
 282                         data_obj->event_code |= ET_FLAG_FINISH;
 283                         data_obj->event_tag = NULL;
 284                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 285                         if (data_obj->event_tag) {
 286                                 _INFO("event Tag creation succeeded \n");
 287                                 data_obj->event_tag->sp_idx = bt_scan_hsp;
 288                         } else {
 289                                 _ERR("  data_obj->event_tag object creation fails ");
 290                                 return;
 291                         }
 292                         data_obj->state_2 &= ~(ST2_BLUETOOTH_SCAN_FLAG);
 293                         bt_flag = 0;
 294                         break;
 295                 default:
 296                         return;
 297                 }
 298         }
 299
 300         EXIT;
 301         return;
 302 }
 303
 304 static void fill_bt_device_connection_state_changed_data(int connected)
 305 {
 306         ENTER;
 307
 308         _WARN("__bt_device_connection_state_changed_cb [%d]", connected);
 309         if (!connected)
 310                 _INFO("bt is disconnected");
 311
 312         if (data_obj) {
 313                 if (connected) {
 314                         data_obj->event_code = ET_NONE;
 315                         data_obj->event_code |= ET_CONNECTIVITY_CHANGED ;
 316                         data_obj->event_code |= ET_FLAG_START;
 317                         data_obj->event_tag = NULL;
 318                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 319                         if (data_obj->event_tag) {
 320                                 listener_hsp++;
 321                                 bt_connected_hsp = listener_hsp;
 322                                 _INFO("event Tag creation succeeded \n");
 323                                 data_obj->event_tag->sp_idx = bt_connected_hsp;
 324                         } else {
 325                                 _ERR("  data_obj->event_tag object creation fails ");
 326                                 return;
 327                         }
 328                 } else {
 329                         data_obj->event_code = ET_NONE;
 330                         data_obj->event_code |= ET_CONNECTIVITY_CHANGED;
 331                         data_obj->event_code |= ET_FLAG_FINISH;
 332                         data_obj->event_tag = NULL;
 333                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 334                         if (data_obj->event_tag) {
 335                                 _INFO("event Tag creation succeeded \n");
 336                                 data_obj->event_tag->sp_idx = bt_connected_hsp;
 337                         } else {
 338                                 _ERR("  data_obj->event_tag object creation fails ");
 339                                 return;
 340                         }
 341                 }
 342         }
 343
 344         EXIT;
 345         return;
 346 }
 347
 348 static void fill_wifi_device_state_data(int state)
 349 {
 350         ENTER;
 351
 352         _WARN(" Wifi Device state changed callback");
 353
 354         if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED)
 355                 _INFO(", state : Activated\n");
 356         else
 357                 _INFO(", state : Deactivated\n");
 358
 359         if (data_obj) {
 360                 if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED) {
 361                         data_obj->event_code = ET_NONE;
 362                         data_obj->event_code |= ET_ACTIVE;
 363                         data_obj->event_code |= ET_FLAG_START;
 364                         data_obj->event_tag = NULL;
 365                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 366                         if (data_obj->event_tag) {
 367                                 listener_hsp++;
 368                                 wifi_hsp = listener_hsp;
 369                                 _INFO("event Tag creation succeeded \n");
 370                                 data_obj->event_tag->sp_idx = wifi_hsp;
 371                         } else {
 372                                 _ERR("  data_obj->event_tag object creation fails ");
 373                                 return;
 374                         }
 375                         data_obj->state_2 |= ST2_WIFI_ON_FLAG;
 376                 } else {
 377                         data_obj->event_code = ET_NONE;
 378                         data_obj->event_code |= ET_ACTIVE;
 379                         data_obj->event_code |= ET_FLAG_FINISH;
 380                         data_obj->event_tag = NULL;
 381                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 382                         if (data_obj->event_tag) {
 383                                 _INFO("event Tag creation succeeded \n");
 384                                 data_obj->event_tag->sp_idx = wifi_hsp;
 385                         } else {
 386                                 _ERR("  data_obj->event_tag object creation fails ");
 387                                 return;
 388                         }
 389                         data_obj->state_2 &= ~(ST2_WIFI_ON_FLAG);
 390                 }
 391         }
 392
 393         EXIT;
 394         return;
 395 }
 396
 397 static void fill_wifi_scan_changed_data(int state)
 398 {
 399         ENTER;
 400
 401         _WARN("Wifi Scan changed, scan state : %d\n", state);
 402         if (data_obj) {
 403                 if (state == WIFI_MANAGER_SCAN_STATE_SCANNING) {
 404                         data_obj->event_code = ET_NONE;
 405                         data_obj->event_code |= ET_FLAG_START;
 406                         data_obj->event_code |= ET_CONNECTIVITY_CHANGED;
 407                         data_obj->event_tag = NULL;
 408                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 409                         if (data_obj->event_tag) {
 410                                 if (!wifi_flag) {
 411                                         listener_hsp++;
 412                                         wifi_scan_hsp = listener_hsp;
 413                                         wifi_flag = 1;
 414                                 }
 415                                 _INFO("event Tag creation succeeded \n");
 416                                 data_obj->event_tag->sp_idx = wifi_scan_hsp;
 417                         } else {
 418                                 _ERR("  data_obj->event_tag object creation fails ");
 419                                 return;
 420                         }
 421                         data_obj->state_1 |= ST1_WIFI_SCAN_FLAG;
 422                 } else {
 423                         data_obj->event_code = ET_NONE;
 424                         data_obj->event_code |= ET_FLAG_FINISH;
 425                         data_obj->event_code |= ET_CONNECTIVITY_CHANGED;
 426                         data_obj->event_tag = NULL;
 427                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 428                         if (data_obj->event_tag) {
 429                                 _INFO("event Tag creation succeeded \n");
 430                                 data_obj->event_tag->sp_idx = wifi_scan_hsp;
 431                         } else {
 432                                 _ERR("  data_obj->event_tag object creation fails ");
 433                                 return;
 434                         }
 435                         data_obj->state_1 &= ~(ST1_WIFI_SCAN_FLAG);
 436                         wifi_flag = 0;
 437                 }
 438         }
 439
 440         EXIT;
 441         return;
 442 }
 443
 444 static void fill_wifi_connection_state_changed_data(int state)
 445 {
 446         ENTER;
 447
 448         _WARN("Wifi Connection changed, connection state : %d\n", state);
 449
 450         if (data_obj) {
 451                 switch (state) {
 452                 case WIFI_MANAGER_CONNECTION_STATE_CONNECTED:
 453                         data_obj->event_code = ET_NONE;
 454                         data_obj->event_code |= ET_CONNECTIVITY_CHANGED;
 455                         data_obj->event_code |= ET_FLAG_START;
 456                         data_obj->event_tag = NULL;
 457                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 458                         if (data_obj->event_tag) {
 459                                 _INFO("event Tag creation succeeded \n");
 460                                 listener_hsp++;
 461                                 wifi_connected_hsp = listener_hsp;
 462                                 data_obj->event_tag->sp_idx = wifi_connected_hsp;
 463                         } else {
 464                                 _ERR("  data_obj->event_tag object creation fails ");
 465                                 return;
 466                         }
 467                         break;
 468                 case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED:
 469                         data_obj->event_code = ET_NONE;
 470                         data_obj->event_code |= ET_CONNECTIVITY_CHANGED;
 471                         data_obj->event_code |= ET_FLAG_FINISH;
 472                         data_obj->event_tag = NULL;
 473                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 474                         if (data_obj->event_tag) {
 475                                 _INFO("event Tag creation succeeded \n");
 476                                 data_obj->event_tag->sp_idx = wifi_connected_hsp;
 477                         } else {
 478                                 _ERR("  data_obj->event_tag object creation fails ");
 479                                 return;
 480                         }
 481                         break;
 482                 default:
 483                         break;
 484                 }
 485         }
 486
 487         EXIT;
 488         return;
 489 }
 490
 491 static void fill_device_display_change(int value)
 492 {
 493         ENTER;
 494         _WARN("device state changed succeeded\n");
 495
 496         switch (value) {
 497         case DISPLAY_STATE_NORMAL:
 498                 _INFO("Display on");
 499                 display_on = true;
 500                 data_obj->event_code = ET_NONE;
 501                 data_obj->event_code |= ET_SCREEN_WAKE_UP;
 502                 data_obj->event_code |= ET_FLAG_START;
 503                 data_obj->event_tag = NULL;
 504                 data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 505                 if (data_obj->event_tag) {
 506                         listener_hsp++;
 507                         display_hsp = listener_hsp;
 508                         _INFO("event Tag creation succeeded \n");
 509                         data_obj->event_tag->sp_idx = display_hsp;
 510                 } else {
 511                         _ERR("  data_obj->event_tag object creation fails ");
 512                         return;
 513                 }
 514                 data_obj->state_1 |= ST1_SCREEN_ON_FLAG;
 515                 data_obj->state_1 &= ~(ST1_SCREEN_DOZE_FLAG);
 516                 break;
 517         case DISPLAY_STATE_SCREEN_DIM:
 518                 _INFO("Display dim");
 519                 data_obj->event_code = ET_NONE;
 520                 data_obj->event_tag = NULL;
 521                 data_obj->state_1 |= ST1_SCREEN_DOZE_FLAG;
 522                 break;
 523         case DISPLAY_STATE_SCREEN_OFF:
 524                 _INFO("Display off");
 525                 data_obj->event_code = ET_NONE;
 526                 data_obj->event_code |= ET_SCREEN_WAKE_UP;
 527                 data_obj->event_code |= ET_FLAG_FINISH;
 528                 data_obj->event_tag = NULL;
 529                 data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 530                 if (data_obj->event_tag) {
 531                         _INFO("event Tag creation succeeded \n");
 532                         data_obj->event_tag->sp_idx = display_hsp;
 533                 } else {
 534                         _ERR("  data_obj->event_tag object creation fails ");
 535                         return;
 536                 }
 537                 data_obj->state_1 &= ~(ST1_SCREEN_ON_FLAG);
 538                 data_obj->state_1 &= ~(ST1_SCREEN_DOZE_FLAG);
 539                 display_on = false;
 540                 break;
 541         }
 542
 543         EXIT;
 544         return;
 545 }
 546
 547 static void fill_display_brightness_change(int brightness_level)
 548 {
 549         ENTER;
 550
 551         _WARN(" device brightness changed =%d ", brightness_level);
 552         if (data_obj) {
 553                 data_obj->state_1 &= ~brightness_val;
 554                 brightness_val = brightness_level;
 555                 data_obj->state_1 |= brightness_val;
 556                 data_obj->event_code = ET_NONE;
 557                 data_obj->event_tag = NULL;
 558         }
 559
 560         EXIT;
 561         return;
 562 }
 563
 564 static void fill_battery_capacity_change(int charging_level)
 565 {
 566         ENTER;
 567
 568         _WARN(" device battery_capacity changed =%d ", charging_level);
 569         if (data_obj) {
 570                 data_obj->event_code = ET_NONE;
 571                 data_obj->event_tag = NULL;
 572         }
 573
 574         EXIT;
 575         return;
 576 }
 577
 578 static void fill_charging_status_change(int charging)
 579 {
 580         ENTER;
 581
 582         _INFO(" device charging_status changed =%d ", charging);
 583         if (data_obj) {
 584                 if (charging) {
 585                         data_obj->event_code = ET_NONE;
 586                         data_obj->event_tag = NULL;
 587                         data_obj->state_2 |= ST2_CHARGING_FLAG;
 588                 } else {
 589                         data_obj->event_code = ET_NONE;
 590                         data_obj->event_tag = NULL;
 591                         data_obj->state_2 &= ~(ST2_CHARGING_FLAG);
 592                 }
 593         }
 594
 595         EXIT;
 596         return;
 597 }
 598
 599 static void fill_signal_strength_change(int ss)
 600 {
 601         ENTER;
 602
 603         _WARN(" device signal_strength changed =%d ", ss);
 604         if (data_obj) {
 605                 data_obj->state_1 &= ~ss_val << ST1_PHONE_SIGNAL_STRENGTH_SHIFT;
 606                 ss_val = ss;
 607                 data_obj->state_1 |= ss_val << ST1_PHONE_SIGNAL_STRENGTH_SHIFT;
 608                 data_obj->event_code = ET_NONE;
 609                 data_obj->event_tag = NULL;
 610         }
 611
 612         EXIT;
 613         return;
 614 }
 615
 616 static void fill_sleep_wakeup_change(int val)
 617 {
 618         ENTER;
 619
 620         _WARN(" sleep/wake up changed =%d ", val);
 621         if (val) {
 622                 data_obj->event_code = ET_NONE;
 623                 data_obj->event_tag = NULL;
 624                 data_obj->wakereason_tag = NULL;
 625                 data_obj->wakereason_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 626                 if (data_obj->wakereason_tag) {
 627                         listener_hsp++;
 628                         wakeup_hsp = listener_hsp;
 629                         _INFO("Wakereason Tag creation succeeded \n");
 630                         data_obj->wakereason_tag->sp_idx = wakeup_hsp;
 631                         data_obj->wakereason_tag->uid = 1000;
 632                         data_obj->wakereason_tag->string_info = g_string_sized_new(10);
 633                         if (data_obj->wakereason_tag->string_info == NULL) {
 634                                 _ERR("data_obj->wakereason_tag->string_info creation failed");
 635                                 BM_FREE(data_obj->wakereason_tag);
 636                                 return;
 637                         }
 638                         g_string_append_printf(data_obj->wakereason_tag->string_info, "%s", "Tizen");
 639                 } else {
 640                         _ERR(" data_obj->wakereason_tag object creation fails ");
 641                         return;
 642                 }
 643                 data_obj->state_1 |= ST1_CPU_RUNNING_FLAG;
 644         } else {
 645                 data_obj->event_code = ET_NONE;
 646                 data_obj->event_tag = NULL;
 647                 data_obj->wakereason_tag = NULL;
 648                 data_obj->wakereason_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 649                 if (data_obj->wakereason_tag) {
 650                         _INFO("Wakereason Tag creation succeeded \n");
 651                         data_obj->wakereason_tag->sp_idx = wakeup_hsp;
 652                         data_obj->wakereason_tag->uid = 1000;
 653                         data_obj->wakereason_tag->string_info = g_string_sized_new(10);
 654                         if (data_obj->wakereason_tag->string_info == NULL) {
 655                                 _ERR("data_obj->wakereason_tag->string_info creation failed");
 656                                 BM_FREE(data_obj->wakereason_tag);
 657                                 return;
 658                         }
 659                         g_string_append_printf(data_obj->wakereason_tag->string_info, "%s", "Tizen");
 660                 } else {
 661                         _ERR(" data_obj->wakereason_tag object creation fails ");
 662                         return;
 663                 }
 664                 data_obj->state_1 &= ~(ST1_CPU_RUNNING_FLAG);
 665         }
 666
 667         EXIT;
 668         return;
 669 }
 670
 671 static void fill_location_change(int gps)
 672 {
 673         ENTER;
 674
 675         _WARN(" maps location changed =%d ", gps);
 676         if (data_obj) {
 677                 if (gps) {
 678                         data_obj->event_code = ET_NONE;
 679                         data_obj->event_code |= ET_ACTIVE;
 680                         data_obj->event_code |= ET_FLAG_START;
 681                         data_obj->event_tag = NULL;
 682                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 683                         if (data_obj->event_tag) {
 684                                 listener_hsp++;
 685                                 gps_hsp = listener_hsp;
 686                                 _INFO("event Tag creation succeeded \n");
 687                                 data_obj->event_tag->sp_idx = gps_hsp;
 688                         } else {
 689                                 _ERR(" data_obj->event_tag object creation fails ");
 690                                 return;
 691                         }
 692                         data_obj->state_1 |= ST1_GPS_ON_FLAG;
 693                 } else {
 694                         data_obj->event_code = ET_NONE;
 695                         data_obj->event_code |= ET_ACTIVE;
 696                         data_obj->event_code |= ET_FLAG_FINISH;
 697                         data_obj->event_tag = NULL;
 698                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 699                         if (data_obj->event_tag) {
 700                                 _INFO("event Tag creation succeeded \n");
 701                                 data_obj->event_tag->sp_idx = gps_hsp;
 702                         } else {
 703                                 _ERR(" data_obj->event_tag object creation fails ");
 704                                 return;
 705                         }
 706                         data_obj->state_1 &= ~(ST1_GPS_ON_FLAG);
 707                 }
 708         }
 709
 710         EXIT;
 711         return;
 712 }
 713
 714 static int fill_power_lock_unlock_change(int lock)
 715 {
 716         ENTER;
 717
 718         _WARN(" fill_powerlock_change changed =%d ", lock);
 719         if (prev_wakeup == lock)
 720                 return 1;
 721         else
 722                 prev_wakeup = lock;
 723
 724         if (data_obj) {
 725                 if (lock) {
 726                         data_obj->event_code = ET_NONE;
 727                         data_obj->wakelock_tag = NULL;
 728                         data_obj->event_tag = NULL;
 729                         data_obj->wakelock_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 730                         if (data_obj->wakelock_tag) {
 731                                 listener_hsp++;
 732                                 lock_hsp = listener_hsp;
 733                                 _INFO("wakelock Tag creation succeeded \n");
 734                                 data_obj->wakelock_tag->sp_idx = lock_hsp;
 735                                 data_obj->wakelock_tag->uid = 1000;
 736                                 data_obj->wakelock_tag->string_info = g_string_sized_new(10);
 737                                 BM_CHECK_MEM_ALLOC(data_obj->wakelock_tag->string_info, {BM_FREE(data_obj->wakelock_tag); });
 738                                 g_string_append_printf(data_obj->wakelock_tag->string_info, "%s", "Tizen");
 739                                 //WRITE THE WL TAG
 740                         } else {
 741                                 _ERR(" data_obj->wakelock_tag object creation fails ");
 742                                 return 1;
 743                         }
 744                         data_obj->state_1 |= ST1_WAKE_LOCK_FLAG;
 745                 } else {
 746                         data_obj->event_code = ET_NONE;
 747                         data_obj->wakelock_tag = NULL;
 748                         data_obj->event_tag = NULL;
 749                         //WAKE LOCK TAG INFORMATION NOT REQ. AT UNSET.
 750                         data_obj->state_1 &= ~(ST1_WAKE_LOCK_FLAG);
 751                 }
 752         }
 753
 754         EXIT;
 755         return 0;
 756 }
 757
 758 static int fill_app_status_change(int val, char *app_id)
 759 {
 760         ENTER;
 761
 762         if (app_id == NULL)
 763                 return 1;
 764
 765         void *prv_data = NULL;
 766         void *prv_app_id = NULL;
 767         int error_code = 0;
 768
 769         _WARN(" App status changed for = %s ", app_id);
 770         if (data_obj) {
 771                 if (val) {
 772                         data_obj->event_code = ET_NONE;
 773                         data_obj->event_code |= ET_FOREGROUND;
 774                         data_obj->event_code |= ET_FLAG_START;
 775                         data_obj->event_tag = NULL;
 776                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 777                         if (data_obj->event_tag) {
 778                                 listener_hsp++;
 779                                 app_hsp = listener_hsp;
 780                                 _INFO("event Tag creation succeeded \n");
 781                                 data_obj->event_tag->sp_idx = app_hsp;
 782                                 if (g_hash_table_lookup_extended(app_list, app_id, &prv_app_id, &prv_data) == true) {
 783                                         int *temp = (int *)prv_data;
 784                                         *temp = app_hsp;
 785                                         _INFO(" sp index for this app id is = %d and apphsp= %d", *temp, app_hsp);
 786                                         if (fill_AppId_info(app_id)) {
 787                                                 error_code = 1;
 788                                                 goto out;
 789                                         }
 790                                         error_code = 0;
 791                                         goto out;
 792                                 } else {
 793                                         int *temp = (int *)calloc(1, sizeof(int));
 794                                         if (temp == NULL) {
 795                                                 _ERR("memory allocation failed");
 796                                                 BM_FREE(data_obj->event_tag);
 797                                                 error_code = 1;
 798                                                 goto out;
 799                                         }
 800                                         *temp = app_hsp;
 801                                         _INFO("This App is not present in the list, inserting it");
 802                                         g_hash_table_insert(app_list, app_id, temp);
 803                                         if (fill_AppId_info(app_id)) {
 804                                                 error_code = 1;
 805                                                 goto out;
 806                                         }
 807                                         error_code = 0;
 808                                         return error_code;
 809                                 }
 810                         } else {
 811                                 _ERR(" data_obj->event_tag object creation fails ");
 812                                 error_code = 1;
 813                                 goto out;
 814                         }
 815                 } else {
 816                         data_obj->event_code = ET_NONE;
 817                         data_obj->event_code |= ET_FOREGROUND;
 818                         data_obj->event_code |= ET_FLAG_FINISH;
 819                         data_obj->event_tag = NULL;
 820                         data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 821                         if (data_obj->event_tag) {
 822                                 _INFO("looking for key = %s \n", app_id);
 823                                 if (g_hash_table_lookup_extended(app_list, app_id, &prv_app_id, &prv_data) == true) {
 824                                         int *tmp = (int *)prv_data;
 825                                         app_hsp = *tmp;
 826                                         error_code = 0;
 827                                         data_obj->event_tag->sp_idx = app_hsp;
 828                                         if (fill_AppId_info(app_id))
 829                                                 error_code = 1;
 830                                         goto out;
 831                                 } else {
 832                                         _INFO(" This App is not present in the list and in background");
 833                                         BM_FREE(data_obj->event_tag);
 834                                         error_code = 1;
 835                                         goto out;
 836                                 }
 837                         } else {
 838                                 _ERR(" data_obj->event_tag object creation fails ");
 839                                 error_code = 1;
 840                                 goto out;
 841                         }
 842                 }
 843         }
 844
 845 out:
 846         if (app_id)
 847                 g_free(app_id);
 848
 849         EXIT;
 850         return error_code;
 851 }
 852
 853 static void fill_modem_power_state_change(int state)
 854 {
 855         ENTER;
 856
 857         _WARN("fill_modem_power_state_change - state[%d]", state);
 858
 859         if (data_obj && state == 0) { /* ON */
 860                 data_obj->event_code = ET_NONE;
 861                 data_obj->event_code |= ET_ACTIVE;
 862                 data_obj->event_code |= ET_FLAG_START;
 863                 data_obj->event_tag = NULL;
 864
 865                 data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 866                 if (data_obj->event_tag) {
 867                         listener_hsp++;
 868                         modem_hsp = listener_hsp;
 869                         data_obj->event_tag->sp_idx = modem_hsp;
 870                         _DBG("ON event tag - success");
 871                 } else {
 872                         _ERR("ON event tag - failure");
 873                         return;
 874                 }
 875
 876                 data_obj->state_1 |= ST1_MOBILE_RADIO_ACTIVE_FLAG;
 877
 878         } else if (data_obj && state == 1) { /* OFF */
 879                 data_obj->event_code = ET_NONE;
 880                 data_obj->event_code |= ET_ACTIVE;
 881                 data_obj->event_code |= ET_FLAG_FINISH;
 882                 data_obj->event_tag = NULL;
 883
 884                 data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
 885                 if (data_obj->event_tag) {
 886                         data_obj->event_tag->sp_idx = modem_hsp;
 887                         _DBG("OFF event tag - success");
 888                 } else {
 889                         _ERR("OFF event tag - failure");
 890                         return;
 891                 }
 892
 893                 data_obj->state_1 &= ~(ST1_MOBILE_RADIO_ACTIVE_FLAG);
 894
 895         } else {
 896                 _ERR("invalid data-object or state");
 897         }
 898
 899         EXIT;
 900         return;
 901 }
 902
 903 static void bm_create_event_data(int type, int val, char *app)
 904 {
 905         ENTER;
 906         if (!data_obj)
 907                 return;
 908
 909         switch (type) {
 910         case LISTEN_BT_STATE:
 911                 fill_bt_adapter_state_changed_data(val);
 912                 break;
 913         case LISTEN_BT_CONNECTION_STATE:
 914                 fill_bt_device_connection_state_changed_data(val);
 915                 break;
 916         case LISTEN_BT_SCAN_STATE:
 917                 fill_bt_device_discovery_state_changed_data(val);
 918                 break;
 919         case LISTEN_WIFI_STATE:
 920                 fill_wifi_device_state_data(val);
 921                 break;
 922         case LISTEN_WIFI_CONNECTION_STATE:
 923                 fill_wifi_connection_state_changed_data(val);
 924                 break;
 925         case LISTEN_WIFI_SCAN_STATE:
 926                 fill_wifi_scan_changed_data(val);
 927                 break;
 928         case LISTEN_DEVICE_DISPLAY_STATE:
 929                 fill_device_display_change(val);
 930                 break;
 931         case LISTEN_BRIGHTNESS_CHANGE:
 932                 fill_display_brightness_change(val);
 933                 break;
 934         case LISTEN_BATTERY_CAPACITY_CHANGE:
 935                 fill_battery_capacity_change(val);
 936                 break;
 937         case LISTEN_LOCATION_CHANGE:
 938                 fill_location_change(val);
 939                 break;
 940         case LISTEN_CHARGING_STATUS_CHANGE:
 941                 fill_charging_status_change(val);
 942                 break;
 943         case LISTEN_SIGNAL_STRENGTH_CHANGE:
 944                 fill_signal_strength_change(val);
 945                 break;
 946         case LISTEN_POWERLOCKUNLOCK_STATE:
 947                 if (fill_power_lock_unlock_change(val) == BATTERY_MONITOR_ERROR_NONE)
 948                         break;
 949                 else
 950                         return;
 951         case LISTEN_SLEEP_WAKEUP_STATE:
 952                 fill_sleep_wakeup_change(val);
 953                 break;
 954         case LISTEN_APP_STATUS:
 955                 if (fill_app_status_change(val, app) == BATTERY_MONITOR_ERROR_NONE)
 956                         break;
 957                 else
 958                         return;
 959         case LISTEN_MODEM_POWER_STATE:
 960                 fill_modem_power_state_change(val);
 961                 break;
 962         default:
 963                 return;
 964         }
 965
 966         data_obj->cmd_s = CM_UPD;
 967         data_obj->time_current = 0;
 968
 969         struct timeval tv;
 970         gettimeofday(&tv, NULL);
 971         data_obj->time_s = ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000);
 972
 973         double time_taken;
 974         time_taken = (tv.tv_sec - prev_event_time.tv_sec) * 1000000;
 975         time_taken = (time_taken + (tv.tv_usec - prev_event_time.tv_usec)) * 0.000001;
 976
 977         _DBG("time_taken = %lf ", time_taken);
 978
 979         if (time_taken >= BATTERY_INFO_DELAY) {
 980                 if (fill_battery_info() != DEVICE_ERROR_NONE)
 981                         _ERR("Fill Battery information failed ");
 982
 983                 prev_event_time = tv;
 984         } else {
 985                 _DBG("Event occur too early, not updating battery information ");
 986         }
 987
 988         if (type == LISTEN_BATTERY_CAPACITY_CHANGE && prev_battery_level == data_obj->battery_level)
 989                 return;
 990         else
 991                 prev_battery_level = data_obj->battery_level;
 992
 993         if (data_obj->event_tag && type != LISTEN_APP_STATUS) {
 994                 data_obj->event_tag->uid = 1000;
 995                 data_obj->event_tag->string_info = g_string_sized_new(7);
 996                 if (!data_obj->event_tag->string_info) {
 997                         _ERR("memory allocation  failed ");
 998                         return;
 999                 }
1000
1001                 g_string_append_printf(data_obj->event_tag->string_info, "%s", "Tizen");
1002         }
1003         if (data_obj->event_tag) {
1004                 _DBG("Data Value of listener event uid : %d ", data_obj->event_tag->uid);
1005                 _DBG("Data Value of listener event string : %s  sp index = %d",
1006                         data_obj->event_tag->string_info->str, data_obj->event_tag->sp_idx);
1007         }
1008
1009         if (type == LISTEN_POWERLOCKUNLOCK_STATE)
1010                 data_obj->event_tag = NULL;
1011         else
1012                 data_obj->wakelock_tag = NULL;
1013
1014         if (type != LISTEN_SLEEP_WAKEUP_STATE)
1015                 data_obj->wakereason_tag = NULL;
1016
1017         if (bd_store_history_item(data_obj) != BATTERY_MONITOR_ERROR_NONE) {
1018                 _ERR("Failed to store history items ");
1019                 return;
1020         }
1021
1022         EXIT;
1023         return;
1024 }
1025
1026 void* event_producer(void *data)
1027 {
1028         ENTER;
1029         event_pool *event = (event_pool*) data;
1030         if (event == NULL)
1031                 return NULL;
1032
1033         pthread_mutex_lock(&battery_lister_mutex);
1034         while (buff_count == MAX_BUFF)
1035                 pthread_cond_wait(&empty, &battery_lister_mutex);
1036
1037         events_buf[fill_ptr].type = event->type;
1038         events_buf[fill_ptr].val = event->val;
1039         events_buf[fill_ptr].app = event->app;
1040         _INFO("type: %d and val = %d", events_buf[fill_ptr].type , events_buf[fill_ptr].val);
1041         fill_ptr = (fill_ptr + 1) % MAX_BUFF;
1042         buff_count++;
1043
1044         pthread_cond_signal(&fill);
1045         pthread_mutex_unlock(&battery_lister_mutex);
1046
1047         BM_FREE(event);
1048         EXIT;
1049         pthread_exit(NULL);
1050 }
1051
1052 void __bm_bt_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
1053 {
1054         ENTER;
1055         _INFO("__bt_adapter_state_changed_cb");
1056         _INFO("result: %d", result);
1057         _INFO("state: %s", (adapter_state == BT_ADAPTER_ENABLED) ? "ENABLED" : "DISABLED");
1058         int bt_state ;
1059         if (adapter_state == BT_ADAPTER_ENABLED)
1060                 bt_state = 1;
1061         else
1062                 bt_state = 0;
1063
1064         if (bt_adaptor == bt_state)
1065                 return;
1066         else
1067                 bt_adaptor = bt_state;
1068         _INFO("__bm_bt_adapter_state_changed_cb  bt_state = %d ", bt_state);
1069         _INFO("buff_count: %d and fill_ptr = %d", buff_count , fill_ptr);
1070
1071         event_pool *bt_event = (event_pool *)calloc(1, sizeof(event_pool));
1072         if (!bt_event) {
1073                 _ERR("Failed to allocated memory ");
1074                 return;
1075         }
1076         bt_event->type = LISTEN_BT_STATE;
1077         bt_event->val = bt_state;
1078         bt_event->app = NULL;
1079
1080         pthread_t producer;
1081         if (pthread_create(&producer, &attr, event_producer, bt_event)) {
1082                 _ERR("Failed to pthread_create.");
1083                 BM_FREE(bt_event);
1084                 return;
1085         }
1086
1087         EXIT;
1088         return;
1089 }
1090
1091 void __bm_bt_device_connection_state_changed_cb(bool connected, bt_device_connection_info_s *conn_info, void *user_data)
1092 {
1093         ENTER;
1094
1095         _INFO("__bt_device_connection_state_changed_cb [%d]", connected);
1096         _INFO("address [%s]", conn_info->remote_address);
1097         _INFO("link type [%d]", conn_info->link);
1098         if (!connected)
1099                 _INFO("disconnection reason [%d]", conn_info->disconn_reason);
1100
1101         event_pool *bt_event = (event_pool *)calloc(1, sizeof(event_pool));
1102         if (!bt_event) {
1103                 _ERR("Failed to allocated memory ");
1104                 return;
1105         }
1106         bt_event->type = LISTEN_BT_CONNECTION_STATE;
1107         bt_event->val = connected;
1108         bt_event->app = NULL;
1109
1110         pthread_t producer;
1111         if (pthread_create(&producer, &attr, event_producer, bt_event)) {
1112                 _ERR("Failed to pthread_create.");
1113                 BM_FREE(bt_event);
1114                 return;
1115         }
1116
1117         EXIT;
1118         return;
1119 }
1120
1121 static void __bm_bt_device_discovery_state_changed_cb(int result, bt_adapter_device_discovery_state_e discovery_state,
1122         bt_adapter_device_discovery_info_s *discovery_info, void *user_data)
1123 {
1124         ENTER;
1125         _INFO("__bt_adapter_state_changed_cb");
1126         _INFO("result: %d  , discovery_state = %d", result, discovery_state);
1127         if (discovery_state > 1) {
1128                 _INFO(" This state will be handled later");
1129                 return;
1130         }
1131
1132         if (bt_discovery_state == discovery_state) {
1133                 _INFO(" state is same as last state, didnt changed");
1134                 return;
1135         } else {
1136                 bt_discovery_state = discovery_state;
1137         }
1138         event_pool *bt_event = (event_pool *)calloc(1, sizeof(event_pool));
1139         if (!bt_event) {
1140                 _ERR("Failed to allocated memory ");
1141                 return;
1142         }
1143         bt_event->type = LISTEN_BT_SCAN_STATE;
1144         bt_event->val = discovery_state;
1145         bt_event->app = NULL;
1146
1147         pthread_t producer;
1148         if (pthread_create(&producer, &attr, event_producer, bt_event)) {
1149                 _ERR("Failed to pthread_create.");
1150                 BM_FREE(bt_event);
1151                 return;
1152         }
1153
1154         EXIT;
1155         return;
1156 }
1157
1158 static void __bm_wifi_device_state_callback(wifi_manager_device_state_e state, void* user_data)
1159 {
1160         ENTER;
1161
1162         _INFO("Wifi Device state changed callback");
1163
1164         if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED)
1165                 _INFO(", state : Activated\n");
1166         else
1167                 _INFO(", state : Deactivated\n");
1168
1169         event_pool *wifi_event = (event_pool *)calloc(1, sizeof(event_pool));
1170         if (!wifi_event) {
1171                 _ERR("Failed to allocated memory ");
1172                 return;
1173         }
1174         wifi_event->type = LISTEN_WIFI_STATE;
1175         wifi_event->val = state;
1176         wifi_event->app = NULL;
1177
1178         pthread_t producer;
1179         if (pthread_create(&producer, &attr, event_producer, wifi_event)) {
1180                 _ERR("Failed to pthread_create.");
1181                 BM_FREE(wifi_event);
1182                 return;
1183         }
1184
1185         EXIT;
1186         return;
1187 }
1188
1189 static void __bm_wifi_scan_changed_callback(wifi_manager_scan_state_e state, void* user_data)
1190 {
1191         ENTER;
1192
1193         _INFO("Wifi Scan changed, scan state : %d\n", state);
1194
1195         event_pool *wifi_event = (event_pool *)calloc(1, sizeof(event_pool));
1196         if (!wifi_event) {
1197                 _ERR("Failed to allocated memory ");
1198                 return;
1199         }
1200         wifi_event->type = LISTEN_WIFI_SCAN_STATE;
1201         wifi_event->val = state;
1202         wifi_event->app = NULL;
1203
1204         pthread_t producer;
1205         if (pthread_create(&producer, &attr, event_producer, wifi_event)) {
1206                 _ERR("Failed to pthread_create.");
1207                 BM_FREE(wifi_event);
1208                 return;
1209         }
1210
1211         EXIT;
1212         return;
1213 }
1214
1215 static void __bm_wifi_connection_state_changed_callback(wifi_manager_connection_state_e state, wifi_manager_ap_h ap, void *user_data)
1216 {
1217         ENTER;
1218
1219         _INFO("Wifi Connection changed, new connection state : %d\n", state);
1220         if (state == -1 || state == 1 || state == 2) {
1221                 _WARN("These connection states are not related ");
1222                 return;
1223         }
1224
1225         event_pool *wifi_event = (event_pool *)calloc(1, sizeof(event_pool));
1226         if (!wifi_event) {
1227                 _ERR("Failed to allocated memory ");
1228                 return;
1229         }
1230         wifi_event->type = LISTEN_WIFI_CONNECTION_STATE;
1231         wifi_event->val = state;
1232         wifi_event->app = NULL;
1233
1234         pthread_t producer;
1235         if (pthread_create(&producer, &attr, event_producer, wifi_event)) {
1236                 _ERR("Failed to pthread_create.");
1237                 BM_FREE(wifi_event);
1238                 return;
1239         }
1240
1241         EXIT;
1242         return;
1243 }
1244
1245 static void __bm_device_display_change(device_callback_e type, void *value, void *user_data)
1246 {
1247         ENTER;
1248         _INFO("device state changed succeeded\n");
1249
1250         if (type != DEVICE_CALLBACK_DISPLAY_STATE)
1251                 return;
1252
1253         display_state_e state = (display_state_e)value;
1254
1255         if (state == display_flag)
1256                 return;
1257         else
1258                 display_flag = state;
1259
1260         event_pool *device_event = (event_pool *)calloc(1, sizeof(event_pool));
1261         if (!device_event) {
1262                 _ERR("Failed to allocated memory ");
1263                 return;
1264         }
1265         device_event->type = LISTEN_DEVICE_DISPLAY_STATE;
1266         device_event->val = state;
1267         device_event->app = NULL;
1268
1269         pthread_t producer;
1270         if (pthread_create(&producer, &attr, event_producer, device_event)) {
1271                 _ERR("Failed to pthread_create.");
1272                 BM_FREE(device_event);
1273                 return;
1274         }
1275
1276         EXIT;
1277         return;
1278 }
1279
1280 static void __bm_display_brightness_change(keynode_t *key, void* data)
1281 {
1282         ENTER;
1283         _INFO("device brightness changed succeeded\n");
1284         int brightness_level = 0;
1285         vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness_level);
1286
1287         int flag;
1288         if (brightness_level >= 0 && brightness_level <= 10) {
1289                 flag = 0;
1290                 if (brightness_flag == flag)
1291                         return;
1292                 else
1293                         brightness_flag = flag;
1294         } else if (brightness_level > 10 && brightness_level <= 25) {
1295                 flag = 1;
1296                 if (brightness_flag == flag)
1297                         return;
1298                 else
1299                         brightness_flag = flag;
1300         } else if (brightness_level > 25 && brightness_level <= 50) {
1301                 flag = 2;
1302                 if (brightness_flag == flag)
1303                         return;
1304                 else
1305                         brightness_flag = flag;
1306         } else if (brightness_level > 50 && brightness_level <= 75) {
1307                 flag = 3;
1308                 if (brightness_flag == flag)
1309                         return;
1310                 else
1311                         brightness_flag = flag;
1312         } else if (brightness_level > 75 && brightness_level <= 100) {
1313                 flag = 4;
1314                 if (brightness_flag == flag)
1315                         return;
1316                 else
1317                         brightness_flag = flag;
1318         }
1319
1320         _INFO(" device brightness changed =%d ", brightness_level);
1321
1322         event_pool *display_event = (event_pool *)calloc(1, sizeof(event_pool));
1323         if (!display_event) {
1324                 _ERR("Failed to allocated memory ");
1325                 return;
1326         }
1327         display_event->type = LISTEN_BRIGHTNESS_CHANGE;
1328         display_event->val = brightness_flag;
1329         display_event->app = NULL;
1330
1331         pthread_t producer;
1332         if (pthread_create(&producer, &attr, event_producer, display_event)) {
1333                 _ERR("Failed to pthread_create.");
1334                 BM_FREE(display_event);
1335                 return;
1336         }
1337
1338         EXIT;
1339         return;
1340 }
1341
1342 static void __bm_battery_capacity_change(keynode_t *key, void* data)
1343 {
1344         ENTER;
1345         _INFO("device battery_capacity changed succeeded\n");
1346         int charging = 0;
1347         vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &charging);
1348
1349         _INFO(" device battery_capacity changed =%d ", charging);
1350
1351         event_pool *charging_event = (event_pool *)calloc(1, sizeof(event_pool));
1352         if (!charging_event) {
1353                 _ERR("Failed to allocated memory ");
1354                 return;
1355         }
1356         charging_event->type = LISTEN_BATTERY_CAPACITY_CHANGE;
1357         charging_event->val = charging;
1358         charging_event->app = NULL;
1359
1360         pthread_t producer;
1361         if (pthread_create(&producer, &attr, event_producer, charging_event)) {
1362                 _ERR("Failed to pthread_create.");
1363                 BM_FREE(charging_event);
1364                 return;
1365         }
1366
1367         EXIT;
1368         return;
1369 }
1370
1371 static void __bm_charging_status_change(keynode_t *key, void* data)
1372 {
1373         ENTER;
1374         _INFO("device charging_status changed succeeded\n");
1375         int charging = 0;
1376         vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &charging);
1377
1378         _INFO(" device charging_status changed = %d ", charging);
1379
1380         event_pool *charging_event = (event_pool *)calloc(1, sizeof(event_pool));
1381         if (!charging_event) {
1382                 _ERR("Failed to allocated memory ");
1383                 return;
1384         }
1385         charging_event->type = LISTEN_CHARGING_STATUS_CHANGE;
1386         charging_event->val = charging;
1387         charging_event->app = NULL;
1388
1389         pthread_t producer;
1390         if (pthread_create(&producer, &attr, event_producer, charging_event)) {
1391                 _ERR("Failed to pthread_create.");
1392                 BM_FREE(charging_event);
1393                 return;
1394         }
1395
1396         EXIT;
1397         return;
1398 }
1399
1400 static void __bm_location_change(keynode_t *key, void* data)
1401 {
1402         ENTER;
1403         _INFO("device location changed succeeded\n");
1404         int location = 0;
1405         vconf_get_int(VCONFKEY_LOCATION_ENABLED, &location);
1406
1407         _INFO(" device location changed = %d ", location);
1408
1409         if (location == location_flag)
1410                 return;
1411         else
1412                 location_flag = location;
1413
1414         event_pool *location_event = (event_pool *)calloc(1, sizeof(event_pool));
1415         if (!location_event) {
1416                 _ERR("Failed to allocated memory ");
1417                 return;
1418         }
1419         location_event->type = LISTEN_LOCATION_CHANGE;
1420         location_event->val = location;
1421         location_event->app = NULL;
1422
1423         pthread_t producer;
1424         if (pthread_create(&producer, &attr, event_producer, location_event)) {
1425                 _ERR("Failed to pthread_create.");
1426                 BM_FREE(location_event);
1427                 return;
1428         }
1429
1430         EXIT;
1431         return;
1432 }
1433
1434 static void _bm_notify_signal_strength(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
1435 {
1436         ENTER;
1437
1438         if (data == NULL) {
1439                 _ERR("invalid data");
1440                 return;
1441         }
1442
1443         int sig_strength_level = *((int *)data);
1444
1445         _INFO(" device signal strength changed = %d ", sig_strength_level);
1446
1447         if (ss_flag == sig_strength_level)
1448                 return;
1449         else
1450                 ss_flag = sig_strength_level;
1451
1452         event_pool *signal_event = (event_pool *)calloc(1, sizeof(event_pool));
1453         if (!signal_event) {
1454                 _ERR("Failed to allocated memory ");
1455                 return;
1456         }
1457         signal_event->type = LISTEN_SIGNAL_STRENGTH_CHANGE;
1458         signal_event->val = ss_flag;
1459         signal_event->app = NULL;
1460
1461         pthread_t producer;
1462         if (pthread_create(&producer, &attr, event_producer, signal_event)) {
1463                 _ERR("Failed to pthread_create.");
1464                 BM_FREE(signal_event);
1465                 return;
1466         }
1467
1468         EXIT;
1469         return;
1470 }
1471
1472 static void _bm_notify_modem_power(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
1473 {
1474         ENTER;
1475
1476         if (data == NULL) {
1477                 _ERR("invalid data");
1478                 return;
1479         }
1480
1481         _INFO("modem power change notification - data[%d]", *((int *)data));
1482
1483         int *status = (int *)data;
1484
1485         if (*status && !modem_flag) {
1486                 _DBG("redundant request");
1487                 return;
1488         }
1489
1490         int state = -1;
1491
1492         /* handling only On/Off states */
1493         switch (*status) {
1494         case 0: /* ON */
1495                 state = 0;
1496                 modem_flag = 1;
1497                 break;
1498         case 1: /* OFF */
1499                 state = 1;
1500                 modem_flag = 0;
1501                 break;
1502         default:
1503                 break;
1504         }
1505
1506         if (state != -1) {
1507                 event_pool *modem_power_event = (event_pool *)calloc(1, sizeof(event_pool));
1508                 if (!modem_power_event) {
1509                         _ERR("Failed to allocated memory ");
1510                         return;
1511                 }
1512                 modem_power_event->type = LISTEN_MODEM_POWER_STATE;
1513                 modem_power_event->val = state;
1514                 modem_power_event->app = NULL;
1515
1516                 pthread_t producer;
1517                 if (pthread_create(&producer, &attr, event_producer, modem_power_event)) {
1518                         _ERR("Failed to pthread_create.");
1519                         BM_FREE(modem_power_event);
1520                         return;
1521                 }
1522         }
1523
1524         EXIT;
1525         return;
1526 }
1527
1528 static void create_lock_event(char *lock_type)
1529 {
1530         int val;
1531
1532         if (g_strcmp0(lock_type, "lcdoff") == 0)
1533                 val = 0;
1534         else if (g_strcmp0(lock_type, "lcddim") == 0)
1535                 val = 1;
1536         else if (g_strcmp0(lock_type, "lcdon") == 0)
1537                 val = 2;
1538         else
1539                 return;
1540
1541         if (prev_lock == val)
1542                 return;
1543         else
1544                 prev_lock = val;
1545
1546         event_pool *lock_event = (event_pool *)calloc(1, sizeof(event_pool));
1547         if (!lock_event) {
1548                 _ERR("Failed to allocated memory ");
1549                 return;
1550         }
1551
1552         lock_event->type = LISTEN_POWERLOCKUNLOCK_STATE;
1553         lock_event->val = val;
1554         lock_event->app = NULL;
1555
1556         pthread_t producer;
1557         if (pthread_create(&producer, &attr, event_producer, lock_event)) {
1558                 _ERR("Failed to pthread_create.");
1559                 BM_FREE(lock_event);
1560                 return;
1561         }
1562
1563         EXIT;
1564         return;
1565 }
1566
1567 static void __powerlock_signal_callback(GDBusConnection *conn,
1568                 const gchar *sender,
1569                 const gchar *path,
1570                 const gchar *iface,
1571                 const gchar *signal,
1572                 GVariant *params,
1573                 gpointer user_data)
1574 {
1575         ENTER;
1576         pid_t pid;
1577         char *lock_type;
1578         unsigned int timeout;
1579         g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
1580
1581         _INFO(" powerlock value changed =%s Pid=%d, timeout=%d", lock_type, pid, timeout);
1582
1583         create_lock_event(lock_type);
1584
1585         EXIT;
1586         return;
1587 }
1588
1589 static void __powerunlock_signal_callback(GDBusConnection *conn,
1590                 const gchar *sender,
1591                 const gchar *path,
1592                 const gchar *iface,
1593                 const gchar *signal,
1594                 GVariant *params,
1595                 gpointer user_data)
1596 {
1597         ENTER;
1598         pid_t pid;
1599         char *lock_type;
1600         unsigned int timeout;
1601
1602         g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
1603
1604         _INFO(" powerUnlock value changed =%s Pid=%d, timeout=%d", lock_type, pid, timeout);
1605
1606         create_lock_event(lock_type);
1607
1608         EXIT;
1609         return;
1610 }
1611
1612 static void __sleep_signal_callback(GDBusConnection *conn,
1613                 const gchar *sender,
1614                 const gchar *path,
1615                 const gchar *iface,
1616                 const gchar *signal,
1617                 GVariant *params,
1618                 gpointer user_data)
1619 {
1620         ENTER;
1621
1622         event_pool *sleep_event = (event_pool *)calloc(1, sizeof(event_pool));
1623         if (!sleep_event) {
1624                 _ERR("Failed to allocated memory ");
1625                 return;
1626         }
1627
1628         sleep_event->type = LISTEN_SLEEP_WAKEUP_STATE;
1629         sleep_event->val = 0;
1630         sleep_event->app = NULL;
1631
1632         pthread_t producer;
1633         if (pthread_create(&producer, &attr, event_producer, sleep_event)) {
1634                 _ERR("Failed to pthread_create.");
1635                 BM_FREE(sleep_event);
1636                 return;
1637         }
1638
1639         EXIT;
1640         return;
1641 }
1642
1643 static void __wakeup_signal_callback(GDBusConnection *conn,
1644                 const gchar *sender,
1645                 const gchar *path,
1646                 const gchar *iface,
1647                 const gchar *signal,
1648                 GVariant *params,
1649                 gpointer user_data)
1650 {
1651         ENTER;
1652
1653         event_pool *wakeup_event = (event_pool *)calloc(1, sizeof(event_pool));
1654         if (!wakeup_event) {
1655                 _ERR("Failed to allocated memory ");
1656                 return;
1657         }
1658
1659         wakeup_event->type = LISTEN_SLEEP_WAKEUP_STATE;
1660         wakeup_event->val = 1;
1661         wakeup_event->app = NULL;
1662
1663         pthread_t producer;
1664         if (pthread_create(&producer, &attr, event_producer, wakeup_event)) {
1665                 _ERR("Failed to pthread_create.");
1666                 BM_FREE(wakeup_event);
1667                 return;
1668         }
1669
1670         EXIT;
1671         return;
1672 }
1673
1674 static void __app_status_signal_callback(GDBusConnection *conn,
1675                 const gchar *sender,
1676                 const gchar *path,
1677                 const gchar *iface,
1678                 const gchar *signal,
1679                 GVariant *params,
1680                 gpointer user_data)
1681 {
1682         ENTER;
1683         int pid, val;
1684         char *appid;
1685         char *status;
1686
1687         /* (issss) : pid, appid, pkgid, status, type */
1688         g_variant_get(params, "(i&s&s&s&s)", &pid, &appid, NULL, &status, NULL);
1689
1690         if (status == NULL) {
1691                 _ERR("Status is NULL");
1692                 return;
1693         }
1694
1695         if (appid == NULL) {
1696                 _ERR("appid is NULL");
1697                 return;
1698         }
1699
1700         event_pool *app_event = (event_pool *)calloc(1, sizeof(event_pool));
1701         if (!app_event) {
1702                 _ERR("Failed to allocated memory ");
1703                 return;
1704         }
1705
1706         _DBG("pid:%d, appid:%s, status:%s", pid, appid, status);
1707
1708         if (g_strcmp0(status, "fg") == 0)
1709                 val = 1;
1710         else
1711                 val = 0;
1712
1713         app_event->type = LISTEN_APP_STATUS;
1714         app_event->val = val;
1715         app_event->app = g_strdup(appid);
1716
1717         pthread_t producer;
1718         if (pthread_create(&producer, &attr, event_producer, app_event)) {
1719                 _ERR("Failed to pthread_create.");
1720                 BM_FREE(app_event->app);
1721                 BM_FREE(app_event);
1722         }
1723
1724         EXIT;
1725         return;
1726 }
1727
1728 static int  bm_charging_status_listeners()
1729 {
1730         ENTER;
1731
1732         /* Charging callbacks */
1733         int ret = 0;
1734         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS, __bm_charging_status_change, NULL);
1735         if (ret != 0) {
1736                 _ERR("failed to register a cb key:%s err:%d", "VCONFKEY_SYSMAN_CHARGER_STATUS", ret);
1737                 return 1;
1738         }
1739
1740         EXIT;
1741         return 0;
1742 }
1743
1744 static int  bm_battery_capacity_listeners()
1745 {
1746         ENTER;
1747
1748         /* Charging callbacks */
1749         int ret = 0;
1750         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, __bm_battery_capacity_change, NULL);
1751         if (ret != 0) {
1752                 _ERR("failed to register a cb key:%s err:%d", "VCONFKEY_SYSMAN_BATTERY_CAPACITY", ret);
1753                 return 1;
1754         }
1755
1756         EXIT;
1757         return 0;
1758 }
1759
1760 static int  bm_location_listeners()
1761 {
1762         ENTER;
1763
1764         /* Charging callbacks */
1765         int ret = 0;
1766         ret = vconf_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __bm_location_change, NULL);
1767         if (ret != 0) {
1768                 _ERR("failed to register a cb key:%s err:%d", "VCONFKEY_LOCATION_ENABLED", ret);
1769                 return 1;
1770         }
1771
1772         EXIT;
1773         return 0;
1774 }
1775
1776 static int  bm_screen_subscribe_listeners()
1777 {
1778         ENTER;
1779
1780         /* Screen callbacks */
1781         int ret = device_add_callback(DEVICE_CALLBACK_DISPLAY_STATE, __bm_device_display_change, NULL);
1782         if (ret != BATTERY_MONITOR_ERROR_NONE) {
1783                 _ERR("device_add_callback failed: %s", get_error_message(ret));
1784                 return 1;
1785         }
1786
1787         EXIT;
1788         return 0;
1789 }
1790
1791 static int bm_telephony_listeners()
1792 {
1793         ENTER;
1794
1795         /* get handle */
1796         handle = tel_init(NULL);
1797         if (handle == NULL) {
1798                 _ERR("invalid handle - signal strength");
1799                 return 1;
1800         }
1801
1802         int ret = BATTERY_MONITOR_ERROR_NONE;
1803
1804         /* register signal strength notification */
1805         ret = tel_register_noti_event(handle, TAPI_PROP_NETWORK_SIGNALSTRENGTH_LEVEL, _bm_notify_signal_strength, NULL);
1806         if (ret != BATTERY_MONITOR_ERROR_NONE) {
1807                 _ERR("register for signal-strength failed");
1808                 return 1;
1809         }
1810
1811         /* register modem power notification */
1812         ret = tel_register_noti_event(handle, TAPI_PROP_MODEM_POWER, _bm_notify_modem_power, NULL);
1813         if (ret != BATTERY_MONITOR_ERROR_NONE) {
1814                 _ERR("register for modem-power failed");
1815                 return 1;
1816         }
1817
1818         EXIT;
1819         return 0;
1820 }
1821
1822 static int  bm_display_brightness_listeners()
1823 {
1824         ENTER;
1825
1826         /* Screen callbacks */
1827         int ret = 0;
1828         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, __bm_display_brightness_change, NULL);
1829         if (ret != 0) {
1830                 _ERR("failed to register a cb key:%s err:%d", "VCONFKEY_SETAPPL_LCD_BRIGHTNESS", ret);
1831                 return 1;
1832         }
1833
1834         EXIT;
1835         return 0;
1836 }
1837
1838 static int  bm_wifi_subscribe_listeners()
1839 {
1840         ENTER;
1841
1842         /* Wifi callbacks */
1843         int rv = wifi_manager_initialize(&wifi);
1844         if (rv == WIFI_MANAGER_ERROR_NONE) {
1845                 int ret = wifi_manager_set_device_state_changed_cb(wifi, __bm_wifi_device_state_callback, NULL);
1846                 if (ret == WIFI_MANAGER_ERROR_NONE)
1847                         _INFO("wifi_manager_set_device_state_changed_cb  success  : [%p]\n", __bm_wifi_device_state_callback);
1848                 else
1849                         _ERR("wifi_manager_set_device_state_changed_cb failed");
1850
1851                 ret = wifi_manager_set_scan_state_changed_cb(wifi, __bm_wifi_scan_changed_callback, NULL);
1852                 if (ret == WIFI_MANAGER_ERROR_NONE)
1853                         _INFO("wifi_manager_set_scan_state_changed_cb  success\n");
1854                 else
1855                         _ERR("wifi_manager_set_scan_state_changed_cb failed");
1856
1857                 ret = wifi_manager_set_connection_state_changed_cb(wifi, __bm_wifi_connection_state_changed_callback, NULL);
1858                 if (ret == WIFI_MANAGER_ERROR_NONE)
1859                         _INFO("wifi_manager_set_connection_state_changed_cb  success\n");
1860                 else
1861                         _ERR("wifi_manager_set_scan_state_changed_cb failed");
1862         } else {
1863                 _ERR(" Wifi init failed \n");
1864                 return 1;
1865         }
1866
1867         _INFO("Wifi init succeeded\n");
1868
1869         EXIT;
1870         return 0;
1871 }
1872
1873 static int  bm_bluetooth_subscribe_listeners()
1874 {
1875         ENTER;
1876
1877         /* Bluetooth callbacks */
1878         int rv = bt_initialize();
1879
1880         if (rv == BT_ERROR_NONE) {
1881                 int ret = bt_device_set_connection_state_changed_cb(__bm_bt_device_connection_state_changed_cb, NULL);
1882                 _INFO("bt_device_set_connection_state_changed_cb  ret =%d \n", ret);
1883
1884                 ret = bt_adapter_set_state_changed_cb(__bm_bt_adapter_state_changed_cb, NULL);
1885                 _INFO("bt_adapter_set_state_changed_cb ret =%d \n", ret);
1886
1887                 ret = bt_adapter_set_device_discovery_state_changed_cb(__bm_bt_device_discovery_state_changed_cb, NULL);
1888                 _INFO("bt_adapter_set_device_discovery_state_changed_cb ret =%d \n", ret);
1889
1890         } else {
1891                 _ERR(" bluetooth init failed \n");
1892                 return 1;
1893         }
1894
1895         _INFO("bluetooth init succeeded\n");
1896         EXIT;
1897         return 0;
1898 }
1899
1900 static int bm_powerlock_unlock_subscribe_listener(void)
1901 {
1902         ENTER;
1903         guint ret = 0;
1904
1905         if (!dbus_connection) {
1906                 _ERR("dbus connection is null");
1907                 EXIT;
1908                 return 1;
1909         }
1910
1911         ret = g_dbus_connection_signal_subscribe(dbus_connection,
1912                                 NULL,
1913                                 DBUS_DEVICED_IFACE,
1914                                 DBUS_DEVICED_PL_MEMBER,
1915                                 DBUS_DEVICED_PATH,
1916                                 NULL,
1917                                 G_DBUS_SIGNAL_FLAGS_NONE,
1918                                 __powerlock_signal_callback,
1919                                 NULL,
1920                                 NULL);
1921
1922         if (ret == 0) {
1923                 _ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
1924                 return 1;
1925         }
1926
1927         ret = g_dbus_connection_signal_subscribe(dbus_connection,
1928                                         NULL,
1929                                         DBUS_DEVICED_IFACE,
1930                                         DBUS_DEVICED_PU_MEMBER,
1931                                         DBUS_DEVICED_PATH,
1932                                         NULL,
1933                                         G_DBUS_SIGNAL_FLAGS_NONE,
1934                                         __powerunlock_signal_callback,
1935                                         NULL,
1936                                         NULL);
1937
1938         if (ret == 0) {
1939                 _ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
1940                 return 1;
1941         }
1942
1943         EXIT;
1944         return BATTERY_MONITOR_ERROR_NONE;
1945 }
1946
1947 static int bm_sleep_wakeup_subscribe_listener(void)
1948 {
1949         ENTER;
1950         guint ret = 0;
1951
1952         if (!dbus_connection) {
1953                 _ERR("dbus connection is null");
1954                 EXIT;
1955                 return 1;
1956         }
1957
1958         ret = g_dbus_connection_signal_subscribe(dbus_connection,
1959                                 NULL,
1960                                 DBUS_DEVICED_IFACE,
1961                                 DBUS_DEVICED_SLEEP_MEMBER,
1962                                 DBUS_DEVICED_PATH,
1963                                 NULL,
1964                                 G_DBUS_SIGNAL_FLAGS_NONE,
1965                                 __sleep_signal_callback,
1966                                 NULL,
1967                                 NULL);
1968
1969         if (ret == 0) {
1970                 _ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
1971                 return 1;
1972         }
1973
1974         ret = g_dbus_connection_signal_subscribe(dbus_connection,
1975                                 NULL,
1976                                 DBUS_DEVICED_IFACE,
1977                                 DBUS_DEVICED_WAKEUP_MEMBER,
1978                                 DBUS_DEVICED_PATH,
1979                                 NULL,
1980                                 G_DBUS_SIGNAL_FLAGS_NONE,
1981                                 __wakeup_signal_callback,
1982                                 NULL,
1983                                 NULL);
1984
1985         if (ret == 0) {
1986                 _ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
1987                 return 1;
1988         }
1989
1990         EXIT;
1991         return BATTERY_MONITOR_ERROR_NONE;
1992 }
1993
1994 static int bm_app_status_listener(void)
1995 {
1996         ENTER;
1997         guint ret = 0;
1998
1999         if (!dbus_connection) {
2000                 _ERR("dbus connection is null");
2001                 EXIT;
2002                 return 1;
2003         }
2004
2005         ret = g_dbus_connection_signal_subscribe(dbus_connection,
2006                                 NULL,
2007                                 "org.tizen.aul.AppStatus",
2008                                 "AppStatusChange",
2009                                 "/Org/Tizen/Aul/AppStatus",
2010                                 NULL,
2011                                 G_DBUS_SIGNAL_FLAGS_NONE,
2012                                 __app_status_signal_callback,
2013                                 NULL,
2014                                 NULL);
2015
2016         if (ret == 0) {
2017                 _ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
2018                 return 1;
2019         }
2020
2021         EXIT;
2022         return BATTERY_MONITOR_ERROR_NONE;
2023 }
2024
2025 void* event_consumer()
2026 {
2027         ENTER;
2028
2029         while (1) {
2030                 pthread_mutex_lock(&battery_lister_mutex);
2031                 while (buff_count == 0)
2032                         pthread_cond_wait(&fill, &battery_lister_mutex);
2033
2034                 bm_create_event_data(events_buf[use_ptr].type, events_buf[use_ptr].val, events_buf[use_ptr].app);
2035
2036                 _INFO("type: %d and val = %d", events_buf[use_ptr].type, events_buf[use_ptr].val);
2037                 _INFO("buff_count: %d and fill_ptr = %d , use_ptr = %d", buff_count, fill_ptr, use_ptr);
2038
2039                 use_ptr = (use_ptr + 1) % MAX_BUFF;
2040                 buff_count--;
2041
2042                 pthread_cond_signal(&empty);
2043                 pthread_mutex_unlock(&battery_lister_mutex);
2044         }
2045         EXIT;
2046 }
2047
2048 static int bm_initialize_history_data_obj()
2049 {
2050         ENTER;
2051
2052         pthread_t consumer;
2053         if (pthread_create(&consumer, &attr, event_consumer, NULL)) {
2054                 _ERR("Failed to pthread_create.");
2055                 return BATTERY_MONITOR_ERROR_NOT_SUPPORTED;
2056         }
2057
2058         // Hash table initialize for application list
2059         app_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
2060
2061         if (data_obj != NULL) {
2062                 _WARN(" History data object already exits");
2063                 return BATTERY_MONITOR_ERROR_NONE;
2064         }
2065         data_obj = (history_item_s *)calloc(1, sizeof(history_item_s));
2066         if (data_obj) {
2067                 data_obj->state_1 = 0;
2068                 data_obj->state_2 = 0;
2069                 data_obj->event_code = ET_NONE;
2070                 data_obj->event_tag = NULL;
2071         } else {
2072                 _ERR(" history_item_s data object creation fails ");
2073                 return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
2074         }
2075
2076         if (fill_battery_info() != DEVICE_ERROR_NONE) {
2077                 _ERR("Battery information failed ");
2078                 data_obj->battery_level = 0;
2079                 data_obj->battery_temperature = 0;
2080                 data_obj->battery_voltage = 0;
2081                 data_obj->battery_health = BD_BHLT_UNKN;
2082                 data_obj->battery_plugtype = BD_BPLT_NONE;
2083                 data_obj->battery_status = BD_BSTA_UNKN;
2084         }
2085
2086         gettimeofday(&prev_event_time, NULL);
2087
2088         EXIT;
2089         return BATTERY_MONITOR_ERROR_NONE;
2090 }
2091
2092 int bd_initialize_listeners(void)
2093 {
2094         ENTER;
2095
2096         listener_hsp = -1;
2097
2098         /* Initialize Hash Table */
2099         if (!bm_initialize_history_data_obj())
2100                 _INFO("bm_initialize_history_data_obj succeeded \n");
2101         else {
2102                 _ERR("bm_initialize_history_data_obj failed \n");
2103                 return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
2104         }
2105
2106         /* Initialize pthread attributes */
2107         if (pthread_attr_init(&attr) != 0) {
2108                 _ERR("pthread_attr_init failed");
2109                 return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
2110         }
2111
2112         if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
2113                 _ERR("pthread_attr_setdetachstate failed");
2114
2115         /*Initialize DBus*/
2116         if (bm_listener_dbus_init())
2117                 _ERR("bm_listener_dbus_init failed \n");
2118
2119         /*  Wifi callbacks */
2120         if (!bm_wifi_subscribe_listeners())
2121                 _INFO("Wifi listeners succeeded to subscribed\n");
2122         else
2123                 _ERR("Wifi listeners failed to subscribed\n");
2124
2125         /*  BlueTooth callbacks */
2126         if (!bm_bluetooth_subscribe_listeners())
2127                 _INFO("bluetooth listeners succeeded to subscribed\n");
2128         else
2129                 _ERR("bluetooth listeners failed to subscribed\n");
2130
2131         /*  Screen wakeup callbacks */
2132         if (!bm_screen_subscribe_listeners())
2133                 _INFO("Display listeners succeeded to subscribed\n");
2134         else
2135                 _ERR("Display listeners failed to subscribed\n");
2136
2137         /* Brightness change callbacks */
2138         if (!bm_display_brightness_listeners())
2139                 _INFO("Brightness listeners succeeded to subscribed\n");
2140         else
2141                 _ERR("Brightness listeners failed to subscribed\n");
2142
2143         /* battery_capacity change callbacks */
2144         if (!bm_battery_capacity_listeners())
2145                 _INFO("battery_capacity listeners succeeded to subscribed\n");
2146         else
2147                 _ERR("battery_capacity listeners failed to subscribed\n");
2148
2149         /* battery charging change callbacks */
2150         if (!bm_charging_status_listeners())
2151                 _INFO("battery charging listeners succeeded to subscribed\n");
2152         else
2153                 _ERR("battery charging listeners failed to subscribed\n");
2154
2155         /* GPS change callbacks */
2156         if (!bm_location_listeners())
2157                 _INFO("location listeners succeeded to subscribed\n");
2158         else
2159                 _ERR("location listeners failed to subscribed\n");
2160
2161         /* telephony listeners */
2162         if (!bm_telephony_listeners())
2163                 _INFO("telephony listeners succeeded to subscribed\n");
2164         else
2165                 _ERR("telephony  listeners failed to subscribed\n");
2166
2167         /* Powerlock callbacks */
2168         if (!bm_powerlock_unlock_subscribe_listener())
2169                 _INFO("Pwoerlock listeners succeeded to subscribed\n");
2170         else
2171                 _ERR("Powerlock listeners failed to subscribed\n");
2172
2173         /* Device Sleep callbacks */
2174         if (!bm_sleep_wakeup_subscribe_listener())
2175                 _INFO("Sleep Wakeup listeners succeeded to subscribed\n");
2176         else
2177                 _ERR("Sleep Wakeup listeners failed to subscribed\n");
2178
2179         /* App Status callbacks */
2180         if (!bm_app_status_listener())
2181                 _INFO("FG listeners succeeded to subscribed\n");
2182         else
2183                 _ERR("FG Wakeup listeners failed to subscribed\n");
2184
2185         EXIT;
2186         return BATTERY_MONITOR_ERROR_NONE;
2187 }
2188
2189 int bd_deinitialize_listeners()
2190 {
2191         ENTER;
2192
2193         _INFO("de-initializing History listeners");
2194
2195         /* Wi-Fi */
2196         /*unset the callbacks related to wifi*/
2197         if (wifi_manager_unset_connection_state_changed_cb(wifi) != WIFI_MANAGER_ERROR_NONE)
2198                 _ERR("wifi_manager_unset_connection_state_changed_cb() failed.\n");
2199         else
2200                 _INFO("wifi_manager_unset_connection_state_changed_cb() success.\n");
2201
2202         if (wifi_manager_deinitialize(wifi) != WIFI_MANAGER_ERROR_NONE)
2203                 _ERR("wifi_manager_deinitialize() failed.\n");
2204         else
2205                 _INFO("wifi_manager_deinitialize() success.\n");
2206
2207         /* Bluetooth */
2208         /* unset bluetooth device connection state changed state event callback*/
2209         if (bt_device_unset_connection_state_changed_cb() != BT_ERROR_NONE)
2210                 _ERR("bt_device_unset_connection_state_changed_cb() failed.\n");
2211         else
2212                 _INFO("bt_device_unset_connection_state_changed_cb() success.\n");
2213
2214         /* unset bluetooth adapter changed state event callback*/
2215         if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE)
2216                 _ERR("bt_adapter_unset_state_changed_cb() failed.\n");
2217         else
2218                 _INFO("bt_adapter_unset_state_changed_cb() success.\n");
2219
2220         /* deinit bluetooth api*/
2221         if (bt_deinitialize() != BT_ERROR_NONE)
2222                 _ERR("bt_deinitialize() failed.\n");
2223         else
2224                 _INFO("bt_deinitialize() success.\n");
2225
2226         //Brightness
2227         if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, __bm_display_brightness_change) < 0)
2228                 _ERR("failed to de-register vconf callback");
2229
2230         //Battery capacity
2231         if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, __bm_battery_capacity_change) < 0)
2232                 _ERR("failed to de-register vconf callback");
2233
2234         //Battery charging
2235         if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS, __bm_charging_status_change) < 0)
2236                 _ERR("failed to de-register vconf callback");
2237
2238         /* de-register telephony callbacks */
2239         if (handle) {
2240                 int ret = tel_deregister_noti_event(handle, TAPI_NOTI_NETWORK_SIGNALSTRENGTH);
2241                 if (ret != BATTERY_MONITOR_ERROR_NONE) {
2242                         _ERR("tel_deregister_noti_event failed: %s", get_error_message(ret));
2243                         return 1;
2244                 }
2245                 ret = tel_deregister_noti_event(handle, TAPI_NOTI_MODEM_POWER);
2246                 if (ret != BATTERY_MONITOR_ERROR_NONE) {
2247                         _ERR("tel_deregister_noti_event failed: %s", get_error_message(ret));
2248                         return 1;
2249                 }
2250                 tel_deinit(handle);
2251         }
2252
2253         /*Dbus Deinitialize*/
2254         if (bm_listener_dbus_deinit())
2255                 _ERR("failed to de-init dbus ");
2256
2257         /* de-initialize pthread attributes */
2258         if (pthread_attr_destroy(&attr) != 0)
2259                 _ERR("pthread_attr_destroy failed");
2260
2261         g_hash_table_destroy(app_list);
2262
2263         if (data_obj)
2264                 BM_FREE(data_obj);
2265
2266         EXIT;
2267         return BATTERY_MONITOR_ERROR_NONE;
2268 }