src/Application/ApplicationManager.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include "ApplicationManager.h"
  19
  20 #include <cassert>
  21 #include <sstream>
  22 #include <Commons/Exception.h>
  23 #include <Commons/EventReceiver.h>
  24 #include <Commons/Regex.h>
  25 #include <plugins-ipc-message/ipc_message_support.h>
  26
  27 #include "ApplicationInformation.h"
  28 #include "ApplicationContext.h"
  29 #include "ApplicationControlData.h"
  30 #include "ApplicationControl.h"
  31 #include "Application.h"
  32
  33 #include <app.h>
  34
  35 // to launch app by aul
  36 #include <aul.h>
  37
  38 // to get package name by appid
  39 #include <app_info.h>
  40 #include <app_manager.h>
  41
  42 // To get cert information from package
  43 #include <package_manager.h>
  44 #include <package_info.h>
  45
  46 // To get app size and installed time
  47 #include <pkgmgr-info.h>
  48
  49 // To get ppid
  50 #include <unistd.h>
  51
  52 #include <TimeTracer.h>
  53
  54 #include <Logger.h>
  55
  56 namespace DeviceAPI {
  57 namespace Application {
  58
  59
  60 using namespace WrtDeviceApis;
  61 using namespace WrtDeviceApis::Commons;
  62
  63 namespace {
  64
  65         typedef KeyMultiMap<ApplicationManager*, LaunchAppControlPendingEvent> LaunchAppControlPendingEventMap;
  66         static LaunchAppControlPendingEventMap gLaunchAppControlPendingEventMap;
  67
  68         // Callback from 'app_manager_set_app_context_event_cb'
  69         // Used by 'kill'
  70         static void app_manager_app_context_event_callback(app_context_h app_context,
  71                         app_context_event_e event, void *user_data)
  72         {
  73                 int ret = 0;
  74
  75                 if(event != APP_CONTEXT_EVENT_TERMINATED)
  76                         return;
  77
  78                 int pid = 0;
  79
  80                 ret = app_context_get_pid(app_context, &pid);
  81                 if(ret != APP_MANAGER_ERROR_NONE)
  82                 {
  83                         LoggerE("Fail to get pid of terminated app (" << ret << ")");
  84                         return;
  85                 }
  86
  87                 ApplicationManager* appManager = (ApplicationManager*)(user_data);
  88                 appManager->invokeManualAnswerKill(pid);
  89         }
  90
  91         // get package name by id
  92         static char* getPackageByAppId(const char* appId)
  93         {
  94                 app_info_h handle;
  95                 char* pkgName;
  96                 int ret = 0;
  97
  98                 ret = app_manager_get_app_info(appId, &handle);
  99                 if (ret < 0)
 100                 {
 101                         LoggerE("Fail to get appinfo");
 102                         return NULL;
 103                 }
 104
 105                 ret = app_info_get_package(handle, &pkgName);
 106                 if (ret < 0)
 107                 {
 108                         LoggerE("Fail to get pkgName");
 109                         pkgName = NULL;
 110                 }
 111
 112                 ret = app_info_destroy(handle);
 113                 if (ret < 0)
 114                 {
 115                         LoggerE("Fail to get destory appinfo");
 116                         return NULL;
 117                 }
 118
 119                 return pkgName;
 120         }
 121
 122
 123         // Callback of 'app_manager_foreach_app_context'
 124         // Used by 'getAppsContext'
 125         static bool app_manager_app_context_callback(app_context_h app_context, void *user_data)
 126         {
 127                 int ret = 0;
 128
 129                 char *app_id = NULL;
 130                 int pid;
 131
 132                 std::string contextId;
 133
 134                 if (user_data == NULL)
 135                 {
 136                         return false;
 137                 }
 138
 139                 ret = app_context_get_app_id(app_context, &app_id);
 140                 if((ret != APP_MANAGER_ERROR_NONE) || (app_id == NULL))
 141                 {
 142                         LoggerE("Fail to get app id from context (" << ret << ")");
 143                         return false;
 144                 }
 145
 146                 ret = app_context_get_pid(app_context, &pid);
 147                 if(ret != APP_MANAGER_ERROR_NONE)
 148                 {
 149                         LoggerE("Fail to get pid from context (" << ret << ")");
 150                         if (app_id)
 151                                 free(app_id);
 152                         return false;
 153                 }
 154
 155                 std::stringstream sstream;
 156                 sstream << pid;
 157                 contextId = sstream.str();
 158
 159                 ApplicationContextPtr appContext(new ApplicationContext());
 160                 appContext->setAppId(app_id);
 161                 appContext->setContextId(contextId);
 162
 163                 ApplicationContextArray* appContextArray = (ApplicationContextArray*)user_data;
 164
 165                 appContextArray->push_back(appContext);
 166
 167                 if (app_id)
 168                         free(app_id);
 169
 170                 return true;
 171         }
 172
 173         // Callback of 'service_send_launch_request'
 174         // Used by 'launchAppControl'
 175         static void service_reply_callback(service_h request, service_h reply,
 176                         service_result_e result, void *user_data)
 177         {
 178                 LaunchAppControlPendingEventMap::DataKeyType key =
 179                                 (LaunchAppControlPendingEventMap::DataKeyType)user_data;
 180
 181                 LaunchAppControlPendingEvent *pendingEvent = gLaunchAppControlPendingEventMap.getData(key);
 182                 if(pendingEvent != NULL)
 183                 {
 184                         ApplicationManager *application = (ApplicationManager *)pendingEvent->getThisObject();
 185                         EventApplicationLaunchAppControlReplyPtr event = pendingEvent->getEvent();
 186                         application->invokeManualAnswerLaunchAppControl(request, reply, result, event);
 187
 188                         delete pendingEvent;
 189                         pendingEvent = NULL;
 190                         user_data = NULL;
 191
 192                         gLaunchAppControlPendingEventMap.eraseData(key);
 193                 }
 194         }
 195
 196         static bool package_cert_cb(package_info_h handle, package_cert_type_e cert_type, const char *cert_value, void *user_data)
 197         {
 198                 ApplicationCertPtr cert(new ApplicationCert());
 199                 const char* certName = NULL;
 200
 201                 switch(cert_type) {
 202                 case PACKAGE_INFO_AUTHOR_ROOT_CERT:
 203                         certName = "AUTHOR_ROOT";
 204                         break;
 205                 case PACKAGE_INFO_AUTHOR_INTERMEDIATE_CERT:
 206                         certName = "AUTHOR_INTERMEDIATE";
 207                         break;
 208                 case PACKAGE_INFO_AUTHOR_SIGNER_CERT:
 209                         certName = "AUTHOR_SIGNER";
 210                         break;
 211                 case PACKAGE_INFO_DISTRIBUTOR_ROOT_CERT:
 212                         certName = "DISTRIBUTOR_ROOT";
 213                         break;
 214                 case PACKAGE_INFO_DISTRIBUTOR_INTERMEDIATE_CERT:
 215                         certName = "DISTRIBUTOR_INTERMEDIATE";
 216                         break;
 217                 case PACKAGE_INFO_DISTRIBUTOR_SIGNER_CERT:
 218                         certName = "DISTRIBUTOR_SIGNER";
 219                         break;
 220                 case PACKAGE_INFO_DISTRIBUTOR2_ROOT_CERT:
 221                         certName = "DISTRIBUTOR2_ROOT";
 222                         break;
 223                 case PACKAGE_INFO_DISTRIBUTOR2_INTERMEDIATE_CERT:
 224                         certName = "DISTRIBUTOR2_INTERMEDIATE";
 225                         break;
 226                 case PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT:
 227                         certName = "DISTRIBUTOR2_SIGNER";
 228                         break;
 229                 default:
 230                         LoggerE("Unknow Cert type!!!");
 231                         break;
 232                 }
 233
 234                 cert->setType(certName);
 235                 cert->setValue(cert_value);
 236
 237                 ApplicationCertArray *certs = (ApplicationCertArray *)user_data;
 238                 certs->push_back(cert);
 239
 240                 return true;
 241         }
 242
 243         static std::string get_current_app_id()
 244         {
 245                 std::string appId = AppManagerWrapperSingleton::Instance().getCurrentAppId();
 246                 return appId;
 247         }
 248
 249         static int category_cb(const char *category, void *user_data)
 250         {
 251                 if (category == NULL)
 252                         return true;
 253
 254                 ApplicationInformation* appInfo = (ApplicationInformation*)user_data;
 255                 appInfo->addCategories(category);
 256                 return true;
 257         }
 258
 259         static ApplicationInformationPtr create_app_info(pkgmgrinfo_appinfo_h handle)
 260         {
 261                 char* appId = NULL;
 262                 char* name = NULL;
 263                 char* iconPath = NULL;
 264                 bool noDisplay = false;
 265                 char* pkgId = NULL;
 266                 int ret = 0;
 267
 268                 ApplicationInformationPtr appInfo(new ApplicationInformation());
 269                 ret = pkgmgrinfo_appinfo_get_appid(handle, &appId);
 270                 if (ret != PMINFO_R_OK) {
 271                         LoggerD("Fail to get name");
 272                 } else {
 273                         appInfo->setAppId(appId);
 274                 }
 275
 276                 ret = pkgmgrinfo_appinfo_get_label(handle, &name);
 277                 if ((ret != PMINFO_R_OK) || (name == NULL)) {
 278                         LoggerD("Fail to get name");
 279                 } else {
 280                         appInfo->setName(name);
 281                 }
 282
 283                 ret = pkgmgrinfo_appinfo_get_icon(handle, &iconPath);
 284                 if ((ret != PMINFO_R_OK) || (iconPath == NULL)) {
 285                         LoggerD("Fail to get icon");
 286                 } else {
 287                         appInfo->setIconPath(iconPath);
 288                 }
 289
 290                 ret = pkgmgrinfo_appinfo_is_nodisplay(handle, &noDisplay);
 291                 if (ret != PMINFO_R_OK) {
 292                         LoggerD("Fail to get nodisplay");
 293                 } else {
 294                         appInfo->setShow(!noDisplay);
 295                 }
 296
 297                 ret = pkgmgrinfo_appinfo_foreach_category(handle, category_cb, (void*)appInfo.Get());
 298                 if (ret != PMINFO_R_OK) {
 299                         LoggerD("Fail to get categories");
 300                 }
 301
 302                 ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgId);
 303                 if ((ret != PMINFO_R_OK) || (pkgId == NULL)) {
 304                         LoggerD("Fail to get pkg Id");
 305                 } else {
 306                         appInfo->setPackageId(pkgId);
 307                 }
 308
 309                 char *version = NULL;
 310                 int installed_time = 0;
 311                 pkgmgrinfo_pkginfo_h pkginfo_h;
 312
 313                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgId, &pkginfo_h);
 314                 if (ret != PMINFO_R_OK) {
 315                         LoggerE("Fail to get package info");
 316                 } else {
 317                         ret = pkgmgrinfo_pkginfo_get_version(pkginfo_h, &version);
 318                         if (ret != PMINFO_R_OK) {
 319                                 LoggerE("Fail to get version");
 320                         } else {
 321                                 appInfo->setVersion(version);
 322                         }
 323
 324                         ret = pkgmgrinfo_pkginfo_get_installed_time(pkginfo_h, &installed_time);
 325                         if (ret != PMINFO_R_OK) {
 326                                 LoggerE("Fail to get installed date");
 327                         } else {
 328                                 appInfo->setInstallDate(installed_time);
 329                         }
 330
 331                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
 332                 }
 333
 334                 // remark : attribute "total size" is set at first attribute access time for performance.
 335                 return appInfo;
 336         }
 337
 338
 339         static int installed_app_info_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
 340         {
 341                 ApplicationInformationPtr appInfo = create_app_info(handle);
 342                 ApplicationInformationArray *appInfoArray = (ApplicationInformationArray*)user_data;
 343                 appInfoArray->push_back(appInfo);
 344                 return 0;
 345         }
 346
 347         // Callback from 'service_foreach_app_matched'
 348         // Used by 'findAppControl'
 349         static bool service_app_matched_callback(service_h service, const char *appid, void *user_data)
 350         {
 351                 if(appid == NULL)
 352                 {
 353                         LoggerD("appid is NULL");
 354                         return false;
 355                 }
 356                 //ApplicationInformationPtr appInfo(new ApplicationInformation(appid));
 357                 pkgmgrinfo_appinfo_h handle;
 358                 int ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
 359                 if (ret != PMINFO_R_OK) {
 360                         LoggerD("Fail to get appInfo from appId : " << appid);
 361                 } else {
 362                         ApplicationInformationPtr appInfo = create_app_info(handle);
 363                         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 364
 365                         ApplicationInformationArray *appInfos = (ApplicationInformationArray *)user_data;
 366                         appInfos->push_back(appInfo);
 367                 }
 368
 369                 return true;
 370         }
 371
 372         static int app_meta_data_cb(const char *meta_key, const char *meta_value, void *user_data)
 373         {
 374                 if ((meta_key == NULL)  || (meta_value == NULL)) {
 375                         LoggerE("meta_key or meta_value is null");
 376                         return 0;
 377                 }
 378
 379                 ApplicationMetaDataPtr metaData(new ApplicationMetaData());
 380
 381                 metaData->setKey(meta_key);
 382                 metaData->setValue(meta_value);
 383
 384                 ApplicationMetaDataArray *metaDataArray = (ApplicationMetaDataArray *)user_data;
 385                 metaDataArray->push_back(metaData);
 386
 387                 return 0;
 388         }
 389 }
 390
 391 ApplicationManager::ApplicationManager() :
 392         m_initialized(false)
 393 {
 394
 395 }
 396
 397 ApplicationManager::~ApplicationManager()
 398 {
 399         if(m_installedApplicationsEmitters.size() != 0)
 400         {
 401                 AppManagerWrapperSingleton::Instance().unregisterAppListChangedCallbacks(this);
 402                 WatchIdMap::iterator iter = m_watchIdMap.begin();
 403                 for(; iter != m_watchIdMap.end(); iter++)
 404                 {
 405                         m_installedApplicationsEmitters.detach(iter->second);
 406                 }
 407         }
 408
 409         LaunchAppControlPendingEventMap::DataPtrListType dataPtrList =
 410                         gLaunchAppControlPendingEventMap.getDataPtrList(this);
 411
 412         LaunchAppControlPendingEventMap::DataPtrListType::iterator iter = dataPtrList.begin();
 413         for(; iter != dataPtrList.end(); iter++)
 414         {
 415                 delete *iter;
 416         }
 417
 418         gLaunchAppControlPendingEventMap.eraseKey(this);
 419
 420         // unset context event callback which is registered by kill().
 421         app_manager_unset_app_context_event_cb();
 422 }
 423
 424 void ApplicationManager::launch(const EventApplicationLaunchPtr& event)
 425 {
 426         if (m_initialized == false) {
 427                 initialize();
 428         }
 429
 430         EventRequestReceiver<EventApplicationLaunch>::PostRequest(event);
 431 }
 432
 433 void ApplicationManager::kill(const EventApplicationKillPtr& event)
 434 {
 435         if (m_initialized == false) {
 436                 initialize();
 437         }
 438
 439         EventRequestReceiver<EventApplicationKill>::PostRequest(event);
 440 }
 441
 442 void ApplicationManager::launchAppControl(const EventApplicationLaunchAppControlPtr& event)
 443 {
 444         if (m_initialized == false) {
 445                 initialize();
 446         }
 447
 448         EventApplicationLaunchAppControlReplyPtr eventReply = event->getEventReply();
 449         if(eventReply != NULL)
 450                 EventRequestReceiver<EventApplicationLaunchAppControlReply>::PostRequest(eventReply);
 451
 452         EventRequestReceiver<EventApplicationLaunchAppControl>::PostRequest(event);
 453 }
 454
 455 void ApplicationManager::findAppControl(const EventApplicationFindAppControlPtr& event)
 456 {
 457         if (m_initialized == false) {
 458                 initialize();
 459         }
 460
 461         EventRequestReceiver<EventApplicationFindAppControl>::PostRequest(event);
 462 }
 463
 464 void ApplicationManager::getAppsContext(const EventApplicationGetAppsContextPtr& event)
 465 {
 466         if (m_initialized == false) {
 467                 initialize();
 468         }
 469
 470         EventRequestReceiver<EventApplicationGetAppsContext>::PostRequest(event);
 471 }
 472
 473
 474 void ApplicationManager::getAppsInfo(const EventApplicationGetAppsInfoPtr& event)
 475 {
 476         if (m_initialized == false) {
 477                 initialize();
 478         }
 479
 480         EventRequestReceiver<EventApplicationGetAppsInfo>::PostRequest(event);
 481 }
 482
 483
 484 void ApplicationManager::addAppInfoEventListener(const EventApplicationAddAppInfoEventListenerPtr& event)
 485 {
 486         if (m_initialized == false) {
 487                 initialize();
 488         }
 489
 490         EventRequestReceiver<EventApplicationAddAppInfoEventListener>::PostRequest(event);
 491 }
 492
 493 void ApplicationManager::removeAppInfoEventListener(const EventApplicationRemoveAppInfoEventListenerPtr& event)
 494 {
 495         if (m_initialized == false) {
 496                 initialize();
 497         }
 498
 499         EventRequestReceiver<EventApplicationRemoveAppInfoEventListener>::PostRequest(event);
 500 }
 501
 502
 503 void ApplicationManager::invokeManualAnswerLaunchAppControl(service_h request, service_h reply,
 504                 service_result_e result,
 505                 EventApplicationLaunchAppControlReplyPtr &event)
 506 {
 507         if (event == NULL) {
 508                 return;
 509         }
 510
 511         if(result == SERVICE_RESULT_SUCCEEDED)
 512         {
 513                 // create new service object to store result.
 514                 ApplicationControlDataArrayPtr appControlDataArray(new ApplicationControlDataArray());
 515
 516                 int result = service_foreach_extra_data(reply, service_extra_data_callback, appControlDataArray.Get());
 517                 if( result == SERVICE_ERROR_NONE)
 518                 {
 519                         event->setAppControlDataArray(appControlDataArray);
 520                 }
 521                 else
 522                 {
 523                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
 524                 }
 525         }
 526         else if(result == SERVICE_RESULT_FAILED || result == SERVICE_RESULT_CANCELED)
 527         {
 528                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
 529         }
 530
 531         EventRequestReceiver<EventApplicationLaunchAppControlReply>::ManualAnswer(event);
 532 }
 533
 534 void ApplicationManager::invokeManualAnswerKill(int pid)
 535 {
 536         DPL::Mutex::ScopedLock lock(&m_killMapLock);
 537
 538         std::map<int, EventApplicationKillPtr>::iterator it = m_killEventMap.find(pid);
 539         if (it == m_killEventMap.end()) {
 540                 return;
 541         }
 542
 543         EventApplicationKillPtr event = it->second;
 544         m_killEventMap.erase(it);
 545
 546         EventRequestReceiver<EventApplicationKill>::ManualAnswer(event);
 547 }
 548
 549
 550 bool ApplicationManager::service_extra_data_callback(service_h service, const char *key, void* user_data)
 551 {
 552         int ret = 0;
 553
 554         ApplicationControlDataArray* appControlDataArray = (ApplicationControlDataArray*)user_data;
 555
 556         bool isArray = false;
 557         ret = service_is_extra_data_array(service, key, &isArray);
 558         if (ret != SERVICE_ERROR_NONE)
 559         {
 560                 LoggerE("service_is_extra_data_array passes error");
 561                 // fail to checking. go to next extra data.
 562                 return true;
 563         }
 564
 565         std::string keyStr(key);
 566
 567         if(isArray)
 568         {
 569                 int length = 0;
 570                 char **value = NULL;
 571
 572                 ret = service_get_extra_data_array(service, key, &value, &length);
 573                 switch(ret)
 574                 {
 575                 case SERVICE_ERROR_NONE: {
 576                         std::vector<std::string> valArray;
 577                         LoggerI("value length : " << length);
 578                         for (int i = 0; i < length; i++)
 579                         {
 580                                 if(value[i])
 581                                 {
 582                                         valArray.push_back(value[i]);
 583                                 }
 584                         }
 585
 586                         ApplicationControlDataPtr appControlData(new ApplicationControlData());
 587                         appControlData->setKey(keyStr);
 588                         appControlData->setValue(valArray);
 589                         appControlDataArray->push_back(appControlData);
 590
 591                         for (int i = 0; i < length; i++)
 592                         {
 593                                 if (value[i])
 594                                         free(value[i]);
 595                         }
 596                         if (value)
 597                                 free(value);
 598                         break;
 599                 }
 600                 case SERVICE_ERROR_INVALID_PARAMETER:
 601                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_INVALID_PARAMETER");
 602                         break;
 603                 case SERVICE_ERROR_KEY_NOT_FOUND:
 604                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_KEY_NOT_FOUND");
 605                         break;
 606                 case SERVICE_ERROR_OUT_OF_MEMORY:
 607                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_OUT_OF_MEMORY");
 608                         break;
 609                 default:
 610                         LoggerE("service_get_extra_data retuns Error");
 611                         break;
 612                 }
 613         }
 614         else // (!isArray)
 615         {
 616                 char *value = NULL;
 617
 618                 ret = service_get_extra_data(service, key, &value);
 619                 switch (ret)
 620                 {
 621                 case SERVICE_ERROR_NONE:
 622                 {
 623                         if(value == NULL)
 624                         {
 625                                 LoggerE("service_get_extra_data returns NULL");
 626                                 break;
 627                         }
 628
 629                         std::vector<std::string> valArray;
 630                         valArray.push_back(value);
 631
 632                         ApplicationControlDataPtr appControlData(new ApplicationControlData());
 633                         appControlData->setKey(keyStr);
 634                         appControlData->setValue(valArray);
 635                         appControlDataArray->push_back(appControlData);
 636
 637                         if (value)
 638                                 free(value);
 639
 640                         break;
 641                 }
 642                 case SERVICE_ERROR_INVALID_PARAMETER:
 643                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_INVALID_PARAMETER");
 644                         break;
 645                 case SERVICE_ERROR_KEY_NOT_FOUND:
 646                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_KEY_NOT_FOUND");
 647                         break;
 648                 case SERVICE_ERROR_OUT_OF_MEMORY:
 649                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_OUT_OF_MEMORY");
 650                         break;
 651                 default:
 652                         LoggerE("service_get_extra_data retuns Error");
 653                         break;
 654                 }
 655         }
 656
 657         return true;
 658 }
 659
 660
 661 ApplicationPtr ApplicationManager::getCurrentApplication()
 662 {
 663         std::string appId = get_current_app_id();
 664
 665         //ApplicationInformationPtr appinfo(new ApplicationInformation(appId));
 666         pkgmgrinfo_appinfo_h handle;
 667         TIME_TRACER_ITEM_BEGIN("(getCurrentApplication)pkgmgrinfo_appinfo_get_appinfo", 0);
 668         int ret = pkgmgrinfo_appinfo_get_appinfo(appId.c_str(), &handle);
 669         TIME_TRACER_ITEM_END("(getCurrentApplication)pkgmgrinfo_appinfo_get_appinfo", 0);
 670         if (ret != PMINFO_R_OK) {
 671                 LoggerE("Fail to get appInfo");
 672                 ThrowMsg(UnknownException, "pkgmgrinfo_appinfo_get_appinfo error : unknown error");
 673         }
 674         ApplicationInformationPtr appInfo = create_app_info(handle);
 675         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 676
 677
 678         ApplicationPtr app(new Application());
 679         app->setAppInfo(appInfo);
 680
 681         LoggerD("set appinfo to application");
 682         {
 683                 //int pid = getpid();
 684                 int pid = getppid();
 685                 std::stringstream sstr;
 686                 sstr << pid;
 687                 app->setContextId(sstr.str());
 688         }
 689
 690         return app;
 691 }
 692
 693
 694 ApplicationContextPtr ApplicationManager::getAppContext(const std::string id)
 695 {
 696         int ret = 0;
 697
 698         std::string contextId = id;
 699         int pid;
 700
 701         if (contextId.empty())
 702         {
 703                 //pid = getpid();
 704                 pid = getppid();
 705
 706                 std::stringstream sstr;
 707                 sstr << pid;
 708                 contextId = sstr.str();
 709         }
 710         else
 711         {
 712                 std::stringstream(contextId) >> pid;
 713                 if (pid <= 0)
 714                 {
 715                         LoggerE("Given contextId is wrong");
 716                         ThrowMsg(NotFoundException, "Given contextId is wrong");
 717                 }
 718         }
 719
 720         char *app_id = NULL;
 721
 722         TIME_TRACER_ITEM_BEGIN("(getAppContext)app_manager_get_app_id", 0);
 723         ret = app_manager_get_app_id(pid, &app_id);
 724         TIME_TRACER_ITEM_END("(getAppContext)app_manager_get_app_id", 0);
 725         if(ret != APP_MANAGER_ERROR_NONE)
 726         {
 727                 if(app_id)
 728                         free(app_id);
 729
 730                 switch(ret)
 731                 {
 732                 case APP_MANAGER_ERROR_NO_SUCH_APP:
 733                 case APP_MANAGER_ERROR_INVALID_PARAMETER:
 734                         LoggerE("app_manager_get_app_id error : no such app");
 735                         ThrowMsg(NotFoundException, "app_manager_get_app_id error : no such app");
 736                 default:
 737                         LoggerE("app_manager_get_app_id error (" << ret << ")");
 738                         ThrowMsg(UnknownException, "app_manager_get_app_id error : unknown error");
 739                 }
 740         }
 741
 742         ApplicationContextPtr appContext(new ApplicationContext());
 743         appContext->setAppId(app_id);
 744         appContext->setContextId(contextId);
 745
 746         if(app_id)
 747                 free(app_id);
 748
 749         return appContext;
 750 }
 751
 752
 753 ApplicationInformationPtr ApplicationManager::getAppInfo(const std::string id)
 754 {
 755         std::string appId = id;
 756         // in case of no argument, get application information of current.
 757         if (appId.empty())
 758         {
 759                 appId = get_current_app_id();
 760         }
 761
 762         pkgmgrinfo_appinfo_h handle;
 763         TIME_TRACER_ITEM_BEGIN("(getAppInfo)pkgmgrinfo_appinfo_get_appinfo", 0);
 764         int ret = pkgmgrinfo_appinfo_get_appinfo(appId.c_str(), &handle);
 765         TIME_TRACER_ITEM_END("(getAppInfo)pkgmgrinfo_appinfo_get_appinfo", 0);
 766         if (ret != PMINFO_R_OK) {
 767                 ThrowMsg(NotFoundException, "Can not get appinfo");
 768         }
 769
 770         ApplicationInformationPtr appInfo = create_app_info(handle);
 771
 772         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 773
 774         return appInfo;
 775 }
 776
 777
 778 ApplicationCertArrayPtr ApplicationManager::getAppCerts(const std::string id)
 779 {
 780         std::string appId = id;
 781
 782         // in case of no argument, get application information of current.
 783         if (appId.empty())
 784         {
 785                 appId = get_current_app_id();
 786         }
 787
 788         TIME_TRACER_ITEM_BEGIN("(getAppCerts)getPackageByAppId", 0);
 789         char* package = getPackageByAppId(appId.c_str());
 790         TIME_TRACER_ITEM_END("(getAppCerts)getPackageByAppId", 0);
 791         if (package == NULL)
 792         {
 793                 LoggerE("Can not get package");
 794                 ThrowMsg(NotFoundException, "Can not get package");
 795         }
 796
 797         package_info_h pkg_info;
 798         int result = 0;
 799
 800         TIME_TRACER_ITEM_BEGIN("(getAppCerts)package_manager_get_package_info", 0);
 801         result = package_manager_get_package_info(package, &pkg_info);
 802         TIME_TRACER_ITEM_END("(getAppCerts)package_manager_get_package_info", 0);
 803         if (result != PACKAGE_MANAGER_ERROR_NONE)
 804         {
 805                 ThrowMsg(UnknownException, "Can not get package info");
 806         }
 807
 808         ApplicationCertArrayPtr certArray(new ApplicationCertArray());
 809
 810         TIME_TRACER_ITEM_BEGIN("(getAppCerts)package_info_foreach_cert_info", 0);
 811         result = package_info_foreach_cert_info(pkg_info, package_cert_cb, (void*)certArray.Get());
 812         TIME_TRACER_ITEM_END("(getAppCerts)package_info_foreach_cert_info", 0);
 813         if ((result != PACKAGE_MANAGER_ERROR_NONE) && (result != PACKAGE_MANAGER_ERROR_IO_ERROR))
 814         {
 815                 ThrowMsg(UnknownException, "Can not get package cert info");
 816         }
 817
 818         return certArray;
 819 }
 820
 821 std::string ApplicationManager::getAppSharedURI(const std::string id)
 822 {
 823 #define TIZENAPIS_APP_FILE_SCHEME               "file://"
 824 #define TIZENAPIS_APP_SLASH                             "/"
 825 #define TIZENAPIS_APP_SHARED                    "shared"
 826
 827         std::string appId;
 828
 829         if (id.empty()) {
 830                 appId = get_current_app_id();
 831         } else {
 832                 appId = id;
 833         }
 834
 835         app_info_h handle;
 836         char* pkg_name = NULL;
 837         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)app_manager_get_app_info", 0);
 838         int ret = app_manager_get_app_info(appId.c_str(), &handle);
 839         TIME_TRACER_ITEM_END("(getAppSharedURI)app_manager_get_app_info", 0);
 840         if (ret != APP_ERROR_NONE) {
 841                 LoggerD("Fail to get appinfo");
 842                 //throw NotFoundException("Fail to get appinfo");
 843                 ThrowMsg(NotFoundException, "Fail to get appinfo");
 844         }
 845
 846         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)app_info_get_package", 0);
 847         ret = app_info_get_package(handle, &pkg_name);
 848         TIME_TRACER_ITEM_END("(getAppSharedURI)app_info_get_package", 0);
 849         if ((ret != APP_ERROR_NONE) || (pkg_name == NULL)) {
 850                 LoggerD("Fail to get pkg_name");
 851                 //throw NotFoundException("Fail to get pkg_name");
 852                 ThrowMsg(NotFoundException, "Fail to get pkg_name");
 853         }
 854
 855         app_info_destroy(handle);
 856
 857         pkgmgrinfo_pkginfo_h pkginfo_h;
 858         char* root_path = NULL;
 859
 860         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)pkgmgrinfo_pkginfo_get_pkginfo", 0);
 861         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkg_name, &pkginfo_h);
 862         TIME_TRACER_ITEM_END("(getAppSharedURI)pkgmgrinfo_pkginfo_get_pkginfo", 0);
 863         if (ret != PMINFO_R_OK) {
 864                 free(pkg_name);
 865                 //throw UnknownException("Fail to get pkginfo");
 866                 ThrowMsg(UnknownException, "Fail to get pkginfo");
 867         }
 868
 869         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)pkgmgrinfo_pkginfo_get_root_path", 0);
 870         ret = pkgmgrinfo_pkginfo_get_root_path(pkginfo_h, &root_path);
 871         TIME_TRACER_ITEM_END("(getAppSharedURI)pkgmgrinfo_pkginfo_get_root_path", 0);
 872         if ((ret != PMINFO_R_OK) || (root_path == NULL)) {
 873                 LoggerE("Fail to get root path");
 874                 free(pkg_name);
 875                 //throw UnknownException("Fail to get rotpath");
 876                 ThrowMsg(UnknownException, "Fail to get rotpath");
 877         }
 878
 879         std::string sharedURI = TIZENAPIS_APP_FILE_SCHEME + std::string(root_path) + TIZENAPIS_APP_SLASH + TIZENAPIS_APP_SHARED + TIZENAPIS_APP_SLASH;
 880         free(pkg_name);
 881
 882         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
 883
 884         return sharedURI;
 885 }
 886
 887 ApplicationMetaDataArrayPtr ApplicationManager::getAppMetaData(const std::string id)
 888 {
 889         std::string appId = id;
 890
 891         // in case of no argument, get application information of current.
 892         if (appId.empty())
 893         {
 894                 appId = get_current_app_id();
 895         }
 896
 897         int ret = 0;
 898         pkgmgrinfo_appinfo_h handle;
 899
 900         TIME_TRACER_ITEM_BEGIN("(getAppMetaData)pkgmgrinfo_appinfo_get_appinfo", 0);
 901         ret = pkgmgrinfo_appinfo_get_appinfo(appId.c_str(), &handle);
 902         TIME_TRACER_ITEM_END("(getAppMetaData)pkgmgrinfo_appinfo_get_appinfo", 0);
 903
 904         if (ret != PMINFO_R_OK) {
 905                 ThrowMsg(NotFoundException, "Cannot found application with given appId");
 906         }
 907
 908         ApplicationMetaDataArrayPtr metaDataArray(new ApplicationMetaDataArray());
 909
 910         TIME_TRACER_ITEM_BEGIN("(getAppMetaData)pkgmgrinfo_appinfo_foreach_metadata", 0);
 911         ret = pkgmgrinfo_appinfo_foreach_metadata(handle, app_meta_data_cb, (void*)metaDataArray.Get());
 912         TIME_TRACER_ITEM_END("(getAppMetaData)pkgmgrinfo_appinfo_foreach_metadata", 0);
 913
 914         if (ret != PMINFO_R_OK) {
 915                 LoggerE("pkgmgrinfo_appinfo_metadata_filter_foreach() failed");
 916                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
 917                 ThrowMsg(UnknownException, "fail to get custom tag");
 918         }
 919
 920         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 921
 922         return metaDataArray;
 923 }
 924
 925 void ApplicationManager::OnRequestReceived(const EventApplicationLaunchPtr& event)
 926 {
 927         Try
 928         {
 929                 int ret;
 930                 int retry = 0;
 931
 932                 std::string appId = event->getAppId();
 933                 if(appId.empty())
 934                 {
 935                         LoggerE("App id is mandatory field.");
 936                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
 937                         return;
 938                 }
 939
 940                 // if the application is running, send raise event to the app instead of reset the application.
 941                 // give a second chance to launch application to avoid platform issue.
 942                 // this retry code will be removed after platform code change.
 943                 while (retry < 3) {
 944                         ret = aul_open_app(appId.c_str());
 945                         if (ret >= 0) {
 946                                 break;
 947                         }
 948                         // delay 300ms for each retry
 949                         usleep(300 * 1000);
 950                         retry++;
 951                         LoggerD("retry launch request : " << retry);
 952                 }
 953
 954                 if (ret < 0) {
 955                         switch (ret)
 956                         {
 957                         case AUL_R_EINVAL:
 958                         case AUL_R_ERROR:
 959                                 LoggerE("returns Not Found error");
 960                                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
 961                                 break;
 962                         case AUL_R_ECOMM:
 963                                 LoggerE("returns internal IPC error");
 964                                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 965                                 break;
 966                         default:
 967                                 LoggerE("returns Unknown error");
 968                                 event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
 969                                 break;
 970                         }
 971                 } else {
 972                         LoggerD("Success to launch.");
 973                 }
 974         }
 975         Catch (WrtDeviceApis::Commons::Exception)
 976         {
 977                 LoggerE("Error on launch : " << _rethrown_exception.GetMessage());
 978                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 979         }
 980 }
 981
 982 // Because of platform issue, some termination event is not come to app_manager_set_app_context_event_cb().
 983 // To prevent blocking issue by wating callback function, add termination checking code.
 984 // this function check whether callback is called or not after 3 sec. if callback is not called,
 985 // calls callback function forcibily.
 986 // After fixing platform issue, below code should be removed
 987
 988 typedef struct {
 989         ApplicationManager* appManager;
 990         int pid;
 991         EventApplicationKillPtr event;
 992 } KILL_DATA_T;
 993
 994 gboolean check_terminate_callback (gpointer user_data)
 995 {
 996         //EventApplicationKillPtr event = (EventApplicationKillPtr)data;
 997         KILL_DATA_T* data = (KILL_DATA_T*)user_data;
 998
 999         char * appId = NULL;
1000         if (app_manager_get_app_id(data->pid, &appId) == APP_MANAGER_ERROR_NONE) {
1001                 // if context is still alive, error callback should be called.
1002                 data->event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1003         }
1004
1005         data->appManager->invokeManualAnswerKill(data->pid);
1006
1007         return false;
1008 }
1009
1010
1011 void ApplicationManager::OnRequestReceived(const EventApplicationKillPtr& event)
1012 {
1013         Try
1014         {
1015                 int ret;
1016                 std::string contextId = event->getContextId();
1017
1018                 if(contextId.empty())
1019                 {
1020                         LoggerE("Context id is mandatory");
1021                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1022                         return;
1023                 }
1024
1025                 int pid;
1026                 std::stringstream(contextId) >> pid;
1027                 if(pid <= 0)
1028                 {
1029                         LoggerE("Given context id is wrong");
1030                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1031                         return;
1032                 }
1033
1034                 // if kill request is come for current context, throw InvalidValueException by spec
1035                 if (pid == getppid())
1036                 {
1037                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1038                         return;
1039                 }
1040
1041                 char *appIdCStr = NULL;
1042                 ret = app_manager_get_app_id(pid, &appIdCStr);
1043                 if (ret != APP_MANAGER_ERROR_NONE)
1044                 {
1045                         LoggerE("Error while getting app id (" << ret << ")");
1046                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1047                         return;
1048                 }
1049
1050                 std::string appId = appIdCStr;
1051                 free(appIdCStr);
1052
1053                 app_context_h appContext;
1054                 ret = app_manager_get_app_context (appId.c_str(), &appContext);
1055                 if (ret != APP_MANAGER_ERROR_NONE)
1056                 {
1057                         LoggerE("Error while getting app context (" << ret << ")");
1058                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1059                         return;
1060                 }
1061
1062                 // TODO thread
1063                 ret = app_manager_set_app_context_event_cb(app_manager_app_context_event_callback, this);
1064                 if (ret != APP_MANAGER_ERROR_NONE)
1065                 {
1066                         LoggerE("Error while registering app context event (" << ret << ")");
1067                         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
1068                         return;
1069                 }
1070
1071                 ret = app_manager_terminate_app(appContext);
1072                 if (ret != APP_MANAGER_ERROR_NONE)
1073                 {
1074                         LoggerE("Error while terminating app (" << ret << ")");
1075                         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
1076                         return;
1077                 }
1078
1079                 // Because of platform issue, some termination event is not come to app_manager_set_app_context_event_cb().
1080                 // To prevent blocking issue by wating callback function, add termination checking code.
1081                 // this function check whether callback is called or not after 3 sec. if callback is not called,
1082                 // calls callback function forcibily.
1083                 // After fixing platform issue, below code should be removed
1084                 {
1085                         KILL_DATA_T *data = new KILL_DATA_T;
1086                         data->pid = pid;
1087                         data->appManager = this;
1088                         data->event = event;
1089                         g_timeout_add(3000, check_terminate_callback, (void*)data);
1090                 }
1091
1092                 DPL::Mutex::ScopedLock lock(&m_killMapLock);
1093                 m_killEventMap[pid] = event;
1094                 event->switchToManualAnswer();
1095         }
1096         Catch (WrtDeviceApis::Commons::Exception)
1097         {
1098                 LoggerE("Error on kill : " << _rethrown_exception.GetMessage());
1099                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1100         }
1101 }
1102
1103 void ApplicationManager::OnRequestReceived(const EventApplicationLaunchAppControlPtr& event)
1104 {
1105         Try
1106         {
1107                 int ret = 0;
1108                 int retry = 0;
1109
1110                 ApplicationControlPtr appControl = event->getAppControl();
1111                 if(appControl == NULL)
1112                 {
1113                         LoggerE("appControl is mandatory");
1114                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1115                         return;
1116                 }
1117
1118                 std::string operation = appControl->getOperation();
1119                 if(operation.empty())
1120                 {
1121                         LoggerE("operation is madatory");
1122                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1123                         return;
1124                 }
1125
1126                 std::string appId = event->getAppId();
1127
1128                 service_h service;
1129                 service_create(&service);
1130
1131                 if (!appId.empty())
1132                 {
1133                         service_set_app_id(service, appId.c_str());
1134
1135                         // get resolved app id for aliased app id cannot be used to app_manager_get_app_info()
1136                         char* resolved_app_id = NULL;
1137                         service_get_app_id(service, &resolved_app_id);
1138
1139                         // Application exist checking. if specific application is not exist, return Not Found Exception.
1140                         app_info_h info_h;
1141                         if (app_manager_get_app_info(resolved_app_id, &info_h) != APP_MANAGER_ERROR_NONE) {
1142                                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1143                                 if (resolved_app_id) {
1144                                         free(resolved_app_id);
1145                                 }
1146                                 service_destroy(service);
1147                                 return;
1148                         }
1149
1150                         app_info_destroy(info_h);
1151                         if (resolved_app_id) {
1152                                 free(resolved_app_id);
1153                         }
1154                 }
1155
1156                 const char* windowId = IPCMessageSupport::sendMessageToUiProcess("tizen://getWindowHandle", NULL);
1157                 if (windowId != NULL)
1158                 {
1159                         service_set_window(service, atoi(windowId));
1160                 }
1161
1162                 service_set_operation(service, operation.c_str() );
1163
1164                 std::string uri = appControl->getUri();
1165                 if (!uri.empty())
1166                 {
1167                         service_set_uri(service, uri.c_str() );
1168                 }
1169
1170                 std::string mime = appControl->getMime();
1171                 if (!mime.empty())
1172                 {
1173                         service_set_mime(service, mime.c_str() );
1174                 }
1175
1176                 std::string category = appControl->getCategory();
1177                 if (!category.empty())
1178                 {
1179                         service_set_category(service, category.c_str() );
1180                 }
1181
1182                 std::vector<ApplicationControlDataPtr> appControlDataArray = appControl->getAppControlDataArray();
1183
1184                 if(!appControlDataArray.empty())
1185                 {
1186                         LoggerI(" data size     : " << appControlDataArray.size());
1187
1188                         ApplicationControlDataArray::iterator iter;
1189                         for(iter = appControlDataArray.begin(); iter != appControlDataArray.end(); iter++)
1190                         {
1191                                 ApplicationControlDataPtr appControlData = *iter;
1192
1193                                 std::string key = appControlData->getKey();
1194
1195                                 if(key.empty())
1196                                 {
1197                                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1198                                         continue;
1199                                 }
1200
1201                                 std::vector<std::string> valueArray = appControlData->getValue();
1202                                 size_t size = valueArray.size();
1203
1204                                 const char **arr = (const char**)calloc(sizeof(char*), size);
1205
1206                                 for (size_t j = 0; j < size; j++)
1207                                 {
1208                                         arr[j] = valueArray.at(j).c_str();
1209                                 }
1210
1211                                 // @20121207-wscho: roll-back to return extra-data instead of extra-data array when the value size is one.
1212                                 const char *keyCStr = key.c_str();
1213                                 if (size == 1) {
1214                                         service_add_extra_data(service, keyCStr, arr[0]);
1215                                 } else {
1216                                         service_add_extra_data_array(service, keyCStr, arr, size);
1217                                 }
1218
1219                                 if (arr)
1220                                         free(arr);
1221                         }
1222                 }
1223
1224                 LaunchAppControlPendingEvent *pendingEvent = NULL;
1225                 LaunchAppControlPendingEventMap::DataKeyType key = 0;
1226
1227                 EventApplicationLaunchAppControlReplyPtr eventReply = event->getEventReply();
1228                 if(eventReply)
1229                 {
1230                         pendingEvent = new LaunchAppControlPendingEvent((void*)this, eventReply);
1231                         key = gLaunchAppControlPendingEventMap.insert(this, pendingEvent);
1232                 }
1233
1234                 // give a second chance to launch application to avoid platform issue.
1235                 // this retry code will be removed after platform code change.
1236                 while (retry < 3) {
1237                         ret = service_send_launch_request(service, service_reply_callback, (void *)key);
1238                         if (ret != SERVICE_ERROR_LAUNCH_REJECTED) {
1239                                 break;
1240                         }
1241                         // delay 300ms for each retry
1242                         usleep(300 * 1000);
1243                         retry++;
1244                         LoggerD("retry launch request : " << retry);
1245                 }
1246
1247                 service_destroy(service);
1248
1249                 if(ret != SERVICE_ERROR_NONE)
1250                 {
1251                         switch (ret)
1252                         {
1253                         case SERVICE_ERROR_INVALID_PARAMETER:
1254                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_INVALID_PARAMETER");
1255                                 event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1256                                 break;
1257                         case SERVICE_ERROR_OUT_OF_MEMORY:
1258                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_OUT_OF_MEMORY");
1259                                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1260                                 break;
1261                         case SERVICE_ERROR_LAUNCH_REJECTED:
1262                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_LAUNCH_REJECTED!!!");
1263                                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1264                                 break;
1265                         case SERVICE_ERROR_APP_NOT_FOUND:
1266                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_APP_NOT_FOUND");
1267                                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1268                                 break;
1269                         default:
1270                                 LoggerE("service_send_launch_request returns UNKNOWN ERROR!!!");
1271                                 event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
1272                                 break;
1273                         }
1274
1275                         if(pendingEvent)
1276                         {
1277                                 gLaunchAppControlPendingEventMap.eraseData(key);
1278
1279                                 delete pendingEvent;
1280                                 pendingEvent = NULL;
1281
1282                                 eventReply->cancelRequest();
1283                                 EventRequestReceiver<EventApplicationLaunchAppControlReply>::ManualAnswer(eventReply);
1284                         }
1285                 }
1286         }
1287         Catch (WrtDeviceApis::Commons::Exception)
1288         {
1289                 LoggerE("Error on launchAppControl : " << _rethrown_exception.GetMessage());
1290                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1291         }
1292 }
1293
1294 void ApplicationManager::OnRequestReceived(const EventApplicationLaunchAppControlReplyPtr& event)
1295 {
1296         event->switchToManualAnswer();
1297 }
1298
1299 void ApplicationManager::OnRequestReceived(const EventApplicationFindAppControlPtr& event)
1300 {
1301         Try
1302         {
1303                 ApplicationControlPtr appControl = event->getAppControl();
1304                 if(appControl == NULL)
1305                 {
1306                         LoggerE("appControl is NULL");
1307                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1308                         return;
1309                 }
1310
1311                 std::string operation = appControl->getOperation();
1312                 if(operation.empty())
1313                 {
1314                         LoggerE("operation is madatory");
1315                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1316                         return;
1317                 }
1318
1319                 service_h service;
1320                 service_create(&service);
1321
1322                 service_set_operation(service, operation.c_str() );
1323
1324                 std::string uri = appControl->getUri();
1325                 if (!uri.empty())
1326                 {
1327                         service_set_uri(service, uri.c_str() );
1328                 }
1329
1330                 std::string mime = appControl->getMime();
1331                 if (!mime.empty())
1332                 {
1333                         service_set_mime(service, mime.c_str() );
1334                 }
1335
1336                 std::string category = appControl->getCategory();
1337                 if (!category.empty())
1338                 {
1339                         service_set_category(service, category.c_str() );
1340                 }
1341
1342                 std::vector<ApplicationControlDataPtr> appControlDataArray = appControl->getAppControlDataArray();
1343
1344                 if(!appControlDataArray.empty())
1345                 {
1346                         LoggerD(" data size     : " << appControlDataArray.size());
1347
1348                         ApplicationControlDataArray::iterator iter;
1349                         for(iter = appControlDataArray.begin(); iter != appControlDataArray.end(); iter++)
1350                         {
1351                                 ApplicationControlDataPtr appControlData = *iter;
1352
1353                                 std::string key = appControlData->getKey();
1354
1355                                 if(key.empty())
1356                                 {
1357                                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1358                                         continue;
1359                                 }
1360
1361                                 std::vector<std::string> valueArray = appControlData->getValue();
1362                                 size_t size = valueArray.size();
1363
1364                                 const char **arr = (const char**)calloc(sizeof(char*), size);
1365
1366                                 for (size_t j = 0; j < size; j++)
1367                                 {
1368                                         arr[j] = valueArray.at(j).c_str();
1369                                 }
1370
1371                                 // @20121207-wscho: roll-back to return extra-data instead of extra-data array when the value size is one.
1372                                 const char *keyCStr = key.c_str();
1373                                 if (size == 1) {
1374                                         service_add_extra_data(service, keyCStr, arr[0]);
1375                                 } else {
1376                                         service_add_extra_data_array(service, keyCStr, arr, size);
1377                                 }
1378
1379                                 if (arr)
1380                                         free(arr);
1381                         }
1382                 }
1383
1384                 ApplicationInformationArrayPtr appInfos(new ApplicationInformationArray());
1385
1386                 int result = service_foreach_app_matched(service, service_app_matched_callback, (void *)appInfos.Get());
1387                 if (result != SERVICE_ERROR_NONE)
1388                 {
1389                         LoggerE("service_foreach_app_matched error (" << result << ")");
1390                         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1391                         service_destroy(service);
1392                         return;
1393                 }
1394
1395                 service_destroy(service);
1396
1397                 event->setAppInfos(appInfos);
1398         }
1399         Catch (WrtDeviceApis::Commons::Exception)
1400         {
1401                 LoggerE("Error on findAppControl : " << _rethrown_exception.GetMessage());
1402                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1403         }
1404 }
1405
1406
1407 void ApplicationManager::OnRequestReceived(const EventApplicationGetAppsContextPtr& event)
1408 {
1409         Try
1410         {
1411                 int ret = 0;
1412
1413                 ApplicationContextArrayPtr appContextArray = event->getAppContextArray();
1414                 ret = app_manager_foreach_app_context(app_manager_app_context_callback, appContextArray.Get());
1415                 if(ret != APP_MANAGER_ERROR_NONE)
1416                 {
1417                         LoggerE("app_manager_foreach_app_context error (" << ret << ")");
1418                         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1419                 }
1420         }
1421         Catch (WrtDeviceApis::Commons::Exception)
1422         {
1423                 LoggerE("Error on  : " << _rethrown_exception.GetMessage());
1424                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1425         }
1426 }
1427
1428
1429
1430 void ApplicationManager::OnRequestReceived(const EventApplicationGetAppsInfoPtr& event)
1431 {
1432         Try
1433         {
1434                 int ret = 0;
1435                 ApplicationInformationArrayPtr appInfoArray = event->getAppInfoArray();
1436                 ret = pkgmgrinfo_appinfo_get_installed_list(installed_app_info_cb, (void*)appInfoArray.Get());
1437                 if (ret != PMINFO_R_OK) {
1438                         LoggerE("Error on getAppsInfo : ");
1439                         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1440                 }
1441         }
1442         Catch (WrtDeviceApis::Commons::Exception)
1443         {
1444                 LoggerE("Error on getAppsInfo : " << _rethrown_exception.GetMessage());
1445                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1446         }
1447 }
1448
1449
1450 void ApplicationManager::OnRequestReceived(const EventApplicationAddAppInfoEventListenerPtr& event)
1451 {
1452         Try
1453         {
1454                 EventApplicationAppInfoEventListenerEmitterPtr emitter = event->getEmitter();
1455
1456                 if(m_installedApplicationsEmitters.size() == 0)
1457                 {
1458                         LoggerD("First time registering event listener to this application object.");
1459
1460                         // Below can throw Exception
1461                         AppManagerWrapperSingleton::Instance().registerAppListChangedCallbacks(this);
1462                 }
1463
1464                 m_installedApplicationsEmitters.attach(emitter);
1465
1466                 long watchId = AppManagerWrapperSingleton::Instance().getWatchIdAndInc();
1467
1468                 m_watchIdMap[watchId] = emitter->getId();
1469
1470                 event->setWatchId(watchId);
1471         }
1472         Catch (WrtDeviceApis::Commons::Exception)
1473         {
1474                 LoggerE("Error on addAppInfoEventListener : " << _rethrown_exception.GetMessage());
1475                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1476         }
1477 }
1478
1479 void ApplicationManager::OnRequestReceived(const EventApplicationRemoveAppInfoEventListenerPtr& event)
1480 {
1481         Try
1482         {
1483                 long watchId = event->getWatchId();
1484
1485                 if(m_watchIdMap.find(watchId) == m_watchIdMap.end()) {
1486                         ThrowMsg(NotFoundException, "No watchId : " << watchId);
1487                 }
1488
1489                 EventApplicationAppInfoEventListenerEmitter::IdType emitterId = m_watchIdMap[watchId];
1490
1491                 bool success = m_installedApplicationsEmitters.detach(emitterId);
1492                 if(!success)
1493                         ThrowMsg(NotFoundException, "No watchId : " << watchId);
1494
1495                 if(m_installedApplicationsEmitters.size() == 0)
1496                 {
1497                         LoggerD("No more event listener on this application object.");
1498
1499                         AppManagerWrapperSingleton::Instance().unregisterAppListChangedCallbacks(this);
1500                 }
1501         }
1502         Catch (WrtDeviceApis::Commons::NotFoundException)
1503         {
1504                 LoggerE("Not found : " << _rethrown_exception.GetMessage());
1505                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1506         }
1507         Catch (WrtDeviceApis::Commons::Exception)
1508         {
1509                 LoggerE("Error on removeAppInfoEventListener : " << _rethrown_exception.GetMessage());
1510                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1511         }
1512 }
1513
1514
1515
1516 void ApplicationManager::onAppManagerEventInstalled(const char *appId)
1517 {
1518         EventApplicationAppInfoEventListenerPtr event(new EventApplicationAppInfoEventListener());
1519
1520         pkgmgrinfo_appinfo_h handle;
1521         int ret = pkgmgrinfo_appinfo_get_appinfo(appId, &handle);
1522         if (ret != PMINFO_R_OK) {
1523                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1524         } else {
1525                 ApplicationInformationPtr appInfo = create_app_info(handle);
1526                 event->setAppInfo(appInfo);
1527                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
1528         }
1529
1530         event->setType(EventApplicationAppInfoEventListener::OnInstalled);
1531         m_installedApplicationsEmitters.emit(event);
1532 }
1533
1534 void ApplicationManager::onAppManagerEventUninstalled(const char *appId)
1535 {
1536         EventApplicationAppInfoEventListenerPtr event(new EventApplicationAppInfoEventListener());
1537
1538         ApplicationInformationPtr appInfo(new ApplicationInformation(appId));
1539
1540         event->setType(EventApplicationAppInfoEventListener::OnUninstalled);
1541         event->setAppInfo(appInfo);
1542         m_installedApplicationsEmitters.emit(event);
1543 }
1544
1545 void ApplicationManager::onAppManagerEventUpdated(const char *appId)
1546 {
1547         EventApplicationAppInfoEventListenerPtr event(new EventApplicationAppInfoEventListener());
1548
1549         pkgmgrinfo_appinfo_h handle;
1550         int ret = pkgmgrinfo_appinfo_get_appinfo(appId, &handle);
1551         if (ret != PMINFO_R_OK) {
1552                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1553         } else {
1554                 ApplicationInformationPtr appInfo = create_app_info(handle);
1555                 event->setAppInfo(appInfo);
1556                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
1557         }
1558
1559         event->setType(EventApplicationAppInfoEventListener::OnUpdated);
1560         m_installedApplicationsEmitters.emit(event);
1561 }
1562
1563 void ApplicationManager::initialize()
1564 {
1565         if (!m_initialized) {
1566                 DPL::Mutex::ScopedLock lock(&m_initializationMutex);
1567                 if (!m_initialized) {
1568
1569                 }
1570         }
1571 }
1572
1573 }
1574 }