#define PKGMGR_INFO_STR_DATA_SIZE "data_size"
#define PKGMGR_INFO_STR_APP_SIZE "app_size"
#define PKGMGR_INFO_STR_INSTALLED_TIME "installed_time"
+
+/**
+ * @brief listening status type in pkgmgr.
+ */
+#define PKGMGR_CLIENT_STATUS_ALL 0x00
+#define PKGMGR_CLIENT_STATUS_INSTALL 0x01
+#define PKGMGR_CLIENT_STATUS_UNINSTALL 0x02
+#define PKGMGR_CLIENT_STATUS_UPGRADE 0x04
+#define PKGMGR_CLIENT_STATUS_MOVE 0x08
+#define PKGMGR_CLIENT_STATUS_CLEAR_DATA 0x10
+#define PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS 0x20
/** @} */
/* 1 -100 : Package command errors */
typedef enum {
PM_GET_TOTAL_SIZE= 0,
PM_GET_DATA_SIZE = 1,
+ PM_GET_ALL_PKGS = 2,
+ PM_GET_MAX
}pkgmgr_getsize_type;
/**
const char *appid, pkgmgr_mode mode);
/**
+ * @brief This API set status type to listen for the pkgmgr's broadcasting
+ *
+ * This API is for package-manager client application.\n
+ *
+ * @param[in] pc pkgmgr_client
+ * @param[in] status_type status type to listen
+ * @return request_id (>0) if success, error code(<0) if fail\n
+ * @retval PKGMGR_R_OK success
+ * @retval PKGMGR_R_EINVAL invalid argument
+*/
+int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type);
+
+/**
* @brief This API request to listen the pkgmgr's broadcasting
*
* This API is for package-manager client application.\n
} \
} while (0)
+#define trym_if(expr, fmt, arg...) do { \
+ if (expr) { \
+ PKGMGR_DEBUG_ERR("(%s) "fmt, #expr, ##arg); \
+ goto catch; \
+ } \
+ } while (0)
+
#define tryvm_if(expr, val, fmt, arg...) do { \
if (expr) { \
PKGMGR_DEBUG_ERR("(%s) "fmt, #expr, ##arg); \
typedef struct _pkgmgr_client_t {
client_type ctype;
+ int status_type;
union {
struct _request {
comm_client *cc;
static int __get_size_process(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
{
char *req_key = NULL;
- int req_id = 0;
int ret =0;
- pkgmgrinfo_pkginfo_h handle;
- char *pkgtype = NULL;
- char *installer_path = NULL;
+ char *pkgtype = "rpm";
char *argv[PKG_ARGC_MAX] = { NULL, };
char *args = NULL;
int argcnt = 0;
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
- ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
- retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_pkginfo failed");
-
- ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
- tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_type failed");
-
- installer_path = _get_backend_path_with_type(pkgtype);
req_key = __get_req_key(pkgid);
- req_id = _get_request_id();
snprintf(buf, 128, "%d", get_type);
- argv[argcnt++] = installer_path;
- /* argv[1] */
- argv[argcnt++] = strdup("-k");
- /* argv[2] */
- argv[argcnt++] = req_key;
- /* argv[3] */
- argv[argcnt++] = strdup("-d");
- /* argv[4] */
argv[argcnt++] = strdup(pkgid);
- /* argv[5] */
- argv[argcnt++] = strdup("-t");
- /* argv[6] */
argv[argcnt++] = strdup(buf);
/*** add quote in all string for special charactor like '\n'*** FIX */
if (cookie)
free(cookie);
- pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
return ret;
}
pkgmgr_client_t *pc = NULL;
int ret = -1;
- if (ctype != PC_REQUEST && ctype != PC_LISTENING
- && ctype != PC_BROADCAST)
- return NULL;
+ retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING && ctype != PC_BROADCAST, NULL, "ctype is not client_type");
/* Allocate memory for ADT:pkgmgr_client */
pc = calloc(1, sizeof(pkgmgr_client_t));
- if (pc == NULL) {
- _LOGE("No memory");
- return NULL;
- }
+ retvm_if(pc == NULL, NULL, "No memory");
/* Manage pc */
pc->ctype = ctype;
+ pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
if (pc->ctype == PC_REQUEST) {
pc->info.request.cc = comm_client_new();
- if (pc->info.request.cc == NULL) {
- _LOGE("client creation failed");
- goto err;
- }
- ret = comm_client_set_status_callback(pc->info.request.cc,
- __operation_callback, pc);
- if (ret < 0) {
- _LOGE("comm_client_set_status_callback() failed - %d",
- ret);
- goto err;
- }
+ trym_if(pc->info.request.cc == NULL, "client creation failed");
+
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
+ trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
} else if (pc->ctype == PC_LISTENING) {
pc->info.listening.cc = comm_client_new();
- if (pc->info.listening.cc == NULL) {
- _LOGE("client creation failed");
- goto err;
- }
- ret = comm_client_set_status_callback(pc->info.listening.cc,
- __status_callback, pc);
- if (ret < 0) {
- _LOGE("comm_client_set_status_callback() failed - %d",
- ret);
- goto err;
- }
+ trym_if(pc->info.listening.cc == NULL, "client creation failed");
+
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
+ trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
} else if (pc->ctype == PC_BROADCAST) {
- pc->info.broadcast.bc = comm_status_broadcast_server_connect();
- if (pc->info.broadcast.bc == NULL) {
- _LOGE("client creation failed");
- goto err;
- }
- ret = 0;
+ pc->info.broadcast.bc = comm_status_broadcast_server_connect(COMM_STATUS_BROADCAST_ALL);
+ trym_if(pc->info.broadcast.bc == NULL, "client creation failed");
}
return (pkgmgr_client *) pc;
- err:
+ catch:
if (pc)
free(pc);
return NULL;
{
int ret = -1;
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
-
- if (mpc == NULL) {
- _LOGE("Invalid argument");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
if (mpc->ctype == PC_REQUEST) {
req_cb_info *tmp;
}
ret = comm_client_free(mpc->info.request.cc);
- if (ret < 0) {
- _LOGE("comm_client_free() failed - %d", ret);
- goto err;
- }
+ tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
} else if (mpc->ctype == PC_LISTENING) {
- listen_cb_info *tmp;
- listen_cb_info *prev;
- for (tmp = mpc->info.listening.lhead; tmp;) {
- prev = tmp;
- tmp = tmp->next;
- free(prev);
- }
+ listen_cb_info *tmp;
+ listen_cb_info *prev;
+ for (tmp = mpc->info.listening.lhead; tmp;) {
+ prev = tmp;
+ tmp = tmp->next;
+ free(prev);
+ }
- ret = comm_client_free(mpc->info.listening.cc);
- if (ret < 0) {
- _LOGE("comm_client_free() failed - %d", ret);
- goto err;
- }
+ ret = comm_client_free(mpc->info.listening.cc);
+ tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
} else if (mpc->ctype == PC_BROADCAST) {
comm_status_broadcast_server_disconnect(mpc->info.broadcast.bc);
ret = 0;
mpc = NULL;
return PKGMGR_R_OK;
- err:
+ catch:
if (mpc) {
free(mpc);
mpc = NULL;
char *cookie = NULL;
int ret;
/* Check for NULL value of pc */
- if (pc == NULL) {
- _LOGD("package manager client handle is NULL\n");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
+
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
/* 0. check the pc type */
- if (mpc->ctype != PC_REQUEST)
- return PKGMGR_R_EINVAL;
+ retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
/* 1. check argument */
- if (pkgid == NULL)
- return PKGMGR_R_EINVAL;
+ retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
+ retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
if (pkg_type == NULL) {
pkgtype = _get_pkg_type_from_desktop_file(pkgid);
- if (pkgtype == NULL)
- return PKGMGR_R_EINVAL;
+ retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
} else
pkgtype = pkg_type;
- if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
- return PKGMGR_R_EINVAL;
-
/* 2. generate req_key */
req_key = __get_req_key(pkgid);
+ retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
/* 3. request activate */
- ret = comm_client_request(mpc->info.request.cc, req_key,
- COMM_REQ_TO_ACTIVATOR, pkgtype,
- pkgid, "1 PKG", cookie, 1);
- if (ret < 0) {
- _LOGE("request failed, ret=%d\n", ret);
- free(req_key);
- return PKGMGR_R_ECOMM;
- }
+ ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, pkgid, "1 PKG", cookie, 1);
+ tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
- free(req_key);
+ ret = PKGMGR_R_OK;
- return PKGMGR_R_OK;
+catch:
+ free(req_key);
+ return ret;
}
API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
char *cookie = NULL;
int ret;
/* Check for NULL value of pc */
- if (pc == NULL) {
- _LOGD("package manager client handle is NULL\n");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
+
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
/* 0. check the pc type */
- if (mpc->ctype != PC_REQUEST)
- return PKGMGR_R_EINVAL;
+ retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
/* 1. check argument */
- if (pkgid == NULL)
- return PKGMGR_R_EINVAL;
+ retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
+ retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
if (pkg_type == NULL) {
pkgtype = _get_pkg_type_from_desktop_file(pkgid);
} else
pkgtype = pkg_type;
- if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
- return PKGMGR_R_EINVAL;
-
/* 2. generate req_key */
req_key = __get_req_key(pkgid);
+ retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
/* 3. request activate */
- ret = comm_client_request(mpc->info.request.cc, req_key,
- COMM_REQ_TO_ACTIVATOR, pkgtype,
- pkgid, "0 PKG", cookie, 1);
- if (ret < 0) {
- _LOGE("request failed, ret=%d\n", ret);
- free(req_key);
- return PKGMGR_R_ECOMM;
- }
+ ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, pkgid, "0 PKG", cookie, 1);
+ tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
- free(req_key);
+ ret = PKGMGR_R_OK;
- return PKGMGR_R_OK;
+catch:
+ free(req_key);
+ return ret;
}
API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
char *cookie = NULL;
int ret;
/* Check for NULL value of pc */
- if (pc == NULL) {
- _LOGD("package manager client handle is NULL\n");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
+
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
/* 0. check the pc type */
- if (mpc->ctype != PC_REQUEST)
- return PKGMGR_R_EINVAL;
+ retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
/* 1. check argument */
- if (appid == NULL)
- return PKGMGR_R_EINVAL;
-
- if (strlen(appid) >= PKG_STRING_LEN_MAX)
- return PKGMGR_R_EINVAL;
+ retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
+ retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
pkgtype = _get_pkg_type_from_desktop_file(appid);
+ retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
/* 2. generate req_key */
req_key = __get_req_key(appid);
+ retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
/* 3. request activate */
- ret = comm_client_request(mpc->info.request.cc, req_key,
- COMM_REQ_TO_ACTIVATOR, pkgtype,
- appid, "1 APP", cookie, 1);
- if (ret < 0) {
- _LOGE("request failed, ret=%d\n", ret);
- free(req_key);
- return PKGMGR_R_ECOMM;
- }
+ ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, "1 APP", cookie, 1);
+ tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
- free(req_key);
+ ret = PKGMGR_R_OK;
- return PKGMGR_R_OK;
+catch:
+ free(req_key);
+ return ret;
}
API int pkgmgr_client_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[])
char *args = NULL;
char *argsr = NULL;
/* Check for NULL value of pc */
- if (pc == NULL) {
- _LOGD("package manager client handle is NULL\n");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
+
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
/* 0. check the pc type */
- if (mpc->ctype != PC_REQUEST)
- return PKGMGR_R_EINVAL;
+ retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
/* 1. check argument */
- if (appid == NULL)
- return PKGMGR_R_EINVAL;
-
- if (strlen(appid) >= PKG_STRING_LEN_MAX)
- return PKGMGR_R_EINVAL;
+ retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
+ retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
pkgtype = _get_pkg_type_from_desktop_file(appid);
+ retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
/* 2. generate req_key */
req_key = __get_req_key(appid);
+ retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
/*** add quote in all string for special charactor like '\n'*** FIX */
if (argv) {
if (argcnt) {
args = (char *)calloc(len, sizeof(char));
- if (args == NULL) {
- _LOGE("calloc failed");
- free(req_key);
- return PKGMGR_R_ERROR;
- }
+ tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
strncpy(args, argv[0], len - 1);
for (i = 1; i < argcnt; i++) {
}
argsr = (char *)calloc(strlen("1 APP")+2+len, sizeof(char));
- if (argsr == NULL) {
- _LOGE("calloc failed");
- free(req_key);
- free(args);
- return PKGMGR_R_ERROR;
- }
+ tryvm_if(argsr == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
+
strncpy(argsr, "1 APP", strlen("1 APP"));
if (argcnt) {
strncat(argsr, " ", strlen(" "));
/******************* end of quote ************************/
/* 3. request activate */
- ret = comm_client_request(mpc->info.request.cc, req_key,
- COMM_REQ_TO_ACTIVATOR, pkgtype,
- appid, argsr, cookie, 1);
- if (ret < 0) {
- _LOGE("request failed, ret=%d\n", ret);
- free(req_key);
- free(args);
- free(argsr);
- return PKGMGR_R_ECOMM;
- }
+ ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, argsr, cookie, 1);
+ tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
+
+ ret = PKGMGR_R_OK;
+
+catch:
free(req_key);
free(args);
free(argsr);
- return PKGMGR_R_OK;
+ return ret;
}
API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
char *cookie = NULL;
int ret;
/* Check for NULL value of pc */
- if (pc == NULL) {
- _LOGD("package manager client handle is NULL\n");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
+
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
/* 0. check the pc type */
- if (mpc->ctype != PC_REQUEST)
- return PKGMGR_R_EINVAL;
+ retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
/* 1. check argument */
- if (appid == NULL)
- return PKGMGR_R_EINVAL;
-
- if (strlen(appid) >= PKG_STRING_LEN_MAX)
- return PKGMGR_R_EINVAL;
+ retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
+ retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
pkgtype = _get_pkg_type_from_desktop_file(appid);
+ retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
/* 2. generate req_key */
req_key = __get_req_key(appid);
+ retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
/* 3. request activate */
- ret = comm_client_request(mpc->info.request.cc, req_key,
- COMM_REQ_TO_ACTIVATOR, pkgtype,
- appid, "0 APP", cookie, 1);
- if (ret < 0) {
- _LOGE("request failed, ret=%d\n", ret);
- free(req_key);
- return PKGMGR_R_ECOMM;
- }
+ ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, "0 APP", cookie, 1);
+ tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
- free(req_key);
+ ret = PKGMGR_R_OK;
- return PKGMGR_R_OK;
+catch:
+ free(req_key);
+ return ret;
}
return PKGMGR_R_OK;
}
+
+API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
+{
+ int ret = -1;
+
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
+ retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
+ pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
+
+ /* free listening head */
+ listen_cb_info *tmp = NULL;
+ listen_cb_info *prev = NULL;
+ for (tmp = mpc->info.listening.lhead; tmp;) {
+ prev = tmp;
+ tmp = tmp->next;
+ free(prev);
+ }
+
+ /* free dbus connection */
+ ret = comm_client_free(mpc->info.listening.cc);
+ retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
+
+ /* Manage pc for seperated event */
+ mpc->ctype = PC_LISTENING;
+ mpc->status_type = status_type;
+
+ mpc->info.listening.cc = comm_client_new();
+ retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
+
+ if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
+ retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
+ }
+
+ if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
+ retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
+ }
+
+ if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
+ retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
+ }
+
+ if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
+ retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
+ }
+
+ if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
+ ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
+ retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
+ }
+
+ return PKGMGR_R_OK;
+}
+
API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
void *data)
{
int req_id;
/* Check for NULL value of pc */
- if (pc == NULL) {
- _LOGD("package manager client handle is NULL\n");
- return PKGMGR_R_EINVAL;
- }
+ retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
- /* 0. check the pc type */
- if (mpc->ctype != PC_LISTENING)
- return PKGMGR_R_EINVAL;
+ /* 0. check input */
+ retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
+ retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
- /* 1. check argument */
- if (event_cb == NULL)
- return PKGMGR_R_EINVAL;
+ /* 1. get id */
+ req_id = _get_request_id();
/* 2. add callback info to pkgmgr_client */
- req_id = _get_request_id();
__add_stat_cbinfo(mpc, req_id, event_cb, data);
-
return req_id;
}
if (mpc->ctype != PC_BROADCAST)
return PKGMGR_R_EINVAL;
- comm_status_broadcast_server_send_signal(mpc->info.broadcast.bc,
+ comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, mpc->info.broadcast.bc,
PKG_STATUS, pkg_type,
pkgid, key, val);
case PM_REQUEST_GET_SIZE:
tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
- tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode > PM_GET_DATA_SIZE), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
+ tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
ret = __get_size_process(pc, pkgid, (pkgmgr_getsize_type)service_mode, event_cb, data);
break;
### Get required CFLAGS, LDFLAGS from pkg-config
include(FindPkgConfig)
-pkg_check_modules(comm_pkgs REQUIRED dbus-1 dbus-glib-1 dlog pkgmgr-info)
+pkg_check_modules(comm_pkgs REQUIRED dbus-1 glib-2.0 dbus-glib-1 gio-2.0 gio-unix-2.0 dlog pkgmgr-info)
foreach(flag ${comm_pkgs_CFLAGS})
set(comm_pkgs_CFLAGS_str "${comm_pkgs_CFLAGS_str} ${flag}")
set_target_properties(pkgmgr_installer_client PROPERTIES COMPILE_FLAGS "${comm_pkgs_CFLAGS_str}")
target_link_libraries(pkgmgr_installer_client ${comm_pkgs_LDFLAGS})
add_dependencies(pkgmgr_installer_client comm_pkg_mgr_client_dbus_bindings.h comm_status_broadcast_client_dbus_bindings.h comm_status_broadcast_signal_marshaller.h comm_status_broadcast_signal_marshaller.c)
+#add_dependencies(pkgmgr_installer_client comm_pkg_mgr_client_gdbus_generated.h comm_pkg_mgr_client_gdbus_generated.c)
## pkg-mgr server for PMS
# Get request
/* ... */
DBusConnection *conn;
-conn = comm_status_broadcast_server_connect();
+conn = comm_status_broadcast_server_connect(COMM_STATUS_BROADCAST_ALL);
-comm_status_broadcast_server_send_signal(conn, req_id, pkg_type, pkgid, "start", "0");
+comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, conn, req_id, pkg_type, pkgid, "start", "0");
/* ... */
-comm_status_broadcast_server_send_signal(conn, req_id, pkg_type, pkgid, "install_percent", "60");
+comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL,conn, req_id, pkg_type, pkgid, "install_percent", "60");
/* ... */
-comm_status_broadcast_server_send_signal(conn, req_id, pkg_type, pkgid, "end", "0");
+comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, conn, req_id, pkg_type, pkgid, "end", "0");
/* ... */
@endcode
const char *pkgid, const char *args,
const char *cookie, int is_block);
-API int comm_client_set_status_callback(comm_client *cc, status_cb cb,
- void *cb_data);
-
+API int comm_client_set_status_callback(int comm_status_type, comm_client *cc, status_cb cb, void *cb_data);
#endif /* __COMM_CLIENT_H__ */
/*********************************
* Internal function description
*/
+static char *__get_interface(int status_type)
+{
+ char *interface = NULL;
+
+ switch (status_type) {
+ case COMM_STATUS_BROADCAST_ALL:
+ interface = COMM_STATUS_BROADCAST_DBUS_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL:
+ interface = COMM_STATUS_BROADCAST_DBUS_INSTALL_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_UNINSTALL:
+ interface = COMM_STATUS_BROADCAST_DBUS_UNINSTALL_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_MOVE:
+ interface = COMM_STATUS_BROADCAST_DBUS_MOVE_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL_PROGRESS:
+ interface = COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_UPGRADE:
+ interface = COMM_STATUS_BROADCAST_DBUS_UPGRADE_INTERFACE;
+ break;
+
+ default:
+ interface = NULL;
+ }
+ return interface;
+}
/**
* signal handler filter
sig_cb_data = (struct signal_callback_data *)user_data;
/* Signal check */
- if (dbus_message_is_signal(msg,
- COMM_STATUS_BROADCAST_DBUS_INTERFACE,
- COMM_STATUS_BROADCAST_SIGNAL_STATUS)) {
+ if ((dbus_message_is_signal(msg, COMM_STATUS_BROADCAST_DBUS_INTERFACE, COMM_STATUS_BROADCAST_SIGNAL_STATUS)) ||
+ (dbus_message_is_signal(msg, COMM_STATUS_BROADCAST_DBUS_INSTALL_INTERFACE, COMM_STATUS_BROADCAST_EVENT_INSTALL)) ||
+ (dbus_message_is_signal(msg, COMM_STATUS_BROADCAST_DBUS_UNINSTALL_INTERFACE, COMM_STATUS_BROADCAST_EVENT_UNINSTALL)) ||
+ (dbus_message_is_signal(msg, COMM_STATUS_BROADCAST_DBUS_MOVE_INTERFACE, COMM_STATUS_BROADCAST_EVENT_MOVE)) ||
+ (dbus_message_is_signal(msg, COMM_STATUS_BROADCAST_DBUS_UPGRADE_INTERFACE, COMM_STATUS_BROADCAST_EVENT_UPGRADE)) ||
+ (dbus_message_is_signal(msg, COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_INTERFACE, COMM_STATUS_BROADCAST_EVENT_INSTALL_PROGRESS))) {
/* Signal type check */
if (dbus_message_get_args(msg, &err,
* Set a callback for status signal
*/
int
-comm_client_set_status_callback(comm_client *cc, status_cb cb, void *cb_data)
+comm_client_set_status_callback(int comm_status_type, comm_client *cc, status_cb cb, void *cb_data)
{
DBusError err;
char buf[256] = { 0, };
goto ERROR_CLEANUP;
/* Add a rule for signal */
- snprintf(buf, 255, "type='signal',interface='%s'",
- COMM_STATUS_BROADCAST_DBUS_INTERFACE);
+ snprintf(buf, 255, "type='signal',interface='%s'", __get_interface(comm_status_type));
dbus_bus_add_match(cc->conn, buf, &err);
if (dbus_error_is_set(&err)) {
ERR("dbus error:%s", err.message);
--- /dev/null
+/*
+ * slp-pkgmgr
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
+ * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+/*
+ * comm_client_gdbus.c
+ * comm_client library using gdbus
+ */
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include "comm_config.h"
+#include "comm_client.h"
+#include "comm_pkg_mgr_client_gdbus_generated.h"
+
+/*******************
+ * ADT description
+ */
+
+/* Storing status_cb */
+struct signal_callback_data {
+ status_cb cb;
+ void *cb_data;
+};
+
+/* comm_client ADT */
+struct comm_client {
+ guint subscription_id;
+ GDBusConnection *conn;
+ struct signal_callback_data *sig_cb_data;
+};
+
+static char *__get_interface(int status_type)
+{
+ char *ifc = NULL;
+
+ switch (status_type) {
+ case COMM_STATUS_BROADCAST_ALL:
+ ifc = COMM_STATUS_BROADCAST_DBUS_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL:
+ ifc = COMM_STATUS_BROADCAST_DBUS_INSTALL_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_UNINSTALL:
+ ifc = COMM_STATUS_BROADCAST_DBUS_UNINSTALL_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_MOVE:
+ ifc = COMM_STATUS_BROADCAST_DBUS_MOVE_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL_PROGRESS:
+ ifc = COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_INTERFACE;
+ break;
+
+ default:
+ break;
+ }
+ return ifc;
+}
+
+/**
+ * signal handler filter
+ * Filter signal, and run user callback
+ */
+void _on_signal_handle_filter(GDBusConnection *conn,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data)
+{
+ if (interface_name && strcmp(interface_name, COMM_STATUS_BROADCAST_DBUS_INTERFACE) &&
+ strcmp(interface_name, COMM_STATUS_BROADCAST_DBUS_INSTALL_INTERFACE) &&
+ strcmp(interface_name, COMM_STATUS_BROADCAST_DBUS_UNINSTALL_INTERFACE) &&
+ strcmp(interface_name, COMM_STATUS_BROADCAST_DBUS_MOVE_INTERFACE) &&
+ strcmp(interface_name, COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_INTERFACE)) {
+ dbg("Interface name did not match. Drop the message");
+ return;
+ }
+ if (signal_name && strcmp(signal_name, COMM_STATUS_BROADCAST_SIGNAL_STATUS) &&
+ strcmp(signal_name, COMM_STATUS_BROADCAST_EVENT_INSTALL) &&
+ strcmp(signal_name, COMM_STATUS_BROADCAST_EVENT_UNINSTALL) &&
+ strcmp(signal_name, COMM_STATUS_BROADCAST_EVENT_MOVE) &&
+ strcmp(signal_name, COMM_STATUS_BROADCAST_EVENT_INSTALL_PROGRESS)) {
+ dbg("Signal name did not match. Drop the message");
+ return;
+ }
+ /* Values to be received by signal */
+ char *req_id = NULL;
+ char *pkg_type = NULL;
+ char *pkgid = NULL;
+ char *key = NULL;
+ char *val = NULL;
+
+ /* User's signal handler */
+ struct signal_callback_data *sig_cb_data;
+ if (user_data)
+ sig_cb_data = (struct signal_callback_data *)user_data;
+ else
+ return;
+
+ g_variant_get(parameters, "(&s&s&s&s&s)",
+ &req_id, &pkg_type, &pkgid, &key, &val);
+ /* Got signal! */
+ dbg("Got signal: [%s] %s / %s / %s / %s / %s", signal_name, req_id,
+ pkg_type, pkgid, key, val);
+
+ /* Run signal callback if exist */
+ if (sig_cb_data && sig_cb_data->cb) {
+ sig_cb_data->cb(sig_cb_data->cb_data, req_id,
+ pkg_type, pkgid, key, val);
+ dbg("callback function is end");
+ }
+ dbg("Handled signal. Exit function");
+ return;
+}
+
+/**
+ * signal_callback_data free function
+ * Just free it!
+ */
+void _free_sig_cb_data(void *data)
+{
+ struct signal_callback_data *sig_cb_data = NULL;
+ if (data)
+ sig_cb_data = (struct signal_callback_data *)data;
+ if (!sig_cb_data)
+ return;
+ free(sig_cb_data);
+}
+
+/*******************
+ * API description
+ */
+
+/**
+ * Create a new comm_client object
+ */
+comm_client *comm_client_new(void)
+{
+ GError *error = NULL;
+ comm_client *cc = NULL;
+
+ /* Allocate memory for ADT:comm_client */
+ g_type_init();
+ cc = calloc(1, sizeof(comm_client));
+ if (NULL == cc) {
+ ERR("No memory");
+ goto ERROR_CLEANUP;
+ }
+
+ /* Connect to gdbus */
+ cc->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (error) {
+ ERR("gdbus connection error (%s)", error->message);
+ g_error_free(error);
+ goto ERROR_CLEANUP;
+ }
+ if (NULL == cc->conn) {
+ ERR("gdbus connection is not set, even gdbus error isn't raised");
+ goto ERROR_CLEANUP;
+ }
+ return cc;
+
+ ERROR_CLEANUP:
+ if (cc)
+ free(cc);
+ return NULL;
+}
+
+/**
+ * Free comm_client object
+ */
+int comm_client_free(comm_client *cc)
+{
+ if (!cc)
+ return -1;
+ if (!(cc->conn) || g_dbus_connection_is_closed(cc->conn)) {
+ ERR("Invalid gdbus connection");
+ return -2;
+ }
+
+ /* Cleanup ADT */
+ /* flush remaining buffer: blocking mode */
+ g_dbus_connection_flush_sync(cc->conn, NULL, NULL);
+
+ /* Free signal filter if signal callback is exist */
+ if (cc->sig_cb_data) {
+ g_dbus_connection_signal_unsubscribe(cc->conn, cc->subscription_id);
+ /* TODO: Is it needed to free cc->sig_cb_data here? */
+ /* _free_sig_cb_data(cc->sig_cb_data); */
+ }
+
+ g_dbus_connection_close_sync(cc->conn, NULL, NULL);
+ g_object_unref(cc->conn);
+ free(cc);
+
+ return 0;
+}
+
+/**
+ * Request a message
+ */
+
+int
+comm_client_request(
+ comm_client *cc,
+ const char *req_id,
+ const int req_type,
+ const char *pkg_type,
+ const char *pkgid,
+ const char *args,
+ const char *cookie,
+ int is_block)
+{
+ GError *error = NULL;
+ int ret = 0;
+ int rc = 0;
+ ComSamsungSlpPkgmgr *proxy;
+ if (!cc){
+ ERR("Invalid gdbus input");
+ return COMM_RET_ERROR;
+ }
+ proxy = com_samsung_slp_pkgmgr_proxy_new_sync(cc->conn,
+ G_DBUS_PROXY_FLAGS_NONE, COMM_PKG_MGR_DBUS_SERVICE,
+ COMM_PKG_MGR_DBUS_PATH,
+ NULL, &error);
+ if (proxy == NULL) {
+ ERR("Unable to create proxy\n");
+ return COMM_RET_ERROR;
+ }
+ rc = com_samsung_slp_pkgmgr_call_request_sync(proxy,
+ req_id, req_type, pkg_type, pkgid, args, cookie, &ret, NULL, &error);
+ if (!rc) {
+ ERR("Failed to send request\n");
+ return COMM_RET_ERROR;
+ }
+ return COMM_RET_OK;
+}
+
+/**
+ * Set a callback for status signal
+ */
+int
+comm_client_set_status_callback(int comm_status_type, comm_client *cc, status_cb cb, void *cb_data)
+{
+ int r = COMM_RET_ERROR;
+ char *ifc = NULL;
+
+ if (NULL == cc)
+ goto ERROR_CLEANUP;
+
+ ifc = __get_interface(comm_status_type);
+ if (ifc == NULL) {
+ ERR("Invalid interface name\n");
+ return COMM_RET_ERROR;
+ }
+ /* If previous signal handler is set already, remove filter first */
+ if (cc->sig_cb_data) {
+ g_dbus_connection_signal_unsubscribe(cc->conn, cc->subscription_id);
+ /* TODO: Is it needed to free cc->sig_cb_data here? */
+ }
+
+ /* Create new sig_cb_data */
+ cc->sig_cb_data = calloc(1, sizeof(struct signal_callback_data));
+ (cc->sig_cb_data)->cb = cb;
+ (cc->sig_cb_data)->cb_data = cb_data;
+
+ /* Add a filter for signal */
+ cc->subscription_id = g_dbus_connection_signal_subscribe(cc->conn, NULL, ifc,
+ NULL, NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
+ _on_signal_handle_filter, (gpointer)cc->sig_cb_data, _free_sig_cb_data);
+ if (!cc->subscription_id) {
+ ERR("Failed to add filter\n");
+ r = COMM_RET_ERROR;
+ goto ERROR_CLEANUP;
+ }
+
+ return COMM_RET_OK;
+
+ ERROR_CLEANUP:
+ ERR("General error");
+ return r;
+}
+
#define LOG_TAG "PKGMGR"
#endif /* LOG_TAG */
#include <dlog.h>
-#define dbg(fmtstr, args...) \
- do { SLOGI("[comm]%s:%d:%s(): " \
- fmtstr "\n", basename(__FILE__), __LINE__, __func__, ##args); } \
- while (0)
-#define ERR(fmtstr, args...) \
- do { SLOGE("[comm]%s:%d:%s(): " \
- fmtstr "\n", basename(__FILE__), __LINE__, __func__, ##args); } \
- while (0)
+
+#define dbg(fmt, arg...) LOGD(fmt, ##arg)
+#define ERR(fmt, arg...) LOGE(fmt, ##arg)
+
#else
#include <stdio.h>
#include <sys/types.h>
"org.tizen.slp.pkgmgr_status"
#define COMM_STATUS_BROADCAST_SIGNAL_STATUS "status"
+#define COMM_STATUS_BROADCAST_DBUS_INSTALL_SERVICE_PREFIX "org.tizen.slp.pkgmgr.install"
+#define COMM_STATUS_BROADCAST_DBUS_INSTALL_PATH "/org/tizen/slp/pkgmgr/install"
+#define COMM_STATUS_BROADCAST_DBUS_INSTALL_INTERFACE "org.tizen.slp.pkgmgr.install"
+#define COMM_STATUS_BROADCAST_EVENT_INSTALL "install"
+
+#define COMM_STATUS_BROADCAST_DBUS_UNINSTALL_SERVICE_PREFIX "org.tizen.slp.pkgmgr.uninstall"
+#define COMM_STATUS_BROADCAST_DBUS_UNINSTALL_PATH "/org/tizen/slp/pkgmgr/uninstall"
+#define COMM_STATUS_BROADCAST_DBUS_UNINSTALL_INTERFACE "org.tizen.slp.pkgmgr.uninstall"
+#define COMM_STATUS_BROADCAST_EVENT_UNINSTALL "uninstall"
+
+#define COMM_STATUS_BROADCAST_DBUS_MOVE_SERVICE_PREFIX "org.tizen.slp.pkgmgr.move"
+#define COMM_STATUS_BROADCAST_DBUS_MOVE_PATH "/org/tizen/slp/pkgmgr/move"
+#define COMM_STATUS_BROADCAST_DBUS_MOVE_INTERFACE "org.tizen.slp.pkgmgr.move"
+#define COMM_STATUS_BROADCAST_EVENT_MOVE "move"
+
+#define COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_SERVICE_PREFIX "org.tizen.slp.pkgmgr.install.progress"
+#define COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_PATH "/org/tizen/slp/pkgmgr/install/progress"
+#define COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_INTERFACE "org.tizen.slp.pkgmgr.install.progress"
+#define COMM_STATUS_BROADCAST_EVENT_INSTALL_PROGRESS "install_progress"
+
+#define COMM_STATUS_BROADCAST_DBUS_UPGRADE_SERVICE_PREFIX "org.tizen.slp.pkgmgr.upgrade"
+#define COMM_STATUS_BROADCAST_DBUS_UPGRADE_PATH "/org/tizen/slp/pkgmgr/upgrade"
+#define COMM_STATUS_BROADCAST_DBUS_UPGRADE_INTERFACE "org.tizen.slp.pkgmgr.upgrade"
+#define COMM_STATUS_BROADCAST_EVENT_UPGRADE "upgrade"
+
/********
* enums
********/
COMM_RET_MAX_SENTINEL
};
+/* broadcast type */
+enum {
+ COMM_STATUS_BROADCAST_ALL = 1,
+ COMM_STATUS_BROADCAST_INSTALL,
+ COMM_STATUS_BROADCAST_UNINSTALL,
+ COMM_STATUS_BROADCAST_MOVE,
+ COMM_STATUS_BROADCAST_INSTALL_PROGRESS,
+ COMM_STATUS_BROADCAST_UPGRADE,
+ COMM_STATUS_BROADCAST_MAX
+};
+
#endif /* __COMM_CONFIG_H__ */
#include <dbus/dbus.h>
/* pure dbus api */
-API DBusConnection *comm_status_broadcast_server_connect(void);
-API void comm_status_broadcast_server_send_signal(DBusConnection *conn,
+API DBusConnection *comm_status_broadcast_server_connect(int comm_status_type);
+API void comm_status_broadcast_server_send_signal(int comm_status_type, DBusConnection *conn,
const char *req_id,
const char *pkg_type,
const char *pkgid,
/********************************************
* pure dbus signal service for internal use
********************************************/
+static char *__get_prifix(int status_type)
+{
+ char *prifix = NULL;
+
+ switch (status_type) {
+ case COMM_STATUS_BROADCAST_ALL:
+ prifix = COMM_STATUS_BROADCAST_DBUS_SERVICE_PREFIX;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL:
+ prifix = COMM_STATUS_BROADCAST_DBUS_INSTALL_SERVICE_PREFIX;
+ break;
+
+ case COMM_STATUS_BROADCAST_UNINSTALL:
+ prifix = COMM_STATUS_BROADCAST_DBUS_UNINSTALL_SERVICE_PREFIX;
+ break;
+
+ case COMM_STATUS_BROADCAST_MOVE:
+ prifix = COMM_STATUS_BROADCAST_DBUS_MOVE_SERVICE_PREFIX;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL_PROGRESS:
+ prifix = COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_SERVICE_PREFIX;
+ break;
+
+ case COMM_STATUS_BROADCAST_UPGRADE:
+ prifix = COMM_STATUS_BROADCAST_DBUS_UPGRADE_SERVICE_PREFIX;
+ break;
+
+ default:
+ prifix = NULL;
+ }
+ return prifix;
+}
+
+static char *__get_path(int status_type)
+{
+ char *path = NULL;
+
+ switch (status_type) {
+ case COMM_STATUS_BROADCAST_ALL:
+ path = COMM_STATUS_BROADCAST_DBUS_PATH;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL:
+ path = COMM_STATUS_BROADCAST_DBUS_INSTALL_PATH;
+ break;
+
+ case COMM_STATUS_BROADCAST_UNINSTALL:
+ path = COMM_STATUS_BROADCAST_DBUS_UNINSTALL_PATH;
+ break;
+
+ case COMM_STATUS_BROADCAST_MOVE:
+ path = COMM_STATUS_BROADCAST_DBUS_MOVE_PATH;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL_PROGRESS:
+ path = COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_PATH;
+ break;
+
+ case COMM_STATUS_BROADCAST_UPGRADE:
+ path = COMM_STATUS_BROADCAST_DBUS_UPGRADE_PATH;
+ break;
+
+ default:
+ path = NULL;
+ }
+ return path;
+}
+
+static char *__get_interface(int status_type)
+{
+ char *interface = NULL;
+
+ switch (status_type) {
+ case COMM_STATUS_BROADCAST_ALL:
+ interface = COMM_STATUS_BROADCAST_DBUS_INTERFACE;
+ break;
-API DBusConnection *comm_status_broadcast_server_connect(void)
+ case COMM_STATUS_BROADCAST_INSTALL:
+ interface = COMM_STATUS_BROADCAST_DBUS_INSTALL_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_UNINSTALL:
+ interface = COMM_STATUS_BROADCAST_DBUS_UNINSTALL_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_MOVE:
+ interface = COMM_STATUS_BROADCAST_DBUS_MOVE_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL_PROGRESS:
+ interface = COMM_STATUS_BROADCAST_DBUS_INSTALL_PROGRESS_INTERFACE;
+ break;
+
+ case COMM_STATUS_BROADCAST_UPGRADE:
+ interface = COMM_STATUS_BROADCAST_DBUS_UPGRADE_INTERFACE;
+ break;
+
+ default:
+ interface = NULL;
+ }
+ return interface;
+}
+
+static char *__get_name(int status_type)
+{
+ char *name = NULL;
+
+ switch (status_type) {
+ case COMM_STATUS_BROADCAST_ALL:
+ name = COMM_STATUS_BROADCAST_SIGNAL_STATUS;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL:
+ name = COMM_STATUS_BROADCAST_EVENT_INSTALL;
+ break;
+
+ case COMM_STATUS_BROADCAST_UNINSTALL:
+ name = COMM_STATUS_BROADCAST_EVENT_UNINSTALL;
+ break;
+
+ case COMM_STATUS_BROADCAST_MOVE:
+ name = COMM_STATUS_BROADCAST_EVENT_MOVE;
+ break;
+
+ case COMM_STATUS_BROADCAST_INSTALL_PROGRESS:
+ name = COMM_STATUS_BROADCAST_EVENT_INSTALL_PROGRESS;
+ break;
+
+ case COMM_STATUS_BROADCAST_UPGRADE:
+ name = COMM_STATUS_BROADCAST_EVENT_UPGRADE;
+ break;
+
+ default:
+ name = NULL;
+ }
+ return name;
+}
+
+API DBusConnection *comm_status_broadcast_server_connect(int status_type)
{
DBusError err;
DBusConnection *conn;
dbus_error_free(&err);
}
dbus_error_free(&err);
- if (NULL == conn)
- exit(1);
- dbus_bus_request_name(conn,
- COMM_STATUS_BROADCAST_DBUS_SERVICE_PREFIX,
- DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &err);
+ if (NULL == conn) {
+ dbg("conn is NULL");
+ return NULL;
+ }
+
+ dbus_bus_request_name(conn, __get_prifix(status_type), DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &err);
if (dbus_error_is_set(&err)) {
dbg("Failed to request name: %s", err.message);
dbus_error_free(&err);
- exit(1);
+ return NULL;
}
return conn;
}
API void
-comm_status_broadcast_server_send_signal(DBusConnection *conn,
+comm_status_broadcast_server_send_signal(int comm_status_type, DBusConnection *conn,
const char *req_id,
const char *pkg_type,
const char *pkgid, const char *key,
};
int i;
- msg = dbus_message_new_signal(COMM_STATUS_BROADCAST_DBUS_PATH,
- COMM_STATUS_BROADCAST_DBUS_INTERFACE,
- COMM_STATUS_BROADCAST_SIGNAL_STATUS);
+ msg = dbus_message_new_signal(__get_path(comm_status_type), __get_interface(comm_status_type), __get_name(comm_status_type));
if (NULL == msg) {
dbg("msg NULL");
- exit(1);
+ return;
}
dbus_message_iter_init_append(msg, &args);
(&args, DBUS_TYPE_STRING, &(values[i]))) {
dbg("dbus_message_iter_append_basic failed:"
" Out of memory");
- exit(1);
+ return;
}
}
if (!dbus_connection_send(conn, msg, &serial)) {
dbg("dbus_connection_send failed: Out of memory");
- exit(1);
+ return;
}
dbus_connection_flush(conn);
dbus_message_unref(msg);
return;
dbus_connection_unref(conn);
}
-
/* API */
+static int __send_signal_for_event(int comm_status_type, pkgmgr_installer *pi,
+ const char *pkg_type,
+ const char *pkgid,
+ const char *key, const char *val)
+{
+ if (!pi)
+ return -1;
+
+ if (!pi->conn)
+ pi->conn = comm_status_broadcast_server_connect(comm_status_type);
+
+ char *sid = pi->session_id;
+ if (!sid)
+ sid = "";
+ comm_status_broadcast_server_send_signal(comm_status_type, pi->conn, sid, pkg_type, pkgid, key, val);
+
+ return 0;
+}
+
+API int __send_event(pkgmgr_installer *pi,
+ const char *pkg_type,
+ const char *pkgid,
+ const char *key, const char *val)
+{
+ int r = -1;
+
+ if (strcmp(key,PKGMGR_INSTALLER_START_KEY_STR) == 0) {
+ if(strcmp(key,PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0) {
+ pi->request_type = PKGMGR_REQ_UPGRADE;
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_UPGRADE, pi, pkg_type, pkgid, key, val);
+ }
+ if(pi->request_type == PKGMGR_REQ_INSTALL) {
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_INSTALL, pi, pkg_type, pkgid, key, val);
+ } else if (pi->request_type == PKGMGR_REQ_UNINSTALL){
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_UNINSTALL, pi, pkg_type, pkgid, key, val);
+ }
+ } else if (strcmp(key,PKGMGR_INSTALLER_END_KEY_STR) == 0) {
+ if(pi->request_type == PKGMGR_REQ_INSTALL) {
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_INSTALL, pi, pkg_type, pkgid, key, val);
+ } else if (pi->request_type == PKGMGR_REQ_UNINSTALL){
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_UNINSTALL, pi, pkg_type, pkgid, key, val);
+ } else if (pi->request_type == PKGMGR_REQ_UPGRADE){
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_UPGRADE, pi, pkg_type, pkgid, key, val);
+ }
+ } else if (strcmp(key,PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0) {
+ r = __send_signal_for_event(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, pi, pkg_type, pkgid, key, val);
+ }
+
+ return r;
+}
+
API pkgmgr_installer *pkgmgr_installer_new(void)
{
pkgmgr_installer *pi = NULL;
int r = 0;
if (!pi->conn)
- pi->conn = comm_status_broadcast_server_connect();
+ pi->conn = comm_status_broadcast_server_connect(COMM_STATUS_BROADCAST_ALL);
char *sid = pi->session_id;
if (!sid)
sid = "";
- comm_status_broadcast_server_send_signal(pi->conn, sid, pkg_type,
+ comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, pi->conn, sid, pkg_type,
pkgid, key, val);
+ __send_event(pi, pkg_type, pkgid, key, val);
+
return r;
}
typedef void* pkgmgr_instcertinfo_h;
/**
+ * @brief listening event type in pkgmgr.
+ */
+#define PKGMGR_INSTALLER_START_KEY_STR "start"
+#define PKGMGR_INSTALLER_END_KEY_STR "end"
+#define PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR "install_percent"
+
+#define PKGMGR_INSTALLER_INSTALL_EVENT_STR "install"
+#define PKGMGR_INSTALLER_UNINSTALL_EVENT_STR "uninstall"
+#define PKGMGR_INSTALLER_MOVE_EVENT_STR "move"
+#define PKGMGR_INSTALLER_UPGRADE_EVENT_STR "upgrade"
+
+
+
+
+/**
* Request type.
*/
enum {
PKGMGR_REQ_MOVE = 4,
PKGMGR_REQ_RECOVER = 5,
PKGMGR_REQ_REINSTALL = 6,
- PKGMGR_REQ_GETSIZE = 7
+ PKGMGR_REQ_GETSIZE = 7,
+ PKGMGR_REQ_UPGRADE = 8
};
enum {
"this_is_a_cookie", 0);
printf("client: waiting signal...\n");
- comm_client_set_status_callback(cc, stat_cb, NULL);
+ comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, cc, stat_cb, NULL);
g_main_loop_run(mainloop);
static int _main_dbus(int argc, char **argv);
static int _main_dbus(int argc, char **argv)
{
- DBusConnection *conn = comm_status_broadcast_server_connect();
+ DBusConnection *conn = comm_status_broadcast_server_connect(COMM_STATUS_BROADCAST_ALL);
int i;
for (i = 0; i < 100; i++) {
- comm_status_broadcast_server_send_signal(conn, "test_id",
+ comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, conn, "test_id",
"test", "test_pkgid",
"test_key",
"test_val");
struct signal_counter counter = { 0, };
comm_client *cc;
cc = comm_client_new();
- comm_client_set_status_callback(cc, get_signal_cb, &counter);
+ comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, cc, get_signal_cb, &counter);
/* sender */
g_timeout_add_seconds(1, timer_send_signal, pi);
#sbs-git:slp/pkgs/s/slp-pkgmgr pkgmgr 0.1.103 29b53909a5d6e8728429f0a188177eac691cb6ce
Name: pkgmgr
Summary: Packager Manager client library package
-Version: 0.2.112
+Version: 0.2.119
Release: 1
Group: System/Libraries
License: Apache License, Version 2.0
BuildRequires: gettext-tools
BuildRequires: pkgconfig(ecore)
BuildRequires: pkgconfig(security-server)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(gio-unix-2.0)
+BuildRequires: pkgconfig(gio-2.0)
BuildRequires: pkgconfig(dbus-1)
BuildRequires: pkgconfig(dbus-glib-1)
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(iniparser)
BuildRequires: pkgmgr-info-parser-devel
BuildRequires: pkgmgr-info-parser
+BuildRequires: python-xml
%description
%prep
%setup -q
+%if 0%{?tizen_build_binary_release_type_eng}
+export CFLAGS="$CFLAGS -DTIZEN_ENGINEER_MODE"
+export CXXFLAGS="$CXXFLAGS ?DTIZEN_ENGINEER_MODE"
+export FFLAGS="$FFLAGS -DTIZEN_ENGINEER_MODE"
+%endif
+
cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix}
%build
make %{?jobs:-j%jobs}
+
%install
rm -rf %{buildroot}
%make_install
#init DB
mkdir -p /usr/share/packages
mkdir -p /opt/share/packages
-mkdir -p /opt/share/packages/.recovery
+mkdir -p /opt/share/packages/.recovery/pkgmgr
+mkdir -p /opt/share/packages/.recovery/tpk
+mkdir -p /opt/share/packages/.recovery/wgt
mkdir -p /usr/share/applications
mkdir -p /opt/share/applications
<smack request="system::media" type="rwxat"/>
<smack request="ail::db" type="rwx"/>
<smack request="system::vconf" type="rwxat"/>
+ <smack request="system::vconf_inhouse" type="rwxat"/>
<smack request="pkgmgr::db" type="rwx"/>
</request>
</define>
/bin/rm /opt/dbspace/.pkgmgr_parser.db
/bin/rm /opt/dbspace/.pkgmgr_parser.db-journal
/usr/bin/pkg_fota
-/usr/bin/ail_initdb
+/usr/bin/ail_fota
#define LOCALEDIR "/usr/share/locale"
#endif
-#define PACKAGE_RECOVERY_DIR "/opt/share/packages/.recovery"
+#define PACKAGE_RECOVERY_DIR "/opt/share/packages/.recovery/pkgmgr"
#define DESKTOP_W 720.0
}
DBGE("manifest : %s\n", manifest);
- if (val)
- ret = pkgmgr_parser_parse_manifest_for_installation(manifest, NULL);
+ if (val) {
+ pkgmgrinfo_pkginfo_h handle;
+ ret = pkgmgrinfo_pkginfo_get_pkginfo(item->pkgid, &handle);
+ if (ret < 0) {
+ ret = pkgmgr_parser_parse_manifest_for_installation(manifest, NULL);
+ if (ret < 0) {
+ DBGE("insert in db failed\n");
+ exit(1);
+ }
+
+ ret = ail_desktop_add(item->pkgid);
+ if (ret != AIL_ERROR_OK) {
+ perror("fail to ail_desktop_add");
+ exit(1);
+ }
+ } else {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ }
+
+ ret = pkgmgrinfo_appinfo_set_state_enabled(item->pkgid, val);
+ if (ret != PMINFO_R_OK) {
+ perror("fail to activate/deactivte package");
+ exit(1);
+ }
+
+ ret = ail_desktop_appinfo_modify_bool(item->pkgid,
+ AIL_PROP_X_SLP_ENABLED_BOOL,
+ val, TRUE);
+ if (ret != AIL_ERROR_OK) {
+ perror("fail to ail_desktop_appinfo");
+ exit(1);
+ }
+ }
else
ret = pkgmgr_parser_parse_manifest_for_uninstallation(manifest, NULL);
return ret;
}
+static int __pkg_list_cb (const pkgmgrinfo_pkginfo_h handle, void *user_data)
+{
+ int ret = -1;
+ int size = 0;
+ char *pkgid;
+
+ ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
+ if(ret < 0) {
+ printf("pkgmgr_pkginfo_get_pkgid() failed\n");
+ }
+
+ ret = pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, PM_GET_TOTAL_SIZE, (pkgmgr_client *)user_data, NULL, pkgid, NULL, NULL, NULL);
+ if (ret < 0){
+ printf("pkgmgr_client_request_service Failed\n");
+ return -1;
+ }
+
+ printf("pkg[%s] size = %d\n", pkgid, ret);
+
+ return 0;
+}
+
static int __process_request()
{
int ret = -1;
if (data.pkgid[0] == '\0') {
printf("Please provide the arguments.\n");
printf("use -h option to see usage\n");
- data.result = PKGCMD_ERR_ARGUMENT_INVALID;
- break;
- }
- if (data.type < 0 || data.type > 1) {
- printf("Invalid get type...See usage\n");
ret = -1;
break;
}
break;
}
+ if (data.type == 9) {
+ ret = pkgmgrinfo_pkginfo_get_list(__pkg_list_cb, (void *)pc);
+ break;
+ }
+
ret = pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, data.type, pc, NULL, data.pkgid, NULL, NULL, NULL);
if (ret < 0){
data.result = PKGCMD_ERR_FATAL_ERROR;
// pkgmgr_parser_parse_manifest_for_installation(buf, NULL);
char buf2[BUFSZE];
- snprintf(buf2, sizeof(buf2), "/usr/bin/pkginfo --imd %s", buf);
+ snprintf(buf2, sizeof(buf2), "/usr/bin/pkginfo --fota %s", buf);
system(buf2);
free(manifest);
#include <pkgmgr-info.h>
#include <vconf.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
-#include "pkgmgr_installer.h"
#include "pkgmgr-debug.h"
+#include "package-manager.h"
#undef LOG_TAG
#ifndef LOG_TAG
#endif /* LOG_TAG */
#define MAX_PKG_BUF_LEN 1024
+#define BLOCK_SIZE 4096 /*in bytes*/
+
#define PKG_TMP_PATH "/opt/usr/apps/tmp"
+#define PKG_RW_PATH "/opt/usr/apps/"
+#define PKG_RO_PATH "/usr/apps/"
-static int _pkg_getsize(int argc, char **argv)
+long long __calculate_dir_size(char *dirname)
{
- int ret = 0;
- char *pkgid = NULL;
- char *type = NULL;
- pkgmgr_installer *pi = NULL;
- pkgmgrinfo_pkginfo_h handle = NULL;
- int size = -1;
- int get_type = -1;
- char *pkeyid = NULL;
-
- /*make new pkgmgr_installer handle*/
- pi = pkgmgr_installer_new();
- retvm_if(!pi, PMINFO_R_ERROR, "service type is error\n");
-
- /*get args*/
- ret = pkgmgr_installer_receive_request(pi, argc, argv);
- tryvm_if(ret < 0, PMINFO_R_ERROR, "pkgmgr_installer_receive_request failed");
-
- /*get pkgid from installer handle*/
- pkgid = pkgmgr_installer_get_request_info(pi);
- tryvm_if(pkgid == NULL, ret = PMINFO_R_ERROR, "pkgmgr_installer_get_request_info failed");
-
- pkeyid = pkgmgr_installer_get_session_id(pi);
- tryvm_if(pkeyid == NULL, ret = PMINFO_R_ERROR, "pkgmgr_installer_get_session_id failed");
-
- get_type = pkgmgr_installer_get_move_type(pi);
- tryvm_if(pkgid < 0, ret = PMINFO_R_ERROR, "pkgmgr_installer_get_request_info failed");
-
- /*get pkgmgr handle from pkgid*/
- ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
- tryvm_if(ret < 0, ret = PMINFO_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo[pkgid=%s] failed", pkgid);
-
- /*get type info from handle*/
- ret = pkgmgrinfo_pkginfo_get_type(handle, &type);
- tryvm_if(ret < 0, ret = PMINFO_R_ERROR, "pkgmgrinfo_pkginfo_get_type[pkgid=%s] failed", pkgid);
-
- /*get size info from handle
- typedef enum {
- PM_GET_TOTAL_SIZE= 0,
- PM_GET_DATA_SIZE = 1,
- }pkgmgr_getsize_type;
-
- */
- if (get_type == 0) {
- ret = pkgmgrinfo_pkginfo_get_total_size(handle, &size);
- tryvm_if(ret < 0, ret = PMINFO_R_ERROR, "pkgmgrinfo_pkginfo_get_total_size[pkgid=%s] failed", pkgid);
+ long long total = 0;
+ long long ret = 0;
+ int q = 0; /*quotient*/
+ int r = 0; /*remainder*/
+ DIR *dp = NULL;
+ struct dirent *ep = NULL;
+ struct stat fileinfo;
+ char abs_filename[FILENAME_MAX] = { 0, };
+ if(dirname == NULL) {
+ _LOGE("dirname is NULL");
+ return PMINFO_R_ERROR;
+ }
+ dp = opendir(dirname);
+ if (dp != NULL) {
+ while ((ep = readdir(dp)) != NULL) {
+ if (!strcmp(ep->d_name, ".") ||
+ !strcmp(ep->d_name, "..")) {
+ continue;
+ }
+ snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
+ ep->d_name);
+ if (lstat(abs_filename, &fileinfo) < 0)
+ perror(abs_filename);
+ else {
+ if (S_ISDIR(fileinfo.st_mode)) {
+ total += fileinfo.st_size;
+ if (strcmp(ep->d_name, ".")
+ && strcmp(ep->d_name, "..")) {
+ ret = __calculate_dir_size
+ (abs_filename);
+ total = total + ret;
+ }
+ } else if (S_ISLNK(fileinfo.st_mode)) {
+ continue;
+ } else {
+ /*It is a file. Calculate the actual
+ size occupied (in terms of 4096 blocks)*/
+ q = (fileinfo.st_size / BLOCK_SIZE);
+ r = (fileinfo.st_size % BLOCK_SIZE);
+ if (r) {
+ q = q + 1;
+ }
+ total += q * BLOCK_SIZE;
+ }
+ }
+ }
+ (void)closedir(dp);
} else {
- ret = pkgmgrinfo_pkginfo_get_data_size(handle, &size);
- tryvm_if(ret < 0, ret = PMINFO_R_ERROR, "pkgmgrinfo_pkginfo_get_data_size[pkgid=%s] failed", pkgid);
+ _LOGE("Couldn't open the directory\n");
+ return -1;
}
+ return total;
- vconf_set_int(VCONFKEY_PKGMGR_STATUS, size);
+}
-catch:
+static int __get_total_size(char *pkgid, int *size)
- pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
- pkgmgr_installer_free(pi);
+{
+ char device_path[MAX_PKG_BUF_LEN] = { '\0', };
+ long long rw_size = 0;
+ long long ro_size= 0;
+ long long tmp_size= 0;
+ long long total_size= 0;
+ struct stat fileinfo;
+ int ret = -1;
+
+ /* RW area */
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/bin", PKG_RW_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ rw_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/info", PKG_RW_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ rw_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/res", PKG_RW_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ rw_size += tmp_size;
+ }
+ }
- return ret;
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/data", PKG_RW_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ rw_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/shared", PKG_RW_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ rw_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/setting", PKG_RW_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ rw_size += tmp_size;
+ }
+ }
+#if 1
+ /* RO area */
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/bin", PKG_RO_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ ro_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/info", PKG_RO_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ ro_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/res", PKG_RO_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ ro_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/data", PKG_RO_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ ro_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/shared", PKG_RO_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ ro_size += tmp_size;
+ }
+ }
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/setting", PKG_RO_PATH, pkgid);
+ if (lstat(device_path, &fileinfo) == 0) {
+ if (!S_ISLNK(fileinfo.st_mode)) {
+ tmp_size = __calculate_dir_size(device_path);
+ if (tmp_size > 0)
+ ro_size += tmp_size;
+ }
+ }
+#endif
+ /* Total size */
+ total_size = rw_size + ro_size;
+ *size = (int)total_size;
+
+ return PMINFO_R_OK;
+}
+
+static int __get_data_size(char *pkgid, int *size)
+{
+ char device_path[MAX_PKG_BUF_LEN] = { '\0', };
+ long long total_size= 0;
+
+ snprintf(device_path, MAX_PKG_BUF_LEN, "%s%s/data", PKG_RW_PATH, pkgid);
+ if (access(device_path, R_OK) == 0)
+ total_size = __calculate_dir_size(device_path);
+ if (total_size < 0)
+ return PMINFO_R_ERROR;
+
+ *size = (int)total_size;
+
+ return PMINFO_R_OK;
+}
+
+static int __pkg_list_cb (const pkgmgrinfo_pkginfo_h handle, void *user_data)
+{
+ int ret = -1;
+ char *pkgid;
+
+ int size = 0;
+
+ ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
+ if(ret < 0) {
+ printf("pkgmgr_pkginfo_get_pkgid() failed\n");
+ }
+
+ __get_total_size(pkgid, &size);
+
+ _LOGD("pkg=[%s], size=[%d]\n", pkgid, size);
+
+ return 0;
}
int main(int argc, char *argv[])
{
int ret = 0;
+ int size = 0;
+ int get_type = 0;
+ char *pkgid = NULL;
- ret = _pkg_getsize(argc, argv);
- if (ret < 0) {
- _LOGE("_pkg_getsize failed \n");
- return -1;
+ pkgid = argv[0];
+ get_type = atoi(argv[1]);
+
+ if (get_type == PM_GET_TOTAL_SIZE) {
+ ret = __get_total_size(pkgid, &size);
+ } else if(get_type == PM_GET_DATA_SIZE) {
+ ret = __get_data_size(pkgid, &size);
+ } else if(get_type == PM_GET_ALL_PKGS) {
+ ret = pkgmgrinfo_pkginfo_get_list(__pkg_list_cb, NULL);
}
+ if (ret < 0)
+ _LOGD("_pkg_getsize fail \n");
+ else
+ _LOGD("_pkg_getsize success \n");
- _LOGE("_pkg_getsize success \n");
+ vconf_set_int(VCONFKEY_PKGMGR_STATUS, size);
return 0;
}
static int __get_app_category_list(char *appid);
static int __get_app_metadata_list(char *appid);
static int __get_app_control_list(char *appid);
-static int __get_app_visibility(char *appid);
-static int __set_app_visibility(char *appid);
static int __get_pkg_list(void);
static int __get_installed_app_list();
static int __add_app_filter(void);
printf("\tpkginfo --pkg-flt\n\n");
printf("To add metadata filter values\n");
printf("\tpkginfo --metadata-flt\n\n");
- printf("To get guest mode visibility of a particular application\n");
- printf("\tpkginfo --getvisibility <appid>\n\n");
- printf("To set guest mode visibility of a particular application\n");
- printf("\tpkginfo --setvisibility <appid>\n\n");
}
static void __print_arg_filter_usage()
return 0;
}
+static int __fota_insert_manifest_in_db(char *manifest)
+{
+ int ret = 0;
+ char *temp[] = {"fota=true", NULL};
+
+ if (manifest == NULL) {
+ printf("Manifest file is NULL\n");
+ return -1;
+ }
+ ret = pkgmgr_parser_parse_manifest_for_installation(manifest, temp);
+ if (ret < 0) {
+ printf("insert in db failed\n");
+ return -1;
+ }
+ return 0;
+}
+
static int __remove_manifest_from_db(char *manifest)
{
int ret = 0;
return 0;
}
-static int __get_app_visibility(char *appid)
-{
- int ret = -1;
- bool status = true;
- pkgmgr_appinfo_h handle;
- ret = pkgmgr_appinfo_get_appinfo(appid, &handle);
- if (ret < 0) {
- printf("Failed to get handle\n");
- return -1;
- }
- ret = pkgmgrinfo_appinfo_is_guestmode_visibility(handle, &status);
- if (ret < 0) {
- printf("pkgmgrinfo_appinfo_is_guestmode_visibility failed\n");
- pkgmgr_appinfo_destroy_appinfo(handle);
- return -1;
- }
- pkgmgr_appinfo_destroy_appinfo(handle);
- printf("visibility Status is %d\n",status);
- return status;
-}
-
-static int __set_app_visibility(char *appid)
-{
- int ret = 0;
- int value = 0;
- pkgmgrinfo_appinfo_h handle;
- printf("Enter [0/1]: 0--Hide, 1-Show\n");
- value = __get_integer_input_data();
- ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
- if (ret != PMINFO_R_OK)
- return -1;
- ret = pkgmgrinfo_appinfo_set_guestmode_visibility(handle, value);
- if (ret != PMINFO_R_OK) {
- pkgmgrinfo_appinfo_destroy_appinfo(handle);
- return -1;
- }
- pkgmgrinfo_appinfo_destroy_appinfo(handle);
- return 0;
-}
-
static int __set_app_enabled(char *appid, bool enabled)
{
int ret = -1;
printf("insert in db failed\n");
goto end;
}
+ } else if (strcmp(argv[1], "--fota") == 0) {
+ ret = __fota_insert_manifest_in_db(argv[2]);
+ if (ret == -1) {
+ printf("insert in db failed\n");
+ goto end;
+ }
} else if (strcmp(argv[1], "--rmd") == 0) {
ret = __remove_manifest_from_db(argv[2]);
if (ret == -1) {
printf("get app control list failed\n");
goto end;
}
- } else if (strcmp(argv[1], "--getvisibility") == 0) {
- ret = __get_app_visibility(argv[2]);
- if (ret == -1) {
- printf("get app visibility failed\n");
- goto end;
- }
- } else if (strcmp(argv[1], "--setvisibility") == 0) {
- ret = __set_app_visibility(argv[2]);
- if (ret == -1) {
- printf("set app visibility failed\n");
- goto end;
- }
} else
__print_usage();
int ret;
char buf[BUFSZE];
int total_cnt = 0;
-// int ok_cnt = 0;
+ int ok_cnt = 0;
// desktop file
dir = opendir(directory);
#!/bin/sh
#
-_pkg_recovery_path="/opt/share/packages/.recovery"
-_pkg_recovery_file="/opt/share/packages/.recovery/*"
+_pkg_recovery_path="/opt/share/packages/.recovery/pkgmgr"
+_pkg_recovery_file="/opt/share/packages/.recovery/pkgmgr/*"
FILE_LIST=`ls $_pkg_recovery_path`
if [ -n "$FILE_LIST" ]; then
echo "There are packages to recovery"
- /usr/bin/wrt-installer -v
- /usr/bin/osp-installer -v
+ /usr/bin/wrt-installer -b
+ /usr/bin/osp-installer -b
echo "delete recovery files"
rm $_pkg_recovery_file
else
snprintf(dirpath, BUFF_SIZE, "/opt/usr/apps/%s/shared/res", pkgname);
if (__is_dir(dirpath))
- __pkg_smack_change_smack_label(dirpath, "_", 0);/*0 is SMACK_LABEL_ACCESS*/
+ __pkg_smack_setup_path(pkgname, dirpath, RPM_PATH_ANY_LABEL, "_");
memset(dirpath, '\0', BUFF_SIZE);
/*/shared/data dir. setup path and change group to 'app'*/
projects / framework / appfw / slp-pkgmgr.git / commitdiff