src/app_manager.c

   1 /*
   2  * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23
  24 #include <aul.h>
  25 #include <aul_window.h>
  26 #include <dlog.h>
  27 #include <cynara-client.h>
  28 #include <package-manager.h>
  29
  30 #include "app_manager.h"
  31 #include "app_manager_internal.h"
  32
  33 #ifdef LOG_TAG
  34 #undef LOG_TAG
  35 #endif
  36
  37 #define LOG_TAG "CAPI_APPFW_APP_MANAGER"
  38
  39 #define SMACK_LABEL_LEN 255
  40
  41 static const char *app_manager_error_to_string(app_manager_error_e error)
  42 {
  43         switch (error) {
  44         case APP_MANAGER_ERROR_NONE:
  45                 return "Successful";
  46         case APP_MANAGER_ERROR_INVALID_PARAMETER:
  47                 return "Invalid parameter";
  48         case APP_MANAGER_ERROR_OUT_OF_MEMORY:
  49                 return "Out of memory";
  50         case APP_MANAGER_ERROR_IO_ERROR:
  51                 return "IO error";
  52         case APP_MANAGER_ERROR_NO_SUCH_APP:
  53                 return "No such application";
  54         case APP_MANAGER_ERROR_DB_FAILED:
  55                 return "DB error";
  56         case APP_MANAGER_ERROR_INVALID_PACKAGE:
  57                 return "Invalid package";
  58         case APP_MANAGER_ERROR_NOT_SUPPORTED:
  59                 return "Not supported";
  60         case APP_MANAGER_ERROR_PERMISSION_DENIED:
  61                 return "Permission denied";
  62         default:
  63                 return "Unknown";
  64         }
  65 }
  66
  67 int app_manager_error(app_manager_error_e error, const char *function, const char *description)
  68 {
  69         if (description)
  70                 LOGE("[%s] %s(0x%08x) : %s", function, app_manager_error_to_string(error), error, description);
  71         else
  72                 LOGE("[%s] %s(0x%08x)", function, app_manager_error_to_string(error), error);
  73
  74         return error;
  75 }
  76
  77 API int app_manager_set_app_context_event_cb(app_manager_app_context_event_cb callback, void *user_data)
  78 {
  79         int retval;
  80
  81         retval = app_context_set_event_cb(callback, user_data);
  82         if (retval != APP_MANAGER_ERROR_NONE)
  83                 return app_manager_error(retval, __FUNCTION__, NULL);
  84
  85         return APP_MANAGER_ERROR_NONE;
  86 }
  87
  88 API void app_manager_unset_app_context_event_cb(void)
  89 {
  90         app_context_unset_event_cb();
  91 }
  92
  93 API int app_manager_foreach_app_context(app_manager_app_context_cb callback, void *user_data)
  94 {
  95         int retval;
  96
  97         retval = app_context_foreach_app_context(callback, user_data);
  98         if (retval != APP_MANAGER_ERROR_NONE)
  99                 return app_manager_error(retval, __FUNCTION__, NULL);
 100
 101         return APP_MANAGER_ERROR_NONE;
 102 }
 103
 104 API int app_manager_foreach_running_app_context(app_manager_app_context_cb callback, void *user_data)
 105 {
 106         int retval;
 107
 108         retval = app_context_foreach_running_app_context(callback, user_data);
 109         if (retval != APP_MANAGER_ERROR_NONE)
 110                 return app_manager_error(retval, __FUNCTION__, NULL);
 111
 112         return APP_MANAGER_ERROR_NONE;
 113 }
 114
 115 API int app_manager_get_app_context(const char *app_id, app_context_h *app_context)
 116 {
 117         int retval;
 118
 119         retval = app_context_get_app_context(app_id, app_context);
 120         if (retval != APP_MANAGER_ERROR_NONE)
 121                 return app_manager_error(retval, __FUNCTION__, NULL);
 122
 123         return APP_MANAGER_ERROR_NONE;
 124 }
 125
 126 API int app_manager_resume_app(app_context_h app_context)
 127 {
 128         char *app_id = NULL;
 129         char *instance_id = NULL;
 130         int retval = APP_MANAGER_ERROR_NONE;
 131
 132         if (app_context == NULL)
 133                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 134
 135         if (app_context_get_app_id(app_context, &app_id) != APP_MANAGER_ERROR_NONE)
 136                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "failed to get the application ID");
 137
 138         app_context_get_instance_id(app_context, &instance_id);
 139         if (instance_id) {
 140                 retval = aul_resume_app_by_instance_id(app_id, instance_id);
 141                 free(instance_id);
 142         } else {
 143                 if (aul_app_is_running(app_id) == 0) {
 144                         if (app_id) {
 145                                 free(app_id);
 146                                 app_id = NULL;
 147                         }
 148                         return app_manager_error(APP_MANAGER_ERROR_APP_NO_RUNNING, __FUNCTION__, NULL);
 149                 }
 150
 151                 retval = aul_resume_app(app_id);
 152         }
 153
 154         if (app_id)
 155                 free(app_id);
 156
 157         if (retval == AUL_R_EINVAL)
 158                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 159         else if (retval == AUL_R_EILLACC)
 160                 return app_manager_error(APP_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 161         else if (retval < 0)
 162                 return app_manager_error(APP_MANAGER_ERROR_REQUEST_FAILED, __FUNCTION__, NULL);
 163
 164         return APP_MANAGER_ERROR_NONE;
 165 }
 166
 167 API int app_manager_foreach_app_info(app_manager_app_info_cb callback, void *user_data)
 168 {
 169         int retval;
 170
 171         retval = app_info_foreach_app_info(callback, user_data);
 172         if (retval != APP_MANAGER_ERROR_NONE)
 173                 return app_manager_error(retval, __FUNCTION__, NULL);
 174
 175         return APP_MANAGER_ERROR_NONE;
 176 }
 177
 178 API int app_manager_get_app_info(const char *app_id, app_info_h *app_info)
 179 {
 180         int retval;
 181
 182         retval = app_info_create(app_id, app_info);
 183         if (retval != APP_MANAGER_ERROR_NONE)
 184                 return app_manager_error(retval, __FUNCTION__, NULL);
 185
 186         return APP_MANAGER_ERROR_NONE;
 187 }
 188
 189 API int app_manager_get_app_id(pid_t pid, char **app_id)
 190 {
 191         char buffer[256] = {0, };
 192         char *app_id_dup = NULL;
 193
 194         if (app_id == NULL)
 195                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 196
 197         if (aul_app_get_appid_bypid(pid, buffer, sizeof(buffer)) != AUL_R_OK)
 198                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "Invalid process ID");
 199
 200         app_id_dup = strdup(buffer);
 201         if (app_id_dup == NULL)
 202                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL); /* LCOV_EXCL_LINE */
 203
 204         *app_id = app_id_dup;
 205
 206         return APP_MANAGER_ERROR_NONE;
 207 }
 208
 209 API int app_manager_terminate_app(app_context_h app_context)
 210 {
 211         int retval;
 212         pid_t pid = 0;
 213
 214         if (app_context == NULL)
 215                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 216
 217         if (app_context_get_pid(app_context, &pid) != APP_MANAGER_ERROR_NONE)
 218                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "failed to get the process ID");
 219
 220         retval = aul_terminate_pid(pid);
 221         if (retval == AUL_R_EINVAL) {
 222                 LOGE("[%s] APP_MANAGER_ERROR_INVALID_PARAMETER(0x%08x) : Invalid param", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER);
 223                 return APP_MANAGER_ERROR_INVALID_PARAMETER;
 224         } else if (retval == AUL_R_EILLACC) {
 225                 LOGE("[%s] APP_MANAGER_ERROR_PERMISSION_DENIED(0x%08x) : Permission denied", __FUNCTION__, APP_MANAGER_ERROR_PERMISSION_DENIED);
 226                 return APP_MANAGER_ERROR_PERMISSION_DENIED;
 227         } else if (retval < 0) {
 228                 return APP_MANAGER_ERROR_REQUEST_FAILED;
 229         }
 230
 231         return APP_MANAGER_ERROR_NONE;
 232 }
 233
 234 API int app_manager_request_terminate_bg_app(app_context_h app_context)
 235 {
 236         int retval = APP_MANAGER_ERROR_NONE;
 237         pid_t pid = 0;
 238
 239         if (app_context == NULL)
 240                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 241
 242         if (app_context_get_pid(app_context, &pid) != APP_MANAGER_ERROR_NONE)
 243                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, "failed to get the process ID");
 244
 245         retval = aul_terminate_bgapp_pid(pid);
 246         if (retval == AUL_R_EINVAL) {
 247                 LOGE("[%s] APP_MANAGER_ERROR_INVALID_PARAMETER(0x%08x) : Invalid param", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER);
 248                 return APP_MANAGER_ERROR_INVALID_PARAMETER;
 249         } else if (retval == AUL_R_EILLACC) {
 250                 LOGE("[%s] APP_MANAGER_ERROR_PERMISSION_DENIED(0x%08x) : Permission denied", __FUNCTION__, APP_MANAGER_ERROR_PERMISSION_DENIED);
 251                 return APP_MANAGER_ERROR_PERMISSION_DENIED;
 252         } else if (retval < 0) {
 253                 return APP_MANAGER_ERROR_REQUEST_FAILED;
 254         }
 255
 256         return APP_MANAGER_ERROR_NONE;
 257 }
 258
 259 API int app_manager_is_running(const char *app_id, bool *running)
 260 {
 261         if (app_id == NULL) {
 262                 LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid package", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER);
 263                 return APP_MANAGER_ERROR_INVALID_PARAMETER;
 264         }
 265
 266         if (running == NULL) {
 267                 LOGE("[%s] INVALID_PARAMETER(0x%08x) : invalid output param", __FUNCTION__, APP_MANAGER_ERROR_INVALID_PARAMETER);
 268                 return APP_MANAGER_ERROR_INVALID_PARAMETER;
 269         }
 270
 271         *running = aul_app_is_running(app_id);
 272
 273         return APP_MANAGER_ERROR_NONE;
 274 }
 275
 276 API int app_manager_get_shared_data_path(const char *app_id, char **path)
 277 {
 278         int r;
 279         int retval;
 280
 281         if (app_id == NULL || path == NULL)
 282                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 283
 284         retval = aul_get_app_shared_data_path_by_appid(app_id, path);
 285         switch (retval) {
 286         case AUL_R_OK:
 287                 r = APP_MANAGER_ERROR_NONE;
 288                 break;
 289         case AUL_R_ENOAPP:
 290                 r = app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 291                 break;
 292         case AUL_R_EINVAL:
 293                 r = app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 294                 break;
 295         case AUL_R_ERROR:
 296                 r = app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 297                 break;
 298         case AUL_R_EREJECTED:
 299                 r = app_manager_error(APP_MANAGER_ERROR_NOT_SUPPORTED, __FUNCTION__, NULL);
 300                 break;
 301         default:
 302                 r = app_manager_error(APP_MANAGER_ERROR_REQUEST_FAILED, __FUNCTION__, NULL);
 303                 break;
 304         }
 305
 306         return r;
 307 }
 308
 309 API int app_manager_get_shared_resource_path(const char *app_id, char **path)
 310 {
 311         int r;
 312         int retval = aul_get_app_shared_resource_path_by_appid(app_id, path);
 313
 314         switch (retval) {
 315         case AUL_R_OK:
 316                 r = APP_MANAGER_ERROR_NONE;
 317                 break;
 318         case AUL_R_ENOAPP:
 319                 r = app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 320                 break;
 321         case AUL_R_EINVAL:
 322                 r = app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 323                 break;
 324         case AUL_R_ERROR:
 325                 r = app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 326                 break;
 327         default:
 328                 r = app_manager_error(APP_MANAGER_ERROR_REQUEST_FAILED, __FUNCTION__, NULL);
 329                 break;
 330         }
 331
 332         return r;
 333 }
 334
 335 API int app_manager_get_shared_trusted_path(const char *app_id, char **path)
 336 {
 337         int r;
 338         int retval = aul_get_app_shared_trusted_path_by_appid(app_id, path);
 339
 340         switch (retval) {
 341         case AUL_R_OK:
 342                 r = APP_MANAGER_ERROR_NONE;
 343                 break;
 344         case AUL_R_ENOAPP:
 345                 r = app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 346                 break;
 347         case AUL_R_EINVAL:
 348                 r = app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 349                 break;
 350         case AUL_R_ERROR:
 351                 r = app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 352                 break;
 353         default:
 354                 r = app_manager_error(APP_MANAGER_ERROR_REQUEST_FAILED, __FUNCTION__, NULL);
 355                 break;
 356         }
 357
 358         return r;
 359 }
 360
 361 API int app_manager_get_external_shared_data_path(const char *app_id, char **path)
 362 {
 363         dlog_print(DLOG_WARN, LOG_TAG, "DEPRECATION WARNING: app_manager_get_external_shared_data_path() is deprecated and will be removed from next release.");
 364         int r;
 365         int retval = aul_get_app_external_shared_data_path_by_appid(app_id, path);
 366
 367         switch (retval) {
 368         case AUL_R_OK:
 369                 r = APP_MANAGER_ERROR_NONE;
 370                 break;
 371         case AUL_R_ENOAPP:
 372                 r = app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 373                 break;
 374         case AUL_R_EINVAL:
 375                 r = app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 376                 break;
 377         case AUL_R_ERROR:
 378                 r = app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 379                 break;
 380         default:
 381                 r = app_manager_error(APP_MANAGER_ERROR_REQUEST_FAILED, __FUNCTION__, NULL);
 382                 break;
 383         }
 384
 385         return r;
 386 }
 387
 388 API int app_manager_set_splash_screen_display(const char *app_id, bool display)
 389 {
 390         int r;
 391         pkgmgr_client *pc;
 392
 393         if (app_id == NULL)
 394                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 395                                 __FUNCTION__, NULL);
 396
 397         pc = pkgmgr_client_new(PC_REQUEST);
 398         if (pc == NULL)
 399                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY,
 400                                 __FUNCTION__, NULL);
 401
 402         if (display)
 403                 r = pkgmgr_client_enable_splash_screen(pc, app_id);
 404         else
 405                 r = pkgmgr_client_disable_splash_screen(pc, app_id);
 406         pkgmgr_client_free(pc);
 407
 408         switch (r) {
 409         case PKGMGR_R_OK:
 410                 r = APP_MANAGER_ERROR_NONE;
 411                 break;
 412         case PKGMGR_R_EINVAL:
 413                 r = app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 414                                 __FUNCTION__, NULL);
 415                 break;
 416         case PKGMGR_R_EPRIV:
 417                 r = app_manager_error(APP_MANAGER_ERROR_PERMISSION_DENIED,
 418                                 __FUNCTION__, NULL);
 419                 break;
 420         case PKGMGR_R_ENOMEM:
 421                 r = app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY,
 422                                 __FUNCTION__, NULL);
 423                 break;
 424         default:
 425                 r = app_manager_error(APP_MANAGER_ERROR_IO_ERROR,
 426                                 __FUNCTION__, NULL);
 427                 break;
 428         }
 429
 430         return r;
 431 }
 432
 433 API int app_manager_set_app_icon(const char *app_id, const char *icon_path)
 434 {
 435         int r;
 436         pkgmgr_client *pc;
 437
 438         if (app_id == NULL)
 439                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 440                                 __FUNCTION__, NULL);
 441
 442         pc = pkgmgr_client_new(PC_REQUEST);
 443         if (pc == NULL)
 444                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY,
 445                                 __FUNCTION__, NULL);
 446
 447         r = pkgmgr_client_set_app_icon(pc, (char *)app_id, (char *)icon_path);
 448         pkgmgr_client_free(pc);
 449
 450         switch (r) {
 451         case PKGMGR_R_OK:
 452                 r = APP_MANAGER_ERROR_NONE;
 453                 break;
 454         case PKGMGR_R_EINVAL:
 455                 r = app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 456                                 __FUNCTION__, NULL);
 457                 break;
 458         case PKGMGR_R_EPRIV:
 459                 r = app_manager_error(APP_MANAGER_ERROR_PERMISSION_DENIED,
 460                                 __FUNCTION__, NULL);
 461                 break;
 462         default:
 463                 r = app_manager_error(APP_MANAGER_ERROR_IO_ERROR,
 464                                 __FUNCTION__, NULL);
 465                 break;
 466         }
 467
 468         return r;
 469 }
 470
 471
 472 API int app_manager_event_create(app_manager_event_h *handle)
 473 {
 474         pkgmgr_client *pc = NULL;
 475         app_manager_event *app_mgr_evt = NULL;
 476
 477         if (handle == NULL)
 478                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 479                                 __FUNCTION__, NULL);
 480
 481         app_mgr_evt = (app_manager_event *)calloc(1, sizeof(app_manager_event));
 482         if (app_mgr_evt == NULL) {
 483                 /* LCOV_EXCL_START */
 484                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY,
 485                                 __FUNCTION__, NULL);
 486                 /* LCOV_EXCL_STOP */
 487         }
 488
 489         pc = pkgmgr_client_new(PC_LISTENING);
 490         if (pc == NULL) {
 491                 /* LCOV_EXCL_START */
 492                 free(app_mgr_evt);
 493                 return app_manager_error(APP_MANAGER_ERROR_OUT_OF_MEMORY,
 494                                 __FUNCTION__, NULL);
 495                 /* LCOV_EXCL_STOP */
 496         }
 497
 498         app_mgr_evt->pc = pc;
 499         *handle = app_mgr_evt;
 500         return APP_MANAGER_ERROR_NONE;
 501 }
 502
 503 API int app_manager_event_set_status(app_manager_event_h handle, int status_type)
 504 {
 505         int ret = APP_MANAGER_ERROR_NONE;
 506         int pkgmgr_status_type = -1;
 507
 508         if (handle == NULL || status_type < 0)
 509                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 510                                 __FUNCTION__, NULL);
 511
 512         pkgmgr_status_type = convert_status_type(status_type);
 513         if (pkgmgr_status_type < 0)
 514                 return app_manager_error(APP_MANAGER_ERROR_REQUEST_FAILED,
 515                                 __FUNCTION__, NULL);
 516
 517         ret = pkgmgr_client_set_status_type(handle->pc, pkgmgr_status_type);
 518         if (ret != PKGMGR_R_OK) {
 519                 /* LCOV_EXCL_START */
 520                 LOGE("[%s] APP_MANAGER_ERROR_REQUEST_FAILED(0x%08x) : " \
 521                                 "Failed to set event status", __FUNCTION__,
 522                                 APP_MANAGER_ERROR_REQUEST_FAILED);
 523                 return APP_MANAGER_ERROR_REQUEST_FAILED;
 524                 /* LCOV_EXCL_STOP */
 525         }
 526
 527         return APP_MANAGER_ERROR_NONE;
 528 }
 529
 530 API int app_manager_set_event_cb(app_manager_event_h handle,
 531                 app_manager_event_cb callback,
 532                 void *user_data)
 533 {
 534         int ret = APP_MANAGER_ERROR_NONE;
 535
 536         if (handle == NULL || callback == NULL)
 537                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 538                                 __FUNCTION__, NULL);
 539
 540         handle->event_cb = callback;
 541         handle->user_data = user_data;
 542
 543         ret = pkgmgr_client_listen_app_status(handle->pc,
 544                         app_event_handler, handle);
 545         if (ret < PKGMGR_R_OK) {
 546                 /* LCOV_EXCL_START */
 547                 LOGE("[%s] APP_MANAGER_ERROR_REQUEST_FAILED(0x%08x) : " \
 548                                 "Failed to set event callback", __FUNCTION__,
 549                                 APP_MANAGER_ERROR_REQUEST_FAILED);
 550                 return APP_MANAGER_ERROR_REQUEST_FAILED;
 551                 /* LCOV_EXCL_STOP */
 552         }
 553
 554         handle->req_id = ret;
 555         return APP_MANAGER_ERROR_NONE;
 556 }
 557
 558 API int app_manager_unset_event_cb(app_manager_event_h handle)
 559 {
 560         int ret = APP_MANAGER_ERROR_NONE;
 561
 562         if (handle == NULL || handle->pc == NULL)
 563                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 564                                 __FUNCTION__, NULL);
 565
 566         ret = pkgmgr_client_remove_listen_status(handle->pc);
 567         if (ret != 0) {
 568                 /* LCOV_EXCL_START */
 569                 LOGE("[%s] APP_MANAGER_ERROR_REQUEST_FAILED(0x%08x) : " \
 570                                 "Failed to unset event callback", __FUNCTION__,
 571                                 APP_MANAGER_ERROR_REQUEST_FAILED);
 572                 return APP_MANAGER_ERROR_REQUEST_FAILED;
 573                 /* LCOV_EXCL_STOP */
 574         }
 575
 576         return APP_MANAGER_ERROR_NONE;
 577 }
 578
 579 API int app_manager_event_destroy(app_manager_event_h handle)
 580 {
 581         int ret = APP_MANAGER_ERROR_NONE;
 582
 583         if (handle == NULL)
 584                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER,
 585                                 __FUNCTION__, NULL);
 586
 587         ret = pkgmgr_client_free(handle->pc);
 588         if (ret != 0) {
 589                 /* LCOV_EXCL_START */
 590                 LOGE("[%s] APP_MANAGER_ERROR_REQUEST_FAILED(0x%08x) : " \
 591                                 "Failed to destroy handle", __FUNCTION__,
 592                                 APP_MANAGER_ERROR_REQUEST_FAILED);
 593                 return APP_MANAGER_ERROR_REQUEST_FAILED;
 594                 /* LCOV_EXCL_STOP */
 595         }
 596         remove_app_manager_event_info_list(handle->head);
 597
 598         free(handle);
 599         return APP_MANAGER_ERROR_NONE;
 600 }
 601
 602 API int app_manager_set_app_context_status_cb(app_manager_app_context_status_cb callback, const char *appid, void *user_data)
 603 {
 604         int ret;
 605
 606         ret = app_context_set_status_cb(callback, appid, user_data);
 607         if (ret != APP_MANAGER_ERROR_NONE)
 608                 return app_manager_error(ret, __FUNCTION__, NULL);
 609
 610         return APP_MANAGER_ERROR_NONE;
 611 }
 612
 613 API int app_manager_get_app_context_by_instance_id(const char *app_id, const char *instance_id, app_context_h *app_context)
 614 {
 615         int ret;
 616
 617         ret = app_context_get_app_context_by_instance_id(app_id, instance_id, app_context);
 618         if (ret != APP_MANAGER_ERROR_NONE)
 619                 return app_manager_error(ret, __FUNCTION__, NULL);
 620
 621         return APP_MANAGER_ERROR_NONE;
 622 }
 623
 624 API int app_manager_get_focused_app_context(app_context_h *app_context)
 625 {
 626         int ret;
 627         pid_t pid = -1;
 628
 629         if (app_context == NULL)
 630                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 631
 632         ret = aul_window_get_focused_pid(&pid);
 633         if (ret != 0)
 634                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL); /* LCOV_EXCL_LINE */
 635
 636         if (pid < 0)
 637                 return app_manager_error(APP_MANAGER_ERROR_NO_SUCH_APP, __FUNCTION__, NULL);
 638
 639         ret = app_context_get_app_context_by_pid(pid, app_context);
 640         if (ret != APP_MANAGER_ERROR_NONE)
 641                 return app_manager_error(ret, __FUNCTION__, NULL); /* LCOV_EXCL_LINE */
 642
 643         return APP_MANAGER_ERROR_NONE;
 644 }
 645
 646 API int app_manager_attach_window(const char *parent_app_id, const char *child_app_id)
 647 {
 648         int ret;
 649
 650         if (parent_app_id == NULL || child_app_id == NULL)
 651                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 652
 653         ret = aul_window_attach(parent_app_id, child_app_id);
 654         if (ret != 0)
 655                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 656
 657         return APP_MANAGER_ERROR_NONE;
 658 }
 659
 660 API int app_manager_detach_window(const char *app_id)
 661 {
 662         int ret;
 663
 664         if (app_id == NULL)
 665                 return app_manager_error(APP_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 666
 667         ret = aul_window_detach(app_id);
 668         if (ret != 0)
 669                 return app_manager_error(APP_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 670
 671         return APP_MANAGER_ERROR_NONE;
 672 }
 673
 674 API int app_manager_unset_app_context_status_cb(app_manager_app_context_status_cb callback, const char *appid)
 675 {
 676         int ret;
 677
 678         ret = app_context_unset_status_cb(callback, appid);
 679         if (ret != APP_MANAGER_ERROR_NONE)
 680                 return app_manager_error(ret, __FUNCTION__, NULL);
 681
 682         return APP_MANAGER_ERROR_NONE;
 683 }
 684
 685 API int app_manager_foreach_visible_app_context(app_manager_app_context_cb callback, void *user_data)
 686 {
 687         int ret;
 688
 689         ret = app_context_foreach_visible_app_context(callback, user_data);
 690         if (ret != APP_MANAGER_ERROR_NONE)
 691                 return app_manager_error(ret, __FUNCTION__, NULL);
 692
 693         return APP_MANAGER_ERROR_NONE;
 694 }