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