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                 LoggerD("launch success callback called");
 149                 return;
 150         } Catch(Exception) {
 151                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 152                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 153
 154                 callbackManager->callOnError(error);
 155                 LoggerD("launch error callback called");
 156                 return;
 157         }
 158 }
 159
 160 void ApplicationAsyncAnswerHandler::kill(const EventApplicationKillPtr &event)
 161 {
 162         JSCallbackManagerPtr callbackManager =
 163                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 164         if (!callbackManager) {
 165                 LoggerE("no callback manager");
 166                 return;
 167         }
 168
 169         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 170
 171         if(event->checkCancelled()) {
 172                 LoggerD("Operation cancelled");
 173                 return;
 174         }
 175
 176         JSContextRef gContext = callbackManager->getContext();
 177
 178         JSValueRef error = NULL;
 179         if (ExceptionCodes::None != event->getExceptionCode())
 180         {
 181                 switch (event->getExceptionCode())
 182                 {
 183                 case ExceptionCodes::NotFoundException:
 184                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 185                         break;
 186                 case ExceptionCodes::PlatformException:
 187                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 188                         break;
 189                 case ExceptionCodes::InvalidArgumentException:
 190                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "invalid value");
 191                         break;
 192                 default:
 193                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 194                         break;
 195                 }
 196
 197                 callbackManager->callOnError(error);
 198                 LoggerD("kill error callback called");
 199                 return;
 200         }
 201
 202         Try {
 203                 callbackManager->callOnSuccess();
 204                 LoggerD("kill success callback called");
 205                 return;
 206         } Catch(Exception) {
 207                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 208                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 209
 210                 callbackManager->callOnError(error);
 211                 LoggerD("kill error callback called");
 212                 return;
 213         }
 214 }
 215
 216 void ApplicationAsyncAnswerHandler::launchAppControl(const EventApplicationLaunchAppControlPtr &event)
 217 {
 218         JSCallbackManagerPtr callbackManager =
 219                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 220         if (!callbackManager) {
 221                 LoggerE("no callback manager");
 222                 return;
 223         }
 224
 225         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 226
 227         if(event->checkCancelled()) {
 228                 LoggerD("Operation cancelled");
 229                 return;
 230         }
 231
 232         JSContextRef gContext = callbackManager->getContext();
 233
 234         JSValueRef error = NULL;
 235         if (ExceptionCodes::None != event->getExceptionCode())
 236         {
 237                 switch (event->getExceptionCode())
 238                 {
 239                 case ExceptionCodes::NotFoundException:
 240                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 241                         break;
 242                 case ExceptionCodes::PlatformException:
 243                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 244                         break;
 245                 default:
 246                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 247                         break;
 248                 }
 249
 250                 callbackManager->callOnError(error);
 251                 LoggerD("launchAppControl error callback called");
 252                 return;
 253         }
 254
 255         Try {
 256                 callbackManager->callOnSuccess();
 257                 LoggerD("launchAppControl success callback called");
 258                 return;
 259         } Catch(Exception) {
 260                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 261                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 262
 263                 callbackManager->callOnError(error);
 264                 LoggerD("launchAppControl error callback called");
 265                 return;
 266         }
 267 }
 268
 269 void ApplicationAsyncAnswerHandler::launchAppControlReply(const EventApplicationLaunchAppControlReplyPtr &event)
 270 {
 271         JSCallbackManagerPtr callbackManager =
 272                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 273         if (!callbackManager) {
 274                 LoggerE("no callback manager");
 275                 return;
 276         }
 277
 278         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 279
 280         if(event->checkCancelled()) {
 281                 LoggerD("Operation cancelled");
 282                 return;
 283         }
 284
 285         JSContextRef gContext = callbackManager->getContext();
 286
 287         if (ExceptionCodes::None != event->getExceptionCode())
 288         {
 289                 callbackManager->callOnError();
 290                 LoggerD("launchAppControl reply failure callback called");
 291                 return;
 292         }
 293
 294         Try {
 295                 ApplicationControlDataArrayPtr appControlDataArray = event->getAppControlDataArray();
 296                 if(appControlDataArray == NULL)
 297                 {
 298                         ThrowMsg(WrtDeviceApis::Commons::UnknownException, "No reply");
 299                 }
 300
 301                 ApplicationConverterFactory::ConverterType converter =
 302                         ApplicationConverterFactory::getConverter(gContext);
 303                 JSValueRef result = converter->toJSValueRef(*appControlDataArray);
 304
 305                 callbackManager->callOnSuccess(result);
 306                 LoggerD("launchAppControl reply return callback called");
 307                 return;
 308         } Catch(Exception) {
 309                 callbackManager->callOnError();
 310                 LoggerD("launchAppControl reply failure callback called");
 311                 return;
 312         }
 313 }
 314
 315 void ApplicationAsyncAnswerHandler::findAppControl(const EventApplicationFindAppControlPtr &event)
 316 {
 317         JSCallbackManagerPtr callbackManager =
 318                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 319         if (!callbackManager) {
 320                 LoggerE("no callback manager");
 321                 return;
 322         }
 323
 324         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 325
 326         if(event->checkCancelled()) {
 327                 LoggerD("Operation cancelled");
 328                 return;
 329         }
 330
 331         JSContextRef gContext = callbackManager->getContext();
 332
 333         JSValueRef error = NULL;
 334         if (ExceptionCodes::None != event->getExceptionCode())
 335         {
 336                 switch (event->getExceptionCode())
 337                 {
 338                 case ExceptionCodes::NotFoundException:
 339                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 340                         break;
 341                 case ExceptionCodes::PlatformException:
 342                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 343                         break;
 344                 default:
 345                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 346                         break;
 347                 }
 348
 349                 callbackManager->callOnError(error);
 350                 LoggerD("findAppControl error callback called");
 351                 return;
 352         }
 353
 354         Try {
 355                 ApplicationInformationArrayPtr appInfos = event->getAppInfos();
 356                 ApplicationControlPtr appControl = event->getAppControl();
 357
 358                 ApplicationConverter converter(gContext, event.Get());
 359
 360                 JSValueRef result[2];
 361                 result[0] = converter.toJSValueRef(appInfos);
 362                 result[1] = converter.toJSValueRef(appControl);
 363
 364                 callbackManager->callOnSuccess(result, 2);
 365                 LoggerD("findAppControl success callback called");
 366                 return;
 367         } Catch(Exception) {
 368                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 369                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 370
 371                 callbackManager->callOnError(error);
 372                 LoggerD("findAppControl error callback called");
 373                 return;
 374         }
 375 }
 376
 377 void ApplicationAsyncAnswerHandler::getAppsContext(const EventApplicationGetAppsContextPtr &event)
 378 {
 379         JSCallbackManagerPtr callbackManager =
 380                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 381         if (!callbackManager) {
 382                 LoggerE("no callback manager");
 383                 return;
 384         }
 385
 386         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 387
 388         if(event->checkCancelled()) {
 389                 LoggerD("Operation cancelled");
 390                 return;
 391         }
 392
 393         JSContextRef gContext = callbackManager->getContext();
 394
 395         JSValueRef error = NULL;
 396         if (ExceptionCodes::None != event->getExceptionCode())
 397         {
 398                 switch (event->getExceptionCode())
 399                 {
 400                 case ExceptionCodes::NotFoundException:
 401                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 402                         break;
 403                 case ExceptionCodes::PlatformException:
 404                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 405                         break;
 406                 default:
 407                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 408                         break;
 409                 }
 410
 411                 callbackManager->callOnError(error);
 412                 LoggerD("getAppsContext error callback called");
 413                 return;
 414         }
 415
 416         Try {
 417                 ApplicationContextArrayPtr appContextArray = event->getAppContextArray();
 418
 419                 ApplicationConverterFactory::ConverterType converter =
 420                         ApplicationConverterFactory::getConverter(gContext);
 421
 422                 JSValueRef result = converter->toJSValueRef(appContextArray);
 423
 424                 callbackManager->callOnSuccess(result);
 425                 LoggerD("getAppsContext success callback called");
 426                 return;
 427         } Catch(Exception) {
 428                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 429                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 430
 431                 callbackManager->callOnError(error);
 432                 LoggerD("getAppsContext error callback called");
 433                 return;
 434         }
 435 }
 436
 437 void ApplicationAsyncAnswerHandler::getAppsInfo(const EventApplicationGetAppsInfoPtr &event)
 438 {
 439         JSCallbackManagerPtr callbackManager =
 440                         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 441         if (!callbackManager) {
 442                 LoggerE("no callback manager");
 443                 return;
 444         }
 445
 446         ApplicationAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(callbackManager);
 447
 448         if(event->checkCancelled()) {
 449                 LoggerD("Operation cancelled");
 450                 return;
 451         }
 452
 453         JSContextRef gContext = callbackManager->getContext();
 454
 455         JSValueRef error = NULL;
 456         if (ExceptionCodes::None != event->getExceptionCode())
 457         {
 458                 switch (event->getExceptionCode())
 459                 {
 460                 case ExceptionCodes::NotFoundException:
 461                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::NOT_FOUND_ERROR,"given package is not found");
 462                         break;
 463                 case ExceptionCodes::PlatformException:
 464                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"platform exception");
 465                         break;
 466                 default:
 467                         error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR,"unknown error");
 468                         break;
 469                 }
 470
 471                 callbackManager->callOnError(error);
 472                 LoggerD("getAppsInfo error callback called");
 473                 return;
 474         }
 475
 476         Try {
 477                 ApplicationInformationArrayPtr appInfoArray = event->getAppInfoArray();
 478
 479                 ApplicationConverter converter(gContext, event.Get());
 480
 481                 JSValueRef result = converter.toJSValueRef(appInfoArray);
 482
 483                 callbackManager->callOnSuccess(result);
 484                 LoggerD("getAppsInfo success callback called");
 485                 return;
 486         } Catch(Exception) {
 487                 LoggerE("error during processing answer" << _rethrown_exception.GetMessage());
 488                 error = JSWebAPIErrorFactory::makeErrorObject(gContext, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 489
 490                 callbackManager->callOnError(error);
 491                 LoggerD("getAppsInfo error callback called");
 492                 return;
 493         }
 494 }
 495
 496
 497 void ApplicationAsyncAnswerHandler::eventListener(const EventApplicationAppInfoEventListenerPtr &event)
 498 {
 499         JSApplicationEventCallbackManagerPtr callbackManager =
 500                 DPL::StaticPointerCast<JSApplicationEventCallbackManager>(event->getPrivateData());
 501         if (!callbackManager)
 502         {
 503                 LoggerE("no callback manager");
 504                 return;
 505         }
 506
 507         JSContextRef gContext = callbackManager->getContext();
 508
 509         ApplicationConverter converter(gContext, callbackManager.Get());
 510
 511         Try {
 512                 if(event->getType() == EventApplicationAppInfoEventListener::OnInstalled)
 513                 {
 514                         ApplicationInformationPtr appInfo = event->getAppInfo();
 515                         if(appInfo == NULL)
 516                         {
 517                                 LoggerE("AppInfo is not set.");
 518                                 return;
 519                         }
 520                         JSValueRef result = converter.toJSValueRefFromApplicationInformation(appInfo);
 521                         callbackManager->callOnInstalled(result);
 522                         LoggerD("AppInfoEvent oninstalled callback called");
 523                 }
 524                 else if(event->getType() == EventApplicationAppInfoEventListener::OnUpdated)
 525                 {
 526                         ApplicationInformationPtr appInfo = event->getAppInfo();
 527                         if(appInfo == NULL)
 528                         {
 529                                 LoggerE("AppInfo is not set.");
 530                                 return;
 531                         }
 532                         JSValueRef result = converter.toJSValueRefFromApplicationInformation(appInfo);
 533                         callbackManager->callOnUpdated(result);
 534                         LoggerD("AppInfoEvent onupdated callback called");
 535                 }
 536                 else if(event->getType() == EventApplicationAppInfoEventListener::OnUninstalled)
 537                 {
 538                         ApplicationInformationPtr appInfo = event->getAppInfo();
 539                         std::string appId = appInfo->getAppId();
 540                         if(appId == "")
 541                         {
 542                                 LoggerE("AppId is not set.");
 543                                 return;
 544                         }
 545                         JSValueRef result = converter.toJSValueRef(appId);
 546                         callbackManager->callOnUninstalled(result);
 547                         LoggerD("AppInfoEvent onuninstalled callback called");
 548                 }
 549                 else
 550                 {
 551                         LoggerE("Event callback type is wrong.");
 552                         return;
 553                 }
 554         } Catch (Exception) {
 555                 LoggerE("Conversion error");
 556                 return;
 557         }
 558 }
 559
 560 } // Application
 561 } // DeviceAPI