src/app/FApp_AppControlImpl.cpp

   1 //
   2 // Open Service Platform
   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 /**
  19  * @file                FApp_AppControlImpl.cpp
  20  * @brief               This is the implementation for the Application Control class.
  21  */
  22
  23 #include <new>
  24 #include <typeinfo>
  25 #include <unique_ptr.h>
  26
  27 #include <appsvc/appsvc.h>
  28
  29 #include <FAppAppControl.h>
  30 #include <FAppAppManager.h>
  31 #include <FAppPkgPackageAppInfo.h>
  32 #include <FAppIAppControlEventListener.h>
  33 #include <FAppIAppControlResponseListener.h>
  34 #include <FBaseColHashMap.h>
  35 #include <FBaseSysLog.h>
  36
  37 #include <FBaseRt_LibraryImpl.h>
  38 #include <FIo_DirectoryImpl.h>
  39
  40 #include "FApp_AppControlImpl.h"
  41 #include "FApp_AppControlManager.h"
  42 #include "FApp_AppArg.h"
  43 #include "FApp_AppImpl.h"
  44 #include "FApp_AppControlRegistry.h"
  45 #include "FApp_AppMessageImpl.h"
  46 #include "FApp_AppInfo.h"
  47 #include "FAppPkg_PackageManagerImpl.h"
  48 #include "FApp_Aul.h"
  49 #include "FApp_AppControlEventArg.h"
  50 #include "FApp_AppControlResponseEvent.h"
  51 #include "FBaseRt_ThreadImpl.h"
  52
  53 using namespace Tizen::Base;
  54 using namespace Tizen::Base::Collection;
  55 using namespace Tizen::Base::Runtime;
  56 using namespace Tizen::App;
  57 using namespace Tizen::App::Package;
  58 using namespace Tizen::Io;
  59
  60 namespace
  61 {
  62
  63 static const int _REQ_ID_INVALID = -1;
  64
  65 }
  66
  67 namespace Tizen { namespace App
  68 {
  69
  70 const wchar_t TIZEN_OPERATION_MAIN[] = L"http://tizen.org/appcontrol/operation/main";
  71 const char TIZEN_APPCONTROL_DATA_LEGACY[] = "http://tizen.org/appcontrol/data/legacyresult";
  72
  73 _AppControlImpl::_AppControlImpl(const AppControl& value)
  74         : _appControl(value)
  75         , _reqId(_REQ_ID_INVALID)
  76         , _property(_APPCONTROL_PROPERTY_NONE)
  77         , _processId(_REQ_ID_INVALID)
  78 {
  79         __appControlResponseEventList.Construct();
  80 }
  81
  82 _AppControlImpl::~_AppControlImpl(void)
  83 {
  84         IEnumeratorT<int>* pEnum = __appControlResponseEventList.GetEnumeratorN();
  85         IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = null;
  86         if(pEnum != null)
  87         {
  88                 pResponseEventContainer = _AppControlManager::GetInstance()->GetAppControlResponseEventContainer();
  89         }
  90
  91         while(pEnum->MoveNext() == E_SUCCESS)
  92         {
  93                 int reqId;
  94                 pEnum->GetCurrent(reqId);
  95                 if (pResponseEventContainer != null)
  96                 {
  97                         _AppControlResponseEvent* pResponseEvent = null;
  98                         pResponseEventContainer->GetValue(reqId, pResponseEvent);
  99                         delete pResponseEvent;
 100
 101                         pResponseEventContainer->Remove(reqId);
 102                         SysLog(NID_APP, "pResponseEvent gets deleted. reqId(%d)", reqId);
 103                 }
 104         }
 105         delete pEnum;
 106 }
 107
 108 AppControl*
 109 _AppControlImpl::CreateN(const String& path, const String& aId, const String& oId, const String& name, int prop)
 110 {
 111         SysTryReturn(NID_APP, !path.IsEmpty(), null, E_INVALID_ARG, "[E_INVALID_ARG] Path is empty.");
 112         SysTryReturn(NID_APP, !aId.IsEmpty(), null, E_INVALID_ARG, "[E_INVALID_ARG] Provider Id is empty.");
 113         SysTryReturn(NID_APP, !oId.IsEmpty(), null, E_INVALID_ARG, "[E_INVALID_ARG] Operation Id is empty.");
 114
 115         AppControl* pAc = new (std::nothrow) AppControl;
 116         SysTryReturn(NID_APP, pAc != null, null, E_OUT_OF_MEMORY, "AppControl allocation failure.");
 117
 118         _AppControlImpl* pImpl = pAc->__pAppControlImpl;
 119         SysTryReturn(NID_APP, pImpl != null, null, E_OUT_OF_MEMORY, "AppControlImpl instance must not be null.");
 120
 121         pImpl->_path = path;
 122         pImpl->_provider = aId;
 123         pImpl->_opId = oId;
 124         // [FIXME] Proper App name setting
 125         pImpl->_appName = name;
 126         pImpl->_property = prop;
 127
 128         return pAc;
 129 }
 130
 131 AppControl*
 132 _AppControlImpl::CreateN(const AppId& appId, const String& operationId, bool changeAppId)
 133 {
 134         SysTryReturn(NID_APP, !appId.IsEmpty(), null, E_INVALID_ARG, "[E_INVALID_ARG] appId is empty.");
 135
 136         AppControl* pAc = new (std::nothrow) AppControl;
 137         SysTryReturn(NID_APP, pAc != null, null, E_OUT_OF_MEMORY, "AppControl allocation failure.");
 138
 139         _AppControlImpl* pImpl = pAc->__pAppControlImpl;
 140         SysTryReturn(NID_APP, pImpl != null, null, E_OUT_OF_MEMORY, "AppControlImpl instance must not be null.");
 141
 142         pImpl->_path = appId;
 143         pImpl->_provider = appId;
 144         pImpl->_opId = operationId;
 145         //pImpl->_appName = appId;
 146         pImpl->_property |= (_APPCONTROL_PROPERTY_OSP | _APPCONTROL_PROPERTY_PUBLIC);
 147
 148         if (changeAppId)
 149         {
 150                 pImpl->_property |= _APPCONTROL_PROPERTY_APPID_CHANGE;
 151         }
 152
 153         return pAc;
 154 }
 155
 156 AppControl*
 157 _AppControlImpl::CreateN(const AppControl& ac)
 158 {
 159         const _AppControlImpl* pImpl = GetInstance(ac);
 160         SysTryReturn(NID_APP, pImpl != null, null, E_INVALID_STATE, "AppControlImpl instance must not be null.");
 161
 162         return CreateN(pImpl->_path, pImpl->_provider, pImpl->_opId, pImpl->_appName, pImpl->_property);
 163 }
 164
 165 const _AppControlImpl*
 166 _AppControlImpl::GetInstance(const AppControl& ac)
 167 {
 168         return ac.__pAppControlImpl;
 169 }
 170
 171 _AppControlImpl*
 172 _AppControlImpl::GetInstance(AppControl& ac)
 173 {
 174         return ac.__pAppControlImpl;
 175 }
 176
 177 result
 178 _AppControlImpl::Start(const IList* pDataList, IAppControlEventListener* pListener)
 179 {
 180         SysLog(NID_APP, "Enter");
 181         result r = E_SYSTEM;
 182
 183         if (_property & _APPCONTROL_PROPERTY_SLP)
 184         {
 185                 r = StartNative(pDataList, pListener);
 186         }
 187         else if (_property & _APPCONTROL_PROPERTY_OSP)
 188         {
 189                 r = StartOsp(pDataList, pListener);
 190         }
 191         else
 192         {
 193                 SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] Invalid AppControl type(property %d)", _property);
 194         }
 195         SysLog(NID_APP, "Exit");
 196
 197         return r;
 198 }
 199
 200 result
 201 _AppControlImpl::Start(const String* pUriData, const String* pDataType, const IMap* pExtraData, IAppControlResponseListener* pListener)
 202 {
 203         SysLog(NID_APP, "Enter");
 204         result r = E_SYSTEM;
 205
 206         if (_property & _APPCONTROL_PROPERTY_SLP)
 207         {
 208                 r = StartNative(pUriData, pDataType, pExtraData, pListener);
 209         }
 210         else if (_property & _APPCONTROL_PROPERTY_OSP)
 211         {
 212                 r = StartOsp(pUriData, pDataType, pExtraData, pListener);
 213         }
 214         else
 215         {
 216                 SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] Invalid AppControl type(property %d)", _property);
 217         }
 218         SysLog(NID_APP, "Exit");
 219
 220         return r;
 221 }
 222
 223 result
 224 _AppControlImpl::FindAndStart(const String& operationId, const String* pUriPattern, const String* pDataType, const String* pCategory, const IMap* pExtraData, IAppControlResponseListener* pListener)
 225 {
 226         // [FIXME] valid argument size checking required
 227         SysLog(NID_APP, "Enter");
 228
 229         std::unique_ptr<bundle, BundleDeleter> pBundle(bundle_create());
 230         SysTryReturnResult(NID_APP, pBundle.get(), E_OUT_OF_MEMORY, "Bundle creation failure.");
 231
 232         _AppMessageImpl::SetOperation(pBundle.get(), operationId);
 233
 234         if (pUriPattern)
 235         {
 236                 _AppMessageImpl::SetUri(pBundle.get(), *pUriPattern);
 237         }
 238
 239         if (pDataType)
 240         {
 241                 String mimeType = *pDataType;
 242
 243                 if ((*pDataType)[0] == L'.')
 244                 {
 245                         SysLog(NID_APP, "Extension to MIME conversion for %ls", pDataType->GetPointer());
 246
 247 #if 0
 248                         String ext;
 249                         pDataType->SubString(1, ext);
 250
 251                         result r = _AppControlManager::GetMimeFromExt(ext, mimeType);
 252
 253                         SysTryReturn(NID_APP, !IsFailed(r), null, r, "[%s] MIME type conversion failure for %ls.", GetErrorMessage(r), ext.GetPointer());
 254
 255                         pMimeType = &mimeType;
 256
 257                         SysLog(NID_APP, "Conversion : %ls -> %ls.", pDataType->GetPointer(), pMimeType->GetPointer());
 258 #endif
 259                 }
 260
 261                 _AppMessageImpl::SetMime(pBundle.get(), mimeType);
 262         }
 263
 264         if (pCategory)
 265         {
 266                 _AppMessageImpl::SetCategory(pBundle.get(), *pCategory);
 267         }
 268
 269         return StartImplicit(pBundle.get(), pExtraData, pListener);
 270 }
 271
 272 result
 273 _AppControlImpl::StartOsp(const IList* pDataList, IAppControlEventListener* pListener)
 274 {
 275         SysLog(NID_APP, "Enter");
 276         result r = E_SUCCESS;
 277
 278         _AppArg* pArg = new (std::nothrow) _AppArg;
 279         SysTryReturnResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "Argument allocation failure.");
 280
 281         pArg->Construct(*this, pDataList);
 282
 283         _AppControlManager* pImpl = _AppControlManager::GetInstance();
 284         int req = _REQ_ID_INVALID;
 285
 286         if (pListener)
 287         {
 288                 _AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pImpl, pArg, AppControlCbLegacy, pListener, _property);
 289                 req = reqObj.GetRequestNumber();
 290
 291                 _processId = pImpl->Launch(_path, pArg, req);
 292
 293                 if (_processId < 0)
 294                 {
 295                         reqObj.Invalidate();
 296                         r = GetLastResult();
 297                         SysLog(NID_APP, "[%s]Launching(%ls) is failed" , GetErrorMessage(r), _path.GetPointer());
 298                         return r;
 299                 }
 300         }
 301         else
 302         {
 303                 _processId = pImpl->Launch(_path, pArg);
 304                 delete pArg;
 305                 SysTryReturnResult(NID_APP, _processId >= 0, GetLastResult(), "Launching(%ls) is failed", _path.GetPointer());
 306         }
 307         SysLog(NID_APP, "Exit");
 308
 309         return r;
 310 }
 311
 312 result
 313 _AppControlImpl::StartOsp(const String* pUriData, const String* pMimeType, const IMap* pDataList, IAppControlResponseListener* pListener)
 314 {
 315         SysLog(NID_APP, "Enter");
 316         result r = E_SUCCESS;
 317
 318         _AppArg* pArg = new (std::nothrow) _AppArg;
 319         SysTryReturnResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "Argument allocation failure.");
 320
 321         pArg->Construct(*this, pUriData, pMimeType, pDataList);
 322
 323         _AppControlManager* pImpl = _AppControlManager::GetInstance();
 324         int req = _REQ_ID_INVALID;
 325
 326         if (pListener)
 327         {
 328                 _AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pImpl, pArg, AppControlCb, pListener, _property);
 329                 req = reqObj.GetRequestNumber();
 330
 331                 if (_ThreadImpl::GetCurrentThreadImpl()->GetThreadType() == THREAD_TYPE_EVENT_DRIVEN)
 332                 {
 333                         _AppControlResponseEvent* pAppControlResponseEvent = new (std::nothrow) _AppControlResponseEvent();
 334                         if (pAppControlResponseEvent != null)
 335                         {
 336                                 r = pAppControlResponseEvent->Construct();
 337                                 SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::Construct() is failed", GetErrorMessage(r));
 338
 339                                 r = pAppControlResponseEvent->AddListener(*this, true);
 340                                 SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::AddListener() is failed", GetErrorMessage(r));
 341
 342                                 IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = pImpl->GetAppControlResponseEventContainer();
 343                                 if (pResponseEventContainer != null)
 344                                 {
 345                                         pResponseEventContainer->Add(req, pAppControlResponseEvent);
 346                                         __appControlResponseEventList.Add(req);
 347                                         SysLog(NID_APP, "pResponseEvent gets added. reqId(%d)", req);
 348                                 }
 349                         }
 350                 }
 351
 352                 _processId = pImpl->Launch(_path, pArg, req);
 353                 if (_processId < 0)
 354                 {
 355                         reqObj.Invalidate();
 356                         r = GetLastResult();
 357                         SysLog(NID_APP, "[%s]Launching(%ls) is failed" , GetErrorMessage(r), _path.GetPointer());
 358                         return r;
 359                 }
 360         }
 361         else
 362         {
 363                 _processId = pImpl->Launch(_path, pArg);
 364                 delete pArg;
 365                 SysTryReturnResult(NID_APP, _processId >= 0, GetLastResult(), "Launching(%ls) is failed", _path.GetPointer());
 366         }
 367         SysLog(NID_APP, "Exit");
 368
 369         return r;
 370 }
 371
 372 result
 373 _AppControlImpl::StartImplicit(bundle* pBundle, const IList* pDataList, IAppControlEventListener* pListener)
 374 {
 375         SysLog(NID_APP, "Enter");
 376         result r = E_SUCCESS;
 377
 378         _AppArg* pArg = new (std::nothrow) _AppArg;
 379         SysTryReturnResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "Argument allocation failure.");
 380
 381         pArg->Construct(pBundle);
 382
 383         _AppMessageImpl::AddData(pArg->GetBundle(), pDataList);
 384
 385         _AppControlManager* pImpl = _AppControlManager::GetInstance();
 386         int req = _REQ_ID_INVALID;
 387
 388         if (pListener)
 389         {
 390                 _AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pImpl, pArg, AppControlCbLegacy, pListener, _APPCONTROL_PROPERTY_NONE);
 391                 req = reqObj.GetRequestNumber();
 392
 393                 r = pImpl->LaunchAppImplicit(pArg, req);
 394                 SysTryCatch(NID_APP, r == E_SUCCESS, reqObj.Invalidate(), r, "[%s] Propagating." , GetErrorMessage(r));
 395         }
 396         else
 397         {
 398                 r = pImpl->LaunchAppImplicit(pArg, -1);
 399                 delete pArg;
 400         }
 401
 402         // [FIXME] launch registration is not working correctly
 403         SysLog(NID_APP, "Exit");
 404
 405 CATCH:
 406         return r;
 407 }
 408
 409 result
 410 _AppControlImpl::StartImplicit(bundle* pBundle, const IMap* pData, IAppControlResponseListener* pListener)
 411 {
 412         SysLog(NID_APP, "Enter");
 413         result r = E_SUCCESS;
 414
 415         _AppArg* pArg = new (std::nothrow) _AppArg;
 416         SysTryReturnResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "Argument allocation failure.");
 417
 418         pArg->Construct(pBundle);
 419
 420         _AppArg::AddStrMap(pArg->GetBundle(), pData);
 421
 422         _AppControlManager* pImpl = _AppControlManager::GetInstance();
 423         int req = _REQ_ID_INVALID;
 424
 425         if (pListener)
 426         {
 427                 _AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pImpl, pArg, AppControlCb, pListener, _APPCONTROL_PROPERTY_NONE);
 428                 req = reqObj.GetRequestNumber();
 429
 430                 if (_ThreadImpl::GetCurrentThreadImpl()->GetThreadType() == THREAD_TYPE_EVENT_DRIVEN)
 431                 {
 432                         _AppControlResponseEvent* pAppControlResponseEvent = new (std::nothrow) _AppControlResponseEvent();
 433
 434                         if (pAppControlResponseEvent != null)
 435                         {
 436                                 r = pAppControlResponseEvent->Construct();
 437                                 SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::Construct() is failed", GetErrorMessage(r));
 438
 439                                 r = pAppControlResponseEvent->AddListener(*pImpl, true);
 440                                 SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::AddListener() is failed", GetErrorMessage(r));
 441
 442                                 IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = pImpl->GetAppControlResponseEventContainer();
 443                                 if (pResponseEventContainer != null)
 444                                 {
 445                                         pResponseEventContainer->Add(req, pAppControlResponseEvent);
 446                                         SysLog(NID_APP, "pResponseEvent gets added. reqId(%d)", req);
 447                                 }
 448                         }
 449                 }
 450                 r = pImpl->LaunchAppImplicit(pArg, req);
 451                 SysTryCatch(NID_APP, r == E_SUCCESS, reqObj.Invalidate(), r, "[%s] Propagating." , GetErrorMessage(r));
 452         }
 453         else
 454         {
 455                 r = pImpl->LaunchAppImplicit(pArg, -1);
 456                 delete pArg;
 457         }
 458         SysLog(NID_APP, "Exit");
 459
 460         // [FIXME] launch registration is not working correctly
 461
 462 CATCH:
 463
 464         return r;
 465 }
 466
 467 result
 468 _AppControlImpl::AppControlCbLegacy(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId)
 469 {
 470         SysLog(NID_APP, "Result value %d", res);
 471
 472         SysTryReturnResult(NID_APP, data && pResArg && pArg, E_SYSTEM, "Invalid result (callback, result, arg) = (0x%x, 0x%x, 0x%x).",
 473                                           data, pResArg,
 474                                           pArg);
 475
 476         bundle* b = pResArg->GetBundle();
 477         SysTryReturnResult(NID_APP, b != NULL, E_SYSTEM, "Invalid result bundle.");
 478
 479         IAppControlEventListener* pListener = static_cast<IAppControlEventListener*>(data);
 480         SysTryReturnResult(NID_APP, typeid(pListener) == typeid(IAppControlEventListener*), E_SYSTEM, "Invalid result callback");
 481
 482         bundle* inb = pArg->GetBundle();
 483         SysTryReturnResult(NID_APP, inb != NULL, E_SYSTEM, "Empty caller bundle.");
 484
 485         String oId;
 486
 487         AppId provider = pResArg->GetCalleeAppId();
 488
 489         const char* p = appsvc_get_operation(inb);
 490         if (p)
 491         {
 492                 oId = p;
 493         }
 494
 495         SysLog(NID_APP, "Invoking callback with (%ls, %ls)", provider.GetPointer(), oId.GetPointer());
 496
 497         if (prop & _APPCONTROL_PROPERTY_ALIAS)
 498         {
 499                 const _AppControlRegistry::_AppControlAliasEntry* pEntry = null;
 500                 pEntry = _AppControlRegistry::GetInstance()->GetReverseAppControlAliasEntry(provider, oId);
 501                 if (pEntry)
 502                 {
 503                         provider = pEntry->provider;
 504                         oId = pEntry->operation;
 505
 506                         SysLog(NID_APP, "Legacy AppControl name (%ls, %ls).", provider.GetPointer(), oId.GetPointer());
 507                 }
 508         }
 509
 510         if (prop & _APPCONTROL_PROPERTY_APPID_CHANGE)
 511         {
 512                 String tmp = _AppControlRegistry::GetInstance()->GetReverseAliasAppId(provider);
 513                 if (!tmp.IsEmpty())
 514                 {
 515                         SysLog(NID_APP, "AppId change (%ls -> %ls).", provider.GetPointer(), tmp.GetPointer());
 516
 517                         provider = tmp;
 518                 }
 519         }
 520
 521         std::unique_ptr<HashMap> pMap(pResArg->GetArgMapN());
 522
 523         ArrayList list(SingleObjectDeleter);
 524         _AppArg::FillLegacyAppControlResult(list, res, pMap.get(), provider);
 525
 526         // proper callback invokation
 527         pListener->OnAppControlCompleted(provider, oId, &list);
 528
 529         return E_SUCCESS;
 530 }
 531
 532 result
 533 _AppControlImpl::AppControlCb(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId)
 534 {
 535         SysLog(NID_APP, "Result value : %d, property : 0x%x", res, prop);
 536
 537         SysTryReturnResult(NID_APP, data && pResArg && pArg, E_SYSTEM, "Invalid result (callback, result, arg) = (0x%x, 0x%x, 0x%x).",
 538                                           data, pResArg,
 539                                           pArg);
 540
 541         bundle* b = pResArg->GetBundle();
 542         SysTryReturnResult(NID_APP, b != NULL, E_SYSTEM, "Invalid result bundle.");
 543
 544         IAppControlResponseListener* pListener = static_cast<IAppControlResponseListener*>(data);
 545         SysTryReturnResult(NID_APP, typeid(pListener) == typeid(IAppControlResponseListener*), E_SYSTEM, "Invalid result callback");
 546
 547         bundle* inb = pArg->GetBundle();
 548         SysTryReturnResult(NID_APP, inb != NULL, E_SYSTEM, "Empty caller bundle.");
 549
 550         String oId;
 551
 552         AppId provider = pResArg->GetCalleeAppId();
 553
 554         const char* p = appsvc_get_operation(inb);
 555         if (p)
 556         {
 557                 oId = p;
 558         }
 559
 560         SysLog(NID_APP, "Invoking callback with (%ls, %ls)", provider.GetPointer(), oId.GetPointer());
 561
 562         if (prop & _APPCONTROL_PROPERTY_ALIAS)
 563         {
 564                 SysLog(NID_APP, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
 565                 const _AppControlRegistry::_AppControlAliasEntry* pEntry = null;
 566                 pEntry = _AppControlRegistry::GetInstance()->GetReverseRuntimeAliasEntry(provider, oId);
 567                 if (pEntry)
 568                 {
 569                         provider = pEntry->provider;
 570                         oId = pEntry->operation;
 571
 572                         SysLog(NID_APP, "Original AppControl name (%ls, %ls).", provider.GetPointer(), oId.GetPointer());
 573                 }
 574                 SysLog(NID_APP, "CCCCCCCCCCCCCCCCCCCCCCCCCCCCC 0x%x", pEntry);
 575         }
 576
 577         if (prop & _APPCONTROL_PROPERTY_APPID_CHANGE)
 578         {
 579                 String tmp = _AppControlRegistry::GetInstance()->GetReverseAliasAppId(provider);
 580                 if (!tmp.IsEmpty())
 581                 {
 582                         SysLog(NID_APP, "AppId change (%ls -> %ls).", provider.GetPointer(), tmp.GetPointer());
 583
 584                         provider = tmp;
 585                 }
 586         }
 587
 588         std::unique_ptr<HashMap> pMap(pResArg->GetArgMapN());
 589
 590         AppCtrlResult ret = APP_CTRL_RESULT_FAILED;
 591         // to prevent enum overflow;
 592         int resCode = res;
 593         switch(resCode)
 594         {
 595         case SERVICE_RESULT_SUCCEEDED:
 596                 ret = APP_CTRL_RESULT_SUCCEEDED;
 597                 break;
 598         case SERVICE_RESULT_FAILED:
 599                 ret = APP_CTRL_RESULT_CANCELED;
 600                 break;
 601         case SERVICE_RESULT_CANCELED:
 602                 ret = APP_CTRL_RESULT_ABORTED;
 603                 break;
 604         case APPSVC_OSP_RES_FAIL:
 605                 ret = APP_CTRL_RESULT_FAILED;
 606                 break;
 607         case APPSVC_OSP_RES_TERMINATE:
 608                 ret = APP_CTRL_RESULT_TERMINATED;
 609                 break;
 610         default:
 611                 ret = APP_CTRL_RESULT_FAILED;
 612                 break;
 613         }
 614
 615         SysLog(NID_APP, "Result code : 0x%x.", ret);
 616
 617         // proper callback invokation
 618         _AppControlResponseEvent* pResponseEvent = null;
 619         _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->GetValue(reqId, pResponseEvent);
 620
 621         if (pResponseEvent != null)
 622         {
 623                 _AppControlResponseEventArg* pResponseEventArg = new (std::nothrow) _AppControlResponseEventArg(pListener, _APPCONTROL_RESPONSETYPE_COMPLETE, provider, oId, E_SUCCESS, ret, pMap.get(), reqId);
 624                 pResponseEvent->Fire(*pResponseEventArg);
 625                 SysLog(NID_APP, "OnAppControlCompleteResponseReceived, pResponseEvent is Fired");
 626         }
 627         else
 628         {
 629                 pListener->OnAppControlCompleteResponseReceived(provider, oId, ret, pMap.get());
 630                 SysLog(NID_APP, "OnAppControlCompleteResponseReceived, Called");
 631         }
 632
 633         return E_SUCCESS;
 634 }
 635
 636 result
 637 _AppControlImpl::StartNative(const IList* pDataList, IAppControlEventListener* pListener)
 638 {
 639         SysLog(NID_APP, "Enter");
 640         _InProcessInfo* pInfo = _AppControlManager::GetInstance()->__inAppManager.FindItem(_reqId);
 641         SysTryReturnResult(NID_APP, pInfo == null, E_IN_PROGRESS, "Request ID %d is already in progress.", _reqId);
 642
 643         int req = _REQ_ID_INVALID;
 644         _LibraryImpl* pLib = null;
 645
 646         pLib = new (std::nothrow) _LibraryImpl;
 647         SysTryReturnResult(NID_APP, pLib != null, E_OUT_OF_MEMORY, "Failed to allocate libraryimpl.");
 648
 649         unsigned long option = _LIBRARY_LOAD_OPTION_LAZY;
 650         option |= _LIBRARY_LOAD_OPTION_NODELETE;
 651
 652         result r = pLib->Construct(_path, option);
 653         SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating.", GetErrorMessage(r));
 654
 655         if (pListener)
 656         {
 657                 _InProcessInfo* pItem = new (std::nothrow) _InProcessInfo(_provider, _opId, _property, true, *pLib, pListener);
 658                 if (pItem)
 659                 {
 660                         req = _AppControlManager::GetInstance()->__inAppManager.InsertItem(pItem);
 661                 }
 662         }
 663         r = InvokeStartAppControl(*pLib, req, _provider, _opId, pDataList);
 664
 665         if (pListener == null)
 666         {
 667                 delete pLib;
 668         }
 669
 670         // after acquring request number, pLib should be managed from the list, not CATCH
 671         if (IsFailed(r))
 672         {
 673                 SetLastResult(E_SYSTEM);
 674                 _AppControlManager::GetInstance()->__inAppManager.RemoveItem(req);
 675                 SysLog(NID_APP, "[E_SYSTEM] A system error has occurred with %s.", GetErrorMessage(r));
 676
 677                 return E_SYSTEM;
 678         }
 679
 680         _reqId = req;
 681
 682         SysLog(NID_APP, "Exit");
 683         return E_SUCCESS;
 684
 685 CATCH:
 686         delete pLib;
 687
 688         switch (r)
 689         {
 690         case E_LIBRARY_NOT_FOUND:
 691                 r = E_OBJ_NOT_FOUND;
 692                 break;
 693         default:
 694                 r = E_SYSTEM;
 695                 break;
 696         }
 697
 698         return r;
 699 }
 700
 701 result
 702 _AppControlImpl::StartNative(const String* pUriData, const String* pMimeType, const IMap* pDataList, IAppControlResponseListener* pListener)
 703 {
 704         SysLog(NID_APP, "Enter");
 705         _InProcessInfo* pInfo = _AppControlManager::GetInstance()->__inAppManager.FindItem(_reqId);
 706         SysTryReturnResult(NID_APP, pInfo == null, E_IN_PROGRESS, "Request ID %d is already in progress.", _reqId);
 707
 708         int req = _REQ_ID_INVALID;
 709         _LibraryImpl* pLib = null;
 710
 711         pLib = new (std::nothrow) _LibraryImpl;
 712         SysTryReturnResult(NID_APP, pLib != null, E_OUT_OF_MEMORY, "Failed to allocate libraryimpl.");
 713
 714         unsigned long option = _LIBRARY_LOAD_OPTION_LAZY;
 715         option |= _LIBRARY_LOAD_OPTION_NODELETE;
 716
 717         result r = pLib->Construct(_path, option);
 718
 719         SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating.", GetErrorMessage(r));
 720
 721         if (pListener)
 722         {
 723                 _InProcessInfo* pItem = new (std::nothrow) _InProcessInfo(_provider, _opId, _property, false, *pLib, pListener);
 724                 if (pItem)
 725                 {
 726                         req = _AppControlManager::GetInstance()->__inAppManager.InsertItem(pItem);
 727                 }
 728
 729                 if (_ThreadImpl::GetCurrentThreadImpl()->GetThreadType() == THREAD_TYPE_EVENT_DRIVEN)
 730                 {
 731                         _AppControlResponseEvent* pAppControlResponseEvent = new (std::nothrow) _AppControlResponseEvent();
 732
 733                         if (pAppControlResponseEvent != null)
 734                         {
 735                                 r = pAppControlResponseEvent->Construct();
 736                                 SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::Construct() is failed", GetErrorMessage(r));
 737
 738                                 r = pAppControlResponseEvent->AddListener(*this, true);
 739                                 SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::AddListener() is failed", GetErrorMessage(r));
 740
 741                                 IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = _AppControlManager::GetInstance()->GetAppControlResponseEventContainer();
 742                                 if (pResponseEventContainer != null)
 743                                 {
 744                                         int responseEventRequestId = RESPONSE_EVENT_REQID_MAGIC + req;
 745                                         pResponseEventContainer->Add(responseEventRequestId, pAppControlResponseEvent);
 746                                         __appControlResponseEventList.Add(responseEventRequestId);
 747                                         SysLog(NID_APP, "pResponseEvent gets added. reqId(%d)", responseEventRequestId);
 748                                 }
 749                         }
 750                 }
 751         }
 752         r = InvokeStartAppControl(*pLib, req, _provider, _opId, pUriData, pMimeType, pDataList);
 753
 754         if (pListener == null)
 755         {
 756                 delete pLib;
 757         }
 758
 759         // after acquring request number, pLib should be managed from the list, not CATCH
 760         if (IsFailed(r))
 761         {
 762                 SetLastResult(E_SYSTEM);
 763                 _AppControlManager::GetInstance()->__inAppManager.RemoveItem(req);
 764                 SysLog(NID_APP, "[E_SYSTEM] A system error has occurred with %s.", GetErrorMessage(r));
 765
 766                 return E_SYSTEM;
 767         }
 768
 769         _reqId = req;
 770         SysLog(NID_APP, "Exit");
 771
 772         return E_SUCCESS;
 773
 774 CATCH:
 775         delete pLib;
 776
 777         switch (r)
 778         {
 779         case E_LIBRARY_NOT_FOUND:
 780                 r = E_OBJ_NOT_FOUND;
 781                 break;
 782         default:
 783                 r = E_SYSTEM;
 784                 break;
 785         }
 786
 787         return r;
 788 }
 789
 790 result
 791 _AppControlImpl::InvokeStartAppControl(_LibraryImpl& lib, int req, const String& appId, const String& oId, const IList* pList)
 792 {
 793         SysLog(NID_APP, "Legacy stuff for converting argument");
 794
 795         HashMap map(SingleObjectDeleter);
 796         HashMap* pMap = null;
 797         if (pList)
 798         {
 799                 map.Construct();
 800
 801                 _AppArg::FillMapFromList(&map, pList);
 802
 803                 pMap = &map;
 804         }
 805
 806         return InvokeStartAppControl(lib, req, appId, oId, null, null, pMap);
 807 }
 808
 809
 810 result
 811 _AppControlImpl::InvokeStartAppControl(_LibraryImpl& lib, int req, const String& appId, const String& oId, const String* pUri, const String* pMime, const IMap* pMap)
 812 {
 813         result (*pFunc)(int req, const String&, const String&, const String*, const String*, const IMap*) = null;
 814
 815         pFunc =
 816                 reinterpret_cast<result (*)(int, const String&, const String&, const String*, const String*, const IMap*)>(lib.GetProcAddress(L"StartAppControl"));
 817         SysTryReturnResult(NID_APP, pFunc != null, E_OBJ_NOT_FOUND, "Entry \"StartAppControl\" not found for %ls", appId.GetPointer());
 818
 819         const String* pActualUri = (pUri && !(pUri->IsEmpty())) ? pUri : null;
 820         const String* pActualMime = (pMime && !(pMime->IsEmpty())) ? pMime : null;
 821         return (*pFunc)(req, appId, oId, pActualUri, pActualMime, pMap);
 822 }
 823
 824 static bool
 825 IsValidAppControl(const String& appcontrolID)
 826 {
 827         return ((appcontrolID == L"osp.appcontrol.provider.audio")
 828                 || (appcontrolID == L"osp.appcontrol.provider.bluetooth")
 829                 || (appcontrolID == L"osp.appcontrol.provider.calendar")
 830                 || (appcontrolID == L"osp.appcontrol.provider.camera")
 831                 || (appcontrolID == L"osp.appcontrol.provider.contact")
 832                 || (appcontrolID == L"osp.appcontrol.provider.certificatemanager")
 833                 || (appcontrolID == L"osp.appcontrol.provider.email")
 834                 || (appcontrolID == L"osp.appcontrol.provider.image")
 835                 || (appcontrolID == L"osp.appcontrol.provider.media")
 836                 || (appcontrolID == L"osp.appcontrol.provider.message")
 837                 || (appcontrolID == L"osp.appcontrol.provider.video")
 838                 || (appcontrolID == L"osp.appcontrol.provider.imageeditor")
 839                 || (appcontrolID == L"osp.appcontrol.provider.allshare")
 840                 || (appcontrolID == L"tizen.filemanager")
 841                 || (appcontrolID == L"tizen.camera")
 842                 || (appcontrolID == L"tizen.gallery")
 843                 || (appcontrolID == L"tizen.imageviewer")
 844                 || (appcontrolID == L"tizen.videoplayer")
 845                 || (appcontrolID == L"tizen.memo")
 846                 || (appcontrolID == L"tizen.contacts")
 847                 || (appcontrolID == L"tizen.calendar")
 848                 || (appcontrolID == L"tizen.events")
 849                 || (appcontrolID == L"tizen.email")
 850                 || (appcontrolID == L"tizen.settings")
 851                 || (appcontrolID == L"tizen.messages")
 852                 || (appcontrolID == L"tizen.musicplayer")
 853                 || (appcontrolID == L"tizen.bluetooth")
 854                 || (appcontrolID == L"samsung.snote")
 855                 || (appcontrolID == L"0pnxz8hbsr.MyFiles")
 856                 || (appcontrolID == L"hdufar9ycj.Camera")
 857                 || (appcontrolID == L"ijudt7w61q.Gallery")
 858                 || (appcontrolID == L"jysyv9o1dc.ImageViewer")
 859                 || (appcontrolID == L"npwf0scb88.VideoPlayer")
 860                 || (appcontrolID == L"zunqjlsnce.Memo")
 861                 || (appcontrolID == L"f9uev8hsyo.Contacts")
 862                 || (appcontrolID == L"ph1vq2phrp.Calendar")
 863                 || (appcontrolID == L"vxqbrefica.Email")
 864                 || (appcontrolID == L"kto5jikgul.Settings")
 865                 || (appcontrolID == L"8r4r5ddzzn.Messages")
 866                 || (appcontrolID == L"dhrul6qzj3.MusicPlayer")
 867                 || (appcontrolID == L"smemo-efl"));
 868 }
 869
 870 result
 871 _AppControlImpl::Stop(void)
 872 {
 873         const String appcontrolID(GetAppControlProviderId());
 874         SysTryReturnResult(NID_APP, IsValidAppControl(appcontrolID), E_INVALID_OPERATION, "Invalid appcontrolID(%ls)", appcontrolID.GetPointer());
 875
 876         if (_property & _APPCONTROL_PROPERTY_SLP)
 877         {
 878                 SysTryReturnResult(NID_APP, _reqId != _REQ_ID_INVALID, E_INVALID_OPERATION, "Invalid request ID .");
 879
 880                 _InProcessInfo* pInfo = _AppControlManager::GetInstance()->__inAppManager.FindItem(_reqId);
 881                 SysTryReturnResult(NID_APP, pInfo != null, E_INVALID_OPERATION, "Request ID %d is not found.", _reqId);
 882
 883                 result (*pStop)(int req) = null;
 884                 pStop = reinterpret_cast<result (*)(int)>(pInfo->pLib->GetProcAddress(L"TerminateAppControl"));
 885                 SysTryReturnResult(NID_APP, pStop != null, E_SYSTEM, "No TerminateAppControl() function.");
 886
 887                 (*pStop)(_reqId);
 888
 889                 _AppControlManager::GetInstance()->__inAppManager.RemoveItem(_reqId);
 890
 891                 _reqId = _REQ_ID_INVALID;
 892         }
 893         else if (_property & _APPCONTROL_PROPERTY_OSP)
 894         {
 895                 _Aul::TerminateApplicationByPid(_processId);
 896         }
 897
 898         return E_SUCCESS;
 899 }
 900
 901 String
 902 _AppControlImpl::GetAppName(void)
 903 {
 904         if ((_property & _APPCONTROL_PROPERTY_OSP) && _appName.IsEmpty())
 905         {
 906                 const AppId& appId = _path;
 907
 908                 std::unique_ptr<PackageAppInfo> pInfo(_PackageManagerImpl::GetInstance()->GetPackageAppInfoN(appId));
 909
 910                 if (pInfo.get())
 911                 {
 912                         const String& name = pInfo->GetAppName();
 913                         if (name == L"_AppControl")
 914                         {
 915                                 // workaround for special case: requery with actual appId
 916                                 const PackageId& packageId = _PackageManagerImpl::GetPackageIdByAppId(appId);
 917                                 const String& defaultName = _PackageManagerImpl::GetInstance()->GetDefaultAppExecutableName(packageId);
 918
 919                                 const String& convertedAppId = packageId + L'.' + defaultName;
 920
 921                                 std::unique_ptr<PackageAppInfo> pNewInfo(_PackageManagerImpl::GetInstance()->GetPackageAppInfoN(convertedAppId));
 922
 923                                 if (pNewInfo.get())
 924                                 {
 925                                         _appName = pNewInfo->GetAppName();
 926                                 }
 927                                 else
 928                                 {
 929                                         SysLog(NID_APP, "No default applicaiton information, possible database error.");
 930                                 }
 931                         }
 932                         else
 933                         {
 934                                 _appName = pInfo->GetAppName();
 935                         }
 936                         SysLog(NID_APP, "Initializing AppName(%ls) for %ls.", _appName.GetPointer(), appId.GetPointer());
 937                 }
 938         }
 939
 940         return _appName;
 941 }
 942
 943 String
 944 _AppControlImpl::GetAppId(void) const
 945 {
 946         return (_property & _APPCONTROL_PROPERTY_OSP) ? _path : _provider;
 947 }
 948
 949 const String&
 950 _AppControlImpl::GetAppControlProviderId(void) const
 951 {
 952         return _provider;
 953 }
 954
 955 const String&
 956 _AppControlImpl::GetOperationId(void) const
 957 {
 958         return _opId;
 959 }
 960
 961 IList*
 962 _AppControlImpl::GetCategoryListN(void) const
 963 {
 964         const AppId& appId = GetAppId();
 965         SysTryReturn(NID_APP, !appId.IsEmpty(), null, E_SYSTEM, "[E_SYSTEM] Empty appId.");
 966
 967         SysLog(NID_APP, "Acquiring category for appId %ls.", appId.GetPointer());
 968
 969         std::unique_ptr<PackageAppInfo> pAppInfo(_PackageManagerImpl::GetInstance()->GetPackageAppInfoN(appId));
 970         SysTryReturn(NID_APP, pAppInfo.get() != null, null, E_SYSTEM, "[E_SYSTEM] Getting PackageAppInfo failed.");
 971
 972         return pAppInfo->GetAppCategoryListN();
 973 }
 974
 975 void
 976 _AppControlImpl::StopAppControlResponseListener(IAppControlResponseListener* pListener)
 977 {
 978         _AppControlManager::GetInstance()->__listenerList.Add(pListener);
 979 }
 980
 981 void
 982 _AppControlImpl::OnAppControlResponseEventReceivedN(const Tizen::Base::Runtime::IEventArg* arg)
 983 {
 984         const _AppControlResponseEventArg* pEventArg = dynamic_cast<const _AppControlResponseEventArg*>(arg);
 985
 986         if (pEventArg != null)
 987         {
 988                 IAppControlResponseListener* pResponseListener = pEventArg->GetListener();
 989
 990                 if(pResponseListener != null)
 991                 {
 992                         if(pEventArg->GetType() == _APPCONTROL_RESPONSETYPE_COMPLETE)
 993                         {
 994                                 pResponseListener->OnAppControlCompleteResponseReceived(pEventArg->GetAppId(), pEventArg->GetOperationId(), pEventArg->GetAppControlResult(), pEventArg->GetExtraData());
 995                                 SysLog(NID_APP, "OnAppControlCompleteResponseReceived called");
 996
 997                                 _AppControlResponseEvent* pResponseEvent = null;
 998                                 _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->GetValue(pEventArg->GetRequestId(), pResponseEvent);
 999                                 _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->Remove(pEventArg->GetRequestId());
1000                                 delete pResponseEvent;
1001                                 SysLog(NID_APP, "pResponseEvent gets deleted, reqId(%d)", pEventArg->GetRequestId());
1002                         }
1003                         else
1004                         {
1005                                 SysLog(NID_APP, "Unexpected AppControlResponseType(%d)", pEventArg->GetType());
1006                         }
1007                 }
1008                 else
1009                 {
1010                         SysLog(NID_APP, "Invalid ResponseListener");
1011                 }
1012         }
1013         else
1014         {
1015                 SysLog(NID_APP, "Invalid AppControl arguments : arg(0x%x)", &arg);
1016         }
1017
1018 }
1019 }}    //Tizen::App