src/SecureElement/SEService.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 <Commons/Exception.h>
  19 #include "SEService.h"
  20 #include <Logger.h>
  21
  22 namespace DeviceAPI {
  23 namespace SecureElement {
  24
  25 using namespace WrtDeviceApis;
  26
  27
  28 namespace
  29 {
  30 class SEServiceEventHandler : public smartcard_service_api::SEServiceListener
  31 {
  32         void serviceConnected(smartcard_service_api::SEServiceHelper *service, void *context)
  33         {
  34                 LoggerD("entered");
  35                 if (context)
  36                         (static_cast<SEService*>(context))->getSEServiceCompleted();
  37         }
  38
  39         void eventHandler(smartcard_service_api::SEServiceHelper *service, char *seName, int event, void *context)
  40         {
  41                 LoggerD("entered");
  42                 (static_cast<SEService*>(context))->eventChanged(seName, event);
  43         }
  44
  45         void errorHandler(smartcard_service_api::SEServiceHelper *service, int error, void *context)
  46         {
  47                 LoggerD("entered");
  48         }
  49 };
  50 static SEServiceEventHandler SEEventHandler;
  51 }//private namespace
  52
  53 SEService::SEService()
  54 {
  55         LoggerD("entered");
  56         bInitialized = false;
  57         bReqShutDown = false;
  58         m_EventListSEsPtr.Reset();
  59         m_seService = new smartcard_service_api::SEService((void *)this, &SEEventHandler);
  60
  61 }
  62
  63 SEService::~SEService()
  64 {
  65         LoggerD("entered");
  66
  67         if (m_seService) {
  68                 m_seService->shutdownSync();
  69                 delete m_seService;
  70
  71                 m_seService = NULL;
  72         }
  73 }
  74
  75 void SEService::getSEServiceCompleted() {
  76         LoggerD("getSEServiceCompleted");
  77
  78         if (bReqShutDown)
  79                 m_seService->shutdownSync();
  80
  81         bInitialized = true;
  82         while (eventListSEsPtrs.size() > 0) {
  83                 EventRequestReceiver<EventListSEs>::PostRequest(eventListSEsPtrs.front());
  84                 eventListSEsPtrs.pop();
  85         }
  86 }
  87
  88 void SEService::getReaders(const EventListSEsPtr& event) {
  89         LoggerD("Enter");
  90         if (bInitialized)
  91                 EventRequestReceiver<EventListSEs>::PostRequest(event);
  92         else
  93                 eventListSEsPtrs.push(event);
  94
  95 }
  96
  97 void SEService::registerSEListener(const EventSEStateChangedEmitterPtr& emitter) {
  98         m_EventSEStateChangedEmitterPtrs.push_back(emitter);
  99 }
 100
 101 void SEService::unregisterSEListener(unsigned long id) {
 102         std::vector<EventSEStateChangedEmitterPtr>::iterator it;
 103         for (it = m_EventSEStateChangedEmitterPtrs.begin(); it != m_EventSEStateChangedEmitterPtrs.end(); ++it) {
 104                 if (id == static_cast<long>((*it)->getId())) {
 105                         m_EventSEStateChangedEmitterPtrs.erase(it);
 106                         LoggerD("m_EventSEStateChangedEmitterPtrs is removed. (" << m_EventSEStateChangedEmitterPtrs.size() << ")");
 107                         return;
 108                 }
 109         }
 110         ThrowMsg(NotFoundException, "Not Found ID.");
 111 }
 112
 113 void SEService::eventChanged(char *seName, int event) {
 114         if (m_EventSEStateChangedEmitterPtrs.size() > 0) {
 115                 EventSEStateChangedPtr eventState( new EventSEStateChanged() );
 116                 switch (event) {
 117                         case 1:
 118                                 eventState->setSEState(SE_INSERTED);
 119                                 break;
 120                         case 2:
 121                                 eventState->setSEState(SE_REMOVED);
 122                                 break;
 123                         default:
 124                                 LoggerD("Not correct event");
 125                                 return;
 126                 }
 127                 std::vector<smartcard_service_api::ReaderHelper *> readers = m_seService->getReaders();
 128                 size_t i = 0;
 129                 for (i = readers.size(); i > 0; i--) {
 130                         if ((strlen(readers[i-1]->getName()) == strlen(seName))
 131                                 && !strncmp(readers[i-1]->getName(), seName, strlen(seName))) {
 132                                 if (((event == 1) && readers[i-1]->isSecureElementPresent())
 133                                         ||((event == 2) && !readers[i-1]->isSecureElementPresent()))
 134                                         break;
 135                         }
 136                 }
 137                 if (i == 0) {
 138                         LoggerE("Not found reader");
 139                         return;
 140                 }
 141
 142                 eventState->setReader((void *)(readers[i-1]));
 143
 144                 for (i = 0; i < m_EventSEStateChangedEmitterPtrs.size(); i++)
 145                         m_EventSEStateChangedEmitterPtrs[i]->emit(eventState);
 146         }
 147 }
 148
 149 void SEService::OnRequestReceived(const EventListSEsPtr& event) {
 150         std::vector<smartcard_service_api::ReaderHelper *> readers = m_seService->getReaders();
 151         LoggerD("readers.size() : " << readers.size());
 152         event->setResult(true);
 153         for (std::size_t i = 0; i < readers.size(); i++) {
 154                 if (readers[i]->isSecureElementPresent())
 155                         event->addSEs((void *)readers[i]);
 156         }
 157 }
 158
 159
 160 void SEService::shutdown() {
 161         bReqShutDown = true;
 162         if (bInitialized)
 163                 m_seService->shutdownSync();
 164 }
 165
 166 }
 167 }