include/pkgmgr-info.h

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