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::setNDEFListener : 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         LogInfo("NFCManager::setNDEFListener : result << " << result);
 234         return result;
 235 }
 236
 237 int NFCManager::setSEEventListener(const EventNFCChangedSeEventEmitterPtr& emitter) {
 238         LogDebug(" NFCManager::setNDEFListener Entered");
 239         int result = -1;
 240
 241         if (m_SeEventEmitterPtr.Get() != NULL)
 242                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
 243
 244         m_SeEventEmitterPtr = emitter;
 245         result = nfc_manager_set_se_event_cb (SeEventCallback, this);
 246         if (result != NFC_ERROR_NONE)
 247         {
 248                 LogInfo("failed to set callback of NFC_manager_set_tag_discovered_cb");
 249                 return result;
 250         }
 251         LogInfo("NFCManager::setSEEventListener : result << " << result);
 252         return result;
 253 }
 254
 255 void NFCManager::unsetTagListener(/*EventNFCChangedEmitter::IdType id*/) {
 256         LogDebug(" NFCManager::unsetTagListener Entered");
 257
 258         nfc_manager_unset_tag_discovered_cb ();
 259         m_NFCTagEmitterPtr.Reset();
 260         }
 261
 262 void NFCManager::unsetPeerListener(/*EventNFCChangedEmitter::IdType id*/) {
 263         LogDebug(" NFCManager::unsetPeerListener Entered");
 264         nfc_manager_unset_p2p_target_discovered_cb();
 265         m_NFCTargetEmitterPtr.Reset();
 266 }
 267
 268
 269 void NFCManager::unsetNDEFListener() {
 270         LogDebug(" NFCManager::unsetNDEFListener Entered");
 271         nfc_manager_unset_ndef_discovered_cb();
 272         m_NdefEmitterPtr.Reset();
 273 }
 274
 275 void NFCManager::unsetSEEventListener() {
 276         LogDebug(" NFCManager::unsetSEEventListener Entered");
 277         nfc_manager_unset_se_event_cb();
 278         m_SeEventEmitterPtr.Reset();
 279 }
 280
 281 void NFCManager::NFCHasDetected(void *props, EventNFCType type)
 282 {
 283         LogDebug("NFCManager::NFCHasDetected Enter type : " << type);
 284
 285         if (((m_NFCTagEmitterPtr.Get() != NULL) && (type == NFC_TAG_TYPE)) ||
 286                 ((m_NFCTargetEmitterPtr.Get() != NULL) && (type == NFC_TARGET_TYPE))){
 287                 EventNFCType nfcType = type;
 288
 289                 if ((props != NULL) && (type == NFC_TAG_TYPE)) {
 290
 291                         nfc_tag_type_e tagType;
 292
 293                         if (nfc_tag_get_type((nfc_tag_h)props, &tagType) == NFC_ERROR_NONE) {
 294                                 LogDebug("NFCManager::NFCHasDetected Tag real type : " << tagType);
 295                                                                         int cnt;
 296                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize() ; cnt++) {
 297                                         NFCUtil Util;
 298                                         if (Util.convertTonfcTagType(static_cast<unsigned short>(tagType)) == m_tagFilter->getFilterValue(cnt))
 299                                                 break;
 300                                 }
 301                                 if ((m_tagFilter->getFilterSize() > 0) && (cnt == m_tagFilter->getFilterSize())) {
 302                                         LogDebug("Filter doesn't have this tag type ");
 303                                         return;
 304                                 }
 305
 306                                 switch(tagType) {
 307                                         case NFC_MIFARE_MINI_PICC:
 308                                         case NFC_MIFARE_1K_PICC:
 309                                         case NFC_MIFARE_4K_PICC:
 310                                                 nfcType = NFC_TAG_MIFARE_CLASSIC_TYPE;
 311                                                 break;
 312                                         case NFC_MIFARE_ULTRA_PICC:
 313                                                 nfcType = NFC_TAG_MIFARE_ULTRA_TYPE;
 314                                                 break;
 315                                         default:
 316                                                 nfcType = NFC_TAG_TYPE;
 317                                                 break;
 318                                 }
 319                         } else {
 320                                 LogDebug("It can't get real nfc tag type");
 321                                 int cnt;
 322                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize() ; cnt++) {
 323                                         if (NFC_TAGTYPE_GENERIC_PICC == m_tagFilter->getFilterValue(cnt))
 324                                                 break;
 325                                 }
 326
 327                                 if (cnt == m_tagFilter->getFilterSize()) {
 328                                         LogDebug("Filter doesn't have this tag type ");
 329                                         return;
 330                                 }
 331
 332                         }
 333                 }
 334
 335                 EventNFCChangedPtr event( new EventNFCChanged() );
 336                 LogDebug("nfc type was detected");
 337                 if (props == NULL)
 338                         event->setNFCStatus(NFC_DETATCHED);
 339                 else
 340                         event->setNFCStatus(NFC_ATTATCHED);
 341                 event->setNFCProperties(props);
 342                 event->setNFCType(nfcType);
 343                 event->setPrivateNFCManagerPtr(m_managerPriv);
 344                 LogDebug("emit event with nfc tag info");
 345                 if (type == NFC_TARGET_TYPE)
 346                         m_NFCTargetEmitterPtr->emit(event);
 347                 else
 348                         m_NFCTagEmitterPtr->emit(event);
 349         } else {
 350                 LogDebug("m_NFCTagEmitterPtr.Get() != NULL ? " << (m_NFCTagEmitterPtr.Get() != NULL));
 351         }
 352
 353
 354 }
 355
 356 void NFCManager::NDEFHasDetected(std::vector<unsigned char> data)
 357 {
 358         LogDebug("NFCManager::NFCHasDetected Enter");
 359
 360         if (m_NdefEmitterPtr.Get() != NULL) {
 361                 EventNFCChangedNdefPtr event( new EventNFCChangedNdef() );
 362                 LogDebug("nfc type was detected");
 363
 364                 event->setReadNdefResult(data);
 365                 LogDebug("emit event with nfc tag info");
 366                 m_NdefEmitterPtr->emit(event);
 367         }
 368 }
 369
 370 void NFCManager::SeEventHasDetected(nfcSeEventType eventType)
 371 {
 372         LogDebug("NDEF is detected Enter");
 373
 374         if (m_SeEventEmitterPtr.Get() != NULL) {
 375                 EventNFCChangedSeEventPtr event( new EventNFCChangedSeEvent() );
 376                 event->setSeEvent(eventType);
 377                 m_SeEventEmitterPtr->emit(event);
 378         }
 379 }
 380
 381 void NFCManager::initialize() {
 382         LogDebug("NFCManager::initialize Entered");
 383         int result = -1;
 384         result = nfc_manager_initialize();
 385         if (result != NFC_ERROR_NONE) {
 386                 LogError("Could not initialize NFC.");
 387                 Throw(WrtDeviceApis::Commons::UnsupportedException);
 388                 m_initialized = false;
 389         }
 390         m_initialized = true;
 391         return;
 392 }
 393
 394 void *NFCManager::getCachedMessage() {
 395         LogDebug("Entered");
 396         nfc_ndef_message_h messageHandle;
 397         int result = nfc_manager_get_cached_message(&messageHandle);
 398         if (result == NFC_ERROR_INVALID_NDEF_MESSAGE)
 399                 return NULL;
 400         if (result != NFC_ERROR_NONE)
 401                 ThrowMsg(PlatformException, "Can't get cached message");
 402
 403         return (void *)(messageHandle);
 404 }
 405
 406 bool NFCManager::isValidHandle(void * handle) {
 407         LogDebug("Entered");
 408         if ((handle != NULL) && (handle == curHandle))
 409                 return TRUE;
 410
 411         return FALSE;
 412 }
 413
 414 void NFCManager::updateCurrentHandle(void *handle) {
 415         LogDebug("Updated!");
 416         curHandle = handle;
 417 }
 418
 419 }
 420 }
 421 }