installer/src/pkgmgr_installer.h

   1 /*
   2  * slp-pkgmgr
   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 #ifndef __PKGMGR_INSTALLER_H__
  25 #define __PKGMGR_INSTALLER_H__
  26
  27 #include <sys/types.h>
  28
  29 #include "package-manager.h"
  30 #include "pkgmgr_installer_type.h"
  31
  32 /**
  33  * @file pkgmgr_installer.h
  34  * @author Youmin Ha <youmin.ha@samsung.com>
  35  * @version 0.1
  36  * @brief    This file declares API of pkgmgr_installer
  37  */
  38
  39 #ifdef __cplusplus
  40 extern "C" {
  41 #endif
  42
  43 /**
  44  * pkgmgr_installer is an opaque type for an object
  45  */
  46 typedef void pkgmgr_installer;
  47 typedef void *pkgmgr_instcertinfo_h;
  48
  49 /**
  50  * @brief       Create a pkgmgr_installer object.
  51  * @pre         None
  52  * @post        pkgmgr_installer object must be freed.
  53  * @see         pkgmgr_installer_free
  54  * @return      pkgmgr_installer object
  55  * @retval      NULL    on failure creating an object
  56  * @remark      None
  57 @code
  58 #include <pkgmgr_installer.h>
  59 pkgmgr_installer *pi = pkgmgr_installer_new();
  60 pkgmgr_installer_free(pi);
  61 @endcode
  62  */
  63 pkgmgr_installer *pkgmgr_installer_new(void);
  64
  65 /**
  66  * @brief       Create a pkgmgr_installer object in offline mode
  67  * @pre         None
  68  * @post        pkgmgr_installer object must be freed.
  69  * @see         pkgmgr_installer_free
  70  * @return      pkgmgr_installer object
  71  * @retval      NULL    on failure creating an object
  72  * @remark      None
  73 @code
  74 #include <pkgmgr_installer.h>
  75 pkgmgr_installer *pi = pkgmgr_installer_offline_new();
  76 pkgmgr_installer_free(pi);
  77 @endcode
  78  */
  79 pkgmgr_installer *pkgmgr_installer_offline_new(void);
  80
  81 /**
  82         @brief          Free a pkgmgr_installer object
  83         @pre            pi must be a valid object.
  84         @post           None
  85         @see            pkgmgr_installer_new
  86         @param[in]      pi      A pkgmgr_installer object
  87         @return         Operation result
  88         @retval         0       on success
  89         @retval         -errno  on error
  90         @remark         None
  91         @code
  92 #include <pkgmgr_installer.h>
  93 pkgmgr_installer *pi = pkgmgr_installer_new();
  94 pkgmgr_installer_free(pi);
  95         @endcode
  96  */
  97 int pkgmgr_installer_free(pkgmgr_installer *pi);
  98
  99 /**
 100         @brief          Receive a request from argv
 101         @pre            None
 102         @post           pkgmgr_installer_get_*(), pkgmgr_installer_is_quiet() can be called.
 103         @see            pkgmgr_installer_get_request_type, pkgmgr_installer_get_request_info, pkgmgr_installer_get_session_id, pkgmgr_installer_is_quiet
 104         @param[in]      pi      a pkgmgr_installer object
 105         @param[in]      argc    argc from system
 106         @param[in]      argv    argv from system
 107         @return         Operation result
 108         @retval         0 on success
 109         @retval         -errno on failure
 110         @remark         None
 111         @code
 112 #include <pkgmgr_installer.h>
 113 int main(int argc, char **argv)
 114 {
 115         pkgmgr_installer *pi;
 116         int r;
 117
 118         pi = pkgmgr_installer_new();
 119         int r = pkgmgr_installer_receive_request(pi, argc, argv);
 120         pkgmgr_installer_free(pi);
 121
 122         return 0;
 123 }
 124         @endcode
 125  */
 126 int pkgmgr_installer_receive_request(pkgmgr_installer *pi,
 127                                      const int argc, char **argv);
 128
 129 /**
 130         @brief          Get request type
 131         @pre            pkgmgr_installer_receive_request() must be called.
 132         @post           None
 133         @see            pkgmgr_installer_receive_request
 134         @param[in]      pi      pkgmgr_installer object
 135         @return         Request type (One of PKGMGR_REQ_* enum values)
 136         @remark         None
 137         @code
 138 int main(int argc, char **argv)
 139 {
 140         pkgmgr_installer *pi;
 141         int r = 0;
 142
 143         pi = pkgmgr_installer_new();
 144         if(!pi) return -1;
 145         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 146                 r = -1;
 147                 goto CLEANUP_RET;
 148         }
 149
 150         switch(pkgmgr_installer_get_request_type(pi)) {
 151                 case PKGMGR_REQ_PERM:
 152                         // Do error processing
 153                         break;
 154                 case PKGMGR_REQ_INVALID:
 155                         // Do error processing
 156                         r = -1;
 157                         break;
 158                 case PKGMGR_REQ_INSTALL:
 159                         // Do install processing
 160                         break;
 161                 case PKGMGR_REQ_UNINSTALL:
 162                         // Do uninstall processing
 163                         break;
 164                 case PKGMGR_REQ_RECOVER:
 165                         // Do recovere processing
 166                         break;
 167                 case PKGMGR_REQ_REINSTALL:
 168                         // Do reinstall processing
 169                         break;
 170                 default:
 171                         goto CLEANUP_END;
 172         }
 173 CLEANUP_END:
 174         pkgmgr_installer_free(pi);
 175
 176         return r;
 177 }
 178         @endcode
 179  */
 180 int pkgmgr_installer_get_request_type(pkgmgr_installer *pi);
 181
 182 /**
 183         @brief          Get uid
 184         @pre            pkgmgr_installer_receive_request() must be called.
 185         @post           None
 186         @see            pkgmgr_installer_receive_request
 187         @param[in]      pi      pkgmgr_installer object
 188         @return         Uid info.
 189         @retval         NULL    on function failure
 190         @remark         Returned uid must not be modified.
 191         @code
 192 #include <pkgmgr_installer.h>
 193 int main(int argc, char **argv)
 194 {
 195         pkgmgr_installer *pi;
 196         int r = 0;
 197         uid_t uid;
 198
 199         pi = pkgmgr_installer_new();
 200         if(!pi) return -1;
 201         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 202                 r = -1;
 203                 goto CLEANUP_RET;
 204         }
 205         uid = pkgmgr_installer_get_uid(pi);
 206
 207         // Do something...
 208
 209         pkgmgr_installer_free(pi);
 210         return r;
 211 }
 212         @endcode
 213  */
 214 uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi);
 215
 216 /**
 217         @brief          Get request info
 218         @pre            pkgmgr_installer_receive_request() must be called.
 219         @post           None
 220         @see            pkgmgr_installer_receive_request
 221         @param[in]      pi      pkgmgr_installer object
 222         @return         Request info. When PKGMGR_REQ_INSTALL, this is a package file path to be installed. When PKGMGR_REQ_UNINSTALL, this is a package name to be uninstalled.
 223         @retval         NULL    on function failure
 224         @remark         Returned string must not be modified.
 225         @code
 226 #include <pkgmgr_installer.h>
 227 int main(int argc, char **argv)
 228 {
 229         pkgmgr_installer *pi;
 230         int r = 0;
 231         char *req_info = NULL;
 232
 233         pi = pkgmgr_installer_new();
 234         if(!pi) return -1;
 235         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 236                 r = -1;
 237                 goto CLEANUP_RET;
 238         }
 239         req_info = (char *) pkgmgr_installer_get_request_info(pi);
 240
 241         // Do something...
 242
 243         pkgmgr_installer_free(pi);
 244         return r;
 245 }
 246         @endcode
 247  */
 248 const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi);
 249
 250 /**
 251         @brief          Get request info at specific position
 252         @pre            pkgmgr_installer_receive_request() must be called.
 253         @post           None
 254         @see            pkgmgr_installer_receive_request
 255         @see            pkgmgr_installer_get_request_info_count
 256         @param[in]      pi      pkgmgr_installer object
 257         @return         Request info. When PKGMGR_REQ_INSTALL, this is a package file path to be installed. When PKGMGR_REQ_UNINSTALL, this is a package name to be uninstalled.
 258         @retval         NULL    on function failure
 259         @remark         Returned string must not be modified.
 260         @code
 261 #include <pkgmgr_installer.h>
 262 int main(int argc, char **argv)
 263 {
 264         pkgmgr_installer *pi;
 265         int r = 0;
 266         char *req_info = NULL;
 267
 268         pi = pkgmgr_installer_new();
 269         if(!pi) return -1;
 270         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 271                 r = -1;
 272                 goto CLEANUP_RET;
 273         }
 274         req_info = (char *) pkgmgr_installer_get_request_info_at(pi, 1);
 275
 276         // Do something...
 277
 278         pkgmgr_installer_free(pi);
 279         return r;
 280 }
 281         @endcode
 282  */
 283 const char *pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi,
 284                 int at);
 285
 286 /**
 287         @brief          Get the number of request info
 288         @pre            pkgmgr_installer_receive_request() must be called.
 289         @post           None
 290         @see            pkgmgr_installer_receive_request
 291         @param[in]      pi      pkgmgr_installer object
 292         @return         The number of request info.
 293         @code
 294 #include <pkgmgr_installer.h>
 295 int main(int argc, char **argv)
 296 {
 297         pkgmgr_installer *pi;
 298         int r = 0;
 299         int n;
 300
 301         pi = pkgmgr_installer_new();
 302         if(!pi) return -1;
 303         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 304                 r = -1;
 305                 goto CLEANUP_RET;
 306         }
 307         n = pkgmgr_installer_get_request_info_count(pi);
 308
 309         // Do something...
 310
 311         pkgmgr_installer_free(pi);
 312         return r;
 313 }
 314         @endcode
 315  */
 316 int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi);
 317
 318 /**
 319         @brief          Get TEP path
 320         @pre            pkgmgr_installer_receive_request() must be called.
 321         @post           None
 322         @see            pkgmgr_installer_receive_request
 323         @param[in]      pi      pkgmgr_installer object
 324         @return         TEP path if exists
 325         @retval         NULL    on function failure
 326         @remark         Returned string must not be modified.
 327         @code
 328 #include <pkgmgr_installer.h>
 329 int main(int argc, char **argv)
 330 {
 331         pkgmgr_installer *pi;
 332         int r = 0;
 333         char *tep_path = NULL;
 334
 335         pi = pkgmgr_installer_new();
 336         if(!pi) return -1;
 337         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 338                 r = -1;
 339                 goto CLEANUP_RET;
 340         }
 341         tep_path = (char *) pkgmgr_installer_get_tep_path(pi);
 342
 343         // Do something...
 344
 345         pkgmgr_installer_free(pi);
 346         return r;
 347 }
 348 @endcode
 349  */
 350 const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi);
 351
 352 /**
 353         @brief          Get TEP move type
 354         @pre            pkgmgr_installer_receive_request() must be called.
 355         @post           None
 356         @see            pkgmgr_installer_receive_request
 357         @param[in]      pi      pkgmgr_installer object
 358         @return         integer value indicates tep move type(0: copy TEP file / 1: move TEP file)
 359         @retval         0       on function failure
 360         @remark         Returned string must not be modified.
 361         @code
 362 #include <pkgmgr_installer.h>
 363 int main(int argc, char **argv)
 364 {
 365         pkgmgr_installer *pi;
 366         int r = 0;
 367         int tep_move_type = -1;
 368
 369         pi = pkgmgr_installer_new();
 370         if(!pi) return -1;
 371         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 372                 r = -1;
 373                 goto CLEANUP_RET;
 374         }
 375         tep_move_type = pkgmgr_installer_get_tep_move_type(pi);
 376
 377         // Do something...
 378
 379         pkgmgr_installer_free(pi);
 380         return r;
 381 }
 382 @endcode
 383  */
 384 int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi);
 385
 386 /**
 387         @brief          Get session ID for a certain session
 388         @pre            pkgmgr_installer_receive_request() must be called.
 389         @post           None
 390         @see            pkgmgr_installer_receive_request
 391         @param[in]      pi      pkgmgr_installer object
 392         @return         A session ID
 393         @retval         NULL    on function failure
 394         @remark         Returned string must not be modified.
 395         @code
 396 #include <pkgmgr_installer.h>
 397 int main(int argc, char **argv)
 398 {
 399         pkgmgr_installer *pi;
 400         int r = 0;
 401         char *session_id = NULL;
 402
 403         pi = pkgmgr_installer_new();
 404         if(!pi) return -1;
 405         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 406                 r = -1;
 407                 goto CLEANUP_RET;
 408         }
 409         session_id = (char *) pkgmgr_installer_get_session_id(pi);
 410
 411         // Do something...
 412
 413         pkgmgr_installer_free(pi);
 414         return r;
 415 }
 416 @endcode
 417  */
 418 const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi);
 419
 420 /**
 421         @brief          Get a license path
 422         @pre            pkgmgr_installer_receive_request() must be called.
 423         @post           None
 424         @see            pkgmgr_installer_receive_request
 425         @param[in]      pi      pkgmgr_installer object
 426         @return         license path
 427         @retval         NULL    on function failure
 428         @remark         Returned string must not be modified.
 429         @code
 430 #include <pkgmgr_installer.h>
 431 int main(int argc, char **argv)
 432 {
 433         pkgmgr_installer *pi;
 434         int r = 0;
 435         char *license_path = NULL;
 436
 437         pi = pkgmgr_installer_new();
 438         if(!pi) return -1;
 439         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 440                 r = -1;
 441                 goto CLEANUP_RET;
 442         }
 443         session_id = (char *) pkgmgr_installer_get_license_path(pi);
 444
 445         // Do something...
 446
 447         pkgmgr_installer_free(pi);
 448         return r;
 449 }
 450 @endcode
 451  */
 452 const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi);
 453
 454 /**
 455         @brief          Get a optional data
 456         @pre            pkgmgr_installer_receive_request() must be called.
 457         @post           None
 458         @see            pkgmgr_installer_receive_request
 459         @param[in]      pi      pkgmgr_installer object
 460         @return         optional data
 461         @retval         NULL    on function failure
 462         @remark         Returned string must not be modified.
 463         @code
 464 #include <pkgmgr_installer.h>
 465 int main(int argc, char **argv)
 466 {
 467         pkgmgr_installer *pi;
 468         int r = 0;
 469         char *optional_data = NULL;
 470
 471         pi = pkgmgr_installer_new();
 472         if(!pi) return -1;
 473         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 474                 r = -1;
 475                 goto CLEANUP_RET;
 476         }
 477         optional_data = (char *) pkgmgr_installer_get_optional_data(pi);
 478
 479         // Do something...
 480
 481         pkgmgr_installer_free(pi);
 482         return r;
 483 }
 484 @endcode
 485  */
 486 const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi);
 487
 488 /**
 489         @brief          Get if a request is with quite mode or not
 490         @pre            pkgmgr_installer_receive_request() must be called.
 491         @post           None
 492         @see            pkgmgr_installer_receive_request
 493         @param[in]      pi      pkgmgr_installer object
 494         @return         Operation result
 495         @retval         0 if a request is not quiet mode
 496         @retval         1 if a request is quiet mode
 497         @remark         None
 498         @code
 499 #include <pkgmgr_installer.h>
 500 int main(int argc, char **argv)
 501 {
 502         pkgmgr_installer *pi;
 503         int r = 0;
 504
 505         pi = pkgmgr_installer_new();
 506         if(!pi) return -1;
 507         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 508                 r = -1;
 509                 goto CLEANUP_RET;
 510         }
 511         if(pkgmgr_installer_is_quiet(pi)) {
 512                 // Do quiet mode work...
 513         } else {
 514                 // Do normal mode work...
 515         }
 516
 517         pkgmgr_installer_free(pi);
 518         return r;
 519 }
 520         @endcode
 521  */
 522 int pkgmgr_installer_is_quiet(pkgmgr_installer *pi);
 523
 524 /**
 525         @brief          Get move type
 526         @pre            pkgmgr_installer_receive_request() must be called.
 527         @post           None
 528         @see            pkgmgr_installer_receive_request
 529         @param[in]      pi      pkgmgr_installer object
 530         @return         Operation result
 531         @retval         enum value of move type
 532         @remark         None
 533         @code
 534 #include <pkgmgr_installer.h>
 535 int main(int argc, char **argv)
 536 {
 537         pkgmgr_installer *pi;
 538         int r = 0;
 539
 540         pi = pkgmgr_installer_new();
 541         if(!pi) return -1;
 542         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 543                 r = -1;
 544                 goto CLEANUP_RET;
 545         }
 546         move_type = pkgmgr_installer_get_move_type(pi);
 547
 548         //Do Something
 549
 550         pkgmgr_installer_free(pi);
 551         return r;
 552 }
 553         @endcode
 554  */
 555 int pkgmgr_installer_get_move_type(pkgmgr_installer *pi);
 556
 557 /**
 558         @brief          Get caller package id
 559         @pre            pkgmgr_installer_receive_request() must be called.
 560         @post           None
 561         @see            pkgmgr_installer_receive_request
 562         @param[in]      pi      pkgmgr_installer object
 563         @return         Operation result
 564         @retval         enum value of move type
 565         @remark         None
 566         @code
 567 #include <pkgmgr_installer.h>
 568 int main(int argc, char **argv)
 569 {
 570         pkgmgr_installer *pi;
 571         int r = 0;
 572         char *pkgid = NULL;
 573
 574         pi = pkgmgr_installer_new();
 575         if(!pi) return -1;
 576         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 577                 r = -1;
 578                 goto CLEANUP_RET;
 579         }
 580         pkgid = (char *) pkgmgr_installer_get_caller_pkgid(pi);
 581
 582         // Do something...
 583
 584         pkgmgr_installer_free(pi);
 585         return r;
 586 }
 587         @endcode
 588  */
 589 const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi);
 590
 591 /**
 592         @brief          Get if the request is for preload app or not
 593         @pre            pkgmgr_installer_receive_request() must be called.
 594         @post           None
 595         @see            pkgmgr_installer_receive_request
 596         @param[in]      pi      pkgmgr_installer object
 597         @return         Operation result
 598         @retval         0 if a request is not for preload
 599         @retval         1 if a request is for preload
 600         @remark         None
 601         @code
 602 #include <pkgmgr_installer.h>
 603 int main(int argc, char **argv)
 604 {
 605         pkgmgr_installer *pi;
 606         int r = 0;
 607         int is_preload = 0;
 608
 609         pi = pkgmgr_installer_new();
 610         if(!pi) return -1;
 611         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 612                 r = -1;
 613                 goto CLEANUP_RET;
 614         }
 615         is_preload = pkgmgr_installer_get_is_preload(pi);
 616
 617         // Do something...
 618
 619         pkgmgr_installer_free(pi);
 620         return r;
 621 }
 622         @endcode
 623  */
 624 int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi);
 625 int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi);
 626
 627 /**
 628         @brief          Get if the request is for force-removal
 629         @pre            pkgmgr_installer_receive_request() must be called.
 630         @post           None
 631         @see            pkgmgr_installer_receive_request
 632         @param[in]      pi      pkgmgr_installer object
 633         @return         Operation result
 634         @retval         0 if a request is not for force-removal
 635         @retval         1 if a request is for force-removal
 636         @remark         None
 637         @code
 638 #include <pkgmgr_installer.h>
 639 int main(int argc, char **argv)
 640 {
 641         pkgmgr_installer *pi;
 642         int r = 0;
 643         int force_remove = 0;
 644
 645         pi = pkgmgr_installer_new();
 646         if(!pi) return -1;
 647         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 648                 r = -1;
 649                 goto CLEANUP_RET;
 650         }
 651         force_remove = pkgmgr_installer_get_force_removal(pi);
 652
 653         // Do something...
 654
 655         pkgmgr_installer_free(pi);
 656         return r;
 657 }
 658         @endcode
 659  */
 660 int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi);
 661 int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi);
 662
 663 /**
 664         @brief          Get if the request is for keep-rwdata
 665         @pre            pkgmgr_installer_receive_request() must be called.
 666         @post           None
 667         @see            pkgmgr_installer_receive_request
 668         @param[in]      pi      pkgmgr_installer object
 669         @return         Operation result
 670         @retval         0 if a request is not for keep-rwdata
 671         @retval         1 if a request is for keep-rwdata
 672         @remark         Keep RW-data of updated RO pkg.
 673         @code
 674 #include <pkgmgr_installer.h>
 675 int main(int argc, char **argv)
 676 {
 677         pkgmgr_installer *pi;
 678         int r = 0;
 679         int force_remove = 0;
 680
 681         pi = pkgmgr_installer_new();
 682         if(!pi) return -1;
 683         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 684                 r = -1;
 685                 goto CLEANUP_RET;
 686         }
 687         force_remove = pkgmgr_installer_get_keep_rwdata(pi);
 688
 689         // Do something...
 690
 691         pkgmgr_installer_free(pi);
 692         return r;
 693 }
 694         @endcode
 695  */
 696 int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi);
 697
 698 /**
 699         @brief          Get if the request is for partial-rw
 700         @pre            pkgmgr_installer_receive_request() must be called.
 701         @post           None
 702         @see            pkgmgr_installer_receive_request
 703         @param[in]      pi      pkgmgr_installer object
 704         @return         Operation result
 705         @retval         0 if a request is not for partial-rw
 706         @retval         1 if a request is for partial-rw
 707         @remark         For install/update/uninstall of stubs of RO pkg
 708                         on RW partitions
 709         @code
 710 #include <pkgmgr_installer.h>
 711 int main(int argc, char **argv)
 712 {
 713         pkgmgr_installer *pi;
 714         int r = 0;
 715         int force_remove = 0;
 716
 717         pi = pkgmgr_installer_new();
 718         if(!pi) return -1;
 719         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 720                 r = -1;
 721                 goto CLEANUP_RET;
 722         }
 723         force_remove = pkgmgr_installer_get_partial_rw(pi);
 724
 725         // Do something...
 726
 727         pkgmgr_installer_free(pi);
 728         return r;
 729 }
 730         @endcode
 731  */
 732 int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi);
 733
 734 /**
 735         @brief          Get debug mode value
 736         @pre            pkgmgr_installer_receive_request() must be called.
 737         @post           None
 738         @see            pkgmgr_installer_receive_request
 739         @param[in]      pi      pkgmgr_installer object
 740         @return         Operation result
 741         @retval         0 if a request is not debug mode
 742         @retval         1 if a request is debug mode
 743         @remark         None
 744         @code
 745 #include <pkgmgr_installer.h>
 746 int main(int argc, char **argv)
 747 {
 748         pkgmgr_installer *pi;
 749         int r = 0;
 750         int force_remove = 0;
 751
 752         pi = pkgmgr_installer_new();
 753         if(!pi) return -1;
 754         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 755                 r = -1;
 756                 goto CLEANUP_RET;
 757         }
 758         force_remove = pkgmgr_installer_get_debug_mode(pi);
 759
 760         // Do something...
 761
 762         pkgmgr_installer_free(pi);
 763         return r;
 764 }
 765         @endcode
 766 */
 767 int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi);
 768
 769 /**
 770         @brief          Get skip_check_reference value
 771         @pre            pkgmgr_installer_receive_request() must be called.
 772         @post           None
 773         @see            pkgmgr_installer_receive_request
 774         @param[in]      pi      pkgmgr_installer object
 775         @return         Operation result
 776         @retval         0 if a request does not skip checking reference
 777         @retval         1 if a request skip checking reference
 778         @remark         None
 779         @code
 780 #include <pkgmgr_installer.h>
 781 int main(int argc, char **argv)
 782 {
 783         pkgmgr_installer *pi;
 784         int r = 0;
 785         int check_reference = 0;
 786
 787         pi = pkgmgr_installer_new();
 788         if(!pi) return -1;
 789         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 790                 r = -1;
 791                 goto CLEANUP_RET;
 792         }
 793         check_reference = pkgmgr_installer_get_skip_check_reference(pi);
 794
 795         // Do something...
 796
 797         pkgmgr_installer_free(pi);
 798         return r;
 799 }
 800         @endcode
 801 */
 802 int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi);
 803
 804 /**
 805         @brief          Get skip optimization value
 806         @pre            pkgmgr_installer_receive_request() must be called.
 807         @post           None
 808         @see            pkgmgr_installer_receive_request
 809         @param[in]      pi      pkgmgr_installer object
 810         @return         Operation result
 811         @retval         0 if a request is not debug mode
 812         @retval         1 if a request is debug mode
 813         @remark         None
 814         @code
 815 #include <pkgmgr_installer.h>
 816 int main(int argc, char **argv)
 817 {
 818         pkgmgr_installer *pi;
 819         int r = 0;
 820         int skip_optimization = 0;
 821
 822         pi = pkgmgr_installer_new();
 823         if(!pi) return -1;
 824         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 825                 r = -1;
 826                 goto CLEANUP_RET;
 827         }
 828         skip_optimization = pkgmgr_installer_get_skip_optimization(pi);
 829
 830         // Do something...
 831
 832         pkgmgr_installer_free(pi);
 833         return r;
 834 }
 835         @endcode
 836 */
 837 int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi);
 838
 839 /**
 840         @brief          Get recovery cleanup mode
 841         @pre            pkgmgr_installer_receive_request() must be called.
 842         @post           None
 843         @see            pkgmgr_installer_receive_request
 844         @param[in]      pi      pkgmgr_installer object
 845         @return         Operation result
 846         @retval         0 if a recovery cleanup flag has not set
 847         @retval         1 if a recovery cleanup flag has set
 848         @remark         None
 849         @code
 850 #include <pkgmgr_installer.h>
 851 int main(int argc, char **argv)
 852 {
 853         pkgmgr_installer *pi;
 854         int r = 0;
 855         int recovery_cleanup = 0;
 856
 857         pi = pkgmgr_installer_new();
 858         if(!pi) return -1;
 859         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 860                 r = -1;
 861                 goto CLEANUP_RET;
 862         }
 863         recovery_cleanup = pkgmgr_installer_get_recovery_cleanup(pi);
 864
 865         // Do something...
 866
 867         pkgmgr_installer_free(pi);
 868         return r;
 869 }
 870         @endcode
 871 */
 872 int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi);
 873
 874 /**
 875         @brief          Send a app status signal
 876         @pre            None
 877         @post           None
 878         @see            None
 879         @param[in]      pi      pkgmgr_installer object
 880         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 881         @param[in]      pkgid   package id
 882         @param[in]      appid   application id
 883         @param[in]      key                     Signal key
 884         @param[in]      val                     Signal value
 885         @return         Operation result
 886         @retval         0 on success
 887         @retval         -errno on failure
 888         @code
 889 #include <pkgmgr_installer.h>
 890 void send_app_singal(uid_t uid, int request_type, int req_id,
 891                 const char *pkg_type, const char *pkgid, const char *appid,
 892                 const char *key, const char *val)
 893 {
 894         pkgmgr_installer *pi;
 895         int r = 0;
 896
 897         pi = pkgmgr_installer_new();
 898         if(!pi) return -1;
 899
 900         if (pkgmgr_installer_set_uid(pi, uid))
 901                 goto CLEANUP_RET;
 902         if (pkgmgr_installer_set_request_type(pi, request_type))
 903                 goto CLEANUP_RET;
 904         if ((pkgmgr_installer_set_session_id(pi, req_id))
 905                 goto CLEANUP_RET;
 906         pkgmgr_installer_send_app_signal(pi, pkg_type, pkgid, appid, key, val);
 907
 908 }
 909         @endcode
 910  */
 911 int pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
 912                              const char *pkg_type,
 913                              const char *pkgid,
 914                              const char *appid,
 915                              const char *key, const char *val);
 916
 917 /**
 918         @brief          Send a process status signal
 919         @pre            None
 920         @post           None
 921         @see            None
 922         @param[in]      pi      pkgmgr_installer object
 923         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 924         @param[in]      pkgid   package id
 925         @param[in]      key                     Signal key
 926         @param[in]      val                     Signal value
 927         @return         Operation result
 928         @retval         0 on success
 929         @retval         -errno on failure
 930         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 931         @code
 932 #include <pkgmgr_installer.h>
 933 int main(int argc, char **argv)
 934 {
 935         pkgmgr_installer *pi;
 936         int r = 0;
 937         char *session_id = NULL;
 938
 939         pi = pkgmgr_installer_new();
 940         if(!pi) return -1;
 941         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 942                 r = -1;
 943                 goto CLEANUP_RET;
 944         }
 945
 946         // Do something...
 947         pkgmgr_installer_send_signal(pi,
 948          "deb", "org.tizen.foo", "install_percent", "100");
 949         // A sample signal
 950
 951         pkgmgr_installer_free(pi);
 952         return r;
 953 }
 954         @endcode
 955  */
 956 int pkgmgr_installer_send_signal(pkgmgr_installer *pi,
 957                                  const char *pkg_type,
 958                                  const char *pkgid, const char *key,
 959                                  const char *val);
 960
 961 /**
 962         @brief          Send a app status signal
 963         @pre            None
 964         @post           None
 965         @see            None
 966         @param[in]      pi      pkgmgr_installer object
 967         @param[in]      uid     user id
 968         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 969         @param[in]      pkgid   package id
 970         @param[in]      appid   application id
 971         @param[in]      key                     Signal key
 972         @param[in]      val                     Signal value
 973         @return         Operation result
 974         @retval         0 on success, otherwise -1
 975         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 976  */
 977 int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
 978                                  uid_t uid,
 979                                  const char *pkg_type,
 980                                  const char *pkgid,
 981                                  const char *appid,
 982                                  const char *key, const char *val);
 983
 984 /**
 985         @brief          Send a process status signal
 986         @pre            None
 987         @post           None
 988         @see            None
 989         @param[in]      pi      pkgmgr_installer object
 990         @param[in]      uid     user id
 991         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 992         @param[in]      pkgid   package id
 993         @param[in]      key                     Signal key
 994         @param[in]      val                     Signal value
 995         @return         Operation result
 996         @retval         0 on success, otherwise -1
 997         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 998  */
 999 int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
