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         EventApplicationKillPtr event = it->second;
 543         m_killEventMap.erase(it);
 544
 545         EventRequestReceiver<EventApplicationKill>::ManualAnswer(event);
 546 }
 547
 548
 549 bool ApplicationManager::service_extra_data_callback(service_h service, const char *key, void* user_data)
 550 {
 551         int ret = 0;
 552
 553         ApplicationControlDataArray* appControlDataArray = (ApplicationControlDataArray*)user_data;
 554
 555         bool isArray = false;
 556         ret = service_is_extra_data_array(service, key, &isArray);
 557         if (ret != SERVICE_ERROR_NONE)
 558         {
 559                 LoggerE("service_is_extra_data_array passes error");
 560                 // fail to checking. go to next extra data.
 561                 return true;
 562         }
 563
 564         std::string keyStr(key);
 565
 566         if(isArray)
 567         {
 568                 int length = 0;
 569                 char **value = NULL;
 570
 571                 ret = service_get_extra_data_array(service, key, &value, &length);
 572                 switch(ret)
 573                 {
 574                 case SERVICE_ERROR_NONE: {
 575                         std::vector<std::string> valArray;
 576                         LoggerI("value length : " << length);
 577                         for (int i = 0; i < length; i++)
 578                         {
 579                                 if(value[i])
 580                                 {
 581                                         valArray.push_back(value[i]);
 582                                 }
 583                         }
 584
 585                         ApplicationControlDataPtr appControlData(new ApplicationControlData());
 586                         appControlData->setKey(keyStr);
 587                         appControlData->setValue(valArray);
 588                         appControlDataArray->push_back(appControlData);
 589
 590                         for (int i = 0; i < length; i++)
 591                         {
 592                                 if (value[i])
 593                                         free(value[i]);
 594                         }
 595                         if (value)
 596                                 free(value);
 597                         break;
 598                 }
 599                 case SERVICE_ERROR_INVALID_PARAMETER:
 600                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_INVALID_PARAMETER");
 601                         break;
 602                 case SERVICE_ERROR_KEY_NOT_FOUND:
 603                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_KEY_NOT_FOUND");
 604                         break;
 605                 case SERVICE_ERROR_OUT_OF_MEMORY:
 606                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_OUT_OF_MEMORY");
 607                         break;
 608                 default:
 609                         LoggerE("service_get_extra_data retuns Error");
 610                         break;
 611                 }
 612         }
 613         else // (!isArray)
 614         {
 615                 char *value = NULL;
 616
 617                 ret = service_get_extra_data(service, key, &value);
 618                 switch (ret)
 619                 {
 620                 case SERVICE_ERROR_NONE:
 621                 {
 622                         if(value == NULL)
 623                         {
 624                                 LoggerE("service_get_extra_data returns NULL");
 625                                 break;
 626                         }
 627
 628                         std::vector<std::string> valArray;
 629                         valArray.push_back(value);
 630
 631                         ApplicationControlDataPtr appControlData(new ApplicationControlData());
 632                         appControlData->setKey(keyStr);
 633                         appControlData->setValue(valArray);
 634                         appControlDataArray->push_back(appControlData);
 635
 636                         if (value)
 637                                 free(value);
 638
 639                         break;
 640                 }
 641                 case SERVICE_ERROR_INVALID_PARAMETER:
 642                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_INVALID_PARAMETER");
 643                         break;
 644                 case SERVICE_ERROR_KEY_NOT_FOUND:
 645                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_KEY_NOT_FOUND");
 646                         break;
 647                 case SERVICE_ERROR_OUT_OF_MEMORY:
 648                         LoggerE("service_get_extra_data retuns SERVICE_ERROR_OUT_OF_MEMORY");
 649                         break;
 650                 default:
 651                         LoggerE("service_get_extra_data retuns Error");
 652                         break;
 653                 }
 654         }
 655
 656         return true;
 657 }
 658
 659
 660 ApplicationPtr ApplicationManager::getCurrentApplication()
 661 {
 662         std::string appId = get_current_app_id();
 663
 664         //ApplicationInformationPtr appinfo(new ApplicationInformation(appId));
 665         pkgmgrinfo_appinfo_h handle;
 666         TIME_TRACER_ITEM_BEGIN("(getCurrentApplication)pkgmgrinfo_appinfo_get_appinfo", 0);
 667         int ret = pkgmgrinfo_appinfo_get_appinfo(appId.c_str(), &handle);
 668         TIME_TRACER_ITEM_END("(getCurrentApplication)pkgmgrinfo_appinfo_get_appinfo", 0);
 669         if (ret != PMINFO_R_OK) {
 670                 LoggerE("Fail to get appInfo");
 671                 ThrowMsg(UnknownException, "pkgmgrinfo_appinfo_get_appinfo error : unknown error");
 672         }
 673         ApplicationInformationPtr appInfo = create_app_info(handle);
 674         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 675
 676
 677         ApplicationPtr app(new Application());
 678         app->setAppInfo(appInfo);
 679
 680         LoggerD("set appinfo to application");
 681         {
 682                 //int pid = getpid();
 683                 int pid = getppid();
 684                 std::stringstream sstr;
 685                 sstr << pid;
 686                 app->setContextId(sstr.str());
 687         }
 688
 689         return app;
 690 }
 691
 692
 693 ApplicationContextPtr ApplicationManager::getAppContext(const std::string id)
 694 {
 695         int ret = 0;
 696
 697         std::string contextId = id;
 698         int pid;
 699
 700         if (contextId.empty())
 701         {
 702                 //pid = getpid();
 703                 pid = getppid();
 704
 705                 std::stringstream sstr;
 706                 sstr << pid;
 707                 contextId = sstr.str();
 708         }
 709         else
 710         {
 711                 std::stringstream(contextId) >> pid;
 712                 if (pid <= 0)
 713                 {
 714                         LoggerE("Given contextId is wrong");
 715                         ThrowMsg(NotFoundException, "Given contextId is wrong");
 716                 }
 717         }
 718
 719         char *app_id = NULL;
 720
 721         TIME_TRACER_ITEM_BEGIN("(getAppContext)app_manager_get_app_id", 0);
 722         ret = app_manager_get_app_id(pid, &app_id);
 723         TIME_TRACER_ITEM_END("(getAppContext)app_manager_get_app_id", 0);
 724         if(ret != APP_MANAGER_ERROR_NONE)
 725         {
 726                 if(app_id)
 727                         free(app_id);
 728
 729                 switch(ret)
 730                 {
 731                 case APP_MANAGER_ERROR_NO_SUCH_APP:
 732                 case APP_MANAGER_ERROR_INVALID_PARAMETER:
 733                         LoggerE("app_manager_get_app_id error : no such app");
 734                         ThrowMsg(NotFoundException, "app_manager_get_app_id error : no such app");
 735                 default:
 736                         LoggerE("app_manager_get_app_id error (" << ret << ")");
 737                         ThrowMsg(UnknownException, "app_manager_get_app_id error : unknown error");
 738                 }
 739         }
 740
 741         ApplicationContextPtr appContext(new ApplicationContext());
 742         appContext->setAppId(app_id);
 743         appContext->setContextId(contextId);
 744
 745         if(app_id)
 746                 free(app_id);
 747
 748         return appContext;
 749 }
 750
 751
 752 ApplicationInformationPtr ApplicationManager::getAppInfo(const std::string id)
 753 {
 754         std::string appId = id;
 755         // in case of no argument, get application information of current.
 756         if (appId.empty())
 757         {
 758                 appId = get_current_app_id();
 759         }
 760
 761         pkgmgrinfo_appinfo_h handle;
 762         TIME_TRACER_ITEM_BEGIN("(getAppInfo)pkgmgrinfo_appinfo_get_appinfo", 0);
 763         int ret = pkgmgrinfo_appinfo_get_appinfo(appId.c_str(), &handle);
 764         TIME_TRACER_ITEM_END("(getAppInfo)pkgmgrinfo_appinfo_get_appinfo", 0);
 765         if (ret != PMINFO_R_OK) {
 766                 ThrowMsg(NotFoundException, "Can not get appinfo");
 767         }
 768
 769         ApplicationInformationPtr appInfo = create_app_info(handle);
 770
 771         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 772
 773         return appInfo;
 774 }
 775
 776
 777 ApplicationCertArrayPtr ApplicationManager::getAppCerts(const std::string id)
 778 {
 779         std::string appId = id;
 780
 781         // in case of no argument, get application information of current.
 782         if (appId.empty())
 783         {
 784                 appId = get_current_app_id();
 785         }
 786
 787         TIME_TRACER_ITEM_BEGIN("(getAppCerts)getPackageByAppId", 0);
 788         char* package = getPackageByAppId(appId.c_str());
 789         TIME_TRACER_ITEM_END("(getAppCerts)getPackageByAppId", 0);
 790         if (package == NULL)
 791         {
 792                 LoggerE("Can not get package");
 793                 ThrowMsg(NotFoundException, "Can not get package");
 794         }
 795
 796         package_info_h pkg_info;
 797         int result = 0;
 798
 799         TIME_TRACER_ITEM_BEGIN("(getAppCerts)package_manager_get_package_info", 0);
 800         result = package_manager_get_package_info(package, &pkg_info);
 801         TIME_TRACER_ITEM_END("(getAppCerts)package_manager_get_package_info", 0);
 802         if (result != PACKAGE_MANAGER_ERROR_NONE)
 803         {
 804                 ThrowMsg(UnknownException, "Can not get package info");
 805         }
 806
 807         ApplicationCertArrayPtr certArray(new ApplicationCertArray());
 808
 809         TIME_TRACER_ITEM_BEGIN("(getAppCerts)package_info_foreach_cert_info", 0);
 810         result = package_info_foreach_cert_info(pkg_info, package_cert_cb, (void*)certArray.Get());
 811         TIME_TRACER_ITEM_END("(getAppCerts)package_info_foreach_cert_info", 0);
 812         if ((result != PACKAGE_MANAGER_ERROR_NONE) && (result != PACKAGE_MANAGER_ERROR_IO_ERROR))
 813         {
 814                 ThrowMsg(UnknownException, "Can not get package cert info");
 815         }
 816
 817         return certArray;
 818 }
 819
 820 std::string ApplicationManager::getAppSharedURI(const std::string id)
 821 {
 822 #define TIZENAPIS_APP_FILE_SCHEME               "file://"
 823 #define TIZENAPIS_APP_SLASH                             "/"
 824 #define TIZENAPIS_APP_SHARED                    "shared"
 825
 826         std::string appId;
 827
 828         if (id.empty()) {
 829                 appId = get_current_app_id();
 830         } else {
 831                 appId = id;
 832         }
 833
 834         app_info_h handle;
 835         char* pkg_name = NULL;
 836         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)app_manager_get_app_info", 0);
 837         int ret = app_manager_get_app_info(appId.c_str(), &handle);
 838         TIME_TRACER_ITEM_END("(getAppSharedURI)app_manager_get_app_info", 0);
 839         if (ret != APP_ERROR_NONE) {
 840                 LoggerD("Fail to get appinfo");
 841                 //throw NotFoundException("Fail to get appinfo");
 842                 ThrowMsg(NotFoundException, "Fail to get appinfo");
 843         }
 844
 845         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)app_info_get_package", 0);
 846         ret = app_info_get_package(handle, &pkg_name);
 847         TIME_TRACER_ITEM_END("(getAppSharedURI)app_info_get_package", 0);
 848         if ((ret != APP_ERROR_NONE) || (pkg_name == NULL)) {
 849                 LoggerD("Fail to get pkg_name");
 850                 //throw NotFoundException("Fail to get pkg_name");
 851                 ThrowMsg(NotFoundException, "Fail to get pkg_name");
 852         }
 853
 854         app_info_destroy(handle);
 855
 856         pkgmgrinfo_pkginfo_h pkginfo_h;
 857         char* root_path = NULL;
 858
 859         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)pkgmgrinfo_pkginfo_get_pkginfo", 0);
 860         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkg_name, &pkginfo_h);
 861         TIME_TRACER_ITEM_END("(getAppSharedURI)pkgmgrinfo_pkginfo_get_pkginfo", 0);
 862         if (ret != PMINFO_R_OK) {
 863                 free(pkg_name);
 864                 //throw UnknownException("Fail to get pkginfo");
 865                 ThrowMsg(UnknownException, "Fail to get pkginfo");
 866         }
 867
 868         TIME_TRACER_ITEM_BEGIN("(getAppSharedURI)pkgmgrinfo_pkginfo_get_root_path", 0);
 869         ret = pkgmgrinfo_pkginfo_get_root_path(pkginfo_h, &root_path);
 870         TIME_TRACER_ITEM_END("(getAppSharedURI)pkgmgrinfo_pkginfo_get_root_path", 0);
 871         if ((ret != PMINFO_R_OK) || (root_path == NULL)) {
 872                 LoggerE("Fail to get root path");
 873                 free(pkg_name);
 874                 //throw UnknownException("Fail to get rotpath");
 875                 ThrowMsg(UnknownException, "Fail to get rotpath");
 876         }
 877
 878         std::string sharedURI = TIZENAPIS_APP_FILE_SCHEME + std::string(root_path) + TIZENAPIS_APP_SLASH + TIZENAPIS_APP_SHARED + TIZENAPIS_APP_SLASH;
 879         free(pkg_name);
 880
 881         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
 882
 883         return sharedURI;
 884 }
 885
 886 ApplicationMetaDataArrayPtr ApplicationManager::getAppMetaData(const std::string id)
 887 {
 888         std::string appId = id;
 889
 890         // in case of no argument, get application information of current.
 891         if (appId.empty())
 892         {
 893                 appId = get_current_app_id();
 894         }
 895
 896         int ret = 0;
 897         pkgmgrinfo_appinfo_h handle;
 898
 899         TIME_TRACER_ITEM_BEGIN("(getAppMetaData)pkgmgrinfo_appinfo_get_appinfo", 0);
 900         ret = pkgmgrinfo_appinfo_get_appinfo(appId.c_str(), &handle);
 901         TIME_TRACER_ITEM_END("(getAppMetaData)pkgmgrinfo_appinfo_get_appinfo", 0);
 902
 903         if (ret != PMINFO_R_OK) {
 904                 ThrowMsg(NotFoundException, "Cannot found application with given appId");
 905         }
 906
 907         ApplicationMetaDataArrayPtr metaDataArray(new ApplicationMetaDataArray());
 908
 909         TIME_TRACER_ITEM_BEGIN("(getAppMetaData)pkgmgrinfo_appinfo_foreach_metadata", 0);
 910         ret = pkgmgrinfo_appinfo_foreach_metadata(handle, app_meta_data_cb, (void*)metaDataArray.Get());
 911         TIME_TRACER_ITEM_END("(getAppMetaData)pkgmgrinfo_appinfo_foreach_metadata", 0);
 912
 913         if (ret != PMINFO_R_OK) {
 914                 LoggerE("pkgmgrinfo_appinfo_metadata_filter_foreach() failed");
 915                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
 916                 ThrowMsg(UnknownException, "fail to get custom tag");
 917         }
 918
 919         pkgmgrinfo_appinfo_destroy_appinfo(handle);
 920
 921         return metaDataArray;
 922 }
 923
 924 void ApplicationManager::OnRequestReceived(const EventApplicationLaunchPtr& event)
 925 {
 926         Try
 927         {
 928                 int ret;
 929                 int retry = 0;
 930
 931                 std::string appId = event->getAppId();
 932                 if(appId.empty())
 933                 {
 934                         LoggerE("App id is mandatory field.");
 935                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
 936                         return;
 937                 }
 938
 939                 // if the application is running, send raise event to the app instead of reset the application.
 940                 // give a second chance to launch application to avoid platform issue.
 941                 // this retry code will be removed after platform code change.
 942                 while (retry < 3) {
 943                         ret = aul_open_app(appId.c_str());
 944                         if (ret >= 0) {
 945                                 break;
 946                         }
 947                         // delay 300ms for each retry
 948                         usleep(300 * 1000);
 949                         retry++;
 950                         LoggerD("retry launch request : " << retry);
 951                 }
 952
 953                 if (ret < 0) {
 954                         switch (ret)
 955                         {
 956                         case AUL_R_EINVAL:
 957                         case AUL_R_ERROR:
 958                                 LoggerE("returns Not Found error");
 959                                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
 960                                 break;
 961                         case AUL_R_ECOMM:
 962                                 LoggerE("returns internal IPC error");
 963                                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 964                                 break;
 965                         default:
 966                                 LoggerE("returns Unknown error");
 967                                 event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
 968                                 break;
 969                         }
 970                 } else {
 971                         LoggerD("Success to launch.");
 972                 }
 973         }
 974         Catch (WrtDeviceApis::Commons::Exception)
 975         {
 976                 LoggerE("Error on launch : " << _rethrown_exception.GetMessage());
 977                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 978         }
 979 }
 980
 981 void ApplicationManager::OnRequestReceived(const EventApplicationKillPtr& event)
 982 {
 983         Try
 984         {
 985                 int ret;
 986                 std::string contextId = event->getContextId();
 987
 988                 if(contextId.empty())
 989                 {
 990                         LoggerE("Context id is mandatory");
 991                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
 992                         return;
 993                 }
 994
 995                 int pid;
 996                 std::stringstream(contextId) >> pid;
 997                 if(pid <= 0)
 998                 {
 999                         LoggerE("Given context id is wrong");
1000                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1001                         return;
1002                 }
1003
1004                 // if kill request is come for current context, throw InvalidValueException by spec
1005                 if (pid == getppid())
1006                 {
1007                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1008                         return;
1009                 }
1010
1011                 char *appIdCStr = NULL;
1012                 ret = app_manager_get_app_id(pid, &appIdCStr);
1013                 if (ret != APP_MANAGER_ERROR_NONE)
1014                 {
1015                         LoggerE("Error while getting app id (" << ret << ")");
1016                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1017                         return;
1018                 }
1019
1020                 std::string appId = appIdCStr;
1021                 free(appIdCStr);
1022
1023                 app_context_h appContext;
1024                 ret = app_manager_get_app_context (appId.c_str(), &appContext);
1025                 if (ret != APP_MANAGER_ERROR_NONE)
1026                 {
1027                         LoggerE("Error while getting app context (" << ret << ")");
1028                         event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1029                         return;
1030                 }
1031
1032                 // TODO thread
1033                 ret = app_manager_set_app_context_event_cb(app_manager_app_context_event_callback, this);
1034                 if (ret != APP_MANAGER_ERROR_NONE)
1035                 {
1036                         LoggerE("Error while registering app context event (" << ret << ")");
1037                         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
1038                         return;
1039                 }
1040
1041                 ret = app_manager_terminate_app(appContext);
1042                 if (ret != APP_MANAGER_ERROR_NONE)
1043                 {
1044                         LoggerE("Error while terminating app (" << ret << ")");
1045                         event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
1046                         return;
1047                 }
1048
1049                 DPL::Mutex::ScopedLock lock(&m_killMapLock);
1050                 m_killEventMap[pid] = event;
1051                 event->switchToManualAnswer();
1052         }
1053         Catch (WrtDeviceApis::Commons::Exception)
1054         {
1055                 LoggerE("Error on kill : " << _rethrown_exception.GetMessage());
1056                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1057         }
1058 }
1059
1060 void ApplicationManager::OnRequestReceived(const EventApplicationLaunchAppControlPtr& event)
1061 {
1062         Try
1063         {
1064                 int ret = 0;
1065                 int retry = 0;
1066
1067                 ApplicationControlPtr appControl = event->getAppControl();
1068                 if(appControl == NULL)
1069                 {
1070                         LoggerE("appControl is mandatory");
1071                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1072                         return;
1073                 }
1074
1075                 std::string operation = appControl->getOperation();
1076                 if(operation.empty())
1077                 {
1078                         LoggerE("operation is madatory");
1079                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1080                         return;
1081                 }
1082
1083                 std::string appId = event->getAppId();
1084
1085                 service_h service;
1086                 service_create(&service);
1087
1088                 if (!appId.empty())
1089                 {
1090                         service_set_app_id(service, appId.c_str());
1091
1092                         // get resolved app id for aliased app id cannot be used to app_manager_get_app_info()
1093                         char* resolved_app_id = NULL;
1094                         service_get_app_id(service, &resolved_app_id);
1095
1096                         // Application exist checking. if specific application is not exist, return Not Found Exception.
1097                         app_info_h info_h;
1098                         if (app_manager_get_app_info(resolved_app_id, &info_h) != APP_MANAGER_ERROR_NONE) {
1099                                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1100                                 if (resolved_app_id) {
1101                                         free(resolved_app_id);
1102                                 }
1103                                 service_destroy(service);
1104                                 return;
1105                         }
1106
1107                         app_info_destroy(info_h);
1108                         if (resolved_app_id) {
1109                                 free(resolved_app_id);
1110                         }
1111                 }
1112
1113                 const char* windowId = IPCMessageSupport::sendMessageToUiProcess("tizen://getWindowHandle", NULL);
1114                 if (windowId != NULL)
1115                 {
1116                         service_set_window(service, atoi(windowId));
1117                 }
1118
1119                 service_set_operation(service, operation.c_str() );
1120
1121                 std::string uri = appControl->getUri();
1122                 if (!uri.empty())
1123                 {
1124                         service_set_uri(service, uri.c_str() );
1125                 }
1126
1127                 std::string mime = appControl->getMime();
1128                 if (!mime.empty())
1129                 {
1130                         service_set_mime(service, mime.c_str() );
1131                 }
1132
1133                 std::string category = appControl->getCategory();
1134                 if (!category.empty())
1135                 {
1136                         service_set_category(service, category.c_str() );
1137                 }
1138
1139                 std::vector<ApplicationControlDataPtr> appControlDataArray = appControl->getAppControlDataArray();
1140
1141                 if(!appControlDataArray.empty())
1142                 {
1143                         LoggerI(" data size     : " << appControlDataArray.size());
1144
1145                         ApplicationControlDataArray::iterator iter;
1146                         for(iter = appControlDataArray.begin(); iter != appControlDataArray.end(); iter++)
1147                         {
1148                                 ApplicationControlDataPtr appControlData = *iter;
1149
1150                                 std::string key = appControlData->getKey();
1151
1152                                 if(key.empty())
1153                                 {
1154                                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1155                                         continue;
1156                                 }
1157
1158                                 std::vector<std::string> valueArray = appControlData->getValue();
1159                                 size_t size = valueArray.size();
1160
1161                                 const char **arr = (const char**)calloc(sizeof(char*), size);
1162
1163                                 for (size_t j = 0; j < size; j++)
1164                                 {
1165                                         arr[j] = valueArray.at(j).c_str();
1166                                 }
1167
1168                                 // @20121207-wscho: roll-back to return extra-data instead of extra-data array when the value size is one.
1169                                 const char *keyCStr = key.c_str();
1170                                 if (size == 1) {
1171                                         service_add_extra_data(service, keyCStr, arr[0]);
1172                                 } else {
1173                                         service_add_extra_data_array(service, keyCStr, arr, size);
1174                                 }
1175
1176                                 if (arr)
1177                                         free(arr);
1178                         }
1179                 }
1180
1181                 LaunchAppControlPendingEvent *pendingEvent = NULL;
1182                 LaunchAppControlPendingEventMap::DataKeyType key = 0;
1183
1184                 EventApplicationLaunchAppControlReplyPtr eventReply = event->getEventReply();
1185                 if(eventReply)
1186                 {
1187                         pendingEvent = new LaunchAppControlPendingEvent((void*)this, eventReply);
1188                         key = gLaunchAppControlPendingEventMap.insert(this, pendingEvent);
1189                 }
1190
1191                 // give a second chance to launch application to avoid platform issue.
1192                 // this retry code will be removed after platform code change.
1193                 while (retry < 3) {
1194                         ret = service_send_launch_request(service, service_reply_callback, (void *)key);
1195                         if (ret != SERVICE_ERROR_LAUNCH_REJECTED) {
1196                                 break;
1197                         }
1198                         // delay 300ms for each retry
1199                         usleep(300 * 1000);
1200                         retry++;
1201                         LoggerD("retry launch request : " << retry);
1202                 }
1203
1204                 service_destroy(service);
1205
1206                 if(ret != SERVICE_ERROR_NONE)
1207                 {
1208                         switch (ret)
1209                         {
1210                         case SERVICE_ERROR_INVALID_PARAMETER:
1211                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_INVALID_PARAMETER");
1212                                 event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1213                                 break;
1214                         case SERVICE_ERROR_OUT_OF_MEMORY:
1215                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_OUT_OF_MEMORY");
1216                                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1217                                 break;
1218                         case SERVICE_ERROR_LAUNCH_REJECTED:
1219                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_LAUNCH_REJECTED!!!");
1220                                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1221                                 break;
1222                         case SERVICE_ERROR_APP_NOT_FOUND:
1223                                 LoggerE("service_send_launch_request returns SERVICE_ERROR_APP_NOT_FOUND");
1224                                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1225                                 break;
1226                         default:
1227                                 LoggerE("service_send_launch_request returns UNKNOWN ERROR!!!");
1228                                 event->setExceptionCode(Commons::ExceptionCodes::UnknownException);
1229                                 break;
1230                         }
1231
1232                         if(pendingEvent)
1233                         {
1234                                 gLaunchAppControlPendingEventMap.eraseData(key);
1235
1236                                 delete pendingEvent;
1237                                 pendingEvent = NULL;
1238
1239                                 eventReply->cancelRequest();
1240                                 EventRequestReceiver<EventApplicationLaunchAppControlReply>::ManualAnswer(eventReply);
1241                         }
1242                 }
1243         }
1244         Catch (WrtDeviceApis::Commons::Exception)
1245         {
1246                 LoggerE("Error on launchAppControl : " << _rethrown_exception.GetMessage());
1247                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1248         }
1249 }
1250
1251 void ApplicationManager::OnRequestReceived(const EventApplicationLaunchAppControlReplyPtr& event)
1252 {
1253         event->switchToManualAnswer();
1254 }
1255
1256 void ApplicationManager::OnRequestReceived(const EventApplicationFindAppControlPtr& event)
1257 {
1258         Try
1259         {
1260                 ApplicationControlPtr appControl = event->getAppControl();
1261                 if(appControl == NULL)
1262                 {
1263                         LoggerE("appControl is NULL");
1264                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1265                         return;
1266                 }
1267
1268                 std::string operation = appControl->getOperation();
1269                 if(operation.empty())
1270                 {
1271                         LoggerE("operation is madatory");
1272                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1273                         return;
1274                 }
1275
1276                 service_h service;
1277                 service_create(&service);
1278
1279                 service_set_operation(service, operation.c_str() );
1280
1281                 std::string uri = appControl->getUri();
1282                 if (!uri.empty())
1283                 {
1284                         service_set_uri(service, uri.c_str() );
1285                 }
1286
1287                 std::string mime = appControl->getMime();
1288                 if (!mime.empty())
1289                 {
1290                         service_set_mime(service, mime.c_str() );
1291                 }
1292
1293                 std::string category = appControl->getCategory();
1294                 if (!category.empty())
1295                 {
1296                         service_set_category(service, category.c_str() );
1297                 }
1298
1299                 std::vector<ApplicationControlDataPtr> appControlDataArray = appControl->getAppControlDataArray();
1300
1301                 if(!appControlDataArray.empty())
1302                 {
1303                         LoggerD(" data size     : " << appControlDataArray.size());
1304
1305                         ApplicationControlDataArray::iterator iter;
1306                         for(iter = appControlDataArray.begin(); iter != appControlDataArray.end(); iter++)
1307                         {
1308                                 ApplicationControlDataPtr appControlData = *iter;
1309
1310                                 std::string key = appControlData->getKey();
1311
1312                                 if(key.empty())
1313                                 {
1314                                         event->setExceptionCode(Commons::ExceptionCodes::InvalidArgumentException);
1315                                         continue;
1316                                 }
1317
1318                                 std::vector<std::string> valueArray = appControlData->getValue();
1319                                 size_t size = valueArray.size();
1320
1321                                 const char **arr = (const char**)calloc(sizeof(char*), size);
1322
1323                                 for (size_t j = 0; j < size; j++)
1324                                 {
1325                                         arr[j] = valueArray.at(j).c_str();
1326                                 }
1327
1328                                 // @20121207-wscho: roll-back to return extra-data instead of extra-data array when the value size is one.
1329                                 const char *keyCStr = key.c_str();
1330                                 if (size == 1) {
1331                                         service_add_extra_data(service, keyCStr, arr[0]);
1332                                 } else {
1333                                         service_add_extra_data_array(service, keyCStr, arr, size);
1334                                 }
1335
1336                                 if (arr)
1337                                         free(arr);
1338                         }
1339                 }
1340
1341                 ApplicationInformationArrayPtr appInfos(new ApplicationInformationArray());
1342
1343                 int result = service_foreach_app_matched(service, service_app_matched_callback, (void *)appInfos.Get());
1344                 if (result != SERVICE_ERROR_NONE)
1345                 {
1346                         LoggerE("service_foreach_app_matched error (" << result << ")");
1347                         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1348                         service_destroy(service);
1349                         return;
1350                 }
1351
1352                 service_destroy(service);
1353
1354                 event->setAppInfos(appInfos);
1355         }
1356         Catch (WrtDeviceApis::Commons::Exception)
1357         {
1358                 LoggerE("Error on findAppControl : " << _rethrown_exception.GetMessage());
1359                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1360         }
1361 }
1362
1363
1364 void ApplicationManager::OnRequestReceived(const EventApplicationGetAppsContextPtr& event)
1365 {
1366         Try
1367         {
1368                 int ret = 0;
1369
1370                 ApplicationContextArrayPtr appContextArray = event->getAppContextArray();
1371                 ret = app_manager_foreach_app_context(app_manager_app_context_callback, appContextArray.Get());
1372                 if(ret != APP_MANAGER_ERROR_NONE)
1373                 {
1374                         LoggerE("app_manager_foreach_app_context error (" << ret << ")");
1375                         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1376                 }
1377         }
1378         Catch (WrtDeviceApis::Commons::Exception)
1379         {
1380                 LoggerE("Error on  : " << _rethrown_exception.GetMessage());
1381                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1382         }
1383 }
1384
1385
1386
1387 void ApplicationManager::OnRequestReceived(const EventApplicationGetAppsInfoPtr& event)
1388 {
1389         Try
1390         {
1391                 int ret = 0;
1392                 ApplicationInformationArrayPtr appInfoArray = event->getAppInfoArray();
1393                 ret = pkgmgrinfo_appinfo_get_installed_list(installed_app_info_cb, (void*)appInfoArray.Get());
1394                 if (ret != PMINFO_R_OK) {
1395                         LoggerE("Error on getAppsInfo : ");
1396                         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1397                 }
1398         }
1399         Catch (WrtDeviceApis::Commons::Exception)
1400         {
1401                 LoggerE("Error on getAppsInfo : " << _rethrown_exception.GetMessage());
1402                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1403         }
1404 }
1405
1406
1407 void ApplicationManager::OnRequestReceived(const EventApplicationAddAppInfoEventListenerPtr& event)
1408 {
1409         Try
1410         {
1411                 EventApplicationAppInfoEventListenerEmitterPtr emitter = event->getEmitter();
1412
1413                 if(m_installedApplicationsEmitters.size() == 0)
1414                 {
1415                         LoggerD("First time registering event listener to this application object.");
1416
1417                         // Below can throw Exception
1418                         AppManagerWrapperSingleton::Instance().registerAppListChangedCallbacks(this);
1419                 }
1420
1421                 m_installedApplicationsEmitters.attach(emitter);
1422
1423                 long watchId = AppManagerWrapperSingleton::Instance().getWatchIdAndInc();
1424
1425                 m_watchIdMap[watchId] = emitter->getId();
1426
1427                 event->setWatchId(watchId);
1428         }
1429         Catch (WrtDeviceApis::Commons::Exception)
1430         {
1431                 LoggerE("Error on addAppInfoEventListener : " << _rethrown_exception.GetMessage());
1432                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1433         }
1434 }
1435
1436 void ApplicationManager::OnRequestReceived(const EventApplicationRemoveAppInfoEventListenerPtr& event)
1437 {
1438         Try
1439         {
1440                 long watchId = event->getWatchId();
1441
1442                 if(m_watchIdMap.find(watchId) == m_watchIdMap.end()) {
1443                         ThrowMsg(NotFoundException, "No watchId : " << watchId);
1444                 }
1445
1446                 EventApplicationAppInfoEventListenerEmitter::IdType emitterId = m_watchIdMap[watchId];
1447
1448                 bool success = m_installedApplicationsEmitters.detach(emitterId);
1449                 if(!success)
1450                         ThrowMsg(NotFoundException, "No watchId : " << watchId);
1451
1452                 if(m_installedApplicationsEmitters.size() == 0)
1453                 {
1454                         LoggerD("No more event listener on this application object.");
1455
1456                         AppManagerWrapperSingleton::Instance().unregisterAppListChangedCallbacks(this);
1457                 }
1458         }
1459         Catch (WrtDeviceApis::Commons::NotFoundException)
1460         {
1461                 LoggerE("Not found : " << _rethrown_exception.GetMessage());
1462                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1463         }
1464         Catch (WrtDeviceApis::Commons::Exception)
1465         {
1466                 LoggerE("Error on removeAppInfoEventListener : " << _rethrown_exception.GetMessage());
1467                 event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
1468         }
1469 }
1470
1471
1472
1473 void ApplicationManager::onAppManagerEventInstalled(const char *appId)
1474 {
1475         EventApplicationAppInfoEventListenerPtr event(new EventApplicationAppInfoEventListener());
1476
1477         pkgmgrinfo_appinfo_h handle;
1478         int ret = pkgmgrinfo_appinfo_get_appinfo(appId, &handle);
1479         if (ret != PMINFO_R_OK) {
1480                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1481         } else {
1482                 ApplicationInformationPtr appInfo = create_app_info(handle);
1483                 event->setAppInfo(appInfo);
1484                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
1485         }
1486
1487         event->setType(EventApplicationAppInfoEventListener::OnInstalled);
1488         m_installedApplicationsEmitters.emit(event);
1489 }
1490
1491 void ApplicationManager::onAppManagerEventUninstalled(const char *appId)
1492 {
1493         EventApplicationAppInfoEventListenerPtr event(new EventApplicationAppInfoEventListener());
1494
1495         ApplicationInformationPtr appInfo(new ApplicationInformation(appId));
1496
1497         event->setType(EventApplicationAppInfoEventListener::OnUninstalled);
1498         event->setAppInfo(appInfo);
1499         m_installedApplicationsEmitters.emit(event);
1500 }
1501
1502 void ApplicationManager::onAppManagerEventUpdated(const char *appId)
1503 {
1504         EventApplicationAppInfoEventListenerPtr event(new EventApplicationAppInfoEventListener());
1505
1506         pkgmgrinfo_appinfo_h handle;
1507         int ret = pkgmgrinfo_appinfo_get_appinfo(appId, &handle);
1508         if (ret != PMINFO_R_OK) {
1509                 event->setExceptionCode(Commons::ExceptionCodes::NotFoundException);
1510         } else {
1511                 ApplicationInformationPtr appInfo = create_app_info(handle);
1512                 event->setAppInfo(appInfo);
1513                 pkgmgrinfo_appinfo_destroy_appinfo(handle);
1514         }
1515
1516         event->setType(EventApplicationAppInfoEventListener::OnUpdated);
1517         m_installedApplicationsEmitters.emit(event);
1518 }
1519
1520 void ApplicationManager::initialize()
1521 {
1522         if (!m_initialized) {
1523                 DPL::Mutex::ScopedLock lock(&m_initializationMutex);
1524                 if (!m_initialized) {
1525
1526                 }
1527         }
1528 }
1529
1530 }
1531 }