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;
_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;
} 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;
}
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;
{
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;
{
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;
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)
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;
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)
_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;
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;
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;
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;
_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;
}
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;
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;
{
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;
{
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;
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)
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;
}
projects / platform / core / system / batterymonitor.git / commitdiff