src/Application/ApplicationController.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <CommonsJavaScript/JSCallbackManager.h>
  19 #include <JSWebAPIErrorFactory.h>
  20 #include <TimeTracer.h>
  21 #include "ApplicationController.h"
  22 #include "ApplicationConverter.h"
  23 #include "JSApplicationEventCallbackManager.h"
  24 #include "ApplicationAsyncCallbackManager.h"
  25 #include "ApplicationInformationEventPrivateData.h"
  26
  27 // to unset event callback for kill() API
  28 #include <app_manager.h>
  29
  30 #include <Logger.h>
  31
  32 namespace DeviceAPI {
  33 namespace Application {
  34
  35 using namespace DeviceAPI::Common;
  36 using namespace WrtDeviceApis::Commons;
  37 using namespace WrtDeviceApis::CommonsJavaScript;
  38
  39 ApplicationController::ApplicationController(JSContextRef context, IApplicationManagerPtr application) :
  40                 EventApplicationLaunchEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  41                 EventApplicationKillEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  42                 EventApplicationLaunchAppControlEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  43                 EventApplicationLaunchAppControlReplyEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  44                 EventApplicationFindAppControlEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  45                 EventApplicationGetAppsContextEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  46                 EventApplicationGetAppsInfoEventAnswerReceiver(ThreadEnum::NULL_THREAD),
  47                 EventApplicationAppInfoEventListenerListener(ThreadEnum::NULL_THREAD),
  48                 SecurityAccessor(),
  49                 ApplicationPrivObject(context, application)
  50 {
  51         if (!application) {
  52                 LoggerE("controller has no application object");
  53         }
  54 }
  55
  56 ApplicationController::~ApplicationController()
  57 {
  58 }
  59
  60 void ApplicationController::OnAnswerReceived(const EventApplicationLaunchPtr &event)
  61 {
  62         ApplicationAsyncAnswerHandler::launch(event);
  63         TIME_TRACER_ITEM_END("launch(async)", 0);
  64 }
  65
  66 void ApplicationController::OnAnswerReceived(const EventApplicationKillPtr &event)
  67 {
  68         ApplicationAsyncAnswerHandler::kill(event);
  69         //TIME_TRACER_ITEM_END("kill(async)", 0);
  70 }
  71
  72 void ApplicationController::OnAnswerReceived(const EventApplicationLaunchAppControlPtr &event)
  73 {
  74         ApplicationAsyncAnswerHandler::launchAppControl(event);
  75         TIME_TRACER_ITEM_END("launchAppControl(async)", 0);
  76 }
  77
  78 void ApplicationController::OnAnswerReceived(const EventApplicationLaunchAppControlReplyPtr &event)
  79 {
  80         ApplicationAsyncAnswerHandler::launchAppControlReply(event);
  81         TIME_TRACER_ITEM_END("launchAppControlReply(async)", 0);
  82 }
  83
  84 void ApplicationController::OnAnswerReceived(const EventApplicationFindAppControlPtr &event)
  85 {
  86         ApplicationAsyncAnswerHandler::findAppControl(event);
  87         TIME_TRACER_ITEM_END("findAppControl(async)", 0);
  88 }
  89
  90 void ApplicationController::OnAnswerReceived(const EventApplicationGetAppsContextPtr &event)
  91 {
  92         ApplicationAsyncAnswerHandler::getAppsContext(event);
  93         TIME_TRACER_ITEM_END("getAppsContext(async)", 0);
  94 }
  95
  96 void ApplicationController::OnAnswerReceived(const EventApplicationGetAppsInfoPtr &event)
  97 {
  98         ApplicationAsyncAnswerHandler::getAppsInfo(event);
  99         TIME_TRACER_ITEM_END("getAppsInfo(async)", 0);
 100 }
 101
 102 void ApplicationController::onAnswerReceived(const EventApplicationAppInfoEventListenerPtr &event)
 103 {
 104         ApplicationAsyncAnswerHandler::eventListener(event);
 105 }
 106
 107 void ApplicationAsyncAnswerHandler::launch(const EventApplicationLaunchPtr &event)
 108 {
 109         JSCallbackManagerPtr callbackManager =
 110                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 111         if (!callbackManager) {
 112                 LoggerE("no callback manager");
 113                 return;
 114         }
 115
 116         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 117
 118         if(event->checkCancelled()) {
 119                 LoggerD("Operation cancelled");
 120                 return;
 121         }
 122
 123         JSContextRef gContext = callbackManager->getContext();
 124
 125         JSValueRef error = NULL;
 126         if (ExceptionCodes::None != event->getExceptionCode())
 127         {
 128                 switch (event->getExceptionCode())
 129                 {
 130                 case ExceptionCodes::InvalidArgumentException:
 131                 case ExceptionCodes::NotFoundException:
 132                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR, "given app id is not found");
 133                         break;
 134                 case ExceptionCodes::PlatformException:
 135                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "platform exception");
 136                         break;
 137                 default:
 138                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 139                         break;
 140                 }
 141
 142                 callbackManager->callOnError(error);
 143                 return;
 144         }
 145
 146         Try {
 147                 callbackManager->callOnSuccess();
 148                 return;
 149         } Catch(Exception) {
 150                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 151                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 152
 153                 callbackManager->callOnError(error);
 154                 return;
 155         }
 156 }
 157
 158 void ApplicationAsyncAnswerHandler::kill(const EventApplicationKillPtr &event)
 159 {
 160         JSCallbackManagerPtr callbackManager =
 161                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 162         if (!callbackManager) {
 163                 LoggerE("no callback manager");
 164                 return;
 165         }
 166
 167         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 168
 169         if(event->checkCancelled()) {
 170                 LoggerD("Operation cancelled");
 171                 return;
 172         }
 173
 174         JSContextRef gContext = callbackManager->getContext();
 175
 176         JSValueRef error = NULL;
 177         if (ExceptionCodes::None != event->getExceptionCode())
 178         {
 179                 switch (event->getExceptionCode())
 180                 {
 181                 case ExceptionCodes::NotFoundException:
 182                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 183                         break;
 184                 case ExceptionCodes::PlatformException:
 185                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 186                         break;
 187                 case ExceptionCodes::InvalidArgumentException:
 188                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid value");
 189                         break;
 190                 default:
 191                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 192                         break;
 193                 }
 194
 195                 callbackManager->callOnError(error);
 196                 return;
 197         }
 198
 199         Try {
 200                 callbackManager->callOnSuccess();
 201                 return;
 202         } Catch(Exception) {
 203                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 204                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 205
 206                 callbackManager->callOnError(error);
 207                 return;
 208         }
 209 }
 210
 211 void ApplicationAsyncAnswerHandler::launchAppControl(const EventApplicationLaunchAppControlPtr &event)
 212 {
 213         JSCallbackManagerPtr callbackManager =
 214                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 215         if (!callbackManager) {
 216                 LoggerE("no callback manager");
 217                 return;
 218         }
 219
 220         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 221
 222         if(event->checkCancelled()) {
 223                 LoggerD("Operation cancelled");
 224                 return;
 225         }
 226
 227         JSContextRef gContext = callbackManager->getContext();
 228
 229         JSValueRef error = NULL;
 230         if (ExceptionCodes::None != event->getExceptionCode())
 231         {
 232                 switch (event->getExceptionCode())
 233                 {
 234                 case ExceptionCodes::NotFoundException:
 235                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 236                         break;
 237                 case ExceptionCodes::PlatformException:
 238                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 239                         break;
 240                 default:
 241                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 242                         break;
 243                 }
 244
 245                 callbackManager->callOnError(error);
 246                 return;
 247         }
 248
 249         Try {
 250                 callbackManager->callOnSuccess();
 251                 return;
 252         } Catch(Exception) {
 253                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 254                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 255
 256                 callbackManager->callOnError(error);
 257                 return;
 258         }
 259 }
 260
 261 void ApplicationAsyncAnswerHandler::launchAppControlReply(const EventApplicationLaunchAppControlReplyPtr &event)
 262 {
 263         JSCallbackManagerPtr callbackManager =
 264                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 265         if (!callbackManager) {
 266                 LoggerE("no callback manager");
 267                 return;
 268         }
 269
 270         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 271
 272         if(event->checkCancelled()) {
 273                 LoggerD("Operation cancelled");
 274                 return;
 275         }
 276
 277         JSContextRef gContext = callbackManager->getContext();
 278
 279         if (ExceptionCodes::None != event->getExceptionCode())
 280         {
 281                 callbackManager->callOnError();
 282                 return;
 283         }
 284
 285         Try {
 286                 ApplicationControlDataArrayPtr appControlDataArray = event->getAppControlDataArray();
 287                 if(appControlDataArray == NULL)
 288                 {
 289                         ThrowMsg(WrtDeviceApis::Commons::UnknownException, "No reply");
 290                 }
 291
 292                 ApplicationConverterFactory::ConverterType converter =
 293                         ApplicationConverterFactory::getConverter(gContext);
 294                 JSValueRef result = converter->toJSValueRef(*appControlDataArray);
 295
 296                 callbackManager->callOnSuccess(result);
 297                 return;
 298         } Catch(Exception) {
 299                 callbackManager->callOnError();
 300                 return;
 301         }
 302 }
 303
 304 void ApplicationAsyncAnswerHandler::findAppControl(const EventApplicationFindAppControlPtr &event)
 305 {
 306         JSCallbackManagerPtr callbackManager =
 307                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 308         if (!callbackManager) {
 309                 LoggerE("no callback manager");
 310                 return;
 311         }
 312
 313         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 314
 315         if(event->checkCancelled()) {
 316                 LoggerD("Operation cancelled");
 317                 return;
 318         }
 319
 320         JSContextRef gContext = callbackManager->getContext();
 321
 322         JSValueRef error = NULL;
 323         if (ExceptionCodes::None != event->getExceptionCode())
 324         {
 325                 switch (event->getExceptionCode())
 326                 {
 327                 case ExceptionCodes::NotFoundException:
 328                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 329                         break;
 330                 case ExceptionCodes::PlatformException:
 331                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 332                         break;
 333                 default:
 334                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 335                         break;
 336                 }
 337
 338                 callbackManager->callOnError(error);
 339                 return;
 340         }
 341
 342         Try {
 343                 ApplicationInformationArrayPtr appInfos = event->getAppInfos();
 344                 ApplicationControlPtr appControl = event->getAppControl();
 345
 346                 ApplicationConverterFactory::ConverterType converter =
 347                         ApplicationConverterFactory::getConverter(gContext);
 348
 349                 JSValueRef result[2];
 350                 result[0] = converter->toJSValueRef(appInfos);
 351                 result[1] = converter->toJSValueRef(appControl);
 352
 353                 callbackManager->callOnSuccess(result, 2);
 354                 return;
 355         } Catch(Exception) {
 356                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 357                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 358
 359                 callbackManager->callOnError(error);
 360                 return;
 361         }
 362 }
 363
 364 void ApplicationAsyncAnswerHandler::getAppsContext(const EventApplicationGetAppsContextPtr &event)
 365 {
 366         JSCallbackManagerPtr callbackManager =
 367                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 368         if (!callbackManager) {
 369                 LoggerE("no callback manager");
 370                 return;
 371         }
 372
 373         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 374
 375         if(event->checkCancelled()) {
 376                 LoggerD("Operation cancelled");
 377                 return;
 378         }
 379
 380         JSContextRef gContext = callbackManager->getContext();
 381
 382         JSValueRef error = NULL;
 383         if (ExceptionCodes::None != event->getExceptionCode())
 384         {
 385                 switch (event->getExceptionCode())
 386                 {
 387                 case ExceptionCodes::NotFoundException:
 388                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 389                         break;
 390                 case ExceptionCodes::PlatformException:
 391                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 392                         break;
 393                 default:
 394                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 395                         break;
 396                 }
 397
 398                 callbackManager->callOnError(error);
 399                 return;
 400         }
 401
 402         Try {
 403                 ApplicationContextArrayPtr appContextArray = event->getAppContextArray();
 404
 405                 ApplicationConverterFactory::ConverterType converter =
 406                         ApplicationConverterFactory::getConverter(gContext);
 407
 408                 JSValueRef result = converter->toJSValueRef(appContextArray);
 409
 410                 callbackManager->callOnSuccess(result);
 411                 return;
 412         } Catch(Exception) {
 413                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 414                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 415
 416                 callbackManager->callOnError(error);
 417                 return;
 418         }
 419 }
 420
 421 void ApplicationAsyncAnswerHandler::getAppsInfo(const EventApplicationGetAppsInfoPtr &event)
 422 {
 423         JSCallbackManagerPtr callbackManager =
 424                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 425         if (!callbackManager) {
 426                 LoggerE("no callback manager");
 427                 return;
 428         }
 429
 430         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 431
 432         if(event->checkCancelled()) {
 433                 LoggerD("Operation cancelled");
 434                 return;
 435         }
 436
 437         JSContextRef gContext = callbackManager->getContext();
 438
 439         JSValueRef error = NULL;
 440         if (ExceptionCodes::None != event->getExceptionCode())
 441         {
 442                 switch (event->getExceptionCode())
 443                 {
 444                 case ExceptionCodes::NotFoundException:
 445                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 446                         break;
 447                 case ExceptionCodes::PlatformException:
 448                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 449                         break;
 450                 default:
 451                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 452                         break;
 453                 }
 454
 455                 callbackManager->callOnError(error);
 456                 return;
 457         }
 458
 459         Try {
 460                 ApplicationInformationArrayPtr appInfoArray = event->getAppInfoArray();
 461
 462                 ApplicationConverterFactory::ConverterType converter =
 463                         ApplicationConverterFactory::getConverter(gContext);
 464
 465                 JSValueRef result = converter->toJSValueRef(appInfoArray);
 466
 467                 callbackManager->callOnSuccess(result);
 468                 return;
 469         } Catch(Exception) {
 470                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 471                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 472
 473                 callbackManager->callOnError(error);
 474                 return;
 475         }
 476 }
 477
 478
 479 void ApplicationAsyncAnswerHandler::eventListener(const EventApplicationAppInfoEventListenerPtr &event)
 480 {
 481         JSApplicationEventCallbackManagerPtr callbackManager =
 482                 DPL::StaticPointerCast<JSApplicationEventCallbackManager>(event->getPrivateData());
 483         if (!callbackManager)
 484         {
 485                 LoggerE("no callback manager");
 486                 return;
 487         }
 488
 489         JSContextRef gContext = callbackManager->getContext();
 490
 491         ApplicationConverterFactory::ConverterType converter =
 492                         ApplicationConverterFactory::getConverter(gContext);
 493
 494         Try {
 495                 if(event->getType() == EventApplicationAppInfoEventListener::OnInstalled)
 496                 {
 497                         ApplicationInformationPtr appInfo = event->getAppInfo();
 498                         if(appInfo == NULL)
 499                         {
 500                                 LoggerE("AppInfo is not set.");
 501                                 return;
 502                         }
 503                         JSValueRef result = converter->toJSValueRefFromApplicationInformation(appInfo);
 504                         callbackManager->callOnInstalled(result);
 505                 }
 506                 else if(event->getType() == EventApplicationAppInfoEventListener::OnUpdated)
 507                 {
 508                         ApplicationInformationPtr appInfo = event->getAppInfo();
 509                         if(appInfo == NULL)
 510                         {
 511                                 LoggerE("AppInfo is not set.");
 512                                 return;
 513                         }
 514                         JSValueRef result = converter->toJSValueRefFromApplicationInformation(appInfo);
 515                         callbackManager->callOnUpdated(result);
 516                 }
 517                 else if(event->getType() == EventApplicationAppInfoEventListener::OnUninstalled)
 518                 {
 519                         ApplicationInformationPtr appInfo = event->getAppInfo();
 520                         std::string appId = appInfo->getAppId();
 521                         if(appId == "")
 522                         {
 523                                 LoggerE("AppId is not set.");
 524                                 return;
 525                         }
 526                         JSValueRef result = converter->toJSValueRef(appId);
 527                         callbackManager->callOnUninstalled(result);
 528                 }
 529                 else
 530                 {
 531                         LoggerE("Event callback type is wrong.");
 532                         return;
 533                 }
 534         } Catch (Exception) {
 535                 LoggerE("Conversion error");
 536                 return;
 537         }
 538 }
 539
 540 } // Application
 541 } // DeviceAPI