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                 // successCallback
 208                 JSObjectRef successCallback = validator.toFunction(1, true);
 209                 if (successCallback)
 210                         callbackManager->setOnSuccess(successCallback);
 211
 212                 // errorCallback
 213                 JSObjectRef errorCallback = validator.toFunction(2, true);
 214                 if (errorCallback)
 215                         callbackManager->setOnError(errorCallback);
 216
 217         callbackManager->setObject(thisObject);
 218                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 219
 220                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 221                 event->setForAsynchronousCall(controller);
 222
 223                 appmgr->launch(event);
 224                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 225                 return JSValueMakeUndefined(context);
 226
 227         } catch (const BasePlatformException &err) {
 228         return JSWebAPIErrorFactory::postException(context, exception, err);
 229     } catch (...) {
 230         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.launch().");
 231         return JSWebAPIErrorFactory::postException(context, exception, err);
 232     }
 233 }
 234
 235 JSValueRef JSApplicationManager::kill(JSContextRef context,
 236         JSObjectRef object,
 237         JSObjectRef thisObject,
 238         size_t argumentCount,
 239         const JSValueRef arguments[],
 240         JSValueRef* exception)
 241 {
 242         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 243         TIME_TRACER_ITEM_BEGIN("kill(async)", 0);
 244
 245         TIME_TRACER_ITEM_BEGIN("kill(ACE)", 0);
 246         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_KILL);
 247         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 248         TIME_TRACER_ITEM_END("kill(ACE)", 0);
 249
 250         try {
 251                 IApplicationManagerPtr appmgr;
 252                 JSContextRef gContext;
 253                 ApplicationController *controller;
 254
 255                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 256                 if (!controller) {
 257                         throw TypeMismatchException("No private object.");
 258                 }
 259                 appmgr = controller->getObject();
 260                 gContext = controller->getContext();
 261
 262                 EventApplicationKillPtr event(new EventApplicationKill());
 263                 JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 264         ArgumentValidator validator(context, argumentCount, arguments);
 265
 266         // contextId
 267        std::string contextId = validator.toString(0);
 268                 event->setContextId(contextId);
 269
 270                 // successCallback
 271                 JSObjectRef successCallback = validator.toFunction(1, true);
 272                 if (successCallback)
 273                         callbackManager->setOnSuccess(successCallback);
 274
 275                 // errorCallback
 276                 JSObjectRef errorCallback = validator.toFunction(2, true);
 277                 if (errorCallback)
 278                         callbackManager->setOnError(errorCallback);
 279
 280         callbackManager->setObject(thisObject);
 281                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 282
 283                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 284                 event->setForAsynchronousCall(controller);
 285
 286                 appmgr->kill(event);
 287                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 288                 return JSValueMakeUndefined(context);
 289
 290         } catch (const BasePlatformException &err) {
 291         return JSWebAPIErrorFactory::postException(context, exception, err);
 292     } catch (...) {
 293         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.kill().");
 294         return JSWebAPIErrorFactory::postException(context, exception, err);
 295     }
 296 }
 297
 298
 299 JSValueRef JSApplicationManager::setUserAgent(JSContextRef context,
 300         JSObjectRef object,
 301         JSObjectRef thisObject,
 302         size_t argumentCount,
 303         const JSValueRef arguments[],
 304         JSValueRef* exception)
 305 {
 306         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 307
 308         try {
 309                 ArgumentValidator validator(context, argumentCount, arguments);
 310
 311         // UserAgent
 312         std::string userAgent = validator.toString(0);
 313
 314                 // perform
 315                 IPCMessageSupport::sendAsyncMessageToUiProcess(IPCMessageSupport::TIZEN_CHANGE_USERAGENT, userAgent.c_str(), NULL, NULL);
 316
 317                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 318                 return JSValueMakeUndefined(context);
 319
 320         } catch (const BasePlatformException &err) {
 321         return JSWebAPIErrorFactory::postException(context, exception, err);
 322     } catch (...) {
 323         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.removeAppInfoEventListener().");
 324         return JSWebAPIErrorFactory::postException(context, exception, err);
 325     }
 326 }
 327
 328
 329 JSValueRef JSApplicationManager::launchAppControl(JSContextRef context,
 330         JSObjectRef object,
 331         JSObjectRef thisObject,
 332         size_t argumentCount,
 333         const JSValueRef arguments[],
 334         JSValueRef* exception)
 335 {
 336         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 337         TIME_TRACER_ITEM_BEGIN("launchAppControlReply", 0);
 338         TIME_TRACER_ITEM_BEGIN("launchAppControl(async)", 0);
 339         TIME_TRACER_ITEM_BEGIN("launchAppControlReply(async)", 0);
 340
 341         TIME_TRACER_ITEM_BEGIN("launchAppControl(ACE)", 0);
 342         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL);
 343         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 344         TIME_TRACER_ITEM_END("launchAppControl(ACE)", 0);
 345
 346         try {
 347                 IApplicationManagerPtr appmgr;
 348                 JSContextRef gContext;
 349                 ApplicationController *controller;
 350
 351                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 352                 if (!controller) {
 353                         throw TypeMismatchException("No private object.");
 354                 }
 355                 appmgr = controller->getObject();
 356                 gContext = controller->getContext();
 357
 358
 359                 EventApplicationLaunchAppControlPtr event(new EventApplicationLaunchAppControl());
 360             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 361                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 362
 363                 ArgumentValidator validator(context, argumentCount, arguments);
 364
 365         // appControl
 366         JSObjectRef appControlObj = validator.toObject(0);
 367                 ApplicationControlPtr appControl = converter->toApplicationControl(appControlObj);
 368         if (!appControl) {
 369             throw TypeMismatchException("ApplicationControl's private object is NULL.");
 370         }
 371                 event->setAppControl(appControl);
 372
 373         // id
 374         std::string id = validator.toString(1, true, "");
 375                 event->setAppId(id);
 376
 377                 // successCallback
 378                 JSObjectRef successCallback = validator.toFunction(2, true);
 379                 if (successCallback)
 380                         callbackManager->setOnSuccess(successCallback);
 381
 382                 // errorCallback
 383                 JSObjectRef errorCallback = validator.toFunction(3, true);
 384                 if (errorCallback)
 385                         callbackManager->setOnError(errorCallback);
 386
 387                 callbackManager->setObject(thisObject);
 388                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 389
 390                 // replyCallback
 391                 JSCallbackManagerPtr callbackManagerReply;
 392                 JSObjectRef replyCallbackObj = validator.toCallbackObject(4, true, "onsuccess", "onfailure", NULL);
 393
 394                 if (replyCallbackObj) {
 395                         callbackManagerReply = JSCallbackManager::createObject(gContext);
 396
 397                         // onsuccess
 398                         JSValueRef onsuccess = JSUtil::getProperty(context, replyCallbackObj, "onsuccess", exception);
 399                         if (!JSValueIsUndefined(context, onsuccess)) {
 400                                 callbackManagerReply->setOnSuccess(onsuccess);
 401                         }
 402
 403                         // onfailure
 404                         JSValueRef onfailure = JSUtil::getProperty(context, replyCallbackObj, "onfailure", exception);
 405                         if (!JSValueIsUndefined(context, onfailure)) {
 406                                 callbackManagerReply->setOnError(onfailure);
 407                         }
 408
 409                         callbackManagerReply->setObject(thisObject);
 410                         ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManagerReply, gContext);
 411
 412                         EventApplicationLaunchAppControlReplyPtr eventReply(new EventApplicationLaunchAppControlReply());
 413                         eventReply->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManagerReply));
 414                         eventReply->setForAsynchronousCall(controller);
 415
 416                         event->setEventReply(eventReply);
 417                 }
 418
 419                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 420                 event->setForAsynchronousCall(controller);
 421
 422                 appmgr->launchAppControl(event);
 423
 424                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 425                 TIME_TRACER_ITEM_END("launchAppControlReply", 0);
 426                 return JSValueMakeUndefined(context);
 427         } catch (const BasePlatformException &err) {
 428         return JSWebAPIErrorFactory::postException(context, exception, err);
 429     } catch (...) {
 430         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.launchAppControl().");
 431         return JSWebAPIErrorFactory::postException(context, exception, err);
 432     }
 433
 434 }
 435
 436
 437 JSValueRef JSApplicationManager::findAppControl(JSContextRef context,
 438         JSObjectRef object,
 439         JSObjectRef thisObject,
 440         size_t argumentCount,
 441         const JSValueRef arguments[],
 442         JSValueRef* exception)
 443 {
 444         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 445         TIME_TRACER_ITEM_BEGIN("findAppControl(async)", 0);
 446         try {
 447
 448                 IApplicationManagerPtr appmgr;
 449                 JSContextRef gContext;
 450                 ApplicationController *controller;
 451
 452                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 453                 if (!controller) {
 454                         throw TypeMismatchException("No private object.");
 455                 }
 456                 appmgr = controller->getObject();
 457                 gContext = controller->getContext();
 458
 459         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 460         EventApplicationFindAppControlPtr event(new EventApplicationFindAppControl());
 461             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 462
 463                 ArgumentValidator validator(context, argumentCount, arguments);
 464
 465         // appControl
 466         JSObjectRef appControlObj = validator.toObject(0);
 467
 468         ApplicationControlPtr appControl = converter->toApplicationControl(appControlObj);
 469         if (!appControl) {
 470             throw TypeMismatchException("ApplicationControl's private object is NULL.");
 471         }
 472                 event->setAppControl(appControl);
 473
 474         // successCallback
 475         JSObjectRef successCallbackObj = validator.toFunction(1);
 476         if (successCallbackObj) {
 477             callbackManager->setOnSuccess(successCallbackObj);
 478         }
 479
 480         // errorCallback
 481         JSObjectRef errorCallback = validator.toFunction(2, true);
 482                 if (errorCallback) {
 483                         callbackManager->setOnError(errorCallback);
 484                 }
 485
 486         callbackManager->setObject(thisObject);
 487                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 488
 489                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 490                 event->setForAsynchronousCall(controller);
 491
 492                 appmgr->findAppControl(event);
 493                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 494                 return JSValueMakeUndefined(context);
 495
 496         } catch (const BasePlatformException &err) {
 497         return JSWebAPIErrorFactory::postException(context, exception, err);
 498     } catch (...) {
 499         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.findAppControl().");
 500         return JSWebAPIErrorFactory::postException(context, exception, err);
 501     }
 502 }
 503
 504
 505 JSValueRef JSApplicationManager::getAppsContext(JSContextRef context,
 506         JSObjectRef object,
 507         JSObjectRef thisObject,
 508         size_t argumentCount,
 509         const JSValueRef arguments[],
 510         JSValueRef* exception)
 511 {
 512         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 513         TIME_TRACER_ITEM_BEGIN("getAppsContext(async)", 0);
 514
 515         try {
 516                 IApplicationManagerPtr appmgr;
 517                 JSContextRef gContext;
 518                 ApplicationController *controller;
 519
 520                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 521                 if (!controller) {
 522                         throw TypeMismatchException("No private object.");
 523                 }
 524                 appmgr = controller->getObject();
 525                 gContext = controller->getContext();
 526
 527                 EventApplicationGetAppsContextPtr event(new EventApplicationGetAppsContext());
 528             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 529
 530         ArgumentValidator validator(context, argumentCount, arguments);
 531
 532         // successCallback
 533         JSObjectRef successCallbackObj = validator.toFunction(0);
 534                 callbackManager->setOnSuccess(successCallbackObj);
 535
 536         // errorCallback
 537         JSObjectRef errorCallbackObj = validator.toFunction(1, true);
 538                 if (errorCallbackObj)
 539                         callbackManager->setOnError(errorCallbackObj);
 540
 541         callbackManager->setObject(thisObject);
 542                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 543
 544                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 545                 event->setForAsynchronousCall(controller);
 546
 547                 appmgr->getAppsContext(event);
 548                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 549                 return JSValueMakeUndefined(context);
 550
 551         } catch (const BasePlatformException &err) {
 552                 LoggerE("BasePlatformException");
 553         return JSWebAPIErrorFactory::postException(context, exception, err);
 554     } catch (...) {
 555             LoggerE("etc...");
 556         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppsContext().");
 557         return JSWebAPIErrorFactory::postException(context, exception, err);
 558     }
 559 }
 560
 561
 562 JSValueRef JSApplicationManager::getAppContext(JSContextRef context,
 563         JSObjectRef object,
 564         JSObjectRef thisObject,
 565         size_t argumentCount,
 566         const JSValueRef arguments[],
 567         JSValueRef* exception)
 568 {
 569         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 570
 571         try {
 572                 ArgumentValidator validator(context, argumentCount, arguments);
 573
 574                 ApplicationContextPtr result = ApplicationManager::getAppContext(validator.toString(0, true, ""));
 575                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 576
 577                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 578                 return converter->toJSValueRefFromApplicationContext(result);
 579
 580         } catch (const BasePlatformException &err) {
 581         return JSWebAPIErrorFactory::postException(context, exception, err);
 582     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 583            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 584         } catch (...) {
 585         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppContext().");
 586         return JSWebAPIErrorFactory::postException(context, exception, err);
 587     }
 588 }
 589
 590
 591 JSValueRef JSApplicationManager::getAppsInfo(JSContextRef context,
 592         JSObjectRef object,
 593         JSObjectRef thisObject,
 594         size_t argumentCount,
 595         const JSValueRef arguments[],
 596         JSValueRef* exception)
 597 {
 598         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 599         TIME_TRACER_ITEM_BEGIN("getAppsInfo(async)", 0);
 600
 601         try {
 602                 IApplicationManagerPtr appmgr;
 603                 JSContextRef gContext;
 604                 ApplicationController *controller;
 605
 606                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 607                 if (!controller) {
 608                         throw TypeMismatchException("No private object.");
 609                 }
 610                 appmgr = controller->getObject();
 611                 gContext = controller->getContext();
 612
 613                 EventApplicationGetAppsInfoPtr event(new EventApplicationGetAppsInfo());
 614             JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(gContext);
 615
 616         ArgumentValidator validator(context, argumentCount, arguments);
 617
 618         // successCallback
 619         JSObjectRef successCallbackObj = validator.toFunction(0);
 620                 callbackManager->setOnSuccess(successCallbackObj);
 621
 622         // errorCallback
 623         JSObjectRef errorCallbackObj = validator.toFunction(1, true);
 624                 if (errorCallbackObj) {
 625                         callbackManager->setOnError(errorCallbackObj);
 626                 }
 627
 628                 callbackManager->setObject(thisObject);
 629                 ApplicationAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, gContext);
 630
 631                 event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 632                 event->setForAsynchronousCall(controller);
 633
 634                 appmgr->getAppsInfo(event);
 635                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 636                 return JSValueMakeUndefined(context);
 637
 638         } catch (const BasePlatformException &err) {
 639         return JSWebAPIErrorFactory::postException(context, exception, err);
 640     } catch (...) {
 641         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppsInfo().");
 642         return JSWebAPIErrorFactory::postException(context, exception, err);
 643     }
 644 }
 645
 646
 647 JSValueRef JSApplicationManager::getAppInfo(JSContextRef context,
 648         JSObjectRef object,
 649         JSObjectRef thisObject,
 650         size_t argumentCount,
 651         const JSValueRef arguments[],
 652         JSValueRef* exception)
 653 {
 654         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 655
 656         try {
 657                 ApplicationController *controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 658                 if (!controller) {
 659                         throw TypeMismatchException("No private object.");
 660                 }
 661                 JSContextRef gContext = controller->getContext();
 662
 663                 ArgumentValidator validator(context, argumentCount, arguments);
 664
 665                 ApplicationInformationPtr result = ApplicationManager::getAppInfo(validator.toString(0, true, ""));
 666                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(gContext);
 667
 668                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 669                 return converter->toJSValueRefFromApplicationInformation(result);
 670
 671     } catch (const BasePlatformException &err) {
 672         return JSWebAPIErrorFactory::postException(context, exception, err);
 673     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 674            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 675         } catch (...) {
 676         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppInfo().");
 677         return JSWebAPIErrorFactory::postException(context, exception, err);
 678     }
 679 }
 680
 681 JSValueRef JSApplicationManager::addAppInfoEventListener(JSContextRef context,
 682         JSObjectRef object,
 683         JSObjectRef thisObject,
 684         size_t argumentCount,
 685         const JSValueRef arguments[],
 686         JSValueRef* exception)
 687 {
 688         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 689
 690         try {
 691                 IApplicationManagerPtr appmgr;
 692                 JSContextRef gContext;
 693                 ApplicationController *controller;
 694
 695                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 696                 if (!controller) {
 697                         throw TypeMismatchException("No private object.");
 698                 }
 699                 appmgr = controller->getObject();
 700                 gContext = controller->getContext();
 701
 702                 EventApplicationAddAppInfoEventListenerPtr event(new EventApplicationAddAppInfoEventListener());
 703
 704         ArgumentValidator validator(context, argumentCount, arguments);
 705
 706                 // eventCallback
 707                 JSObjectRef eventCBObj = validator.toCallbackObject(0, false, "oninstalled", "onupdated", "onuninstalled", NULL);
 708                 JSApplicationEventCallbackManagerPtr callbackManager = JSApplicationEventCallbackManager::createObject(gContext);
 709
 710                 JSValueRef oninstalled = JSUtil::getProperty(context, eventCBObj, "oninstalled", exception);
 711                 if (!JSValueIsUndefined(context, oninstalled)) {
 712                         callbackManager->setOnInstalled(oninstalled);
 713                 }
 714
 715                 JSValueRef onupdated = JSUtil::getProperty(context, eventCBObj, "onupdated", exception);
 716                 if (!JSValueIsUndefined(context, onupdated)) {
 717                         callbackManager->setOnUpdated(onupdated);
 718                 }
 719
 720                 JSValueRef onuninstalled = JSUtil::getProperty(context, eventCBObj, "onuninstalled", exception);
 721                 if (!JSValueIsUndefined(context, onuninstalled)) {
 722                         callbackManager->setOnUninstalled(onuninstalled);
 723                 }
 724
 725                 EventApplicationAppInfoEventListenerEmitterPtr emitter(new EventApplicationAppInfoEventListenerEmitter());
 726
 727                 emitter->setEventPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
 728                 emitter->setListener(controller);
 729
 730         event->setEmitter(emitter);
 731                 event->setForSynchronousCall();
 732
 733                 appmgr->addAppInfoEventListener(event);
 734
 735                 if (event->getExceptionCode() != ExceptionCodes::None) {
 736                         throw UnknownException("Unknown Exception Occured");
 737                 }
 738
 739                 unsigned long id = event->getWatchId();
 740
 741                 ApplicationListenerCancellerPtr canceller = ApplicationListenerCancellerPtr(new ApplicationListenerCanceller(gContext, thisObject, id));
 742                 DeviceAPI::Common::IListenerItemPtr listenerItem = DPL::StaticPointerCast<DeviceAPI::Common::IListenerItem>(canceller);
 743                 ApplicationListenerManagerSingleton::Instance().registerListener(listenerItem, gContext);
 744
 745                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 746                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 747                 return converter->toJSValueRef(id);
 748
 749         } catch (const BasePlatformException &err) {
 750         return JSWebAPIErrorFactory::postException(context, exception, err);
 751     } catch (...) {
 752         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.addAppInfoEventListener().");
 753         return JSWebAPIErrorFactory::postException(context, exception, err);
 754     }
 755 }
 756
 757 JSValueRef JSApplicationManager::removeAppInfoEventListener(JSContextRef context,
 758         JSObjectRef object,
 759         JSObjectRef thisObject,
 760         size_t argumentCount,
 761         const JSValueRef arguments[],
 762         JSValueRef* exception)
 763 {
 764         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 765
 766         try {
 767                 IApplicationManagerPtr appmgr;
 768                 JSContextRef gContext;
 769                 ApplicationController *controller;
 770
 771                 controller = static_cast<ApplicationController*>(JSObjectGetPrivate(thisObject));
 772                 if (!controller) {
 773                         throw TypeMismatchException("No private object.");
 774                 }
 775                 appmgr = controller->getObject();
 776                 gContext = controller->getContext();
 777
 778         EventApplicationRemoveAppInfoEventListenerPtr event(new EventApplicationRemoveAppInfoEventListener());
 779
 780         ArgumentValidator validator(context, argumentCount, arguments);
 781
 782         // watchId
 783         long watchId = validator.toLong(0);
 784                 event->setWatchId(watchId);
 785
 786                 event->setForSynchronousCall();
 787
 788                 appmgr->removeAppInfoEventListener(event);
 789
 790         ApplicationListenerCancellerPtr canceller = ApplicationListenerCancellerPtr(new ApplicationListenerCanceller(gContext, thisObject, watchId));
 791         DeviceAPI::Common::IListenerItemPtr listenerItem = DPL::StaticPointerCast<DeviceAPI::Common::IListenerItem>(canceller);
 792         ApplicationListenerManagerSingleton::Instance().unregisterListener(listenerItem);
 793
 794                 if (event->getExceptionCode() == ExceptionCodes::NotFoundException) {
 795                         throw NotFoundException("Watch id not found");
 796                 }
 797                 else if (event->getExceptionCode() != ExceptionCodes::None) {
 798                         throw UnknownException("UnknownException Occured");
 799                 }
 800
 801                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 802             return JSValueMakeUndefined(context);
 803
 804         } catch (const BasePlatformException &err) {
 805         return JSWebAPIErrorFactory::postException(context, exception, err);
 806     } catch (...) {
 807         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.removeAppInfoEventListener().");
 808         return JSWebAPIErrorFactory::postException(context, exception, err);
 809     }
 810 }
 811
 812
 813 JSValueRef JSApplicationManager::getAppCerts(JSContextRef context,
 814         JSObjectRef object,
 815         JSObjectRef thisObject,
 816         size_t argumentCount,
 817         const JSValueRef arguments[],
 818         JSValueRef* exception)
 819 {
 820         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 821
 822         TIME_TRACER_ITEM_BEGIN("(getAppCerts)ACE", 0);
 823         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_GET_APP_CERTS);
 824         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 825         TIME_TRACER_ITEM_END("(getAppCerts)ACE", 0);
 826
 827         try {
 828                 ArgumentValidator validator(context, argumentCount, arguments);
 829
 830                 ApplicationCertArrayPtr result = ApplicationManager::getAppCerts(validator.toString(0, true, ""));
 831                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 832
 833                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 834                 return converter->toJSValueRefFromApplicationCerts(result);
 835
 836     } catch (const BasePlatformException &err) {
 837         return JSWebAPIErrorFactory::postException(context, exception, err);
 838     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 839            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 840         } catch (...) {
 841         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppCerts().");
 842         return JSWebAPIErrorFactory::postException(context, exception, err);
 843     }
 844 }
 845
 846
 847 JSValueRef JSApplicationManager::getAppSharedURI(JSContextRef context,
 848         JSObjectRef object,
 849         JSObjectRef thisObject,
 850         size_t argumentCount,
 851         const JSValueRef arguments[],
 852         JSValueRef* exception)
 853 {
 854         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 855
 856         try {
 857                 ArgumentValidator validator(context, argumentCount, arguments);
 858
 859                 std::string result = ApplicationManager::getAppSharedURI(validator.toString(0, true, ""));
 860                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 861
 862                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 863                 return converter->toJSValueRef(result);
 864
 865     } catch (const BasePlatformException &err) {
 866         return JSWebAPIErrorFactory::postException(context, exception, err);
 867     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 868            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 869         } catch (...) {
 870         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
 871         return JSWebAPIErrorFactory::postException(context, exception, err);
 872     }
 873 }
 874
 875 JSValueRef JSApplicationManager::getAppMetaData(JSContextRef context,
 876         JSObjectRef object,
 877         JSObjectRef thisObject,
 878         size_t argumentCount,
 879         const JSValueRef arguments[],
 880         JSValueRef* exception)
 881 {
 882         TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 883
 884         TIME_TRACER_ITEM_BEGIN("(getAppMetaData)ACE", 0);
 885         AceSecurityStatus status = APPLICATION_CHECK_ACCESS(APPLICATION_FUNCTION_API_GET_APP_META_DATA);
 886         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 887         TIME_TRACER_ITEM_END("(getAppMetaData)ACE", 0);
 888
 889         try {
 890                 ArgumentValidator validator(context, argumentCount, arguments);
 891
 892                 ApplicationMetaDataArrayPtr result = ApplicationManager::getAppMetaData(validator.toString(0, true, ""));
 893                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 894
 895                 TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 896                 return converter->toJSValueRefFromApplicationMetaDataArray(result);
 897
 898     } catch (const BasePlatformException &err) {
 899         return JSWebAPIErrorFactory::postException(context, exception, err);
 900     } catch (const WrtDeviceApis::Commons::NotFoundException& ex) {
 901            return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_FOUND_ERROR, ex.GetMessage());
 902         } catch (...) {
 903         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppCerts().");
 904         return JSWebAPIErrorFactory::postException(context, exception, err);
 905     }
 906 }
 907
 908
 909 /* scheme-callback using title is not working on iframe. So, use IPC API instead of below API.
 910 void JSApplicationManager::setTitleProperty(JSContextRef context, std::string propertyValue){
 911
 912         WrtDeviceApis::CommonsJavaScript::Converter converter(context);
 913         // get window object
 914         JSObjectRef windowObject = JSContextGetGlobalObject(context);
 915
 916         // get title object
 917         JSObjectRef documentObject = converter.toJSObjectRef(JSObjectGetProperty(context,
 918                         windowObject,
 919                         ScopedJSStringRef(JSStringCreateWithUTF8CString("document")).get(),
 920                         NULL));
 921
 922         JSObjectSetProperty(context,
 923                         documentObject,
 924                         ScopedJSStringRef(JSStringCreateWithUTF8CString("title")).get(),
 925                         JSValueMakeString(context, JSStringCreateWithUTF8CString("tizen://dummy#$#@##")),
 926                         kJSPropertyAttributeNone,
 927                         NULL);
 928
 929         JSObjectSetProperty(context,
 930                         documentObject,
 931                         ScopedJSStringRef(JSStringCreateWithUTF8CString("title")).get(),
 932                         JSValueMakeString(context, JSStringCreateWithUTF8CString(propertyValue.c_str())),
 933                         kJSPropertyAttributeNone,
 934                         NULL);
 935 }
 936 */
 937
 938 }
 939 }