installer/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 "pkgmgr_installer_type.h"
  30
  31 /**
  32  * @file pkgmgr_installer.h
  33  * @author Youmin Ha <youmin.ha@samsung.com>
  34  * @version 0.1
  35  * @brief    This file declares API of pkgmgr_installer
  36  */
  37
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif
  41
  42 /**
  43  * pkgmgr_installer is an opaque type for an object
  44  */
  45 typedef struct pkgmgr_installer pkgmgr_installer;
  46 typedef void *pkgmgr_instcertinfo_h;
  47
  48 /**
  49  * @brief       Create a pkgmgr_installer object.
  50  * @pre         None
  51  * @post        pkgmgr_installer object must be freed.
  52  * @see         pkgmgr_installer_free
  53  * @return      pkgmgr_installer object
  54  * @retval      NULL    on failure creating an object
  55  * @remark      None
  56 @code
  57 #include <pkgmgr_installer.h>
  58 pkgmgr_installer *pi = pkgmgr_installer_new();
  59 pkgmgr_installer_free(pi);
  60 @endcode
  61  */
  62 pkgmgr_installer *pkgmgr_installer_new(void);
  63
  64 /**
  65  * @brief       Create a pkgmgr_installer object in offline mode
  66  * @pre         None
  67  * @post        pkgmgr_installer object must be freed.
  68  * @see         pkgmgr_installer_free
  69  * @return      pkgmgr_installer object
  70  * @retval      NULL    on failure creating an object
  71  * @remark      None
  72 @code
  73 #include <pkgmgr_installer.h>
  74 pkgmgr_installer *pi = pkgmgr_installer_offline_new();
  75 pkgmgr_installer_free(pi);
  76 @endcode
  77  */
  78 pkgmgr_installer *pkgmgr_installer_offline_new(void);
  79
  80 /**
  81         @brief          Free a pkgmgr_installer object
  82         @pre            pi must be a valid object.
  83         @post           None
  84         @see            pkgmgr_installer_new
  85         @param[in]      pi      A pkgmgr_installer object
  86         @return         Operation result
  87         @retval         0       on success
  88         @retval         -errno  on error
  89         @remark         None
  90         @code
  91 #include <pkgmgr_installer.h>
  92 pkgmgr_installer *pi = pkgmgr_installer_new();
  93 pkgmgr_installer_free(pi);
  94         @endcode
  95  */
  96 int pkgmgr_installer_free(pkgmgr_installer *pi);
  97
  98 /**
  99         @brief          Receive a request from argv
 100         @pre            None
 101         @post           pkgmgr_installer_get_*(), pkgmgr_installer_is_quiet() can be called.
 102         @see            pkgmgr_installer_get_request_type, pkgmgr_installer_get_request_info, pkgmgr_installer_get_session_id, pkgmgr_installer_is_quiet
 103         @param[in]      pi      a pkgmgr_installer object
 104         @param[in]      argc    argc from system
 105         @param[in]      argv    argv from system
 106         @return         Operation result
 107         @retval         0 on success
 108         @retval         -errno on failure
 109         @remark         None
 110         @code
 111 #include <pkgmgr_installer.h>
 112 int main(int argc, char **argv)
 113 {
 114         pkgmgr_installer *pi;
 115         int r;
 116
 117         pi = pkgmgr_installer_new();
 118         int r = pkgmgr_installer_receive_request(pi, argc, argv);
 119         pkgmgr_installer_free(pi);
 120
 121         return 0;
 122 }
 123         @endcode
 124  */
 125 int pkgmgr_installer_receive_request(pkgmgr_installer *pi,
 126                                      const int argc, char **argv);
 127
 128 /**
 129         @brief          Get request type
 130         @pre            pkgmgr_installer_receive_request() must be called.
 131         @post           None
 132         @see            pkgmgr_installer_receive_request
 133         @param[in]      pi      pkgmgr_installer object
 134         @return         Request type (One of PKGMGR_REQ_* enum values)
 135         @remark         None
 136         @code
 137 int main(int argc, char **argv)
 138 {
 139         pkgmgr_installer *pi;
 140         int r = 0;
 141
 142         pi = pkgmgr_installer_new();
 143         if(!pi) return -1;
 144         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 145                 r = -1;
 146                 goto CLEANUP_RET;
 147         }
 148
 149         switch(pkgmgr_installer_get_request_type(pi)) {
 150                 case PKGMGR_REQ_PERM:
 151                         // Do error processing
 152                         break;
 153                 case PKGMGR_REQ_INVALID:
 154                         // Do error processing
 155                         r = -1;
 156                         break;
 157                 case PKGMGR_REQ_INSTALL:
 158                         // Do install processing
 159                         break;
 160                 case PKGMGR_REQ_UNINSTALL:
 161                         // Do uninstall processing
 162                         break;
 163                 case PKGMGR_REQ_RECOVER:
 164                         // Do recovere processing
 165                         break;
 166                 case PKGMGR_REQ_REINSTALL:
 167                         // Do reinstall processing
 168                         break;
 169                 default:
 170                         goto CLEANUP_END;
 171         }
 172 CLEANUP_END:
 173         pkgmgr_installer_free(pi);
 174
 175         return r;
 176 }
 177         @endcode
 178  */
 179 int pkgmgr_installer_get_request_type(pkgmgr_installer *pi);
 180
 181 /**
 182         @brief          Get uid
 183         @pre            pkgmgr_installer_receive_request() must be called.
 184         @post           None
 185         @see            pkgmgr_installer_receive_request
 186         @param[in]      pi      pkgmgr_installer object
 187         @return         Uid info.
 188         @retval         NULL    on function failure
 189         @remark         Returned uid must not be modified.
 190         @code
 191 #include <pkgmgr_installer.h>
 192 int main(int argc, char **argv)
 193 {
 194         pkgmgr_installer *pi;
 195         int r = 0;
 196         uid_t uid;
 197
 198         pi = pkgmgr_installer_new();
 199         if(!pi) return -1;
 200         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 201                 r = -1;
 202                 goto CLEANUP_RET;
 203         }
 204         uid = pkgmgr_installer_get_uid(pi);
 205
 206         // Do something...
 207
 208         pkgmgr_installer_free(pi);
 209         return r;
 210 }
 211         @endcode
 212  */
 213 uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi);
 214
 215 /**
 216         @brief          Get request info
 217         @pre            pkgmgr_installer_receive_request() must be called.
 218         @post           None
 219         @see            pkgmgr_installer_receive_request
 220         @param[in]      pi      pkgmgr_installer object
 221         @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.
 222         @retval         NULL    on function failure
 223         @remark         Returned string must not be modified.
 224         @code
 225 #include <pkgmgr_installer.h>
 226 int main(int argc, char **argv)
 227 {
 228         pkgmgr_installer *pi;
 229         int r = 0;
 230         char *req_info = NULL;
 231
 232         pi = pkgmgr_installer_new();
 233         if(!pi) return -1;
 234         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 235                 r = -1;
 236                 goto CLEANUP_RET;
 237         }
 238         req_info = (char *) pkgmgr_installer_get_request_info(pi);
 239
 240         // Do something...
 241
 242         pkgmgr_installer_free(pi);
 243         return r;
 244 }
 245         @endcode
 246  */
 247 const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi);
 248
 249 /**
 250         @brief          Get TEP path
 251         @pre            pkgmgr_installer_receive_request() must be called.
 252         @post           None
 253         @see            pkgmgr_installer_receive_request
 254         @param[in]      pi      pkgmgr_installer object
 255         @return         TEP path if exists
 256         @retval         NULL    on function failure
 257         @remark         Returned string must not be modified.
 258         @code
 259 #include <pkgmgr_installer.h>
 260 int main(int argc, char **argv)
 261 {
 262         pkgmgr_installer *pi;
 263         int r = 0;
 264         char *tep_path = NULL;
 265
 266         pi = pkgmgr_installer_new();
 267         if(!pi) return -1;
 268         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 269                 r = -1;
 270                 goto CLEANUP_RET;
 271         }
 272         tep_path = (char *) pkgmgr_installer_get_tep_path(pi);
 273
 274         // Do something...
 275
 276         pkgmgr_installer_free(pi);
 277         return r;
 278 }
 279 @endcode
 280  */
 281 const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi);
 282
 283 /**
 284         @brief          Get TEP move type
 285         @pre            pkgmgr_installer_receive_request() must be called.
 286         @post           None
 287         @see            pkgmgr_installer_receive_request
 288         @param[in]      pi      pkgmgr_installer object
 289         @return         integer value indicates tep move type(0: copy TEP file / 1: move TEP file)
 290         @retval         0       on function failure
 291         @remark         Returned string must not be modified.
 292         @code
 293 #include <pkgmgr_installer.h>
 294 int main(int argc, char **argv)
 295 {
 296         pkgmgr_installer *pi;
 297         int r = 0;
 298         int tep_move_type = -1;
 299
 300         pi = pkgmgr_installer_new();
 301         if(!pi) return -1;
 302         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 303                 r = -1;
 304                 goto CLEANUP_RET;
 305         }
 306         tep_move_type = pkgmgr_installer_get_tep_move_type(pi);
 307
 308         // Do something...
 309
 310         pkgmgr_installer_free(pi);
 311         return r;
 312 }
 313 @endcode
 314  */
 315 int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi);
 316
 317 /**
 318         @brief          Get session ID for a certain session
 319         @pre            pkgmgr_installer_receive_request() must be called.
 320         @post           None
 321         @see            pkgmgr_installer_receive_request
 322         @param[in]      pi      pkgmgr_installer object
 323         @return         A session ID
 324         @retval         NULL    on function failure
 325         @remark         Returned string must not be modified.
 326         @code
 327 #include <pkgmgr_installer.h>
 328 int main(int argc, char **argv)
 329 {
 330         pkgmgr_installer *pi;
 331         int r = 0;
 332         char *session_id = NULL;
 333
 334         pi = pkgmgr_installer_new();
 335         if(!pi) return -1;
 336         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 337                 r = -1;
 338                 goto CLEANUP_RET;
 339         }
 340         session_id = (char *) pkgmgr_installer_get_session_id(pi);
 341
 342         // Do something...
 343
 344         pkgmgr_installer_free(pi);
 345         return r;
 346 }
 347 @endcode
 348  */
 349 const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi);
 350
 351 /**
 352         @brief          Get a license path
 353         @pre            pkgmgr_installer_receive_request() must be called.
 354         @post           None
 355         @see            pkgmgr_installer_receive_request
 356         @param[in]      pi      pkgmgr_installer object
 357         @return         license path
 358         @retval         NULL    on function failure
 359         @remark         Returned string must not be modified.
 360         @code
 361 #include <pkgmgr_installer.h>
 362 int main(int argc, char **argv)
 363 {
 364         pkgmgr_installer *pi;
 365         int r = 0;
 366         char *license_path = NULL;
 367
 368         pi = pkgmgr_installer_new();
 369         if(!pi) return -1;
 370         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 371                 r = -1;
 372                 goto CLEANUP_RET;
 373         }
 374         session_id = (char *) pkgmgr_installer_get_license_path(pi);
 375
 376         // Do something...
 377
 378         pkgmgr_installer_free(pi);
 379         return r;
 380 }
 381 @endcode
 382  */
 383 const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi);
 384
 385 /**
 386         @brief          Get a optional data
 387         @pre            pkgmgr_installer_receive_request() must be called.
 388         @post           None
 389         @see            pkgmgr_installer_receive_request
 390         @param[in]      pi      pkgmgr_installer object
 391         @return         optional data
 392         @retval         NULL    on function failure
 393         @remark         Returned string must not be modified.
 394         @code
 395 #include <pkgmgr_installer.h>
 396 int main(int argc, char **argv)
 397 {
 398         pkgmgr_installer *pi;
 399         int r = 0;
 400         char *optional_data = NULL;
 401
 402         pi = pkgmgr_installer_new();
 403         if(!pi) return -1;
 404         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 405                 r = -1;
 406                 goto CLEANUP_RET;
 407         }
 408         optional_data = (char *) pkgmgr_installer_get_optional_data(pi);
 409
 410         // Do something...
 411
 412         pkgmgr_installer_free(pi);
 413         return r;
 414 }
 415 @endcode
 416  */
 417 const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi);
 418
 419 /**
 420         @brief          Get if a request is with quite mode or not
 421         @pre            pkgmgr_installer_receive_request() must be called.
 422         @post           None
 423         @see            pkgmgr_installer_receive_request
 424         @param[in]      pi      pkgmgr_installer object
 425         @return         Operation result
 426         @retval         0 if a request is not quiet mode
 427         @retval         1 if a request is quiet mode
 428         @remark         None
 429         @code
 430 #include <pkgmgr_installer.h>
 431 int main(int argc, char **argv)
 432 {
 433         pkgmgr_installer *pi;
 434         int r = 0;
 435
 436         pi = pkgmgr_installer_new();
 437         if(!pi) return -1;
 438         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 439                 r = -1;
 440                 goto CLEANUP_RET;
 441         }
 442         if(pkgmgr_installer_is_quiet(pi)) {
 443                 // Do quiet mode work...
 444         } else {
 445                 // Do normal mode work...
 446         }
 447
 448         pkgmgr_installer_free(pi);
 449         return r;
 450 }
 451         @endcode
 452  */
 453 int pkgmgr_installer_is_quiet(pkgmgr_installer *pi);
 454
 455 /**
 456         @brief          Get move type
 457         @pre            pkgmgr_installer_receive_request() must be called.
 458         @post           None
 459         @see            pkgmgr_installer_receive_request
 460         @param[in]      pi      pkgmgr_installer object
 461         @return         Operation result
 462         @retval         enum value of move type
 463         @remark         None
 464         @code
 465 #include <pkgmgr_installer.h>
 466 int main(int argc, char **argv)
 467 {
 468         pkgmgr_installer *pi;
 469         int r = 0;
 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         move_type = pkgmgr_installer_get_move_type(pi);
 478
 479         //Do Something
 480
 481         pkgmgr_installer_free(pi);
 482         return r;
 483 }
 484         @endcode
 485  */
 486 int pkgmgr_installer_get_move_type(pkgmgr_installer *pi);
 487
 488 /**
 489         @brief          Get caller package id
 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         enum value of move type
 496         @remark         None
 497         @code
 498 #include <pkgmgr_installer.h>
 499 int main(int argc, char **argv)
 500 {
 501         pkgmgr_installer *pi;
 502         int r = 0;
 503         char *pkgid = NULL;
 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         pkgid = (char *) pkgmgr_installer_get_caller_pkgid(pi);
 512
 513         // Do something...
 514
 515         pkgmgr_installer_free(pi);
 516         return r;
 517 }
 518         @endcode
 519  */
 520 const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi);
 521
 522 /**
 523         @brief          Get if the request is for preload app or not
 524         @pre            pkgmgr_installer_receive_request() must be called.
 525         @post           None
 526         @see            pkgmgr_installer_receive_request
 527         @param[in]      pi      pkgmgr_installer object
 528         @return         Operation result
 529         @retval         0 if a request is not for preload
 530         @retval         1 if a request is for preload
 531         @remark         None
 532         @code
 533 #include <pkgmgr_installer.h>
 534 int main(int argc, char **argv)
 535 {
 536         pkgmgr_installer *pi;
 537         int r = 0;
 538         int is_preload = 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         is_preload = pkgmgr_installer_get_is_preload(pi);
 547
 548         // Do something...
 549
 550         pkgmgr_installer_free(pi);
 551         return r;
 552 }
 553         @endcode
 554  */
 555 int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi);
 556 int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi);
 557
 558 /**
 559         @brief          Get if the request is for force-removal
 560         @pre            pkgmgr_installer_receive_request() must be called.
 561         @post           None
 562         @see            pkgmgr_installer_receive_request
 563         @param[in]      pi      pkgmgr_installer object
 564         @return         Operation result
 565         @retval         0 if a request is not for force-removal
 566         @retval         1 if a request is for force-removal
 567         @remark         None
 568         @code
 569 #include <pkgmgr_installer.h>
 570 int main(int argc, char **argv)
 571 {
 572         pkgmgr_installer *pi;
 573         int r = 0;
 574         int force_remove = 0;
 575
 576         pi = pkgmgr_installer_new();
 577         if(!pi) return -1;
 578         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 579                 r = -1;
 580                 goto CLEANUP_RET;
 581         }
 582         force_remove = pkgmgr_installer_get_force_removal(pi);
 583
 584         // Do something...
 585
 586         pkgmgr_installer_free(pi);
 587         return r;
 588 }
 589         @endcode
 590  */
 591 int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi);
 592 int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi);
 593
 594 /**
 595         @brief          Get if the request is for keep-rwdata
 596         @pre            pkgmgr_installer_receive_request() must be called.
 597         @post           None
 598         @see            pkgmgr_installer_receive_request
 599         @param[in]      pi      pkgmgr_installer object
 600         @return         Operation result
 601         @retval         0 if a request is not for keep-rwdata
 602         @retval         1 if a request is for keep-rwdata
 603         @remark         Keep RW-data of updated RO pkg.
 604         @code
 605 #include <pkgmgr_installer.h>
 606 int main(int argc, char **argv)
 607 {
 608         pkgmgr_installer *pi;
 609         int r = 0;
 610         int force_remove = 0;
 611
 612         pi = pkgmgr_installer_new();
 613         if(!pi) return -1;
 614         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 615                 r = -1;
 616                 goto CLEANUP_RET;
 617         }
 618         force_remove = pkgmgr_installer_get_keep_rwdata(pi);
 619
 620         // Do something...
 621
 622         pkgmgr_installer_free(pi);
 623         return r;
 624 }
 625         @endcode
 626  */
 627 int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi);
 628
 629 /**
 630         @brief          Get if the request is for partial-rw
 631         @pre            pkgmgr_installer_receive_request() must be called.
 632         @post           None
 633         @see            pkgmgr_installer_receive_request
 634         @param[in]      pi      pkgmgr_installer object
 635         @return         Operation result
 636         @retval         0 if a request is not for partial-rw
 637         @retval         1 if a request is for partial-rw
 638         @remark         For install/update/uninstall of stubs of RO pkg
 639                         on RW partitions
 640         @code
 641 #include <pkgmgr_installer.h>
 642 int main(int argc, char **argv)
 643 {
 644         pkgmgr_installer *pi;
 645         int r = 0;
 646         int force_remove = 0;
 647
 648         pi = pkgmgr_installer_new();
 649         if(!pi) return -1;
 650         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 651                 r = -1;
 652                 goto CLEANUP_RET;
 653         }
 654         force_remove = pkgmgr_installer_get_partial_rw(pi);
 655
 656         // Do something...
 657
 658         pkgmgr_installer_free(pi);
 659         return r;
 660 }
 661         @endcode
 662  */
 663 int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi);
 664
 665 /**
 666         @brief          Get debug mode value
 667         @pre            pkgmgr_installer_receive_request() must be called.
 668         @post           None
 669         @see            pkgmgr_installer_receive_request
 670         @param[in]      pi      pkgmgr_installer object
 671         @return         Operation result
 672         @retval         0 if a request is not debug mode
 673         @retval         1 if a request is debug mode
 674         @remark         None
 675         @code
 676 #include <pkgmgr_installer.h>
 677 int main(int argc, char **argv)
 678 {
 679         pkgmgr_installer *pi;
 680         int r = 0;
 681         int force_remove = 0;
 682
 683         pi = pkgmgr_installer_new();
 684         if(!pi) return -1;
 685         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 686                 r = -1;
 687                 goto CLEANUP_RET;
 688         }
 689         force_remove = pkgmgr_installer_get_debug_mode(pi);
 690
 691         // Do something...
 692
 693         pkgmgr_installer_free(pi);
 694         return r;
 695 }
 696         @endcode
 697 */
 698 int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi);
 699
 700 /**
 701         @brief          Send a app status signal
 702         @pre            None
 703         @post           None
 704         @see            None
 705         @param[in]      pi      pkgmgr_installer object
 706         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 707         @param[in]      pkgid   package id
 708         @param[in]      appid   application id
 709         @param[in]      key                     Signal key
 710         @param[in]      val                     Signal value
 711         @return         Operation result
 712         @retval         0 on success
 713         @retval         -errno on failure
 714         @code
 715 #include <pkgmgr_installer.h>
 716 void send_app_singal(uid_t uid, int request_type, int req_id,
 717                 const char *pkg_type, const char *pkgid, const char *appid,
 718                 const char *key, const char *val)
 719 {
 720         pkgmgr_installer *pi;
 721         int r = 0;
 722
 723         pi = pkgmgr_installer_new();
 724         if(!pi) return -1;
 725
 726         if (pkgmgr_installer_set_uid(pi, uid))
 727                 goto CLEANUP_RET;
 728         if (pkgmgr_installer_set_request_type(pi, request_type))
 729                 goto CLEANUP_RET;
 730         if ((pkgmgr_installer_set_session_id(pi, req_id))
 731                 goto CLEANUP_RET;
 732         pkgmgr_installer_send_app_signal(pi, pkg_type, pkgid, appid, key, val);
 733
 734 }
 735         @endcode
 736  */
 737 int pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
 738                              const char *pkg_type,
 739                              const char *pkgid,
 740                              const char *appid,
 741                              const char *key, const char *val);
 742
 743 /**
 744         @brief          Send a process status signal
 745         @pre            None
 746         @post           None
 747         @see            None
 748         @param[in]      pi      pkgmgr_installer object
 749         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 750         @param[in]      pkgid   package id
 751         @param[in]      key                     Signal key
 752         @param[in]      val                     Signal value
 753         @return         Operation result
 754         @retval         0 on success
 755         @retval         -errno on failure
 756         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 757         @code
 758 #include <pkgmgr_installer.h>
 759 int main(int argc, char **argv)
 760 {
 761         pkgmgr_installer *pi;
 762         int r = 0;
 763         char *session_id = NULL;
 764
 765         pi = pkgmgr_installer_new();
 766         if(!pi) return -1;
 767         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 768                 r = -1;
 769                 goto CLEANUP_RET;
 770         }
 771
 772         // Do something...
 773         pkgmgr_installer_send_signal(pi,
 774          "deb", "org.tizen.foo", "install_percent", "100");
 775         // A sample signal
 776
 777         pkgmgr_installer_free(pi);
 778         return r;
 779 }
 780         @endcode
 781  */
 782 int pkgmgr_installer_send_signal(pkgmgr_installer *pi,
 783                                  const char *pkg_type,
 784                                  const char *pkgid, const char *key,
 785                                  const char *val);
 786
 787 /**
 788         @brief          Send a app status signal
 789         @pre            None
 790         @post           None
 791         @see            None
 792         @param[in]      pi      pkgmgr_installer object
 793         @param[in]      uid     user id
 794         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 795         @param[in]      pkgid   package id
 796         @param[in]      appid   application id
 797         @param[in]      key                     Signal key
 798         @param[in]      val                     Signal value
 799         @return         Operation result
 800         @retval         0 on success, otherwise -1
 801         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 802  */
 803 int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
 804                                  uid_t uid,
 805                                  const char *pkg_type,
 806                                  const char *pkgid,
 807                                  const char *appid,
 808                                  const char *key, const char *val);
 809
 810 /**
 811         @brief          Send a process status signal
 812         @pre            None
 813         @post           None
 814         @see            None
 815         @param[in]      pi      pkgmgr_installer object
 816         @param[in]      uid     user id
 817         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 818         @param[in]      pkgid   package id
 819         @param[in]      key                     Signal key
 820         @param[in]      val                     Signal value
 821         @return         Operation result
 822         @retval         0 on success, otherwise -1
 823         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 824  */
 825 int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
 826                                  uid_t uid,
 827                                  const char *pkg_type,
 828                                  const char *pkgid, const char *key,
 829                                  const char *val);
 830
 831 /**
 832         @brief          Send a signal which indicates application is being uninstalled
 833         @pre            None
 834         @post           None
 835         @see            None
 836         @param[in]      pi      pkgmgr_installer object
 837         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 838         @param[in]      pkgid   package id
 839         @param[in]      key                     Signal key
 840         @param[in]      val                     Signal value
 841         @return         Operation result
 842         @retval         0 on success
 843         @retval         -errno on failure
 844         @code
 845 #include <pkgmgr_installer.h>
 846 int main(int argc, char **argv)
 847 {
 848         pkgmgr_installer *pi;
 849         int r = 0;
 850         char *session_id = NULL;
 851
 852         pi = pkgmgr_installer_new();
 853         if(!pi) return -1;
 854         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 855                 r = -1;
 856                 goto CLEANUP_RET;
 857         }
 858
 859         // Do something...
 860         pkgmgr_installer_send_app_uninstall_signal(pi,
 861          "tpk", "org.tizen.foo");
 862         // A sample signal
 863
 864         pkgmgr_installer_free(pi);
 865         return r;
 866 }
 867         @endcode
 868  */
 869 int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
 870                              const char *pkg_type,
 871                              const char *pkgid,
 872                              const char *val);
 873
 874 /**
 875         @brief          Send a signal which indicates application is being uninstalled
 876         @pre            None
 877         @post           None
 878         @see            None
 879         @param[in]      pi      pkgmgr_installer object
 880         @param[in]      uid     user id
 881         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 882         @param[in]      pkgid   package 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  */
 889 int pkgmgr_installer_send_app_uninstall_signal_for_uid(
 890                 pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
 891                 const char *pkgid, const char *val);
 892
 893 /**
 894  * @brief       This API sets the uid of given pkgmgr_installer.
 895  *
 896  *              This API is for package-manager client application.\n
 897  *
 898  * @param[in]pi                         pointer to pkgmgr_installer
 899  * @param[in]uid                                uid
 900  * @return      0 if success, error code(<0) if fail\n
 901 */
 902 int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid);
 903
 904 /**
 905  * @brief       This API sets the requst info of given pkgmgr_installer.
 906  *
 907  *              This API is for package-manager client application.\n
 908  *
 909  * @param[in]pi                         pointer to pkgmgr_installer
 910  * @param[in]   request_type                            request type
 911  * @return      0 if success, error code(<0) if fail\n
 912 */
 913 int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type);
 914
 915 /**
 916  * @brief       This API sets the session ID.
 917  *
 918  *              This API is for package-manager client application.\n
 919  *
 920  * @param[in]   pi                              pointer to pkgmgr_installer
 921  * @param[in]   session_id                              session ID to be set
 922  * @return      0 if success, error code(<0) if fail\n
 923 */
 924 int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id);
 925
 926 /**
 927  * @brief       This API creates the certinfo handle.
 928  *
 929  *              This API is for package-manager client application.\n
 930  *
 931  * @param[out]  handle                          pointer to cert info handle
 932  * @return      0 if success, error code(<0) if fail\n
 933 */
 934 int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle);
 935
 936 /**
 937  * @brief       This API sets cert value for corresponding cert type.
 938  *
 939  *              This API is for package-manager client application.\n
 940  *
 941  * @param[in]   handle                          pointer to cert info handle
 942  * @param[in]   cert_type                       enum value for certificate type
 943  * @param[in]   cert_value                      certificate value
 944  * @return      0 if success, error code(<0) if fail\n
 945 */
 946 int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value);
 947
 948 /**
 949  * @brief       This API saves cert info in DB.
 950  *
 951  *              This API is for package-manager client application.\n
 952  *
 953  * @param[in]   pkgid                           package ID
 954  * @param[in]   handle                          pointer to cert info handle
 955  * @return      0 if success, error code(<0) if fail\n
 956 */
 957 int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid);
 958
 959 /**
 960  * @brief       This API destroys cert info handle freeing all resources.
 961  *
 962  *              This API is for package-manager client application.\n
 963  *
 964  * @param[in]   handle                          pointer to cert info handle
 965  * @return      0 if success, error code(<0) if fail\n
 966 */
 967 int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle);
 968
 969 /**
 970  * @brief       This API deletes cert info from DB. To be used to cleanup info upon pkg uninstallation
 971  *
 972  *              This API is for package-manager client application.\n
 973  *
 974  * @param[in]   pkgid                           package ID
 975  * @return      0 if success, error code(<0) if fail\n
 976 */
 977 int pkgmgr_installer_delete_certinfo(const char *pkgid);
 978
 979 /**
 980  * @brief       This API sets privilege level for pkgmgr_installer_info
 981  *
 982  *              This API is for installer backend.\n
 983  *
 984  * @param[in]   level                           pkgmgr_privilege_level
 985  * @return      0 if success, error code(<0) if fail\n
 986 */
 987 int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level);
 988
 989 #ifdef __cplusplus
 990 }
 991 #endif
 992
 993 #endif                          /* __PKGMGR_INSTALLER_H__ */
 994