Unlock mutex before calling event callback

The internal callback function calls g_mutex_unlock() before calling
event callback function.

Change-Id: I837437f276fd0ddb745795a9ab56bc0584531df0
Signed-off-by: Hwankyu Jhun <h.jhun@samsung.com>

diff --git a/src/package_manager.c b/src/package_manager.c
index 214ecda..80782bc 100644 (file)
--- a/src/package_manager.c
+++ b/src/package_manager.c
@@ -1026,8 +1026,6 @@ API int package_manager_destroy(package_manager_h manager)
                     NULL);
        }
 
-       g_mutex_trylock(&manager->mutex);
-       g_mutex_unlock(&manager->mutex);
        g_mutex_clear(&manager->mutex);
        pkgmgr_client_free(manager->pc);
        g_hash_table_destroy(manager->event_info_table);
@@ -1065,11 +1063,15 @@ 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;
        struct package_manager_event_info *info = NULL;
+       int ret = -1;
        package_manager_h manager = data;
        uid_t uid = target_uid;
+       bool invoke_callback = false;
+       package_manager_event_type_e event_type = -1;
+       package_manager_event_state_e event_state;
+       int progress = 0;
+       package_manager_error_e error = PACKAGE_MANAGER_ERROR_NONE;
 
        _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
                        req_id, pkg_name, pkg_type, key, val);
@@ -1107,60 +1109,55 @@ static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
                        __insert_event_info(manager, pkg_name, event_type,
                                        PACKAGE_MANAGER_EVENT_STATE_STARTED);
 
-                       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);
+                       event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
+                       progress = 0;
+                       error = PACKAGE_MANAGER_ERROR_NONE;
+                       invoke_callback = true;
                } else {
                        _LOGE("unexpected start event");
                }
        } else if (strcasecmp(key, "install_percent") == 0
                   || strcasecmp(key, "progress_percent") == 0) {
                info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
-               if (manager->event_cb && getuid() == uid)
-                       manager->event_cb(pkg_type, pkg_name,
-                                       info->event_type,
-                                       info->event_state,
-                                       atoi(val),
-                                       PACKAGE_MANAGER_ERROR_NONE,
-                                       manager->user_data);
+               event_type = info->event_type;
+               event_state = info->event_state;
+               progress = atoi(val);
+               error = PACKAGE_MANAGER_ERROR_NONE;
+               invoke_callback = true;
        } else if (strcasecmp(key, "error") == 0) {
                info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
-               if (manager->event_cb && getuid() == uid)
-                       manager->event_cb(pkg_type, pkg_name,
-                                       info->event_type,
-                                       info->event_state,
-                                       0,
-                                       __convert_to_error(val),
-                                       manager->user_data);
+               event_type = info->event_state;
+               event_state = info->event_state;
+               progress = 0;
+               error = __convert_to_error(val);
+               invoke_callback = true;
        } else if (strcasecmp(key, "end") == 0) {
                if (info->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_SYSTEM_ERROR,
-                                               manager->user_data);
-                               }
+                       if (strcasecmp(val, "ok") == 0) {
+                               event_type = info->event_type;
+                               event_state =
+                                       PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
+                               progress = 100;
+                               error = PACKAGE_MANAGER_ERROR_NONE;
+                               invoke_callback = true;
+                       } else {
+                               event_type = info->event_type;
+                               event_state =
+                                       PACKAGE_MANAGER_EVENT_STATE_FAILED;
+                               progress = 0;
+                               error = PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
+                               invoke_callback = true;
                        }
                }
                g_hash_table_remove(manager->event_info_table, info->pkg_name);
        }
-
        g_mutex_unlock(&manager->mutex);
 
+       if (invoke_callback && manager->event_cb && getuid() == uid) {
+               manager->event_cb(pkg_type, pkg_name, event_type, event_state,
+                               progress, error, manager->user_data);
+       }
+
        return PACKAGE_MANAGER_ERROR_NONE;
 }