static GHashTable *__cb_table = NULL;
#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
-typedef struct _event_info {
+typedef struct _request_event_info {
int req_id;
package_manager_event_type_e event_type;
package_manager_event_state_e event_state;
- struct _event_info *next;
-} event_info;
+ struct _request_event_info *next;
+} request_event_info;
+
+struct package_manager_event_info {
+ char *pkg_name;
+ package_manager_event_type_e event_type;
+};
struct package_manager_s {
int handle_id;
pkgmgr_client_type ctype;
pkgmgr_client *pc;
pkgmgr_mode mode;
- event_info *head;
+ GHashTable *event_info_table;
package_manager_event_cb event_cb;
void *user_data;
};
pkgmgr_client *pc;
char *pkg_type;
pkgmgr_mode mode;
- event_info *head;
+ request_event_info *head;
package_manager_request_event_cb event_cb;
GHashTable *request_cb_table;
void *user_data;
return manager_handle_id++;
}
+static void __clean_all_event_info(request_event_info *head)
+{
+ request_event_info *current = head;
+ request_event_info *prev;
+
+ if (current == NULL)
+ return;
+
+ while (current) {
+ prev = current;
+ current = current->next;
+ free(prev);
+ }
+}
+
+static int __insert_event_info(package_manager_h manager, const char *pkg_name,
+ package_manager_event_type_e event_type)
+{
+ struct package_manager_event_info *info;
+
+ info = calloc(1, sizeof(struct package_manager_event_info));
+ if (info == NULL)
+ return -1;
+ info->pkg_name = strdup(pkg_name);
+ info->event_type = event_type;
+ g_hash_table_insert(manager->event_info_table, info->pkg_name, info);
+
+ return 0;
+}
+
+static void __free_event_info(gpointer data)
+{
+ struct package_manager_event_info *info =
+ (struct package_manager_event_info *)data;
+
+ if (!info)
+ return;
+
+ if (info->pkg_name)
+ free(info->pkg_name);
+ free(info);
+
+ _LOGD("event_info removed");
+}
+
static void __free_request_cb_info(gpointer data)
{
int req_id;
return 0;
}
-static void __clean_all_event_info(event_info *head)
-{
- event_info *current = head;
- event_info *prev;
-
- if (current == NULL)
- return;
-
- while (current) {
- prev = current;
- current = current->next;
- free(prev);
- prev = NULL;
- }
-}
-
API int package_manager_request_create(package_manager_request_h *request)
{
struct package_manager_request_s *package_manager_request;
return PACKAGE_MANAGER_ERROR_NONE;
}
-static int __add_event_info(event_info **head, int req_id,
+static int __add_event_info(request_event_info **head, int req_id,
package_manager_event_type_e event_type,
package_manager_event_state_e event_state)
{
- event_info *evt_info;
- event_info *current;
- event_info *prev;
+ request_event_info *evt_info;
+ request_event_info *current;
+ request_event_info *prev;
- evt_info = (event_info *) calloc(1, sizeof(event_info));
+ evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
if (evt_info == NULL) {
_LOGD("calloc failed");
return -1;
return 0;
}
-static int __find_event_info(event_info **head, int req_id,
+static int __find_event_info(request_event_info **head, int req_id,
package_manager_event_type_e *event_type,
package_manager_event_state_e *event_state)
{
- event_info *tmp;
+ request_event_info *tmp;
tmp = *head;
return -1;
}
-static int __update_event_info(event_info **head, int req_id,
+static int __update_event_info(request_event_info **head, int req_id,
package_manager_event_type_e event_type,
package_manager_event_state_e event_state)
{
package_manager_event_type_e evt_type;
package_manager_event_state_e evt_state;
- event_info *tmp;
+ request_event_info *tmp;
if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
__add_event_info(head, req_id, event_type, event_state);
return -1;
}
-/*
-static int __remove_event_info(event_info **head request, int req_id)
-{
- event_info *current;
- event_info *tmp;
-
- if (* == NULL)
- return -1;
-
- current = *head;
- while (current) {
- if (current->next) {
- if (current->next->req_id == req_id) {
- tmp = current->next;
- current->next = current->next->next;
- free(tmp);
- return 0;
- }
- }
- tmp = tmp->next;
- }
-
- return -1;
-}
-*/
-
static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
const char *pkg_name, const char *key,
const char *val, const void *pmsg, void *data)
}
pkgmgr_client_free(manager->pc);
- manager->pc = NULL;
- __clean_all_event_info(manager->head);
+ g_hash_table_destroy(manager->event_info_table);
free(manager);
return PACKAGE_MANAGER_ERROR_NONE;
}
-static int __add_event(event_info **head, int req_id,
- package_manager_event_type_e event_type,
- package_manager_event_state_e event_state)
-{
- event_info *evt_info;
-
- evt_info = (event_info *) calloc(1, sizeof(event_info));
- if (evt_info == NULL) {
- _LOGD("calloc failed");
- return -1;
- }
- evt_info->req_id = req_id;
- evt_info->event_type = event_type;
- evt_info->event_state = event_state;
- evt_info->next = NULL;
-
- *head = evt_info;
-
- return 0;
-}
-
-static int __find_event(event_info **head, int req_id,
- package_manager_event_type_e *event_type,
- package_manager_event_state_e *event_state)
-{
- event_info *tmp;
-
- tmp = *head;
-
- if (tmp == NULL) {
- _LOGE("tmp is NULL");
- return -1;
- }
-
- *event_type = tmp->event_type;
- *event_state = tmp->event_state;
- return 0;
-}
-
-static int __update_event(event_info **head, int req_id,
- package_manager_event_type_e event_type,
- package_manager_event_state_e event_state)
-{
- package_manager_event_type_e evt_type;
- package_manager_event_state_e evt_state;
- event_info *tmp;
-
- if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
- __add_event_info(head, req_id, event_type, event_state);
- else {
- tmp = *head;
-
- if (tmp == NULL) {
- _LOGE("tmp is NULL");
- return -1;
- }
-
- tmp->event_type = event_type;
- tmp->event_state = event_state;
- return 0;
- }
-
- return -1;
-}
-
/* App Event Listening Policy:
* +----------------+------------+---------------+------------------+
* |Listener \ Type |Global Event|My User's Event|Other user's Event|
return -1;
}
-static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
+static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
const char *pkg_name, const char *key,
const char *val, const void *pmsg, void *data)
{
int ret = -1;
package_manager_event_type_e event_type = -1;
package_manager_event_state_e event_state = -1;
+ struct package_manager_event_info *info = NULL;
+ package_manager_h manager = data;
uid_t uid = target_uid;
- package_manager_h manager = data;
+ _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
+ req_id, pkg_name, pkg_type, key, val);
if (target_uid == GLOBAL_USER)
uid = getuid();
if (__validate_event_signal(uid))
return PACKAGE_MANAGER_ERROR_NONE;
+ if (manager && manager->event_info_table) {
+ info = g_hash_table_lookup(manager->event_info_table, pkg_name);
+ } else {
+ _LOGE("invalid handle");
+ return PACKAGE_MANAGER_ERROR_NONE;
+ }
+
+ if (!info) {
+ if (strcasecmp(key, "start") != 0) {
+ _LOGD("unexpected signal or no info(removed)");
+ return PACKAGE_MANAGER_ERROR_NONE;
+ }
+ }
+
if (strcasecmp(key, "start") == 0) {
ret = package_manager_get_event_type(val, &event_type);
if (ret != PACKAGE_MANAGER_ERROR_NONE)
return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
- __add_event(&(manager->head), req_id, event_type,
- PACKAGE_MANAGER_EVENT_STATE_STARTED);
+ if (!info) {
+ __insert_event_info(manager, pkg_name, event_type);
- if (manager->event_cb && getuid() == uid)
- manager->event_cb(pkg_type, pkg_name,
- event_type,
- PACKAGE_MANAGER_EVENT_STATE_STARTED,
- 0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
- } else if (strcasecmp(key, "install_percent") == 0
- || strcasecmp(key, "progress_percent") == 0) {
- if (__find_event
- (&(manager->head), req_id, &event_type,
- &event_state) == 0) {
- __update_event(&(manager->head), req_id,
- event_type,
- PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
if (manager->event_cb && getuid() == uid)
manager->event_cb(pkg_type, pkg_name,
- event_type,
- PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
- atoi(val),
- PACKAGE_MANAGER_ERROR_NONE,
- manager->user_data);
+ event_type,
+ PACKAGE_MANAGER_EVENT_STATE_STARTED,
+ 0,
+ PACKAGE_MANAGER_ERROR_NONE,
+ manager->user_data);
+ } else {
+ _LOGE("unexpected start event");
}
-
+ } else if (strcasecmp(key, "install_percent") == 0
+ || strcasecmp(key, "progress_percent") == 0) {
+ if (manager->event_cb && getuid() == uid)
+ manager->event_cb(pkg_type, pkg_name,
+ info->event_type,
+ PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
+ atoi(val),
+ PACKAGE_MANAGER_ERROR_NONE,
+ manager->user_data);
} else if (strcasecmp(key, "error") == 0) {
- if (strcasecmp(key, "0") != 0) {
- if (__find_event
- (&(manager->head), req_id, &event_type,
- &event_state) == 0) {
- __update_event(&(manager->head), req_id,
- event_type,
- PACKAGE_MANAGER_EVENT_STATE_FAILED);
- }
-
- if (manager->event_cb && getuid() == uid)
- manager->event_cb(pkg_type,
- pkg_name, event_type,
- PACKAGE_MANAGER_EVENT_STATE_FAILED,
- 0,
- PACKAGE_MANAGER_ERROR_NONE,
- manager->user_data);
- }
+ if (manager->event_cb && getuid() == uid)
+ manager->event_cb(pkg_type, pkg_name,
+ info->event_type,
+ PACKAGE_MANAGER_EVENT_STATE_FAILED,
+ 0,
+ PACKAGE_MANAGER_ERROR_NONE,
+ manager->user_data);
} else if (strcasecmp(key, "end") == 0) {
- if (__find_event
- (&(manager->head), req_id, &event_type,
- &event_state) == 0) {
- if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
- if (manager->event_cb && getuid() == uid)
- manager->event_cb(pkg_type,
- pkg_name, event_type,
- PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
- 100,
- PACKAGE_MANAGER_ERROR_NONE,
- manager->user_data);
- }
- } else {
- if (strcasecmp(key, "ok") != 0) {
- if (manager->event_cb && getuid() == uid)
- manager->event_cb(pkg_type,
- pkg_name, event_type,
- PACKAGE_MANAGER_EVENT_STATE_FAILED,
- 0,
- PACKAGE_MANAGER_ERROR_NONE,
- manager->user_data);
+ if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
+ if (manager->event_cb && getuid() == uid) {
+ if (strcasecmp(val, "ok") == 0) {
+ manager->event_cb(pkg_type, pkg_name,
+ info->event_type,
+ PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
+ 100,
+ PACKAGE_MANAGER_ERROR_NONE,
+ manager->user_data);
+ } else {
+ manager->event_cb(pkg_type, pkg_name,
+ info->event_type,
+ PACKAGE_MANAGER_EVENT_STATE_FAILED,
+ 0,
+ PACKAGE_MANAGER_ERROR_NONE,
+ manager->user_data);
+ }
}
}
+ g_hash_table_remove(manager->event_info_table, info->pkg_name);
}
return PACKAGE_MANAGER_ERROR_NONE;
manager->event_cb = callback;
manager->user_data = user_data;
- pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
+ retval = pkgmgr_client_listen_status(manager->pc,
+ internal_callback, manager);
+ if (retval < 0) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
+ __FUNCTION__, NULL);
+ }
+
+ if (!manager->event_info_table) {
+ manager->event_info_table =
+ g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, __free_event_info);
+ }
return PACKAGE_MANAGER_ERROR_NONE;
}
manager->event_cb = NULL;
manager->user_data = NULL;
+ g_hash_table_remove_all(manager->event_info_table);
+
retval = pkgmgr_client_remove_listen_status(manager->pc);
if (retval == PKGMGR_R_EINVAL)
return