src/NFC/NFCAdapter.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 <dpl/scoped_ptr.h>
  20 #include <Commons/Exception.h>
  21 #include <JSTizenException.h>
  22 #include <nfc.h>
  23 #include "NFCDefaultAdapter.h"
  24 #include "NFCAdapter.h"
  25 #include "NFCUtil.h"
  26
  27 using namespace DPL;
  28 namespace DeviceAPI {
  29 namespace NFC {
  30
  31 NFCAdapter::NFCAdapter() {
  32         LogDebug("NFCAdapter");
  33         if (!NFCDefaultAdapterSingleton::Instance().isSupported())
  34                 ThrowMsg(UnsupportedException, "Not Support");
  35
  36         m_NFCTagEmitterPtr.Reset();
  37         m_NFCTargetEmitterPtr.Reset();
  38         m_tagFilter.Reset();
  39         m_EventNFCChangedSetPoweredPtr.Reset();
  40         m_eventNFCSetCardEmulationPtr.Reset();
  41         m_NFCChangedCardEmulations.Reset();
  42 }
  43
  44 NFCAdapter::~NFCAdapter() {
  45         LogDebug("Enter");
  46         unsetTagListener();
  47         unsetPeerListener();
  48         m_EventNFCChangedSetPoweredPtr.Reset();
  49         m_eventNFCSetCardEmulationPtr.Reset();
  50         unsetCardEmulationChangeListener();
  51 }
  52
  53 int NFCAdapter::setTagListener(const EventNFCChangedEmitterPtr& emitter, const TagFilterPtr& filter) {
  54         LogDebug(" NFCAdapter::setTagListener Entered");
  55         if (m_NFCTagEmitterPtr.Get() != NULL)
  56                 ThrowMsg(PlatformException, "It has already set Tag Listener");
  57
  58         m_NFCTagEmitterPtr = emitter;
  59         m_tagFilter = filter;
  60
  61         return NFCDefaultAdapterSingleton::Instance().setTagListener(this);
  62 }
  63
  64 int NFCAdapter::setPeerListener(const EventNFCChangedEmitterPtr& emitter) {
  65         LogDebug(" NFCAdapter::setPeerListener Entered");
  66
  67         if (m_NFCTargetEmitterPtr.Get() != NULL)
  68                 ThrowMsg(PlatformException, "It has already set Peer Listener");
  69
  70         m_NFCTargetEmitterPtr = emitter;
  71         return NFCDefaultAdapterSingleton::Instance().setPeerListener(this);
  72 }
  73 void NFCAdapter::unsetTagListener() {
  74         LogDebug(" NFCAdapter::unsetTagListener Entered");
  75         m_NFCTagEmitterPtr.Reset();
  76         m_tagFilter.Reset();
  77         NFCDefaultAdapterSingleton::Instance().unsetTagListener(this);
  78 }
  79
  80 void NFCAdapter::unsetPeerListener() {
  81         LogDebug(" NFCAdapter::unsetPeerListener Entered");
  82         m_NFCTargetEmitterPtr.Reset();
  83         NFCDefaultAdapterSingleton::Instance().unsetPeerListener(this);
  84 }
  85
  86 void NFCAdapter::NFCTagHasDetected(void *props)
  87 {
  88         if (m_NFCTagEmitterPtr.Get() != NULL) {
  89                 if ((props != NULL) && (m_tagFilter->getFilterSize() > 0)) {
  90                         nfc_tag_type_e tagType;
  91
  92                         if (nfc_tag_get_type((nfc_tag_h)props, &tagType) == NFC_ERROR_NONE) {
  93                                 LogDebug("NFCAdapter::NFCTagHasDetected Tag real type : " << tagType);
  94                                 int cnt;
  95                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize(); cnt++) {
  96                                         NFCUtil util;
  97                                         if (util.convertTonfcTagType(static_cast<unsigned short>(tagType)) == m_tagFilter->getFilterValue(cnt))
  98                                                 break;
  99                                 }
 100                                 if (cnt == m_tagFilter->getFilterSize()) {
 101                                         LogDebug("Filter doesn't have this tag type ");
 102                                         return;
 103                                 }
 104                         } else {
 105                                 LogDebug("It can't get real nfc tag type");
 106                                 int cnt;
 107                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize(); cnt++) {
 108                                         if (NFC_TAGTYPE_GENERIC_PICC == m_tagFilter->getFilterValue(cnt))
 109                                                 break;
 110                                 }
 111
 112                                 if (cnt == m_tagFilter->getFilterSize()) {
 113                                         LogDebug("Filter doesn't have this tag type ");
 114                                         return;
 115                                 }
 116
 117                         }
 118                 }
 119                 EventNFCChangedPtr event(new EventNFCChanged());
 120                 if (props == NULL)
 121                         event->setNFCStatus(NFC_DETATCHED);
 122                 else
 123                         event->setNFCStatus(NFC_ATTATCHED);
 124
 125                 event->setNFCProperties(props);
 126                 event->setNFCType(NFC_TAG_TYPE);
 127                 LogDebug("emit event with nfc tag info");
 128                 m_NFCTagEmitterPtr->emit(event);
 129         }
 130 }
 131
 132 void NFCAdapter::NFCTargetHasDetected(void *props)
 133 {
 134         if (m_NFCTargetEmitterPtr.Get() != NULL) {
 135                 EventNFCChangedPtr event(new EventNFCChanged());
 136                 if (props == NULL)
 137                         event->setNFCStatus(NFC_DETATCHED);
 138                 else
 139                         event->setNFCStatus(NFC_ATTATCHED);
 140                 event->setNFCProperties(props);
 141                 event->setNFCType(NFC_TARGET_TYPE);
 142                 LogDebug("emit event with nfc target info");
 143                 m_NFCTargetEmitterPtr->emit(event);
 144         }
 145 }
 146
 147 void *NFCAdapter::getCachedMessage() {
 148         return NFCDefaultAdapterSingleton::Instance().getCachedMessage();
 149 }
 150
 151 bool NFCAdapter::getPowerState() {
 152         return NFCDefaultAdapterSingleton::Instance().getPowerState();
 153 }
 154
 155 void NFCAdapter::setPowered(const EventNFCChangedSetPoweredPtr& event) {
 156         LogDebug("Enter");
 157         EventRequestReceiver<EventNFCChangedSetPowered>::PostRequest(event);
 158 }
 159
 160 void NFCAdapter::OnRequestReceived(const EventNFCChangedSetPoweredPtr& event) {
 161         if (getPowerState() == event->getState()) {
 162                 event->setResult(true);
 163                 return;
 164         }
 165         if (m_EventNFCChangedSetPoweredPtr.Get() !=NULL) {
 166                 event->setResult(false);
 167                 event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
 168                 event->setErrorMessage("Progressing Identical Operation");
 169                 return;
 170         }
 171
 172         event->switchToManualAnswer();
 173         m_EventNFCChangedSetPoweredPtr = event;
 174         Try {
 175                 NFCDefaultAdapterSingleton::Instance().setPowered(event->getState(), this);
 176                 return;
 177         } Catch(PlatformException) {
 178                 LogError("Exception: " << _rethrown_exception.GetMessage());
 179                 event->setResult(false);
 180                 event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
 181                 event->setErrorMessage("Progressing Identical Operation");
 182                 EventRequestReceiver<EventNFCChangedSetPowered>::ManualAnswer(event);
 183         } Catch(WrtDeviceApis::Commons::Exception) {
 184                 LogError("Exception: " << _rethrown_exception.GetMessage());
 185                 setPoweredManualAnswer(NFC_ERROR_OPERATION_FAILED);
 186         }
 187 }
 188
 189 void NFCAdapter::setPoweredManualAnswer(int error) {
 190         if (m_EventNFCChangedSetPoweredPtr.Get() != NULL) {
 191                 if (error == NFC_ERROR_NONE) {
 192                         m_EventNFCChangedSetPoweredPtr->setResult(true);
 193                 } else {
 194                         NFCUtil util;
 195                         m_EventNFCChangedSetPoweredPtr->setResult(false);
 196                         m_EventNFCChangedSetPoweredPtr->setError(util.getNFCErrorString(error));
 197                         m_EventNFCChangedSetPoweredPtr->setErrorMessage(util.getNFCErrorMessage(error));
 198                 }
 199                 EventRequestReceiver<EventNFCChangedSetPowered>::ManualAnswer(m_EventNFCChangedSetPoweredPtr);
 200                 m_EventNFCChangedSetPoweredPtr.Reset();
 201         }
 202 }
 203
 204 EventNFCSEType NFCAdapter::getSEType() {
 205         return NFCDefaultAdapterSingleton::Instance().getSEType();
 206 }
 207
 208 void NFCAdapter::setCardEmulation(const EventNFCSetCardEmulationPtr& event) {
 209         LogDebug("Enter");
 210         EventRequestReceiver<EventNFCSetCardEmulation>::PostRequest(event);
 211 }
 212
 213 void NFCAdapter::OnRequestReceived(const EventNFCSetCardEmulationPtr& event) {
 214         if (getSEType() == event->getSEType()) {
 215                 event->setResult(true);
 216                 return;
 217         }
 218         if (m_eventNFCSetCardEmulationPtr.Get() !=NULL) {
 219                 event->setResult(false);
 220                 event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
 221                 event->setErrorMessage("Progressing Identical Operation");
 222                 return;
 223         }
 224
 225         event->switchToManualAnswer();
 226         m_eventNFCSetCardEmulationPtr = event;
 227         Try {
 228                 NFCDefaultAdapterSingleton::Instance().setCardEmulation(event->getSEType(), this);
 229                 return;
 230         } Catch(PlatformException) {
 231                 LogError("Exception: " << _rethrown_exception.GetMessage());
 232                 event->setResult(false);
 233                 event->setError(DeviceAPI::Common::JSTizenException::SERVICE_NOT_AVAILABLE);
 234                 event->setErrorMessage("Progressing Identical Operation");
 235                 EventRequestReceiver<EventNFCSetCardEmulation>::ManualAnswer(event);
 236         } Catch(WrtDeviceApis::Commons::Exception) {
 237                 LogError("Exception: " << _rethrown_exception.GetMessage());
 238                 setCardEmulationManualAnswer(NFC_ERROR_OPERATION_FAILED);
 239         }
 240 }
 241
 242 void NFCAdapter::setCardEmulationManualAnswer(int error) {
 243         if (m_eventNFCSetCardEmulationPtr.Get() != NULL) {
 244                 if (error == NFC_ERROR_NONE) {
 245                         m_eventNFCSetCardEmulationPtr->setResult(true);
 246                 } else {
 247                         NFCUtil util;
 248                         m_eventNFCSetCardEmulationPtr->setResult(false);
 249                         if (error == NFC_ERROR_INVALID_PARAMETER) {
 250                                 m_eventNFCSetCardEmulationPtr->setError(DeviceAPI::Common::JSTizenException::NOT_FOUND_ERROR);
 251                                 m_eventNFCSetCardEmulationPtr->setErrorMessage("Not Found Error");
 252                         } else {
 253                                 m_eventNFCSetCardEmulationPtr->setError(util.getNFCErrorString(error));
 254                                 m_eventNFCSetCardEmulationPtr->setErrorMessage(util.getNFCErrorMessage(error));
 255                         }
 256                 }
 257                 EventRequestReceiver<EventNFCSetCardEmulation>::ManualAnswer(m_eventNFCSetCardEmulationPtr);
 258                 m_eventNFCSetCardEmulationPtr.Reset();
 259         }
 260 }
 261
 262 void NFCAdapter::setCardEmulationChangeListener(const EventNFCChangedCardEmulationEmitterPtr& emitter) {
 263         LogDebug("Entered");
 264
 265         if (m_NFCChangedCardEmulations.Get() != NULL)
 266                 ThrowMsg(PlatformException, "It has already set Card Emulation Change Listener");
 267
 268         m_NFCChangedCardEmulations = emitter;
 269
 270         NFCDefaultAdapterSingleton::Instance().setCardEmulationChangeListener(this);
 271 }
 272
 273 void NFCAdapter::seChanged(EventNFCSEType seType) {
 274         if (m_NFCChangedCardEmulations.Get() != NULL) {
 275                 EventNFCChangedCardEmulationPtr event(new EventNFCChangedCardEmulation());
 276                 event->setSEType(seType);
 277                 LogDebug("emit event with seChanged(type:" << seType << ")");
 278                 m_NFCChangedCardEmulations->emit(event);
 279         }
 280 }
 281 void NFCAdapter::unsetCardEmulationChangeListener() {
 282         m_NFCChangedCardEmulations.Reset();
 283         NFCDefaultAdapterSingleton::Instance().unsetCardEmulationChangeListener(this);
 284 }
 285
 286 }
 287 }