1000                                  uid_t uid,
1001                                  const char *pkg_type,
1002                                  const char *pkgid, const char *key,
1003                                  const char *val);
1004
1005 /**
1006         @brief          Send a signal which indicates application is being uninstalled
1007         @pre            None
1008         @post           None
1009         @see            None
1010         @param[in]      pi      pkgmgr_installer object
1011         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
1012         @param[in]      pkgid   package id
1013         @param[in]      key                     Signal key
1014         @param[in]      val                     Signal value
1015         @return         Operation result
1016         @retval         0 on success
1017         @retval         -errno on failure
1018         @code
1019 #include <pkgmgr_installer.h>
1020 int main(int argc, char **argv)
1021 {
1022         pkgmgr_installer *pi;
1023         int r = 0;
1024         char *session_id = NULL;
1025
1026         pi = pkgmgr_installer_new();
1027         if(!pi) return -1;
1028         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
1029                 r = -1;
1030                 goto CLEANUP_RET;
1031         }
1032
1033         // Do something...
1034         pkgmgr_installer_send_app_uninstall_signal(pi,
1035          "tpk", "org.tizen.foo");
1036         // A sample signal
1037
1038         pkgmgr_installer_free(pi);
1039         return r;
1040 }
1041         @endcode
1042  */
1043 int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
1044                              const char *pkg_type,
1045                              const char *pkgid,
1046                              const char *val);
1047
1048 /**
1049         @brief          Send a signal which indicates application is being uninstalled
1050         @pre            None
1051         @post           None
1052         @see            None
1053         @param[in]      pi      pkgmgr_installer object
1054         @param[in]      uid     user id
1055         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
1056         @param[in]      pkgid   package id
1057         @param[in]      key                     Signal key
1058         @param[in]      val                     Signal value
1059         @return         Operation result
1060         @retval         0 on success
1061         @retval         -errno on failure
1062  */
1063 int pkgmgr_installer_send_app_uninstall_signal_for_uid(
1064                 pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
1065                 const char *pkgid, const char *val);
1066
1067 /**
1068  * @brief       This API sets the uid of given pkgmgr_installer.
1069  *
1070  *              This API is for package-manager client application.\n
1071  *
1072  * @param[in]pi                         pointer to pkgmgr_installer
1073  * @param[in]uid                                uid
1074  * @return      0 if success, error code(<0) if fail\n
1075 */
1076 int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid);
1077
1078 /**
1079  * @brief       This API sets the requst info of given pkgmgr_installer.
1080  *
1081  *              This API is for package-manager client application.\n
1082  *
1083  * @param[in]pi                         pointer to pkgmgr_installer
1084  * @param[in]   request_type                            request type
1085  * @return      0 if success, error code(<0) if fail\n
1086 */
1087 int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type);
1088
1089 /**
1090  * @brief       This API sets the session ID.
1091  *
1092  *              This API is for package-manager client application.\n
1093  *
1094  * @param[in]   pi                              pointer to pkgmgr_installer
1095  * @param[in]   session_id                              session ID to be set
1096  * @return      0 if success, error code(<0) if fail\n
1097 */
1098 int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id);
1099
1100 /**
1101  * @brief       This API creates the certinfo handle.
1102  *
1103  *              This API is for package-manager client application.\n
1104  *
1105  * @param[out]  handle                          pointer to cert info handle
1106  * @return      0 if success, error code(<0) if fail\n
1107 */
1108 int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle);
1109
1110 /**
1111  * @brief       This API sets cert value for corresponding cert type.
1112  *
1113  *              This API is for package-manager client application.\n
1114  *
1115  * @param[in]   handle                          pointer to cert info handle
1116  * @param[in]   cert_type                       enum value for certificate type
1117  * @param[in]   cert_value                      certificate value
1118  * @return      0 if success, error code(<0) if fail\n
1119 */
1120 int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value);
1121
1122 /**
1123  * @brief       This API saves cert info in DB.
1124  *
1125  *              This API is for package-manager client application.\n
1126  *
1127  * @param[in]   pkgid                           package ID
1128  * @param[in]   handle                          pointer to cert info handle
1129  * @return      0 if success, error code(<0) if fail\n
1130 */
1131 int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid);
1132
1133 /**
1134  * @brief       This API destroys cert info handle freeing all resources.
1135  *
1136  *              This API is for package-manager client application.\n
1137  *
1138  * @param[in]   handle                          pointer to cert info handle
1139  * @return      0 if success, error code(<0) if fail\n
1140 */
1141 int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle);
1142
1143 /**
1144  * @brief       This API deletes cert info from DB. To be used to cleanup info upon pkg uninstallation
1145  *
1146  *              This API is for package-manager client application.\n
1147  *
1148  * @param[in]   pkgid                           package ID
1149  * @return      0 if success, error code(<0) if fail\n
1150 */
1151 int pkgmgr_installer_delete_certinfo(const char *pkgid);
1152
1153 /**
1154  * @brief       This API sets privilege level for pkgmgr_installer_info
1155  *
1156  *              This API is for installer backend.\n
1157  *
1158  * @param[in]   level                           pkgmgr_privilege_level
1159  * @return      0 if success, error code(<0) if fail\n
1160 */
1161 int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level);
1162
1163 /**
1164  * @brief       This API converts error code to string
1165  *
1166  *              This API is for installer backend.\n
1167  *
1168  * @param[in]   error_code                      pkgmgr installer error code
1169  * @return      error string\n
1170 */
1171 const char *pkgmgr_installer_error_to_string(int error_code);
1172
1173 /**
1174  * @brief       This API adds pkg to be send at once
1175  *
1176  *              This API is for installer backend.\n
1177  *
1178  * @param[in]   pi                              pointer to pkgmgr_installer
1179  * @param[in]   pkgid                           package ID
1180  * @param[in]   pkg_type                        type of package
1181  * @return      0 if success, error code(<0) if fail\n
1182 */
1183 int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
1184                 const char *pkgid, const char *pkg_type);
1185
1186 /**
1187  * @brief       This API sends signals with packages already added
1188  *
1189  *              This API is for installer backend.\n
1190  *
1191  * @param[in]   pi                      pointer to pkgmgr_installer
1192  * @param[in]   key                     Signal key
1193  * @param[in]   val                     Signal value
1194  * @return      0 if success, error code(<0) if fail\n
1195 */
1196 int pkgmgr_installer_send_signals(pkgmgr_installer *pi,
1197                 const char *key, const char *val);
1198
1199 /**
1200  * @brief       This API sends signals to certain uid with packages already added
1201  *
1202  *              This API is for installer backend.\n
1203  *
1204  * @param[in]   pi                      pointer to pkgmgr_installer
1205  * @param[in]   uid                     user id
1206  * @param[in]   key                     Signal key
1207  * @param[in]   val                     Signal value
1208  * @return      0 if success, error code(<0) if fail\n
1209 */
1210 int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid,
1211                 const char *key, const char *val);
1212
1213 /**
1214  * @brief       This API sets is_upgrade_flag of given pkgmgr_installer.
1215  *
1216  *              This API is for package-manager client application.\n
1217  *
1218  * @param[in]pi                         pointer to pkgmgr_installer
1219  * @param[in]is_upgrade                 is_upgrade flag
1220  * @return      0 if success, error code(<0) if fail\n
1221 */
1222 int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade);
1223
1224 /**
1225         @brief          Send a signal of the resource copy event status
1226         @pre            None
1227         @post           None
1228         @see            None
1229         @param[in]      pi              pkgmgr_installer object
1230         @param[in]      pkgid           package id
1231         @param[in]      status          event status
1232         @param[in]      event_info      event info handle
1233         @return         Operation result
1234         @retval         0 on success, otherwise -1
1235         @code
1236 #include <pkgmgr_installer.h>
1237 void send_res_singal(uid_t uid, int request_type, const char *session_id,
1238                 const char *pkgid, const char *status,
1239                 pkgmgr_res_event_info *event_info)
1240 {
1241         pkgmgr_installer *pi;
1242         int r = 0;
1243
1244         pi = pkgmgr_installer_new();
1245         if(!pi) return -1;
1246
1247         if (pkgmgr_installer_set_uid(pi, uid))
1248                 goto CLEANUP_RET;
1249         if (pkgmgr_installer_set_request_type(pi, request_type))
1250                 goto CLEANUP_RET;
1251         if ((pkgmgr_installer_set_session_id(pi, session_id))
1252                 goto CLEANUP_RET;
1253         pkgmgr_installer_send_res_signal(pi, pkgid, status, event_info);
1254
1255 }
1256         @endcode
1257  */
1258 int pkgmgr_installer_send_res_signal(pkgmgr_installer *pi,
1259                 const char *pkgid, const char *status,
1260                 pkgmgr_res_event_info *event_info);
1261
1262 /**
1263         @brief          Send a signal of the resource copy event status
1264         @pre            None
1265         @post           None
1266         @see            None
1267         @param[in]      pi              pkgmgr_installer object
1268         @param[in]      uid             user id
1269         @param[in]      pkgid           package id
1270         @param[in]      status          event status
1271         @param[in]      event_info      event info handle
1272         @return         Operation result
1273         @retval         0 on success, otherwise -1
1274  */
1275 int pkgmgr_installer_send_res_signal_for_uid(pkgmgr_installer *pi,
1276                 uid_t uid, const char *pkgid, const char *status,
1277                 pkgmgr_res_event_info *event_info);
1278
1279 /**
1280         @brief          Send a signal of the upgrade event status
1281         @pre            None
1282         @post           None
1283         @see            None
1284         @param[in]      pi              pkgmgr_installer object
1285         @param[in]      progress        progress of upgrade
1286         @return         Operation result
1287         @retval         0 on success, otherwise -1
1288         @code
1289 #include <pkgmgr_installer.h>
1290 void send_upgrade_singal(int progress)
1291 {
1292         pkgmgr_installer *pi;
1293         int r = 0;
1294
1295         pi = pkgmgr_installer_new();
1296         if(!pi) return -1;
1297
1298         pkgmgr_installer_send_pkg_upgrade_signal(pi, progress);
1299 }
1300         @endcode
1301  */
1302 int pkgmgr_installer_send_pkg_upgrade_signal(pkgmgr_installer *pi,
1303                 unsigned int progress);
1304
1305 #ifdef __cplusplus
1306 }
1307 #endif
1308
1309 #endif                          /* __PKGMGR_INSTALLER_H__ */