include/pkgmgr-info.h

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