include/pkgmgr-info.h

   1 /*
   2  * pkgmgr-info
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23
  24
  25
  26
  27 /**
  28  * @file                pkgmgr-info.h
  29  * @author              Sewook Park <sewook7.park@samsung.com>
  30  * @author              Shobhit Srivastava <shobhit.s@samsung.com>
  31  * @version             0.1
  32  * @brief               This file declares API of pkgmgr-info library
  33  *
  34  * @addtogroup          APPLICATION_FRAMEWORK
  35  * @{
  36  *
  37  * @defgroup            PackageManagerInfo
  38  * @section             Header Header file to include:
  39  * @code
  40  * #include             <pkgmgr-info.h>
  41  * @endcode
  42  *
  43  * @}
  44  */
  45
  46 #ifndef __PKG_INFO_H__
  47 #define __PKG_INFO_H__
  48
  49 #include <errno.h>
  50 #include <stdbool.h>
  51
  52 #ifdef __cplusplus
  53 extern "C" {
  54 #endif
  55
  56
  57 /**
  58  * @mainpage
  59  *
  60  * This is package information library
  61  *
  62  * Package Information Library is used to get package related information.\n
  63  * It uses the package manifest information database to get any package related information\n
  64  * It also provides API to set information in the package info database\n
  65  *
  66  */
  67
  68 /**
  69  * @file        pkgmgr-info.h
  70  * @brief       Package Information Library Header File
  71  *
  72  * Generated by    Sewook Park <sewook7.park@samsung.com>
  73  */
  74
  75
  76 /**
  77  * @brief A handle to insert certificate information
  78  */
  79 typedef void* pkgmgrinfo_instcertinfo_h;
  80
  81 /**
  82  * @brief Certificate Types to be used for setting information
  83  */
  84 typedef enum {
  85         PMINFO_SET_AUTHOR_ROOT_CERT = 0,                /**< Author Root Certificate*/
  86         PMINFO_SET_AUTHOR_INTERMEDIATE_CERT = 1,                /**< Author Intermediate Certificate*/
  87         PMINFO_SET_AUTHOR_SIGNER_CERT = 2,              /**< Author Signer Certificate*/
  88         PMINFO_SET_DISTRIBUTOR_ROOT_CERT = 3,           /**< Distributor Root Certificate*/
  89         PMINFO_SET_DISTRIBUTOR_INTERMEDIATE_CERT = 4,           /**< Distributor Intermediate Certificate*/
  90         PMINFO_SET_DISTRIBUTOR_SIGNER_CERT = 5,         /**< Distributor Signer Certificate*/
  91         PMINFO_SET_DISTRIBUTOR2_ROOT_CERT = 6,          /**< End Entity Root Certificate*/
  92         PMINFO_SET_DISTRIBUTOR2_INTERMEDIATE_CERT = 7,          /**< End Entity Intermediate Certificate*/
  93         PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT = 8,                /**< End Entity Signer Certificate*/
  94 }pkgmgrinfo_instcert_type;
  95
  96 typedef enum {
  97         PMINFO_CERT_COMPARE_MATCH,
  98         PMINFO_CERT_COMPARE_MISMATCH,
  99         PMINFO_CERT_COMPARE_LHS_NO_CERT,
 100         PMINFO_CERT_COMPARE_RHS_NO_CERT,
 101         PMINFO_CERT_COMPARE_BOTH_NO_CERT,
 102         PMINFO_CERT_COMPARE_ERROR,
 103 } pkgmgrinfo_cert_compare_result_type_e;
 104
 105 /**
 106  * @brief API return values
 107  */
 108 enum {
 109         PMINFO_R_EINVAL = -2,           /**< Invalid argument */
 110         PMINFO_R_ERROR = -1,            /**< General error */
 111         PMINFO_R_OK = 0                 /**< General success */
 112 };
 113
 114 /**
 115  * @brief Value to be used when filtering based on install location
 116  */
 117 #define PMINFO_PKGINFO_INSTALL_LOCATION_AUTO            "LOCATION_AUTO"
 118
 119 /**
 120  * @brief Value to be used when filtering based on install location
 121  */
 122 #define PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL        "LOCATION_INTERNAL"
 123
 124 /**
 125  * @brief Value to be used when filtering based on install location
 126  */
 127 #define PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL        "LOCATION_EXTERNAL"
 128
 129 /**
 130  * @brief Value to be used when filtering based on app-component
 131  */
 132 #define PMINFO_APPINFO_UI_APP                           "UI_APP"
 133
 134 /**
 135  * @brief Value to be used when filtering based on app-component
 136  */
 137 #define PMINFO_APPINFO_SVC_APP                          "SVC_APP"
 138
 139 typedef enum {
 140         PMINFO_HWACCELERATION_NOT_USE_GL = 0,           /**< Don't use hardware acceleration*/
 141         PMINFO_HWACCELERATION_USE_GL = 1,               /**< Use hardware acceleration*/
 142         PMINFO_HWACCELERATION_USE_SYSTEM_SETTING = 2            /**< Follow system setting for hardware acceleration */
 143 }pkgmgrinfo_app_hwacceleration;
 144
 145 typedef enum {
 146         PMINFO_RECENTIMAGE_USE_ICON = 0,                /**<Use icon for recent image*/
 147         PMINFO_RECENTIMAGE_USE_CAPTURE = 1,             /**< Use capture for recent image*/
 148         PMINFO_RECENTIMAGE_USE_NOTHING = 2              /**< Don't use recent image */
 149 }pkgmgrinfo_app_recentimage;
 150
 151 /**
 152  * @brief A handle to get package information
 153  */
 154 typedef void* pkgmgrinfo_pkginfo_h;
 155
 156 /**
 157  * @brief A handle to get application information
 158  */
 159 typedef void* pkgmgrinfo_appinfo_h;
 160
 161 /**
 162  * @brief A handle to get certificate information
 163  */
 164 typedef void* pkgmgrinfo_certinfo_h;
 165
 166 /**
 167  * @brief A handle to insert package information
 168  */
 169 typedef void* pkgmgrinfo_pkgdbinfo_h;
 170
 171 /**
 172  * @brief A handle to filter package information
 173  */
 174 typedef void* pkgmgrinfo_pkginfo_filter_h;
 175
 176 /**
 177  * @brief A handle to filter application information
 178  */
 179 typedef void* pkgmgrinfo_appinfo_filter_h;
 180
 181 /**
 182  * @brief A handle to filter application metadata  information
 183  */
 184 typedef void* pkgmgrinfo_appinfo_metadata_filter_h;
 185
 186 /**
 187  * @brief A handle to get appcontrol information
 188  */
 189 typedef void* pkgmgrinfo_appcontrol_h;
 190
 191 /**
 192  * @fn int (*pkgmgrinfo_pkg_list_cb ) (const pkgmgrinfo_pkginfo_h handle, void *user_data)
 193  *
 194  * @brief Specifies the type of function passed to pkgmgrinfo_pkginfo_get_list(), pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
 195  *
 196  * @param[in] handle the pkginfo handle
 197  * @param[in] user_data user data passed to pkgmgrinfo_pkginfo_get_list(), pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
 198  *
 199  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 200  *
 201  * @see  pkgmgrinfo_pkginfo_get_list()
 202  * @see  pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
 203  */
 204 typedef int (*pkgmgrinfo_pkg_list_cb ) (const pkgmgrinfo_pkginfo_h handle,
 205                                                         void *user_data);
 206
 207 /**
 208  * @fn int (*pkgmgrinfo_app_list_cb ) (const pkgmgrinfo_appinfo_h handle, void *user_data)
 209  *
 210  * @brief Specifies the type of function passed to pkgmgrinfo_appinfo_get_list(), pkgmgrinfo_appinfo_filter_foreach_appinfo(), pkgmgrinfo_appinfo_metadata_filter_foreach()
 211  *
 212  * @param[in] handle the appinfo handle
 213  * @param[in] user_data user data passed to pkgmgrinfo_appinfo_get_list(), pkgmgrinfo_appinfo_filter_foreach_appinfo(), pkgmgrinfo_appinfo_metadata_filter_foreach()
 214  *
 215  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 216  *
 217  * @see  pkgmgrinfo_appinfo_get_list()
 218  * @see  pkgmgrinfo_appinfo_filter_foreach_appinfo()
 219  * @see  pkgmgrinfo_appinfo_metadata_filter_foreach()
 220  */
 221 typedef int (*pkgmgrinfo_app_list_cb ) (const pkgmgrinfo_appinfo_h handle,
 222                                                         void *user_data);
 223
 224 /**
 225  * @fn int (*pkgmgrinfo_app_category_list_cb ) (const char *category_name, void *user_data)
 226  *
 227  * @brief Specifies the type of function passed to pkgmgrinfo_appinfo_foreach_category()
 228  *
 229  * @param[in] category_name the name of the category
 230  * @param[in] user_data user data passed to pkgmgrinfo_appinfo_foreach_category()
 231  *
 232  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 233  *
 234  * @see  pkgmgrinfo_appinfo_foreach_category()
 235  */
 236 typedef int (*pkgmgrinfo_app_category_list_cb ) (const char *category_name,
 237                                                         void *user_data);
 238
 239 /**
 240  * @fn int (*pkgmgrinfo_app_permission_list_cb ) (const char *permission_type, void *user_data)
 241  *
 242  * @brief Specifies the type of function passed to pkgmgrinfo_appinfo_foreach_category()
 243  *
 244  * @param[in] permission_name the name of the permission
 245  * @param[in] user_data user data passed to pkgmgrinfo_appinfo_foreach_category()
 246  *
 247  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 248  *
 249  * @see  pkgmgrinfo_appinfo_foreach_category()
 250  */
 251 typedef int (*pkgmgrinfo_app_permission_list_cb ) (const char *permission_type,
 252                                                         void *user_data);
 253
 254 /**
 255  * @fn int (*pkgmgrinfo_pkg_privilege_list_cb ) (const char *privilege_name, void *user_data)
 256  *
 257  * @brief Specifies the type of function passed to pkgmgrinfo_pkginfo_foreach_privilege()
 258  *
 259  * @param[in] privilege_name the name of the privilege
 260  * @param[in] user_data user data passed to pkgmgrinfo_pkginfo_foreach_privilege()
 261  *
 262  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 263  *
 264  * @see  pkgmgrinfo_pkginfo_foreach_privilege()
 265  */
 266 typedef int (*pkgmgrinfo_pkg_privilege_list_cb ) (const char *privilege_name,
 267                                                         void *user_data);
 268
 269 /**
 270  * @fn int (*pkgmgrinfo_app_metadata_list_cb ) (const char *metadata_key, const char *metadata_value, void *user_data)
 271  *
 272  * @brief Specifies the type of function passed to pkgmgrinfo_appinfo_foreach_metadata()
 273  *
 274  * @param[in] metadata_name the name of the metadata
 275  * @param[in] metadata_value the value of the metadata
 276  * @param[in] user_data user data passed to pkgmgrinfo_appinfo_foreach_metadata()
 277  *
 278  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 279  *
 280  * @see  pkgmgrinfo_appinfo_foreach_metadata()
 281  */
 282 typedef int (*pkgmgrinfo_app_metadata_list_cb ) (const char *metadata_key,
 283                                                         const char *metadata_value, void *user_data);
 284
 285 /**
 286  * @fn int (*pkgmgrinfo_app_control_list_cb ) (pkgmgrinfo_appcontrol_h handle, void *user_data)
 287  *
 288  * @brief Specifies the type of function passed to pkgmgrinfo_appinfo_foreach_appcontrol()
 289  *
 290  * @param[in] handle the appcontrol handle to be used to get operation, uri and mime info
 291  * @param[in] user_data user data passed to pkgmgrinfo_appinfo_foreach_appcontrol()
 292  *
 293  * @return 0 if success, negative value(<0) if fail. Callback is not called if return value is negative.\n
 294  *
 295  * @see  pkgmgrinfo_appinfo_foreach_appcontrol()
 296  */
 297 typedef int (*pkgmgrinfo_app_control_list_cb ) (pkgmgrinfo_appcontrol_h handle,
 298                                                         void *user_data);
 299
 300 /**
 301  * @brief Install Location Types
 302  */
 303 typedef enum {
 304         PMINFO_INSTALL_LOCATION_AUTO = 0,               /**< Auto*/
 305         PMINFO_INSTALL_LOCATION_INTERNAL_ONLY,          /**< Internal Installation*/
 306         PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL,                /**< External Installation*/
 307 }pkgmgrinfo_install_location;
 308
 309 /**
 310  * @brief Application Component Types
 311  */
 312 typedef enum {
 313         PMINFO_ALL_APP = 0,     /**< All Application*/
 314         PMINFO_UI_APP,          /**< UI Application*/
 315         PMINFO_SVC_APP,         /**< Service Application*/
 316 }pkgmgrinfo_app_component;
 317
 318 /**
 319  * @brief Application Storage Types
 320  */
 321 typedef enum {
 322         PMINFO_INTERNAL_STORAGE = 0,            /**< Internal Storage*/
 323         PMINFO_EXTERNAL_STORAGE = 1,            /**< External Storage*/
 324 }pkgmgrinfo_installed_storage;
 325
 326 /**
 327  * @brief Certificate Types to be used for getting information
 328  */
 329 typedef enum {
 330         PMINFO_AUTHOR_ROOT_CERT = 0,            /**< Author Root Certificate*/
 331         PMINFO_AUTHOR_INTERMEDIATE_CERT = 1,            /**< Author Intermediate Certificate*/
 332         PMINFO_AUTHOR_SIGNER_CERT = 2,          /**< Author Signer Certificate*/
 333         PMINFO_DISTRIBUTOR_ROOT_CERT = 3,               /**< Distributor Root Certificate*/
 334         PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT = 4,               /**< Distributor Intermediate Certificate*/
 335         PMINFO_DISTRIBUTOR_SIGNER_CERT = 5,             /**< Distributor Signer Certificate*/
 336         PMINFO_DISTRIBUTOR2_ROOT_CERT = 6,              /**< End Entity Root Certificate*/
 337         PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT = 7,              /**< End Entity Intermediate Certificate*/
 338         PMINFO_DISTRIBUTOR2_SIGNER_CERT = 8,            /**< End Entity Signer Certificate*/
 339 }pkgmgrinfo_cert_type;
 340
 341 /**
 342  * @brief Install Location Types to be used when setting data in DB
 343  */
 344 typedef enum {
 345         INSTALL_INTERNAL = 0,           /**< Internal Installation*/
 346         INSTALL_EXTERNAL,               /**< External Installation*/
 347 } INSTALL_LOCATION;
 348
 349  /**
 350   * @brief permission Types
 351   */
 352  typedef enum {
 353          PMINFO_PERMISSION_NORMAL = 0,           /**< permission normal*/
 354          PMINFO_PERMISSION_SIGNATURE,    /**< permission type is signature*/
 355          PMINFO_PERMISSION_PRIVILEGE,    /**< permission type is privilege*/
 356  }pkgmgrinfo_permission_type;
 357
 358
 359  /** String property for filtering based on package info*/
 360 #define PMINFO_PKGINFO_PROP_PACKAGE_ID          "PMINFO_PKGINFO_PROP_PACKAGE_ID"
 361  /** String property for filtering based on package info*/
 362 #define PMINFO_PKGINFO_PROP_PACKAGE_TYPE        "PMINFO_PKGINFO_PROP_PACKAGE_TYPE"
 363  /** String property for filtering based on package info*/
 364 #define PMINFO_PKGINFO_PROP_PACKAGE_VERSION     "PMINFO_PKGINFO_PROP_PACKAGE_VERSION"
 365  /** String property for filtering based on package info*/
 366 #define PMINFO_PKGINFO_PROP_PACKAGE_INSTALL_LOCATION            "PMINFO_PKGINFO_PROP_PACKAGE_INSTALL_LOCATION"
 367   /** String property for filtering based on package info*/
 368 #define PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE           "PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE"
 369  /** String property for filtering based on package info*/
 370 #define PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_NAME         "PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_NAME"
 371  /** String property for filtering based on package info*/
 372 #define PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_EMAIL                "PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_EMAIL"
 373  /** String property for filtering based on package info*/
 374 #define PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF         "PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF"
 375
 376  /** Boolean property for filtering based on package info*/
 377 #define PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE           "PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE"
 378  /** Boolean property for filtering based on package info*/
 379 #define PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD             "PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD"
 380  /** Boolean property for filtering based on package info*/
 381 #define PMINFO_PKGINFO_PROP_PACKAGE_READONLY            "PMINFO_PKGINFO_PROP_PACKAGE_READONLY"
 382   /** Boolean property for filtering based on package info*/
 383 #define PMINFO_PKGINFO_PROP_PACKAGE_UPDATE              "PMINFO_PKGINFO_PROP_PACKAGE_UPDATE"
 384   /** Boolean property for filtering based on package info*/
 385 #define PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING          "PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING"
 386    /** Boolean property for filtering based on package info*/
 387 #define PMINFO_PKGINFO_PROP_PACKAGE_NODISPLAY_SETTING           "PMINFO_PKGINFO_PROP_PACKAGE_NODISPLAY_SETTING"
 388
 389  /** Integer property for filtering based on package info*/
 390 #define PMINFO_PKGINFO_PROP_PACKAGE_SIZE                "PMINFO_PKGINFO_PROP_PACKAGE_SIZE"
 391
 392  /** String property for filtering based on app info*/
 393 #define PMINFO_APPINFO_PROP_APP_ID              "PMINFO_APPINFO_PROP_APP_ID"
 394  /** String property for filtering based on app info*/
 395 #define PMINFO_APPINFO_PROP_APP_COMPONENT               "PMINFO_APPINFO_PROP_APP_COMPONENT"
 396  /** String property for filtering based on app info*/
 397 #define PMINFO_APPINFO_PROP_APP_EXEC            "PMINFO_APPINFO_PROP_APP_EXEC"
 398  /** String property for filtering based on app info*/
 399 #define PMINFO_APPINFO_PROP_APP_ICON            "PMINFO_APPINFO_PROP_APP_ICON"
 400  /** String property for filtering based on app info*/
 401 #define PMINFO_APPINFO_PROP_APP_TYPE            "PMINFO_APPINFO_PROP_APP_TYPE"
 402  /** String property for filtering based on app info*/
 403 #define PMINFO_APPINFO_PROP_APP_OPERATION       "PMINFO_APPINFO_PROP_APP_OPERATION"
 404  /** String property for filtering based on app info*/
 405 #define PMINFO_APPINFO_PROP_APP_URI                     "PMINFO_APPINFO_PROP_APP_URI"
 406  /** String property for filtering based on app info*/
 407 #define PMINFO_APPINFO_PROP_APP_MIME            "PMINFO_APPINFO_PROP_APP_MIME"
 408  /** String property for filtering based on app info*/
 409 #define PMINFO_APPINFO_PROP_APP_CATEGORY        "PMINFO_APPINFO_PROP_APP_CATEGORY"
 410  /** String property for filtering based on app info*/
 411 #define PMINFO_APPINFO_PROP_APP_HWACCELERATION  "PMINFO_APPINFO_PROP_APP_HWACCELERATION"
 412
 413  /** Boolean property for filtering based on app info*/
 414 #define PMINFO_APPINFO_PROP_APP_NODISPLAY               "PMINFO_APPINFO_PROP_APP_NODISPLAY"
 415  /** Boolean property for filtering based on app info*/
 416 #define PMINFO_APPINFO_PROP_APP_MULTIPLE                "PMINFO_APPINFO_PROP_APP_MULTIPLE"
 417  /** Boolean property for filtering based on app info*/
 418 #define PMINFO_APPINFO_PROP_APP_ONBOOT                  "PMINFO_APPINFO_PROP_APP_ONBOOT"
 419  /** Boolean property for filtering based on app info*/
 420 #define PMINFO_APPINFO_PROP_APP_AUTORESTART     "PMINFO_APPINFO_PROP_APP_AUTORESTART"
 421  /** Boolean property for filtering based on app info*/
 422 #define PMINFO_APPINFO_PROP_APP_TASKMANAGE      "PMINFO_APPINFO_PROP_APP_TASKMANAGE"
 423  /** Boolean property for filtering based on app info*/
 424 #define PMINFO_APPINFO_PROP_APP_LAUNCHCONDITION "PMINFO_APPINFO_PROP_APP_LAUNCHCONDITION"
 425
 426  /** will be updated*/
 427  /** string property for filtering based on pkg info*/
 428 #define PMINFO_PKGINFO_PROP_RANGE_BASIC "PMINFO_PKGINFO_PROP_RANGE_BASIC"
 429
 430 /**
 431  * @fn  int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
 432  * @brief       This API gets list of installed packages
 433  *
 434  * @par         This API is for package-manager client application
 435  * @par Sync (or) Async : Synchronous API
 436  * @param[in]   pkg_list_cb     iteration function for list
 437  * @param[in]   user_data       user data to be passed to callback function
 438  * @return      0 if success, error code(<0) if fail
 439  * @retval      PMINFO_R_OK     success
 440  * @retval      PMINFO_R_EINVAL invalid argument
 441  * @retval      PMINFO_R_ERROR  internal error
 442  * @pre         None
 443  * @post        None
 444  * @code
 445 int pkg_list_cb(pkgmgrinfo_pkginfo_h handle, void *user_data)
 446 {
 447         char *pkgid1 = NULL;
 448         char *pkgid2 = NULL;
 449         pkgid1 = (char *)user_data;
 450         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid2);
 451         if (strcmp(pkgid1, pkgid2) == 0) {
 452                 return -1;
 453         } else {
 454                 return 0;
 455         }
 456 }
 457
 458 static int list_pkgs()
 459 {
 460         int ret = 0;
 461         char *name = "helloworld";
 462         ret = pkgmgrinfo_pkginfo_get_list(pkg_list_cb, (void *)name);
 463         if (ret != PMINFO_R_OK) {
 464                 return -1;
 465         }
 466         return 0;
 467 }
 468  * @endcode
 469  */
 470 int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data);
 471
 472 /**
 473  * @fn int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle)
 474  * @brief       This API creates the package information handle from db
 475  *
 476  * @par         This API is for package-manager client application
 477  * @par Sync (or) Async : Synchronous API
 478  *
 479  * @param[in]   pkgid   pointer to package ID
 480  * @param[out] handle           pointer to the package info handle.
 481  * @return      0 if success, error code(<0) if fail
 482  * @retval      PMINFO_R_OK     success
 483  * @retval      PMINFO_R_EINVAL invalid argument
 484  * @retval      PMINFO_R_ERROR  internal error
 485  * @pre         None
 486  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 487  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 488  * @see         pkgmgrinfo_pkginfo_is_removable()
 489  * @code
 490 static int get_pkg_type(const char *pkgid)
 491 {
 492         int ret = 0;
 493         char *type = NULL;
 494         pkgmgrinfo_pkginfo_h handle;
 495         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 496         if (ret != PMINFO_R_OK)
 497                 return -1;
 498         ret = pkgmgrinfo_pkginfo_get_type(handle, &type);
 499         if (ret != PMINFO_R_OK) {
 500                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 501                 return -1;
 502         }
 503         printf("pkgtype: %s\n", type);
 504         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 505         return 0;
 506 }
 507  * @endcode
 508  */
 509 int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle);
 510
 511 /**
 512  * @fn int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
 513  * @brief       This API gets the package name from the package ID
 514  *
 515  * @par         This API is for package-manager client application
 516  * @par Sync (or) Async : Synchronous API
 517  *
 518  * @param[in]   handle  pointer to package info handle
 519  * @param[out]  pkg_name        pointer to hold package name
 520  * @return      0 if success, error code(<0) if fail
 521  * @retval      PMINFO_R_OK     success
 522  * @retval      PMINFO_R_EINVAL invalid argument
 523  * @retval      PMINFO_R_ERROR  internal error
 524  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 525  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 526  * @see         pkgmgrinfo_pkginfo_get_type()
 527  * @see         pkgmgrinfo_pkginfo_is_removable()
 528  * @code
 529 static int get_pkg_name(const char *pkgid)
 530 {
 531         int ret = 0;
 532         char *pkgname = NULL;
 533         pkgmgrinfo_pkginfo_h handle;
 534         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 535         if (ret != PMINFO_R_OK)
 536                 return -1;
 537         ret = pkgmgrinfo_pkginfo_get_pkgname(handle, &pkgname);
 538         if (ret != PMINFO_R_OK) {
 539                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 540                 return -1;
 541         }
 542         printf("pkgname: %s\n", pkgname);
 543         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 544         return 0;
 545 }
 546  * @endcode
 547  */
 548 int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name);
 549
 550 /**
 551  * @fn int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
 552  * @brief       This API gets the package id from the package ID
 553  *
 554  * @par         This API is for package-manager client application
 555  * @par Sync (or) Async : Synchronous API
 556  *
 557  * @param[in]   handle  pointer to package info handle
 558  * @param[out]  pkgid   pointer to hold package id
 559  * @return      0 if success, error code(<0) if fail
 560  * @retval      PMINFO_R_OK     success
 561  * @retval      PMINFO_R_EINVAL invalid argument
 562  * @retval      PMINFO_R_ERROR  internal error
 563  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 564  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 565  * @see         pkgmgrinfo_pkginfo_get_type()
 566  * @see         pkgmgrinfo_pkginfo_is_removable()
 567  * @code
 568 static int get_pkgid(const char *pkgid)
 569 {
 570         int ret = 0;
 571         char *pkg_id = NULL;
 572         pkgmgrinfo_pkginfo_h handle;
 573         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 574         if (ret != PMINFO_R_OK)
 575                 return -1;
 576         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkg_id);
 577         if (ret != PMINFO_R_OK) {
 578                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 579                 return -1;
 580         }
 581         printf("pkg id: %s\n", pkg_id);
 582         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 583         return 0;
 584 }
 585  * @endcode
 586  */
 587 int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid);
 588
 589 /**
 590  * @fn int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
 591  * @brief       This API gets the package type from the package ID
 592  *
 593  * @par         This API is for package-manager client application
 594  * @par Sync (or) Async : Synchronous API
 595  *
 596  * @param[in]   handle  pointer to package info handle
 597  * @param[out] type             pointer to hold package type
 598  * @return      0 if success, error code(<0) if fail
 599  * @retval      PMINFO_R_OK     success
 600  * @retval      PMINFO_R_EINVAL invalid argument
 601  * @retval      PMINFO_R_ERROR  internal error
 602  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 603  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 604  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 605  * @see         pkgmgrinfo_pkginfo_is_removable()
 606  * @code
 607 static int get_pkg_type(const char *pkgid)
 608 {
 609         int ret = 0;
 610         char *type = NULL;
 611         pkgmgrinfo_pkginfo_h handle;
 612         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 613         if (ret != PMINFO_R_OK)
 614                 return -1;
 615         ret = pkgmgrinfo_pkginfo_get_type(handle, &type);
 616         if (ret != PMINFO_R_OK) {
 617                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 618                 return -1;
 619         }
 620         printf("pkgtype: %s\n", type);
 621         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 622         return 0;
 623 }
 624  * @endcode
 625  */
 626 int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type);
 627
 628 /**
 629  * @fn int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
 630  * @brief       This API gets the package version from the package ID
 631  *
 632  * @par         This API is for package-manager client application
 633  * @par Sync (or) Async : Synchronous API
 634  *
 635  * @param[in]   handle  pointer to package info handle
 636  * @param[out] version          pointer to hold package version
 637  * @return      0 if success, error code(<0) if fail
 638  * @retval      PMINFO_R_OK     success
 639  * @retval      PMINFO_R_EINVAL invalid argument
 640  * @retval      PMINFO_R_ERROR  internal error
 641  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 642  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 643  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 644  * @see         pkgmgrinfo_pkginfo_is_removable()
 645  * @code
 646 static int get_pkg_version(const char *pkgid)
 647 {
 648         int ret = 0;
 649         char *version = NULL;
 650         pkgmgrinfo_pkginfo_h handle;
 651         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 652         if (ret != PMINFO_R_OK)
 653                 return -1;
 654         ret = pkgmgrinfo_pkginfo_get_version(handle, &version);
 655         if (ret != PMINFO_R_OK) {
 656                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 657                 return -1;
 658         }
 659         printf("pkg version: %s\n", version);
 660         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 661         return 0;
 662 }
 663  * @endcode
 664  */
 665 int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version);
 666
 667 /**
 668  * @fn int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
 669  * @brief       This API gets the package install location from the package ID
 670  *
 671  * @par         This API is for package-manager client application
 672  * @par Sync (or) Async : Synchronous API
 673  *
 674  * @param[in] handle    pointer to package info handle
 675  * @param[out] location         pointer to hold package install location
 676  * @return      0 if success, error code(<0) if fail
 677  * @retval      PMINFO_R_OK     success
 678  * @retval      PMINFO_R_EINVAL invalid argument
 679  * @retval      PMINFO_R_ERROR  internal error
 680  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 681  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 682  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 683  * @see         pkgmgrinfo_pkginfo_is_removable()
 684  * @code
 685 static int get_pkg_install_location(const char *pkgid)
 686 {
 687         int ret = 0;
 688         pkgmgrinfo_install_location location;
 689         pkgmgrinfo_pkginfo_h handle;
 690         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 691         if (ret != PMINFO_R_OK)
 692                 return -1;
 693         ret = pkgmgrinfo_pkginfo_get_install_location(handle, &location);
 694         if (ret != PMINFO_R_OK) {
 695                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 696                 return -1;
 697         }
 698         printf("pkg install location: %d\n", location);
 699         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 700         return 0;
 701 }
 702  * @endcode
 703  */
 704 int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location);
 705
 706 /**
 707  * @fn int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
 708  * @brief       This API gets the package size from the package ID. size will be 0 if package install location is internal-only.
 709  size will be 0 if package install location is prefer-external but size is not specified in manifest file.Application should check
 710  the return value of pkgmgrinfo_pkginfo_get_install_location() and use it to distinguish the above cases.
 711  *
 712  * @par         This API is for package-manager client application
 713  * @par Sync (or) Async : Synchronous API
 714  *
 715  * @param[in]   handle  pointer to package info handle
 716  * @param[out] size             pointer to hold package size
 717  * @return      0 if success, error code(<0) if fail
 718  * @retval      PMINFO_R_OK     success
 719  * @retval      PMINFO_R_EINVAL invalid argument
 720  * @retval      PMINFO_R_ERROR  internal error
 721  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 722  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 723  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 724  * @see         pkgmgrinfo_pkginfo_is_removable()
 725  * @code
 726 static int get_pkg_size(const char *pkgid)
 727 {
 728         int ret = 0;
 729         int size = 0;
 730         pkgmgrinfo_pkginfo_h handle;
 731         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 732         if (ret != PMINFO_R_OK)
 733                 return -1;
 734         ret = pkgmgrinfo_pkginfo_get_package_size(handle, &size);
 735         if (ret != PMINFO_R_OK) {
 736                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 737                 return -1;
 738         }
 739         printf("pkgsize: %d\n", size);
 740         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 741         return 0;
 742 }
 743  * @endcode
 744  */
 745 int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size);
 746
 747 /**
 748  * @fn int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
 749  * @brief       This API gets the installed package total size on the target.
 750  *
 751  * @par         This API is for package-manager client application
 752  * @par Sync (or) Async : Synchronous API
 753  *
 754  * @param[in]   handle  pointer to package info handle
 755  * @param[out] size             pointer to hold package total size
 756  * @return      0 if success, error code(<0) if fail
 757  * @retval      PMINFO_R_OK     success
 758  * @retval      PMINFO_R_EINVAL invalid argument
 759  * @retval      PMINFO_R_ERROR  internal error
 760  * @code
 761 static int get_pkg_total_size(const char *pkgid)
 762 {
 763         int ret = 0;
 764         int size = 0;
 765         pkgmgrinfo_pkginfo_h handle;
 766         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 767         if (ret != PMINFO_R_OK)
 768                 return -1;
 769         ret = pkgmgrinfo_pkginfo_get_total_size(handle, &size);
 770         if (ret != PMINFO_R_OK) {
 771                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 772                 return -1;
 773         }
 774         printf("pkg total size: %d\n", size);
 775         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 776         return 0;
 777 }
 778  * @endcode
 779  */
 780  int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size);
 781
 782 /**
 783  * @fn int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
 784  * @brief       This API gets the installed package data size on the target.
 785  *
 786  * @par         This API is for package-manager client application
 787  * @par Sync (or) Async : Synchronous API
 788  *
 789  * @param[in]   handle  pointer to package info handle
 790  * @param[out] size             pointer to hold package data size
 791  * @return      0 if success, error code(<0) if fail
 792  * @retval      PMINFO_R_OK     success
 793  * @retval      PMINFO_R_EINVAL invalid argument
 794  * @retval      PMINFO_R_ERROR  internal error
 795  * @code
 796 static int get_pkg_data_size(const char *pkgid)
 797 {
 798         int ret = 0;
 799         int size = 0;
 800         pkgmgrinfo_pkginfo_h handle;
 801         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 802         if (ret != PMINFO_R_OK)
 803                 return -1;
 804         ret = pkgmgrinfo_pkginfo_get_data_size(handle, &size);
 805         if (ret != PMINFO_R_OK) {
 806                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 807                 return -1;
 808         }
 809         printf("pkg data size: %d\n", size);
 810         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 811         return 0;
 812 }
 813  * @endcode
 814  */
 815  int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size);
 816
 817 /**
 818  * @fn int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
 819  * @brief       This API gets the package icon from the package ID
 820  *
 821  * @par         This API is for package-manager client application
 822  * @par Sync (or) Async : Synchronous API
 823  *
 824  * @param[in]   handle  pointer to package info handle
 825  * @param[out] icon             pointer to hold package icon
 826  * @return      0 if success, error code(<0) if fail
 827  * @retval      PMINFO_R_OK     success
 828  * @retval      PMINFO_R_EINVAL invalid argument
 829  * @retval      PMINFO_R_ERROR  internal error
 830  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 831  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 832  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 833  * @see         pkgmgrinfo_pkginfo_is_removable()
 834  * @code
 835 static int get_pkg_icon(const char *pkgid)
 836 {
 837         int ret = 0;
 838         char *icon = NULL;
 839         pkgmgrinfo_pkginfo_h handle;
 840         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 841         if (ret != PMINFO_R_OK)
 842                 return -1;
 843         ret = pkgmgrinfo_pkginfo_get_icon(handle, &icon);
 844         if (ret != PMINFO_R_OK) {
 845                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 846                 return -1;
 847         }
 848         printf("pkg icon: %s\n", icon);
 849         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 850         return 0;
 851 }
 852  * @endcode
 853  */
 854 int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon);
 855
 856 /**
 857  * @fn int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
 858  * @brief       This API gets the package label from the package ID
 859  *
 860  * @par         This API is for package-manager client application
 861  * @par Sync (or) Async : Synchronous API
 862  *
 863  * @param[in]   handle  pointer to package info handle
 864  * @param[out] label            pointer to hold package label
 865  * @return      0 if success, error code(<0) if fail
 866  * @retval      PMINFO_R_OK     success
 867  * @retval      PMINFO_R_EINVAL invalid argument
 868  * @retval      PMINFO_R_ERROR  internal error
 869  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 870  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 871  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 872  * @see         pkgmgrinfo_pkginfo_is_removable()
 873  * @code
 874 static int get_pkg_label(const char *pkgid)
 875 {
 876         int ret = 0;
 877         char *label = NULL;
 878         pkgmgrinfo_pkginfo_h handle;
 879         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 880         if (ret != PMINFO_R_OK)
 881                 return -1;
 882         ret = pkgmgrinfo_pkginfo_get_label(handle, &label);
 883         if (ret != PMINFO_R_OK) {
 884                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 885                 return -1;
 886         }
 887         printf("pkg label: %s\n", label);
 888         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 889         return 0;
 890 }
 891  * @endcode
 892  */
 893 int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label);
 894
 895 /**
 896  * @fn int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
 897  * @brief       This API gets the package description from the package ID
 898  *
 899  * @par         This API is for package-manager client application
 900  * @par Sync (or) Async : Synchronous API
 901  *
 902  * @param[in]   handle  pointer to package info handle
 903  * @param[out] description              pointer to hold package description
 904  * @return      0 if success, error code(<0) if fail
 905  * @retval      PMINFO_R_OK     success
 906  * @retval      PMINFO_R_EINVAL invalid argument
 907  * @retval      PMINFO_R_ERROR  internal error
 908  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 909  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 910  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 911  * @see         pkgmgrinfo_pkginfo_is_removable()
 912  * @code
 913 static int get_pkg_description(const char *pkgid)
 914 {
 915         int ret = 0;
 916         char *description = NULL;
 917         pkgmgrinfo_pkginfo_h handle;
 918         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 919         if (ret != PMINFO_R_OK)
 920                 return -1;
 921         ret = pkgmgrinfo_pkginfo_get_description(handle, &description);
 922         if (ret != PMINFO_R_OK) {
 923                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 924                 return -1;
 925         }
 926         printf("pkg description: %s\n", description);
 927         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 928         return 0;
 929 }
 930  * @endcode
 931  */
 932 int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description);
 933
 934 /**
 935  * @fn int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
 936  * @brief       This API gets the package's author name from the package ID
 937  *
 938  * @par         This API is for package-manager client application
 939  * @par Sync (or) Async : Synchronous API
 940  *
 941  * @param[in]   handle  pointer to package info handle
 942  * @param[out] author_name              pointer to hold package author name
 943  * @return      0 if success, error code(<0) if fail
 944  * @retval      PMINFO_R_OK     success
 945  * @retval      PMINFO_R_EINVAL invalid argument
 946  * @retval      PMINFO_R_ERROR  internal error
 947  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 948  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 949  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 950  * @see         pkgmgrinfo_pkginfo_is_removable()
 951  * @code
 952 static int get_pkg_author_name(const char *pkgid)
 953 {
 954         int ret = 0;
 955         char *author_name = NULL;
 956         pkgmgrinfo_pkginfo_h handle;
 957         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 958         if (ret != PMINFO_R_OK)
 959                 return -1;
 960         ret = pkgmgrinfo_pkginfo_get_author_name(handle, &author_name);
 961         if (ret != PMINFO_R_OK) {
 962                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 963                 return -1;
 964         }
 965         printf("pkg author name: %s\n", author_name);
 966         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 967         return 0;
 968 }
 969  * @endcode
 970  */
 971 int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name);
 972
 973 /**
 974  * @fn int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
 975  * @brief       This API gets the package's author email from the package ID
 976  *
 977  * @par         This API is for package-manager client application
 978  * @par Sync (or) Async : Synchronous API
 979  *
 980  * @param[in]   handle  pointer to package info handle
 981  * @param[out] author_email             pointer to hold package author email
 982  * @return      0 if success, error code(<0) if fail
 983  * @retval      PMINFO_R_OK     success
 984  * @retval      PMINFO_R_EINVAL invalid argument
 985  * @retval      PMINFO_R_ERROR  internal error
 986  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
 987  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
 988  * @see         pkgmgrinfo_pkginfo_get_pkgid()
 989  * @see         pkgmgrinfo_pkginfo_is_removable()
 990  * @code
 991 static int get_pkg_author_email(const char *pkgid)
 992 {
 993         int ret = 0;
 994         char *author_email = NULL;
 995         pkgmgrinfo_pkginfo_h handle;
 996         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 997         if (ret != PMINFO_R_OK)
 998                 return -1;
 999         ret = pkgmgrinfo_pkginfo_get_author_email(handle, &author_email);
1000         if (ret != PMINFO_R_OK) {
1001                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1002                 return -1;
1003         }
1004         printf("pkg author email: %s\n", author_email);
1005         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1006         return 0;
1007 }
1008  * @endcode
1009  */
1010 int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email);
1011
1012 /**
1013  * @fn int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1014  * @brief       This API gets the package's author href from the package ID
1015  *
1016  * @par         This API is for package-manager client application
1017  * @par Sync (or) Async : Synchronous API
1018  *
1019  * @param[in]   handle  pointer to package info handle
1020  * @param[out] author_href              pointer to hold package author href
1021  * @return      0 if success, error code(<0) if fail
1022  * @retval      PMINFO_R_OK     success
1023  * @retval      PMINFO_R_EINVAL invalid argument
1024  * @retval      PMINFO_R_ERROR  internal error
1025  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1026  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1027  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1028  * @see         pkgmgrinfo_pkginfo_is_removable()
1029  * @code
1030 static int get_pkg_author_href(const char *pkgid)
1031 {
1032         int ret = 0;
1033         char *author_href = NULL;
1034         pkgmgrinfo_pkginfo_h handle;
1035         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1036         if (ret != PMINFO_R_OK)
1037                 return -1;
1038         ret = pkgmgrinfo_pkginfo_get_author_href(handle, &author_href);
1039         if (ret != PMINFO_R_OK) {
1040                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1041                 return -1;
1042         }
1043         printf("pkg author href: %s\n", author_href);
1044         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1045         return 0;
1046 }
1047  * @endcode
1048  */
1049 int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href);
1050
1051 /**
1052  * @fn int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1053  * @brief       This API gets the package installed storagae value from the package ID
1054  *
1055  * @par         This API is for package-manager client application
1056  * @par Sync (or) Async : Synchronous API
1057  *
1058  * @param[in]   handle  pointer to package info handle
1059  * @param[out] storage          pointer to hold package installed storage
1060  * @return      0 if success, error code(<0) if fail
1061  * @retval      PMINFO_R_OK     success
1062  * @retval      PMINFO_R_EINVAL invalid argument
1063  * @retval      PMINFO_R_ERROR  internal error
1064  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1065  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1066  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1067  * @see         pkgmgrinfo_pkginfo_is_removable()
1068  * @code
1069 static int get_pkg_installed_storage(const char *pkgid)
1070 {
1071         int ret = 0;
1072         pkgmgrinfo_installed_storage storage;
1073         pkgmgrinfo_pkginfo_h handle;
1074         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1075         if (ret != PMINFO_R_OK)
1076                 return -1;
1077         ret = pkgmgrinfo_pkginfo_get_installed_storage(handle, &storage);
1078         if (ret != PMINFO_R_OK) {
1079                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1080                 return -1;
1081         }
1082         printf("pkg installed storage: %d\n", storage);
1083         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1084         return 0;
1085 }
1086  * @endcode
1087  */
1088 int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage);
1089
1090 /**
1091  * @fn int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1092  * @brief       This API gets the installed time of package from the package ID
1093  *
1094  * @par         This API is for package-manager client application
1095  * @par Sync (or) Async : Synchronous API
1096  *
1097  * @param[in]   handle  pointer to package info handle
1098  * @param[out] installed_time           pointer to hold installed time of package
1099  * @return      0 if success, error code(<0) if fail
1100  * @retval      PMINFO_R_OK     success
1101  * @retval      PMINFO_R_EINVAL invalid argument
1102  * @retval      PMINFO_R_ERROR  internal error
1103  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1104  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1105  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1106  * @see         pkgmgrinfo_pkginfo_is_removable()
1107  * @code
1108 static int get_pkg_installed_time(const char *pkgid)
1109 {
1110         int ret = 0;
1111         int installed_time = 0;
1112         pkgmgrinfo_pkginfo_h handle;
1113         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1114         if (ret != PMINFO_R_OK)
1115                 return -1;
1116         ret = pkgmgrinfo_pkginfo_get_installed_time(handle, &installed_time);
1117         if (ret != PMINFO_R_OK) {
1118                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1119                 return -1;
1120         }
1121         printf("installed_time: %d\n", installed_time);
1122         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1123         return 0;
1124 }
1125  * @endcode
1126  */
1127 int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time);
1128
1129 /**
1130  * @fn int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1131  * @brief       This API gets the store client id of package from the package ID
1132  *
1133  * @par         This API is for package-manager client application
1134  * @par Sync (or) Async : Synchronous API
1135  *
1136  * @param[in]   handle  pointer to package info handle
1137  * @param[out] storeclientid            pointer to hold store client id of package
1138  * @return      0 if success, error code(<0) if fail
1139  * @retval      PMINFO_R_OK     success
1140  * @retval      PMINFO_R_EINVAL invalid argument
1141  * @retval      PMINFO_R_ERROR  internal error
1142  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1143  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1144  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1145  * @see         pkgmgrinfo_pkginfo_is_removable()
1146  * @code
1147 static int get_pkg_storeclientid(const char *pkgid)
1148 {
1149         int ret = 0;
1150         char *storeclientid = 0;
1151         pkgmgrinfo_pkginfo_h handle;
1152         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1153         if (ret != PMINFO_R_OK)
1154                 return -1;
1155         ret = pkgmgrinfo_pkginfo_get_storeclientid(handle, &storeclientid);
1156         if (ret != PMINFO_R_OK) {
1157                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1158                 return -1;
1159         }
1160         printf(store client id: %s\n", storeclientid);
1161         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1162         return 0;
1163 }
1164  * @endcode
1165  */
1166 int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid);
1167
1168 /**
1169  * @fn int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1170  * @brief       This API gets the main app id of package from the package ID
1171  *
1172  * @par         This API is for package-manager client application
1173  * @par Sync (or) Async : Synchronous API
1174  *
1175  * @param[in]   handle  pointer to package info handle
1176  * @param[out] mainappid                pointer to hold main app id of package
1177  * @return      0 if success, error code(<0) if fail
1178  * @retval      PMINFO_R_OK     success
1179  * @retval      PMINFO_R_EINVAL invalid argument
1180  * @retval      PMINFO_R_ERROR  internal error
1181  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1182  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1183  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1184  * @see         pkgmgrinfo_pkginfo_is_removable()
1185  * @code
1186 static int get_pkg_mainappid(const char *pkgid)
1187 {
1188         int ret = 0;
1189         char *mainappid = 0;
1190         pkgmgrinfo_pkginfo_h handle;
1191         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1192         if (ret != PMINFO_R_OK)
1193                 return -1;
1194         ret = pkgmgrinfo_pkginfo_get_mainappid(handle, &mainappid);
1195         if (ret != PMINFO_R_OK) {
1196                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1197                 return -1;
1198         }
1199         printf(main app id: %s\n", mainappid);
1200         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1201         return 0;
1202 }
1203  * @endcode
1204  */
1205 int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid);
1206
1207 /**
1208  * @fn int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1209  * @brief       This API gets the url of package from the package ID
1210  *
1211  * @par         This API is for package-manager client application
1212  * @par Sync (or) Async : Synchronous API
1213  *
1214  * @param[in]   handle  pointer to package info handle
1215  * @param[out] url              pointer to hold url of package
1216  * @return      0 if success, error code(<0) if fail
1217  * @retval      PMINFO_R_OK     success
1218  * @retval      PMINFO_R_EINVAL invalid argument
1219  * @retval      PMINFO_R_ERROR  internal error
1220  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1221  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1222  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1223  * @see         pkgmgrinfo_pkginfo_is_removable()
1224  * @code
1225 static int get_pkg_url(const char *pkgid)
1226 {
1227         int ret = 0;
1228         char *url = 0;
1229         pkgmgrinfo_pkginfo_h handle;
1230         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1231         if (ret != PMINFO_R_OK)
1232                 return -1;
1233         ret = pkgmgrinfo_pkginfo_get_url(handle, &url);
1234         if (ret != PMINFO_R_OK) {
1235                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1236                 return -1;
1237         }
1238         printf("url : %s\n", url);
1239         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1240         return 0;
1241 }
1242  * @endcode
1243  */
1244 int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url);
1245
1246
1247 /**
1248  * @fn int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1249  * @brief       This API gets the root path of package
1250  *
1251  * @par Sync (or) Async : Synchronous API
1252  *
1253  * @param[in] handle            pointer to package info handle
1254  * @param[out] path             pointer to hold root path of package
1255  * @return      0 if success, error code(<0) if fail
1256  * @retval      PMINFO_R_OK     success
1257  * @retval      PMINFO_R_EINVAL invalid argument
1258  * @retval      PMINFO_R_ERROR  internal error
1259  * @code
1260 static int get_root_path(const char *pkgid)
1261 {
1262         int ret = 0;
1263         char *path = 0;
1264         pkgmgrinfo_pkginfo_h handle;
1265         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1266         if (ret != PMINFO_R_OK)
1267                 return -1;
1268
1269         ret = pkgmgrinfo_pkginfo_get_root_path(handle, &path);
1270         if (ret != PMINFO_R_OK) {
1271                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1272                 return -1;
1273         }
1274         printf("path : %s\n", path);
1275         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1276
1277         return 0;
1278 }
1279  * @endcode
1280  */
1281 int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path);
1282
1283
1284 /**
1285  * @fn int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1286  * @brief       This API gets the csc path of package
1287  *
1288  * @par Sync (or) Async : Synchronous API
1289  *
1290  * @param[in] handle            pointer to package info handle
1291  * @param[out] path             pointer to hold csc path of package
1292  * @return      0 if success, error code(<0) if fail
1293  * @retval      PMINFO_R_OK     success
1294  * @retval      PMINFO_R_EINVAL invalid argument
1295  * @retval      PMINFO_R_ERROR  internal error
1296  * @code
1297 static int get_csc_path(const char *pkgid)
1298 {
1299         int ret = 0;
1300         char *path = 0;
1301         pkgmgrinfo_pkginfo_h handle;
1302         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1303         if (ret != PMINFO_R_OK)
1304                 return -1;
1305
1306         ret = pkgmgrinfo_pkginfo_get_csc_path(handle, &path);
1307         if (ret != PMINFO_R_OK) {
1308                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1309                 return -1;
1310         }
1311         printf("path : %s\n", path);
1312         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1313
1314         return 0;
1315 }
1316  * @endcode
1317  */
1318 int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path);
1319
1320 /**
1321  * @fn int pkgmgrinfo_pkginfo_compare_pkg_cert_info(const char *lhs_package_id, const char *rhs_package_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
1322  * @brief       This API compare the cert information from given package id
1323  *
1324  * @par         This API is for package-manager client application
1325  * @par Sync (or) Async : Synchronous API
1326  *
1327  * @param[in]   lhs_package_id  pointer to first package ID
1328  * @param[in]   rhs_package_id  pointer to second package ID
1329  * @param[out] compare_result           pointer to the compare result.
1330  * @return      0 if success, error code(<0) if fail
1331  * @retval      PMINFO_R_OK     success
1332  * @retval      PMINFO_R_EINVAL invalid argument
1333  * @retval      PMINFO_R_ERROR  internal error
1334  * @pre         None
1335  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1336  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1337  * @see         pkgmgrinfo_pkginfo_is_removable()
1338  * @code
1339 static int compare_pkg_cert_info(const char *lhs_package_id, const char *rhs_package_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
1340 {
1341         int ret = 0;
1342         pkgmgrinfo_cert_compare_result_type_e result;
1343
1344         ret = pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result);
1345         if (ret != PMINFO_R_OK) {
1346                 return -1;
1347         }
1348         printf("result: %d\n", result);
1349         return 0;
1350 }
1351  * @endcode
1352  */
1353 int pkgmgrinfo_pkginfo_compare_pkg_cert_info(const char *lhs_package_id, const char *rhs_package_id, pkgmgrinfo_cert_compare_result_type_e *compare_result);
1354
1355 /**
1356  * @fn int pkgmgrinfo_pkginfo_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
1357  * @brief       This API compare the cert information from given app id
1358  *
1359  * @par         This API is for package-manager client application
1360  * @par Sync (or) Async : Synchronous API
1361  *
1362  * @param[in]   lhs_app_id      pointer to first app ID
1363  * @param[in]   rhs_app_id      pointer to second app ID
1364  * @param[out] compare_result           pointer to the compare result.
1365  * @return      0 if success, error code(<0) if fail
1366  * @retval      PMINFO_R_OK     success
1367  * @retval      PMINFO_R_EINVAL invalid argument
1368  * @retval      PMINFO_R_ERROR  internal error
1369  * @pre         None
1370  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1371  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1372  * @see         pkgmgrinfo_pkginfo_is_removable()
1373  * @code
1374 static int compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
1375 {
1376         int ret = 0;
1377         pkgmgrinfo_cert_compare_result_type_e result;
1378
1379         ret = pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result);
1380         if (ret != PMINFO_R_OK) {
1381                 return -1;
1382         }
1383         printf("result: %d\n", result);
1384         return 0;
1385 }
1386  * @endcode
1387  */
1388 int pkgmgrinfo_pkginfo_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, pkgmgrinfo_cert_compare_result_type_e *compare_result);
1389
1390 /**
1391  * @fn int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1392  * @brief       This API gets the package 'removable' value from the package ID
1393  *
1394  * @par         This API is for package-manager client application
1395  * @par Sync (or) Async : Synchronous API
1396  *
1397  * @param[in]   handle  pointer to package info handle
1398  * @param[out] removable                pointer to hold package removable value
1399  * @return      0 if success, error code(<0) if fail
1400  * @retval      PMINFO_R_OK     success
1401  * @retval      PMINFO_R_EINVAL invalid argument
1402  * @retval      PMINFO_R_ERROR  internal error
1403  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1404  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1405  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1406  * @see         pkgmgrinfo_pkginfo_is_readonly()
1407  * @code
1408 static int get_pkg_removable(const char *pkgid)
1409 {
1410         int ret = 0;
1411         bool removable;
1412         pkgmgrinfo_pkginfo_h handle;
1413         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1414         if (ret != PMINFO_R_OK)
1415                 return -1;
1416         ret = pkgmgrinfo_pkginfo_is_removable(handle, &removable);
1417         if (ret != PMINFO_R_OK) {
1418                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1419                 return -1;
1420         }
1421         printf("pkg removable: %d\n", removable);
1422         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1423         return 0;
1424 }
1425  * @endcode
1426  */
1427 int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable);
1428
1429 /**
1430  * @fn int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1431  * @brief       This API check that the package can move internal storage to external storage or external storage to internal storage from the package ID
1432  *
1433  * @par         This API is for package-manager client application
1434  * @par Sync (or) Async : Synchronous API
1435  *
1436  * @param[in]   handle  pointer to package info handle
1437  * @param[out] movable          pointer to hold package movable state
1438  * @return      0 if success, error code(<0) if fail
1439  * @retval      PMINFO_R_OK     success
1440  * @retval      PMINFO_R_EINVAL invalid argument
1441  * @retval      PMINFO_R_ERROR  internal error
1442  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1443  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1444  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1445  * @code
1446 static int get_pkg_movable(const char *pkgid)
1447 {
1448         int ret = 0;
1449         bool movable;
1450         pkgmgrinfo_pkginfo_h handle;
1451         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1452         if (ret != PMINFO_R_OK)
1453                 return -1;
1454         ret = pkgmgrinfo_pkginfo_is_movable(handle, &movable);
1455         if (ret != PMINFO_R_OK) {
1456                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1457                 return -1;
1458         }
1459         printf("pkg movable: %d\n", movable);
1460         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1461         return 0;
1462 }
1463  * @endcode
1464  */
1465 int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable);
1466
1467 /**
1468  * @fn int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1469  * @brief       This API gets the package 'preload' value from the package ID
1470  *
1471  * @par         This API is for package-manager client application
1472  * @par Sync (or) Async : Synchronous API
1473  *
1474  * @param[in]   handle  pointer to package info handle
1475  * @param[out] preload          pointer to hold package preload value
1476  * @return      0 if success, error code(<0) if fail
1477  * @retval      PMINFO_R_OK     success
1478  * @retval      PMINFO_R_EINVAL invalid argument
1479  * @retval      PMINFO_R_ERROR  internal error
1480  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1481  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1482  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1483  * @see         pkgmgrinfo_pkginfo_is_readonly()
1484  * @code
1485 static int get_pkg_preload(const char *pkgid)
1486 {
1487         int ret = 0;
1488         bool preload;
1489         pkgmgrinfo_pkginfo_h handle;
1490         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1491         if (ret != PMINFO_R_OK)
1492                 return -1;
1493         ret = pkgmgrinfo_pkginfo_is_preload(handle, &preload);
1494         if (ret != PMINFO_R_OK) {
1495                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1496                 return -1;
1497         }
1498         printf("pkg preload: %d\n", preload);
1499         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1500         return 0;
1501 }
1502  * @endcode
1503  */
1504 int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload);
1505
1506 /**
1507  * @fn int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1508  * @brief       This API gets the package 'readonly' value from the package ID
1509  *
1510  * @par         This API is for package-manager client application
1511  * @par Sync (or) Async : Synchronous API
1512  *
1513  * @param[in]   handle  pointer to package info handle
1514  * @param[out] readonly pointer to hold package readonly value
1515  * @return      0 if success, error code(<0) if fail
1516  * @retval      PMINFO_R_OK     success
1517  * @retval      PMINFO_R_EINVAL invalid argument
1518  * @retval      PMINFO_R_ERROR  internal error
1519  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1520  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1521  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1522  * @see         pkgmgrinfo_pkginfo_is_removable()
1523  * @code
1524 static int get_pkg_readonly(const char *pkgid)
1525 {
1526         int ret = 0;
1527         bool readonly;
1528         pkgmgrinfo_pkginfo_h handle;
1529         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1530         if (ret != PMINFO_R_OK)
1531                 return -1;
1532         ret = pkgmgrinfo_pkginfo_is_readonly(handle, &readonly);
1533         if (ret != PMINFO_R_OK) {
1534                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1535                 return -1;
1536         }
1537         printf("pkg readonly: %d\n", readonly);
1538         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1539         return 0;
1540 }
1541  * @endcode
1542  */
1543 int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly);
1544
1545
1546 /**
1547  * @fn int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1548  * @brief       This API gets the package 'upate' value from the package ID
1549  *
1550  * @par         This API is for package-manager client application
1551  * @par Sync (or) Async : Synchronous API
1552  *
1553  * @param[in]   handle  pointer to package info handle
1554  * @param[out] update   pointer to hold package update value
1555  * @return      0 if success, error code(<0) if fail
1556  * @retval      PMINFO_R_OK     success
1557  * @retval      PMINFO_R_EINVAL invalid argument
1558  * @retval      PMINFO_R_ERROR  internal error
1559  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1560  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1561  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1562  * @code
1563 static int get_pkg_update(const char *pkgid)
1564 {
1565         int ret = 0;
1566         bool update;
1567         pkgmgrinfo_pkginfo_h handle;
1568         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1569         if (ret != PMINFO_R_OK)
1570                 return -1;
1571         ret = pkgmgrinfo_pkginfo_is_update(handle, &update);
1572         if (ret != PMINFO_R_OK) {
1573                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1574                 return -1;
1575         }
1576         printf("pkg update: %d\n", update);
1577         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1578         return 0;
1579 }
1580  * @endcode
1581  */
1582 int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update);
1583
1584 /**
1585  * @fn int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1586  * @brief       This API gets the package 'accessible' value from the package ID
1587  *
1588  * @par         This API is for package-manager client application
1589  * @par Sync (or) Async : Synchronous API
1590  *
1591  * @param[in]   handle  pointer to package info handle
1592  * @param[out] accessible       pointer to hold package accessible value
1593  * @return      0 if success, error code(<0) if fail
1594  * @retval      PMINFO_R_OK     success
1595  * @retval      PMINFO_R_EINVAL invalid argument
1596  * @retval      PMINFO_R_ERROR  internal error
1597  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1598  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1599  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1600  * @see         pkgmgrinfo_pkginfo_is_readonly()
1601  * @code
1602 static int get_pkg_accessible(const char *pkgid)
1603 {
1604         int ret = 0;
1605         bool accessible;
1606         pkgmgrinfo_pkginfo_h handle;
1607         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1608         if (ret != PMINFO_R_OK)
1609                 return -1;
1610         ret = pkgmgrinfo_pkginfo_is_accessible(handle, &accessible);
1611         if (ret != PMINFO_R_OK) {
1612                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1613                 return -1;
1614         }
1615         printf("pkg accessible: %d\n", accessible);
1616         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1617         return 0;
1618 }
1619  * @endcode
1620  */
1621 int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible);
1622
1623 /**
1624  * @fn int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1625  * @brief       This API destroys the package information handle freeing up all the resources
1626  *
1627  * @par         This API is for package-manager client application
1628  * @par Sync (or) Async : Synchronous API
1629  *
1630  * @param[in]   handle  pointer to the package info handle
1631  * @return      0 if success, error code(<0) if fail
1632  * @retval      PMINFO_R_OK     success
1633  * @retval      PMINFO_R_EINVAL invalid argument
1634  * @retval      PMINFO_R_ERROR  internal error
1635  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1636  * @post                None
1637  * @see         pkgmgrinfo_pkginfo_get_pkgid()
1638  * @see         pkgmgrinfo_pkginfo_is_removable()
1639  * @code
1640 static int get_pkg_type(const char *pkgid)
1641 {
1642         int ret = 0;
1643         char *type = NULL;
1644         pkgmgrinfo_pkginfo_h handle;
1645         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1646         if (ret != PMINFO_R_OK)
1647                 return -1;
1648         ret = pkgmgrinfo_pkginfo_get_type(handle, &type);
1649         if (ret != PMINFO_R_OK) {
1650                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1651                 return -1;
1652         }
1653         printf("pkgtype: %s\n", type);
1654         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1655         return 0;
1656 }
1657  * @endcode
1658  */
1659 int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle);
1660
1661 /**
1662  * @fn int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1663  * @brief       This API creates the package information filter handle from db.  All filter properties will be ANDed.
1664  The query will search the entire package information collected from the manifest file of all the installed packages
1665  *
1666  * @par         This API is for package-manager client application
1667  * @par Sync (or) Async : Synchronous API
1668  *
1669  * @param[out] handle           pointer to the package info filter handle.
1670  * @return      0 if success, error code(<0) if fail
1671  * @retval      PMINFO_R_OK     success
1672  * @retval      PMINFO_R_EINVAL invalid argument
1673  * @retval      PMINFO_R_ERROR  internal error
1674  * @pre         None
1675  * @post                pkgmgrinfo_pkginfo_filter_destroy()
1676  * @see         pkgmgrinfo_pkginfo_filter_count()
1677  * @see         pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
1678  * @code
1679 static int get_rpm_pkg_count()
1680 {
1681         int ret = 0;
1682         int count = 0;
1683         pkgmgrinfo_pkginfo_filter_h handle;
1684         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1685         if (ret != PMINFO_R_OK)
1686                 return -1;
1687         ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, "rpm");
1688         if (ret != PMINFO_R_OK) {
1689                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1690                 return -1;
1691         }
1692         ret = pkgmgrinfo_pkginfo_filter_count(handle, &count);
1693         if (ret != PMINFO_R_OK) {
1694                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1695                 return -1;
1696         }
1697         printf("No of rpm pkgs: %d\n", count);
1698         pkgmgrinfo_pkginfo_filter_destroy(handle);
1699         return 0;
1700 }
1701  * @endcode
1702  */
1703 int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle);
1704
1705 /**
1706  * @fn int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1707  * @brief       This API destroys the package information filter handle freeing up all the resources
1708  *
1709  * @par         This API is for package-manager client application
1710  * @par Sync (or) Async : Synchronous API
1711  *
1712  * @param[in] handle            pointer to the package info filter handle.
1713  * @return      0 if success, error code(<0) if fail
1714  * @retval      PMINFO_R_OK     success
1715  * @retval      PMINFO_R_EINVAL invalid argument
1716  * @retval      PMINFO_R_ERROR  internal error
1717  * @pre         pkgmgrinfo_pkginfo_filter_create()
1718  * @post                None
1719  * @see         pkgmgrinfo_pkginfo_filter_count()
1720  * @see         pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
1721  * @code
1722 static int get_rpm_pkg_count()
1723 {
1724         int ret = 0;
1725         int count = 0;
1726         pkgmgrinfo_pkginfo_filter_h handle;
1727         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1728         if (ret != PMINFO_R_OK)
1729                 return -1;
1730         ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, "rpm");
1731         if (ret != PMINFO_R_OK) {
1732                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1733                 return -1;
1734         }
1735         ret = pkgmgrinfo_pkginfo_filter_count(handle, &count);
1736         if (ret != PMINFO_R_OK) {
1737                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1738                 return -1;
1739         }
1740         printf("No of rpm pkgs: %d\n", count);
1741         pkgmgrinfo_pkginfo_filter_destroy(handle);
1742         return 0;
1743 }
1744  * @endcode
1745  */
1746 int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle);
1747
1748 /**
1749  * @fn int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle, const char *property, const bool value)
1750  * @brief       This API adds a boolean filter property to the filter handle
1751  *
1752  * @par         This API is for package-manager client application
1753  * @par Sync (or) Async : Synchronous API
1754  *
1755  * @param[in] handle            pointer to the package info filter handle.
1756  * @param[in] property          boolean property name.
1757  * @param[in] value             value corresponding to the property.
1758  * @return      0 if success, error code(<0) if fail
1759  * @retval      PMINFO_R_OK     success
1760  * @retval      PMINFO_R_EINVAL invalid argument
1761  * @retval      PMINFO_R_ERROR  internal error
1762  * @pre         pkgmgrinfo_pkginfo_filter_create()
1763  * @post                pkgmgrinfo_pkginfo_filter_destroy()
1764  * @see         pkgmgrinfo_pkginfo_filter_count()
1765  * @see         pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
1766  * @code
1767 static int get_preload_pkg_count()
1768 {
1769         int ret = 0;
1770         int count = 0;
1771         pkgmgrinfo_pkginfo_filter_h handle;
1772         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1773         if (ret != PMINFO_R_OK)
1774                 return -1;
1775         ret = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, 1);
1776         if (ret != PMINFO_R_OK) {
1777                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1778                 return -1;
1779         }
1780         ret = pkgmgrinfo_pkginfo_filter_count(handle, &count);
1781         if (ret != PMINFO_R_OK) {
1782                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1783                 return -1;
1784         }
1785         printf("No of preload pkgs: %d\n", count);
1786         pkgmgrinfo_pkginfo_filter_destroy(handle);
1787         return 0;
1788 }
1789  * @endcode
1790  */
1791 int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1792                 const char *property, const bool value);
1793
1794 /**
1795  * @fn int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle, const char *property, const int value)
1796  * @brief       This API adds an integer filter property to the filter handle
1797  *
1798  * @par         This API is for package-manager client application
1799  * @par Sync (or) Async : Synchronous API
1800  *
1801  * @param[in] handle            pointer to the package info filter handle.
1802  * @param[in] property          integer property name.
1803  * @param[in] value             value corresponding to the property.
1804  * @return      0 if success, error code(<0) if fail
1805  * @retval      PMINFO_R_OK     success
1806  * @retval      PMINFO_R_EINVAL invalid argument
1807  * @retval      PMINFO_R_ERROR  internal error
1808  * @pre         pkgmgrinfo_pkginfo_filter_create()
1809  * @post                pkgmgrinfo_pkginfo_filter_destroy()
1810  * @see         pkgmgrinfo_pkginfo_filter_count()
1811  * @see         pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
1812  * @code
1813 static int get_pkg_count()
1814 {
1815         int ret = 0;
1816         int count = 0;
1817         pkgmgrinfo_pkginfo_filter_h handle;
1818         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1819         if (ret != PMINFO_R_OK)
1820                 return -1;
1821         ret = pkgmgrinfo_pkginfo_filter_add_int(handle, PMINFO_PKGINFO_PROP_PACKAGE_SIZE, 10);
1822         if (ret != PMINFO_R_OK) {
1823                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1824                 return -1;
1825         }
1826         ret = pkgmgrinfo_pkginfo_filter_count(handle, &count);
1827         if (ret != PMINFO_R_OK) {
1828                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1829                 return -1;
1830         }
1831         printf("No of preload pkgs: %d\n", count);
1832         pkgmgrinfo_pkginfo_filter_destroy(handle);
1833         return 0;
1834 }
1835  * @endcode
1836  */
1837 int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1838                 const char *property, const int value);
1839
1840 /**
1841  * @fn int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle, const char *property, const char *value)
1842  * @brief       This API adds a string filter property to the filter handle
1843  *
1844  * @par         This API is for package-manager client application
1845  * @par Sync (or) Async : Synchronous API
1846  *
1847  * @param[in] handle            pointer to the package info filter handle.
1848  * @param[in] property          string property name.
1849  * @param[in] value             value corresponding to the property.
1850  * @return      0 if success, error code(<0) if fail
1851  * @retval      PMINFO_R_OK     success
1852  * @retval      PMINFO_R_EINVAL invalid argument
1853  * @retval      PMINFO_R_ERROR  internal error
1854  * @pre         pkgmgrinfo_pkginfo_filter_create()
1855  * @post                pkgmgrinfo_pkginfo_filter_destroy()
1856  * @see         pkgmgrinfo_pkginfo_filter_count()
1857  * @see         pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
1858  * @code
1859 static int get_rpm_pkg_count()
1860 {
1861         int ret = 0;
1862         int count = 0;
1863         pkgmgrinfo_pkginfo_filter_h handle;
1864         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1865         if (ret != PMINFO_R_OK)
1866                 return -1;
1867         ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, "rpm");
1868         if (ret != PMINFO_R_OK) {
1869                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1870                 return -1;
1871         }
1872         ret = pkgmgrinfo_pkginfo_filter_count(handle, &count);
1873         if (ret != PMINFO_R_OK) {
1874                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1875                 return -1;
1876         }
1877         printf("No of rpm pkgs: %d\n", count);
1878         pkgmgrinfo_pkginfo_filter_destroy(handle);
1879         return 0;
1880 }
1881  * @endcode
1882  */
1883 int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1884                 const char *property, const char *value);
1885
1886 /**
1887  * @fn int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle, pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1888  * @brief       This API executes the user supplied callback function for each package that satisfy the filter conditions
1889  *
1890  * @par         This API is for package-manager client application
1891  * @par Sync (or) Async : Synchronous API
1892  *
1893  * @param[in] handle            pointer to the package info filter handle.
1894  * @param[in] pkg_cb            callback function.
1895  * @param[in] user_data         user data to be passed to the callback function
1896  * @return      0 if success, error code(<0) if fail
1897  * @retval      PMINFO_R_OK     success
1898  * @retval      PMINFO_R_EINVAL invalid argument
1899  * @retval      PMINFO_R_ERROR  internal error
1900  * @pre         pkgmgrinfo_pkginfo_filter_create()
1901  * @post                pkgmgrinfo_pkginfo_filter_destroy()
1902  * @see         pkgmgrinfo_pkginfo_filter_count()
1903  * @code
1904 int pkg_list_cb(pkgmgrinfo_pkginfo_h handle, void *user_data)
1905 {
1906         char *pkgid = NULL;
1907         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1908         printf("pkg id : %s\n", pkgid);
1909         return 0;
1910 }
1911
1912 static int get_rpm_pkg_list()
1913 {
1914         int ret = 0;
1915         pkgmgrinfo_pkginfo_filter_h handle;
1916         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1917         if (ret != PMINFO_R_OK)
1918                 return -1;
1919         ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, "rpm");
1920         if (ret != PMINFO_R_OK) {
1921                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1922                 return -1;
1923         }
1924         ret = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, pkg_list_cb, NULL);
1925         if (ret != PMINFO_R_OK) {
1926                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1927                 return -1;
1928         }
1929         pkgmgrinfo_pkginfo_filter_destroy(handle);
1930         return 0;
1931 }
1932  * @endcode
1933  */
1934 int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1935                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data);
1936
1937 /**
1938  * @fn int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1939  * @brief       This API counts the package that satisfy the filter conditions
1940  *
1941  * @par         This API is for package-manager client application
1942  * @par Sync (or) Async : Synchronous API
1943  *
1944  * @param[in] handle            pointer to the package info filter handle.
1945  * @param[in] count             pointer to store the count value.
1946  * @return      0 if success, error code(<0) if fail
1947  * @retval      PMINFO_R_OK     success
1948  * @retval      PMINFO_R_EINVAL invalid argument
1949  * @retval      PMINFO_R_ERROR  internal error
1950  * @pre         pkgmgrinfo_pkginfo_filter_create()
1951  * @post                pkgmgrinfo_pkginfo_filter_destroy()
1952  * @see         pkgmgrinfo_pkginfo_filter_foreach_pkginfo()
1953  * @code
1954 static int get_rpm_pkg_count()
1955 {
1956         int ret = 0;
1957         int count = 0;
1958         pkgmgrinfo_pkginfo_filter_h handle;
1959         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
1960         if (ret != PMINFO_R_OK)
1961                 return -1;
1962         ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, "rpm");
1963         if (ret != PMINFO_R_OK) {
1964                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1965                 return -1;
1966         }
1967         ret = pkgmgrinfo_pkginfo_filter_count(handle, &count);
1968         if (ret != PMINFO_R_OK) {
1969                 pkgmgrinfo_pkginfo_filter_destroy(handle);
1970                 return -1;
1971         }
1972         printf("No of rpm pkgs: %d\n", count);
1973         pkgmgrinfo_pkginfo_filter_destroy(handle);
1974         return 0;
1975 }
1976  * @endcode
1977  */
1978 int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count);
1979
1980 /**
1981  * @fn  int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1982                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data);
1983  * @brief       This API gets the list of privilege for a particular package
1984  *
1985  * @par         This API is for package-manager client application
1986  * @par Sync (or) Async : Synchronous API
1987  * @param[in]   handle          pointer to the package info handle.
1988  * @param[in]   privilege_func          callback function for list
1989  * @param[in] user_data user data to be passed to callback function
1990  * @return      0 if success, error code(<0) if fail
1991  * @retval      PMINFO_R_OK     success
1992  * @retval      PMINFO_R_EINVAL invalid argument
1993  * @retval      PMINFO_R_ERROR  internal error
1994  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
1995  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
1996  * @code
1997 int privilege_func(const char *name, void *user_data)
1998 {
1999         if (strcmp(name, (char *)user_data) == 0)
2000                 return -1;
2001         else
2002                 return 0;
2003 }
2004
2005 static int list_privilege(const char *package, char *privilege)
2006 {
2007         int ret = 0;
2008         pkgmgrinfo_pkginfo_h handle;
2009         ret = pkgmgrinfo_pkginfo_get_pkginfo(package, &handle);
2010         if (ret != PMINFO_R_OK)
2011                 return -1;
2012         ret = pkgmgrinfo_pkginfo_foreach_privilege(handle, privilege_func, (void *)privilege);
2013         if (ret != PMINFO_R_OK) {
2014                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2015                 return -1;
2016         }
2017         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2018         return 0;
2019 }
2020  * @endcode
2021  */
2022 int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
2023                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data);
2024
2025 /**
2026  * @fn  int pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_app_component component,
2027  pkgmgrinfo_app_list_cb app_func, void *user_data)
2028  * @brief       This API gets list of installed applications for a particular package
2029  *
2030  * @par         This API is for package-manager client application
2031  * @par Sync (or) Async : Synchronous API
2032  * @param[in]   handle          package info handle
2033  * @param[in]   component       application component
2034  * @param[in]   app_func                iteration function for list
2035  * @param[in] user_data user data to be passed to callback function
2036  * @return      0 if success, error code(<0) if fail
2037  * @retval      PMINFO_R_OK     success
2038  * @retval      PMINFO_R_EINVAL invalid argument
2039  * @retval      PMINFO_R_ERROR  internal error
2040  * @pre         pkgmgrinfo_pkginfo_get_pkginfo()
2041  * @post                pkgmgrinfo_pkginfo_destroy_pkginfo()
2042  * @code
2043 int app_func(pkgmgrinfo_appinfo_h handle, void *user_data)
2044 {
2045         char *appid = NULL;
2046         pkgmgrinfo_appinfo_get_appid(handle, &appid);
2047         printf("appid : %s\n", appid);
2048         return 0;
2049 }
2050
2051 static int list_apps(const char *pkgid)
2052 {
2053         int ret = 0;
2054         pkgmgrinfo_pkginfo_h handle;
2055         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
2056         if (ret != PMINFO_R_OK)
2057                 return -1;
2058         ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_UI_APP, app_func, NULL);
2059         if (ret != PMINFO_R_OK) {
2060                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2061                 return -1;
2062         }
2063         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2064         return 0;
2065 }
2066  * @endcode
2067  */
2068 int pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_app_component component,
2069                                                         pkgmgrinfo_app_list_cb app_func, void *user_data);
2070 /**
2071  * @fn  int pkgmgrinfo_appinfo_get_install_list(pkgmgrinfo_app_list_cb app_func, void *user_data);
2072  * @brief       This API gets list of installed applications from all packages with  minimum informaion.
2073  *
2074  * @par         This API is for package-manager client application
2075  * @par Sync (or) Async : Synchronous API
2076  * @param[in]   app_func                iteration function for list
2077  * @param[in] user_data user data to be passed to callback function
2078  * @return      0 if success, error code(<0) if fail
2079  * @retval      PMINFO_R_OK     success
2080  * @retval      PMINFO_R_EINVAL invalid argument
2081  * @retval      PMINFO_R_ERROR  internal error
2082  * @pre         None
2083  * @post                None
2084  * @code
2085 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
2086 {
2087         char *pkgid1 = NULL;
2088         char *pkgid2 = NULL;
2089         pkgid1 = (char *)user_data;
2090         pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid2);
2091         if (strcmp(pkgid1, pkgid2) == 0) {
2092                 return -1;
2093         } else {
2094                 return 0;
2095         }
2096 }
2097
2098 static int list_apps()
2099 {
2100         int ret = 0;
2101         char *name = "helloworld";
2102         ret = pkgmgrinfo_appinfo_get_install_list(app_list_cb, (void *)name);
2103         if (ret != PMINFO_R_OK) {
2104                 return -1;
2105         }
2106         return 0;
2107 }
2108  * @endcode
2109  */
2110 int pkgmgrinfo_appinfo_get_install_list(pkgmgrinfo_app_list_cb app_func, void *user_data);
2111
2112 /**
2113  * @fn  int pkgmgrinfo_appinfo_get_installed_list(pkgmgrinfo_app_list_cb app_func, void *user_data);
2114  * @brief       This API gets list of installed applications from all packages.
2115  *
2116  * @par         This API is for package-manager client application
2117  * @par Sync (or) Async : Synchronous API
2118  * @param[in]   app_func                iteration function for list
2119  * @param[in] user_data user data to be passed to callback function
2120  * @return      0 if success, error code(<0) if fail
2121  * @retval      PMINFO_R_OK     success
2122  * @retval      PMINFO_R_EINVAL invalid argument
2123  * @retval      PMINFO_R_ERROR  internal error
2124  * @pre         None
2125  * @post                None
2126  * @code
2127 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
2128 {
2129         char *pkgid1 = NULL;
2130         char *pkgid2 = NULL;
2131         pkgid1 = (char *)user_data;
2132         pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid2);
2133         if (strcmp(pkgid1, pkgid2) == 0) {
2134                 return -1;
2135         } else {
2136                 return 0;
2137         }
2138 }
2139
2140 static int list_apps()
2141 {
2142         int ret = 0;
2143         char *name = "helloworld";
2144         ret = pkgmgrinfo_appinfo_get_installed_list(app_list_cb, (void *)name);
2145         if (ret != PMINFO_R_OK) {
2146                 return -1;
2147         }
2148         return 0;
2149 }
2150  * @endcode
2151  */
2152 int pkgmgrinfo_appinfo_get_installed_list(pkgmgrinfo_app_list_cb app_func, void *user_data);
2153
2154 /**
2155  * @fn int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle)
2156  * @brief       This API creates the application information handle from db
2157  *
2158  * @par         This API is for package-manager client application
2159  * @par Sync (or) Async : Synchronous API
2160  *
2161  * @param[in]   appid   pointer to appid
2162  * @param[out] handle           pointer to the application info handle.
2163  * @return      0 if success, error code(<0) if fail
2164  * @retval      PMINFO_R_OK     success
2165  * @retval      PMINFO_R_EINVAL invalid argument
2166  * @retval      PMINFO_R_ERROR  internal error
2167  * @pre         None
2168  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2169  * @see         pkgmgrinfo_appinfo_get_pkgid()
2170  * @see         pkgmgrinfo_appinfo_is_multiple()
2171  * @code
2172 static int get_app_type(const char *appid)
2173 {
2174         int ret = 0;
2175         char *type = NULL;
2176         pkgmgrinfo_appinfo_h handle;
2177         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2178         if (ret != PMINFO_R_OK)
2179                 return -1;
2180         ret = pkgmgrinfo_appinfo_get_apptype(handle, &type);
2181         if (ret != PMINFO_R_OK) {
2182                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2183                 return -1;
2184         }
2185         printf("apptype: %s\n", type);
2186         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2187         return 0;
2188 }
2189  * @endcode
2190  */
2191 int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle);
2192
2193 /**
2194  * @fn int pkgmgrinfo_appinfo_get_appid(pkgmgrinfo_appinfo_h handle, char **appid)
2195  * @brief       This API gets the application ID
2196  *
2197  * @par         This API is for package-manager client application
2198  * @par Sync (or) Async : Synchronous API
2199  *
2200  * @param[in] handle            pointer to the application info handle.
2201  * @param[out] appid            pointer to hold appid
2202  * @return      0 if success, error code(<0) if fail
2203  * @retval      PMINFO_R_OK     success
2204  * @retval      PMINFO_R_EINVAL invalid argument
2205  * @retval      PMINFO_R_ERROR  internal error
2206  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2207  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2208  * @see         pkgmgrinfo_appinfo_get_pkgid()
2209  * @see         pkgmgrinfo_appinfo_is_multiple()
2210  * @code
2211 static int get_app_id(const char *appid)
2212 {
2213         int ret = 0;
2214         char *app_id = NULL;
2215         pkgmgrinfo_appinfo_h handle;
2216         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2217         if (ret != PMINFO_R_OK)
2218                 return -1;
2219         ret = pkgmgrinfo_appinfo_get_appid(handle, &app_id);
2220         if (ret != PMINFO_R_OK) {
2221                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2222                 return -1;
2223         }
2224         printf("app id: %s\n", app_id);
2225         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2226         return 0;
2227 }
2228  * @endcode
2229  */
2230 int pkgmgrinfo_appinfo_get_appid(pkgmgrinfo_appinfo_h  handle, char **appid);
2231
2232 /**
2233  * @fn int pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo_h handle, char **pkg_name)
2234  * @brief       This API gets the package name of the application
2235  *
2236  * @par         This API is for package-manager client application
2237  * @par Sync (or) Async : Synchronous API
2238  *
2239  * @param[in] handle            pointer to the application info handle.
2240  * @param[out] pkg_name         pointer to hold package name
2241  * @return      0 if success, error code(<0) if fail
2242  * @retval      PMINFO_R_OK     success
2243  * @retval      PMINFO_R_EINVAL invalid argument
2244  * @retval      PMINFO_R_ERROR  internal error
2245  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2246  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2247  * @see         pkgmgrinfo_appinfo_get_appid()
2248  * @see         pkgmgrinfo_appinfo_is_multiple()
2249  * @code
2250 static int get_app_pkgname(const char *appid)
2251 {
2252         int ret = 0;
2253         char *pkgname = NULL;
2254         pkgmgrinfo_appinfo_h handle;
2255         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2256         if (ret != PMINFO_R_OK)
2257                 return -1;
2258         ret = pkgmgrinfo_appinfo_get_pkgname(handle, &pkgname);
2259         if (ret != PMINFO_R_OK) {
2260                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2261                 return -1;
2262         }
2263         printf("pkg name: %s\n", pkgname);
2264         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2265         return 0;
2266 }
2267  * @endcode
2268  */
2269 int pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo_h  handle, char **pkg_name);
2270
2271 /**
2272  * @fn int pkgmgrinfo_appinfo_get_pkgid(pkgmgrinfo_appinfo_h handle, char **pkgid)
2273  * @brief       This API gets the package id of the application
2274  *
2275  * @par         This API is for package-manager client application
2276  * @par Sync (or) Async : Synchronous API
2277  *
2278  * @param[in] handle            pointer to the application info handle.
2279  * @param[out] pkgid            pointer to hold package id
2280  * @return      0 if success, error code(<0) if fail
2281  * @retval      PMINFO_R_OK     success
2282  * @retval      PMINFO_R_EINVAL invalid argument
2283  * @retval      PMINFO_R_ERROR  internal error
2284  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2285  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2286  * @see         pkgmgrinfo_appinfo_get_appid()
2287  * @see         pkgmgrinfo_appinfo_is_multiple()
2288  * @code
2289 static int get_app_pkgid(const char *appid)
2290 {
2291         int ret = 0;
2292         char *pkgid = NULL;
2293         pkgmgrinfo_appinfo_h handle;
2294         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2295         if (ret != PMINFO_R_OK)
2296                 return -1;
2297         ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
2298         if (ret != PMINFO_R_OK) {
2299                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2300                 return -1;
2301         }
2302         printf("pkg id: %s\n", pkgid);
2303         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2304         return 0;
2305 }
2306  * @endcode
2307  */
2308 int pkgmgrinfo_appinfo_get_pkgid(pkgmgrinfo_appinfo_h  handle, char **pkgid);
2309
2310 /**
2311  * @fn int pkgmgrinfo_appinfo_get_exec(pkgmgrinfo_appinfo_h handle, char **exec)
2312  * @brief       This API gets the executable name of the application
2313  *
2314  * @par         This API is for package-manager client application
2315  * @par Sync (or) Async : Synchronous API
2316  *
2317  * @param[in] handle            pointer to the application info handle.
2318  * @param[out] exec             pointer to hold app exec name
2319  * @return      0 if success, error code(<0) if fail
2320  * @retval      PMINFO_R_OK     success
2321  * @retval      PMINFO_R_EINVAL invalid argument
2322  * @retval      PMINFO_R_ERROR  internal error
2323  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2324  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2325  * @see         pkgmgrinfo_appinfo_get_appid()
2326  * @see         pkgmgrinfo_appinfo_is_multiple()
2327  * @code
2328 static int get_app_exec(const char *appid)
2329 {
2330         int ret = 0;
2331         char *exec = NULL;
2332         pkgmgrinfo_appinfo_h handle;
2333         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2334         if (ret != PMINFO_R_OK)
2335                 return -1;
2336         ret = pkgmgrinfo_appinfo_get_exec(handle, &exec);
2337         if (ret != PMINFO_R_OK) {
2338                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2339                 return -1;
2340         }
2341         printf("exec name: %s\n", exec);
2342         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2343         return 0;
2344 }
2345  * @endcode
2346  */
2347 int pkgmgrinfo_appinfo_get_exec(pkgmgrinfo_appinfo_h  handle, char **exec);
2348
2349 /**
2350  * @fn int pkgmgrinfo_appinfo_get_icon(pkgmgrinfo_appinfo_h handle, char **icon)
2351  * @brief       This API gets the icon name of the application
2352  *
2353  * @par         This API is for package-manager client application
2354  * @par Sync (or) Async : Synchronous API
2355  *
2356  * @param[in] handle            pointer to the application info handle.
2357  * @param[out] icon             pointer to hold app icon name
2358  * @return      0 if success, error code(<0) if fail
2359  * @retval      PMINFO_R_OK     success
2360  * @retval      PMINFO_R_EINVAL invalid argument
2361  * @retval      PMINFO_R_ERROR  internal error
2362  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2363  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2364  * @see         pkgmgrinfo_appinfo_get_appid()
2365  * @see         pkgmgrinfo_appinfo_is_multiple()
2366  * @code
2367 static int get_app_icon(const char *appid)
2368 {
2369         int ret = 0;
2370         char *icon = NULL;
2371         pkgmgrinfo_appinfo_h handle;
2372         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2373         if (ret != PMINFO_R_OK)
2374                 return -1;
2375         ret = pkgmgrinfo_appinfo_get_icon(handle, &icon);
2376         if (ret != PMINFO_R_OK) {
2377                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2378                 return -1;
2379         }
2380         printf("icon name: %s\n", icon);
2381         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2382         return 0;
2383 }
2384  * @endcode
2385  */
2386 int pkgmgrinfo_appinfo_get_icon(pkgmgrinfo_appinfo_h  handle, char **icon);
2387
2388 /**
2389  * @fn int pkgmgrinfo_appinfo_get_label(pkgmgrinfo_appinfo_h handle, char **label)
2390  * @brief       This API gets the label of the application
2391  *
2392  * @par         This API is for package-manager client application
2393  * @par Sync (or) Async : Synchronous API
2394  *
2395  * @param[in] handle            pointer to the application info handle.
2396  * @param[out] label            pointer to hold app label
2397  * @return      0 if success, error code(<0) if fail
2398  * @retval      PMINFO_R_OK     success
2399  * @retval      PMINFO_R_EINVAL invalid argument
2400  * @retval      PMINFO_R_ERROR  internal error
2401  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2402  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2403  * @see         pkgmgrinfo_appinfo_get_appid()
2404  * @see         pkgmgrinfo_appinfo_is_multiple()
2405  * @code
2406 static int get_app_label(const char *appid)
2407 {
2408         int ret = 0;
2409         char *label = NULL;
2410         pkgmgrinfo_appinfo_h handle;
2411         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2412         if (ret != PMINFO_R_OK)
2413                 return -1;
2414         ret = pkgmgrinfo_appinfo_get_label(handle, &label);
2415         if (ret != PMINFO_R_OK) {
2416                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2417                 return -1;
2418         }
2419         printf("label : %s\n", label);
2420         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2421         return 0;
2422 }
2423  * @endcode
2424  */
2425 int pkgmgrinfo_appinfo_get_label(pkgmgrinfo_appinfo_h  handle, char **label);
2426
2427 /**
2428  * @fn int pkgmgrinfo_appinfo_get_component(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_app_component *component)
2429  * @brief       This API gets the component of the application
2430  *
2431  * @par         This API is for package-manager client application
2432  * @par Sync (or) Async : Synchronous API
2433  *
2434  * @param[in] handle            pointer to the application info handle.
2435  * @param[out] component                pointer to hold app component
2436  * @return      0 if success, error code(<0) if fail
2437  * @retval      PMINFO_R_OK     success
2438  * @retval      PMINFO_R_EINVAL invalid argument
2439  * @retval      PMINFO_R_ERROR  internal error
2440  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2441  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2442  * @see         pkgmgrinfo_appinfo_get_appid()
2443  * @see         pkgmgrinfo_appinfo_is_multiple()
2444  * @code
2445 static int get_app_component(const char *appid)
2446 {
2447         int ret = 0;
2448         pkgmgrinfo_app_component component;
2449         pkgmgrinfo_appinfo_h handle;
2450         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2451         if (ret != PMINFO_R_OK)
2452                 return -1;
2453         ret = pkgmgrinfo_appinfo_get_component(handle, &component);
2454         if (ret != PMINFO_R_OK) {
2455                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2456                 return -1;
2457         }
2458         printf("component : %s\n", component);
2459         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2460         return 0;
2461 }
2462  * @endcode
2463  */
2464 int pkgmgrinfo_appinfo_get_component(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_app_component *component);
2465
2466 /**
2467  * @fn int pkgmgrinfo_appinfo_get_apptype(pkgmgrinfo_appinfo_h handle, char **app_type)
2468  * @brief       This API gets the apptype of the application
2469  *
2470  * @par         This API is for package-manager client application
2471  * @par Sync (or) Async : Synchronous API
2472  *
2473  * @param[in] handle            pointer to the application info handle.
2474  * @param[out] app_type         pointer to hold apptype
2475  * @return      0 if success, error code(<0) if fail
2476  * @retval      PMINFO_R_OK     success
2477  * @retval      PMINFO_R_EINVAL invalid argument
2478  * @retval      PMINFO_R_ERROR  internal error
2479  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2480  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2481  * @see         pkgmgrinfo_appinfo_get_appid()
2482  * @see         pkgmgrinfo_appinfo_is_multiple()
2483  * @code
2484 static int get_app_type(const char *appid)
2485 {
2486         int ret = 0;
2487         char *apptype = NULL;
2488         pkgmgrinfo_appinfo_h handle;
2489         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2490         if (ret != PMINFO_R_OK)
2491                 return -1;
2492         ret = pkgmgrinfo_appinfo_get_apptype(handle, &apptype);
2493         if (ret != PMINFO_R_OK) {
2494                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2495                 return -1;
2496         }
2497         printf("apptype : %s\n", apptype);
2498         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2499         return 0;
2500 }
2501  * @endcode
2502  */
2503 int pkgmgrinfo_appinfo_get_apptype(pkgmgrinfo_appinfo_h  handle, char **app_type);
2504
2505 /**
2506  * @fn int pkgmgrinfo_appinfo_get_operation(pkgmgrinfo_appcontrol_h  handle,
2507                                                                                 int *operation_count, char ***operation)
2508  * @brief       This API gets the list of operation of the application
2509  *
2510  * @par         This API is for package-manager client application
2511  * @par Sync (or) Async : Synchronous API
2512  *
2513  * @param[in] handle            pointer to the appcontrol handle.
2514  * @param[out] operation_count          pointer to hold number of operations
2515  * @param[out] operation                pointer to hold list of operations
2516  * @return      0 if success, error code(<0) if fail
2517  * @retval      PMINFO_R_OK     success
2518  * @retval      PMINFO_R_EINVAL invalid argument
2519  * @retval      PMINFO_R_ERROR  internal error
2520  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2521  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2522  * @see         pkgmgrinfo_appinfo_get_uri()
2523  * @see         pkgmgrinfo_appinfo_get_mime()
2524  * @code
2525 int appcontrol_func(pkgmgrinfo_appcontrol_h handle, void *user_data)
2526 {
2527         int oc = 0;
2528         int i = 0;
2529         char **operation;
2530         pkgmgrinfo_appinfo_get_operation(handle, &oc, &operation);
2531         for (i = 0; i < oc; i++) {
2532                 if (strcmp(operation[i], (char *)user_data) == 0)
2533                         return -1;
2534                 else
2535                         return 0;
2536         }
2537 }
2538
2539 static int check_operation(const char *appid, char *operation)
2540 {
2541         int ret = 0;
2542         pkgmgrinfo_appinfo_h handle;
2543         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2544         if (ret != PMINFO_R_OK)
2545                 return -1;
2546         ret = pkgmgrinfo_appinfo_foreach_appcontrol(handle, appcontrol_func, (void *)operation);
2547         if (ret != PMINFO_R_OK) {
2548                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2549                 return -1;
2550         }
2551         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2552         return 0;
2553 }
2554  * @endcode
2555  */
2556 int pkgmgrinfo_appinfo_get_operation(pkgmgrinfo_appcontrol_h  handle,
2557                                                                                 int *operation_count, char ***operation);
2558
2559 /**
2560  * @fn int pkgmgrinfo_appinfo_get_uri(pkgmgrinfo_appcontrol_h  handle,
2561                                                                                 int *uri_count, char ***uri)
2562  * @brief       This API gets the list of uri of the application
2563  *
2564  * @par         This API is for package-manager client application
2565  * @par Sync (or) Async : Synchronous API
2566  *
2567  * @param[in] handle            pointer to the appcontrol handle.
2568  * @param[out] uri_count                pointer to hold number of uris
2569  * @param[out] uri              pointer to hold list of uris
2570  * @return      0 if success, error code(<0) if fail
2571  * @retval      PMINFO_R_OK     success
2572  * @retval      PMINFO_R_EINVAL invalid argument
2573  * @retval      PMINFO_R_ERROR  internal error
2574  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2575  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2576  * @see         pkgmgrinfo_appinfo_get_operation()
2577  * @see         pkgmgrinfo_appinfo_get_mime()
2578  * @code
2579 int appcontrol_func(pkgmgrinfo_appcontrol_h handle, void *user_data)
2580 {
2581         int uc = 0;
2582         int i = 0;
2583         char **uri;
2584         pkgmgrinfo_appinfo_get_uri(handle, &uc, &uri);
2585         for (i = 0; i < uc; i++) {
2586                 if (strcmp(uri[i], (char *)user_data) == 0)
2587                         return -1;
2588                 else
2589                         return 0;
2590         }
2591 }
2592
2593 static int check_uri(const char *appid, char *uri)
2594 {
2595         int ret = 0;
2596         pkgmgrinfo_appinfo_h handle;
2597         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2598         if (ret != PMINFO_R_OK)
2599                 return -1;
2600         ret = pkgmgrinfo_appinfo_foreach_appcontrol(handle, appcontrol_func, (void *)uri);
2601         if (ret != PMINFO_R_OK) {
2602                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2603                 return -1;
2604         }
2605         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2606         return 0;
2607 }
2608  * @endcode
2609  */
2610 int pkgmgrinfo_appinfo_get_uri(pkgmgrinfo_appcontrol_h  handle,
2611                                                                                 int *uri_count, char ***uri);
2612
2613 /**
2614  * @fn int pkgmgrinfo_appinfo_get_mime(pkgmgrinfo_appcontrol_h  handle,
2615                                                                                 int *mime_count, char ***mime)
2616  * @brief       This API gets the list of mime of the application
2617  *
2618  * @par         This API is for package-manager client application
2619  * @par Sync (or) Async : Synchronous API
2620  *
2621  * @param[in] handle            pointer to the appcontrol handle.
2622  * @param[out] mime_count               pointer to hold number of mimes
2623  * @param[out] mime             pointer to hold list of mimes
2624  * @return      0 if success, error code(<0) if fail
2625  * @retval      PMINFO_R_OK     success
2626  * @retval      PMINFO_R_EINVAL invalid argument
2627  * @retval      PMINFO_R_ERROR  internal error
2628  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2629  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2630  * @see         pkgmgrinfo_appinfo_get_uri()
2631  * @see         pkgmgrinfo_appinfo_get_operation()
2632  * @code
2633 int appcontrol_func(pkgmgrinfo_appcontrol_h handle, void *user_data)
2634 {
2635         int mc = 0;
2636         int i = 0;
2637         char **mime;
2638         pkgmgrinfo_appinfo_get_operation(handle, &mc, &mime);
2639         for (i = 0; i < mc; i++) {
2640                 if (strcmp(mime[i], (char *)user_data) == 0)
2641                         return -1;
2642                 else
2643                         return 0;
2644         }
2645 }
2646
2647 static int check_mime(const char *appid, char *mime)
2648 {
2649         int ret = 0;
2650         pkgmgrinfo_appinfo_h handle;
2651         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2652         if (ret != PMINFO_R_OK)
2653                 return -1;
2654         ret = pkgmgrinfo_appinfo_foreach_appcontrol(handle, appcontrol_func, (void *)mime);
2655         if (ret != PMINFO_R_OK) {
2656                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2657                 return -1;
2658         }
2659         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2660         return 0;
2661 }
2662  * @endcode
2663  */
2664 int pkgmgrinfo_appinfo_get_mime(pkgmgrinfo_appcontrol_h  handle,
2665                                                                                 int *mime_count, char ***mime);
2666
2667 /**
2668  * @fn int pkgmgrinfo_appinfo_get_notification_icon(pkgmgrinfo_appinfo_h handle, char **icon)
2669  * @brief       This API gets the notification icon of the application
2670  *
2671  * @par         This API is for package-manager client application
2672  * @par Sync (or) Async : Synchronous API
2673  *
2674  * @param[in] handle            pointer to the application info handle.
2675  * @param[out] path             pointer to hold notification icon
2676  * @return      0 if success, error code(<0) if fail
2677  * @retval      PMINFO_R_OK     success
2678  * @retval      PMINFO_R_EINVAL invalid argument
2679  * @retval      PMINFO_R_ERROR  internal error
2680  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2681  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2682  * @see         pkgmgrinfo_appinfo_get_appid()
2683  * @see         pkgmgrinfo_appinfo_is_multiple()
2684  * @code
2685 static int get_app_notification_icon(const char *appid)
2686 {
2687         int ret = 0;
2688         char *notification_icon = NULL;
2689         pkgmgrinfo_appinfo_h handle;
2690         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2691         if (ret != PMINFO_R_OK)
2692                 return -1;
2693         ret = pkgmgrinfo_appinfo_get_notification_icon(handle, &notification_icon);
2694         if (ret != PMINFO_R_OK) {
2695                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2696                 return -1;
2697         }
2698         printf("notification icon : %s\n", notification_icon);
2699         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2700         return 0;
2701 }
2702  * @endcode
2703  */
2704 int pkgmgrinfo_appinfo_get_notification_icon(pkgmgrinfo_appinfo_h  handle, char **icon);
2705
2706 /**
2707  * @fn int pkgmgrinfo_appinfo_get_setting_icon(pkgmgrinfo_appinfo_h handle, char **icon)
2708  * @brief       This API gets the setting icon of the application
2709  *
2710  * @par         This API is for package-manager client application
2711  * @par Sync (or) Async : Synchronous API
2712  *
2713  * @param[in] handle            pointer to the application info handle.
2714  * @param[out] path             pointer to hold setting icon
2715  * @return      0 if success, error code(<0) if fail
2716  * @retval      PMINFO_R_OK     success
2717  * @retval      PMINFO_R_EINVAL invalid argument
2718  * @retval      PMINFO_R_ERROR  internal error
2719  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2720  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2721  * @see         pkgmgrinfo_appinfo_get_appid()
2722  * @see         pkgmgrinfo_appinfo_is_multiple()
2723  * @code
2724 static int get_app_setting_icon(const char *appid)
2725 {
2726         int ret = 0;
2727         char *setting_icon = NULL;
2728         pkgmgrinfo_appinfo_h handle;
2729         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2730         if (ret != PMINFO_R_OK)
2731                 return -1;
2732         ret = pkgmgrinfo_appinfo_get_setting_icon(handle, &setting_icon);
2733         if (ret != PMINFO_R_OK) {
2734                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2735                 return -1;
2736         }
2737         printf("setting icon : %s\n", setting_icon);
2738         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2739         return 0;
2740 }
2741  * @endcode
2742  */
2743 int pkgmgrinfo_appinfo_get_setting_icon(pkgmgrinfo_appinfo_h  handle, char **icon);
2744
2745 /**
2746  * @fn int pkgmgrinfo_appinfo_get_recent_image_type(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_app_recentimage *type)
2747  * @brief       This API gets the type of recent image on app-tray
2748  *
2749  * @par         This API is for package-manager client application
2750  * @par Sync (or) Async : Synchronous API
2751  *
2752  * @param[in] handle            pointer to the application info handle.
2753  * @param[out] type             pointer to hold image type
2754  * @return      0 if success, error code(<0) if fail
2755  * @retval      PMINFO_R_OK     success
2756  * @retval      PMINFO_R_EINVAL invalid argument
2757  * @retval      PMINFO_R_ERROR  internal error
2758  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2759  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2760  * @see         pkgmgrinfo_appinfo_get_appid()
2761  * @see         pkgmgrinfo_appinfo_is_multiple()
2762  * @code
2763 static int get_app_recent_image_type(const char *appid)
2764 {
2765         int ret = 0;
2766         pkgmgrinfo_app_recentimage type;
2767         pkgmgrinfo_appinfo_h handle;
2768         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2769         if (ret != PMINFO_R_OK)
2770                 return -1;
2771         ret = pkgmgrinfo_appinfo_get_recent_image_type(handle, &type);
2772         if (ret != PMINFO_R_OK) {
2773                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2774                 return -1;
2775         }
2776         printf("recent image type: %d\n", type);
2777         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2778         return 0;
2779 }
2780  * @endcode
2781  */
2782 int pkgmgrinfo_appinfo_get_recent_image_type(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_app_recentimage *type);
2783
2784
2785 /**
2786  * @fn int pkgmgrinfo_appinfo_get_preview_image(pkgmgrinfo_appinfo_h  handle, char **preview_img)
2787  * @brief       This API gets the preview image of application
2788  *
2789  * @par Sync (or) Async : Synchronous API
2790  *
2791  * @param[in] handle            pointer to the application info handle.
2792  * @param[out] preview_img              pointer to hold preview image path
2793  * @return      0 if success, error code(<0) if fail
2794  * @retval      PMINFO_R_OK     success
2795  * @retval      PMINFO_R_EINVAL invalid argument
2796  * @retval      PMINFO_R_ERROR  internal error
2797  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2798  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2799  * @see         pkgmgrinfo_appinfo_get_appid()
2800  * @code
2801 static int get_app_previewimage(const char *appid)
2802 {
2803         int ret = 0;
2804         char *preview = NULL;
2805         pkgmgrinfo_appinfo_h handle = NULL;
2806         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2807         if (ret != PMINFO_R_OK)
2808                 return -1;
2809         ret = pkgmgrinfo_appinfo_get_preview_image(handle, &preview);
2810         if (ret != PMINFO_R_OK) {
2811                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2812                 return -1;
2813         }
2814         printf("preview image path : %s\n", preview);
2815         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2816         return 0;
2817 }
2818  * @endcode
2819  */
2820 int pkgmgrinfo_appinfo_get_preview_image(pkgmgrinfo_appinfo_h  handle, char **preview_img);
2821
2822
2823 /**
2824  * @fn int pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_permission_type *permission)
2825  * @brief       This API gets the package permission type of the application
2826  *
2827  * @par         This API is for package-manager client application
2828  * @par Sync (or) Async : Synchronous API
2829  *
2830  * @param[in] handle            pointer to the application info handle.
2831  * @param[out] permission               pointer to hold package permission
2832  * @return      0 if success, error code(<0) if fail
2833  * @retval      PMINFO_R_OK     success
2834  * @retval      PMINFO_R_EINVAL invalid argument
2835  * @retval      PMINFO_R_ERROR  internal error
2836  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2837  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2838  * @see         pkgmgrinfo_appinfo_get_appid()
2839  * @code
2840 static int get_app_permission(const char *appid)
2841 {
2842         int ret = 0;
2843         pkgmgrinfo_permission_type permission = 0;
2844         pkgmgrinfo_appinfo_h handle;
2845
2846         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2847         if (ret != PMINFO_R_OK)
2848                 return -1;
2849         ret = pkgmgrinfo_appinfo_get_permission_type(handle, &permission);
2850         if (ret != PMINFO_R_OK) {
2851                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2852                 return -1;
2853         }
2854         printf("permission type: %d\n", permission);
2855         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2856         return 0;
2857 }
2858  * @endcode
2859  */
2860 int pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_permission_type *permission);
2861
2862 /**
2863  * @fn  int pkgmgrinfo_appinfo_foreach_permission(pkgmgrinfo_appinfo_h handle,
2864                         pkgmgrinfo_app_permission_list_cb permission_func, void *user_data);
2865  * @brief       This API gets the list of permission for a particular application
2866  *
2867  * @par         This API is for package-manager client application
2868  * @par Sync (or) Async : Synchronous API
2869  * @param[in]   handle          pointer to the application info handle.
2870  * @param[in]   permission_func         callback function for list
2871  * @param[in] user_data user data to be passed to callback function
2872  * @return      0 if success, error code(<0) if fail
2873  * @retval      PMINFO_R_OK     success
2874  * @retval      PMINFO_R_EINVAL invalid argument
2875  * @retval      PMINFO_R_ERROR  internal error
2876  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2877  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2878  * @code
2879 int permission_func(const char *name, void *user_data)
2880 {
2881         if (strcmp(name, (char *)user_data) == 0)
2882                 return -1;
2883         else
2884                 return 0;
2885 }
2886
2887 static int list_permission(const char *appid, char *permission)
2888 {
2889         int ret = 0;
2890         pkgmgrinfo_appinfo_h handle;
2891         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2892         if (ret != PMINFO_R_OK)
2893                 return -1;
2894         ret = pkgmgrinfo_appinfo_foreach_permission(handle, permission_func, (void *)permission);
2895         if (ret != PMINFO_R_OK) {
2896                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2897                 return -1;
2898         }
2899         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2900         return 0;
2901 }
2902  * @endcode
2903  */
2904 int pkgmgrinfo_appinfo_foreach_permission(pkgmgrinfo_appinfo_h handle,
2905                         pkgmgrinfo_app_permission_list_cb permission_func, void *user_data);
2906
2907 /**
2908  * @fn  int pkgmgrinfo_appinfo_foreach_category(pkgmgrinfo_appinfo_h handle,
2909                         pkgmgrinfo_app_category_list_cb category_func, void *user_data);
2910  * @brief       This API gets the list of category for a particular application
2911  *
2912  * @par         This API is for package-manager client application
2913  * @par Sync (or) Async : Synchronous API
2914  * @param[in]   handle          pointer to the application info handle.
2915  * @param[in]   category_func           callback function for list
2916  * @param[in] user_data user data to be passed to callback function
2917  * @return      0 if success, error code(<0) if fail
2918  * @retval      PMINFO_R_OK     success
2919  * @retval      PMINFO_R_EINVAL invalid argument
2920  * @retval      PMINFO_R_ERROR  internal error
2921  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2922  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2923  * @code
2924 int category_func(const char *name, void *user_data)
2925 {
2926         if (strcmp(name, (char *)user_data) == 0)
2927                 return -1;
2928         else
2929                 return 0;
2930 }
2931
2932 static int list_category(const char *appid, char *category)
2933 {
2934         int ret = 0;
2935         pkgmgrinfo_appinfo_h handle;
2936         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2937         if (ret != PMINFO_R_OK)
2938                 return -1;
2939         ret = pkgmgrinfo_appinfo_foreach_category(handle, category_func, (void *)category);
2940         if (ret != PMINFO_R_OK) {
2941                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2942                 return -1;
2943         }
2944         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2945         return 0;
2946 }
2947  * @endcode
2948  */
2949 int pkgmgrinfo_appinfo_foreach_category(pkgmgrinfo_appinfo_h handle,
2950                         pkgmgrinfo_app_category_list_cb category_func, void *user_data);
2951
2952 /**
2953  * @fn  int pkgmgrinfo_appinfo_foreach_metadata(pkgmgrinfo_appinfo_h handle,
2954                         pkgmgrinfo_app_metadata_list_cb metadata_func, void *user_data);
2955  * @brief       This API gets the list of metadata for a particular application
2956  *
2957  * @par         This API is for package-manager client application
2958  * @par Sync (or) Async : Synchronous API
2959  * @param[in]   handle          pointer to the application info handle.
2960  * @param[in]   metadata_func           callback function for list
2961  * @param[in] user_data user data to be passed to callback function
2962  * @return      0 if success, error code(<0) if fail
2963  * @retval      PMINFO_R_OK     success
2964  * @retval      PMINFO_R_EINVAL invalid argument
2965  * @retval      PMINFO_R_ERROR  internal error
2966  * @pre         pkgmgrinfo_appinfo_get_appinfo()
2967  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
2968  * @code
2969 int metadata_func(const char *key, const char *value, void *user_data)
2970 {
2971         if (strcmp(key, (char *)user_data) == 0) {
2972                 printf("Value is %s\n", value);
2973                 return -1;
2974         }
2975         else
2976                 return 0;
2977 }
2978
2979 static int list_metadata(const char *appid, char *key)
2980 {
2981         int ret = 0;
2982         pkgmgrinfo_appinfo_h handle;
2983         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
2984         if (ret != PMINFO_R_OK)
2985                 return -1;
2986         ret = pkgmgrinfo_appinfo_foreach_metadata(handle, metadata_func, (void *)key);
2987         if (ret != PMINFO_R_OK) {
2988                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
2989                 return -1;
2990         }
2991         pkgmgrinfo_appinfo_destroy_appinfo(handle);
2992         return 0;
2993 }
2994  * @endcode
2995  */
2996 int pkgmgrinfo_appinfo_foreach_metadata(pkgmgrinfo_appinfo_h handle,
2997                         pkgmgrinfo_app_metadata_list_cb metadata_func, void *user_data);
2998
2999
3000 /**
3001  * @fn  int pkgmgrinfo_appinfo_foreach_appcontrol(pkgmgrinfo_appinfo_h handle,
3002                         pkgmgrinfo_app_control_list_cb appcontrol_func, void *user_data);
3003  * @brief       This API gets the list of app-control for a particular application
3004  *
3005  * @par         This API is for package-manager client application
3006  * @par Sync (or) Async : Synchronous API
3007  * @param[in]   handle          pointer to the application info handle.
3008  * @param[in]   appcontrol_func         callback function for list
3009  * @param[in] user_data user data to be passed to callback function
3010  * @return      0 if success, error code(<0) if fail
3011  * @retval      PMINFO_R_OK     success
3012  * @retval      PMINFO_R_EINVAL invalid argument
3013  * @retval      PMINFO_R_ERROR  internal error
3014  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3015  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3016  * @code
3017 int appcontrol_func(pkgmgrinfo_appcontrol_h handle, void *user_data)
3018 {
3019         int oc = 0;
3020         int i = 0;
3021         char **operation;
3022         pkgmgrinfo_appinfo_get_operation(handle, &oc, &operation);
3023         for (i = 0; i < oc; i++) {
3024                 if (strcmp(operation[i], (char *)user_data) == 0)
3025                         return -1;
3026                 else
3027                         return 0;
3028         }
3029 }
3030
3031 static int check_operation(const char *appid, char *operation)
3032 {
3033         int ret = 0;
3034         pkgmgrinfo_appinfo_h handle;
3035         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3036         if (ret != PMINFO_R_OK)
3037                 return -1;
3038         ret = pkgmgrinfo_appinfo_foreach_appcontrol(handle, appcontrol_func, (void *)operation);
3039         if (ret != PMINFO_R_OK) {
3040                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3041                 return -1;
3042         }
3043         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3044         return 0;
3045 }
3046  * @endcode
3047  */
3048 int pkgmgrinfo_appinfo_foreach_appcontrol(pkgmgrinfo_appinfo_h handle,
3049                         pkgmgrinfo_app_control_list_cb appcontrol_func, void *user_data);
3050
3051 /**
3052  * @fn int pkgmgrinfo_appinfo_is_nodisplay(pkgmgrinfo_appinfo_h handle, bool *nodisplay)
3053  * @brief       This API gets the application 'nodisplay' value from the app ID
3054  *
3055  * @par         This API is for package-manager client application
3056  * @par Sync (or) Async : Synchronous API
3057  *
3058  * @param[in]   handle  pointer to application info handle
3059  * @param[out] nodisplay                pointer to hold package nodisplay value
3060  * @return      0 if success, error code(<0) if fail
3061  * @retval      PMINFO_R_OK     success
3062  * @retval      PMINFO_R_EINVAL invalid argument
3063  * @retval      PMINFO_R_ERROR  internal error
3064  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3065  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3066  * @see         pkgmgrinfo_appinfo_get_appid()
3067  * @see         pkgmgrinfo_appinfo_is_multiple()
3068  * @code
3069 static int get_app_nodisplay(const char *appid)
3070 {
3071         int ret = 0;
3072         bool nodisplay;
3073         pkgmgrinfo_appinfo_h handle;
3074         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3075         if (ret != PMINFO_R_OK)
3076                 return -1;
3077         ret = pkgmgrinfo_appinfo_is_nodisplay(handle, &nodisplay);
3078         if (ret != PMINFO_R_OK) {
3079                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3080                 return -1;
3081         }
3082         printf("app nodisplay: %d\n", nodisplay);
3083         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3084         return 0;
3085 }
3086  * @endcode
3087  */
3088 int pkgmgrinfo_appinfo_is_nodisplay(pkgmgrinfo_appinfo_h  handle, bool *nodisplay);
3089
3090 /**
3091  * @fn int pkgmgrinfo_appinfo_is_multiple(pkgmgrinfo_appinfo_h handle, bool *multiple)
3092  * @brief       This API gets the application 'multiple' value from the app ID
3093  *
3094  * @par         This API is for package-manager client application
3095  * @par Sync (or) Async : Synchronous API
3096  *
3097  * @param[in]   handle  pointer to application info handle
3098  * @param[out] multiple         pointer to hold package multiple value
3099  * @return      0 if success, error code(<0) if fail
3100  * @retval      PMINFO_R_OK     success
3101  * @retval      PMINFO_R_EINVAL invalid argument
3102  * @retval      PMINFO_R_ERROR  internal error
3103  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3104  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3105  * @see         pkgmgrinfo_appinfo_get_appid()
3106  * @see         pkgmgrinfo_appinfo_is_nodisplay()
3107  * @code
3108 static int get_app_multiple(const char *appid)
3109 {
3110         int ret = 0;
3111         bool multiple;
3112         pkgmgrinfo_appinfo_h handle;
3113         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3114         if (ret != PMINFO_R_OK)
3115                 return -1;
3116         ret = pkgmgrinfo_appinfo_is_multiple(handle, &multiple);
3117         if (ret != PMINFO_R_OK) {
3118                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3119                 return -1;
3120         }
3121         printf("app multiple: %d\n", multiple);
3122         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3123         return 0;
3124 }
3125  * @endcode
3126  */
3127 int pkgmgrinfo_appinfo_is_multiple(pkgmgrinfo_appinfo_h  handle, bool *multiple);
3128
3129 /**
3130  * @fn int pkgmgrinfo_appinfo_is_indicator_display_allowed(pkgmgrinfo_appinfo_h handle, bool *indicator_disp)
3131  * @brief       This API gets the application 'indicatordisplay' value. If true, indicator will be displayed during
3132  *              application launching effect. If fales, indicator will be hidden during application launching effect
3133  *
3134  * @par         This API is for package-manager client application
3135  * @par Sync (or) Async : Synchronous API
3136  *
3137  * @param[in]   handle  pointer to application info handle
3138  * @param[out]  indicator_disp contains indicator display status for application launching effect
3139  * @return      0 if success, error code(<0) if fail
3140  * @retval      PMINFO_R_OK     success
3141  * @retval      PMINFO_R_EINVAL invalid argument
3142  * @retval      PMINFO_R_ERROR  internal error
3143  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3144  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3145  * @see         pkgmgrinfo_appinfo_get_appid()
3146  * @see         pkgmgrinfo_appinfo_is_nodisplay()
3147  * @code
3148 static int get_app_indicator_display(const char *appid)
3149 {
3150         int ret = 0;
3151         bool indicator_disp;
3152         pkgmgrinfo_appinfo_h handle;
3153         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3154         if (ret != PMINFO_R_OK)
3155                 return -1;
3156         ret = pkgmgrinfo_appinfo_is_indicator_display_allowed(handle, &indicator_disp);
3157         if (ret != PMINFO_R_OK){
3158                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3159                 return -1;
3160         }
3161         printf("app indicator disp : %d\n", indicator_disp);
3162         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3163         return 0;
3164 }
3165  * @endcode
3166  */
3167 int pkgmgrinfo_appinfo_is_indicator_display_allowed(pkgmgrinfo_appinfo_h handle, bool *indicator_disp);
3168
3169 /**
3170  * @fn int pkgmgrinfo_appinfo_get_effectimage(pkgmgrinfo_appinfo_h  handle, char **portrait_img, char **landscape_img)
3171  * @brief       This API gets the application's landscape & portrait effect images
3172  *
3173  * @par         This API is for package-manager client application
3174  * @par Sync (or) Async : Synchronous API
3175  *
3176  * @param[in]   handle  pointer to application info handle
3177  * @param[out]  portrait_img contains portrait mode effect image
3178  * @param[out]  landscape_img contains landscape mode effect image
3179  * @return      0 if success, error code(<0) if fail
3180  * @retval      PMINFO_R_OK     success
3181  * @retval      PMINFO_R_EINVAL invalid argument
3182  * @retval      PMINFO_R_ERROR  internal error
3183  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3184  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3185  * @see         pkgmgrinfo_appinfo_get_appid()
3186  * @see         pkgmgrinfo_appinfo_is_nodisplay()
3187  * @code
3188 static int get_app_effectimages(const char *appid)
3189 {
3190         int ret = 0;
3191         char *portraitimg = NULL;
3192         char *landscapeimg = NULL;
3193         pkgmgrinfo_appinfo_h handle;
3194         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3195         if (ret != PMINFO_R_OK)
3196                 return -1;
3197         ret = pkgmgrinfo_appinfo_get_effectimage(handle, &portraitimg, &landscapeimg);
3198         if (ret != PMINFO_R_OK) {
3199                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3200                 return -1;
3201         }
3202         printf("app effect image portrait: %s, app effect image landscape : %s\n", portraitimg, landscapeimg);
3203         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3204         return 0;
3205 }
3206  * @endcode
3207  */
3208 int pkgmgrinfo_appinfo_get_effectimage(pkgmgrinfo_appinfo_h  handle, char **portrait_img, char **landscape_img);
3209
3210 /**
3211  * @fn int pkgmgrinfo_appinfo_is_taskmanage(pkgmgrinfo_appinfo_h handle, bool *taskmanage)
3212  * @brief       This API gets the application 'taskmanage' value from the app ID
3213  *
3214  * @par         This API is for package-manager client application
3215  * @par Sync (or) Async : Synchronous API
3216  *
3217  * @param[in]   handle  pointer to application info handle
3218  * @param[out] taskmanage               pointer to hold package taskmanage value
3219  * @return      0 if success, error code(<0) if fail
3220  * @retval      PMINFO_R_OK     success
3221  * @retval      PMINFO_R_EINVAL invalid argument
3222  * @retval      PMINFO_R_ERROR  internal error
3223  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3224  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3225  * @see         pkgmgrinfo_appinfo_get_appid()
3226  * @see         pkgmgrinfo_appinfo_is_multiple()
3227  * @code
3228 static int get_app_taskmanage(const char *appid)
3229 {
3230         int ret = 0;
3231         bool taskmanage;
3232         pkgmgrinfo_appinfo_h handle;
3233         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3234         if (ret != PMINFO_R_OK)
3235                 return -1;
3236         ret = pkgmgrinfo_appinfo_is_taskmanage(handle, &taskmanage);
3237         if (ret != PMINFO_R_OK) {
3238                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3239                 return -1;
3240         }
3241         printf("app taskmanage: %d\n", taskmanage);
3242         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3243         return 0;
3244 }
3245  * @endcode
3246  */
3247 int pkgmgrinfo_appinfo_is_taskmanage(pkgmgrinfo_appinfo_h  handle, bool *taskmanage);
3248
3249 /**
3250  * @fn int pkgmgrinfo_appinfo_is_enabled(pkgmgrinfo_appinfo_h handle, bool *enabled)
3251  * @brief       This API gets the application 'taskmanage' value from the app ID
3252  *
3253  * @par         This API is for package-manager client application
3254  * @par Sync (or) Async : Synchronous API
3255  *
3256  * @param[in]   handle  pointer to application info handle
3257  * @param[out] enabled          pointer to hold package enabled value
3258  * @return      0 if success, error code(<0) if fail
3259  * @retval      PMINFO_R_OK     success
3260  * @retval      PMINFO_R_EINVAL invalid argument
3261  * @retval      PMINFO_R_ERROR  internal error
3262  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3263  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3264  * @see         pkgmgrinfo_appinfo_get_appid()
3265  * @see         pkgmgrinfo_appinfo_is_multiple()
3266  * @code
3267 static int get_app_enabled(const char *appid)
3268 {
3269         int ret = 0;
3270         bool enabled;
3271         pkgmgrinfo_appinfo_h handle;
3272         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3273         if (ret != PMINFO_R_OK)
3274                 return -1;
3275         ret = pkgmgrinfo_appinfo_is_taskmanage(handle, &enabled);
3276         if (ret != PMINFO_R_OK) {
3277                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3278                 return -1;
3279         }
3280         printf("app enabled: %d\n", enabled);
3281         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3282         return 0;
3283 }
3284  * @endcode
3285  */
3286 int pkgmgrinfo_appinfo_is_enabled(pkgmgrinfo_appinfo_h  handle, bool *enabled);
3287
3288 /**
3289  * @fn int pkgmgrinfo_appinfo_get_hwacceleration(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_app_hwacceleration *hwacceleration)
3290  * @brief       This API gets the application 'hwacceleration' value from the app ID
3291  *
3292  * @par         This API is for package-manager client application
3293  * @par Sync (or) Async : Synchronous API
3294  *
3295  * @param[in]   handle  pointer to application info handle
3296  * @param[out] hwacceleration           pointer to hold package hwacceleration value
3297  * @return      0 if success, error code(<0) if fail
3298  * @retval      PMINFO_R_OK     success
3299  * @retval      PMINFO_R_EINVAL invalid argument
3300  * @retval      PMINFO_R_ERROR  internal error
3301  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3302  * @post        pkgmgrinfo_appinfo_destroy_appinfo()
3303  * @see         pkgmgrinfo_appinfo_get_appid()
3304  * @see         pkgmgrinfo_appinfo_is_multiple()
3305  * @code
3306 static int get_app_hwacceleration(const char *appid)
3307 {
3308         int ret = 0;
3309         pkgmgrinfo_app_hwacceleration hwacceleration;
3310         pkgmgrinfo_appinfo_h handle;
3311         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3312         if (ret != PMINFO_R_OK)
3313                 return -1;
3314         ret = pkgmgrinfo_appinfo_get_hwacceleration(handle, &hwacceleration);
3315         if (ret != PMINFO_R_OK) {
3316                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3317                 return -1;
3318         }
3319         printf("app hwacceleration: %d\n", hwacceleration);
3320         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3321         return 0;
3322 }
3323  * @endcode
3324  */
3325 int pkgmgrinfo_appinfo_get_hwacceleration(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_app_hwacceleration *hwacceleration);
3326
3327 /**
3328  * @fn int pkgmgrinfo_appinfo_is_onboot(pkgmgrinfo_appinfo_h handle, bool *onboot)
3329  * @brief       This API gets the application 'onboot' value from the app ID
3330  *
3331  * @par         This API is for package-manager client application
3332  * @par Sync (or) Async : Synchronous API
3333  *
3334  * @param[in]   handle  pointer to application info handle
3335  * @param[out] onboot           pointer to hold package onboot value
3336  * @return      0 if success, error code(<0) if fail
3337  * @retval      PMINFO_R_OK     success
3338  * @retval      PMINFO_R_EINVAL invalid argument
3339  * @retval      PMINFO_R_ERROR  internal error
3340  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3341  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3342  * @see         pkgmgrinfo_appinfo_get_appid()
3343  * @see         pkgmgrinfo_appinfo_is_multiple()
3344  * @code
3345 static int get_app_onboot(const char *appid)
3346 {
3347         int ret = 0;
3348         bool onboot;
3349         pkgmgrinfo_appinfo_h handle;
3350         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3351         if (ret != PMINFO_R_OK)
3352                 return -1;
3353         ret = pkgmgrinfo_appinfo_is_onboot(handle, &onboot);
3354         if (ret != PMINFO_R_OK) {
3355                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3356                 return -1;
3357         }
3358         printf("app onboot: %d\n", onboot);
3359         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3360         return 0;
3361 }
3362  * @endcode
3363  */
3364 int pkgmgrinfo_appinfo_is_onboot(pkgmgrinfo_appinfo_h  handle, bool *onboot);
3365
3366 /**
3367  * @fn int pkgmgrinfo_appinfo_is_autorestart(pkgmgrinfo_appinfo_h handle, bool *autorestart)
3368  * @brief       This API gets the application 'autorestart' value from the app ID
3369  *
3370  * @par         This API is for package-manager client application
3371  * @par Sync (or) Async : Synchronous API
3372  *
3373  * @param[in]   handle  pointer to application info handle
3374  * @param[out] autorestart              pointer to hold package autorestart value
3375  * @return      0 if success, error code(<0) if fail
3376  * @retval      PMINFO_R_OK     success
3377  * @retval      PMINFO_R_EINVAL invalid argument
3378  * @retval      PMINFO_R_ERROR  internal error
3379  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3380  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3381  * @see         pkgmgrinfo_appinfo_get_appid()
3382  * @see         pkgmgrinfo_appinfo_is_multiple()
3383  * @code
3384 static int get_app_autorestart(const char *appid)
3385 {
3386         int ret = 0;
3387         bool autorestart;
3388         pkgmgrinfo_appinfo_h handle;
3389         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3390         if (ret != PMINFO_R_OK)
3391                 return -1;
3392         ret = pkgmgrinfo_appinfo_is_autorestart(handle, &autorestart);
3393         if (ret != PMINFO_R_OK) {
3394                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3395                 return -1;
3396         }
3397         printf("app autorestart: %d\n", autorestart);
3398         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3399         return 0;
3400 }
3401  * @endcode
3402  */
3403 int pkgmgrinfo_appinfo_is_autorestart(pkgmgrinfo_appinfo_h  handle, bool *autorestart);
3404
3405 /**
3406  * @fn int pkgmgrinfo_appinfo_is_mainapp(pkgmgrinfo_appinfo_h  handle, bool *mainapp)
3407  * @brief       This API gets the value for given application is main app or not from handle
3408  *
3409  * @par         This API is for package-manager client application
3410  * @par Sync (or) Async : Synchronous API
3411  *
3412  * @param[in]   handle  pointer to application info handle
3413  * @param[out] mainapp          pointer to hold package mainapp is or not
3414  * @return      0 if success, error code(<0) if fail
3415  * @retval      PMINFO_R_OK     success
3416  * @retval      PMINFO_R_EINVAL invalid argument
3417  * @retval      PMINFO_R_ERROR  internal error
3418  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3419  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
3420  * @see         pkgmgrinfo_appinfo_get_appid()
3421  * @see         pkgmgrinfo_appinfo_is_multiple()
3422  * @code
3423 static int get_app_mainapp(const char *appid)
3424 {
3425         int ret = 0;
3426         bool mainapp;
3427         pkgmgrinfo_appinfo_h handle;
3428         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3429         if (ret != PMINFO_R_OK)
3430                 return -1;
3431         ret = pkgmgrinfo_appinfo_is_mainapp(handle, &mainapp);
3432         if (ret != PMINFO_R_OK) {
3433                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3434                 return -1;
3435         }
3436         printf("mainapp: %d\n", mainapp);
3437         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3438         return 0;
3439 }
3440  * @endcode
3441  */
3442 int pkgmgrinfo_appinfo_is_mainapp(pkgmgrinfo_appinfo_h  handle, bool *mainapp);
3443
3444 /**
3445  * @fn int pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo_h handle)
3446  * @brief       This API destroys the application information handle freeing up all the resources
3447  *
3448  * @par         This API is for package-manager client application
3449  * @par Sync (or) Async : Synchronous API
3450  *
3451  * @param[in] handle            pointer to the application info handle.
3452  * @return      0 if success, error code(<0) if fail
3453  * @retval      PMINFO_R_OK     success
3454  * @retval      PMINFO_R_EINVAL invalid argument
3455  * @retval      PMINFO_R_ERROR  internal error
3456  * @pre         pkgmgrinfo_appinfo_get_appinfo()
3457  * @post                None
3458  * @see         pkgmgrinfo_appinfo_get_pkgid()
3459  * @see         pkgmgrinfo_appinfo_is_multiple()
3460  * @code
3461 static int get_app_type(const char *appid)
3462 {
3463         int ret = 0;
3464         char *type = NULL;
3465         pkgmgrinfo_appinfo_h handle;
3466         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
3467         if (ret != PMINFO_R_OK)
3468                 return -1;
3469         ret = pkgmgrinfo_appinfo_get_apptype(handle, &type);
3470         if (ret != PMINFO_R_OK) {
3471                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
3472                 return -1;
3473         }
3474         printf("apptype: %s\n", type);
3475         pkgmgrinfo_appinfo_destroy_appinfo(handle);
3476         return 0;
3477 }
3478  * @endcode
3479  */
3480 int pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo_h  handle);
3481
3482 /**
3483  * @fn int pkgmgrinfo_appinfo_filter_create(pkgmgrinfo_appinfo_filter_h *handle)
3484  * @brief       This API creates the application information filter handle from db.  All filter properties will be ANDed.
3485  The query will search the entire application information collected from the manifest file of all the installed packages
3486  *
3487  * @par         This API is for package-manager client application
3488  * @par Sync (or) Async : Synchronous API
3489  *
3490  * @param[out] handle           pointer to the application info filter handle.
3491  * @return      0 if success, error code(<0) if fail
3492  * @retval      PMINFO_R_OK     success
3493  * @retval      PMINFO_R_EINVAL invalid argument
3494  * @retval      PMINFO_R_ERROR  internal error
3495  * @pre         None
3496  * @post                pkgmgrinfo_appinfo_filter_destroy()
3497  * @see         pkgmgrinfo_appinfo_filter_count()
3498  * @see         pkgmgrinfo_appinfo_filter_foreach_appinfo()
3499  * @code
3500 static int get_capp_count()
3501 {
3502         int ret = 0;
3503         int count = 0;
3504         pkgmgrinfo_appinfo_filter_h handle;
3505         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3506         if (ret != PMINFO_R_OK)
3507                 return -1;
3508         ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_TYPE, "capp");
3509         if (ret != PMINFO_R_OK) {
3510                 pkgmgrinfo_appinfo_filter_destroy(handle);
3511                 return -1;
3512         }
3513         ret = pkgmgrinfo_appinfo_filter_count(handle, &count);
3514         if (ret != PMINFO_R_OK) {
3515                 pkgmgrinfo_appinfo_filter_destroy(handle);
3516                 return -1;
3517         }
3518         printf("No of capp: %d\n", count);
3519         pkgmgrinfo_appinfo_filter_destroy(handle);
3520         return 0;
3521 }
3522  * @endcode
3523  */
3524 int pkgmgrinfo_appinfo_filter_create(pkgmgrinfo_appinfo_filter_h *handle);
3525
3526 /**
3527  * @fn int pkgmgrinfo_appinfo_filter_destroy(pkgmgrinfo_appinfo_filter_h handle)
3528  * @brief       This API destroys the application information filter handle freeing up all the resources
3529  *
3530  * @par         This API is for package-manager client application
3531  * @par Sync (or) Async : Synchronous API
3532  *
3533  * @param[in] handle            pointer to the application info filter handle.
3534  * @return      0 if success, error code(<0) if fail
3535  * @retval      PMINFO_R_OK     success
3536  * @retval      PMINFO_R_EINVAL invalid argument
3537  * @retval      PMINFO_R_ERROR  internal error
3538  * @pre         pkgmgrinfo_appinfo_filter_create()
3539  * @post                None
3540  * @see         pkgmgrinfo_appinfo_filter_count()
3541  * @see         pkgmgrinfo_appinfo_filter_foreach_appinfo()
3542  * @code
3543 static int get_capp_count()
3544 {
3545         int ret = 0;
3546         int count = 0;
3547         pkgmgrinfo_appinfo_filter_h handle;
3548         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3549         if (ret != PMINFO_R_OK)
3550                 return -1;
3551         ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_TYPE, "capp");
3552         if (ret != PMINFO_R_OK) {
3553                 pkgmgrinfo_appinfo_filter_destroy(handle);
3554                 return -1;
3555         }
3556         ret = pkgmgrinfo_appinfo_filter_count(handle, &count);
3557         if (ret != PMINFO_R_OK) {
3558                 pkgmgrinfo_appinfo_filter_destroy(handle);
3559                 return -1;
3560         }
3561         printf("No of capp: %d\n", count);
3562         pkgmgrinfo_appinfo_filter_destroy(handle);
3563         return 0;
3564 }
3565  * @endcode
3566  */
3567 int pkgmgrinfo_appinfo_filter_destroy(pkgmgrinfo_appinfo_filter_h handle);
3568
3569 /**
3570  * @fn int pkgmgrinfo_appinfo_filter_add_bool(pkgmgrinfo_appinfo_filter_h handle, const char *property, const bool value)
3571  * @brief       This API adds a boolean filter property to the filter handle
3572  *
3573  * @par         This API is for package-manager client application
3574  * @par Sync (or) Async : Synchronous API
3575  *
3576  * @param[in] handle            pointer to the application info filter handle.
3577  * @param[in] property          boolean property name.
3578  * @param[in] value             value corresponding to the property.
3579  * @return      0 if success, error code(<0) if fail
3580  * @retval      PMINFO_R_OK     success
3581  * @retval      PMINFO_R_EINVAL invalid argument
3582  * @retval      PMINFO_R_ERROR  internal error
3583  * @pre         pkgmgrinfo_appinfo_filter_create()
3584  * @post                pkgmgrinfo_appinfo_filter_destroy()
3585  * @see         pkgmgrinfo_appinfo_filter_count()
3586  * @see         pkgmgrinfo_appinfo_filter_foreach_appinfo()
3587  * @code
3588 static int get_taskmanageable_app_count()
3589 {
3590         int ret = 0;
3591         int count = 0;
3592         pkgmgrinfo_appinfo_filter_h handle;
3593         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3594         if (ret != PMINFO_R_OK)
3595                 return -1;
3596         ret = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_TASKMANAGE, 1);
3597         if (ret != PMINFO_R_OK) {
3598                 pkgmgrinfo_appinfo_filter_destroy(handle);
3599                 return -1;
3600         }
3601         ret = pkgmgrinfo_appinfo_filter_count(handle, &count);
3602         if (ret != PMINFO_R_OK) {
3603                 pkgmgrinfo_appinfo_filter_destroy(handle);
3604                 return -1;
3605         }
3606         printf("No of taskmanageable apps: %d\n", count);
3607         pkgmgrinfo_appinfo_filter_destroy(handle);
3608         return 0;
3609 }
3610  * @endcode
3611  */
3612 int pkgmgrinfo_appinfo_filter_add_bool(pkgmgrinfo_appinfo_filter_h handle,
3613                 const char *property, const bool value);
3614
3615 /**
3616  * @fn int pkgmgrinfo_appinfo_filter_add_int(pkgmgrinfo_appinfo_filter_h handle, const char *property, const int value)
3617  * @brief       This API adds an integer filter property to the filter handle
3618  *
3619  * @par         This API is for package-manager client application
3620  * @par Sync (or) Async : Synchronous API
3621  *
3622  * @param[in] handle            pointer to the application info filter handle.
3623  * @param[in] property          integer property name.
3624  * @param[in] value             value corresponding to the property.
3625  * @return      0 if success, error code(<0) if fail
3626  * @retval      PMINFO_R_OK     success
3627  * @retval      PMINFO_R_EINVAL invalid argument
3628  * @retval      PMINFO_R_ERROR  internal error
3629  * @pre         pkgmgrinfo_appinfo_filter_create()
3630  * @post                pkgmgrinfo_appinfo_filter_destroy()
3631  * @see         pkgmgrinfo_appinfo_filter_count()
3632  * @see         pkgmgrinfo_appinfo_filter_foreach_appinfo()
3633  * @code
3634 static int get_taskmanageable_app_count()
3635 {
3636         int ret = 0;
3637         int count = 0;
3638         pkgmgrinfo_appinfo_filter_h handle;
3639         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3640         if (ret != PMINFO_R_OK)
3641                 return -1;
3642         ret = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_XXX, 10);
3643         if (ret != PMINFO_R_OK) {
3644                 pkgmgrinfo_appinfo_filter_destroy(handle);
3645                 return -1;
3646         }
3647         ret = pkgmgrinfo_appinfo_filter_count(handle, &count);
3648         if (ret != PMINFO_R_OK) {
3649                 pkgmgrinfo_appinfo_filter_destroy(handle);
3650                 return -1;
3651         }
3652         printf("No of apps: %d\n", count);
3653         pkgmgrinfo_appinfo_filter_destroy(handle);
3654         return 0;
3655 }
3656  * @endcode
3657  */
3658 int pkgmgrinfo_appinfo_filter_add_int(pkgmgrinfo_appinfo_filter_h handle,
3659                 const char *property, const int value);
3660
3661 /**
3662  * @fn int pkgmgrinfo_appinfo_filter_add_string(pkgmgrinfo_appinfo_filter_h handle, const char *property, const char *value)
3663  * @brief       This API adds a string filter property to the filter handle
3664  *
3665  * @par         This API is for package-manager client application
3666  * @par Sync (or) Async : Synchronous API
3667  *
3668  * @param[in] handle            pointer to the application info filter handle.
3669  * @param[in] property          string property name.
3670  * @param[in] value             value corresponding to the property.
3671  * @return      0 if success, error code(<0) if fail
3672  * @retval      PMINFO_R_OK     success
3673  * @retval      PMINFO_R_EINVAL invalid argument
3674  * @retval      PMINFO_R_ERROR  internal error
3675  * @pre         pkgmgrinfo_appinfo_filter_create()
3676  * @post                pkgmgrinfo_appinfo_filter_destroy()
3677  * @see         pkgmgrinfo_appinfo_filter_count()
3678  * @see         pkgmgrinfo_appinfo_filter_foreach_appinfo()
3679  * @code
3680 static int get_capp_count()
3681 {
3682         int ret = 0;
3683         int count = 0;
3684         pkgmgrinfo_appinfo_filter_h handle;
3685         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3686         if (ret != PMINFO_R_OK)
3687                 return -1;
3688         ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_TYPE, "capp");
3689         if (ret != PMINFO_R_OK) {
3690                 pkgmgrinfo_appinfo_filter_destroy(handle);
3691                 return -1;
3692         }
3693         ret = pkgmgrinfo_appinfo_filter_count(handle, &count);
3694         if (ret != PMINFO_R_OK) {
3695                 pkgmgrinfo_appinfo_filter_destroy(handle);
3696                 return -1;
3697         }
3698         printf("No of capp: %d\n", count);
3699         pkgmgrinfo_appinfo_filter_destroy(handle);
3700         return 0;
3701 }
3702  * @endcode
3703  */
3704 int pkgmgrinfo_appinfo_filter_add_string(pkgmgrinfo_appinfo_filter_h handle,
3705                 const char *property, const char *value);
3706
3707 /**
3708  * @fn int pkgmgrinfo_appinfo_filter_foreach_appinfo(pkgmgrinfo_appinfo_filter_h handle, pkgmgrinfo_app_list_cb app_cb, void *user_data)
3709  * @brief       This API executes the user supplied callback function for each application that satisfy the filter conditions
3710  *
3711  * @par         This API is for package-manager client application
3712  * @par Sync (or) Async : Synchronous API
3713  *
3714  * @param[in] handle            pointer to the application info filter handle.
3715  * @param[in] app_cb            callback function.
3716  * @param[in] user_data         user data to be passed to the callback function
3717  * @return      0 if success, error code(<0) if fail
3718  * @retval      PMINFO_R_OK     success
3719  * @retval      PMINFO_R_EINVAL invalid argument
3720  * @retval      PMINFO_R_ERROR  internal error
3721  * @pre         pkgmgrinfo_appinfo_filter_create()
3722  * @post                pkgmgrinfo_appinfo_filter_destroy()
3723  * @see         pkgmgrinfo_appinfo_filter_count()
3724  * @code
3725 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
3726 {
3727         char *appid = NULL;
3728         pkgmgrinfo_appinfo_get_appid(handle, &appid);
3729         printf("appid : %s\n", appid);
3730         return 0;
3731 }
3732
3733 static int get_capp_list()
3734 {
3735         int ret = 0;
3736         pkgmgrinfo_appinfo_filter_h handle;
3737         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3738         if (ret != PMINFO_R_OK)
3739                 return -1;
3740         ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_TYPE, "capp");
3741         if (ret != PMINFO_R_OK) {
3742                 pkgmgrinfo_appinfo_filter_destroy(handle);
3743                 return -1;
3744         }
3745         ret = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, app_list_cb, NULL);
3746         if (ret != PMINFO_R_OK) {
3747                 pkgmgrinfo_appinfo_filter_destroy(handle);
3748                 return -1;
3749         }
3750         pkgmgrinfo_appinfo_filter_destroy(handle);
3751         return 0;
3752 }
3753  * @endcode
3754  */
3755 int pkgmgrinfo_appinfo_filter_foreach_appinfo(pkgmgrinfo_appinfo_filter_h handle,
3756                 pkgmgrinfo_app_list_cb app_cb, void *user_data);
3757
3758 /**
3759  * @fn int pkgmgrinfo_appinfo_filter_count(pkgmgrinfo_appinfo_filter_h handle, int *count)
3760  * @brief       This API counts the application that satisfy the filter conditions
3761  *
3762  * @par         This API is for package-manager client application
3763  * @par Sync (or) Async : Synchronous API
3764  *
3765  * @param[in] handle            pointer to the application info filter handle.
3766  * @param[in] count             pointer to store count value
3767  * @return      0 if success, error code(<0) if fail
3768  * @retval      PMINFO_R_OK     success
3769  * @retval      PMINFO_R_EINVAL invalid argument
3770  * @retval      PMINFO_R_ERROR  internal error
3771  * @pre         pkgmgrinfo_appinfo_filter_create()
3772  * @post                pkgmgrinfo_appinfo_filter_destroy()
3773  * @see         pkgmgrinfo_appinfo_filter_foreach_appinfo()
3774  * @code
3775 static int get_capp_count()
3776 {
3777         int ret = 0;
3778         int count = 0;
3779         pkgmgrinfo_appinfo_filter_h handle;
3780         ret = pkgmgrinfo_appinfo_filter_create(&handle);
3781         if (ret != PMINFO_R_OK)
3782                 return -1;
3783         ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_TYPE, "capp");
3784         if (ret != PMINFO_R_OK) {
3785                 pkgmgrinfo_appinfo_filter_destroy(handle);
3786                 return -1;
3787         }
3788         ret = pkgmgrinfo_appinfo_filter_count(handle, &count);
3789         if (ret != PMINFO_R_OK) {
3790                 pkgmgrinfo_appinfo_filter_destroy(handle);
3791                 return -1;
3792         }
3793         printf("No of capp: %d\n", count);
3794         pkgmgrinfo_appinfo_filter_destroy(handle);
3795         return 0;
3796 }
3797  * @endcode
3798  */
3799 int pkgmgrinfo_appinfo_filter_count(pkgmgrinfo_appinfo_filter_h handle, int *count);
3800
3801 /**
3802  * @fn int pkgmgrinfo_appinfo_metadata_filter_create(pkgmgrinfo_appinfo_metadata_filter_h *handle)
3803  * @brief       This API creates the application's metadata  information filter handle from db.
3804  *
3805  * @par         This API is for package-manager client application
3806  * @par Sync (or) Async : Synchronous API
3807  *
3808  * @param[out] handle           pointer to the application metadata info filter handle.
3809  * @return      0 if success, error code(<0) if fail
3810  * @retval      PMINFO_R_OK     success
3811  * @retval      PMINFO_R_EINVAL invalid argument
3812  * @retval      PMINFO_R_ERROR  internal error
3813  * @pre         None
3814  * @post                pkgmgrinfo_appinfo_metadata_filter_destroy()
3815  * @see         pkgmgrinfo_appinfo_metadata_filter_foreach()
3816  * @code
3817 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
3818 {
3819         char *appid = NULL;
3820         pkgmgrinfo_appinfo_get_appid(handle, &appid);
3821         printf("appid : %s\n", appid);
3822         return 0;
3823 }
3824
3825 static int get_app_list(const char *mkey, const char *mvalue)
3826 {
3827         int ret = 0;
3828         pkgmgrinfo_appinfo_metadata_filter_h handle;
3829         ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
3830         if (ret != PMINFO_R_OK)
3831                 return -1;
3832         ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, mkey, mvalue);
3833         if (ret != PMINFO_R_OK) {
3834                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3835                 return -1;
3836         }
3837         ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, app_list_cb, NULL);
3838         if (ret != PMINFO_R_OK) {
3839                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3840                 return -1;
3841         }
3842         pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3843         return 0;
3844 }
3845  * @endcode
3846  */
3847 int pkgmgrinfo_appinfo_metadata_filter_create(pkgmgrinfo_appinfo_metadata_filter_h *handle);
3848
3849 /**
3850  * @fn int pkgmgrinfo_appinfo_metadata_filter_destroy(pkgmgrinfo_appinfo_metadata_filter_h handle)
3851  * @brief       This API destroys the application's metadata  information filter handle.
3852  *
3853  * @par         This API is for package-manager client application
3854  * @par Sync (or) Async : Synchronous API
3855  *
3856  * @param[in] handle            pointer to the application metadata info filter handle.
3857  * @return      0 if success, error code(<0) if fail
3858  * @retval      PMINFO_R_OK     success
3859  * @retval      PMINFO_R_EINVAL invalid argument
3860  * @retval      PMINFO_R_ERROR  internal error
3861  * @pre         pkgmgrinfo_appinfo_metadata_filter_create()
3862  * @post                None
3863  * @see         pkgmgrinfo_appinfo_metadata_filter_foreach()
3864  * @code
3865 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
3866 {
3867         char *appid = NULL;
3868         pkgmgrinfo_appinfo_get_appid(handle, &appid);
3869         printf("appid : %s\n", appid);
3870         return 0;
3871 }
3872
3873 static int get_app_list(const char *mkey, const char *mvalue)
3874 {
3875         int ret = 0;
3876         pkgmgrinfo_appinfo_metadata_filter_h handle;
3877         ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
3878         if (ret != PMINFO_R_OK)
3879                 return -1;
3880         ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, mkey, mvalue);
3881         if (ret != PMINFO_R_OK) {
3882                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3883                 return -1;
3884         }
3885         ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, app_list_cb, NULL);
3886         if (ret != PMINFO_R_OK) {
3887                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3888                 return -1;
3889         }
3890         pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3891         return 0;
3892 }
3893  * @endcode
3894  */
3895 int pkgmgrinfo_appinfo_metadata_filter_destroy(pkgmgrinfo_appinfo_metadata_filter_h handle);
3896
3897 /**
3898  * @fn int pkgmgrinfo_appinfo_metadata_filter_add(pkgmgrinfo_appinfo_metadata_filter_h handle, const char *key, const char *value)
3899  * @brief       This API adds filter condition for the query API.  The query will search the entire application metadata  information collected from
3900  * the manifest file of all the installed packages. You can specify value as NULL to search based on key only.
3901  *
3902  * @par         This API is for package-manager client application
3903  * @par Sync (or) Async : Synchronous API
3904  *
3905  * @param[in] handle            pointer to the application metadata info filter handle.
3906  * @param[in] key                       pointer to metadata key
3907  * @param[in] value                     pointer to metadata value
3908  * @return      0 if success, error code(<0) if fail
3909  * @retval      PMINFO_R_OK     success
3910  * @retval      PMINFO_R_EINVAL invalid argument
3911  * @retval      PMINFO_R_ERROR  internal error
3912  * @pre         pkgmgrinfo_appinfo_metadata_filter_create()
3913  * @post                pkgmgrinfo_appinfo_metadata_filter_foreach(), pkgmgrinfo_appinfo_metadata_filter_destroy()
3914  * @see         pkgmgrinfo_appinfo_metadata_filter_foreach()
3915  * @code
3916 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
3917 {
3918         char *appid = NULL;
3919         pkgmgrinfo_appinfo_get_appid(handle, &appid);
3920         printf("appid : %s\n", appid);
3921         return 0;
3922 }
3923
3924 static int get_app_list(const char *mkey, const char *mvalue)
3925 {
3926         int ret = 0;
3927         pkgmgrinfo_appinfo_metadata_filter_h handle;
3928         ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
3929         if (ret != PMINFO_R_OK)
3930                 return -1;
3931         ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, mkey, mvalue);
3932         if (ret != PMINFO_R_OK) {
3933                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3934                 return -1;
3935         }
3936         ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, app_list_cb, NULL);
3937         if (ret != PMINFO_R_OK) {
3938                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3939                 return -1;
3940         }
3941         pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3942         return 0;
3943 }
3944  * @endcode
3945  */
3946 int pkgmgrinfo_appinfo_metadata_filter_add(pkgmgrinfo_appinfo_metadata_filter_h handle,
3947                 const char *key, const char *value);
3948
3949 /**
3950  * @fn int pkgmgrinfo_appinfo_metadata_filter_foreach(pkgmgrinfo_appinfo_metadata_filter_h handle, pkgmgrinfo_app_list_cb app_cb, void *user_data)
3951  * @brief       This API executes the filter query. The query will search the entire application metadata  information collected from
3952  * the manifest file of all the installed packages. For each application returned by the query, the callback will be called. If callback returns
3953  * negative value, no more callbacks will be called and API will return.
3954  *
3955  * @par         This API is for package-manager client application
3956  * @par Sync (or) Async : Synchronous API
3957  *
3958  * @param[in] handle            pointer to the application metadata info filter handle.
3959  * @param[in] app_cb            function pointer to callback
3960  * @param[in] user_data         pointer to user data
3961  * @return      0 if success, error code(<0) if fail
3962  * @retval      PMINFO_R_OK     success
3963  * @retval      PMINFO_R_EINVAL invalid argument
3964  * @retval      PMINFO_R_ERROR  internal error
3965  * @pre         pkgmgrinfo_appinfo_metadata_filter_create()
3966  * @post                pkgmgrinfo_appinfo_metadata_filter_destroy()
3967  * @code
3968 int app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
3969 {
3970         char *appid = NULL;
3971         pkgmgrinfo_appinfo_get_appid(handle, &appid);
3972         printf("appid : %s\n", appid);
3973         return 0;
3974 }
3975
3976 static int get_app_list(const char *mkey, const char *mvalue)
3977 {
3978         int ret = 0;
3979         pkgmgrinfo_appinfo_metadata_filter_h handle;
3980         ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
3981         if (ret != PMINFO_R_OK)
3982                 return -1;
3983         ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, mkey, mvalue);
3984         if (ret != PMINFO_R_OK) {
3985                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3986                 return -1;
3987         }
3988         ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, app_list_cb, NULL);
3989         if (ret != PMINFO_R_OK) {
3990                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3991                 return -1;
3992         }
3993         pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
3994         return 0;
3995 }
3996  * @endcode
3997  */
3998 int pkgmgrinfo_appinfo_metadata_filter_foreach(pkgmgrinfo_appinfo_metadata_filter_h handle,
3999                 pkgmgrinfo_app_list_cb app_cb, void *user_data);
4000
4001 /**
4002  * @fn int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle)
4003  * @brief       This API creates the package cert information handle to get data from db.
4004  *
4005  * @par         This API is for package-manager client application
4006  * @par Sync (or) Async : Synchronous API
4007  *
4008  * @param[out] handle           pointer to the package cert handle.
4009  * @return      0 if success, error code(<0) if fail
4010  * @retval      PMINFO_R_OK     success
4011  * @retval      PMINFO_R_EINVAL invalid argument
4012  * @retval      PMINFO_R_ERROR  internal error
4013  * @pre         None
4014  * @post                pkgmgrinfo_pkginfo_destroy_certinfo()
4015  * @see         pkgmgrinfo_pkginfo_get_cert_value()
4016  * @see         pkgmgrinfo_pkginfo_load_certinfo()
4017  * @code
4018 static int get_cert_info(const char *pkgid)
4019 {
4020         int ret = 0;
4021         pkgmgrinfo_certinfo_h handle;
4022         char *auth_cert = NULL;
4023         ret = pkgmgrinfo_pkginfo_create_certinfo(&handle);
4024         if (ret != PMINFO_R_OK)
4025                 return -1;
4026         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle);
4027         if (ret != PMINFO_R_OK) {
4028                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4029                 return -1;
4030         }
4031         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, PMINFO_AUTHOR_ROOT_CERT, &auth_cert);
4032         if (ret != PMINFO_R_OK) {
4033                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4034                 return -1;
4035         }
4036         printf("Author root certificate: %s\n", auth_root);
4037         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4038         return 0;
4039 }
4040  * @endcode
4041  */
4042 int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle);
4043
4044 /**
4045  * @fn int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid, pkgmgrinfo_certinfo_h handle)
4046  * @brief       This API loads the package cert information handle with data from db.
4047  *
4048  * @par         This API is for package-manager client application
4049  * @par Sync (or) Async : Synchronous API
4050  *
4051  * @param[in] pkgid             pointer to the package ID.
4052  * @param[in] handle            pointer to the package cert handle.
4053  * @return      0 if success, error code(<0) if fail
4054  * @retval      PMINFO_R_OK     success
4055  * @retval      PMINFO_R_EINVAL invalid argument
4056  * @retval      PMINFO_R_ERROR  internal error
4057  * @pre         pkgmgrinfo_pkginfo_create_certinfo()
4058  * @post                pkgmgrinfo_pkginfo_destroy_certinfo()
4059  * @see         pkgmgrinfo_pkginfo_get_cert_value()
4060  * @code
4061 static int get_cert_info(const char *pkgid)
4062 {
4063         int ret = 0;
4064         pkgmgrinfo_certinfo_h handle;
4065         char *auth_cert = NULL;
4066         ret = pkgmgrinfo_pkginfo_create_certinfo(&handle);
4067         if (ret != PMINFO_R_OK)
4068                 return -1;
4069         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle);
4070         if (ret != PMINFO_R_OK) {
4071                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4072                 return -1;
4073         }
4074         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, PMINFO_AUTHOR_ROOT_CERT, &auth_cert);
4075         if (ret != PMINFO_R_OK) {
4076                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4077                 return -1;
4078         }
4079         printf("Author root certificate: %s\n", auth_root);
4080         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4081         return 0;
4082 }
4083  * @endcode
4084  */
4085 int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid, pkgmgrinfo_certinfo_h handle);
4086
4087 /**
4088  * @fn int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle, pkgmgrinfo_cert_type cert_type, const char **cert_value)
4089  * @brief       This API gets the package cert information from the handle
4090  *
4091  * @par         This API is for package-manager client application
4092  * @par Sync (or) Async : Synchronous API
4093  *
4094  * @param[in] handle            pointer to the package cert handle.
4095  * @param[in] cert_type         certificate type
4096  * @param[out] cert_value       pointer to hold certificate value
4097  * @return      0 if success, error code(<0) if fail
4098  * @retval      PMINFO_R_OK     success
4099  * @retval      PMINFO_R_EINVAL invalid argument
4100  * @retval      PMINFO_R_ERROR  internal error
4101  * @pre         pkgmgrinfo_pkginfo_create_certinfo()
4102  * @post                pkgmgrinfo_pkginfo_destroy_certinfo()
4103  * @see         pkgmgrinfo_pkginfo_load_certinfo()
4104  * @code
4105 static int get_cert_info(const char *pkgid)
4106 {
4107         int ret = 0;
4108         pkgmgrinfo_certinfo_h handle;
4109         char *auth_cert = NULL;
4110         ret = pkgmgrinfo_pkginfo_create_certinfo(&handle);
4111         if (ret != PMINFO_R_OK)
4112                 return -1;
4113         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle);
4114         if (ret != PMINFO_R_OK) {
4115                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4116                 return -1;
4117         }
4118         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, PMINFO_AUTHOR_ROOT_CERT, &auth_cert);
4119         if (ret != PMINFO_R_OK) {
4120                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4121                 return -1;
4122         }
4123         printf("Author root certificate: %s\n", auth_root);
4124         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4125         return 0;
4126 }
4127  * @endcode
4128  */
4129 int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle, pkgmgrinfo_cert_type cert_type, const char **cert_value);
4130
4131 /**
4132  * @fn int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle)
4133  * @brief       This API destroys the package cert information handle freeing up all the resources
4134  *
4135  * @par         This API is for package-manager client application
4136  * @par Sync (or) Async : Synchronous API
4137  *
4138  * @param[in] handle            pointer to the package cert handle.
4139  * @return      0 if success, error code(<0) if fail
4140  * @retval      PMINFO_R_OK     success
4141  * @retval      PMINFO_R_EINVAL invalid argument
4142  * @retval      PMINFO_R_ERROR  internal error
4143  * @pre         pkgmgrinfo_pkginfo_create_certinfo()
4144  * @post                None
4145  * @see         pkgmgrinfo_pkginfo_load_certinfo()
4146  * @code
4147 static int get_cert_info(const char *pkgid)
4148 {
4149         int ret = 0;
4150         pkgmgrinfo_certinfo_h handle;
4151         char *auth_cert = NULL;
4152         ret = pkgmgrinfo_pkginfo_create_certinfo(&handle);
4153         if (ret != PMINFO_R_OK)
4154                 return -1;
4155         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle);
4156         if (ret != PMINFO_R_OK) {
4157                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4158                 return -1;
4159         }
4160         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, PMINFO_AUTHOR_ROOT_CERT, &auth_cert);
4161         if (ret != PMINFO_R_OK) {
4162                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4163                 return -1;
4164         }
4165         printf("Author root certificate: %s\n", auth_root);
4166         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
4167         return 0;
4168 }
4169  * @endcode
4170  */
4171 int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle);
4172
4173 /**
4174  * @fn int pkgmgrinfo_delete_certinfo(const char *pkgid)
4175  * @brief       This API deletes the package cert information from DB
4176  *
4177  * @par         This API is for package-manager client application
4178  * @par Sync (or) Async : Synchronous API
4179  *
4180  * @param[in] pkgid             pointer to the package ID.
4181  * @return      0 if success, error code(<0) if fail
4182  * @retval      PMINFO_R_OK     success
4183  * @retval      PMINFO_R_EINVAL invalid argument
4184  * @retval      PMINFO_R_ERROR  internal error
4185  * @pre         None
4186  * @post                None
4187  * @code
4188 static int delete_cert_info(const char *pkgid)
4189 {
4190         int ret = 0;
4191         ret = pkgmgrinfo_delete_certinfo(pkgid);
4192         if (ret != PMINFO_R_OK)
4193                 return -1;
4194         return 0;
4195 }
4196  * @endcode
4197  */
4198  int pkgmgrinfo_delete_certinfo(const char *pkgid);
4199
4200 /**
4201  * @fn int pkgmgrinfo_create_pkgdbinfo(const char *pkgid, pkgmgrinfo_pkgdbinfo_h *handle)
4202  * @brief       This API creates the package db information handle to set data in db.
4203  *
4204  * @par         This API is for package-manager client application
4205  * @par Sync (or) Async : Synchronous API
4206  *
4207  * @param[in] pkgid     pointer to the package ID.
4208  * @param[out] handle           pointer to the package db info handle.
4209  * @return      0 if success, error code(<0) if fail
4210  * @retval      PMINFO_R_OK     success
4211  * @retval      PMINFO_R_EINVAL invalid argument
4212  * @retval      PMINFO_R_ERROR  internal error
4213  * @pre         None
4214  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4215  * @see         pkgmgrinfo_save_pkgdbinfo()
4216  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4217  * @code
4218 static int set_pkg_in_db(const char *pkgid)
4219 {
4220         int ret = 0;
4221         pkgmgrinfo_pkgdbinfo_h handle;
4222         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4223         if (ret != PMINFO_R_OK)
4224                 return -1;
4225         ret = pkgmgrinfo_set_version_to_pkgdbinfo(handle, "0.0.1");
4226         if (ret != PMINFO_R_OK) {
4227                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4228                 return -1;
4229         }
4230         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4231         if (ret != PMINFO_R_OK) {
4232                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4233                 return -1;
4234         }
4235         pkgmgrinfo_destroy_pkgdbinfo(handle);
4236         return 0;
4237 }
4238  * @endcode
4239  */
4240 int pkgmgrinfo_create_pkgdbinfo(const char *pkgid, pkgmgrinfo_pkgdbinfo_h *handle);
4241
4242 /**
4243  * @fn int pkgmgrinfo_set_type_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *type)
4244  * @brief       This API sets the package type in db handle
4245  *
4246  * @par         This API is for package-manager client application
4247  * @par Sync (or) Async : Synchronous API
4248  *
4249  * @param[in] handle    pointer to the pkgdbinfo handle.
4250  * @param[in] type              pointer to the package type.
4251  * @return      0 if success, error code(<0) if fail
4252  * @retval      PMINFO_R_OK     success
4253  * @retval      PMINFO_R_EINVAL invalid argument
4254  * @retval      PMINFO_R_ERROR  internal error
4255  * @pre         pkgmgrinfo_create_pkgdbinfo()
4256  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4257  * @see         pkgmgrinfo_save_pkgdbinfo()
4258  * @see         pkgmgrinfo_set_version_to_pkgdbinfo()
4259  * @code
4260 static int set_pkg_type_in_db(const char *pkgid)
4261 {
4262         int ret = 0;
4263         pkgmgrinfo_pkgdbinfo_h handle;
4264         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4265         if (ret != PMINFO_R_OK)
4266                 return -1;
4267         ret = pkgmgrinfo_set_type_to_pkgdbinfo(handle, "wgt");
4268         if (ret != PMINFO_R_OK) {
4269                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4270                 return -1;
4271         }
4272         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4273         if (ret != PMINFO_R_OK) {
4274                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4275                 return -1;
4276         }
4277         pkgmgrinfo_destroy_pkgdbinfo(handle);
4278         return 0;
4279 }
4280  * @endcode
4281  */
4282 int pkgmgrinfo_set_type_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *type);
4283
4284 /**
4285  * @fn int pkgmgrinfo_set_version_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *version)
4286  * @brief       This API sets the package version in db handle
4287  *
4288  * @par         This API is for package-manager client application
4289  * @par Sync (or) Async : Synchronous API
4290  *
4291  * @param[in] handle    pointer to the pkgdbinfo handle.
4292  * @param[in] version           pointer to the package version
4293  * @return      0 if success, error code(<0) if fail
4294  * @retval      PMINFO_R_OK     success
4295  * @retval      PMINFO_R_EINVAL invalid argument
4296  * @retval      PMINFO_R_ERROR  internal error
4297  * @pre         pkgmgrinfo_create_pkgdbinfo()
4298  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4299  * @see         pkgmgrinfo_save_pkgdbinfo()
4300  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4301  * @code
4302 static int set_pkg_version_in_db(const char *pkgid)
4303 {
4304         int ret = 0;
4305         pkgmgrinfo_pkgdbinfo_h handle;
4306         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4307         if (ret != PMINFO_R_OK)
4308                 return -1;
4309         ret = pkgmgrinfo_set_version_to_pkgdbinfo(handle, "0.0.1");
4310         if (ret != PMINFO_R_OK) {
4311                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4312                 return -1;
4313         }
4314         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4315         if (ret != PMINFO_R_OK) {
4316                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4317                 return -1;
4318         }
4319         pkgmgrinfo_destroy_pkgdbinfo(handle);
4320         return 0;
4321 }
4322  * @endcode
4323  */
4324 int pkgmgrinfo_set_version_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *version);
4325
4326 /**
4327  * @fn int pkgmgrinfo_set_install_location_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
4328  * @brief       This API sets the package install location in db handle
4329  *
4330  * @par         This API is for package-manager client application
4331  * @par Sync (or) Async : Synchronous API
4332  *
4333  * @param[in] handle    pointer to the pkgdbinfo handle.
4334  * @param[in] location  package install location
4335  * @return      0 if success, error code(<0) if fail
4336  * @retval      PMINFO_R_OK     success
4337  * @retval      PMINFO_R_EINVAL invalid argument
4338  * @retval      PMINFO_R_ERROR  internal error
4339  * @pre         pkgmgrinfo_create_pkgdbinfo()
4340  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4341  * @see         pkgmgrinfo_save_pkgdbinfo()
4342  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4343  * @code
4344 static int set_pkg_install_location_in_db(const char *pkgid)
4345 {
4346         int ret = 0;
4347         pkgmgrinfo_pkgdbinfo_h handle;
4348         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4349         if (ret != PMINFO_R_OK)
4350                 return -1;
4351         ret = pkgmgrinfo_set_install_location_to_pkgdbinfo(handle, INSTALL_INTERNAL);
4352         if (ret != PMINFO_R_OK) {
4353                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4354                 return -1;
4355         }
4356         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4357         if (ret != PMINFO_R_OK) {
4358                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4359                 return -1;
4360         }
4361         pkgmgrinfo_destroy_pkgdbinfo(handle);
4362         return 0;
4363 }
4364  * @endcode
4365  */
4366 int pkgmgrinfo_set_install_location_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location);
4367
4368 /**
4369  * @fn int pkgmgrinfo_set_size_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *size)
4370  * @brief       This API sets the package size in db handle
4371  *
4372  * @par         This API is for package-manager client application
4373  * @par Sync (or) Async : Synchronous API
4374  *
4375  * @param[in] handle    pointer to the pkgdbinfo handle.
4376  * @param[in] size              pointer to the package size
4377  * @return      0 if success, error code(<0) if fail
4378  * @retval      PMINFO_R_OK     success
4379  * @retval      PMINFO_R_EINVAL invalid argument
4380  * @retval      PMINFO_R_ERROR  internal error
4381  * @pre         pkgmgrinfo_create_pkgdbinfo()
4382  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4383  * @see         pkgmgrinfo_save_pkgdbinfo()
4384  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4385  * @code
4386 static int set_pkg_size_in_db(const char *pkgid)
4387 {
4388         int ret = 0;
4389         pkgmgrinfo_pkgdbinfo_h handle;
4390         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4391         if (ret != PMINFO_R_OK)
4392                 return -1;
4393         ret = pkgmgrinfo_set_size_to_pkgdbinfo(handle, "15");
4394         if (ret != PMINFO_R_OK) {
4395                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4396                 return -1;
4397         }
4398         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4399         if (ret != PMINFO_R_OK) {
4400                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4401                 return -1;
4402         }
4403         pkgmgrinfo_destroy_pkgdbinfo(handle);
4404         return 0;
4405 }
4406  * @endcode
4407  */
4408 int pkgmgrinfo_set_size_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *size);
4409
4410 /**
4411  * @fn int pkgmgrinfo_set_label_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *label, const char *locale)
4412  * @brief       This API sets the package label in db handle
4413  *
4414  * @par         This API is for package-manager client application
4415  * @par Sync (or) Async : Synchronous API
4416  *
4417  * @param[in] handle    pointer to the pkgdbinfo handle.
4418  * @param[in] label             pointer to the package label
4419  * @param[in] locale    pointer to the locale
4420  * @return      0 if success, error code(<0) if fail
4421  * @retval      PMINFO_R_OK     success
4422  * @retval      PMINFO_R_EINVAL invalid argument
4423  * @retval      PMINFO_R_ERROR  internal error
4424  * @pre         pkgmgrinfo_create_pkgdbinfo()
4425  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4426  * @see         pkgmgrinfo_save_pkgdbinfo()
4427  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4428  * @code
4429 static int set_pkg_label_in_db(const char *pkgid)
4430 {
4431         int ret = 0;
4432         pkgmgrinfo_pkgdbinfo_h handle;
4433         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4434         if (ret != PMINFO_R_OK)
4435                 return -1;
4436         ret = pkgmgrinfo_set_label_to_pkgdbinfo(handle, "helloworld", "en-us");
4437         if (ret != PMINFO_R_OK) {
4438                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4439                 return -1;
4440         }
4441         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4442         if (ret != PMINFO_R_OK) {
4443                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4444                 return -1;
4445         }
4446         pkgmgrinfo_destroy_pkgdbinfo(handle);
4447         return 0;
4448 }
4449  * @endcode
4450  */
4451 int pkgmgrinfo_set_label_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *label, const char *locale);
4452
4453 /**
4454  * @fn int pkgmgrinfo_set_icon_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *icon, const char *locale)
4455  * @brief       This API sets the package icon in db handle
4456  *
4457  * @par         This API is for package-manager client application
4458  * @par Sync (or) Async : Synchronous API
4459  *
4460  * @param[in] handle    pointer to the pkgdbinfo handle.
4461  * @param[in] icon              pointer to the package icon
4462  * @param[in] locale    pointer to the locale
4463  * @return      0 if success, error code(<0) if fail
4464  * @retval      PMINFO_R_OK     success
4465  * @retval      PMINFO_R_EINVAL invalid argument
4466  * @retval      PMINFO_R_ERROR  internal error
4467  * @pre         pkgmgrinfo_create_pkgdbinfo()
4468  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4469  * @see         pkgmgrinfo_save_pkgdbinfo()
4470  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4471  * @code
4472 static int set_pkg_icon_in_db(const char *pkgid)
4473 {
4474         int ret = 0;
4475         pkgmgrinfo_pkgdbinfo_h handle;
4476         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4477         if (ret != PMINFO_R_OK)
4478                 return -1;
4479         ret = pkgmgrinfo_set_icon_to_pkgdbinfo(handle, "helloworld.png", "en-us");
4480         if (ret != PMINFO_R_OK) {
4481                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4482                 return -1;
4483         }
4484         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4485         if (ret != PMINFO_R_OK) {
4486                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4487                 return -1;
4488         }
4489         pkgmgrinfo_destroy_pkgdbinfo(handle);
4490         return 0;
4491 }
4492  * @endcode
4493  */
4494 int pkgmgrinfo_set_icon_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *icon, const char *locale);
4495
4496 /**
4497  * @fn int pkgmgrinfo_set_description_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *description, const char *locale)
4498  * @brief       This API sets the package description in db handle
4499  *
4500  * @par         This API is for package-manager client application
4501  * @par Sync (or) Async : Synchronous API
4502  *
4503  * @param[in] handle    pointer to the pkgdbinfo handle.
4504  * @param[in] description               pointer to the package description
4505  * @param[in] locale    pointer to the locale
4506  * @return      0 if success, error code(<0) if fail
4507  * @retval      PMINFO_R_OK     success
4508  * @retval      PMINFO_R_EINVAL invalid argument
4509  * @retval      PMINFO_R_ERROR  internal error
4510  * @pre         pkgmgrinfo_create_pkgdbinfo()
4511  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4512  * @see         pkgmgrinfo_save_pkgdbinfo()
4513  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4514  * @code
4515 static int set_pkg_description_in_db(const char *pkgid)
4516 {
4517         int ret = 0;
4518         pkgmgrinfo_pkgdbinfo_h handle;
4519         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4520         if (ret != PMINFO_R_OK)
4521                 return -1;
4522         ret = pkgmgrinfo_set_description_to_pkgdbinfo(handle, "helloworld application", "en-us");
4523         if (ret != PMINFO_R_OK) {
4524                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4525                 return -1;
4526         }
4527         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4528         if (ret != PMINFO_R_OK) {
4529                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4530                 return -1;
4531         }
4532         pkgmgrinfo_destroy_pkgdbinfo(handle);
4533         return 0;
4534 }
4535  * @endcode
4536  */
4537 int pkgmgrinfo_set_description_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *description, const char *locale);
4538
4539 /**
4540  * @fn int pkgmgrinfo_set_author_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *author_name,
4541  const char *author_email, const char *author_href, const char *locale)
4542  * @brief       This API sets the package author info in db handle
4543  *
4544  * @par         This API is for package-manager client application
4545  * @par Sync (or) Async : Synchronous API
4546  *
4547  * @param[in] handle    pointer to the pkgdbinfo handle.
4548  * @param[in] author_name               pointer to the package author name
4549  * @param[in] author_email              pointer to the package author email
4550  * @param[in] author_href               pointer to the package author href
4551  * @param[in] locale    pointer to the locale
4552  * @return      0 if success, error code(<0) if fail
4553  * @retval      PMINFO_R_OK     success
4554  * @retval      PMINFO_R_EINVAL invalid argument
4555  * @retval      PMINFO_R_ERROR  internal error
4556  * @pre         pkgmgrinfo_create_pkgdbinfo()
4557  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4558  * @see         pkgmgrinfo_save_pkgdbinfo()
4559  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4560  * @code
4561 static int set_pkg_author_in_db(const char *pkgid)
4562 {
4563         int ret = 0;
4564         pkgmgrinfo_pkgdbinfo_h handle;
4565         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4566         if (ret != PMINFO_R_OK)
4567                 return -1;
4568         ret = pkgmgrinfo_set_author_to_pkgdbinfo(handle, "John", "john@samsung.com", "www.samsung.com", "en-us");
4569         if (ret != PMINFO_R_OK) {
4570                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4571                 return -1;
4572         }
4573         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4574         if (ret != PMINFO_R_OK) {
4575                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4576                 return -1;
4577         }
4578         pkgmgrinfo_destroy_pkgdbinfo(handle);
4579         return 0;
4580 }
4581  * @endcode
4582  */
4583 int pkgmgrinfo_set_author_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *author_name,
4584                         const char *author_email, const char *author_href, const char *locale);
4585
4586 /**
4587  * @fn int pkgmgrinfo_set_removable_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int removable)
4588  * @brief       This API sets the package 'removable' value in db handle
4589  *
4590  * @par         This API is for package-manager client application
4591  * @par Sync (or) Async : Synchronous API
4592  *
4593  * @param[in] handle    pointer to the pkgdbinfo handle.
4594  * @param[in] removable         package removable value
4595  * @return      0 if success, error code(<0) if fail
4596  * @retval      PMINFO_R_OK     success
4597  * @retval      PMINFO_R_EINVAL invalid argument
4598  * @retval      PMINFO_R_ERROR  internal error
4599  * @pre         pkgmgrinfo_create_pkgdbinfo()
4600  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4601  * @see         pkgmgrinfo_save_pkgdbinfo()
4602  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4603  * @code
4604 static int set_pkg_removable_in_db(const char *pkgid)
4605 {
4606         int ret = 0;
4607         pkgmgrinfo_pkgdbinfo_h handle;
4608         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4609         if (ret != PMINFO_R_OK)
4610                 return -1;
4611         ret = pkgmgrinfo_set_removable_to_pkgdbinfo(handle, 1);
4612         if (ret != PMINFO_R_OK) {
4613                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4614                 return -1;
4615         }
4616         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4617         if (ret != PMINFO_R_OK) {
4618                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4619                 return -1;
4620         }
4621         pkgmgrinfo_destroy_pkgdbinfo(handle);
4622         return 0;
4623 }
4624  * @endcode
4625  */
4626 int pkgmgrinfo_set_removable_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int removable);
4627
4628 /**
4629  * @fn int pkgmgrinfo_set_preload_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int preload)
4630  * @brief       This API sets the package 'preload' value in db handle
4631  *
4632  * @par         This API is for package-manager client application
4633  * @par Sync (or) Async : Synchronous API
4634  *
4635  * @param[in] handle    pointer to the pkgdbinfo handle.
4636  * @param[in] preload           package preload value
4637  * @return      0 if success, error code(<0) if fail
4638  * @retval      PMINFO_R_OK     success
4639  * @retval      PMINFO_R_EINVAL invalid argument
4640  * @retval      PMINFO_R_ERROR  internal error
4641  * @pre         pkgmgrinfo_create_pkgdbinfo()
4642  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4643  * @see         pkgmgrinfo_save_pkgdbinfo()
4644  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4645  * @code
4646 static int set_pkg_preload_in_db(const char *pkgid)
4647 {
4648         int ret = 0;
4649         pkgmgrinfo_pkgdbinfo_h handle;
4650         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4651         if (ret != PMINFO_R_OK)
4652                 return -1;
4653         ret = pkgmgrinfo_set_preload_to_pkgdbinfo(handle, 1);
4654         if (ret != PMINFO_R_OK) {
4655                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4656                 return -1;
4657         }
4658         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4659         if (ret != PMINFO_R_OK) {
4660                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4661                 return -1;
4662         }
4663         pkgmgrinfo_destroy_pkgdbinfo(handle);
4664         return 0;
4665 }
4666  * @endcode
4667  */
4668 int pkgmgrinfo_set_preload_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int preload);
4669
4670 /**
4671  * @fn int pkgmgrinfo_set_installed_storage_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
4672  * @brief       This API sets the package 'installed_storage' value in db handle
4673  *
4674  * @par         This API is for package-manager client application
4675  * @par Sync (or) Async : Synchronous API
4676  *
4677  * @param[in] handle    pointer to the pkgdbinfo handle.
4678  * @param[in] location          installed_storage value
4679  * @return      0 if success, error code(<0) if fail
4680  * @retval      PMINFO_R_OK     success
4681  * @retval      PMINFO_R_EINVAL invalid argument
4682  * @retval      PMINFO_R_ERROR  internal error
4683  * @pre         pkgmgrinfo_create_pkgdbinfo()
4684  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4685  * @see         pkgmgrinfo_save_pkgdbinfo()
4686  * @code
4687 static int set_pkg_installed_storage_in_db(const char *pkgid)
4688 {
4689         int ret = 0;
4690         pkgmgrinfo_pkgdbinfo_h handle;
4691         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4692         if (ret != PMINFO_R_OK)
4693                 return -1;
4694         ret = pkgmgrinfo_set_installed_storage_to_pkgdbinfo(handle, INSTALL_INTERNAL);
4695         if (ret != PMINFO_R_OK) {
4696                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4697                 return -1;
4698         }
4699         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4700         if (ret != PMINFO_R_OK) {
4701                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4702                 return -1;
4703         }
4704         pkgmgrinfo_destroy_pkgdbinfo(handle);
4705         return 0;
4706 }
4707  * @endcode
4708  */
4709 int pkgmgrinfo_set_installed_storage_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location);
4710
4711 /**
4712  * @fn int pkgmgrinfo_save_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
4713  * @brief       This API saves all the information from the handle to the DB.
4714  *
4715  * @par         This API is for package-manager client application
4716  * @par Sync (or) Async : Synchronous API
4717  *
4718  * @param[in] handle            pointer to the package db info handle.
4719  * @return      0 if success, error code(<0) if fail
4720  * @retval      PMINFO_R_OK     success
4721  * @retval      PMINFO_R_EINVAL invalid argument
4722  * @retval      PMINFO_R_ERROR  internal error
4723  * @pre         pkgmgrinfo_create_pkgdbinfo()
4724  * @post                pkgmgrinfo_destroy_pkgdbinfo()
4725  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4726  * @code
4727 static int set_pkg_in_db(const char *pkgid)
4728 {
4729         int ret = 0;
4730         pkgmgrinfo_pkgdbinfo_h handle;
4731         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4732         if (ret != PMINFO_R_OK)
4733                 return -1;
4734         ret = pkgmgrinfo_set_version_to_pkgdbinfo(handle, "0.0.1");
4735         if (ret != PMINFO_R_OK) {
4736                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4737                 return -1;
4738         }
4739         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4740         if (ret != PMINFO_R_OK) {
4741                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4742                 return -1;
4743         }
4744         pkgmgrinfo_destroy_pkgdbinfo(handle);
4745         return 0;
4746 }
4747  * @endcode
4748  */
4749 int pkgmgrinfo_save_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle);
4750
4751 /**
4752  * @fn int pkgmgrinfo_destroy_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
4753  * @brief       This API destroys the package db information handle freeing up all the resources
4754  *
4755  * @par         This API is for package-manager client application
4756  * @par Sync (or) Async : Synchronous API
4757  *
4758  * @param[in] handle            pointer to the package db info handle.
4759  * @return      0 if success, error code(<0) if fail
4760  * @retval      PMINFO_R_OK     success
4761  * @retval      PMINFO_R_EINVAL invalid argument
4762  * @retval      PMINFO_R_ERROR  internal error
4763  * @pre         pkgmgrinfo_create_pkgdbinfo()
4764  * @post                None
4765  * @see         pkgmgrinfo_save_pkgdbinfo()
4766  * @see         pkgmgrinfo_set_type_to_pkgdbinfo()
4767  * @code
4768 static int set_pkg_in_db(const char *pkgid)
4769 {
4770         int ret = 0;
4771         pkgmgrinfo_pkgdbinfo_h handle;
4772         ret = pkgmgrinfo_create_pkgdbinfo(pkgid, &handle);
4773         if (ret != PMINFO_R_OK)
4774                 return -1;
4775         ret = pkgmgrinfo_set_version_to_pkgdbinfo(handle, "0.0.1");
4776         if (ret != PMINFO_R_OK) {
4777                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4778                 return -1;
4779         }
4780         ret = pkgmgrinfo_save_pkgdbinfo(handle);
4781         if (ret != PMINFO_R_OK) {
4782                 pkgmgrinfo_destroy_pkgdbinfo(handle);
4783                 return -1;
4784         }
4785         pkgmgrinfo_destroy_pkgdbinfo(handle);
4786         return 0;
4787 }
4788  * @endcode
4789  */
4790 int pkgmgrinfo_destroy_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle);
4791
4792
4793 /**
4794  * @fn int pkgmgrinfo_create_certinfo_set_handle(pkgmgrinfo_instcertinfo_h *handle)
4795  * @brief       This API creates the package cert information handle to set data in db.
4796  *
4797  * @par         This API is for package-manager client application
4798  * @par Sync (or) Async : Synchronous API
4799  *
4800  * @param[out] handle           pointer to the package cert handle.
4801  * @return      0 if success, error code(<0) if fail
4802  * @retval      PMINFO_R_OK     success
4803  * @retval      PMINFO_R_EINVAL invalid argument
4804  * @retval      PMINFO_R_ERROR  internal error
4805  * @pre         None
4806  * @post                pkgmgrinfo_destroy_certinfo_set_handle()
4807  * @see         pkgmgrinfo_set_cert_value()
4808  * @see         pkgmgrinfo_save_certinfo()
4809  * @code
4810 static int set_cert_in_db(const char *pkgid)
4811 {
4812         int ret = 0;
4813         pkgmgrinfo_instcertinfo_h handle;
4814         ret = pkgmgrinfo_create_certinfo_set_handle(&handle);
4815         if (ret != PMINFO_R_OK)
4816                 return -1;
4817         ret = pkgmgrinfo_set_cert_value(handle, PMINFO_SET_AUTHOR_ROOT_CERT, "author root certificate");
4818         if (ret != PMINFO_R_OK) {
4819                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4820                 return -1;
4821         }
4822         ret = pkgmgrinfo_save_pkgdbinfo(pkgid, handle);
4823         if (ret != PMINFO_R_OK) {
4824                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4825                 return -1;
4826         }
4827         pkgmgrinfo_destroy_certinfo_set_handle(handle);
4828         return 0;
4829 }
4830  * @endcode
4831  */
4832 int pkgmgrinfo_create_certinfo_set_handle(pkgmgrinfo_instcertinfo_h *handle);
4833
4834 /**
4835  * @fn int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, pkgmgrinfo_instcert_type cert_type, char *cert_value)
4836  * @brief       This API sets the package cert information in the handle.
4837  *
4838  * @par         This API is for package-manager client application
4839  * @par Sync (or) Async : Synchronous API
4840  *
4841  * @param[in] handle            pointer to the package cert handle.
4842  * @param[in] cert_type         certificate type.
4843  * @param[in] cert_value        certificate value.
4844  * @return      0 if success, error code(<0) if fail
4845  * @retval      PMINFO_R_OK     success
4846  * @retval      PMINFO_R_EINVAL invalid argument
4847  * @retval      PMINFO_R_ERROR  internal error
4848  * @pre         pkgmgrinfo_create_certinfo_set_handle()
4849  * @post                pkgmgrinfo_destroy_certinfo_set_handle()
4850  * @see         pkgmgrinfo_save_certinfo()
4851  * @code
4852 static int set_cert_in_db(const char *pkgid)
4853 {
4854         int ret = 0;
4855         pkgmgrinfo_instcertinfo_h handle;
4856         ret = pkgmgrinfo_create_certinfo_set_handle(&handle);
4857         if (ret != PMINFO_R_OK)
4858                 return -1;
4859         ret = pkgmgrinfo_set_cert_value(handle, PMINFO_SET_AUTHOR_ROOT_CERT, "author root certificate");
4860         if (ret != PMINFO_R_OK) {
4861                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4862                 return -1;
4863         }
4864         ret = pkgmgrinfo_save_pkgdbinfo(pkgid, handle);
4865         if (ret != PMINFO_R_OK) {
4866                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4867                 return -1;
4868         }
4869         pkgmgrinfo_destroy_certinfo_set_handle(handle);
4870         return 0;
4871 }
4872  * @endcode
4873  */
4874 int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, pkgmgrinfo_instcert_type cert_type, char *cert_value);
4875
4876 /**
4877  * @fn int pkgmgrinfo_save_certinfo(const char *pkgid, pkgmgrinfo_instcertinfo_h handle)
4878  * @brief       This API saves the package cert information in the DB.
4879  *
4880  * @par         This API is for package-manager client application
4881  * @par Sync (or) Async : Synchronous API
4882  *
4883  * @param[in] pkgid             pointer to the package ID.
4884  * @param[in] handle            pointer to the package cert handle.
4885  * @return      0 if success, error code(<0) if fail
4886  * @retval      PMINFO_R_OK     success
4887  * @retval      PMINFO_R_EINVAL invalid argument
4888  * @retval      PMINFO_R_ERROR  internal error
4889  * @pre         pkgmgrinfo_create_certinfo_set_handle()
4890  * @post                pkgmgrinfo_destroy_certinfo_set_handle()
4891  * @see         pkgmgrinfo_save_certinfo()
4892  * @code
4893 static int set_cert_in_db(const char *pkgid)
4894 {
4895         int ret = 0;
4896         pkgmgrinfo_instcertinfo_h handle;
4897         ret = pkgmgrinfo_create_certinfo_set_handle(&handle);
4898         if (ret != PMINFO_R_OK)
4899                 return -1;
4900         ret = pkgmgrinfo_set_cert_value(handle, PMINFO_SET_AUTHOR_ROOT_CERT, "author root certificate");
4901         if (ret != PMINFO_R_OK) {
4902                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4903                 return -1;
4904         }
4905         ret = pkgmgrinfo_save_pkgdbinfo(pkgid, handle);
4906         if (ret != PMINFO_R_OK) {
4907                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4908                 return -1;
4909         }
4910         pkgmgrinfo_destroy_certinfo_set_handle(handle);
4911         return 0;
4912 }
4913  * @endcode
4914  */
4915 int pkgmgrinfo_save_certinfo(const char *pkgid, pkgmgrinfo_instcertinfo_h handle);
4916
4917 /**
4918  * @fn int pkgmgrinfo_destroy_certinfo_set_handle(pkgmgrinfo_instcertinfo_h handle)
4919  * @brief       This API destroys the package cert information handle freeing up all the resources.
4920  *
4921  * @par         This API is for package-manager client application
4922  * @par Sync (or) Async : Synchronous API
4923  *
4924  * @param[in] handle            pointer to the package cert handle.
4925  * @return      0 if success, error code(<0) if fail
4926  * @retval      PMINFO_R_OK     success
4927  * @retval      PMINFO_R_EINVAL invalid argument
4928  * @retval      PMINFO_R_ERROR  internal error
4929  * @pre         pkgmgrinfo_create_certinfo_set_handle()
4930  * @post                None
4931  * @see         pkgmgrinfo_save_certinfo()
4932  * @code
4933 static int set_cert_in_db(const char *pkgid)
4934 {
4935         int ret = 0;
4936         pkgmgrinfo_instcertinfo_h handle;
4937         ret = pkgmgrinfo_create_certinfo_set_handle(&handle);
4938         if (ret != PMINFO_R_OK)
4939                 return -1;
4940         ret = pkgmgrinfo_set_cert_value(handle, PMINFO_SET_AUTHOR_ROOT_CERT, "author root certificate");
4941         if (ret != PMINFO_R_OK) {
4942                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4943                 return -1;
4944         }
4945         ret = pkgmgrinfo_save_pkgdbinfo(pkgid, handle);
4946         if (ret != PMINFO_R_OK) {
4947                 pkgmgrinfo_destroy_certinfo_set_handle(handle);
4948                 return -1;
4949         }
4950         pkgmgrinfo_destroy_certinfo_set_handle(handle);
4951         return 0;
4952 }
4953  * @endcode
4954  */
4955 int pkgmgrinfo_destroy_certinfo_set_handle(pkgmgrinfo_instcertinfo_h handle);
4956
4957 /**
4958  * @fn int pkgmgrinfo_datacontrol_get_info(const char *providerid, const char * type, char **appid, char **access)
4959  * @brief       This API gets the datacontrol info
4960  *
4961  * @par         This API is for package-manager client application
4962  * @par Sync (or) Async : Synchronous API
4963  *
4964  * @param[in] providerid                pointer to the providerid of dataconltrol.
4965  * @param[in] type                      pointer to the type of dataconltrol.
4966  * @param[out] appid                    pointer to hold appid, need to free after using
4967  * @param[out] access                   pointer to hold access, need to free after using
4968  * @return      0 if success, error code(<0) if fail
4969  * @retval      PMINFO_R_OK     success
4970  * @retval      PMINFO_R_EINVAL invalid argument
4971  * @retval      PMINFO_R_ERROR  internal error
4972  * @endcode
4973  */
4974 int pkgmgrinfo_datacontrol_get_info(const char *providerid, const char * type, char **appid, char **access);
4975
4976 /**
4977  * @fn int pkgmgrinfo_appinfo_is_guestmode_appstatus(pkgmgrinfo_appinfo_h handle, bool *status)
4978  * @brief       This API gets the application 'guest mode visibility' value from the DB
4979  *
4980  * @par         This API is for package-manager client application
4981  * @par Sync (or) Async : Synchronous API
4982  *
4983  * @param[in]   handle  pointer to application info handle
4984  * @param[out] status           pointer to hold app guest mode visibility value
4985  * @return      0 if success, error code(<0) if fail
4986  * @retval      PMINFO_R_OK     success
4987  * @retval      PMINFO_R_EINVAL invalid argument
4988  * @retval      PMINFO_R_ERROR  internal error
4989  * @pre         pkgmgrinfo_appinfo_get_appinfo()
4990  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
4991  * @see         pkgmgrinfo_appinfo_get_appid()
4992  * @see         pkgmgrinfo_appinfo_is_multiple()
4993  * @code
4994 static int get_app_guestmode_visibility(const char *appid)
4995 {
4996         int ret = 0;
4997         bool status;
4998         pkgmgrinfo_appinfo_h handle;
4999         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
5000         if (ret != PMINFO_R_OK)
5001                 return -1;
5002         ret = pkgmgrinfo_appinfo_is_guestmode_visibility(handle, &status);
5003         if (ret != PMINFO_R_OK) {
5004                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
5005                 return -1;
5006         }
5007         printf("app guest mode visibility: %d\n", status);
5008         pkgmgrinfo_appinfo_destroy_appinfo(handle);
5009         return 0;
5010 }
5011  * @endcode
5012  */
5013  int pkgmgrinfo_appinfo_is_guestmode_visibility(pkgmgrinfo_appinfo_h handle, bool *status);
5014
5015 /**
5016  * @fn int pkgmgrinfo_appinfo_set_guestmode_visibility(pkgmgrinfo_appinfo_h handle, bool status)
5017  * @brief       This API sets the application 'guest mode visibility' value in the DB
5018  *
5019  * @par         This API is for package-manager client application
5020  * @par Sync (or) Async : Synchronous API
5021  *
5022  * @param[in]   handle  pointer to application info handle
5023  * @param[out] status   app guest mode visibility value
5024  * @return      0 if success, error code(<0) if fail
5025  * @retval      PMINFO_R_OK     success
5026  * @retval      PMINFO_R_EINVAL invalid argument
5027  * @retval      PMINFO_R_ERROR  internal error
5028  * @pre         pkgmgrinfo_appinfo_get_appinfo()
5029  * @post                pkgmgrinfo_appinfo_destroy_appinfo()
5030  * @see         pkgmgrinfo_appinfo_get_appid()
5031  * @see         pkgmgrinfo_appinfo_is_multiple()
5032  * @code
5033 static int set_app_guestmode_visibility(const char *appid, bool value)
5034 {
5035         int ret = 0;
5036         pkgmgrinfo_appinfo_h handle;
5037         ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
5038         if (ret != PMINFO_R_OK)
5039                 return -1;
5040         ret = pkgmgrinfo_appinfo_set_guestmode_visibility(handle, value);
5041         if (ret != PMINFO_R_OK) {
5042                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
5043                 return -1;
5044         }
5045         pkgmgrinfo_appinfo_destroy_appinfo(handle);
5046         return 0;
5047 }
5048  * @endcode
5049  */
5050  int pkgmgrinfo_appinfo_set_guestmode_visibility(pkgmgrinfo_appinfo_h handle, bool status);
5051
5052
5053 /** @} */
5054 #ifdef __cplusplus
5055 }
5056 #endif
5057 #endif                          /* __PKG_INFO_H__ */
5058 /**
5059  * @}
5060  * @}
5061  */
5062