[Non-ACR] refactoring battery-dump listeners

Change-Id: I8b8c2eea067b1837e11676ccfcfadba5ca6b16a7

1 files changed, 187 insertions, 230 deletions

diff --git a/src/battery_dump/bm_listeners.c b/src/battery_dump/bm_listeners.c
index 2f246ba..1147d7a 100644
--- a/src/battery_dump/bm_listeners.c
+++ b/src/battery_dump/bm_listeners.c
@@ -1026,63 +1026,105 @@ static void bm_create_event_data(int type, int val, char *app)
 void* event_producer(void *data)
 {
 	ENTER;
-	event_pool *event = (event_pool*) data;
-	if (event == NULL)
+
+	if (data == NULL) {
+		_WARN("invalid data param");
 		return NULL;
+	}
+
+	event_pool *event = (event_pool*) data;
 
 	pthread_mutex_lock(&battery_lister_mutex);
+
+	//this should be removed, conditional wait is costly
 	while (buff_count == MAX_BUFF)
 		pthread_cond_wait(&empty, &battery_lister_mutex);
 
 	events_buf[fill_ptr].type = event->type;
 	events_buf[fill_ptr].val = event->val;
 	events_buf[fill_ptr].app = event->app;
+
 	_INFO("type: %d and val = %d", events_buf[fill_ptr].type , events_buf[fill_ptr].val);
+
 	fill_ptr = (fill_ptr + 1) % MAX_BUFF;
+
 	buff_count++;
 
 	pthread_cond_signal(&fill);
 	pthread_mutex_unlock(&battery_lister_mutex);
 
 	BM_FREE(event);
+
 	EXIT;
 	pthread_exit(NULL);
 }
 
