#define DBUS_DEVICED_SLEEP_MEMBER "sleep"
#define DBUS_DEVICED_WAKEUP_MEMBER "wakeup"
-/*static GDBusConnection *dbus_connection;
-
-static int bm_listener_dbus_init(void)
-{
- ENTER;
-
- GDBusConnection *conn;
- GError *err = NULL;
-
- if (dbus_connection) {
- _DBG("dbus connection already initialized");
- return 0;
- }
-
- conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
- if (!conn || err) {
- _ERR("failed to get dbus connection:%s", err->message);
- g_error_free(err);
- conn = NULL;
- return -1;
- }
-
- dbus_connection = conn;
-
- EXIT;
- return 0;
-}
-
-int bm_listener_dbus_deinit()
-{
- ENTER;
-
- if (dbus_connection)
- g_object_unref(dbus_connection);
- dbus_connection = NULL;
-
- EXIT;
- return BATTERY_MONITOR_ERROR_NONE;
-}*/
-
-static int fill_AppId_info(char *app_id)
+static int bd_listener_set_appId_info(char *app_id)
{
ENTER;
int ret = 0;
return ret;
}
-static int fill_battery_info()
+static int bd_listener_set_battery_info()
{
ENTER;
+
struct device_battery_info info;
int ret = device_battery_get_info(&info);
if (ret == DEVICE_ERROR_NONE) {
return ret;
}
-static void fill_bt_adapter_state_changed_data(int adapter_state)
+static void bd_listener_set_bt_adapter_state_change_data(int adapter_state)
{
ENTER;
return;
}
-static void fill_bt_device_discovery_state_changed_data(int discovery_state)
+static void bd_listener_set_bt_device_discovery_state_change_data(int discovery_state)
{
ENTER;
return;
}
-static void fill_bt_device_connection_state_changed_data(int connected)
+static void bd_listener_set_bt_device_connection_state_change_data(int connected)
{
ENTER;
return;
}
-static void fill_wifi_device_state_data(int state)
+static void bd_listener_set_wifi_device_state_data(int state)
{
ENTER;
return;
}
-static void fill_wifi_scan_changed_data(int state)
+static void bd_listener_set_wifi_scan_change_data(int state)
{
ENTER;
return;
}
-static void fill_wifi_connection_state_changed_data(int state)
+static void bd_listener_set_wifi_connection_state_change_data(int state)
{
ENTER;
return;
}
-static void fill_device_display_change(int value)
+static void bd_listener_set_device_display_change_data(int value)
{
ENTER;
_WARN("device state changed succeeded\n");
return;
}
-static void fill_display_brightness_change(int brightness_level)
+static void bd_listener_set_display_brightness_change_data(int brightness_level)
{
ENTER;
return;
}
-static void fill_battery_capacity_change(int charging_level)
+static void bd_listener_set_battery_capacity_change_data(int charging_level)
{
ENTER;
return;
}
-static void fill_charging_status_change(int charging)
+static void bd_listener_set_charging_status_change_data(int charging)
{
ENTER;
return;
}
-static void fill_signal_strength_change(int ss)
+static void bd_listener_set_signal_strength_change_data(int ss)
{
ENTER;
return;
}
-static void fill_sleep_wakeup_change(int val)
+static void bd_listener_set_sleep_wakeup_change_data(int val)
{
ENTER;
return;
}
-static void fill_location_change(int gps)
+static void bd_listener_set_location_change_data(int gps)
{
ENTER;
return;
}
-static int fill_power_lock_unlock_change(int lock)
+static int bd_listener_set_power_lock_unlock_change_data(int lock)
{
ENTER;
return 0;
}
-static int fill_app_status_change(int val, char *app_id)
+static int bd_listener_set_app_status_change_data(int val, char *app_id)
{
ENTER;
int *temp = (int *)prv_data;
*temp = app_hsp;
_INFO(" sp index for this app id is = %d and apphsp= %d", *temp, app_hsp);
- if (fill_AppId_info(app_id)) {
+ if (bd_listener_set_appId_info(app_id)) {
error_code = 1;
goto out;
}
*temp = app_hsp;
_INFO("This App is not present in the list, inserting it");
g_hash_table_insert(app_list, app_id, temp);
- if (fill_AppId_info(app_id)) {
+ if (bd_listener_set_appId_info(app_id)) {
error_code = 1;
goto out;
}
app_hsp = *tmp;
error_code = 0;
data_obj->event_tag->sp_idx = app_hsp;
- if (fill_AppId_info(app_id))
+ if (bd_listener_set_appId_info(app_id))
error_code = 1;
goto out;
} else {
return error_code;
}
-static void fill_modem_power_state_change(int state)
+static void bd_listener_set_modem_power_state_change_data(int state)
{
ENTER;
return;
}
-static void bm_create_event_data(int type, int val, char *app)
+static void bd_listener_create_event_data(int type, int val, char *app)
{
ENTER;
if (!data_obj)
switch (type) {
case LISTEN_BT_STATE:
- fill_bt_adapter_state_changed_data(val);
+ bd_listener_set_bt_adapter_state_change_data(val);
break;
case LISTEN_BT_CONNECTION_STATE:
- fill_bt_device_connection_state_changed_data(val);
+ bd_listener_set_bt_device_connection_state_change_data(val);
break;
case LISTEN_BT_SCAN_STATE:
- fill_bt_device_discovery_state_changed_data(val);
+ bd_listener_set_bt_device_discovery_state_change_data(val);
break;
case LISTEN_WIFI_STATE:
- fill_wifi_device_state_data(val);
+ bd_listener_set_wifi_device_state_data(val);
break;
case LISTEN_WIFI_CONNECTION_STATE:
- fill_wifi_connection_state_changed_data(val);
+ bd_listener_set_wifi_connection_state_change_data(val);
break;
case LISTEN_WIFI_SCAN_STATE:
- fill_wifi_scan_changed_data(val);
+ bd_listener_set_wifi_scan_change_data(val);
break;
case LISTEN_DEVICE_DISPLAY_STATE:
- fill_device_display_change(val);
+ bd_listener_set_device_display_change_data(val);
break;
case LISTEN_BRIGHTNESS_CHANGE:
- fill_display_brightness_change(val);
+ bd_listener_set_display_brightness_change_data(val);
break;
case LISTEN_BATTERY_CAPACITY_CHANGE:
- fill_battery_capacity_change(val);
+ bd_listener_set_battery_capacity_change_data(val);
break;
case LISTEN_LOCATION_CHANGE:
- fill_location_change(val);
+ bd_listener_set_location_change_data(val);
break;
case LISTEN_CHARGING_STATUS_CHANGE:
- fill_charging_status_change(val);
+ bd_listener_set_charging_status_change_data(val);
break;
case LISTEN_SIGNAL_STRENGTH_CHANGE:
- fill_signal_strength_change(val);
+ bd_listener_set_signal_strength_change_data(val);
break;
case LISTEN_POWERLOCKUNLOCK_STATE:
- if (fill_power_lock_unlock_change(val) == BATTERY_MONITOR_ERROR_NONE)
+ if (bd_listener_set_power_lock_unlock_change_data(val) == BATTERY_MONITOR_ERROR_NONE)
break;
else
return;
case LISTEN_SLEEP_WAKEUP_STATE:
- fill_sleep_wakeup_change(val);
+ bd_listener_set_sleep_wakeup_change_data(val);
break;
case LISTEN_APP_STATUS:
- if (fill_app_status_change(val, app) == BATTERY_MONITOR_ERROR_NONE)
+ if (bd_listener_set_app_status_change_data(val, app) == BATTERY_MONITOR_ERROR_NONE)
break;
else
return;
case LISTEN_MODEM_POWER_STATE:
- fill_modem_power_state_change(val);
+ bd_listener_set_modem_power_state_change_data(val);
break;
default:
return;
_DBG("time_taken = %lf ", time_taken);
if (time_taken >= BATTERY_INFO_DELAY) {
- if (fill_battery_info() != DEVICE_ERROR_NONE)
+ if (bd_listener_set_battery_info() != DEVICE_ERROR_NONE)
_ERR("Fill Battery information failed ");
prev_event_time = tv;
return;
}
-void* event_producer(void *data)
+void* bd_listener_event_consumer()
{
ENTER;
- if (data == NULL) {
- _WARN("invalid data param");
- return NULL;
+ while (1) {
+ pthread_mutex_lock(&battery_lister_mutex);
+ while (buff_count == 0)
+ pthread_cond_wait(&fill, &battery_lister_mutex);
+
+ bd_listener_create_event_data(events_buf[use_ptr].type, events_buf[use_ptr].val, events_buf[use_ptr].app);
+
+ _INFO("type: %d and val = %d", events_buf[use_ptr].type, events_buf[use_ptr].val);
+ _INFO("buff_count: %d and fill_ptr = %d , use_ptr = %d", buff_count, fill_ptr, use_ptr);
+
+ use_ptr = (use_ptr + 1) % MAX_BUFF;
+ buff_count--;
+
+ pthread_cond_signal(&empty);
+ pthread_mutex_unlock(&battery_lister_mutex);
}
+ EXIT;
+}
+void* bd_listener_event_producer(void *data)
+{
+ ENTER;
event_pool *event = (event_pool*) data;
+ if (event == NULL)
+ return NULL;
pthread_mutex_lock(&battery_lister_mutex);
int ret_val;
pthread_t producer_id;
- ret_val = pthread_create(&producer_id, &attr, event_producer, obj);
+ ret_val = pthread_create(&producer_id, &attr, bd_listener_event_producer, obj);
if (ret_val != 0) {
_ERR("Failed to create produce thread");
return;
}
-void __bm_bt_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
+void _bd_listener_bt_adapter_state_change_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
{
ENTER;
return;
}
-void __bm_bt_device_connection_state_changed_cb(bool connected, bt_device_connection_info_s *conn_info, void *user_data)
+void _bd_listener_bt_device_connection_state_change_cb(bool connected, bt_device_connection_info_s *conn_info, void *user_data)
{
ENTER;
return;
}
-static void __bm_bt_device_discovery_state_changed_cb(int result,
- bt_adapter_device_discovery_state_e discovery_state,
- bt_adapter_device_discovery_info_s *discovery_info, void *user_data)
+static void _bd_listener_bt_device_discovery_state_change_cb(int result,
+ bt_adapter_device_discovery_state_e discovery_state,
+ bt_adapter_device_discovery_info_s *discovery_info,
+ void *user_data)
{
ENTER;
return;
}
-static void __bm_wifi_device_state_callback(wifi_manager_device_state_e state, void* user_data)
+static void _bd_listener_wifi_device_state_callback(wifi_manager_device_state_e state, void* user_data)
{
ENTER;
return;
}
-static void __bm_wifi_scan_changed_callback(wifi_manager_scan_state_e state, void* user_data)
+static void _bd_listener_wifi_scan_change_callback(wifi_manager_scan_state_e state, void* user_data)
{
ENTER;
return;
}
-static void __bm_wifi_connection_state_changed_callback(wifi_manager_connection_state_e state, wifi_manager_ap_h ap, void *user_data)
+static void _bd_listener_wifi_connection_state_change_callback(wifi_manager_connection_state_e state,
+ wifi_manager_ap_h ap, void *user_data)
{
ENTER;
return;
}
-static void __bm_device_display_change(device_callback_e type, void *value, void *user_data)
+static void _bd_listener_device_display_change(device_callback_e type, void *value, void *user_data)
{
ENTER;
-
_INFO("device state changed succeeded\n");
if (type != DEVICE_CALLBACK_DISPLAY_STATE)
return;
}
-static void __bm_display_brightness_change(keynode_t *key, void* data)
+static void _bd_listener_display_brightness_change(keynode_t *key, void* data)
{
ENTER;
_INFO("device brightness changed succeeded");
return;
}
-static void __bm_battery_capacity_change(keynode_t *key, void* data)
+static void _bd_listener_battery_capacity_change(keynode_t *key, void* data)
{
ENTER;
return;
}
-static void __bm_charging_status_change(keynode_t *key, void* data)
+static void _bd_listener_charging_status_change(keynode_t *key, void* data)
{
ENTER;
return;
}
-static void __bm_location_change(keynode_t *key, void* data)
+static void _bd_listener_location_change(keynode_t *key, void* data)
{
ENTER;
_INFO("device location changed succeeded\n");
return;
}
-static void _bm_notify_signal_strength(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
+static void _bd_listener_notify_signal_strength(TapiHandle *handle, const char *noti_id,
+ void *data, void *user_data)
{
ENTER;
return;
}
-static void _bm_notify_modem_power(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
+static void _bd_listener_notify_modem_power(TapiHandle *handle, const char *noti_id,
+ void *data, void *user_data)
{
ENTER;
return;
}
-static void create_lock_event(char *lock_type)
+static void _bd_listener_create_lock_event(char *lock_type)
{
int val;
return;
}
-static void __powerlock_signal_callback(GDBusConnection *conn,
+static void _bd_listener_powerlock_signal_cb(GDBusConnection *conn,
const gchar *sender,
const gchar *path,
const gchar *iface,
_INFO(" powerlock value changed =%s Pid=%d, timeout=%d", lock_type, pid, timeout);
- create_lock_event(lock_type);
+ _bd_listener_create_lock_event(lock_type);
EXIT;
return;
}
-static void __powerunlock_signal_callback(GDBusConnection *conn,
+static void _bd_listener_powerunlock_signal_cb(GDBusConnection *conn,
const gchar *sender,
const gchar *path,
const gchar *iface,
_INFO(" powerUnlock value changed =%s Pid=%d, timeout=%d", lock_type, pid, timeout);
- create_lock_event(lock_type);
+ _bd_listener_create_lock_event(lock_type);
EXIT;
return;
}
-static void __sleep_signal_callback(GDBusConnection *conn,
+static void _bd_listener_sleep_signal_cb(GDBusConnection *conn,
const gchar *sender,
const gchar *path,
const gchar *iface,
return;
}
-static void __wakeup_signal_callback(GDBusConnection *conn,
+static void _bd_listener_wakeup_signal_cb(GDBusConnection *conn,
const gchar *sender,
const gchar *path,
const gchar *iface,
return;
}
-static void __app_status_signal_callback(GDBusConnection *conn,
+static void _bd_listener_app_status_signal_cb(GDBusConnection *conn,
const gchar *sender,
const gchar *path,
const gchar *iface,
return;
}
-static int bm_charging_status_listeners()
+static int bd_subscribe_charging_status_listeners()
{
ENTER;
/* Charging callbacks */
- int ret = 0;
- ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS, __bm_charging_status_change, NULL);
+ int ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS, _bd_listener_charging_status_change, NULL);
if (ret != 0) {
_ERR("failed to register a cb key:%s err:%d", "VCONFKEY_SYSMAN_CHARGER_STATUS", ret);
return 1;
return 0;
}
-static int bm_battery_capacity_listeners()
+static int bd_subscribe_battery_capacity_listeners()
{
ENTER;
/* Charging callbacks */
- int ret = 0;
- ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, __bm_battery_capacity_change, NULL);
+ int ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, _bd_listener_battery_capacity_change, NULL);
if (ret != 0) {
_ERR("failed to register a cb key:%s err:%d", "VCONFKEY_SYSMAN_BATTERY_CAPACITY", ret);
return 1;
return 0;
}
-static int bm_location_listeners()
+static int bd_subscribe_location_listeners()
{
ENTER;
/* Charging callbacks */
int ret = 0;
- ret = vconf_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __bm_location_change, NULL);
+ ret = vconf_notify_key_changed(VCONFKEY_LOCATION_ENABLED, _bd_listener_location_change, NULL);
if (ret != 0) {
_ERR("failed to register a cb key:%s err:%d", "VCONFKEY_LOCATION_ENABLED", ret);
return 1;
return 0;
}
-static int bm_screen_subscribe_listeners()
+static int bd_subscribe_screen_listeners()
{
ENTER;
/* Screen callbacks */
- int ret = device_add_callback(DEVICE_CALLBACK_DISPLAY_STATE, __bm_device_display_change, NULL);
+ int ret = device_add_callback(DEVICE_CALLBACK_DISPLAY_STATE, _bd_listener_device_display_change, NULL);
if (ret != BATTERY_MONITOR_ERROR_NONE) {
_ERR("device_add_callback failed: %s", get_error_message(ret));
return 1;
return 0;
}
-static int bm_telephony_listeners()
+static int bd_subscribe_telephony_listeners()
{
ENTER;
int ret = BATTERY_MONITOR_ERROR_NONE;
/* register signal strength notification */
- ret = tel_register_noti_event(handle, TAPI_PROP_NETWORK_SIGNALSTRENGTH_LEVEL, _bm_notify_signal_strength, NULL);
+ ret = tel_register_noti_event(handle, TAPI_PROP_NETWORK_SIGNALSTRENGTH_LEVEL, _bd_listener_notify_signal_strength, NULL);
if (ret != BATTERY_MONITOR_ERROR_NONE) {
_ERR("register for signal-strength failed");
return 1;
}
/* register modem power notification */
- ret = tel_register_noti_event(handle, TAPI_PROP_MODEM_POWER, _bm_notify_modem_power, NULL);
+ ret = tel_register_noti_event(handle, TAPI_PROP_MODEM_POWER, _bd_listener_notify_modem_power, NULL);
if (ret != BATTERY_MONITOR_ERROR_NONE) {
_ERR("register for modem-power failed");
return 1;
return 0;
}
-static int bm_display_brightness_listeners()
+static int bd_subscribe_display_brightness_listeners()
{
ENTER;
/* Screen callbacks */
- int ret = 0;
- ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, __bm_display_brightness_change, NULL);
+ int ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, _bd_listener_display_brightness_change, NULL);
if (ret != 0) {
_ERR("failed to register a cb key:%s err:%d", "VCONFKEY_SETAPPL_LCD_BRIGHTNESS", ret);
return 1;
return 0;
}
-static int bm_wifi_subscribe_listeners()
+static int bd_subscribe_wifi_listeners()
{
ENTER;
/* Wifi callbacks */
int rv = wifi_manager_initialize(&wifi);
if (rv == WIFI_MANAGER_ERROR_NONE) {
- int ret = wifi_manager_set_device_state_changed_cb(wifi, __bm_wifi_device_state_callback, NULL);
+ int ret = wifi_manager_set_device_state_changed_cb(wifi, _bd_listener_wifi_device_state_callback, NULL);
if (ret == WIFI_MANAGER_ERROR_NONE)
- _INFO("wifi_manager_set_device_state_changed_cb success : [%p]\n", __bm_wifi_device_state_callback);
+ _INFO("wifi_manager_set_device_state_changed_cb success : [%p]\n", _bd_listener_wifi_device_state_callback);
else
_ERR("wifi_manager_set_device_state_changed_cb failed");
- ret = wifi_manager_set_scan_state_changed_cb(wifi, __bm_wifi_scan_changed_callback, NULL);
+ ret = wifi_manager_set_scan_state_changed_cb(wifi, _bd_listener_wifi_scan_change_callback, NULL);
if (ret == WIFI_MANAGER_ERROR_NONE)
_INFO("wifi_manager_set_scan_state_changed_cb success\n");
else
_ERR("wifi_manager_set_scan_state_changed_cb failed");
- ret = wifi_manager_set_connection_state_changed_cb(wifi, __bm_wifi_connection_state_changed_callback, NULL);
+ ret = wifi_manager_set_connection_state_changed_cb(wifi, _bd_listener_wifi_connection_state_change_callback, NULL);
if (ret == WIFI_MANAGER_ERROR_NONE)
_INFO("wifi_manager_set_connection_state_changed_cb success\n");
else
return 0;
}
-static int bm_bluetooth_subscribe_listeners()
+static int bd_subscribe_bluetooth_listeners()
{
ENTER;
int rv = bt_initialize();
if (rv == BT_ERROR_NONE) {
- int ret = bt_device_set_connection_state_changed_cb(__bm_bt_device_connection_state_changed_cb, NULL);
+ int ret = bt_device_set_connection_state_changed_cb(_bd_listener_bt_device_connection_state_change_cb, NULL);
_INFO("bt_device_set_connection_state_changed_cb ret =%d \n", ret);
- ret = bt_adapter_set_state_changed_cb(__bm_bt_adapter_state_changed_cb, NULL);
+ ret = bt_adapter_set_state_changed_cb(_bd_listener_bt_adapter_state_change_cb, NULL);
_INFO("bt_adapter_set_state_changed_cb ret =%d \n", ret);
- ret = bt_adapter_set_device_discovery_state_changed_cb(__bm_bt_device_discovery_state_changed_cb, NULL);
+ ret = bt_adapter_set_device_discovery_state_changed_cb(_bd_listener_bt_device_discovery_state_change_cb, NULL);
_INFO("bt_adapter_set_device_discovery_state_changed_cb ret =%d \n", ret);
} else {
return 0;
}
-static int bm_powerlock_unlock_subscribe_listener(void)
+static int bd_subscribe_powerlock_unlock_listener(void)
{
ENTER;
guint ret = 0;
ret = g_dbus_connection_signal_subscribe(dbus_connection, NULL, DBUS_DEVICED_IFACE,
DBUS_DEVICED_PL_MEMBER, DBUS_DEVICED_PATH, NULL,
- G_DBUS_SIGNAL_FLAGS_NONE, __powerlock_signal_callback,
+ G_DBUS_SIGNAL_FLAGS_NONE, _bd_listener_powerlock_signal_cb,
NULL, NULL);
if (ret == 0) {
ret = g_dbus_connection_signal_subscribe(dbus_connection, NULL, DBUS_DEVICED_IFACE,
DBUS_DEVICED_PU_MEMBER, DBUS_DEVICED_PATH,
- NULL, G_DBUS_SIGNAL_FLAGS_NONE, __powerunlock_signal_callback,
+ NULL, G_DBUS_SIGNAL_FLAGS_NONE, _bd_listener_powerunlock_signal_cb,
NULL, NULL);
if (ret == 0) {
return BATTERY_MONITOR_ERROR_NONE;
}
-static int bm_sleep_wakeup_subscribe_listener(void)
+static int bd_subscribe_sleep_wakeup_listener(void)
{
ENTER;
guint ret = 0;
ret = g_dbus_connection_signal_subscribe(dbus_connection, NULL, DBUS_DEVICED_IFACE,
DBUS_DEVICED_SLEEP_MEMBER, DBUS_DEVICED_PATH, NULL,
- G_DBUS_SIGNAL_FLAGS_NONE, __sleep_signal_callback, NULL, NULL);
+ G_DBUS_SIGNAL_FLAGS_NONE, _bd_listener_sleep_signal_cb, NULL, NULL);
if (ret == 0) {
_ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
ret = g_dbus_connection_signal_subscribe(dbus_connection, NULL, DBUS_DEVICED_IFACE,
DBUS_DEVICED_WAKEUP_MEMBER, DBUS_DEVICED_PATH, NULL,
- G_DBUS_SIGNAL_FLAGS_NONE, __wakeup_signal_callback, NULL, NULL);
+ G_DBUS_SIGNAL_FLAGS_NONE, _bd_listener_wakeup_signal_cb, NULL, NULL);
if (ret == 0) {
_ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
return BATTERY_MONITOR_ERROR_NONE;
}
-static int bm_app_status_listener(void)
+static int bd_subscribe_app_status_listener(void)
{
ENTER;
guint ret = 0;
ret = g_dbus_connection_signal_subscribe(dbus_connection, NULL, "org.tizen.aul.AppStatus",
"AppStatusChange", "/Org/Tizen/Aul/AppStatus", NULL,
- G_DBUS_SIGNAL_FLAGS_NONE, __app_status_signal_callback, NULL, NULL);
+ G_DBUS_SIGNAL_FLAGS_NONE, _bd_listener_app_status_signal_cb, NULL, NULL);
if (ret == 0) {
_ERR("Failed to subscrive bus signal"); //LCOV_EXCL_LINE System Error
return BATTERY_MONITOR_ERROR_NONE;
}
-void* event_consumer()
-{
- ENTER;
-
- while (1) {
- pthread_mutex_lock(&battery_lister_mutex);
- while (buff_count == 0)
- pthread_cond_wait(&fill, &battery_lister_mutex);
-
- bm_create_event_data(events_buf[use_ptr].type, events_buf[use_ptr].val, events_buf[use_ptr].app);
-
- _INFO("type: %d and val = %d", events_buf[use_ptr].type, events_buf[use_ptr].val);
- _INFO("buff_count: %d and fill_ptr = %d , use_ptr = %d", buff_count, fill_ptr, use_ptr);
-
- use_ptr = (use_ptr + 1) % MAX_BUFF;
- buff_count--;
-
- pthread_cond_signal(&empty);
- pthread_mutex_unlock(&battery_lister_mutex);
- }
- EXIT;
-}
-
-static int bm_initialize_history_data_obj()
+static int bd_initialize_data_items()
{
ENTER;
pthread_t consumer;
- if (pthread_create(&consumer, &attr, event_consumer, NULL)) {
+ if (pthread_create(&consumer, &attr, bd_listener_event_consumer, NULL)) {
_ERR("Failed to pthread_create.");
return BATTERY_MONITOR_ERROR_NOT_SUPPORTED;
}
return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
}
- if (fill_battery_info() != DEVICE_ERROR_NONE) {
+ if (bd_listener_set_battery_info() != DEVICE_ERROR_NONE) {
_ERR("Battery information failed ");
data_obj->battery_level = 0;
data_obj->battery_temperature = 0;
listener_hsp = -1;
/* Initialize Hash Table */
- if (!bm_initialize_history_data_obj())
- _INFO("bm_initialize_history_data_obj succeeded \n");
+ if (!bd_initialize_data_items())
+ _INFO("bd_initialize_data_items() success");
else {
- _ERR("bm_initialize_history_data_obj failed \n");
+ _ERR("bd_initialize_data_items() failed");
return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
}
if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
_ERR("pthread_attr_setdetachstate failed");
- /*Initialize DBus*
- if (bm_listener_dbus_init())
- _ERR("bm_listener_dbus_init failed \n"); */
-
/* Wifi callbacks */
- if (!bm_wifi_subscribe_listeners())
+ if (!bd_subscribe_wifi_listeners())
_INFO("Wifi listeners succeeded to subscribed\n");
else
_ERR("Wifi listeners failed to subscribed\n");
/* BlueTooth callbacks */
- if (!bm_bluetooth_subscribe_listeners())
+ if (!bd_subscribe_bluetooth_listeners())
_INFO("bluetooth listeners succeeded to subscribed\n");
else
_ERR("bluetooth listeners failed to subscribed\n");
/* Screen wakeup callbacks */
- if (!bm_screen_subscribe_listeners())
+ if (!bd_subscribe_screen_listeners())
_INFO("Display listeners succeeded to subscribed\n");
else
_ERR("Display listeners failed to subscribed\n");
/* Brightness change callbacks */
- if (!bm_display_brightness_listeners())
+ if (!bd_subscribe_display_brightness_listeners())
_INFO("Brightness listeners succeeded to subscribed\n");
else
_ERR("Brightness listeners failed to subscribed\n");
/* battery_capacity change callbacks */
- if (!bm_battery_capacity_listeners())
+ if (!bd_subscribe_battery_capacity_listeners())
_INFO("battery_capacity listeners succeeded to subscribed\n");
else
_ERR("battery_capacity listeners failed to subscribed\n");
/* battery charging change callbacks */
- if (!bm_charging_status_listeners())
+ if (!bd_subscribe_charging_status_listeners())
_INFO("battery charging listeners succeeded to subscribed\n");
else
_ERR("battery charging listeners failed to subscribed\n");
/* GPS change callbacks */
- if (!bm_location_listeners())
+ if (!bd_subscribe_location_listeners())
_INFO("location listeners succeeded to subscribed\n");
else
_ERR("location listeners failed to subscribed\n");
/* telephony listeners */
- if (!bm_telephony_listeners())
+ if (!bd_subscribe_telephony_listeners())
_INFO("telephony listeners succeeded to subscribed\n");
else
_ERR("telephony listeners failed to subscribed\n");
/* Powerlock callbacks */
- if (!bm_powerlock_unlock_subscribe_listener())
+ if (!bd_subscribe_powerlock_unlock_listener())
_INFO("Pwoerlock listeners succeeded to subscribed\n");
else
_ERR("Powerlock listeners failed to subscribed\n");
/* Device Sleep callbacks */
- if (!bm_sleep_wakeup_subscribe_listener())
+ if (!bd_subscribe_sleep_wakeup_listener())
_INFO("Sleep Wakeup listeners succeeded to subscribed\n");
else
_ERR("Sleep Wakeup listeners failed to subscribed\n");
/* App Status callbacks */
- if (!bm_app_status_listener())
+ if (!bd_subscribe_app_status_listener())
_INFO("FG listeners succeeded to subscribed\n");
else
_ERR("FG Wakeup listeners failed to subscribed\n");
_INFO("bt_deinitialize() success.\n");
//Brightness
- if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, __bm_display_brightness_change) < 0)
+ if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, _bd_listener_display_brightness_change) < 0)
_ERR("failed to de-register vconf callback");
//Battery capacity
- if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, __bm_battery_capacity_change) < 0)
+ if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, _bd_listener_battery_capacity_change) < 0)
_ERR("failed to de-register vconf callback");
//Battery charging
- if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS, __bm_charging_status_change) < 0)
+ if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS, _bd_listener_charging_status_change) < 0)
_ERR("failed to de-register vconf callback");
/* de-register telephony callbacks */
projects / platform / core / system / batterymonitor.git / commitdiff