int app_state;
} appInfo;
+typedef struct WakelockInfo {
+ int hsp_info;
+ int wake_state;
+} wakeInfo;
+
wifi_manager_h wifi = NULL;
struct timeval prev_event_time;
static event_pool events_buf[10];
static int buff_count = 0;
static int lock_ref_count = 0;
+static int lock_hsp = 0;
+static int bt_hsp = 0;
+static int bt_scan_hsp = 0;
+static int wifi_hsp = 0;
+static int wifi_scan_hsp = 0;
+static int wifi_connected_hsp = 0;
+static int display_hsp = 0;
+static int gps_hsp = 0;
+static int app_hsp = 0;
+static int wakeup_hsp = 0;
+static int modem_hsp = 0;
+static int reset_val = 0;
+
GHashTable *app_list = NULL;
+GHashTable *wakelock_list = NULL;
static GHashTable *pid_map = NULL;
+
static void bd_set_free_data_object(void)
{
BD_CHECK_VALIDITY_RETURN((data_obj != NULL), {});
data_obj->event_tag->uid = 1000;
- data_obj->event_tag->string_info = g_string_new(app_id);
+ data_obj->event_tag->string_info = g_string_sized_new(7);
- BD_CHECK_FOR_VALIDITY((data_obj->event_tag->string_info != NULL), {},
- BATTERY_MONITOR_ERROR_OUT_OF_MEMORY);
+ if (!data_obj->event_tag->string_info) {
+ _ERR("memory allocation failed ");
+ return 1;
+ }
- _DBG("set string_info - [%s]", data_obj->event_tag->string_info->str);
+ g_string_append_printf(data_obj->event_tag->string_info, "%s", app_id);
EXIT;
return 0;
else
data_obj->battery_plugtype = BD_BPLT_NONE;
- _DBG("battery_level = %d, battery_status = %d, battery_health = %d, battery_plugtype = %d",
- data_obj->battery_level, data_obj->battery_status, \
+ _DBG("battery_level = %d, battery_status = %d, battery_health = %d, \
+ battery_plugtype = %d", data_obj->battery_level, data_obj->battery_status, \
data_obj->battery_health, data_obj->battery_plugtype);
data_obj->battery_temperature = info.temperature;
{
ENTER;
- static int bt_hsp = 0;
int bt_state = -1;
if (adapter_state == BT_ADAPTER_ENABLED)
_INFO("discovery_state = %d", discovery_state);
- static int bt_scan_hsp = 0, bt_flag = 0;
-
+ static int bt_flag = 0;
if (data_obj) {
switch (discovery_state) {
case BT_ADAPTER_DEVICE_DISCOVERY_STARTED:
(state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED) ? _INFO("Activated") : _INFO("Deactivated");
- static int wifi_hsp = 0;
-
if (data_obj) {
if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED) {
data_obj->event_code = ET_NONE;
_INFO("scan state = %d", state);
- static int wifi_flag = 0, wifi_scan_hsp = 0;
+ static int wifi_flag = 0;
if (data_obj) {
if (state == WIFI_MANAGER_SCAN_STATE_SCANNING) {
_INFO("connection state = %d", state);
- static int wifi_connected_hsp = 0;
-
if (data_obj) {
switch (state) {
case WIFI_MANAGER_CONNECTION_STATE_CONNECTED:
_INFO("device display state = %d", value);
- static int display_hsp = 0;
-
switch (value) {
case DISPLAY_STATE_NORMAL:
_DBG("Display on");
_INFO("sleep wakeup change = %d", val);
- static int wakeup_hsp = 0;
-
if (val) {
data_obj->event_code = ET_NONE;
data_obj->event_tag = NULL;
_INFO("location change = %d", gps);
- static int gps_hsp = 0;
-
if (data_obj) {
if (gps) {
data_obj->event_code = ET_NONE;
_INFO("lock change - %d, app - %s", lock, app_id);
- static int lock_hsp = 0;
- static int prev_lock = -1;
-
- if (prev_lock == lock) {
- _WARN("same lock event");
- BM_FREE(app_id);
- return 1;
- }
+ int error_code = 0;
+ void *prv_data = NULL, *prv_app_id = NULL;
if (lock) {
data_obj->event_code = ET_NONE;
data_obj->event_tag = NULL;
data_obj->wakelock_tag = NULL;
+ lock_hsp = listener_hsp + 1;
+
+ /* check if exists in hash-table */
+ if (g_hash_table_lookup_extended(wakelock_list, app_id, &prv_app_id, &prv_data) == true) {
+ wakeInfo *prevInfo = (wakeInfo *)prv_data;
+
+ /*check if an app try to lock again without sending unlock event*/
+ if (prevInfo->wake_state) {
+ error_code = 1;
+ _ERR(" two consecutive lock events for same app_id");
+ goto out;
+ }
+ prevInfo->hsp_info = lock_hsp;
+ prevInfo->wake_state = lock;
+
+ _DBG(" sp index for this app id is = %d and lock_hsp= %d",
+ prevInfo->hsp_info, lock_hsp);
+ } else {
+ /* first time for app_id , insert into hash-table */
+ wakeInfo *info = (wakeInfo *)calloc(1, sizeof(wakeInfo));
+ if (info == NULL) {
+ _ERR("memory allocation failed");
+ error_code = 1;
+ lock_ref_count++;
+ goto out;
+ }
+ info->hsp_info = lock_hsp;
+ info->wake_state = lock;
+
+ _DBG("inserting in table - [%s], hsp-info = %d, wake_state= %d", app_id, info->hsp_info, info->wake_state);
+ g_hash_table_insert(wakelock_list, g_strdup(app_id), info);
+ }
+ if (reset_val) {
+ /* Check if Reset is Enabled, set EWL event */
+ data_obj->event_code |= ET_WAKE_LOCK;
+ data_obj->event_code |= ET_FLAG_START;
+ data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
+ if (data_obj->event_tag) {
+ data_obj->event_tag->sp_idx = lock_hsp;
+ if (bd_listener_set_appId_info(app_id)) {
+ error_code = 1;
+ lock_ref_count++;
+ _ERR("bd_listener_set_appId_info failure ");
+ BM_FREE(data_obj->event_tag);
+ goto out;
+ }
+ } else {
+ _ERR(" object creation failure ");
+ error_code = 1;
+ lock_ref_count++;
+ goto out;
+ }
+ } else {
+ /* If Reset is Disabled, Don't set EWL event*/
+ if (lock_ref_count > 0) {
+ error_code = 1;
+ _DBG(" Reset Disabled no need to send event ");
+ lock_ref_count++;
+ goto out;
+ }
+
+ }
data_obj->wakelock_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
if (data_obj->wakelock_tag) {
-
- lock_hsp = ++listener_hsp;
data_obj->wakelock_tag->sp_idx = lock_hsp;
data_obj->wakelock_tag->uid = 1000;
-
data_obj->wakelock_tag->string_info = g_string_new(app_id);
- BD_CHECK_FOR_VALIDITY((data_obj->wakelock_tag->string_info != NULL), {},
- BATTERY_MONITOR_ERROR_OUT_OF_MEMORY);
+ BD_CHECK_FOR_VALIDITY((data_obj->wakelock_tag->string_info != NULL), { BM_FREE(app_id); BM_FREE(data_obj->wakelock_tag); },
+ BATTERY_MONITOR_ERROR_OUT_OF_MEMORY);
_DBG("wakelock tag created, string_info - [%s]",
- data_obj->wakelock_tag->string_info->str);
-
+ data_obj->wakelock_tag->string_info->str);
} else {
- _ERR(" object creation failure ");
+ _ERR("wakelock tag object creation failure ");
BM_FREE(app_id);
+ lock_ref_count++;
return 1;
}
- data_obj->state_1 |= ST1_WAKE_LOCK_FLAG;
+
+ /* Set wake lock state*/
+ if (lock_ref_count == 0) {
+ _DBG(" ref_count = 0, set the wake lock state ");
+ data_obj->state_1 |= ST1_WAKE_LOCK_FLAG;
+ }
+
+ lock_ref_count++;
+ listener_hsp++;
+ BM_FREE(app_id);
+ return 0;
} else {
data_obj->event_code = ET_NONE;
- data_obj->wakelock_tag = NULL;
data_obj->event_tag = NULL;
- //WAKE LOCK TAG INFORMATION NOT REQ. AT UNSET.
- data_obj->state_1 &= ~(ST1_WAKE_LOCK_FLAG);
+ data_obj->wakelock_tag = NULL; //WAKE LOCK TAG INFORMATION NOT REQ. AT UNSET.
+
+ /* Unlock before a lock should be ignored*/
+ if (lock_ref_count == 0) {
+ error_code = 1;
+ goto out;
+ }
+
+ if (lock_ref_count >= 1) {
+ if (g_hash_table_lookup_extended(wakelock_list, app_id, &prv_app_id, &prv_data) == true) {
+ wakeInfo *prevInfo = (wakeInfo *)prv_data;
+
+ _DBG("app available in list - app_id[%s], prev_app_id[%s], wake_state[%d]",
+ app_id, (char *)prv_app_id, prevInfo->wake_state);
+
+ /* Check if an app try to Unlock without sending lock event*/
+ if (prevInfo->wake_state == 0) {
+ error_code = 1;
+ _ERR(" two consecutive un-lock events for same app_id");
+ goto out;
+ }
+
+ if (prevInfo->wake_state == 1 && lock == 0) {
+ prevInfo->wake_state = lock; /* update new value for wake lock state */
+
+ /* Set -Ewl event if Reset is enabled*/
+ if (reset_val) {
+ data_obj->event_code = ET_NONE;
+ data_obj->event_code |= ET_WAKE_LOCK;
+ data_obj->event_code |= ET_FLAG_FINISH;
+ data_obj->event_tag = NULL;
+
+ data_obj->event_tag = (history_tag_s *)calloc(1, sizeof(history_tag_s));
+ if (data_obj->event_tag) {
+ lock_hsp = prevInfo->hsp_info;
+ error_code = 0;
+ data_obj->event_tag->sp_idx = lock_hsp;
+ if (bd_listener_set_appId_info(app_id)) {
+ error_code = 1;
+ _ERR("set app id failure ");
+ lock_ref_count--;
+ BM_FREE(data_obj->event_tag);
+ goto out;
+ }
+ } else {
+ _ERR(" data_obj->event_tag object creation fails ");
+ error_code = 1;
+ lock_ref_count--;
+ goto out;
+ }
+ }
+ } else {
+ _DBG("event-tag not created - prev_appid[%s], prev_state[%d], val[%d]",
+ (char *)prv_app_id, prevInfo->wake_state, lock);
+ error_code = 1;
+ lock_ref_count--;
+ goto out;
+ }
+ } else {
+ _DBG("application not available in list ");
+ error_code = 1;
+ goto out;
+ }
+
+ }
+ if (lock_ref_count > 1 && reset_val == 0)
+ error_code = 1;
+
+ /* Unset wake lock state */
+ if (lock_ref_count == 1) {
+ _DBG(" unset the wake lock state ref_count ==1 ");
+ data_obj->state_1 &= ~(ST1_WAKE_LOCK_FLAG);
+ }
+ lock_ref_count--;
}
- prev_lock = lock;
- BM_FREE(app_id);
+out:
+ if (app_id)
+ g_free(app_id);
+ _DBG(" Error code =%d, lock_ref_count = %d ", error_code, lock_ref_count);
EXIT;
- return 0;
+ return error_code;
}
static int bd_listener_set_app_status_change_data(int val, char *app_id)
/* event tag is created only when app transits from foreground to either
* background or terminate state. No event tag is created when transition
* is from background state to terminate state */
- if (prevInfo->app_state == 1 && (val == 0 || val == -1))
- {
+ if (prevInfo->app_state == 1 && (val == 0 || val == -1)) {
prevInfo->app_state = val; /* update new value for app_id */
data_obj->event_code = ET_NONE;
_INFO("modem state = %d", state);
- static int modem_hsp = 0;
-
if (data_obj && state == 0) { /* ON */
data_obj->event_code = ET_NONE;
data_obj->event_code |= ET_ACTIVE;
gettimeofday(&tv, NULL);
data_obj->time_s = ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000);
- double time_taken;
- time_taken = (tv.tv_sec - prev_event_time.tv_sec) * 1000000;
- time_taken = (time_taken + (tv.tv_usec - prev_event_time.tv_usec)) * 0.000001;
+ long long time_taken = 0;
+ time_taken = ((long long)tv.tv_sec * 1000) + ((long long)tv.tv_usec / 1000);
+ time_taken = time_taken - (((long long)prev_event_time.tv_sec * 1000) + ((long long)prev_event_time.tv_usec / 1000));
- _DBG("time_taken = %lf ", time_taken);
+ _DBG("time_taken = %lld ", time_taken);
if (time_taken >= BATTERY_INFO_DELAY) {
if (bd_listener_set_battery_info() != DEVICE_ERROR_NONE)
prev_battery_level = data_obj->battery_level;
}
- if (data_obj->event_tag && type != LISTEN_APP_STATUS) {
+ if (data_obj->event_tag && type != LISTEN_APP_STATUS && type != LISTEN_POWERLOCKUNLOCK_STATE) {
data_obj->event_tag->uid = 1000;
data_obj->event_tag->string_info = g_string_new("Tizen");
data_obj->event_tag->string_info->str, data_obj->event_tag->sp_idx);
}
- if (type == LISTEN_POWERLOCKUNLOCK_STATE)
- data_obj->event_tag = NULL;
- else
+ if (type == LISTEN_POWERLOCKUNLOCK_STATE) {
+ if (reset_val)
+ _DBG(" Powerlockunlock in Reset Enabled state");
+ else
+ data_obj->event_tag = NULL;
+ } else
data_obj->wakelock_tag = NULL;
if (type != LISTEN_SLEEP_WAKEUP_STATE)
g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
BD_CHECK_VALIDITY_RETURN((pid > 0), {});
- _DBG("lock[%s], pid[%d], timeout[%d], ref_count[%d]", lock_type, pid, timeout, lock_ref_count);
-
- if (lock_ref_count == 0) {
+ _DBG("lock[%s], pid[%d], timeout[%d]", lock_type, pid, timeout);
+ bm_get_symlink_for_pid(pid, &pname);
- bm_get_symlink_for_pid(pid, &pname);
+ _DBG("creating wake-lock event, pid[%d], process[%s]", pid, pname);
- _DBG("creating wake-lock event, pid[%d], process[%s]", pid, pname);
-
- /* get event object */
- event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, 1, pname);
- if (event == NULL) {
- _ERR("Failed to get event pool object");
- BM_FREE(pname);
- return;
- }
-
- /* create thread */
- bd_create_producer_thread(event, "lock_event");
-
- ++lock_ref_count;
-
- } else {
- _DBG("lock acquired, ref_count[%d]", ++lock_ref_count);
+ /* get event object */
+ event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, 1, pname);
+ if (event == NULL) {
+ _ERR("Failed to get event pool object");
+ BM_FREE(pname);
+ return;
}
+ /* create thread */
+ bd_create_producer_thread(event, "lock_event");
+
EXIT;
return;
}
g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
BD_CHECK_VALIDITY_RETURN((pid > 0), {});
- _DBG("un-lock[%s], pid[%d], timeout[%d], ref_count[%d]", lock_type, pid, timeout, lock_ref_count);
+ _DBG("un-lock[%s], pid[%d], timeout[%d]", lock_type, pid, timeout);
+ bm_get_symlink_for_pid(pid, &pname);
+
+ _DBG("creating wake-unlock event, pid[%d], process[%s]", pid, pname);
- if (lock_ref_count == 0) {
- _ERR("improper wakelock, no event created");
+ /* get event object */
+ event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, 0, pname);
+ if (event == NULL) {
+ _ERR("Failed to get event pool object");
+ BM_FREE(pname);
return;
- } else if (lock_ref_count > 0) {
- --lock_ref_count;
- _DBG("received unlock event, count[%d]", lock_ref_count);
}
- if (lock_ref_count == 0) {
-
- bm_get_symlink_for_pid(pid, &pname);
-
- _DBG("creating wake-unlock event, pid[%d], process[%s]", pid, pname);
-
- /* get event object */
- event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, 0, pname);
- if (event == NULL) {
- _ERR("Failed to get event pool object");
- BM_FREE(pname);
- return;
- }
-
- /* create thread */
- bd_create_producer_thread(event, "lock_event");
- } else {
- _DBG("still holding lock, ref_count[%d]", lock_ref_count);
- }
+ /* create thread */
+ bd_create_producer_thread(event, "lock_event");
EXIT;
return;
return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
}
+ /* wakeup-list hash table */
+ wakelock_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+ if (wakelock_list == NULL) {
+ _ERR("failed to create wakelock-list table");
+ return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+ }
/* pid-app_id map */
pid_map = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
if (pid_map == NULL) {
_DBG("History Recorder Started");
listener_hsp = -1;
- /* Reinitialize the hsp variables
+ // Reinitialize the hsp variables
bt_hsp = 0; bt_scan_hsp = 0;
wifi_hsp = 0; wifi_scan_hsp = 0; wifi_connected_hsp = 0;
display_hsp = 0; gps_hsp = 0; lock_hsp = 0; app_hsp = 0;
wakeup_hsp = 0; modem_hsp = 0; lock_ref_count = 0;
- */
app_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
-// wakelock_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+ wakelock_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
EXIT;
return 0;
if (app_list)
g_hash_table_destroy(app_list);
- /*
+
if (wakelock_list)
- g_hash_table_destroy(wakelock_list);*/
+ g_hash_table_destroy(wakelock_list);
EXIT;
return BATTERY_MONITOR_ERROR_NONE;
}
if (to_enable)
_DBG("is enabled");
-// reset_val = to_enable;
+ reset_val = to_enable;
EXIT;
return ret;
_ERR("pthread_attr_init failed");
return BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
}
-
- if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
+ if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
_ERR("pthread_attr_setdetachstate failed");
/* Wifi callbacks */
app_list = NULL;
}
+ if (wakelock_list) {
+ g_hash_table_destroy(wakelock_list);
+ wakelock_list = NULL;
+ }
+
if (pid_map) {
g_hash_table_destroy(pid_map);
pid_map = NULL;
}
}
+void bm_get_symlink_for_pid(pid_t pid, char **pname)
+{
+ _INFO("pid = [%d]", pid);
+
+ char *app_id = NULL;
+
+ app_manager_get_app_id(pid, &app_id);
+
+ if (app_id == NULL) { /*it might be a daemon, ex-/usr/bin/batterymonitor-svcd*/
+ char path[PATH_BUFFER_SIZE], buf[BUFFERSIZE];
+ int path_len = 0, lst = 0;
+ ssize_t len = -1;
+ struct stat st_buf;
+ char err_buf[128] = {0,};
+
+ /* prepare pid-exe path */
+ path_len = snprintf(path, PATH_BUFFER_SIZE, "/proc/%d/exe", pid);
+ if (path_len < 1 || path_len >= PATH_BUFFER_SIZE) {
+ _ERR("insufficient buffer size");
+ return;
+ }
+
+ _DBG("exe path - [%s]", path);
+
+ /* check availability */
+ lst = lstat(path, &st_buf);
+ if (lst != 0 || !S_ISLNK(st_buf.st_mode)) {
+ _ERR("sym-link un-available");
+ return;
+ }
+
+ /* read symbolic link */
+ len = readlink(path, buf, sizeof(buf)-1);
+ if (len != -1) {
+ buf[len] = '\0';
+ } else {
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ _ERR("read bytes - [%zd], error [%s]", len, err_buf);
+ return;
+ }
+
+ _DBG("read sym-link - [%s]", buf);
+
+ app_id = strdup(buf);
+ }
+
+ *pname = app_id;
+
+ _INFO("pid - [%d], name - [%s]", pid, *pname);
+
+ return;
+}
+
int bm_set_dbus_connection_obj(GDBusConnection* conn)
{
BM_CHECK_INPUT_PARAM(conn);
}
return_val = app_context_get_app_id(app_context, &app_id);
- if(return_val != APP_MANAGER_ERROR_NONE) {
+ if (return_val != APP_MANAGER_ERROR_NONE) {
_ERR("failed to get app_id");
app_context_destroy(app_context);
return;
return;
}
-void bm_get_symlink_for_pid(pid_t pid, char **pname)
+void bm_get_name_for_pid(pid_t pid, char **pname)
{
_INFO("pid = [%d]", pid);
app_manager_get_app_id(pid, &app_id);
if (app_id == NULL) { /*it might be a daemon, ex-/usr/bin/batterymonitor-svcd*/
- char path[PATH_BUFFER_SIZE], buf[BUFFERSIZE];
- int path_len = 0, lst = 0;
- ssize_t len = -1;
- struct stat st_buf;
+ char buf[PATH_MAX];
+ int fd, r;
- /* prepare pid-exe path */
- path_len = snprintf(path, PATH_BUFFER_SIZE, "/proc/%d/exe", pid);
- if (path_len < 1 || path_len >= PATH_BUFFER_SIZE) {
- _ERR("insufficient buffer size");
+ snprintf(buf, PATH_MAX, "/proc/%d/cmdline", pid);
+
+ if (access(buf, F_OK) != 0) {
+ _ERR("maybe pid no more exists");
return;
}
- _DBG("exe path - [%s]", path);
-
- /* check availability */
- lst = lstat(path, &st_buf);
- if (lst != 0 || !S_ISLNK(st_buf.st_mode)) {
- _ERR("sym-link un-available");
+ fd = open(buf, O_RDONLY);
+ if (fd < 0) {
+ _ERR("process(%d) does not exist now.", pid);
return;
}
- /* read symbolic link */
- len = readlink(path, buf, sizeof(buf)-1);
- if (len != -1) {
- buf[len] = '\0';
+ r = read(fd, buf, PATH_MAX);
+ if ((r >= 0) && (r < PATH_MAX)) {
+ buf[r] = '\0';
} else {
- _ERR("read bytes -[%d], error [%s]", (int)len, strerror(errno));
+ _ERR("read error");
+ if (close(fd) == -1)
+ _ERR("fd close error");
return;
}
- _DBG("read sym-link - [%s]", buf);
-
+ if (close(fd) == -1)
+ _ERR("fd close error");
app_id = strdup(buf);
}
projects / platform / core / system / batterymonitor.git / commitdiff