parser/include/pkgmgr_parser_db.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  * @file                pkgmgr_parser_db.h
  26  * @author      Shobhit Srivastava <shobhit.s@samsung.com>
  27  * @version     0.1
  28  * @brief               This file declares API to store/retrieve manifest data in DB
  29  *
  30  * @addtogroup APPLICATION_FRAMEWORK
  31  * @{
  32  *
  33   * @defgroup   PackageManagerParserDB
  34  * @section     Header Header file to include:
  35  * @code
  36  * #include <pkgmgr_parser_db.h>
  37  * @endcode
  38  *
  39  * @}
  40  */
  41
  42 #ifndef __PKGMGR_PARSER_DB_H__
  43 #define __PKGMGR_PARSER_DB_H__
  44
  45 #include "pkgmgr_parser.h"
  46 #include "pkgmgrinfo_type.h"
  47
  48 #ifdef __cplusplus
  49 extern "C" {
  50 #endif
  51
  52 /**
  53  * @fn int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
  54  * @fn int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx)
  55  * @brief       This API inserts the parsed manifest info in db
  56  *
  57  * @par         This API is for package-manager installer backends
  58  * @par Sync (or) Async : Synchronous API
  59  *
  60  * @param[in]   mfx     pointer to manifest info
  61  * @param[in]   uid     the addressee user id of the instruction
  62  * @return      0 if success, error code(<0) if fail
  63  * @pre         None
  64  * @post                None
  65  * @see         pkgmgr_parser_update_manifest_info_in_db()
  66  * @see         pkgmgr_parser_delete_manifest_info_from_db()
  67  * @code
  68 static int insert_manifest_data(manifest_x *mfx)
  69 {
  70         int ret = 0;
  71         ret = pkgmgr_parser_insert_manifest_info_in_db(mfx);
  72         if (ret < 0)
  73                 return -1;
  74         return 0;
  75 }
  76  * @endcode
  77  */
  78 int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx);
  79 int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid);
  80
  81 /**
  82  * @fn int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx)
  83  * @fn int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx)
  84  * @brief       This API updates the manifest info in db
  85  *
  86  * @par         This API is for package-manager installer backends
  87  * @par Sync (or) Async : Synchronous API
  88  *
  89  * @param[in]   mfx     pointer to manifest info
  90  * @param[in]   uid     the addressee user id of the instruction
  91  * @return      0 if success, error code(<0) if fail
  92  * @pre         None
  93  * @post                None
  94  * @see         pkgmgr_parser_insert_manifest_info_in_db()
  95  * @see         pkgmgr_parser_delete_manifest_info_from_db()
  96  * @code
  97 static int update_manifest_data(manifest_x *mfx)
  98 {
  99         int ret = 0;
 100         ret = pkgmgr_parser_update_manifest_info_in_db(mfx);
 101         if (ret < 0)
 102                 return -1;
 103         return 0;
 104 }
 105  * @endcode
 106  */
 107 int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx);
 108 int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid);
 109
 110 /**
 111  * @fn int pkgmgr_parser_update_tep_info_in_db(const char * pkgid, const char * tep_path)
 112  * @fn int pkgmgr_parser_update_tep_info_in_usr_db(const char * pkgid, const char * tep_path,uid_t uid)
 113  * @brief       This API updates the tep info in db
 114  *
 115  * @par         This API is for package-manager installer backends
 116  * @par Sync (or) Async : Synchronous API
 117  *
 118  * @param[in]   pkgid   pointer to pkgid
 119  * @param[in]   tep_path        path of tep file
 120  * @return      0 if success, error code(<0) if fail
 121  * @pre         None
 122  * @post                None
 123  * @code
 124 static int update_tep_data(const char *pkgid, *tep_path)
 125 {
 126         int ret = 0;
 127         ret = pkgmgr_parser_update_tep_info_in_db(pkgid, tep_path);
 128         if (ret < 0)
 129                 return -1;
 130         return 0;
 131 }
 132  * @endcode
 133  */
 134 int pkgmgr_parser_update_tep_info_in_db(const char *pkgid, const char *tep_path);
 135 int pkgmgr_parser_update_tep_info_in_usr_db(const char *pkgid, const char *tep_path, uid_t uid);
 136
 137 /**
 138  * @fn int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, uid_t uid)
 139  * @fn int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx)
 140  * @brief       This API deletes the parsed manifest info from db
 141  *
 142  * @par         This API is for package-manager installer backends
 143  * @par Sync (or) Async : Synchronous API
 144  *
 145  * @param[in]   mfx     pointer to manifest info
 146  * @param[in]   uid     the addressee user id of the instruction
 147  * @return      0 if success, error code(<0) if fail
 148  * @pre         None
 149  * @post                None
 150  * @see         pkgmgr_parser_update_manifest_info_in_db()
 151  * @see         pkgmgr_parser_insert_manifest_info_in_db()
 152  * @code
 153 static int delete_manifest_data(manifest_x *mfx)
 154 {
 155         int ret = 0;
 156         ret = pkgmgr_parser_delete_manifest_info_from_db(mfx);
 157         if (ret < 0)
 158                 return -1;
 159         return 0;
 160 }
 161  * @endcode
 162  */
 163 int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx);
 164 int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, uid_t uid);
 165
 166 /**
 167  * @fn int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(const char *appid, uid_t uid, int is_disable)
 168  * @brief       This API updates disable info about global app for user specified by uid
 169  *
 170  * @par         This API is for package-manager installer backends
 171  * @par Sync (or) Async : Synchronous API
 172  *
 173  * @param[in]   appid   global application ID to be enabled or disabled
 174  * @param[in]   uid     the addressee user id of the instruction
 175  * @param[in]is_disable determine enable or disable of app
 176  * @return      0 if success, error code(<0) if fail
 177  * @pre         None
 178  * @post                None
 179  * @code
 180 static int disable_global_app_for_uid(const char *appid, uid_t uid)
 181 {
 182         int ret = 0;
 183         ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(appid, uid, 1);
 184         if (ret < 0)
 185                 return -1;
 186         return 0;
 187 }
 188  * @endcode
 189  */
 190 int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(const char *appid, uid_t uid, int is_disable);
 191
 192 /**
 193  * @fn int pkgmgr_parser_update_app_disable_info_in_db(const char *appid, int is_disable);
 194  * @brief       This API updates disable info about app
 195  *
 196  * @par         This API is for package-manager installer backends
 197  * @par Sync (or) Async : Synchronous API
 198  *
 199  * @param[in]   appid   application ID to be enabled or disabled
 200  * @param[in]   is_disable      determine enable or disable of app
 201  * @return      0 if success, error code(<0) if fail
 202  * @pre         None
 203  * @post                None
 204  * @code
 205 static int disable_app(const char *appid)
 206 {
 207         int ret = 0;
 208         ret = pkgmgr_parser_update_app_disable_info_in_db(appid, 1);
 209         if (ret < 0)
 210                 return -1;
 211         return 0;
 212 }
 213  * @endcode
 214  */
 215 int pkgmgr_parser_update_app_disable_info_in_db(const char *appid, int is_disable);
 216 int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid, uid_t uid, int is_disable);
 217
 218 /**
 219  * @fn int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid, int is_disable);
 220  * @brief       This API updates disable info about pkg
 221  *
 222  * @par         This API is for package-manager installer backends
 223  * @par Sync (or) Async : Synchronous API
 224  *
 225  * @param[in]   pkgid   package ID to be enabled or disabled
 226  * @param[in]   is_disable      determine enable or disable of app
 227  * @return      0 if success, error code(<0) if fail
 228  * @pre         None
 229  * @post                None
 230  * @code
 231 static int disable_pkg(const char *pkgid)
 232 {
 233         int ret = 0;
 234         ret = pkgmgr_parser_update_pkg_disable_info_in_db(pkgid, 1);
 235         if (ret < 0)
 236                 return -1;
 237         return 0;
 238 }
 239  * @endcode
 240  */
 241 int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid, int is_disable);
 242 int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid, uid_t uid, int is_disable);
 243
 244 /**
 245  * @fn int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(const char *appid, uid_t uid, int flag)
 246  * @brief       This API updates splash screen display info about global app for user specified by uid
 247  *
 248  * @par         This API is for package-manager installer backends
 249  * @par Sync (or) Async : Synchronous API
 250  *
 251  * @param[in]   appid   global application ID to be enabled or disabled
 252  * @param[in]   uid     user ID
 253  * @param[in]   flag    determine enable or disable of app
 254  * @return      0 if success, error code(<0) if fail
 255  * @pre         None
 256  * @post                None
 257  * @code
 258 static int disable_global_app_splash_screen_for_uid(const char *appid, uid_t uid)
 259 {
 260         int ret = 0;
 261         ret = pkgmgr_parser_update_global_app_splash_screen_info_in_usr_db(appid, uid, 1);
 262         if (ret < 0)
 263                 return -1;
 264         return 0;
 265 }
 266  * @endcode
 267  */
 268 int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(const char *appid, uid_t uid, int flag);
 269
 270 /**
 271  * @fn int pkgmgr_parser_update_app_splash_screen_display_info_in_db(const char *appid, int flag)
 272  * @brief       This API updates splash screen display info about app
 273  *
 274  * @par         This API is for package-manager installer backends
 275  * @par Sync (or) Async : Synchronous API
 276  *
 277  * @param[in]   appid   application ID to be enabled or disabled
 278  * @param[in]   flag    determine enable or disable of app
 279  * @return      0 if success, error code(<0) if fail
 280  * @pre         None
 281  * @post                None
 282  * @code
 283 static int disable_app_splash_screen(const char *appid)
 284 {
 285         int ret = 0;
 286         ret = pkgmgr_parser_update_app_splash_screen_info_in_db(appid, 1);
 287         if (ret < 0)
 288                 return -1;
 289         return 0;
 290 }
 291  * @endcode
 292  */
 293 int pkgmgr_parser_update_app_splash_screen_display_info_in_db(const char *appid, int flag);
 294
 295 /**
 296  * @fn int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(const char *appid, uid_t uid, int flag)
 297  * @brief       This API updates splash screen display info about app for user specified by uid
 298  *
 299  * @par         This API is for package-manager installer backends
 300  * @par Sync (or) Async : Synchronous API
 301  *
 302  * @param[in]   appid   application ID to be enabled or disabled
 303  * @param[in]   uid     user ID
 304  * @param[in]   flag    determine enable or disable of app
 305  * @return      0 if success, error code(<0) if fail
 306  */
 307 int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(const char *appid, uid_t uid, int flag);
 308
 309 /**
 310  * @fn int pkgmgr_parser_update_app_label_info_in_db(const char *appid, const char *label)
 311  * @brief       This API updates label info of application
 312  *
 313  * @par         This API is only for internal usage
 314  * @par Sync (or) Async : Synchronous API
 315  *
 316  * @param[in]   appid   application ID to change label
 317  * @param[in]   label   label to change
 318  * @return      0 if success, error code(<0) if fail
 319  */
 320 int pkgmgr_parser_update_app_label_info_in_db(const char *appid, const char *label);
 321
 322 /**
 323  * @fn int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid, uid_t uid, const char *label)
 324  * @brief       This API updates label info of application for user specified by uid
 325  *
 326  * @par         This API is only for internal usage
 327  * @par Sync (or) Async : Synchronous API
 328  *
 329  * @param[in]   appid   application ID to change label
 330  * @param[in]   uid     user ID
 331  * @param[in]   label   label to change
 332  * @return      0 if success, error code(<0) if fail
 333  */
 334 int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid, uid_t uid, const char *label);
 335
 336 /**
 337  * @fn int pkgmgr_parser_update_app_icon_info_in_db(const char *appid, const char *icon_path)
 338  * @brief       This API updates icon info of application
 339  *
 340  * @par         This API is only for internal usage
 341  * @par Sync (or) Async : Synchronous API
 342  *
 343  * @param[in]   appid           application ID to change label
 344  * @param[in]   icon_path       icon path to change
 345  * @return      0 if success, error code(<0) if fail
 346  */
 347 int pkgmgr_parser_update_app_icon_info_in_db(const char *appid, const char *icon_path);
 348
 349 /**
 350  * @fn int pkgmgr_parser_update_app_icon_info_in_usr_db(const char *appid, uid_t uid, const char *icon_path)
 351  * @brief       This API updates icon info of application for user specified by uid
 352  *
 353  * @par         This API is only for internal usage
 354  * @par Sync (or) Async : Synchronous API
 355  *
 356  * @param[in]   appid           application ID to change label
 357  * @param[in]   uid             user ID
 358  * @param[in]   icon_path       icon path to change
 359  * @return      0 if success, error code(<0) if fail
 360  */
 361 int pkgmgr_parser_update_app_icon_info_in_usr_db(const char *appid, uid_t uid, const char *icon_path);
 362
 363 /**
 364  * @fn int pkgmgr_parser_register_pkg_update_info_in_usr_db(pkgmgrinfo_updateinfo_h handle, uid_t uid)
 365  * @brief       This API registers update informations of given packages for user specified by uid
 366  *
 367  * @par         This API is only for internal usage
 368  * @par Sync (or) Async : Synchronous API
 369  *
 370  * @param[in]   handle  update information handle
 371  * @param[in]   uid     user ID
 372  * @return      0 if success, error code(<0) if fail
 373  * @pre None
 374  * @post         None
 375  * @code
 376 static int register_pkg_update_info(pkgmgrinfo_updateinfo_h update_info, uid_t uid)
 377 {
 378         int ret = 0;
 379         ret = pkgmgr_parser_register_pkg_update_info_in_usr_db(update_info, uid);
 380         if (ret < 0)
 381                 return -1;
 382         return 0;
 383 }
 384  * @endcode
 385  */
 386 int pkgmgr_parser_register_pkg_update_info_in_usr_db(pkgmgrinfo_updateinfo_h handle, uid_t uid);
 387
 388 /**
 389  * @fn int pkgmgr_parser_register_pkg_update_info_in_db(pkgmgrinfo_updateinfo_h update_info)
 390  * @brief       This API registers update informations of given packages
 391  *
 392  * @par         This API is only for internal usage
 393  * @par Sync (or) Async : Synchronous API
 394  *
 395  * @param[in]   update_info     update information handle
 396  * @return      0 if success, error code(<0) if fail
 397  * @pre None
 398  * @post        None
 399  * @code
 400 static int register_pkg_update_info(pkgmgrinfo_updateinfo_h update_info)
 401 {
 402         int ret = 0;
 403         ret = pkgmgr_parser_register_pkg_update_info_in_db(update_info);
 404         if (ret < 0)
 405                 return -1;
 406         return 0;
 407 }
 408  * @endcode
 409  */
 410 int pkgmgr_parser_register_pkg_update_info_in_db(pkgmgrinfo_updateinfo_h update_info);
 411
 412 /**
 413  * @fn int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid, uid_t uid)
 414  * @brief       This API unregister update information of certain package for user specified by uid.
 415  *
 416  * @par         This API is only for internal usage
 417  * @par Sync (or) Async : Synchronous API
 418  *
 419  * @param[in]   pkgid   package ID
 420  * @param[in]   uid     user ID
 421  * @return      0 if success, error code(<0) if fail
 422  * @pre None
 423  * @post        None
 424  * @code
 425 static int register_pkg_update_info(pkgmgrinfo_updateinfo_h update_info, uid_t uid)
 426 {
 427         int ret = 0;
 428         ret = pkgmgr_parser_register_pkg_update_info_in_db(update_info, uid);
 429         if (ret < 0)
 430                 return -1;
 431         return 0;
 432 }
 433  * @endcode
 434  */
 435 int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid, uid_t uid);
 436
 437 /**
 438  * @fn int pkgmgr_parser_unregister_pkg_update_info_in_db(const char * pkgid)
 439  * @brief       This API unregister update information of certain package
 440  *
 441  * @par         This API is only for internal usage
 442  * @par Sync (or) Async : Synchronous API
 443  *
 444  * @param[in]   pkgid   package ID
 445  * @return      0 if success, error code(<0) if fail
 446  * @pre None
 447  * @post        None
 448  * @code
 449 static int unregister_pkg_update_info(const char *pkgid)
 450 {
 451         int ret = 0;
 452         ret = pkgmgr_parser_unregister_pkg_update_info_in_db(pkgid);
 453         if (ret < 0)
 454                 return -1;
 455         return 0;
 456 }
 457  * @endcode
 458  */
 459 int pkgmgr_parser_unregister_pkg_update_info_in_db(const char *pkgid);
 460
 461 /**
 462  * @fn int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid)
 463  * @brief       This API unregister update information of all packages
 464  *
 465  * @par         This API is only for internal usage
 466  * @par Sync (or) Async : Synchronous API
 467  *
 468  * @param[in]   uid     user ID
 469  * @return      0 if success, error code(<0) if fail
 470  * @pre None
 471  * @post        None
 472  * @code
 473 static int unregister_all_pkg_update_info(uid_t uid)
 474 {
 475         int ret = 0;
 476         ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid);
 477         if (ret < 0)
 478                 return -1;
 479         return 0;
 480 }
 481  * @endcode
 482  */
 483 int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid);
 484
 485 /**
 486  * @fn int pkgmgr_parser_unregister_all_pkg_update_info_in_db(void)
 487  * @brief       This API unregisters update information of all packages
 488  *
 489  * @par         This API is only for internal usage
 490  * @par Sync (or) Async : Synchronous API
 491  *
 492  * @return      0 if success, error code(<0) if fail
 493  * @pre None
 494  * @post         None
 495  * @code
 496 static int unregister_all_pkg_update_info(void)
 497 {
 498         int ret = 0;
 499         ret = pkgmgr_parser_unregister_all_pkg_update_info_in_db();
 500         if (ret < 0)
 501                 return -1;
 502         return 0;
 503 }
 504  * @endcode
 505  */
 506 int pkgmgr_parser_unregister_all_pkg_update_info_in_db(void);
 507
 508 /**
 509  * @fn int pkgmgr_parser_register_pkg_plugin_info_in_usr_db(manifest_x *mfx, uid_t uid)
 510  * @brief       This API registers package plugin execution information
 511  *
 512  * @par         This API is only for internal usage
 513  * @par Sync (or) Async : Synchronous API
 514  *
 515  * @param[in]   mfx     manifest structure pointer which contains plugin execution info
 516  * @return      0 if success, error code(<0) if fail
 517  * @pre None
 518  * @post         None
 519  * @code
 520 static int register_pkg_plugin_info(manifest_x *mfx)
 521 {
 522         int ret = 0;
 523         ret = pkgmgr_parser_register_pkg_plugin_info_in_db(mfx);
 524         if (ret < 0)
 525                 return -1;
 526         return 0;
 527 }
 528  * @endcode
 529  */
 530 int pkgmgr_parser_register_pkg_plugin_info_in_db(manifest_x *mfx);
 531 int pkgmgr_parser_register_pkg_plugin_info_in_usr_db(manifest_x *mfx, uid_t uid);
 532
 533 /**
 534  * @fn int pkgmgr_parser_update_pkg_plugin_info_in_usr_db(manifest_x *mfx, uid_t uid)
 535  * @brief       This API updates package plugin execution information
 536  *
 537  * @par         This API is only for internal usage
 538  * @par Sync (or) Async : Synchronous API
 539  *
 540  * @param[in]   mfx     manifest structure pointer which contains plugin execution info
 541  * @return      0 if success, error code(<0) if fail
 542  * @pre None
 543  * @post         None
 544  * @code
 545 static int update_pkg_plugin_info(manifest_x *mfx)
 546 {
 547         int ret = 0;
 548         ret = pkgmgr_parser_update_pkg_plugin_info_in_db(mfx);
 549         if (ret < 0)
 550                 return -1;
 551         return 0;
 552 }
 553  * @endcode
 554  */
 555 int pkgmgr_parser_update_pkg_plugin_info_in_db(manifest_x *mfx);
 556 int pkgmgr_parser_update_pkg_plugin_info_in_usr_db(manifest_x *mfx, uid_t uid);
 557
 558 /**
 559  * @fn int pkgmgr_parser_unregister_pkg_plugin_info_in_usr_db(const char *pkgid, uid_t uid)
 560  * @brief       This API unregisters package plugin execution information
 561  *
 562  * @par         This API is only for internal usage
 563  * @par Sync (or) Async : Synchronous API
 564  *
 565  * @param[in]   pkgid   package ID
 566  * @return      0 if success, error code(<0) if fail
 567  * @pre None
 568  * @post         None
 569  * @code
 570 static int unregister_pkg_plugin_info(const char *pkgid)
 571 {
 572         int ret = 0;
 573         ret = pkgmgr_parser_unregister_pkg_plugin_info_in_db(pkgid);
 574         if (ret < 0)
 575                 return -1;
 576         return 0;
 577 }
 578  * @endcode
 579  */
 580 int pkgmgr_parser_unregister_pkg_plugin_info_in_db(const char *pkgid);
 581 int pkgmgr_parser_unregister_pkg_plugin_info_in_usr_db(const char *pkgid, uid_t uid);
 582
 583 int pkgmgr_parser_create_and_initialize_db(uid_t uid);
 584
 585 int pkgmgr_parser_update_pending_cache(const char *pkgid);
 586
 587 /** @} */
 588 #ifdef __cplusplus
 589 }
 590 #endif
 591 #endif                          /* __PKGMGR_PARSER_DB_H__ */
 592 /**
 593  * @}
 594  * @}
 595  */