+event_pool* bd_listener_get_event_obj(int type, int state, char* app_id)
+{
+	event_pool *event_obj = (event_pool *)calloc(1, sizeof(event_pool));
+	if (event_obj == NULL) {
+		_ERR("Failed to create event object");
+		BM_FREE(app_id);
+		return NULL;
+	}
+
+	event_obj->type = type;
+	event_obj->val = state;
+	event_obj->app = app_id;
+
+	return event_obj;
+}
+
+void bd_create_producer_thread(event_pool *obj, const char* event_name)
+{
+	int ret_val;
+	pthread_t producer_id;
+
+	ret_val = pthread_create(&producer_id, &attr, event_producer, obj);
+
+	if (ret_val != 0) {
+		_ERR("Failed to create produce thread");
+
+		if (g_strcmp0(event_name, "app_status") == 0)
+			BM_FREE(obj->app);
+		BM_FREE(obj);
+	}
+
+	_DBG("success to create thread for - [%s]", event_name);
+
+	return;
+}
+
 void __bm_bt_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
 {
 	ENTER;
-	_INFO("__bt_adapter_state_changed_cb");
-	_INFO("result: %d", result);
+
+	_INFO("__bt_adapter_state_changed_cb - result[%d]", result);
+
 	_INFO("state: %s", (adapter_state == BT_ADAPTER_ENABLED) ? "ENABLED" : "DISABLED");
+
 	int bt_state ;
-	if (adapter_state == BT_ADAPTER_ENABLED)
-		bt_state = 1;
-	else
-		bt_state = 0;
+
+	(adapter_state == BT_ADAPTER_ENABLED) ? (bt_state = 1) : (bt_state = 0);
 
 	if (bt_adaptor == bt_state)
 		return;
 	else
 		bt_adaptor = bt_state;
+
 	_INFO("__bm_bt_adapter_state_changed_cb  bt_state = %d ", bt_state);
+
 	_INFO("buff_count: %d and fill_ptr = %d", buff_count , fill_ptr);
 
-	event_pool *bt_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!bt_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_BT_STATE, bt_state, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	bt_event->type = LISTEN_BT_STATE;
-	bt_event->val = bt_state;
-	bt_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, bt_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(bt_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "bt_adapter_event");
 
 	EXIT;
 	return;
@@ -1095,35 +1137,33 @@ void __bm_bt_device_connection_state_changed_cb(bool connected, bt_device_connec
 	_INFO("__bt_device_connection_state_changed_cb [%d]", connected);
 	_INFO("address [%s]", conn_info->remote_address);
 	_INFO("link type [%d]", conn_info->link);
+
 	if (!connected)
 		_INFO("disconnection reason [%d]", conn_info->disconn_reason);
 
-	event_pool *bt_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!bt_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_BT_CONNECTION_STATE, connected, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	bt_event->type = LISTEN_BT_CONNECTION_STATE;
-	bt_event->val = connected;
-	bt_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, bt_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(bt_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "bt_connection_event");
 
 	EXIT;
 	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 __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)
 {
 	ENTER;
+
 	_INFO("__bt_adapter_state_changed_cb");
 	_INFO("result: %d  , discovery_state = %d", result, discovery_state);
+
 	if (discovery_state > 1) {
 		_INFO(" This state will be handled later");
 		return;
@@ -1135,22 +1175,17 @@ static void __bm_bt_device_discovery_state_changed_cb(int result, bt_adapter_dev
 	} else {
 		bt_discovery_state = discovery_state;
 	}
-	event_pool *bt_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!bt_event) {
-		_ERR("Failed to allocated memory ");
-		return;
-	}
-	bt_event->type = LISTEN_BT_SCAN_STATE;
-	bt_event->val = discovery_state;
-	bt_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, bt_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(bt_event);
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_BT_SCAN_STATE, (int)discovery_state, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
 
+	/* create thread */
+	bd_create_producer_thread(event, "bt_discovery_event");
+
 	EXIT;
 	return;
 }
@@ -1166,21 +1201,15 @@ static void __bm_wifi_device_state_callback(wifi_manager_device_state_e state, v
 	else
 		_INFO(", state : Deactivated\n");
 
-	event_pool *wifi_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!wifi_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_WIFI_STATE, state, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	wifi_event->type = LISTEN_WIFI_STATE;
-	wifi_event->val = state;
-	wifi_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, wifi_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(wifi_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "wifi_device_state");
 
 	EXIT;
 	return;
@@ -1190,23 +1219,17 @@ static void __bm_wifi_scan_changed_callback(wifi_manager_scan_state_e state, voi
 {
 	ENTER;
 
-	_INFO("Wifi Scan changed, scan state : %d\n", state);
+	_INFO("Wifi Scan changed, scan state : [%d]", state);
 
-	event_pool *wifi_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!wifi_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_WIFI_SCAN_STATE, state, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	wifi_event->type = LISTEN_WIFI_SCAN_STATE;
-	wifi_event->val = state;
-	wifi_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, wifi_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(wifi_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "wifi_scan_change");
 
 	EXIT;
 	return;
@@ -1216,27 +1239,22 @@ static void __bm_wifi_connection_state_changed_callback(wifi_manager_connection_
 {
 	ENTER;
 
-	_INFO("Wifi Connection changed, new connection state : %d\n", state);
+	_INFO("Wifi Connection changed, new connection state : [%d]", state);
+
 	if (state == -1 || state == 1 || state == 2) {
 		_WARN("These connection states are not related ");
 		return;
 	}
 
-	event_pool *wifi_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!wifi_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_WIFI_CONNECTION_STATE, state, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	wifi_event->type = LISTEN_WIFI_CONNECTION_STATE;
-	wifi_event->val = state;
-	wifi_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, wifi_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(wifi_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "wifi_connection_state");
 
 	EXIT;
 	return;
@@ -1245,6 +1263,7 @@ static void __bm_wifi_connection_state_changed_callback(wifi_manager_connection_
 static void __bm_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)
@@ -1257,21 +1276,15 @@ static void __bm_device_display_change(device_callback_e type, void *value, void
 	else
 		display_flag = state;
 
-	event_pool *device_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!device_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_DEVICE_DISPLAY_STATE, state, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	device_event->type = LISTEN_DEVICE_DISPLAY_STATE;
-	device_event->val = state;
-	device_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, device_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(device_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "display_change");
 
 	EXIT;
 	return;
@@ -1280,11 +1293,12 @@ static void __bm_device_display_change(device_callback_e type, void *value, void
 static void __bm_display_brightness_change(keynode_t *key, void* data)
 {
 	ENTER;
-	_INFO("device brightness changed succeeded\n");
-	int brightness_level = 0;
+	_INFO("device brightness changed succeeded");
+
+	int flag, brightness_level = 0;
+
 	vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness_level);
 
-	int flag;
 	if (brightness_level >= 0 && brightness_level <= 10) {
 		flag = 0;
 		if (brightness_flag == flag)
@@ -1319,21 +1333,15 @@ static void __bm_display_brightness_change(keynode_t *key, void* data)
 
 	_INFO(" device brightness changed =%d ", brightness_level);
 
-	event_pool *display_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!display_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_BRIGHTNESS_CHANGE, brightness_flag, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	display_event->type = LISTEN_BRIGHTNESS_CHANGE;
-	display_event->val = brightness_flag;
-	display_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, display_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(display_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "brightness_change");
 
 	EXIT;
 	return;
@@ -1342,27 +1350,24 @@ static void __bm_display_brightness_change(keynode_t *key, void* data)
 static void __bm_battery_capacity_change(keynode_t *key, void* data)
 {
 	ENTER;
+
 	_INFO("device battery_capacity changed succeeded\n");
+
 	int charging = 0;
+
 	vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &charging);
 
 	_INFO(" device battery_capacity changed =%d ", charging);
 
-	event_pool *charging_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!charging_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_BATTERY_CAPACITY_CHANGE, charging, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	charging_event->type = LISTEN_BATTERY_CAPACITY_CHANGE;
-	charging_event->val = charging;
-	charging_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, charging_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(charging_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "battery_capacity_change");
 
 	EXIT;
 	return;
@@ -1371,27 +1376,24 @@ static void __bm_battery_capacity_change(keynode_t *key, void* data)
 static void __bm_charging_status_change(keynode_t *key, void* data)
 {
 	ENTER;
+
 	_INFO("device charging_status changed succeeded\n");
+
 	int charging = 0;
+
 	vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &charging);
 
 	_INFO(" device charging_status changed = %d ", charging);
 
-	event_pool *charging_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!charging_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_CHARGING_STATUS_CHANGE, charging, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	charging_event->type = LISTEN_CHARGING_STATUS_CHANGE;
-	charging_event->val = charging;
-	charging_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, charging_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(charging_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "charging_status_change");
 
 	EXIT;
 	return;
@@ -1411,21 +1413,15 @@ static void __bm_location_change(keynode_t *key, void* data)
 	else
 		location_flag = location;
 
-	event_pool *location_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!location_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_LOCATION_CHANGE, location, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
-	location_event->type = LISTEN_LOCATION_CHANGE;
-	location_event->val = location;
-	location_event->app = NULL;
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, location_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(location_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "location_change");
 
 	EXIT;
 	return;
@@ -1444,25 +1440,19 @@ static void _bm_notify_signal_strength(TapiHandle *handle, const char *noti_id,
 
 	_INFO(" device signal strength changed = %d ", sig_strength_level);
 
-	if (ss_flag == sig_strength_level)
-		return;
-	else
+	if (ss_flag != sig_strength_level) {
+
 		ss_flag = sig_strength_level;
 
-	event_pool *signal_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!signal_event) {
-		_ERR("Failed to allocated memory ");
-		return;
-	}
-	signal_event->type = LISTEN_SIGNAL_STRENGTH_CHANGE;
-	signal_event->val = ss_flag;
-	signal_event->app = NULL;
+		/* get event object */
+		event_pool *event = bd_listener_get_event_obj(LISTEN_SIGNAL_STRENGTH_CHANGE, ss_flag, NULL);
+		if (event == NULL) {
+			_ERR("Failed to get event pool object");
+			return;
+		}
 
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, signal_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(signal_event);
-		return;
+		/* create thread */
+		bd_create_producer_thread(event, "signal_strength");
 	}
 
 	EXIT;
@@ -1504,21 +1494,16 @@ static void _bm_notify_modem_power(TapiHandle *handle, const char *noti_id, void
 	}
 
 	if (state != -1) {
-		event_pool *modem_power_event = (event_pool *)calloc(1, sizeof(event_pool));
-		if (!modem_power_event) {
-			_ERR("Failed to allocated memory ");
-			return;
-		}
-		modem_power_event->type = LISTEN_MODEM_POWER_STATE;
-		modem_power_event->val = state;
-		modem_power_event->app = NULL;
-
-		pthread_t producer;
-		if (pthread_create(&producer, &attr, event_producer, modem_power_event)) {
-			_ERR("Failed to pthread_create.");
-			BM_FREE(modem_power_event);
+
+		/* get event object */
+		event_pool *event = bd_listener_get_event_obj(LISTEN_MODEM_POWER_STATE, state, NULL);
+		if (event == NULL) {
+			_ERR("Failed to get event pool object");
 			return;
 		}
+
+		/* create thread */
+		bd_create_producer_thread(event, "modem_power");
 	}
 
 	EXIT;
@@ -1543,22 +1528,15 @@ static void create_lock_event(char *lock_type)
 	else
 		prev_lock = val;
 
-	event_pool *lock_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!lock_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, val, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
 
-	lock_event->type = LISTEN_POWERLOCKUNLOCK_STATE;
-	lock_event->val = val;
-	lock_event->app = NULL;
-
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, lock_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(lock_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "lock_event");
 
 	EXIT;
 	return;
@@ -1619,22 +1597,15 @@ static void __sleep_signal_callback(GDBusConnection *conn,
 {
 	ENTER;
 
-	event_pool *sleep_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!sleep_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_SLEEP_WAKEUP_STATE, 0, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
 
-	sleep_event->type = LISTEN_SLEEP_WAKEUP_STATE;
-	sleep_event->val = 0;
-	sleep_event->app = NULL;
-
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, sleep_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(sleep_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "sleep_signal");
 
 	EXIT;
 	return;
@@ -1650,22 +1621,15 @@ static void __wakeup_signal_callback(GDBusConnection *conn,
 {
 	ENTER;
 
-	event_pool *wakeup_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!wakeup_event) {
-		_ERR("Failed to allocated memory ");
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_SLEEP_WAKEUP_STATE, 1, NULL);
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
 		return;
 	}
 
-	wakeup_event->type = LISTEN_SLEEP_WAKEUP_STATE;
-	wakeup_event->val = 1;
-	wakeup_event->app = NULL;
-
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, wakeup_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(wakeup_event);
-		return;
-	}
+	/* create thread */
+	bd_create_producer_thread(event, "wakeup_signal");
 
 	EXIT;
 	return;
@@ -1697,12 +1661,6 @@ static void __app_status_signal_callback(GDBusConnection *conn,
 		return;
 	}
 
-	event_pool *app_event = (event_pool *)calloc(1, sizeof(event_pool));
-	if (!app_event) {
-		_ERR("Failed to allocated memory ");
-		return;
-	}
-
 	_DBG("pid:%d, appid:%s, status:%s", pid, appid, status);
 
 	if (g_strcmp0(status, "fg") == 0)
@@ -1710,17 +1668,16 @@ static void __app_status_signal_callback(GDBusConnection *conn,
 	else
 		val = 0;
 
-	app_event->type = LISTEN_APP_STATUS;
-	app_event->val = val;
-	app_event->app = g_strdup(appid);
-
-	pthread_t producer;
-	if (pthread_create(&producer, &attr, event_producer, app_event)) {
-		_ERR("Failed to pthread_create.");
-		BM_FREE(app_event->app);
-		BM_FREE(app_event);
+	/* get event object */
+	event_pool *event = bd_listener_get_event_obj(LISTEN_APP_STATUS, val, g_strdup(appid));
+	if (event == NULL) {
+		_ERR("Failed to get event pool object");
+		return;
 	}
 
+	/* create thread */
+	bd_create_producer_thread(event, "app_status");
+
 	EXIT;
 	return;
 }