src/standards/Tizen/NFC/ResponseDispatcher.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vector>
  18 #include <dpl/log/log.h>
  19 #include <CommonsJavaScript/JSCallbackManager.h>
  20 #include <Tizen/Common/JSTizenExceptionFactory.h>
  21 #include <Tizen/Common/JSTizenException.h>
  22 #include "ResponseDispatcher.h"
  23 #include "NFCConverter.h"
  24 #include "JSNdefMessage.h"
  25
  26
  27 using namespace TizenApis::Api::NFC;
  28 using namespace TizenApis::Commons;
  29 using namespace  WrtDeviceApis::Commons;
  30 using namespace  WrtDeviceApis::CommonsJavaScript;
  31 namespace TizenApis {
  32 namespace Tizen1_0 {
  33
  34 NFCResponseDispatcher& NFCResponseDispatcher::getInstance()
  35 {
  36     static NFCResponseDispatcher instance;
  37     return instance;
  38 }
  39
  40 NFCResponseDispatcher::NFCResponseDispatcher() :
  41     readNDEFAnswerReceiver(ThreadEnum::NULL_THREAD),
  42      writeNDEFAnswerReceiver(ThreadEnum::NULL_THREAD),
  43      transceiveAnswerReceiver(ThreadEnum::NULL_THREAD),
  44      formatAnswerReceiver(ThreadEnum::NULL_THREAD),
  45      mifareClassicAuthenticateWithKeyAAnswerReceiver(ThreadEnum::NULL_THREAD),
  46      mifareClassicAuthenticateWithKeyBAnswerReceiver(ThreadEnum::NULL_THREAD),
  47      mifareClassicReadBlockAnswerReceiver(ThreadEnum::NULL_THREAD),
  48      mifareClassicWriteBlockAnswerReceiver(ThreadEnum::NULL_THREAD),
  49      mifareClassicIncrementBlockValueAnswerReceiver(ThreadEnum::NULL_THREAD),
  50      mifareClassicDecrementBlockValueAnswerReceiver(ThreadEnum::NULL_THREAD),
  51      mifareClassicTransferAnswerReceiver(ThreadEnum::NULL_THREAD),
  52      mifareClassicRestoreAnswerReceiver(ThreadEnum::NULL_THREAD),
  53      mifareUltraReadPageAnswerReceiver(ThreadEnum::NULL_THREAD),
  54      mifareUltraWritePageAnswerReceiver(ThreadEnum::NULL_THREAD),
  55      TargetSendNdefAnswerReceiver(ThreadEnum::NULL_THREAD),
  56      TargetReceiveNdefListener(ThreadEnum::NULL_THREAD)
  57 {
  58     LogDebug("entered");
  59 }
  60
  61 NFCResponseDispatcher::~NFCResponseDispatcher()
  62 {
  63     LogDebug("entered");
  64 }
  65
  66 void NFCResponseDispatcher::OnAnswerReceived(const EventTagActionReadPtr &event)
  67 {
  68         JSCallbackManagerPtr cbm =
  69             DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  70
  71         Try {
  72                 if (!cbm) {
  73                         LogDebug("no callback manager");
  74                         return;
  75                 }
  76                 if (event->getResult()) {
  77                         LogDebug("result success");
  78                         cbm->callOnSuccess(JSNdefMessage::createJSObject(cbm->getContext(), event->getReadNdefResult()));
  79                         return;
  80                 }
  81                 LogDebug("result fail");
  82                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
  83                 cbm->callOnError(errorObject);
  84         } Catch (PlatformException) {
  85                 LogError("Platform can't create NdefMessage"  << _rethrown_exception.GetMessage());
  86                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
  87                 cbm->callOnError(errorObject);
  88         } Catch (Exception) {
  89                 LogError("Exception: " << _rethrown_exception.GetMessage());
  90                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
  91                 cbm->callOnError(errorObject);
  92         }
  93 }
  94
  95 void NFCResponseDispatcher::OnAnswerReceived(const EventTagActionWritePtr &event)
  96 {
  97         JSCallbackManagerPtr cbm =
  98             DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  99
 100         if (!cbm) {
 101                 LogDebug("no callback manager");
 102                 return;
 103         }
 104
 105         JSContextRef context = cbm->getContext();
 106
 107         if (event->getResult()) {
 108                 LogDebug("result success");
 109                 cbm->callOnSuccess();
 110                 return;
 111         }
 112         LogDebug("result fail");
 113
 114         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 115
 116 }
 117
 118 void NFCResponseDispatcher::OnAnswerReceived(const EventTagActionTransceivePtr &event)
 119 {
 120         JSCallbackManagerPtr cbm =
 121                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 122
 123         Try {
 124                 if (!cbm) {
 125                         LogDebug("no callback manager");
 126                         return;
 127                 }
 128
 129                 JSContextRef context = cbm->getContext();
 130
 131                 if (event->getResult()) {
 132                         NFCConverter convert(context);
 133                         LogDebug("result success");
 134                         cbm->callOnSuccess(convert.toJSValueRef(event->getTransceiveBuffer()));
 135                         return;
 136                 }
 137                 LogDebug("result fail");
 138
 139                 cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 140         } Catch (ConversionException) {
 141                 LogError("Conversion exception while processing EventTagActionTransceive");
 142                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 143                 cbm->callOnError(errorObject);
 144         } Catch (Exception) {
 145                 LogError("Exception: " << _rethrown_exception.GetMessage());
 146                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 147                 cbm->callOnError(errorObject);
 148         }
 149 }
 150
 151 void NFCResponseDispatcher::OnAnswerReceived(const EventTagActionFormatPtr &event)
 152 {
 153         JSCallbackManagerPtr cbm =
 154                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 155
 156         if (!cbm) {
 157                 LogDebug("no callback manager");
 158                 return;
 159         }
 160
 161         JSContextRef context = cbm->getContext();
 162
 163         if (event->getResult()) {
 164                 LogDebug("result success");
 165                 cbm->callOnSuccess();
 166                 return;
 167         }
 168         LogDebug("result fail");
 169
 170         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 171 }
 172
 173
 174 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicAuthenticateWithKeyAPtr &event)
 175 {
 176         JSCallbackManagerPtr cbm =
 177                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 178
 179         if (!cbm) {
 180                 LogDebug("no callback manager");
 181                 return;
 182         }
 183         if (event->getResult()) {
 184                 LogDebug("result success");
 185                 cbm->callOnSuccess();
 186                 return;
 187         }
 188         LogDebug("result fail");
 189         JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 190         cbm->callOnError(errorObject);
 191 }
 192
 193 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicAuthenticateWithKeyBPtr &event)
 194 {
 195         JSCallbackManagerPtr cbm =
 196                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 197
 198         if (!cbm) {
 199                 LogDebug("no callback manager");
 200                 return;
 201         }
 202
 203         JSContextRef context = cbm->getContext();
 204
 205         if (event->getResult()) {
 206                 LogDebug("result success");
 207                 cbm->callOnSuccess();
 208                 return;
 209         }
 210         LogDebug("result fail");
 211
 212         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 213 }
 214
 215 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicReadBlockPtr &event)
 216 {
 217         JSCallbackManagerPtr cbm =
 218                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 219
 220         Try {
 221                 if (!cbm) {
 222                         LogDebug("no callback manager");
 223                         return;
 224                 }
 225
 226                 JSContextRef context = cbm->getContext();
 227
 228                 if (event->getResult()) {
 229                         NFCConverter convert(context);
 230                         LogDebug("result success");
 231                         cbm->callOnSuccess(convert.toJSValueRef(event->getBlockData()));
 232                         return;
 233                 }
 234                 LogDebug("result fail");
 235
 236         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 237         } Catch (ConversionException) {
 238                 LogError("Conversion exception while processing EventTagMifareClassicReadBlock");
 239                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 240                 cbm->callOnError(errorObject);
 241         } Catch (Exception) {
 242                 LogError("Exception: " << _rethrown_exception.GetMessage());
 243                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 244                 cbm->callOnError(errorObject);
 245         }
 246 }
 247
 248 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicWriteBlockPtr &event)
 249 {
 250         JSCallbackManagerPtr cbm =
 251                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 252
 253         if (!cbm) {
 254                 LogDebug("no callback manager");
 255                 return;
 256         }
 257         if (event->getResult()) {
 258                 LogDebug("result success");
 259                 cbm->callOnSuccess();
 260                 return;
 261         }
 262         LogDebug("result fail");
 263         JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 264         cbm->callOnError(errorObject);
 265 }
 266
 267 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicIncrementBlockValuePtr &event)
 268 {
 269         JSCallbackManagerPtr cbm =
 270         DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 271
 272         if (!cbm) {
 273                 LogDebug("no callback manager");
 274                 return;
 275         }
 276
 277         JSContextRef context = cbm->getContext();
 278
 279         if (event->getResult()) {
 280                 LogDebug("result success");
 281                 cbm->callOnSuccess();
 282                 return;
 283         }
 284         LogDebug("result fail");
 285
 286         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 287 }
 288
 289 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicDecrementBlockValuePtr &event)
 290 {
 291         JSCallbackManagerPtr cbm =
 292                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 293
 294         if (!cbm) {
 295                 LogDebug("no callback manager");
 296                 return;
 297         }
 298
 299         JSContextRef context = cbm->getContext();
 300
 301         if (event->getResult()) {
 302                 LogDebug("result success");
 303                 cbm->callOnSuccess();
 304                 return;
 305         }
 306         LogDebug("result fail");
 307
 308         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 309 }
 310
 311 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicTransferPtr &event)
 312 {
 313         JSCallbackManagerPtr cbm =
 314                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 315
 316         if (!cbm) {
 317                 LogDebug("no callback manager");
 318                 return;
 319         }
 320         if (event->getResult()) {
 321                 LogDebug("result success");
 322                 cbm->callOnSuccess();
 323                 return;
 324         }
 325         LogDebug("result fail");
 326         JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 327         cbm->callOnError(errorObject);
 328 }
 329
 330 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareClassicRestorePtr &event)
 331 {
 332         JSCallbackManagerPtr cbm =
 333                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 334
 335         if (!cbm) {
 336                 LogDebug("no callback manager");
 337                 return;
 338         }
 339
 340         JSContextRef context = cbm->getContext();
 341
 342         if (event->getResult()) {
 343                 LogDebug("result success");
 344                 cbm->callOnSuccess();
 345                 return;
 346         }
 347         LogDebug("result fail");
 348
 349         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 350 }
 351
 352 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareUltraReadPagePtr &event)
 353 {
 354         JSCallbackManagerPtr cbm =
 355                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 356
 357         Try {
 358                 if (!cbm) {
 359                         LogDebug("no callback manager");
 360                         return;
 361                 }
 362
 363                 JSContextRef context = cbm->getContext();
 364                 if (event->getResult()) {
 365                         NFCConverter convert(context);
 366                         LogDebug("result success");
 367                         cbm->callOnSuccess(convert.toJSValueRef(event->getReadPageResult()));
 368                         return;
 369                 }
 370                 LogDebug("result fail");
 371                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 372                 cbm->callOnError(errorObject);
 373         } Catch (ConversionException) {
 374                 LogError("Conversion exception while processing EventTagMifareUltraReadPage");
 375                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 376                 cbm->callOnError(errorObject);
 377         } Catch (Exception) {
 378                 LogError("Exception: " << _rethrown_exception.GetMessage());
 379                 JSValueRef errorObject = JSTizenExceptionFactory::makeErrorObject(cbm->getContext(), JSTizenException::UNKNOWN_ERROR,"Unknown Error");
 380                 cbm->callOnError(errorObject);
 381         }
 382 }
 383
 384 void NFCResponseDispatcher::OnAnswerReceived(const EventTagMifareUltraWritePagePtr &event)
 385 {
 386         JSCallbackManagerPtr cbm =
 387                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 388
 389         if (!cbm) {
 390                 LogDebug("no callback manager");
 391                 return;
 392         }
 393
 394         JSContextRef context = cbm->getContext();
 395
 396         if (event->getResult()) {
 397                 LogDebug("result success");
 398                 cbm->callOnSuccess();
 399                 return;
 400         }
 401         LogDebug("result fail");
 402
 403         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 404 }
 405
 406 void NFCResponseDispatcher::OnAnswerReceived(const EventTargetActionSendPtr &event)
 407 {
 408         JSCallbackManagerPtr cbm =
 409                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 410
 411         if (!cbm) {
 412                 LogDebug("no callback manager");
 413                 return;
 414         }
 415
 416         JSContextRef context = cbm->getContext();
 417
 418         if (event->getResult()) {
 419                 LogDebug("result success");
 420                 cbm->callOnSuccess();
 421                 return;
 422         }
 423         LogDebug("result fail");
 424
 425         cbm->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 426 }
 427
 428 void NFCResponseDispatcher::onAnswerReceived(const EventTargetActionReceivePtr &event)
 429 {
 430         LogDebug("onAnswerReceived Enter");
 431         JSCallbackManagerPtr cbm =
 432                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 433
 434         Try {
 435                 if (!cbm) {
 436                         LogDebug("no callback manager");
 437                         return;
 438                 }
 439
 440                 JSContextRef context = cbm->getContext();
 441
 442                 LogDebug("result success");
 443                 cbm->callOnSuccess(JSNdefMessage::createJSObject(context, event->getReadNdefResult()));
 444         } Catch (PlatformException) {
 445                 LogError("Platform can't create NdefMessage"  << _rethrown_exception.GetMessage());
 446         } Catch (Exception) {
 447                 LogError("Exception: " << _rethrown_exception.GetMessage());
 448         }
 449 }
 450
 451 }
 452 }