2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <package-manager.h>
22 #include <package_manager.h>
23 #include <package_manager_private.h>
24 #include <pkgmgr-info.h>
31 #define LOG_TAG "CAPI_APPFW_PACKAGE_MANAGER"
33 #define _LOGE(fmt, arg...) LOGE(fmt,##arg)
34 #define _LOGD(fmt, arg...) LOGD(fmt, ##arg)
36 typedef struct _event_info {
38 package_manager_event_type_e event_type;
39 package_manager_event_state_e event_state;
40 struct _event_info *next;
43 struct package_manager_s {
49 package_manager_event_cb event_cb;
53 struct package_manager_request_s {
62 package_manager_request_event_cb event_cb;
66 static int package_manager_request_new_id()
68 static int request_handle_id = 0;
69 return request_handle_id++;
72 static int package_manager_new_id()
74 static int manager_handle_id = 0;
75 return manager_handle_id++;
78 static const char *package_manager_error_to_string(package_manager_error_e
82 case PACKAGE_MANAGER_ERROR_NONE:
85 case PACKAGE_MANAGER_ERROR_INVALID_PARAMETER:
86 return "INVALID_PARAMETER";
88 case PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY:
89 return "OUT_OF_MEMORY";
91 case PACKAGE_MANAGER_ERROR_IO_ERROR:
98 int package_manager_error(package_manager_error_e error,
99 const char *function, const char *description)
102 _LOGE("[%s] %s(0x%08x) : %s", function,
103 package_manager_error_to_string(error), error,
106 _LOGE("[%s] %s(0x%08x)", function,
107 package_manager_error_to_string(error), error);
113 int package_manager_request_create(package_manager_request_h * request)
115 struct package_manager_request_s *package_manager_request;
117 if (request == NULL) {
119 package_manager_error
120 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
124 package_manager_request =
125 calloc(1, sizeof(struct package_manager_request_s));
126 if (package_manager_request == NULL) {
128 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
130 "failed to create a package_manager handle");
133 package_manager_request->ctype = PC_REQUEST;
134 package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
135 if (package_manager_request->pc == NULL) {
136 free(package_manager_request);
138 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
140 "failed to create a package_manager client");
143 package_manager_request->handle_id = package_manager_request_new_id();
145 *request = package_manager_request;
147 return PACKAGE_MANAGER_ERROR_NONE;
150 static int package_manager_client_valiate_handle(package_manager_request_h
153 if (request == NULL || request->pc == NULL) {
154 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
157 return PACKAGE_MANAGER_ERROR_NONE;
160 int package_manager_client_destroy(package_manager_request_h request)
162 if (package_manager_client_valiate_handle(request)) {
164 package_manager_error
165 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
169 pkgmgr_client_free(request->pc);
173 return PACKAGE_MANAGER_ERROR_NONE;
176 int package_manager_request_destroy(package_manager_request_h request)
178 if (package_manager_client_valiate_handle(request)) {
180 package_manager_error
181 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
185 pkgmgr_client_free(request->pc);
189 return PACKAGE_MANAGER_ERROR_NONE;
192 int package_manager_request_set_event_cb(package_manager_request_h request,
193 package_manager_request_event_cb
194 callback, void *user_data)
196 if (package_manager_client_valiate_handle(request)) {
198 package_manager_error
199 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
203 request->event_cb = callback;
204 request->user_data = user_data;
206 return PACKAGE_MANAGER_ERROR_NONE;
209 int package_manager_request_unset_event_cb(package_manager_request_h request)
211 // TODO: Please implement this function.
212 return PACKAGE_MANAGER_ERROR_NONE;
216 int package_manager_request_set_type(package_manager_request_h request,
217 const char *pkg_type)
219 if (package_manager_client_valiate_handle(request)) {
221 package_manager_error
222 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
226 request->pkg_type = pkg_type;
228 return PACKAGE_MANAGER_ERROR_NONE;
231 int package_manager_request_set_mode(package_manager_request_h request,
232 package_manager_request_mode_e mode)
234 if (package_manager_client_valiate_handle(request)) {
236 package_manager_error
237 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
241 if (mode == PACKAGE_MANAGER_REQUEST_MODE_QUIET)
242 request->mode = PM_QUIET;
244 request->mode = PM_DEFAULT;
246 return PACKAGE_MANAGER_ERROR_NONE;
249 static int package_manager_get_event_type(const char *key,
250 package_manager_event_type_e *
254 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
256 if (strcasecmp(key, "install") == 0)
257 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
258 else if (strcasecmp(key, "uninstall") == 0)
259 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
260 else if (strcasecmp(key, "update") == 0)
261 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
263 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
265 return PACKAGE_MANAGER_ERROR_NONE;
268 static int __add_event_info(event_info ** head, int req_id,
269 package_manager_event_type_e event_type,
270 package_manager_event_state_e event_state)
272 event_info *evt_info;
276 evt_info = (event_info *) calloc(1, sizeof(event_info));
277 if (evt_info == NULL) {
278 _LOGD("calloc failed");
281 evt_info->req_id = req_id;
282 evt_info->event_type = event_type;
283 evt_info->next = NULL;
288 current = prev = *head;
291 current = current->next;
294 prev->next = evt_info;
300 static int __find_event_info(event_info ** head, int req_id,
301 package_manager_event_type_e * event_type,
302 package_manager_event_state_e * event_state)
309 _LOGE("tmp is NULL");
313 _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
316 if (tmp->req_id == req_id) {
317 *event_type = tmp->event_type;
325 static int __update_event_info(event_info ** head, int req_id,
326 package_manager_event_type_e event_type,
327 package_manager_event_state_e event_state)
329 package_manager_event_type_e evt_type;
330 package_manager_event_state_e evt_state;
333 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
334 __add_event_info(head, req_id, event_type, event_state);
339 _LOGE("tmp is NULL");
344 if (tmp->req_id == req_id) {
345 tmp->event_type = event_type;
356 static int __remove_event_info(event_info **head request, int req_id)
367 if (current->next->req_id == req_id) {
369 current->next = current->next->next;
381 static int request_event_handler(int req_id, const char *pkg_type,
382 const char *pkg_name, const char *key,
383 const char *val, const void *pmsg, void *data)
386 package_manager_event_type_e event_type = -1;
387 package_manager_event_state_e event_state = -1;
389 _LOGD("request_event_handler is called");
391 package_manager_request_h request = data;
393 if (strcasecmp(key, "start") == 0) {
394 ret = package_manager_get_event_type(val, &event_type);
395 if (ret != PACKAGE_MANAGER_ERROR_NONE)
396 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
398 __add_event_info(&(request->head), req_id, event_type,
399 PACKAGE_MANAGER_EVENT_STATE_STARTED);
401 if (request->event_cb)
402 request->event_cb(req_id, pkg_type, pkg_name,
404 PACKAGE_MANAGER_EVENT_STATE_STARTED,
405 0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
407 } else if (strcasecmp(key, "install_percent") == 0
408 || strcasecmp(key, "progress_percent") == 0) {
409 if (__find_event_info
410 (&(request->head), req_id, &event_type,
411 &event_state) == 0) {
412 __update_event_info(&(request->head), req_id,
414 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
415 if (request->event_cb)
416 request->event_cb(req_id, pkg_type, pkg_name,
418 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
420 PACKAGE_MANAGER_ERROR_NONE,
424 } else if (strcasecmp(key, "error") == 0) {
425 if (strcasecmp(key, "0") != 0) {
426 if (__find_event_info
427 (&(request->head), req_id, &event_type,
428 &event_state) == 0) {
429 __update_event_info(&(request->head), req_id,
431 PACKAGE_MANAGER_EVENT_STATE_FAILED);
434 if (request->event_cb)
435 request->event_cb(req_id, pkg_type,
436 pkg_name, event_type,
437 PACKAGE_MANAGER_EVENT_STATE_FAILED,
439 PACKAGE_MANAGER_ERROR_NONE,
443 } else if (strcasecmp(key, "end") == 0) {
444 if (__find_event_info
445 (&(request->head), req_id, &event_type,
446 &event_state) == 0) {
447 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
448 if (request->event_cb)
449 request->event_cb(req_id, pkg_type,
450 pkg_name, event_type,
451 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
453 PACKAGE_MANAGER_ERROR_NONE,
457 if (strcasecmp(key, "ok") != 0)
458 if (request->event_cb)
459 request->event_cb(req_id, pkg_type,
460 pkg_name, event_type,
461 PACKAGE_MANAGER_EVENT_STATE_FAILED,
463 PACKAGE_MANAGER_ERROR_NONE,
468 return PACKAGE_MANAGER_ERROR_NONE;
471 int package_manager_request_install(package_manager_request_h request,
472 const char *path, int *id)
475 request->pkg_path = path;
476 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
477 request->pkg_path, NULL,
478 request->mode, request_event_handler,
482 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
486 return PACKAGE_MANAGER_ERROR_NONE;
489 int package_manager_request_uninstall(package_manager_request_h request,
490 const char *name, int *id)
493 request->pkg_name = name;
494 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
495 request->pkg_name, request->mode,
496 request_event_handler, request);
499 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
503 return PACKAGE_MANAGER_ERROR_NONE;
506 int package_manager_request_move(package_manager_request_h request,
507 const char *name, package_manager_move_type_e move_type)
510 request->pkg_name = name;
511 ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
512 move_type, request->mode);
516 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
520 return PACKAGE_MANAGER_ERROR_NONE;
523 int package_manager_create(package_manager_h * manager)
525 struct package_manager_s *package_manager = NULL;
527 if (manager == NULL) {
529 package_manager_error
530 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
534 package_manager = calloc(1, sizeof(struct package_manager_s));
535 if (package_manager == NULL) {
537 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
539 "failed to create a package_manager handle");
542 package_manager->ctype = PC_LISTENING;
543 package_manager->pc = pkgmgr_client_new(PC_LISTENING);
544 if (package_manager->pc == NULL) {
545 free(package_manager);
547 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
549 "failed to create a package_manager client");
552 package_manager->handle_id = package_manager_new_id();
554 *manager = package_manager;
556 return PACKAGE_MANAGER_ERROR_NONE;
559 static int package_manager_valiate_handle(package_manager_h manager)
561 if (manager == NULL || manager->pc == NULL) {
562 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
565 return PACKAGE_MANAGER_ERROR_NONE;
568 int package_manager_destroy(package_manager_h manager)
570 if (package_manager_valiate_handle(manager)) {
572 package_manager_error
573 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
577 pkgmgr_client_free(manager->pc);
581 return PACKAGE_MANAGER_ERROR_NONE;
584 static int __add_event(event_info ** head, int req_id,
585 package_manager_event_type_e event_type,
586 package_manager_event_state_e event_state)
588 event_info *evt_info;
590 evt_info = (event_info *) calloc(1, sizeof(event_info));
591 if (evt_info == NULL) {
592 _LOGD("calloc failed");
595 evt_info->req_id = req_id;
596 evt_info->event_type = event_type;
597 evt_info->next = NULL;
604 static int __find_event(event_info ** head, int req_id,
605 package_manager_event_type_e * event_type,
606 package_manager_event_state_e * event_state)
613 _LOGE("tmp is NULL");
617 *event_type = tmp->event_type;
621 static int __update_event(event_info ** head, int req_id,
622 package_manager_event_type_e event_type,
623 package_manager_event_state_e event_state)
625 package_manager_event_type_e evt_type;
626 package_manager_event_state_e evt_state;
629 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
630 __add_event_info(head, req_id, event_type, event_state);
635 _LOGE("tmp is NULL");
639 tmp->event_type = event_type;
646 static int global_event_handler(int req_id, const char *pkg_type,
647 const char *pkg_name, const char *key,
648 const char *val, const void *pmsg, void *data)
651 package_manager_event_type_e event_type = -1;
652 package_manager_event_state_e event_state = -1;
654 _LOGD("global_event_handler is called");
656 package_manager_h manager = data;
658 if (strcasecmp(key, "start") == 0) {
659 ret = package_manager_get_event_type(val, &event_type);
660 if (ret != PACKAGE_MANAGER_ERROR_NONE)
661 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
663 __add_event(&(manager->head), req_id, event_type,
664 PACKAGE_MANAGER_EVENT_STATE_STARTED);
666 if (manager->event_cb)
667 manager->event_cb(pkg_type, pkg_name,
669 PACKAGE_MANAGER_EVENT_STATE_STARTED,
670 0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
672 } else if (strcasecmp(key, "install_percent") == 0
673 || strcasecmp(key, "progress_percent") == 0) {
675 (&(manager->head), req_id, &event_type,
676 &event_state) == 0) {
677 __update_event(&(manager->head), req_id,
679 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
680 if (manager->event_cb)
681 manager->event_cb(pkg_type, pkg_name,
683 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
685 PACKAGE_MANAGER_ERROR_NONE,
689 } else if (strcasecmp(key, "error") == 0) {
690 if (strcasecmp(key, "0") != 0) {
692 (&(manager->head), req_id, &event_type,
693 &event_state) == 0) {
694 __update_event(&(manager->head), req_id,
696 PACKAGE_MANAGER_EVENT_STATE_FAILED);
699 if (manager->event_cb)
700 manager->event_cb(pkg_type,
701 pkg_name, event_type,
702 PACKAGE_MANAGER_EVENT_STATE_FAILED,
704 PACKAGE_MANAGER_ERROR_NONE,
708 } else if (strcasecmp(key, "end") == 0) {
710 (&(manager->head), req_id, &event_type,
711 &event_state) == 0) {
712 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
713 if (manager->event_cb)
714 manager->event_cb(pkg_type,
715 pkg_name, event_type,
716 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
718 PACKAGE_MANAGER_ERROR_NONE,
722 if (strcasecmp(key, "ok") != 0)
723 if (manager->event_cb)
724 manager->event_cb(pkg_type,
725 pkg_name, event_type,
726 PACKAGE_MANAGER_EVENT_STATE_FAILED,
728 PACKAGE_MANAGER_ERROR_NONE,
733 return PACKAGE_MANAGER_ERROR_NONE;
736 int package_manager_set_event_cb(package_manager_h manager,
737 package_manager_event_cb callback,
741 if (package_manager_valiate_handle(manager)) {
743 package_manager_error
744 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
748 manager->event_cb = callback;
749 manager->user_data = user_data;
752 pkgmgr_client_listen_status(manager->pc, global_event_handler,
755 return PACKAGE_MANAGER_ERROR_NONE;
758 int package_manager_unset_event_cb(package_manager_h manager)
760 // TODO: Please implement this function.
761 return PACKAGE_MANAGER_ERROR_NONE;
764 int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
766 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
769 char *pkg_id_dup = NULL;
771 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
773 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
776 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
777 if (retval != PMINFO_R_OK)
779 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
782 pkg_id_dup = strdup(pkg_id);
783 if (pkg_id_dup == NULL)
785 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
786 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
789 *package_id = pkg_id_dup;
791 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
793 return PACKAGE_MANAGER_ERROR_NONE;
796 int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
800 retval = package_info_get_package_info(package_id, package_info);
802 if (retval != PACKAGE_MANAGER_ERROR_NONE)
804 return package_manager_error(retval, __FUNCTION__, NULL);
808 return PACKAGE_MANAGER_ERROR_NONE;
812 int package_manager_foreach_package_info(package_manager_package_info_cb callback,
817 retval = package_info_foreach_package_info(callback, user_data);
819 if (retval != PACKAGE_MANAGER_ERROR_NONE)
821 return package_manager_error(retval, __FUNCTION__, NULL);
825 return PACKAGE_MANAGER_ERROR_NONE;
828 int package_manager_compare_package_cert_info(const char *lhs_package_id, const char *rhs_package_id, package_manager_compare_result_type_e *compare_result)
830 pkgmgrinfo_cert_compare_result_type_e result;
832 if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
834 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
837 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
839 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
842 *compare_result = (package_manager_compare_result_type_e)result;
844 return PACKAGE_MANAGER_ERROR_NONE;
847 int package_manager_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, package_manager_compare_result_type_e *compare_result)
849 pkgmgrinfo_cert_compare_result_type_e result;
851 if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
853 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
856 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
858 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
861 *compare_result = (package_manager_compare_result_type_e)result;
863 return PACKAGE_MANAGER_ERROR_NONE;
866 int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
868 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
869 pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
875 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
877 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
880 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
881 if (retval != PMINFO_R_OK)
883 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
884 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
887 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
889 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
890 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
891 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
894 if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK)
896 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
897 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
898 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
906 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
907 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
909 return PACKAGE_MANAGER_ERROR_NONE;
912 int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
915 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo =NULL;
916 pkgmgrinfo_permission_type permission = 0;
918 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
920 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
923 retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
924 if (retval != PMINFO_R_OK)
926 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
929 if (permission == PMINFO_PERMISSION_NORMAL)
930 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
931 else if (permission == PMINFO_PERMISSION_SIGNATURE)
932 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
933 else if (permission == PMINFO_PERMISSION_PRIVILEGE)
934 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
936 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
938 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
939 return PACKAGE_MANAGER_ERROR_NONE;