return cb_info;
}
-static struct cb_info *__create_res_copy_event_cb_info(
+static struct cb_info *__create_res_event_cb_info(
struct pkgmgr_client_t *client,
- pkgmgr_res_copy_handler res_copy_event_cb,
+ pkgmgr_res_handler res_event_cb,
void *data, const char *req_key)
{
struct cb_info *cb_info;
}
cb_info->client = client;
- cb_info->res_copy_event_cb = res_copy_event_cb;
+ cb_info->res_event_cb = res_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_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)
g_variant_builder_unref(client->res_copy_builder);
if (client->res_remove_builder)
g_variant_builder_unref(client->res_remove_builder);
+ if (client->res_create_dir_builder)
+ g_variant_builder_unref(client->res_create_dir_builder);
free(client);
return PKGMGR_R_OK;
_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;
return cb_info->req_id;
}
-API int pkgmgr_client_listen_res_copy_status(pkgmgr_client *pc,
- pkgmgr_res_copy_handler event_cb, void *data)
+API int pkgmgr_client_listen_res_status(pkgmgr_client *pc,
+ pkgmgr_res_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_res_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_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;
return PKGMGR_R_EINVAL;
}
- cb_info = __create_res_copy_event_cb_info(client, event_cb, data, NULL);
+ 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;
}
API int pkgmgr_client_res_copy(pkgmgr_client *pc,
- pkgmgr_res_copy_handler event_cb, void *user_data)
+ pkgmgr_res_handler event_cb, void *user_data)
{
GVariant *result;
int ret;
return ret;
}
- cb_info = __create_res_copy_event_cb_info(client,
+ cb_info = __create_res_event_cb_info(client,
event_cb, user_data, req_key);
g_variant_unref(result);
if (cb_info == NULL)
return cb_info->req_id;
}
-API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
- const char *res_path)
+API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc,
+ const char *dir_path)
{
struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
- if (pc == NULL || res_path == NULL) {
+ if (pc == NULL || dir_path == NULL) {
ERR("invalid parameter");
return PKGMGR_R_EINVAL;
}
- if (client->res_remove_builder == NULL) {
- client->res_remove_builder =
+ if (client->res_create_dir_builder == NULL) {
+ client->res_create_dir_builder =
g_variant_builder_new(G_VARIANT_TYPE("as"));
- if (client->res_remove_builder == NULL) {
+ if (client->res_create_dir_builder == NULL) {
ERR("out of memory");
return PKGMGR_R_ENOMEM;
}
}
- g_variant_builder_add(client->res_remove_builder, "s", res_path);
+ g_variant_builder_add(client->res_create_dir_builder, "s", dir_path);
return PKGMGR_R_OK;
}
-API int pkgmgr_client_res_remove(pkgmgr_client *pc,
- pkgmgr_res_copy_handler event_cb, void *user_data)
+API int pkgmgr_client_res_create_dir(pkgmgr_client *pc,
+ pkgmgr_res_handler event_cb, void *user_data)
{
GVariant *result;
int ret;
}
ret = pkgmgr_client_connection_send_request(client,
- "res_remove",
+ "res_create_dir",
g_variant_new("(as)",
- client->res_remove_builder), &result);
+ client->res_create_dir_builder), &result);
if (ret != PKGMGR_R_OK) {
ERR("request failed: %d", ret);
return ret;
return ret;
}
- cb_info = __create_res_copy_event_cb_info(client,
+ cb_info = __create_res_event_cb_info(client,
event_cb, user_data, req_key);
g_variant_unref(result);
if (cb_info == NULL)
return cb_info->req_id;
}
-API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid,
- pkgmgr_res_copy_handler event_cb, void *user_data)
+API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
+ const char *res_path)
{
- return pkgmgr_client_res_usr_uninstall(pc, pkgid, event_cb,
- user_data, _getuid());
+ struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
+
+ if (pc == NULL || res_path == NULL) {
+ ERR("invalid parameter");
+ return PKGMGR_R_EINVAL;
+ }
+
+ if (client->res_remove_builder == NULL) {
+ client->res_remove_builder =
+ g_variant_builder_new(G_VARIANT_TYPE("as"));
+ if (client->res_remove_builder == NULL) {
+ ERR("out of memory");
+ return PKGMGR_R_ENOMEM;
+ }
+ }
+
+ g_variant_builder_add(client->res_remove_builder, "s", res_path);
+
+ return PKGMGR_R_OK;
}
-API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
- pkgmgr_res_copy_handler event_cb, void *user_data, uid_t uid)
+API int pkgmgr_client_res_remove(pkgmgr_client *pc,
+ pkgmgr_res_handler event_cb, void *user_data)
{
GVariant *result;
- int ret = PKGMGR_R_ECOMM;
+ int ret;
char *req_key = NULL;
struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
struct cb_info *cb_info;
- if (pc == NULL || pkgid == NULL || event_cb == NULL) {
+ if (pc == NULL || event_cb == NULL) {
ERR("invalid parameter");
return PKGMGR_R_EINVAL;
}
ret = pkgmgr_client_connection_send_request(client,
- "res_uninstall",
- g_variant_new("(us)", uid, pkgid), &result);
+ "res_remove",
+ g_variant_new("(as)",
+ client->res_remove_builder), &result);
if (ret != PKGMGR_R_OK) {
ERR("request failed: %d", ret);
return ret;
return ret;
}
- cb_info = __create_res_copy_event_cb_info(client,
+ cb_info = __create_res_event_cb_info(client,
event_cb, user_data, req_key);
g_variant_unref(result);
if (cb_info == NULL)
return cb_info->req_id;
}
+API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid)
+{
+ return pkgmgr_client_res_usr_uninstall(pc, pkgid, _getuid());
+}
+
+API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
+ uid_t uid)
+{
+ GVariant *result;
+ int ret = PKGMGR_R_ECOMM;
+ struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
+
+ if (pc == NULL || pkgid == NULL) {
+ ERR("invalid parameter");
+ return PKGMGR_R_EINVAL;
+ }
+
+ ret = pkgmgr_client_connection_send_request(client,
+ "res_uninstall",
+ g_variant_new("(us)", uid, pkgid), &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 pkgmgr_res_event_info *pkgmgr_res_event_info_new()
{
pkgmgr_res_event_info_t *info;
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 =
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;
*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;
+}
projects / platform / core / appfw / slp-pkgmgr.git / blobdiff