#include <package-manager.h>
#include <pkgmgr_installer.h>
+#include <pkgmgr_installer_error.h>
#include <pkgmgr-info.h>
#include <tzplatform_config.h>
#include "package_manager.h"
#include "package_manager_internal.h"
-static GHashTable *__cb_table = NULL;
-
#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
typedef struct _request_event_info {
int req_id;
GHashTable *event_info_table;
package_manager_event_cb event_cb;
void *user_data;
+ GMutex mutex;
};
struct package_manager_request_s {
request_event_info *head;
package_manager_request_event_cb event_cb;
GHashTable *request_cb_table;
+ int n_paths;
void *user_data;
};
return PACKAGE_MANAGER_ERROR_NONE;
}
+static package_manager_error_e __convert_to_error(const char *val)
+{
+ int errcode = atoi(val);
+
+ switch (errcode) {
+ case PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_ICON_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE:
+ case PKGMGR_INSTALLER_ERRCODE_ERROR:
+ return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
+ case PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID:
+ case PKGMGR_INSTALLER_ERRCODE_CERT_ERROR:
+ case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH:
+ case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND:
+ case PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND:
+ case PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND:
+ return PACKAGE_MANAGER_ERROR_IO_ERROR;
+ case PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND:
+ return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
+ case PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED:
+ return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
+ case PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE:
+ return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
+ case PKGMGR_INSTALLER_ERRCODE_OK:
+ return PACKAGE_MANAGER_ERROR_NONE;
+ default:
+ return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
+ }
+}
+
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)
pkg_name, event_type,
PACKAGE_MANAGER_EVENT_STATE_FAILED,
0,
- PACKAGE_MANAGER_ERROR_NONE,
+ __convert_to_error(val),
request->user_data);
} else if (strcasecmp(key, "end") == 0) {
pkg_name, event_type,
PACKAGE_MANAGER_EVENT_STATE_FAILED,
0,
- PACKAGE_MANAGER_ERROR_NONE,
+ PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
request->user_data);
}
}
pkg_name, event_type,
PACKAGE_MANAGER_EVENT_STATE_FAILED,
0,
- PACKAGE_MANAGER_ERROR_NONE,
+ __convert_to_error(val),
user_data);
}
} else if (strcasecmp(key, "end") == 0) {
if (__find_event_info(&request->head, req_id, &event_type,
&event_state) == 0) {
if (request->request_cb_table) {
- _LOGD("remove item, req_id(%d)", req_id);
- g_hash_table_remove(request->request_cb_table,
- GINT_TO_POINTER(req_id));
+ request->n_paths--;
+ if (request->n_paths < 1) {
+ _LOGD("remove item, req_id(%d)", req_id);
+ g_hash_table_remove(
+ request->request_cb_table,
+ GINT_TO_POINTER(req_id));
+ }
}
if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
if (strcasecmp(val, "ok") == 0) {
pkg_name, event_type,
PACKAGE_MANAGER_EVENT_STATE_FAILED,
0,
- PACKAGE_MANAGER_ERROR_NONE,
+ PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
user_data);
}
}
return PACKAGE_MANAGER_ERROR_NONE;
}
+static int __request_install_packages(package_manager_request_h request,
+ const char **paths, int n_paths, pkgmgr_handler event_cb,
+ int *id)
+{
+ int retval;
+ retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
+ if (retval != PACKAGE_MANAGER_ERROR_NONE)
+ return retval;
+
+ if (package_manager_client_validate_handle(request))
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
+ __FUNCTION__, NULL);
+
+ if (paths == NULL || n_paths < 1)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
+ __FUNCTION__, NULL);
+ request->n_paths = n_paths;
+ int request_id = 0;
+ request_id = pkgmgr_client_install_packages(request->pc, paths,
+ n_paths, event_cb ? event_cb : request_event_handler,
+ request);
+
+ if (request_id == PKGMGR_R_EINVAL)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_ENOPKG)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_ENOMEM)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_EIO)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_IO_ERROR,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_EPRIV)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_ESYSTEM ||
+ request_id == PKGMGR_R_ECOMM ||
+ request_id == PKGMGR_R_ERROR)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
+ __FUNCTION__, NULL);
+
+ if (id)
+ *id = request_id;
+
+ return PACKAGE_MANAGER_ERROR_NONE;
+}
+
static int __request_uninstall(package_manager_request_h request,
const char *name, pkgmgr_handler event_cb, int *id)
{
return PACKAGE_MANAGER_ERROR_NONE;
}
+static int __request_mount_install_packages(package_manager_request_h request,
+ const char **paths, int n_paths, pkgmgr_handler event_cb,
+ int *id)
+{
+ int retval;
+ retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
+ if (retval != PACKAGE_MANAGER_ERROR_NONE)
+ return retval;
+
+ if (package_manager_client_validate_handle(request))
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
+ __FUNCTION__, NULL);
+
+ if (paths == NULL || n_paths < 1)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
+ __FUNCTION__, NULL);
+ request->n_paths = n_paths;
+ int request_id = 0;
+ request_id = pkgmgr_client_mount_install_packages(request->pc, paths,
+ n_paths, event_cb ? event_cb : request_event_handler,
+ request);
+
+ if (request_id == PKGMGR_R_EINVAL)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_ENOPKG)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_ENOMEM)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_EIO)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_IO_ERROR,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_EPRIV)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
+ __FUNCTION__, NULL);
+ else if (request_id == PKGMGR_R_ESYSTEM ||
+ request_id == PKGMGR_R_ECOMM ||
+ request_id == PKGMGR_R_ERROR)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
+ __FUNCTION__, NULL);
+
+ if (id)
+ *id = request_id;
+
+ return PACKAGE_MANAGER_ERROR_NONE;
+}
API int package_manager_request_install(package_manager_request_h request,
const char *path, int *id)
return ret;
}
+API int package_manager_request_install_packages(
+ package_manager_request_h request, const char **paths,
+ int paths_count, int *id)
+{
+ return __request_install_packages(request, paths, paths_count, NULL, id);
+}
+
+API int package_manager_request_install_packages_with_cb(
+ package_manager_request_h request, const char **paths,
+ int paths_count, package_manager_request_event_cb callback,
+ void *user_data, int *id)
+{
+ int ret;
+ int req_id = 0;
+
+ if (request->request_cb_table == NULL)
+ __initialize_request_cb_table(request);
+
+ ret = __request_install_packages(request, paths, paths_count,
+ internal_request_callback, &req_id);
+
+ if (req_id > 0) {
+ ret = __insert_request_cb_info(request, req_id, callback,
+ user_data);
+ if (ret < 0)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
+ __FUNCTION__,
+ "failed to create request cb info");
+ if (id)
+ *id = req_id;
+ }
+
+ return ret;
+}
+
API int package_manager_request_uninstall(package_manager_request_h request,
const char *name, int *id)
{
return ret;
}
+API int package_manager_request_mount_install_packages(
+ package_manager_request_h request, const char **paths,
+ int paths_count, int *id)
+{
+ return __request_mount_install_packages(request, paths, paths_count, NULL,
+ id);
+}
+
+API int package_manager_request_mount_install_packages_with_cb(
+ package_manager_request_h request, const char **paths,
+ int paths_count, package_manager_request_event_cb callback,
+ void *user_data, int *id)
+{
+ int ret;
+ int req_id = 0;
+
+ if (request->request_cb_table == NULL)
+ __initialize_request_cb_table(request);
+
+ ret = __request_mount_install_packages(request, paths, paths_count,
+ internal_request_callback, &req_id);
+
+ if (req_id > 0) {
+ ret = __insert_request_cb_info(request, req_id, callback,
+ user_data);
+ if (ret < 0)
+ return package_manager_error(
+ PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
+ __FUNCTION__,
+ "failed to create request cb info");
+ if (id)
+ *id = req_id;
+ }
+
+ return ret;
+}
+
API int package_manager_create(package_manager_h *manager)
{
int retval;
}
package_manager->handle_id = package_manager_new_id();
+ g_mutex_init(&package_manager->mutex);
*manager = package_manager;
NULL);
}
+ g_mutex_clear(&manager->mutex);
pkgmgr_client_free(manager->pc);
g_hash_table_destroy(manager->event_info_table);
free(manager);
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);
return PACKAGE_MANAGER_ERROR_NONE;
if (manager && manager->event_info_table) {
+ g_mutex_lock(&manager->mutex);
info = g_hash_table_lookup(manager->event_info_table, pkg_name);
} else {
_LOGE("invalid handle");
if (!info) {
if (strcasecmp(key, "start") != 0) {
_LOGD("unexpected signal or no info(removed)");
+ g_mutex_unlock(&manager->mutex);
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)
+ if (ret != PACKAGE_MANAGER_ERROR_NONE) {
+ g_mutex_unlock(&manager->mutex);
return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
+ }
if (!info) {
__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,
- PACKAGE_MANAGER_ERROR_NONE,
- manager->user_data);
+ event_type = info->event_type;
+ 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_NONE,
- 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;
}
package_manager_event_cb callback,
void *user_data)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
manager->event_cb = callback;
manager->user_data = user_data;
+ retval = pkgmgr_client_remove_listen_status(manager->pc);
+ if (retval < 0) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
+ __FUNCTION__, NULL);
+ }
+
retval = pkgmgr_client_listen_status(manager->pc,
internal_callback, manager);
if (retval < 0) {
manager->event_cb = NULL;
manager->user_data = NULL;
+ g_mutex_lock(&manager->mutex);
g_hash_table_remove_all(manager->event_info_table);
+ g_mutex_unlock(&manager->mutex);
retval = pkgmgr_client_remove_listen_status(manager->pc);
if (retval == PKGMGR_R_EINVAL)
API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
void *user_data)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
API int package_manager_clear_cache_dir(const char *package_id)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
API int package_manager_clear_all_cache_dir(void)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
}
-static void __free_client(gpointer data)
-{
- pkgmgr_client *pc = (pkgmgr_client *)data;
- pkgmgr_client_free(pc);
-}
+struct getsize_cbdata {
+ pkgmgr_client *pc;
+ void *cb;
+ void *user_data;
+};
-static void __initialize_cb_table(void)
+static void __free_getsize_cbdata(struct getsize_cbdata *cbdata)
{
- __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
+ pkgmgr_client_free(cbdata->pc);
+ free(cbdata);
}
static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
{
- package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
+ struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
+ package_manager_size_info_receive_cb callback = cbdata->cb;
if (callback == NULL) {
_LOGE("callback is null.");
- g_hash_table_remove(__cb_table, pc);
+ __free_getsize_cbdata(cbdata);
return;
}
size_info.external_cache_size = result->ext_cache_size;
size_info.external_app_size = result->ext_app_size;
- callback(pkgid, (package_size_info_h)&size_info, user_data);
+ callback(pkgid, (package_size_info_h)&size_info, cbdata->user_data);
- g_hash_table_remove(__cb_table, pc);
+ __free_getsize_cbdata(cbdata);
}
static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
{
- package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
+ struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
+ package_manager_total_size_info_receive_cb callback = cbdata->cb;
if (callback == NULL) {
_LOGE("callback is null.");
- g_hash_table_remove(__cb_table, pc);
+ __free_getsize_cbdata(cbdata);
return;
}
size_info.external_cache_size = result->ext_cache_size;
size_info.external_app_size = result->ext_app_size;
- callback((package_size_info_h)&size_info, user_data);
+ callback((package_size_info_h)&size_info, cbdata->user_data);
- g_hash_table_remove(__cb_table, pc);
+ __free_getsize_cbdata(cbdata);
}
static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
{
+ struct getsize_cbdata *cbdata;
+
if (package_id == NULL || callback == NULL)
return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
- if (__cb_table == NULL)
- __initialize_cb_table();
+ cbdata = malloc(sizeof(struct getsize_cbdata));
+ if (cbdata == NULL)
+ return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
- if (pc == NULL)
+ if (pc == NULL) {
+ free(cbdata);
return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+ }
+
+ cbdata->pc = pc;
+ cbdata->cb = callback;
+ cbdata->user_data = user_data;
int res = 0;
if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
- res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
+ res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, cbdata);
else
- res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
-
- if (res == PKGMGR_R_EINVAL) {
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
- } else if (res == PKGMGR_R_ENOPKG) {
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
- } else if (res == PKGMGR_R_ENOMEM) {
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
- } else if (res == PKGMGR_R_EIO) {
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
- } else if (res == PKGMGR_R_EPRIV) {
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
- } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
- } else if (res != PKGMGR_R_OK) {
- _LOGE("Unexpected error");
- pkgmgr_client_free(pc);
- return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+ res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, cbdata);
+
+ if (res != PKGMGR_R_OK) {
+ __free_getsize_cbdata(cbdata);
+ if (res == PKGMGR_R_EINVAL) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
+ } else if (res == PKGMGR_R_ENOPKG) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
+ } else if (res == PKGMGR_R_ENOMEM) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
+ } else if (res == PKGMGR_R_EIO) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
+ } else if (res == PKGMGR_R_EPRIV) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
+ } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
+ return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+ } else {
+ _LOGE("Unexpected error");
+ return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+ }
}
- g_hash_table_insert(__cb_table, pc, callback);
-
return PACKAGE_MANAGER_ERROR_NONE;
}
API int package_manager_filter_count(package_manager_filter_h handle, int *count)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
package_manager_package_info_cb callback, void *user_data)
{
-
int retval;
retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
if (retval != PACKAGE_MANAGER_ERROR_NONE)
projects / platform / core / api / package-manager.git / blobdiff