Release version 0.15.0

[platform/core/appfw/slp-pkgmgr.git] / client / src / pkgmgr.c

diff --git a/client/src/pkgmgr.c b/client/src/pkgmgr.c
index ae55972..3887f55 100644 (file)
--- a/client/src/pkgmgr.c
+++ b/client/src/pkgmgr.c
@@ -172,6 +172,36 @@ static struct cb_info *__create_res_event_cb_info(
        return cb_info;
 }
 
+static struct cb_info *__create_upgrade_event_cb_info(
+               struct pkgmgr_client_t *client,
+               pkgmgr_pkg_upgrade_handler upgrade_event_cb,
+               void *data, const char *req_key)
+{
+       struct cb_info *cb_info;
+
+       cb_info = calloc(1, sizeof(struct cb_info));
+       if (cb_info == NULL) {
+               ERR("out of memory");
+               return NULL;
+       }
+
+       cb_info->client = client;
+       cb_info->upgrade_event_cb = upgrade_event_cb;
+       cb_info->data = data;
+       cb_info->req_id = _get_internal_request_id();
+       if (req_key == NULL)
+               return cb_info;
+
+       cb_info->req_key = strdup(req_key);
+       if (cb_info->req_key == NULL) {
+               ERR("out of memory");
+               free(cb_info);
+               return NULL;
+       }
+
+       return cb_info;
+}
+
 static struct cb_info *__create_size_info_cb_info(
                struct pkgmgr_client_t *client,
                pkgmgr_pkg_size_info_receive_cb size_info_cb,
@@ -1809,6 +1839,44 @@ API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
                        _getuid());
 }
 
+API int pkgmgr_client_usr_clear_user_data_with_path(pkgmgr_client *pc,
+               const char *pkg_type, const char *pkgid, const char *file_path,
+               pkgmgr_mode mode, uid_t uid)
+{
+       GVariant *result;
+       int ret;
+       struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
+
+       if (!pc || !pkgid || !file_path || uid == GLOBAL_USER) {
+               ERR("invalid parameter");
+               return PKGMGR_R_EINVAL;
+       }
+
+       if (client->pc_type != PC_REQUEST) {
+               ERR("client->pc_type is not PC_REQUEST");
+               return PKGMGR_R_EINVAL;
+       }
+
+       ret = pkgmgr_client_connection_send_request(client, "cleardata_with_path",
+                       g_variant_new("(uss)", uid, pkgid, file_path), &result);
+       if (ret != PKGMGR_R_OK) {
+               ERR("request failed: %d", ret);
+               return ret;
+       }
+
+       g_variant_get(result, "(i)", &ret);
+       g_variant_unref(result);
+
+       return ret;
+}
+
+API int pkgmgr_client_clear_user_data_with_path(pkgmgr_client *pc, const char *pkg_type,
+               const char *pkgid, const char *file_path, pkgmgr_mode mode)
+{
+       return pkgmgr_client_usr_clear_user_data_with_path(pc, pkg_type, pkgid,
+                       file_path, mode, _getuid());
+}
+
 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
 {
        struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
@@ -1916,6 +1984,37 @@ API int pkgmgr_client_listen_res_status(pkgmgr_client *pc,
        return cb_info->req_id;
 }
 
+API int pkgmgr_client_listen_pkg_upgrade_status(pkgmgr_client *pc,
+               pkgmgr_pkg_upgrade_handler event_cb, void *data)
+{
+       int ret;
+       struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
+       struct cb_info *cb_info;
+
+       if (pc == NULL || event_cb == NULL) {
+               ERR("invalid parameter");
+               return PKGMGR_R_EINVAL;
+       }
+
+       if (client->pc_type != PC_LISTENING) {
+               ERR("client->pc_type is not PC_LISTENING");
+               return PKGMGR_R_EINVAL;
+       }
+
+       cb_info = __create_upgrade_event_cb_info(client, event_cb, data, NULL);
+       if (cb_info == NULL)
+               return PKGMGR_R_ENOMEM;
+       cb_info->status_type = client->status_type;
+       ret = pkgmgr_client_connection_set_callback(client, cb_info);
+       if (ret != PKGMGR_R_OK) {
+               __free_cb_info(cb_info);
+               return ret;
+       }
+       client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
+
+       return cb_info->req_id;
+}
+
 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
 {
        struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
@@ -3059,6 +3158,17 @@ API pkgmgr_res_event_info *pkgmgr_res_event_info_new()
        return (pkgmgr_res_event_info *)info;
 }
 
+static void __free_path_states(gpointer data)
+{
+       res_event_path_state_t *path_state = (res_event_path_state_t *)data;
+
+       if (path_state == NULL)
+               return;
+       if (path_state->path)
+               free(path_state->path);
+       free(path_state);
+}
+
 API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info)
 {
        pkgmgr_res_event_info_t *event_info =
@@ -3069,6 +3179,8 @@ API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info)
                return PKGMGR_R_EINVAL;
        }
 
+       if (event_info->path_states)
+               g_list_free_full(event_info->path_states, __free_path_states);
        free(event_info);
 
        return PKGMGR_R_OK;
@@ -3097,3 +3209,54 @@ API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int
        *error_code = info->error_code;
        return PKGMGR_R_OK;
 }
+
+API int pkgmgr_res_event_info_add_path_state(pkgmgr_res_event_info *handle,
+               const char *path, pkgmgr_res_event_path_state state)
+{
+       pkgmgr_res_event_info_t *info = handle;
+       res_event_path_state_t *path_state;
+
+       if (info == NULL || path == NULL) {
+               ERR("invalid parameter");
+               return PKGMGR_R_EINVAL;
+       }
+
+       path_state = calloc(1, sizeof(res_event_path_state_t));
+       if (path_state == NULL) {
+               ERR("out of memory");
+               return PKGMGR_R_ENOMEM;
+       }
+
+       path_state->path = strdup(path);
+       if (path_state->path == NULL) {
+               ERR("out of memory");
+               free(path_state);
+               return PKGMGR_R_ENOMEM;
+       }
+       path_state->state = state;
+
+       info->path_states = g_list_prepend(info->path_states , path_state);
+       return PKGMGR_R_OK;
+}
+
+API int pkgmgr_res_event_info_foreach_path(pkgmgr_res_event_info *handle,
+               pkgmgr_res_event_path_cb callback, void *user_data)
+{
+       pkgmgr_res_event_info_t *info = handle;
+       GList *list;
+       res_event_path_state_t *path_state;
+
+       if (info == NULL) {
+               ERR("invalid parameter");
+               return PKGMGR_R_EINVAL;
+       }
+
+       for (list = info->path_states; list != NULL; list = list->next) {
+               path_state = (res_event_path_state_t *)list->data;
+               if (callback(path_state->path, path_state->state,
+                               user_data) < 0)
+                       return PKGMGR_R_OK;
+       }
+
+       return PKGMGR_R_OK;
+}