src/platform/Tizen/NFC/NFCManager.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
  18 #include <dpl/log/log.h>
  19 #include <dpl/scoped_ptr.h>
  20 #include <Commons/Exception.h>
  21 #include <nfc.h>
  22 #include "NFCManager.h"
  23 #include "NFCUtil.h"
  24
  25 using namespace TizenApis::Api::NFC;
  26 using namespace DPL;
  27
  28 namespace TizenApis {
  29 namespace Platform {
  30 namespace NFC {
  31
  32 namespace
  33 {
  34         static void TagDetectedCallback(nfc_discovered_type_e type, nfc_tag_h tag, void *data) {
  35                 LogDebug("Callback TagDetectedCallback.");
  36
  37                 if (data) {
  38                         if (NFC_DISCOVERED_TYPE_ATTACHED == type) {
  39                                 (static_cast<NFCManager*>(data))->updateCurrentHandle((void *)tag);
  40                                 (static_cast<NFCManager*>(data))->NFCHasDetected((void *)tag, NFC_TAG_TYPE);
  41                         } else {
  42                                 (static_cast<NFCManager*>(data))->updateCurrentHandle(NULL);
  43                                 (static_cast<NFCManager*>(data))->NFCHasDetected(NULL, NFC_TAG_TYPE);
  44                         }
  45                 } else {
  46                         LogError("Callback private data is NULL.");
  47                 }
  48
  49         }
  50
  51         static void TargetDetectedCallback(nfc_discovered_type_e type, nfc_p2p_target_h target, void *data) {
  52                 LogDebug("Callback TargetDetectedCallback.");
  53
  54                 if (data) {
  55                         if (NFC_DISCOVERED_TYPE_ATTACHED == type) {
  56                                 (static_cast<NFCManager*>(data))->updateCurrentHandle((void *)target);
  57                                 (static_cast<NFCManager*>(data))->NFCHasDetected((void *)target, NFC_TARGET_TYPE);
  58                         } else {
  59                                 (static_cast<NFCManager*>(data))->updateCurrentHandle(NULL);
  60                                 (static_cast<NFCManager*>(data))->NFCHasDetected(NULL, NFC_TARGET_TYPE);
  61                         }
  62                 } else {
  63                         LogError("Callback private data is NULL.");
  64                 }
  65
  66         }
  67
  68         static void NDEFDetectedCallback(nfc_ndef_message_h message, void *data) {
  69                 LogDebug("Callback NDEFDetectedCallback.");
  70                 if (data) {
  71                         unsigned char *UrawData;
  72                         int size;
  73
  74                         if (nfc_ndef_message_get_rawdata(message, &UrawData, &size) != NFC_ERROR_NONE) {
  75                                 LogError("Can't get rawdata of message");
  76                                 return;
  77                         }
  78
  79                         NFCUtil Util;
  80                         (static_cast<NFCManager*>(data))->NDEFHasDetected(Util.toVector(UrawData, size));
  81
  82                 } else {
  83                         LogError("Callback private data is NULL.");
  84                 }
  85         }
  86
  87         static void SeEventCallback(nfc_se_event_e event, void *data) {
  88                 LogDebug("Callback NDEFDetectedCallback.");
  89                 if (data) {
  90                         nfcSeEventType seEvent = NFC_SE_EVENTTYPE_END_TRANSACTION;
  91                         switch(event) {
  92                                 case NFC_SE_EVENT_START_TRANSACTION:
  93                                         seEvent = NFC_SE_EVENTTYPE_START_TRANSACTION;
  94                                         break;
  95                                 case NFC_SE_EVENT_END_TRANSACTION:
  96                                         seEvent = NFC_SE_EVENTTYPE_END_TRANSACTION;
  97                                         break;
  98                                 case NFC_SE_EVENT_CONNECTIVITY:
  99                                         seEvent = NFC_SE_EVENTTYPE_CONNECTIVITY;
 100                                         break;
 101                                 case NFC_SE_EVENT_FIELD_ON:
 102                                         seEvent = NFC_SE_EVENTTYPE_FIELD_ON;
 103                                         break;
 104                                 case NFC_SE_EVENT_FIELD_OFF:
 105                                         seEvent = NFC_SE_EVENTTYPE_FIELD_OFF;
 106                                         break;
 107                         }
 108                         (static_cast<NFCManager*>(data))->SeEventHasDetected(seEvent);
 109
 110                 } else {
 111                         LogError("Callback private data is NULL.");
 112                 }
 113         }
 114 }//private namespace
 115
 116 NFCManager::NFCManager()
 117         :m_initialized(false) {
 118         LogDebug("Platform::NFC Enter");
 119         initialize();
 120         curHandle = NULL;
 121
 122         m_managerPriv = NULL;
 123
 124         m_NFCTagEmitterPtr.Reset();
 125         m_NFCTargetEmitterPtr.Reset();
 126         m_NdefEmitterPtr.Reset();
 127         m_SeEventEmitterPtr.Reset();
 128
 129         m_tagFilter.Reset();
 130
 131 }
 132
 133 NFCManager::~NFCManager() {
 134         LogDebug("Enter");
 135         int result = -1;
 136         if(m_initialized == true)
 137 {
 138                 result = nfc_manager_deinitialize ();
 139                 if (result !=NFC_ERROR_NONE) {
 140                         LogInfo("failed to deinitialize nfc");
 141                 }
 142         }
 143
 144         nfc_manager_unset_tag_discovered_cb();
 145         nfc_manager_unset_p2p_target_discovered_cb();
 146         nfc_manager_unset_ndef_discovered_cb();
 147         nfc_manager_unset_se_event_cb();
 148
 149         m_managerPriv = NULL;
 150
 151         LogDebug("destroy nfc");
 152 }
 153
 154 int NFCManager::setTagListener(const EventNFCChangedEmitterPtr& emitter,
 155                 TagFilterPtr pFilter, void *managerPriv) {
 156         LogDebug(" NFCManager::setTagListener Entered");
 157         int result = -1;
 158
 159         if (m_NFCTagEmitterPtr.Get() != NULL)
 160                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
 161
 162         m_NFCTagEmitterPtr = emitter;
 163         m_managerPriv = managerPriv;
 164
 165         LogDebug(" NFCManager::setTagListener set discovered callback, filter size == " << pFilter->getFilterSize());
 166
 167         m_tagFilter = pFilter;
 168         if (pFilter->getFilterSize() > 0) {
 169                 int filter = NFC_TAG_FILTER_ALL_DISABLE;
 170                 for (int cnt = 0; cnt < pFilter->getFilterSize() ; cnt++) {
 171                         LogDebug(" NFCManager::setTagListener filter == " << pFilter->getFilterValue(cnt));
 172                         if ((pFilter->getFilterValue(cnt) >= NFC_TAGTYPE_ISO14443_A_PICC) && (pFilter->getFilterValue(cnt) <= NFC_TAGTYPE_MIFARE_DESFIRE_PICC))
 173                                 filter = filter |NFC_TAG_FILTER_ISO14443A_ENABLE;
 174                         else if ((pFilter->getFilterValue(cnt) >= NFC_TAGTYPE_ISO14443_B_PICC) && (pFilter->getFilterValue(cnt) <= NFC_TAGTYPE_ISO14443_BPRIME_PICC))
 175                                 filter = filter |NFC_TAG_FILTER_ISO14443B_ENABLE;
 176                         else if (pFilter->getFilterValue(cnt) == NFC_TAGTYPE_FELICA_PICC)
 177                                 filter = filter |NFC_TAG_FILTER_FELICA_ENABLE ;
 178                         else if (pFilter->getFilterValue(cnt) == NFC_TAGTYPE_JEWEL_PICC)
 179                                 filter = filter |NFC_TAG_FILTER_JEWEL_ENABLE  ;
 180                         else if (pFilter->getFilterValue(cnt) == NFC_TAGTYPE_ISO15693_PICC)
 181                                 filter = filter |NFC_TAG_FILTER_ISO15693_ENABLE ;
 182                 }
 183                 nfc_manager_set_tag_filter(filter);
 184         } else {
 185                 nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
 186         }
 187
 188         result = nfc_manager_set_tag_discovered_cb (TagDetectedCallback, this);
 189         if (result != NFC_ERROR_NONE)
 190         {
 191                 LogInfo("failed to set callback of nfc_manager_set_ndef_discovered_cb");
 192                 return result;
 193         }
 194         LogInfo("NFCManager::setTagListener : result << " << result);
 195         return result;
 196 }
 197
 198 int NFCManager::setPeerListener(const EventNFCChangedEmitterPtr& emitter, void *managerPriv) {
 199         LogDebug(" NFCManager::setPeerListener Entered");
 200         int result = -1;
 201
 202         if (m_NFCTargetEmitterPtr.Get() != NULL)
 203                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
 204
 205         m_NFCTargetEmitterPtr = emitter;
 206         m_managerPriv = managerPriv;
 207         result = nfc_manager_set_p2p_target_discovered_cb (TargetDetectedCallback, this);
 208
 209         if (result != NFC_ERROR_NONE)
 210         {
 211                 LogInfo("failed to set callback of nfc_manager_set_p2p_target_discovered_cb");
 212                 return result;
 213         }
 214
 215         LogInfo("NFCManager::setPeerListener : result << " << result);
 216         return result;
 217 }
 218
 219 int NFCManager::setNDEFListener(const EventNFCChangedNdefEmitterPtr& emitter) {
 220         LogDebug(" NFCManager::setNDEFListener Entered");
 221         int result = -1;
 222
 223         if (m_NdefEmitterPtr.Get() != NULL)
 224                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
 225
 226         m_NdefEmitterPtr = emitter;
 227         result = nfc_manager_set_ndef_discovered_cb(NDEFDetectedCallback, this);
 228         if (result != NFC_ERROR_NONE)
 229         {
 230                 LogInfo("failed to set callback of nfc_manager_set_ndef_discovered_cb");
 231                 return result;
 232         }
 233         nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
 234         LogInfo("NFCManager::setNDEFListener : result << " << result);
 235         return result;
 236 }
 237
 238 int NFCManager::setSEEventListener(const EventNFCChangedSeEventEmitterPtr& emitter) {
 239         LogDebug(" NFCManager::setNDEFListener Entered");
 240         int result = -1;
 241
 242         if (m_SeEventEmitterPtr.Get() != NULL)
 243                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
 244
 245         m_SeEventEmitterPtr = emitter;
 246         result = nfc_manager_set_se_event_cb (SeEventCallback, this);
 247         if (result != NFC_ERROR_NONE)
 248         {
 249                 LogInfo("failed to set callback of NFC_manager_set_tag_discovered_cb");
 250                 return result;
 251         }
 252         LogInfo("NFCManager::setSEEventListener : result << " << result);
 253         return result;
 254 }
 255
 256 void NFCManager::unsetTagListener(/*EventNFCChangedEmitter::IdType id*/) {
 257         LogDebug(" NFCManager::unsetTagListener Entered");
 258
 259         nfc_manager_unset_tag_discovered_cb ();
 260         m_NFCTagEmitterPtr.Reset();
 261         }
 262
 263 void NFCManager::unsetPeerListener(/*EventNFCChangedEmitter::IdType id*/) {
 264         LogDebug(" NFCManager::unsetPeerListener Entered");
 265         nfc_manager_unset_p2p_target_discovered_cb();
 266         m_NFCTargetEmitterPtr.Reset();
 267 }
 268
 269
 270 void NFCManager::unsetNDEFListener() {
 271         LogDebug(" NFCManager::unsetNDEFListener Entered");
 272         nfc_manager_unset_ndef_discovered_cb();
 273         m_NdefEmitterPtr.Reset();
 274 }
 275
 276 void NFCManager::unsetSEEventListener() {
 277         LogDebug(" NFCManager::unsetSEEventListener Entered");
 278         nfc_manager_unset_se_event_cb();
 279         m_SeEventEmitterPtr.Reset();
 280 }
 281
 282 void NFCManager::NFCHasDetected(void *props, EventNFCType type)
 283 {
 284         LogDebug("NFCManager::NFCHasDetected Enter type : " << type);
 285
 286         if (((m_NFCTagEmitterPtr.Get() != NULL) && (type == NFC_TAG_TYPE)) ||
 287                 ((m_NFCTargetEmitterPtr.Get() != NULL) && (type == NFC_TARGET_TYPE))){
 288                 EventNFCType nfcType = type;
 289
 290                 if ((props != NULL) && (type == NFC_TAG_TYPE)) {
 291
 292                         nfc_tag_type_e tagType;
 293
 294                         if (nfc_tag_get_type((nfc_tag_h)props, &tagType) == NFC_ERROR_NONE) {
 295                                 LogDebug("NFCManager::NFCHasDetected Tag real type : " << tagType);
 296                                                                         int cnt;
 297                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize() ; cnt++) {
 298                                         NFCUtil Util;
 299                                         if (Util.convertTonfcTagType(static_cast<unsigned short>(tagType)) == m_tagFilter->getFilterValue(cnt))
 300                                                 break;
 301                                 }
 302                                 if ((m_tagFilter->getFilterSize() > 0) && (cnt == m_tagFilter->getFilterSize())) {
 303                                         LogDebug("Filter doesn't have this tag type ");
 304                                         return;
 305                                 }
 306
 307                                 switch(tagType) {
 308                                         case NFC_MIFARE_MINI_PICC:
 309                                         case NFC_MIFARE_1K_PICC:
 310                                         case NFC_MIFARE_4K_PICC:
 311                                                 nfcType = NFC_TAG_MIFARE_CLASSIC_TYPE;
 312                                                 break;
 313                                         case NFC_MIFARE_ULTRA_PICC:
 314                                                 nfcType = NFC_TAG_MIFARE_ULTRA_TYPE;
 315                                                 break;
 316                                         default:
 317                                                 nfcType = NFC_TAG_TYPE;
 318                                                 break;
 319                                 }
 320                         } else {
 321                                 LogDebug("It can't get real nfc tag type");
 322                                 int cnt;
 323                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize() ; cnt++) {
 324                                         if (NFC_TAGTYPE_GENERIC_PICC == m_tagFilter->getFilterValue(cnt))
 325                                                 break;
 326                                 }
 327
 328                                 if (cnt == m_tagFilter->getFilterSize()) {
 329                                         LogDebug("Filter doesn't have this tag type ");
 330                                         return;
 331                                 }
 332
 333                         }
 334                 }
 335
 336                 EventNFCChangedPtr event( new EventNFCChanged() );
 337                 LogDebug("nfc type was detected");
 338                 if (props == NULL)
 339                         event->setNFCStatus(NFC_DETATCHED);
 340                 else
 341                         event->setNFCStatus(NFC_ATTATCHED);
 342                 event->setNFCProperties(props);
 343                 event->setNFCType(nfcType);
 344                 event->setPrivateNFCManagerPtr(m_managerPriv);
 345                 LogDebug("emit event with nfc tag info");
 346                 if (type == NFC_TARGET_TYPE)
 347                         m_NFCTargetEmitterPtr->emit(event);
 348                 else
 349                         m_NFCTagEmitterPtr->emit(event);
 350         } else {
 351                 LogDebug("m_NFCTagEmitterPtr.Get() != NULL ? " << (m_NFCTagEmitterPtr.Get() != NULL));
 352         }
 353
 354
 355 }
 356
 357 void NFCManager::NDEFHasDetected(std::vector<unsigned char> data)
 358 {
 359         LogDebug("NFCManager::NFCHasDetected Enter");
 360
 361         if (m_NdefEmitterPtr.Get() != NULL) {
 362                 EventNFCChangedNdefPtr event( new EventNFCChangedNdef() );
 363                 LogDebug("nfc type was detected");
 364
 365                 event->setReadNdefResult(data);
 366                 LogDebug("emit event with nfc tag info");
 367                 m_NdefEmitterPtr->emit(event);
 368         }
 369 }
 370
 371 void NFCManager::SeEventHasDetected(nfcSeEventType eventType)
 372 {
 373         LogDebug("NDEF is detected Enter");
 374
 375         if (m_SeEventEmitterPtr.Get() != NULL) {
 376                 EventNFCChangedSeEventPtr event( new EventNFCChangedSeEvent() );
 377                 event->setSeEvent(eventType);
 378                 m_SeEventEmitterPtr->emit(event);
 379         }
 380 }
 381
 382 void NFCManager::initialize() {
 383         LogDebug("NFCManager::initialize Entered");
 384         int result = -1;
 385         result = nfc_manager_initialize();
 386         if (result != NFC_ERROR_NONE) {
 387                 LogError("Could not initialize NFC.");
 388                 Throw(WrtDeviceApis::Commons::UnsupportedException);
 389                 m_initialized = false;
 390         }
 391         m_initialized = true;
 392         return;
 393 }
 394
 395 void *NFCManager::getCachedMessage() {
 396         LogDebug("Entered");
 397         nfc_ndef_message_h messageHandle;
 398         int result = nfc_manager_get_cached_message(&messageHandle);
 399         if (result == NFC_ERROR_INVALID_NDEF_MESSAGE)
 400                 return NULL;
 401         if (result != NFC_ERROR_NONE)
 402                 ThrowMsg(PlatformException, "Can't get cached message");
 403
 404         return (void *)(messageHandle);
 405 }
 406
 407 bool NFCManager::isValidHandle(void * handle) {
 408         LogDebug("Entered");
 409         if ((handle != NULL) && (handle == curHandle))
 410                 return TRUE;
 411
 412         return FALSE;
 413 }
 414
 415 void NFCManager::updateCurrentHandle(void *handle) {
 416         LogDebug("Updated!");
 417         curHandle = handle;
 418 }
 419
 420 }
 421 }
 422 }