src/package_manager.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <dlog.h>
  20
  21 #include <package-manager.h>
  22 #include <package_manager.h>
  23 #include <package_manager_private.h>
  24 #include <pkgmgr-info.h>
  25
  26
  27 #ifdef LOG_TAG
  28 #undef LOG_TAG
  29 #endif
  30
  31 #define LOG_TAG "CAPI_APPFW_PACKAGE_MANAGER"
  32
  33 #define _LOGE(fmt, arg...) LOGE(fmt,##arg)
  34 #define _LOGD(fmt, arg...) LOGD(fmt, ##arg)
  35
  36 typedef struct _event_info {
  37         int req_id;
  38         package_manager_event_type_e event_type;
  39         package_manager_event_state_e event_state;
  40         struct _event_info *next;
  41 } event_info;
  42
  43 struct package_manager_s {
  44         int handle_id;
  45         client_type ctype;
  46         pkgmgr_client *pc;
  47         pkgmgr_mode mode;
  48         event_info *head;
  49         package_manager_event_cb event_cb;
  50         void *user_data;
  51 };
  52
  53 struct package_manager_request_s {
  54         int handle_id;
  55         client_type ctype;
  56         pkgmgr_client *pc;
  57         const char *pkg_type;
  58         const char *pkg_path;
  59         const char *pkg_name;
  60         pkgmgr_mode mode;
  61         event_info *head;
  62         package_manager_request_event_cb event_cb;
  63         void *user_data;
  64 };
  65
  66 static int package_manager_request_new_id()
  67 {
  68         static int request_handle_id = 0;
  69         return request_handle_id++;
  70 }
  71
  72 static int package_manager_new_id()
  73 {
  74         static int manager_handle_id = 0;
  75         return manager_handle_id++;
  76 }
  77
  78 static const char *package_manager_error_to_string(package_manager_error_e
  79                                                    error)
  80 {
  81         switch (error) {
  82         case PACKAGE_MANAGER_ERROR_NONE:
  83                 return "NONE";
  84
  85         case PACKAGE_MANAGER_ERROR_INVALID_PARAMETER:
  86                 return "INVALID_PARAMETER";
  87
  88         case PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY:
  89                 return "OUT_OF_MEMORY";
  90
  91         case PACKAGE_MANAGER_ERROR_IO_ERROR:
  92                 return "IO_ERROR";
  93         default:
  94                 return "UNKNOWN";
  95         }
  96 }
  97
  98 int package_manager_error(package_manager_error_e error,
  99                                  const char *function, const char *description)
 100 {
 101         if (description) {
 102                 _LOGE("[%s] %s(0x%08x) : %s", function,
 103                      package_manager_error_to_string(error), error,
 104                      description);
 105         } else {
 106                 _LOGE("[%s] %s(0x%08x)", function,
 107                      package_manager_error_to_string(error), error);
 108         }
 109
 110         return error;
 111 }
 112
 113 int package_manager_request_create(package_manager_request_h * request)
 114 {
 115         struct package_manager_request_s *package_manager_request;
 116
 117         if (request == NULL) {
 118                 return
 119                     package_manager_error
 120                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 121                      NULL);
 122         }
 123
 124         package_manager_request =
 125             calloc(1, sizeof(struct package_manager_request_s));
 126         if (package_manager_request == NULL) {
 127                 return
 128                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 129                                           __FUNCTION__,
 130                                           "failed to create a package_manager handle");
 131         }
 132
 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);
 137                 return
 138                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 139                                           __FUNCTION__,
 140                                           "failed to create a package_manager client");
 141         }
 142
 143         package_manager_request->handle_id = package_manager_request_new_id();
 144
 145         *request = package_manager_request;
 146
 147         return PACKAGE_MANAGER_ERROR_NONE;
 148 }
 149
 150 static int package_manager_client_valiate_handle(package_manager_request_h
 151                                                  request)
 152 {
 153         if (request == NULL || request->pc == NULL) {
 154                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 155         }
 156
 157         return PACKAGE_MANAGER_ERROR_NONE;
 158 }
 159
 160 int package_manager_client_destroy(package_manager_request_h request)
 161 {
 162         if (package_manager_client_valiate_handle(request)) {
 163                 return
 164                     package_manager_error
 165                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 166                      NULL);
 167         }
 168
 169         pkgmgr_client_free(request->pc);
 170         request->pc = NULL;
 171         free(request);
 172
 173         return PACKAGE_MANAGER_ERROR_NONE;
 174 }
 175
 176 int package_manager_request_destroy(package_manager_request_h request)
 177 {
 178         if (package_manager_client_valiate_handle(request)) {
 179                 return
 180                     package_manager_error
 181                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 182                      NULL);
 183         }
 184
 185         pkgmgr_client_free(request->pc);
 186         request->pc = NULL;
 187         free(request);
 188
 189         return PACKAGE_MANAGER_ERROR_NONE;
 190 }
 191
 192 int package_manager_request_set_event_cb(package_manager_request_h request,
 193                                          package_manager_request_event_cb
 194                                          callback, void *user_data)
 195 {
 196         if (package_manager_client_valiate_handle(request)) {
 197                 return
 198                     package_manager_error
 199                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 200                      NULL);
 201         }
 202
 203         request->event_cb = callback;
 204         request->user_data = user_data;
 205
 206         return PACKAGE_MANAGER_ERROR_NONE;
 207 }
 208
 209 int package_manager_request_unset_event_cb(package_manager_request_h request)
 210 {
 211         // TODO: Please implement this function.
 212         return PACKAGE_MANAGER_ERROR_NONE;
 213 }
 214
 215
 216 int package_manager_request_set_type(package_manager_request_h request,
 217                                      const char *pkg_type)
 218 {
 219         if (package_manager_client_valiate_handle(request)) {
 220                 return
 221                     package_manager_error
 222                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 223                      NULL);
 224         }
 225
 226         request->pkg_type = pkg_type;
 227
 228         return PACKAGE_MANAGER_ERROR_NONE;
 229 }
 230
 231 int package_manager_request_set_mode(package_manager_request_h request,
 232                                      package_manager_request_mode_e mode)
 233 {
 234         if (package_manager_client_valiate_handle(request)) {
 235                 return
 236                     package_manager_error
 237                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 238                      NULL);
 239         }
 240
 241         if (mode == PACKAGE_MANAGER_REQUEST_MODE_QUIET)
 242                 request->mode = PM_QUIET;
 243         else
 244                 request->mode = PM_DEFAULT;
 245
 246         return PACKAGE_MANAGER_ERROR_NONE;
 247 }
 248
 249 static int package_manager_get_event_type(const char *key,
 250                                           package_manager_event_type_e *
 251                                           event_type)
 252 {
 253         if (key == NULL)
 254                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 255
 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;
 262         else
 263                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 264
 265         return PACKAGE_MANAGER_ERROR_NONE;
 266 }
 267
 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)
 271 {
 272         event_info *evt_info;
 273         event_info *current;
 274         event_info *prev;
 275
 276         evt_info = (event_info *) calloc(1, sizeof(event_info));
 277         if (evt_info == NULL) {
 278                 _LOGD("calloc failed");
 279                 return -1;
 280         }
 281         evt_info->req_id = req_id;
 282         evt_info->event_type = event_type;
 283         evt_info->next = NULL;
 284
 285         if (*head == NULL)
 286                 *head = evt_info;
 287         else {
 288                 current = prev = *head;
 289                 while (current) {
 290                         prev = current;
 291                         current = current->next;
 292                 }
 293
 294                 prev->next = evt_info;
 295         }
 296
 297         return 0;
 298 }
 299
 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)
 303 {
 304         event_info *tmp;
 305
 306         tmp = *head;
 307
 308         if (tmp == NULL) {
 309                 _LOGE("tmp is NULL");
 310                 return -1;
 311         }
 312
 313         _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
 314
 315         while (tmp) {
 316                 if (tmp->req_id == req_id) {
 317                         *event_type = tmp->event_type;
 318                         return 0;
 319                 }
 320                 tmp = tmp->next;
 321         }
 322         return -1;
 323 }
 324
 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)
 328 {
 329         package_manager_event_type_e evt_type;
 330         package_manager_event_state_e evt_state;
 331         event_info *tmp;
 332
 333         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 334                 __add_event_info(head, req_id, event_type, event_state);
 335         else {
 336                 tmp = *head;
 337
 338                 if (tmp == NULL) {
 339                         _LOGE("tmp is NULL");
 340                         return -1;
 341                 }
 342
 343                 while (tmp) {
 344                         if (tmp->req_id == req_id) {
 345                                 tmp->event_type = event_type;
 346                                 return 0;
 347                         }
 348                         tmp = tmp->next;
 349                 }
 350         }
 351
 352         return -1;
 353 }
 354
 355 /*
 356 static int __remove_event_info(event_info **head request, int req_id)
 357 {
 358         event_info *current;
 359         event_info *tmp;
 360
 361         if (* == NULL)
 362                 return -1;
 363
 364         current = *head;
 365         while (current) {
 366                 if (current->next) {
 367                         if (current->next->req_id == req_id) {
 368                                 tmp = current->next;
 369                                 current->next = current->next->next;
 370                                 free(tmp);
 371                                 return 0;
 372                         }
 373                 }
 374                 tmp = tmp->next;
 375         }
 376
 377         return -1;
 378 }
 379 */
 380
 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)
 384 {
 385         int ret = -1;
 386         package_manager_event_type_e event_type = -1;
 387         package_manager_event_state_e event_state = -1;
 388
 389         _LOGD("request_event_handler is called");
 390
 391         package_manager_request_h request = data;
 392
 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;
 397
 398                 __add_event_info(&(request->head), req_id, event_type,
 399                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 400
 401                 if (request->event_cb)
 402                         request->event_cb(req_id, pkg_type, pkg_name,
 403                                           event_type,
 404                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 405                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 406
 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,
 413                                             event_type,
 414                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 415                         if (request->event_cb)
 416                                 request->event_cb(req_id, pkg_type, pkg_name,
 417                                                   event_type,
 418                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 419                                                   atoi(val),
 420                                                   PACKAGE_MANAGER_ERROR_NONE,
 421                                                   request->user_data);
 422                 }
 423
 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,
 430                                                     event_type,
 431                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 432                         }
 433
 434                         if (request->event_cb)
 435                                 request->event_cb(req_id, pkg_type,
 436                                                   pkg_name, event_type,
 437                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 438                                                   0,
 439                                                   PACKAGE_MANAGER_ERROR_NONE,
 440                                                   request->user_data);
 441
 442                 }
 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,
 452                                                           100,
 453                                                           PACKAGE_MANAGER_ERROR_NONE,
 454                                                           request->user_data);
 455                         }
 456                 } else {
 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,
 462                                                           0,
 463                                                           PACKAGE_MANAGER_ERROR_NONE,
 464                                                           request->user_data);
 465                 }
 466         }
 467
 468         return PACKAGE_MANAGER_ERROR_NONE;
 469 }
 470
 471 int package_manager_request_install(package_manager_request_h request,
 472                                     const char *path, int *id)
 473 {
 474         int request_id = 0;
 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,
 479                                            request);
 480
 481         if (request_id < 0)
 482                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 483
 484         *id = request_id;
 485
 486         return PACKAGE_MANAGER_ERROR_NONE;
 487 }
 488
 489 int package_manager_request_uninstall(package_manager_request_h request,
 490                                       const char *name, int *id)
 491 {
 492         int request_id = 0;
 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);
 497
 498         if (request_id < 0)
 499                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 500
 501         *id = request_id;
 502
 503         return PACKAGE_MANAGER_ERROR_NONE;
 504 }
 505
 506 int package_manager_request_move(package_manager_request_h request,
 507                                     const char *name, package_manager_move_type_e move_type)
 508 {
 509         int ret = 0;
 510         request->pkg_name = name;
 511         ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 512                                            move_type, request->mode);
 513
 514         if (ret < 0)
 515         {
 516                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 517         }
 518         else
 519         {
 520                 return PACKAGE_MANAGER_ERROR_NONE;
 521         }
 522 }
 523 int package_manager_create(package_manager_h * manager)
 524 {
 525         struct package_manager_s *package_manager = NULL;
 526
 527         if (manager == NULL) {
 528                 return
 529                     package_manager_error
 530                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 531                      NULL);
 532         }
 533
 534         package_manager = calloc(1, sizeof(struct package_manager_s));
 535         if (package_manager == NULL) {
 536                 return
 537                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 538                                           __FUNCTION__,
 539                                           "failed to create a package_manager handle");
 540         }
 541
 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);
 546                 return
 547                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 548                                           __FUNCTION__,
 549                                           "failed to create a package_manager client");
 550         }
 551
 552         package_manager->handle_id = package_manager_new_id();
 553
 554         *manager = package_manager;
 555
 556         return PACKAGE_MANAGER_ERROR_NONE;
 557 }
 558
 559 static int package_manager_valiate_handle(package_manager_h manager)
 560 {
 561         if (manager == NULL || manager->pc == NULL) {
 562                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 563         }
 564
 565         return PACKAGE_MANAGER_ERROR_NONE;
 566 }
 567
 568 int package_manager_destroy(package_manager_h manager)
 569 {
 570         if (package_manager_valiate_handle(manager)) {
 571                 return
 572                     package_manager_error
 573                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 574                      NULL);
 575         }
 576
 577         pkgmgr_client_free(manager->pc);
 578         manager->pc = NULL;
 579         free(manager);
 580
 581         return PACKAGE_MANAGER_ERROR_NONE;
 582 }
 583
 584 static int global_event_handler(int req_id, const char *pkg_type,
 585                                 const char *pkg_name, const char *key,
 586                                 const char *val, const void *pmsg, void *data)
 587 {
 588         int ret = -1;
 589         package_manager_event_type_e event_type = -1;
 590         package_manager_event_state_e event_state = -1;
 591
 592         _LOGD("global_event_handler is called");
 593
 594         package_manager_h manager = data;
 595
 596         if (strcasecmp(key, "start") == 0) {
 597                 ret = package_manager_get_event_type(val, &event_type);
 598                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 599                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 600
 601                 __add_event_info(&(manager->head), req_id, event_type,
 602                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 603
 604                 if (manager->event_cb)
 605                         manager->event_cb(pkg_type, pkg_name,
 606                                           event_type,
 607                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 608                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 609
 610         } else if (strcasecmp(key, "install_percent") == 0
 611                    || strcasecmp(key, "progress_percent") == 0) {
 612                 if (__find_event_info
 613                     (&(manager->head), req_id, &event_type,
 614                      &event_state) == 0) {
 615                         __update_event_info(&(manager->head), req_id,
 616                                             event_type,
 617                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 618                         if (manager->event_cb)
 619                                 manager->event_cb(pkg_type, pkg_name,
 620                                                   event_type,
 621                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 622                                                   atoi(val),
 623                                                   PACKAGE_MANAGER_ERROR_NONE,
 624                                                   manager->user_data);
 625                 }
 626
 627         } else if (strcasecmp(key, "error") == 0) {
 628                 if (strcasecmp(key, "0") != 0) {
 629                         if (__find_event_info
 630                             (&(manager->head), req_id, &event_type,
 631                              &event_state) == 0) {
 632                                 __update_event_info(&(manager->head), req_id,
 633                                                     event_type,
 634                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 635                         }
 636
 637                         if (manager->event_cb)
 638                                 manager->event_cb(pkg_type,
 639                                                   pkg_name, event_type,
 640                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 641                                                   0,
 642                                                   PACKAGE_MANAGER_ERROR_NONE,
 643                                                   manager->user_data);
 644
 645                 }
 646         } else if (strcasecmp(key, "end") == 0) {
 647                 if (__find_event_info
 648                     (&(manager->head), req_id, &event_type,
 649                      &event_state) == 0) {
 650                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 651                                 if (manager->event_cb)
 652                                         manager->event_cb(pkg_type,
 653                                                           pkg_name, event_type,
 654                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 655                                                           100,
 656                                                           PACKAGE_MANAGER_ERROR_NONE,
 657                                                           manager->user_data);
 658                         }
 659                 } else {
 660                         if (strcasecmp(key, "ok") != 0)
 661                                 if (manager->event_cb)
 662                                         manager->event_cb(pkg_type,
 663                                                           pkg_name, event_type,
 664                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 665                                                           0,
 666                                                           PACKAGE_MANAGER_ERROR_NONE,
 667                                                           manager->user_data);
 668                 }
 669         }
 670
 671         return PACKAGE_MANAGER_ERROR_NONE;
 672 }
 673
 674 int package_manager_set_event_cb(package_manager_h manager,
 675                                  package_manager_event_cb callback,
 676                                  void *user_data)
 677 {
 678         int ret = 0;
 679         if (package_manager_valiate_handle(manager)) {
 680                 return
 681                     package_manager_error
 682                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 683                      NULL);
 684         }
 685
 686         manager->event_cb = callback;
 687         manager->user_data = user_data;
 688
 689         ret =
 690             pkgmgr_client_listen_status(manager->pc, global_event_handler,
 691                                         manager);
 692
 693         return PACKAGE_MANAGER_ERROR_NONE;
 694 }
 695
 696 int package_manager_unset_event_cb(package_manager_h manager)
 697 {
 698         // TODO: Please implement this function.
 699         return PACKAGE_MANAGER_ERROR_NONE;
 700 }
 701
 702 int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 703 {
 704         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 705         int retval;
 706         char *pkg_id = NULL;
 707         char *pkg_id_dup = NULL;
 708
 709         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 710         {
 711                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 712         }
 713
 714         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 715         if (retval != PMINFO_R_OK)
 716         {
 717                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 718         }
 719
 720         pkg_id_dup = strdup(pkg_id);
 721         if (pkg_id_dup == NULL)
 722         {
 723                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 724                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 725         }
 726
 727         *package_id = pkg_id_dup;
 728
 729         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 730
 731         return PACKAGE_MANAGER_ERROR_NONE;
 732 }
 733
 734 int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 735 {
 736         int retval;
 737
 738         retval = package_info_get_package_info(package_id, package_info);
 739
 740         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 741         {
 742                 return package_manager_error(retval, __FUNCTION__, NULL);
 743         }
 744         else
 745         {
 746                 return PACKAGE_MANAGER_ERROR_NONE;
 747         }
 748 }
 749
 750 int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 751                                         void *user_data)
 752 {
 753         int retval;
 754
 755         retval = package_info_foreach_package_info(callback, user_data);
 756
 757         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 758         {
 759                 return package_manager_error(retval, __FUNCTION__, NULL);
 760         }
 761         else
 762         {
 763                 return PACKAGE_MANAGER_ERROR_NONE;
 764         }
 765 }
 766 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)
 767 {
 768         pkgmgrinfo_cert_compare_result_type_e result;
 769
 770         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 771         {
 772                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 773         }
 774
 775         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 776         {
 777                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 778         }
 779
 780         *compare_result = (package_manager_compare_result_type_e)result;
 781
 782         return PACKAGE_MANAGER_ERROR_NONE;
 783 }
 784
 785 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)
 786 {
 787         pkgmgrinfo_cert_compare_result_type_e result;
 788
 789         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
 790         {
 791                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 792         }
 793
 794         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
 795         {
 796                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 797         }
 798
 799         *compare_result = (package_manager_compare_result_type_e)result;
 800
 801         return PACKAGE_MANAGER_ERROR_NONE;
 802 }
 803
 804 int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
 805 {
 806         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 807         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
 808
 809         int retval =0;
 810         char *pkg_id = NULL;
 811         bool is_preload = 0;
 812
 813         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 814         {
 815                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 816         }
 817
 818         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 819         if (retval != PMINFO_R_OK)
 820         {
 821                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 822                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 823         }
 824
 825         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
 826         {
 827                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 828                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 829                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 830         }
 831
 832         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK)
 833         {
 834                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 835                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 836                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 837         }
 838
 839         if (is_preload)
 840                 *preload = 1;
 841         else
 842                 *preload = 0;
 843
 844         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 845         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 846
 847         return PACKAGE_MANAGER_ERROR_NONE;
 848 }
 849
 850 int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
 851 {
 852         int retval = 0;
 853         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo =NULL;
 854         pkgmgrinfo_permission_type permission = 0;
 855
 856         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 857         {
 858                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 859         }
 860
 861         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
 862         if (retval != PMINFO_R_OK)
 863         {
 864                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 865         }
 866
 867         if (permission == PMINFO_PERMISSION_NORMAL)
 868                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
 869         else if (permission == PMINFO_PERMISSION_SIGNATURE)
 870                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
 871         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
 872                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
 873         else
 874                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
 875
 876         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 877         return PACKAGE_MANAGER_ERROR_NONE;
 878 }