src/SecureElement/SEResponseDispatcher.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 <vector>
  19 #include <dpl/log/log.h>
  20 #include <CommonsJavaScript/JSCallbackManager.h>
  21 #include <CommonsJavaScript/ScopedJSStringRef.h>
  22 #include <JSTizenExceptionFactory.h>
  23 #include <JSTizenException.h>
  24 #include "JSSEReader.h"
  25 #include "JSSESession.h"
  26 #include "JSSEChannel.h"
  27 #include "SEConverter.h"
  28 #include "SEResponseDispatcher.h"
  29 #include "SEAsyncCallbackManager.h"
  30
  31
  32 using namespace DeviceAPI::Common;
  33 using namespace  WrtDeviceApis::Commons;
  34 using namespace  WrtDeviceApis::CommonsJavaScript;
  35 namespace DeviceAPI {
  36 namespace SecureElement {
  37
  38 SEResponseDispatcher& SEResponseDispatcher::getInstance()
  39 {
  40     static SEResponseDispatcher instance;
  41     return instance;
  42 }
  43
  44 SEResponseDispatcher::SEResponseDispatcher() :
  45      EventSEStateChangedListener(ThreadEnum::NULL_THREAD),
  46      ListSEsAnswerReceiver(ThreadEnum::NULL_THREAD),
  47      SEOpenSessionAnswerReceiver(ThreadEnum::NULL_THREAD),
  48      SEOpenChannelAnswerReceiver(ThreadEnum::NULL_THREAD),
  49      SEChannelTransmitAnswerReceiver(ThreadEnum::NULL_THREAD)
  50 {
  51     LogDebug("entered");
  52 }
  53
  54 SEResponseDispatcher::~SEResponseDispatcher()
  55 {
  56     LogDebug("entered");
  57 }
  58
  59 void SEResponseDispatcher::onAnswerReceived(const EventSEStateChangedPtr& event) {
  60         LogDebug("onAnswerReceived Enter");
  61
  62         JSCallbackManagerPtr cbm =
  63                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  64
  65         if (!cbm) {
  66                 LogDebug("no callback manager");
  67                 return;
  68         }
  69
  70         if (event->getSEState() == SE_INSERTED)
  71                 cbm->callOnSuccess(JSSEReader::createJSObject(cbm->getContext(), event->getReader()));
  72         else if (event->getSEState() == SE_REMOVED)
  73                 cbm->callOnError(JSSEReader::createJSObject(cbm->getContext(), event->getReader()));
  74         else
  75                 LogDebug("not correct state");
  76 }
  77
  78 void SEResponseDispatcher::OnAnswerReceived(const EventListSEsPtr &event)
  79 {
  80         JSCallbackManagerPtr cbm =
  81                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  82
  83         if (!cbm) {
  84                 LogDebug("no callback manager");
  85                 return;
  86         }
  87
  88         SEAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
  89
  90         JSContextRef context = cbm->getContext();
  91         SEConverter convert(context);
  92         if (event->getResult()) {
  93                 LogDebug("result success");
  94                 std::vector<void *> readers = event->getListSEs();
  95                 std::vector<JSValueRef> ListSes;
  96                 for (std::size_t i = 0; i < readers.size(); i++)
  97                         ListSes.push_back(JSSEReader::createJSObject(context, readers[i]));
  98
  99                 cbm->callOnSuccess(convert.toJSValueRef(ListSes));
 100                 return;
 101         }
 102         LogDebug("result fail");
 103
 104         cbm->callOnError(convert.makeSeErrorObject(event->getError(), event->getErrorMessage()));
 105 }
 106
 107 void SEResponseDispatcher::OnAnswerReceived(const EventSEOpenSessionPtr &event)
 108 {
 109         JSCallbackManagerPtr cbm =
 110                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 111
 112         if (!cbm) {
 113                 LogDebug("no callback manager");
 114                 return;
 115         }
 116
 117         SEAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
 118
 119         JSContextRef context = cbm->getContext();
 120         SEConverter convert(context);
 121
 122         if (event->getResult()) {
 123                 LogDebug("result success");
 124                 cbm->callOnSuccess(convert.toJSValueRef(JSSESession::createJSObject(context, event->getSession())));
 125                 return;
 126         }
 127         LogDebug("result fail");
 128
 129         cbm->callOnError(convert.makeSeErrorObject(event->getError(), event->getErrorMessage()));
 130 }
 131
 132
 133 void SEResponseDispatcher::OnAnswerReceived(const EventSEOpenChannelPtr &event)
 134 {
 135         JSCallbackManagerPtr cbm =
 136                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 137
 138         if (!cbm) {
 139                 LogDebug("no callback manager");
 140                 return;
 141         }
 142
 143         SEAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
 144
 145         JSContextRef context = cbm->getContext();
 146         SEConverter convert(context);
 147
 148         if (event->getResult()) {
 149                 LogDebug("result success");
 150                 cbm->callOnSuccess(convert.toJSValueRef(JSSEChannel::createJSObject(context, event->getChannel())));
 151                 return;
 152         }
 153         LogDebug("result fail");
 154
 155         cbm->callOnError(convert.makeSeErrorObject(event->getError(), event->getErrorMessage()));
 156 }
 157
 158 void SEResponseDispatcher::OnAnswerReceived(const EventSEChannelTransmitPtr &event)
 159 {
 160         JSCallbackManagerPtr cbm =
 161                 DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 162
 163         if (!cbm) {
 164                 LogDebug("no callback manager");
 165                 return;
 166         }
 167
 168         SEAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
 169
 170         JSContextRef context = cbm->getContext();
 171         SEConverter convert(context);
 172
 173         if (event->getResult()) {
 174                 LogDebug("result success");
 175                 cbm->callOnSuccess(convert.toJSValueRef(event->getResponse()));
 176                 return;
 177         }
 178         LogDebug("result fail");
 179
 180         cbm->callOnError(convert.makeSeErrorObject(event->getError(), event->getErrorMessage()));
 181 }
 182
 183 }
 184 }