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