include/pkgmgr-info.h

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