src/Application/JSApplicationManager.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
  19 //#include <memory>
  20
  21 #include <CommonsJavaScript/Converter.h>
  22
  23 //#include <CommonsJavaScript/Validator.h>
  24 #include <CommonsJavaScript/JSUtils.h>
  25
  26 #include <CommonsJavaScript/JSCallbackManager.h>
  27 #include <CommonsJavaScript/Utils.h>
  28 #include <CommonsJavaScript/ScopedJSStringRef.h>
  29
  30 #include <ArgumentValidator.h>
  31 #include <JSUtil.h>
  32
  33 #include <SecurityExceptions.h>
  34 //#include <Commons/Exception.h>
  35 #include <JSWebAPIErrorFactory.h>
  36
  37 #include "ApplicationFactory.h"
  38 #include "plugin_config.h"
  39 #include "ApplicationController.h"
  40 #include "JSApplicationManager.h"
  41 #include "ApplicationConverter.h"
  42 #include "ApplicationUtil.h"
  43 #include "JSApplicationControl.h"
  44 #include "ApplicationAsyncCallbackManager.h"
  45 #include "ApplicationListenerManager.h"
  46 #include "ApplicationInformationEventPrivateData.h"
  47 #include "JSApplicationEventCallbackManager.h"
  48 #include "JSApplication.h"
  49 #include "ApplicationManager.h"
  50
  51 #include <TimeTracer.h>
  52 #include <Export.h>
  53 #include <Logger.h>
  54
  55 #include <plugins-ipc-message/ipc_message_support.h>
  56
  57 namespace DeviceAPI {
  58 namespace Application {
  59
  60 using namespace DeviceAPI::Common;
  61
  62 using namespace WrtDeviceApis::Commons;
  63 using namespace WrtDeviceApis::CommonsJavaScript;
  64
  65 JSClassRef JSApplicationManager::m_jsClassRef = NULL;
  66
  67 JSClassDefinition JSApplicationManager::m_classInfo = {
  68                 0,
  69                 kJSClassAttributeNone,
  70                 TIZEN_INTERFACE_APPLICATION_MANAGER,
  71                 NULL,
  72                 NULL,
  73                 m_function,
  74                 initialize,
  75                 finalize,
  76                 NULL, //hasProperty,
  77                 NULL, //getProperty,
  78                 NULL, //setProperty,
  79                 NULL, //deleteProperty,
  80                 NULL, //getPropertyNames,
  81                 NULL,
  82                 NULL,
  83                 NULL,
  84                 NULL
  85 };
  86
  87 JSStaticFunction JSApplicationManager::m_function[] = {
  88                 { APPLICATION_FUNCTION_API_GET_CURRENT_APP, JSApplicationManager::getCurrentApplication, kJSPropertyAttributeNone },
  89                 { APPLICATION_FUNCTION_API_LAUNCH, JSApplicationManager::launch, kJSPropertyAttributeNone },
  90                 { APPLICATION_FUNCTION_API_KILL, JSApplicationManager::kill, kJSPropertyAttributeNone },
  91                 { APPLICATION_FUNCTION_API_SET_USER_AGENT, JSApplicationManager::setUserAgent, kJSPropertyAttributeNone },
  92                 { APPLICATION_FUNCTION_API_GET_APPS_INFO, JSApplicationManager::getAppsInfo, kJSPropertyAttributeNone },
  93                 { APPLICATION_FUNCTION_API_GET_APPS_CONTEXT, JSApplicationManager::getAppsContext, kJSPropertyAttributeNone },
  94                 { APPLICATION_FUNCTION_API_GET_APP_INFO, JSApplicationManager::getAppInfo, kJSPropertyAttributeNone },
  95                 { APPLICATION_FUNCTION_API_GET_APP_CONTEXT, JSApplicationManager::getAppContext, kJSPropertyAttributeNone },
  96                 { APPLICATION_FUNCTION_API_ADD_APP_INFO_EVENT_LISTENER, JSApplicationManager::addAppInfoEventListener, kJSPropertyAttributeNone },
  97                 { APPLICATION_FUNCTION_API_REMOVE_APP_INFO_EVENT_LISTENER, JSApplicationManager::removeAppInfoEventListener, kJSPropertyAttributeNone },
  98                 { APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL, JSApplicationManager::launchAppControl, kJSPropertyAttributeNone },
  99                 { APPLICATION_FUNCTION_API_FIND_APP_CONTROL, JSApplicationManager::findAppControl, kJSPropertyAttributeNone },
 100                 { APPLICATION_FUNCTION_API_GET_APP_CERTS, JSApplicationManager::getAppCerts, kJSPropertyAttributeNone },
 101                 { APPLICATION_FUNCTION_API_GET_APP_SHARED_URI, JSApplicationManager::getAppSharedURI, kJSPropertyAttributeNone },
 102                 { APPLICATION_FUNCTION_API_GET_APP_META_DATA, JSApplicationManager::getAppMetaData, kJSPropertyAttributeNone },
 103                 { 0, 0, 0 }
 104 };
 105
 106 const JSClassRef DLL_EXPORT JSApplicationManager::getClassRef()
 107 {
 108         if (!m_jsClassRef) {
 109                 m_jsClassRef = JSClassCreate(&m_classInfo);
 110         }
 111
 112         return m_jsClassRef;
 113 }
 114
 115 const JSClassDefinition* JSApplicationManager::getClassInfo()
 116 {
 117         return &m_classInfo;
 118 }
 119
 120 void JSApplicationManager::initialize(JSContextRef context, JSObjectRef object)
 121 {
 122         ApplicationController* priv = static_cast<ApplicationController*>(JSObjectGetPrivate(object));
 123
 124         if (!priv) {
 125                 IApplicationManagerPtr applications(ApplicationFactory::getInstance().createApplication());
 126                 priv = new ApplicationController(context, applications);
 127
 128                 if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
 129                         delete priv;
 130                 }
 131         } else {
 132                 LoggerD("private date is already exist");
 133         }
 134 }
 135
 136 void JSApplicationManager::finalize(JSObjectRef object)
 137 {
 138         ApplicationController* priv = static_cast<ApplicationController*> (JSObjectGetPrivate(object));
 139         JSObjectSetPrivate(object, NULL);
 140         delete priv;
 141 }
 142
 143 JSValueRef JSApplicationManager::getCurrentApplication(JSContextRef context,
 144         JSObjectRef object,
 145         JSObjectRef thisObject,
 146         size_t argumentCount,
 147         const JSValueRef arguments[],
 148         JSValueRef* exception)
 149 {
 150         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 151
 152         try {
 153                 ApplicationController *controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 154                 if (!controller) {
 155                         throw TypeMismatchException("No private object.");
 156                 }
 157                 JSContextRef gContext = controller->getContext();
 158
 159                 ApplicationPtr result = ApplicationManager::getCurrentApplication();
 160
 161                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 162                 return JSApplication::makeObject(gContext, result);
 163
 164         } catch (...) {
 165                 DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getCurrentApplication().");
 166                 return JSWebAPIErrorFactory::postException(context, exception, err);
 167         }
 168 }
 169
 170
 171 JSValueRef JSApplicationManager::launch(JSContextRef context,
 172         JSObjectRef object,
 173         JSObjectRef thisObject,
 174         size_t argumentCount,
 175         const JSValueRef arguments[],
 176         JSValueRef* exception)
 177 {
 178         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 179         TIME_TRACER_ITEM_BEGIN("launch(async)", 0);
 180
 181         TIME_TRACER_ITEM_BEGIN("launch(ACE)", 0);
 182         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_LAUNCH);
 183         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 184         TIME_TRACER_ITEM_END("launch(ACE)", 0);
 185
 186         try {
 187                 IApplicationManagerPtr appmgr;
 188                 JSContextRef gContext;
 189                 ApplicationController *controller;
 190
 191                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 192                 if (!controller) {
 193                         throw TypeMismatchException("No private object.");
 194                 }
 195                 appmgr = controller->getObject();
 196                 gContext = controller->getContext();
 197
 198                 EventApplicationLaunchPtr event(new EventApplicationLaunch());
 199                 JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 200
 201                 ArgumentValidator validator(context, argumentCount, arguments);
 202
 203                 // id
 204                 std::string id = validator.toString(0);
 205                 event->setAppId(id);
 206
 207                 IPCMessageSupport::sendAsyncMessageToUiProcess(IPCMessageSupport::TIZEN_LAUNCH, NULL, NULL, NULL);
 208
 209                 // successCallback
 210                 JSObjectRef successCallback = validator.toFunction(1, true);
 211                 if (successCallback)
 212                         callbackManager->setOnSuccess(successCallback);
 213
 214                 // errorCallback
 215                 JSObjectRef errorCallback = validator.toFunction(2, true);
 216                 if (errorCallback)
 217                         callbackManager->setOnError(errorCallback);
 218
 219         callbackManager->setObject(thisObject);
 220                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 221
 222                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 223                 event->setForAsynchronousCall(controller);
 224
 225                 appmgr->launch(event);
 226                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 227                 return JSValueMakeUndefined(context);
 228
 229         } catch (const BasePlatformException &err) {
 230         return JSWebAPIErrorFactory::postException(context, exception, err);
 231     } catch (...) {
 232         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.launch().");
 233         return JSWebAPIErrorFactory::postException(context, exception, err);
 234     }
 235 }
 236
 237 JSValueRef JSApplicationManager::kill(JSContextRef context,
 238         JSObjectRef object,
 239         JSObjectRef thisObject,
 240         size_t argumentCount,
 241         const JSValueRef arguments[],
 242         JSValueRef* exception)
 243 {
 244         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 245         TIME_TRACER_ITEM_BEGIN("kill(async)", 0);
 246
 247         TIME_TRACER_ITEM_BEGIN("kill(ACE)", 0);
 248         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_KILL);
 249         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 250         TIME_TRACER_ITEM_END("kill(ACE)", 0);
 251
 252         try {
 253                 IApplicationManagerPtr appmgr;
 254                 JSContextRef gContext;
 255                 ApplicationController *controller;
 256
 257                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 258                 if (!controller) {
 259                         throw TypeMismatchException("No private object.");
 260                 }
 261                 appmgr = controller->getObject();
 262                 gContext = controller->getContext();
 263
 264                 EventApplicationKillPtr event(new EventApplicationKill());
 265                 JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 266         ArgumentValidator validator(context, argumentCount, arguments);
 267
 268         // contextId
 269        std::string contextId = validator.toString(0);
 270                 event->setContextId(contextId);
 271
 272                 // successCallback
 273                 JSObjectRef successCallback = validator.toFunction(1, true);
 274                 if (successCallback)
 275                         callbackManager->setOnSuccess(successCallback);
 276
 277                 // errorCallback
 278                 JSObjectRef errorCallback = validator.toFunction(2, true);
 279                 if (errorCallback)
 280                         callbackManager->setOnError(errorCallback);
 281
 282         callbackManager->setObject(thisObject);
 283                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 284
 285                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 286                 event->setForAsynchronousCall(controller);
 287
 288                 appmgr->kill(event);
 289                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 290                 return JSValueMakeUndefined(context);
 291
 292         } catch (const BasePlatformException &err) {
 293         return JSWebAPIErrorFactory::postException(context, exception, err);
 294     } catch (...) {
 295         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.kill().");
 296         return JSWebAPIErrorFactory::postException(context, exception, err);
 297     }
 298 }
 299
 300
 301 JSValueRef JSApplicationManager::setUserAgent(JSContextRef context,
 302         JSObjectRef object,
 303         JSObjectRef thisObject,
 304         size_t argumentCount,
 305         const JSValueRef arguments[],
 306         JSValueRef* exception)
 307 {
 308         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 309
 310         try {
 311                 ArgumentValidator validator(context, argumentCount, arguments);
 312
 313         // UserAgent
 314         std::string userAgent = validator.toString(0);
 315
 316                 // perform
 317                 IPCMessageSupport::sendAsyncMessageToUiProcess(IPCMessageSupport::TIZEN_CHANGE_USERAGENT, userAgent.c_str(), NULL, NULL);
 318
 319                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 320                 return JSValueMakeUndefined(context);
 321
 322         } catch (const BasePlatformException &err) {
 323         return JSWebAPIErrorFactory::postException(context, exception, err);
 324     } catch (...) {
 325         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.removeAppInfoEventListener().");
 326         return JSWebAPIErrorFactory::postException(context, exception, err);
 327     }
 328 }
 329
 330
 331 JSValueRef JSApplicationManager::launchAppControl(JSContextRef context,
 332         JSObjectRef object,
 333         JSObjectRef thisObject,
 334         size_t argumentCount,
 335         const JSValueRef arguments[],
 336         JSValueRef* exception)
 337 {
 338         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 339         TIME_TRACER_ITEM_BEGIN("launchAppControlReply", 0);
 340         TIME_TRACER_ITEM_BEGIN("launchAppControl(async)", 0);
 341         TIME_TRACER_ITEM_BEGIN("launchAppControlReply(async)", 0);
 342
 343         TIME_TRACER_ITEM_BEGIN("launchAppControl(ACE)", 0);
 344         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL);
 345         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 346         TIME_TRACER_ITEM_END("launchAppControl(ACE)", 0);
 347
 348         try {
 349                 IApplicationManagerPtr appmgr;
 350                 JSContextRef gContext;
 351                 ApplicationController *controller;
 352
 353                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 354                 if (!controller) {
 355                         throw TypeMismatchException("No private object.");
 356                 }
 357                 appmgr = controller->getObject();
 358                 gContext = controller->getContext();
 359
 360
 361                 EventApplicationLaunchAppControlPtr event(new EventApplicationLaunchAppControl());
 362             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 363                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 364
 365                 ArgumentValidator validator(context, argumentCount, arguments);
 366
 367         // appControl
 368         JSObjectRef appControlObj = validator.toObject(0);
 369                 ApplicationControlPtr appControl = converter->toApplicationControl(appControlObj);
 370         if (!appControl) {
 371             throw TypeMismatchException("ApplicationControl's private object is NULL.");
 372         }
 373                 event->setAppControl(appControl);
 374
 375         // id
 376         std::string id = validator.toString(1, true, "");
 377                 event->setAppId(id);
 378
 379                 // successCallback
 380                 JSObjectRef successCallback = validator.toFunction(2, true);
 381                 if (successCallback)
 382                         callbackManager->setOnSuccess(successCallback);
 383
 384                 // errorCallback
 385                 JSObjectRef errorCallback = validator.toFunction(3, true);
 386                 if (errorCallback)
 387                         callbackManager->setOnError(errorCallback);
 388
 389                 callbackManager->setObject(thisObject);
 390                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 391
 392                 // replyCallback
 393                 JSCallbackManagerPtr callbackManagerReply;
 394                 JSObjectRef replyCallbackObj = validator.toCallbackObject(4, true, "onsuccess", "onfailure", NULL);
 395
 396                 if (replyCallbackObj) {
 397                         callbackManagerReply = JSCallbackManager::createObject(gContext);
 398
 399                         // onsuccess
 400                         JSValueRef onsuccess = JSUtil::getProperty(context, replyCallbackObj, "onsuccess", exception);
 401                         if (!JSValueIsUndefined(context, onsuccess)) {
 402                                 callbackManagerReply->setOnSuccess(onsuccess);
 403                         }
 404
 405                         // onfailure
 406                         JSValueRef onfailure = JSUtil::getProperty(context, replyCallbackObj, "onfailure", exception);
 407                         if (!JSValueIsUndefined(context, onfailure)) {
 408                                 callbackManagerReply->setOnError(onfailure);
 409                         }
 410
 411                         callbackManagerReply->setObject(thisObject);
 412                         ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManagerReply, gContext);
 413
 414                         EventApplicationLaunchAppControlReplyPtr eventReply(new EventApplicationLaunchAppControlReply());
 415                         eventReply->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManagerReply));
 416                         eventReply->setForAsynchronousCall(controller);
 417
 418                         event->setEventReply(eventReply);
 419                 }
 420
 421                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 422                 event->setForAsynchronousCall(controller);
 423
 424                 appmgr->launchAppControl(event);
 425
 426                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 427                 TIME_TRACER_ITEM_END("launchAppControlReply", 0);
 428                 return JSValueMakeUndefined(context);
 429         } catch (const BasePlatformException &err) {
 430         return JSWebAPIErrorFactory::postException(context, exception, err);
 431     } catch (...) {
 432         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.launchAppControl().");
 433         return JSWebAPIErrorFactory::postException(context, exception, err);
 434     }
 435
 436 }
 437
 438
 439 JSValueRef JSApplicationManager::findAppControl(JSContextRef context,
 440         JSObjectRef object,
 441         JSObjectRef thisObject,
 442         size_t argumentCount,
 443         const JSValueRef arguments[],
 444         JSValueRef* exception)
 445 {
 446         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 447         TIME_TRACER_ITEM_BEGIN("findAppControl(async)", 0);
 448         try {
 449
 450                 IApplicationManagerPtr appmgr;
 451                 JSContextRef gContext;
 452                 ApplicationController *controller;
 453
 454                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 455                 if (!controller) {
 456                         throw TypeMismatchException("No private object.");
 457                 }
 458                 appmgr = controller->getObject();
 459                 gContext = controller->getContext();
 460
 461         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 462         EventApplicationFindAppControlPtr event(new EventApplicationFindAppControl());
 463             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 464
 465                 ArgumentValidator validator(context, argumentCount, arguments);
 466
 467         // appControl
 468         JSObjectRef appControlObj = validator.toObject(0);
 469
 470         ApplicationControlPtr appControl = converter->toApplicationControl(appControlObj);
 471         if (!appControl) {
 472             throw TypeMismatchException("ApplicationControl's private object is NULL.");
 473         }
 474                 event->setAppControl(appControl);
 475
 476         // successCallback
 477         JSObjectRef successCallbackObj = validator.toFunction(1);
 478         if (successCallbackObj) {
 479             callbackManager->setOnSuccess(successCallbackObj);
 480         }
 481
 482         // errorCallback
 483         JSObjectRef errorCallback = validator.toFunction(2, true);
 484                 if (errorCallback) {
 485                         callbackManager->setOnError(errorCallback);
 486                 }
 487
 488         callbackManager->setObject(thisObject);
 489                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 490
 491                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 492                 event->setForAsynchronousCall(controller);
 493
 494                 appmgr->findAppControl(event);
 495                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 496                 return JSValueMakeUndefined(context);
 497
 498         } catch (const BasePlatformException &err) {
 499         return JSWebAPIErrorFactory::postException(context, exception, err);
 500     } catch (...) {
 501         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.findAppControl().");
 502         return JSWebAPIErrorFactory::postException(context, exception, err);
 503     }
 504 }
 505
 506
 507 JSValueRef JSApplicationManager::getAppsContext(JSContextRef context,
 508         JSObjectRef object,
 509         JSObjectRef thisObject,
 510         size_t argumentCount,
 511         const JSValueRef arguments[],
 512         JSValueRef* exception)
 513 {
 514         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 515         TIME_TRACER_ITEM_BEGIN("getAppsContext(async)", 0);
 516
 517         try {
 518                 IApplicationManagerPtr appmgr;
 519                 JSContextRef gContext;
 520                 ApplicationController *controller;
 521
 522                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 523                 if (!controller) {
 524                         throw TypeMismatchException("No private object.");
 525                 }
 526                 appmgr = controller->getObject();
 527                 gContext = controller->getContext();
 528
 529                 EventApplicationGetAppsContextPtr event(new EventApplicationGetAppsContext());
 530             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 531
 532         ArgumentValidator validator(context, argumentCount, arguments);
 533
 534         // successCallback
 535         JSObjectRef successCallbackObj = validator.toFunction(0);
 536                 callbackManager->setOnSuccess(successCallbackObj);
 537
 538         // errorCallback
 539         JSObjectRef errorCallbackObj = validator.toFunction(1, true);
 540                 if (errorCallbackObj)
 541                         callbackManager->setOnError(errorCallbackObj);
 542
 543         callbackManager->setObject(thisObject);
 544                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 545
 546                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 547                 event->setForAsynchronousCall(controller);
 548
 549                 appmgr->getAppsContext(event);
 550                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 551                 return JSValueMakeUndefined(context);
 552
 553         } catch (const BasePlatformException &err) {
 554                 LoggerE("BasePlatformException");
 555         return JSWebAPIErrorFactory::postException(context, exception, err);
 556     } catch (...) {
 557             LoggerE("etc...");
 558         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppsContext().");
 559         return JSWebAPIErrorFactory::postException(context, exception, err);
 560     }
 561 }
 562
 563
 564 JSValueRef JSApplicationManager::getAppContext(JSContextRef context,
 565         JSObjectRef object,
 566         JSObjectRef thisObject,
 567         size_t argumentCount,
 568         const JSValueRef arguments[],
 569         JSValueRef* exception)
 570 {
 571         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 572
 573         try {
 574                 ArgumentValidator validator(context, argumentCount, arguments);
 575
 576                 ApplicationContextPtr result = ApplicationManager::getAppContext(validator.toString(0, true, ""));
 577                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 578
 579                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 580                 return converter->toJSValueRefFromApplicationContext(result);
 581
 582         } catch (const BasePlatformException &err) {
 583         return JSWebAPIErrorFactory::postException(context, exception, err);
 584     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 585            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 586         } catch (...) {
 587         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppContext().");
 588         return JSWebAPIErrorFactory::postException(context, exception, err);
 589     }
 590 }
 591
 592
 593 JSValueRef JSApplicationManager::getAppsInfo(JSContextRef context,
 594         JSObjectRef object,
 595         JSObjectRef thisObject,
 596         size_t argumentCount,
 597         const JSValueRef arguments[],
 598         JSValueRef* exception)
 599 {
 600         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 601         TIME_TRACER_ITEM_BEGIN("getAppsInfo(async)", 0);
 602
 603         try {
 604                 IApplicationManagerPtr appmgr;
 605                 JSContextRef gContext;
 606                 ApplicationController *controller;
 607
 608                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 609                 if (!controller) {
 610                         throw TypeMismatchException("No private object.");
 611                 }
 612                 appmgr = controller->getObject();
 613                 gContext = controller->getContext();
 614
 615                 EventApplicationGetAppsInfoPtr event(new EventApplicationGetAppsInfo());
 616             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 617
 618         ArgumentValidator validator(context, argumentCount, arguments);
 619
 620         // successCallback
 621         JSObjectRef successCallbackObj = validator.toFunction(0);
 622                 callbackManager->setOnSuccess(successCallbackObj);
 623
 624         // errorCallback
 625         JSObjectRef errorCallbackObj = validator.toFunction(1, true);
 626                 if (errorCallbackObj) {
 627                         callbackManager->setOnError(errorCallbackObj);
 628                 }
 629
 630                 callbackManager->setObject(thisObject);
 631                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 632
 633                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 634                 event->setForAsynchronousCall(controller);
 635
 636                 appmgr->getAppsInfo(event);
 637                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 638                 return JSValueMakeUndefined(context);
 639
 640         } catch (const BasePlatformException &err) {
 641         return JSWebAPIErrorFactory::postException(context, exception, err);
 642     } catch (...) {
 643         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppsInfo().");
 644         return JSWebAPIErrorFactory::postException(context, exception, err);
 645     }
 646 }
 647
 648
 649 JSValueRef JSApplicationManager::getAppInfo(JSContextRef context,
 650         JSObjectRef object,
 651         JSObjectRef thisObject,
 652         size_t argumentCount,
 653         const JSValueRef arguments[],
 654         JSValueRef* exception)
 655 {
 656         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 657
 658         try {
 659                 ApplicationController *controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 660                 if (!controller) {
 661                         throw TypeMismatchException("No private object.");
 662                 }
 663                 JSContextRef gContext = controller->getContext();
 664
 665                 ArgumentValidator validator(context, argumentCount, arguments);
 666
 667                 ApplicationInformationPtr result = ApplicationManager::getAppInfo(validator.toString(0, true, ""));
 668                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(gContext);
 669
 670                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 671                 return converter->toJSValueRefFromApplicationInformation(result);
 672
 673     } catch (const BasePlatformException &err) {
 674         return JSWebAPIErrorFactory::postException(context, exception, err);
 675     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 676            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 677         } catch (...) {
 678         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppInfo().");
 679         return JSWebAPIErrorFactory::postException(context, exception, err);
 680     }
 681 }
 682
 683 JSValueRef JSApplicationManager::addAppInfoEventListener(JSContextRef context,
 684         JSObjectRef object,
 685         JSObjectRef thisObject,
 686         size_t argumentCount,
 687         const JSValueRef arguments[],
 688         JSValueRef* exception)
 689 {
 690         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 691
 692         try {
 693                 IApplicationManagerPtr appmgr;
 694                 JSContextRef gContext;
 695                 ApplicationController *controller;
 696
 697                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 698                 if (!controller) {
 699                         throw TypeMismatchException("No private object.");
 700                 }
 701                 appmgr = controller->getObject();
 702                 gContext = controller->getContext();
 703
 704                 EventApplicationAddAppInfoEventListenerPtr event(new EventApplicationAddAppInfoEventListener());
 705
 706         ArgumentValidator validator(context, argumentCount, arguments);
 707
 708                 // eventCallback
 709                 JSObjectRef eventCBObj = validator.toCallbackObject(0, false, "oninstalled", "onupdated", "onuninstalled", NULL);
 710                 JSApplicationEventCallbackManagerPtr callbackManager = JSApplicationEventCallbackManager::createObject(gContext);
 711
 712                 JSValueRef oninstalled = JSUtil::getProperty(context, eventCBObj, "oninstalled", exception);
 713                 if (!JSValueIsUndefined(context, oninstalled)) {
 714                         callbackManager->setOnInstalled(oninstalled);
 715                 }
 716
 717                 JSValueRef onupdated = JSUtil::getProperty(context, eventCBObj, "onupdated", exception);
 718                 if (!JSValueIsUndefined(context, onupdated)) {
 719                         callbackManager->setOnUpdated(onupdated);
 720                 }
 721
 722                 JSValueRef onuninstalled = JSUtil::getProperty(context, eventCBObj, "onuninstalled", exception);
 723                 if (!JSValueIsUndefined(context, onuninstalled)) {
 724                         callbackManager->setOnUninstalled(onuninstalled);
 725                 }
 726
 727                 EventApplicationAppInfoEventListenerEmitterPtr emitter(new EventApplicationAppInfoEventListenerEmitter());
 728
 729                 emitter->setEventPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 730                 emitter->setListener(controller);
 731
 732         event->setEmitter(emitter);
 733                 event->setForSynchronousCall();
 734
 735                 appmgr->addAppInfoEventListener(event);
 736
 737                 if (event->getExceptionCode() != ExceptionCodes::None) {
 738                         throw UnknownException("Unknown Exception Occured");
 739                 }
 740
 741                 unsigned long id = event->getWatchId();
 742
 743                 ApplicationListenerCancellerPtr canceller = ApplicationListenerCancellerPtr(new ApplicationListenerCanceller(gContext, thisObject, id));
 744                 DeviceAPI::Common::IListenerItemPtr listenerItem = DPL::StaticPointerCast<DeviceAPI::Common::IListenerItem>(canceller);
 745                 ApplicationListenerManagerSingleton::Instance().registerListener(listenerItem, gContext);
 746
 747                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 748                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 749                 return converter->toJSValueRef(id);
 750
 751         } catch (const BasePlatformException &err) {
 752         return JSWebAPIErrorFactory::postException(context, exception, err);
 753     } catch (...) {
 754         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.addAppInfoEventListener().");
 755         return JSWebAPIErrorFactory::postException(context, exception, err);
 756     }
 757 }
 758
 759 JSValueRef JSApplicationManager::removeAppInfoEventListener(JSContextRef context,
 760         JSObjectRef object,
 761         JSObjectRef thisObject,
 762         size_t argumentCount,
 763         const JSValueRef arguments[],
 764         JSValueRef* exception)
 765 {
 766         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 767
 768         try {
 769                 IApplicationManagerPtr appmgr;
 770                 JSContextRef gContext;
 771                 ApplicationController *controller;
 772
 773                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 774                 if (!controller) {
 775                         throw TypeMismatchException("No private object.");
 776                 }
 777                 appmgr = controller->getObject();
 778                 gContext = controller->getContext();
 779
 780         EventApplicationRemoveAppInfoEventListenerPtr event(new EventApplicationRemoveAppInfoEventListener());
 781
 782         ArgumentValidator validator(context, argumentCount, arguments);
 783
 784         // watchId
 785         long watchId = validator.toLong(0);
 786                 event->setWatchId(watchId);
 787
 788                 event->setForSynchronousCall();
 789
 790                 appmgr->removeAppInfoEventListener(event);
 791
 792         ApplicationListenerCancellerPtr canceller = ApplicationListenerCancellerPtr(new ApplicationListenerCanceller(gContext, thisObject, watchId));
 793         DeviceAPI::Common::IListenerItemPtr listenerItem = DPL::StaticPointerCast<DeviceAPI::Common::IListenerItem>(canceller);
 794         ApplicationListenerManagerSingleton::Instance().unregisterListener(listenerItem);
 795
 796                 if (event->getExceptionCode() == ExceptionCodes::NotFoundException) {
 797                         throw NotFoundException("Watch id not found");
 798                 }
 799                 else if (event->getExceptionCode() != ExceptionCodes::None) {
 800                         throw UnknownException("UnknownException Occured");
 801                 }
 802
 803                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 804             return JSValueMakeUndefined(context);
 805
 806         } catch (const BasePlatformException &err) {
 807         return JSWebAPIErrorFactory::postException(context, exception, err);
 808     } catch (...) {
 809         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.removeAppInfoEventListener().");
 810         return JSWebAPIErrorFactory::postException(context, exception, err);
 811     }
 812 }
 813
 814
 815 JSValueRef JSApplicationManager::getAppCerts(JSContextRef context,
 816         JSObjectRef object,
 817         JSObjectRef thisObject,
 818         size_t argumentCount,
 819         const JSValueRef arguments[],
 820         JSValueRef* exception)
 821 {
 822         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 823
 824         TIME_TRACER_ITEM_BEGIN("(getAppCerts)ACE", 0);
 825         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_GET_APP_CERTS);
 826         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 827         TIME_TRACER_ITEM_END("(getAppCerts)ACE", 0);
 828
 829         try {
 830                 ArgumentValidator validator(context, argumentCount, arguments);
 831
 832                 ApplicationCertArrayPtr result = ApplicationManager::getAppCerts(validator.toString(0, true, ""));
 833                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 834
 835                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 836                 return converter->toJSValueRefFromApplicationCerts(result);
 837
 838     } catch (const BasePlatformException &err) {
 839         return JSWebAPIErrorFactory::postException(context, exception, err);
 840     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 841            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 842         } catch (...) {
 843         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppCerts().");
 844         return JSWebAPIErrorFactory::postException(context, exception, err);
 845     }
 846 }
 847
 848
 849 JSValueRef JSApplicationManager::getAppSharedURI(JSContextRef context,
 850         JSObjectRef object,
 851         JSObjectRef thisObject,
 852         size_t argumentCount,
 853         const JSValueRef arguments[],
 854         JSValueRef* exception)
 855 {
 856         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 857
 858         try {
 859                 ArgumentValidator validator(context, argumentCount, arguments);
 860
 861                 std::string result = ApplicationManager::getAppSharedURI(validator.toString(0, true, ""));
 862                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 863
 864                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 865                 return converter->toJSValueRef(result);
 866
 867     } catch (const BasePlatformException &err) {
 868         return JSWebAPIErrorFactory::postException(context, exception, err);
 869     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 870            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 871         } catch (...) {
 872         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
 873         return JSWebAPIErrorFactory::postException(context, exception, err);
 874     }
 875 }
 876
 877 JSValueRef JSApplicationManager::getAppMetaData(JSContextRef context,
 878         JSObjectRef object,
 879         JSObjectRef thisObject,
 880         size_t argumentCount,
 881         const JSValueRef arguments[],
 882         JSValueRef* exception)
 883 {
 884         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 885
 886         TIME_TRACER_ITEM_BEGIN("(getAppMetaData)ACE", 0);
 887         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_GET_APP_META_DATA);
 888         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 889         TIME_TRACER_ITEM_END("(getAppMetaData)ACE", 0);
 890
 891         try {
 892                 ArgumentValidator validator(context, argumentCount, arguments);
 893
 894                 ApplicationMetaDataArrayPtr result = ApplicationManager::getAppMetaData(validator.toString(0, true, ""));
 895                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 896
 897                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 898                 return converter->toJSValueRefFromApplicationMetaDataArray(result);
 899
 900     } catch (const BasePlatformException &err) {
 901         return JSWebAPIErrorFactory::postException(context, exception, err);
 902     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 903            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 904         } catch (...) {
 905         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppCerts().");
 906         return JSWebAPIErrorFactory::postException(context, exception, err);
 907     }
 908 }
 909
 910
 911 /* scheme-callback using title is not working on iframe. So, use IPC API instead of below API.
 912 void JSApplicationManager::setTitleProperty(JSContextRef context, std::string propertyValue){
 913
 914         WrtDeviceApis::CommonsJavaScript::Converter converter(context);
 915         // get window object
 916         JSObjectRef windowObject = JSContextGetGlobalObject(context);
 917
 918         // get title object
 919         JSObjectRef documentObject = converter.toJSObjectRef(JSObjectGetProperty(context,
 920                         windowObject,
 921                         ScopedJSStringRef(JSStringCreateWithUTF8CString("document")).get(),
 922                         NULL));
 923
 924         JSObjectSetProperty(context,
 925                         documentObject,
 926                         ScopedJSStringRef(JSStringCreateWithUTF8CString("title")).get(),
 927                         JSValueMakeString(context, JSStringCreateWithUTF8CString("tizen://dummy#$#@##")),
 928                         kJSPropertyAttributeNone,
 929                         NULL);
 930
 931         JSObjectSetProperty(context,
 932                         documentObject,
 933                         ScopedJSStringRef(JSStringCreateWithUTF8CString("title")).get(),
 934                         JSValueMakeString(context, JSStringCreateWithUTF8CString(propertyValue.c_str())),
 935                         kJSPropertyAttributeNone,
 936                         NULL);
 937 }
 938 */
 939
 940 }
 941 }