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