src/platform/Tizen/NFC/NFCTagMifareClassic.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
  19
  20 #include <dpl/log.h>
  21
  22 #include <Commons/Exception.h>
  23
  24 #include "NFCTagMifareClassic.h"
  25 #include "NFCUtil.h"
  26
  27 #include <nfc.h>
  28
  29 namespace TizenApis {
  30 namespace Platform {
  31 namespace NFC {
  32
  33 using namespace Api::NFC;
  34 using namespace WrtDeviceApis;
  35 namespace
  36 {
  37         /**
  38         * Callback method called by platform as interval time.
  39         * @param event_type Platform magnetic evet type
  40         * @param event Platform sensor event data
  41         * @param this_ User data pointer.
  42         */
  43         static void MifareClassicAuthenticateWithKeyACallback(nfc_error_e result , void * data) {
  44                 LogDebug("Callback MifareClassicAuthenticateWithKeyACallback. result : " << result);
  45                 if (data) {
  46                         ((NFCTagMifareClassic *)data)->authenticateWithKeyAManualAnswer((int) result);
  47                 } else {
  48                         LogDebug("Error! MifareClassicAuthenticateWithKeyACallback is Null.");
  49                 }
  50         }
  51
  52         static void MifareClassicAuthenticateWithKeyBCallback(nfc_error_e result ,  void * data) {
  53                 LogDebug("Callback MifareClassicAuthenticateWithKeyBCallback. result : " << result);
  54                 if (data) {
  55                         ((NFCTagMifareClassic *)data)->authenticateWithKeyBManualAnswer((int)result);
  56                 } else {
  57                         LogDebug("Error! MifareClassicAuthenticateWithKeyBCallback is Null.");
  58                 }
  59         }
  60
  61         static void MifareClassicReadBlockCallback(nfc_error_e result , unsigned char * buffer, int buffer_size,  void * data) {
  62                 LogDebug("Callback MifareClassicReadBlockCallback. result : " << result);
  63                 if (data) {
  64                         NFCUtil Util;
  65
  66                         ((NFCTagMifareClassic *)data)->readBlockManualAnswer((int)result, Util.toVector(buffer, buffer_size));
  67                 } else {
  68                         LogDebug("Error! MifareClassicReadBlockCallback is Null.");
  69                 }
  70         }
  71
  72         static void MifareClassicWriteBlockCallback(nfc_error_e result , void * data) {
  73                 LogDebug("Callback MifareClassicAuthenticateWithKeyACallback. result : " << result);
  74                 if (data) {
  75                         ((NFCTagMifareClassic *)data)->writeBlockManualAnswer((int)result);
  76                 } else {
  77                         LogDebug("Error! MifareClassicAuthenticateWithKeyACallback is Null.");
  78                 }
  79         }
  80
  81         static void MifareClassicIncrementBlockValueCallback(nfc_error_e result ,  void * data) {
  82                 LogDebug("Callback MifareClassicIncrementBlockValueCallback. result : " << result);
  83                 if (data) {
  84                         ((NFCTagMifareClassic *)data)->incrementBlockValueManualAnswer((int)result);
  85                 } else {
  86                         LogDebug("Error! MifareClassicIncrementBlockValueCallback is Null.");
  87                 }
  88         }
  89
  90         static void MifareClassicDecrementBlockValueCallback(nfc_error_e result , void * data) {
  91                 LogDebug("Callback MifareClassicDecrementBlockValueCallback. result : " << result);
  92                 if (data) {
  93                         ((NFCTagMifareClassic *)data)->decrementBlockValueManualAnswer((int)result );
  94                 } else {
  95                         LogDebug("Error! MifareClassicDecrementBlockValueCallback is Null.");
  96                 }
  97         }
  98
  99         static void MifareClassicTransferManualAnswerCallback(nfc_error_e result , void * data) {
 100                 LogDebug("Callback MifareClassicTransferManualAnswerCallback. result : " << result);
 101                 if (data) {
 102                         ((NFCTagMifareClassic *)data)->transferManualAnswer((int)result );
 103                 } else {
 104                         LogDebug("Error! MifareClassicTransferManualAnswerCallback is Null.");
 105                 }
 106         }
 107
 108         static void MifareClassicRestoreManualAnswerCallback(nfc_error_e result ,  void * data) {
 109                 LogDebug("Callback MifareClassicRestoreCallback. result : " << result);
 110                 if (data) {
 111                         ((NFCTagMifareClassic *)data)->restoreManualAnswer((int)result );
 112                 } else {
 113                         LogDebug("Error! MifareClassicRestoreCallback is Null.");
 114                 }
 115         }
 116 }//private namespace
 117
 118 NFCTagMifareClassic::NFCTagMifareClassic(void *tagHandle)
 119 {
 120         LogDebug("entered");
 121
 122         if (tagHandle == NULL)
 123                 ThrowMsg(Commons::PlatformException, "Tag Handler is Null Pointer.");
 124
 125         handle = (nfc_tag_h)tagHandle;
 126 }
 127
 128 NFCTagMifareClassic::~NFCTagMifareClassic()
 129 {
 130         LogDebug("entered");
 131         handle = NULL;
 132 }
 133
 134 void NFCTagMifareClassic::authenticateWithKeyA(const EventTagMifareClassicAuthenticateWithKeyAPtr& event) {
 135         LogDebug("Enter");
 136         EventRequestReceiver<EventTagMifareClassicAuthenticateWithKeyA>::PostRequest(event);
 137 }
 138
 139 void NFCTagMifareClassic::authenticateWithKeyB(const EventTagMifareClassicAuthenticateWithKeyBPtr& event) {
 140         LogDebug("Enter");
 141         EventRequestReceiver<EventTagMifareClassicAuthenticateWithKeyB>::PostRequest(event);
 142 }
 143
 144 void NFCTagMifareClassic::readBlock(const EventTagMifareClassicReadBlockPtr& event) {
 145         LogDebug("Enter");
 146         EventRequestReceiver<EventTagMifareClassicReadBlock>::PostRequest(event);
 147 }
 148
 149 void NFCTagMifareClassic::writeBlock(const EventTagMifareClassicWriteBlockPtr& event) {
 150         LogDebug("Enter");
 151         EventRequestReceiver<EventTagMifareClassicWriteBlock>::PostRequest(event);
 152 }
 153
 154 void NFCTagMifareClassic::incrementBlockValue(const EventTagMifareClassicIncrementBlockValuePtr& event) {
 155         LogDebug("Enter");
 156         EventRequestReceiver<EventTagMifareClassicIncrementBlockValue>::PostRequest(event);
 157 }
 158
 159 void NFCTagMifareClassic::decrementBlockValue(const EventTagMifareClassicDecrementBlockValuePtr& event) {
 160         LogDebug("Enter");
 161         EventRequestReceiver<EventTagMifareClassicDecrementBlockValue>::PostRequest(event);
 162 }
 163 void NFCTagMifareClassic::transfer(const EventTagMifareClassicTransferPtr& event) {
 164         LogDebug("Enter");
 165         EventRequestReceiver<EventTagMifareClassicTransfer>::PostRequest(event);
 166 }
 167
 168 void NFCTagMifareClassic::restore(const EventTagMifareClassicRestorePtr& event) {
 169         LogDebug("Enter");
 170         EventRequestReceiver<EventTagMifareClassicRestore>::PostRequest(event);
 171 }
 172
 173 void NFCTagMifareClassic::authenticateWithKeyAManualAnswer(int result )
 174 {
 175         LogDebug("Enter");
 176         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 177                 m_EventTagMifareClassicAuthenticateWithKeyAPtr->setResult(TRUE);
 178         } else {
 179                 m_EventTagMifareClassicAuthenticateWithKeyAPtr->setResult(FALSE);
 180         }
 181         EventRequestReceiver<EventTagMifareClassicAuthenticateWithKeyA>::ManualAnswer(m_EventTagMifareClassicAuthenticateWithKeyAPtr);
 182 }
 183
 184 void NFCTagMifareClassic::authenticateWithKeyBManualAnswer(int result  )
 185 {
 186         LogDebug("Enter");
 187         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 188                 m_EventTagMifareClassicAuthenticateWithKeyBPtr->setResult(TRUE);
 189         } else {
 190                 m_EventTagMifareClassicAuthenticateWithKeyBPtr->setResult(FALSE);
 191         }
 192         EventRequestReceiver<EventTagMifareClassicAuthenticateWithKeyB>::ManualAnswer(m_EventTagMifareClassicAuthenticateWithKeyBPtr);
 193 }
 194
 195 void NFCTagMifareClassic::readBlockManualAnswer(int result , std::vector<unsigned char> data )
 196 {
 197         LogDebug("Enter");
 198         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 199                 m_EventTagMifareClassicReadBlockPtr->setResult(TRUE);
 200                 m_EventTagMifareClassicReadBlockPtr->setBlockData(data);
 201         } else {
 202                 m_EventTagMifareClassicReadBlockPtr->setResult(FALSE);
 203         }
 204         EventRequestReceiver<EventTagMifareClassicReadBlock>::ManualAnswer(m_EventTagMifareClassicReadBlockPtr);
 205 }
 206
 207 void NFCTagMifareClassic::writeBlockManualAnswer(int result )
 208 {
 209         LogDebug("Enter");
 210         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 211                 m_EventTagMifareClassicWriteBlockPtr->setResult(TRUE);
 212         } else {
 213                 m_EventTagMifareClassicWriteBlockPtr->setResult(FALSE);
 214         }
 215         EventRequestReceiver<EventTagMifareClassicWriteBlock>::ManualAnswer(m_EventTagMifareClassicWriteBlockPtr);
 216 }
 217
 218 void NFCTagMifareClassic::incrementBlockValueManualAnswer(int result )
 219 {
 220         LogDebug("Enter");
 221         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 222                 m_EventTagMifareClassicIncrementBlockValuePtr->setResult(TRUE);
 223         } else {
 224                 m_EventTagMifareClassicIncrementBlockValuePtr->setResult(FALSE);
 225         }
 226         EventRequestReceiver<EventTagMifareClassicIncrementBlockValue>::ManualAnswer(m_EventTagMifareClassicIncrementBlockValuePtr);
 227 }
 228
 229 void NFCTagMifareClassic::decrementBlockValueManualAnswer(int result )
 230 {
 231         LogDebug("Enter");
 232         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 233                 m_EventTagMifareClassicDecrementBlockValuePtr->setResult(TRUE);
 234         } else {
 235                 m_EventTagMifareClassicDecrementBlockValuePtr->setResult(FALSE);
 236         }
 237         EventRequestReceiver<EventTagMifareClassicDecrementBlockValue>::ManualAnswer(m_EventTagMifareClassicDecrementBlockValuePtr);
 238 }
 239
 240 void NFCTagMifareClassic::transferManualAnswer(int result )
 241 {
 242         LogDebug("Enter");
 243         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 244                 m_EventTagMifareClassicTransferPtr->setResult(TRUE);
 245         } else {
 246                 m_EventTagMifareClassicTransferPtr->setResult(FALSE);
 247         }
 248         EventRequestReceiver<EventTagMifareClassicTransfer>::ManualAnswer(m_EventTagMifareClassicTransferPtr);
 249 }
 250
 251 void NFCTagMifareClassic::restoreManualAnswer(int result )
 252 {
 253         LogDebug("Enter");
 254         if ((nfc_error_e)result == NFC_ERROR_NONE) {
 255                 m_EventTagMifareClassicRestorePtr->setResult(TRUE);
 256         } else {
 257                 m_EventTagMifareClassicRestorePtr->setResult(FALSE);
 258         }
 259         EventRequestReceiver<EventTagMifareClassicRestore>::ManualAnswer(m_EventTagMifareClassicRestorePtr);
 260 }
 261
 262 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicAuthenticateWithKeyAPtr& event) {
 263         try {
 264                 event->switchToManualAnswer();
 265
 266                 m_EventTagMifareClassicAuthenticateWithKeyAPtr = event;
 267                 NFCUtil Util;
 268
 269                 if( nfc_mifare_authenticate_with_keyA(handle, event->getSectorIndex(), Util.toCharPtr(event->getKey()), MifareClassicAuthenticateWithKeyACallback, this) != NFC_ERROR_NONE )
 270                 {
 271                         ThrowMsg(Commons::UnknownException, "call back set error");
 272                 }
 273         }
 274         catch (const Commons::Exception& ex) {
 275                 LogError("Exception: " << ex.GetMessage());
 276                 event->setResult(false);
 277
 278                 EventRequestReceiver<EventTagMifareClassicAuthenticateWithKeyA>::ManualAnswer(event);
 279         }
 280
 281 }
 282
 283 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicAuthenticateWithKeyBPtr& event) {
 284         try {
 285                 event->switchToManualAnswer();
 286
 287                 m_EventTagMifareClassicAuthenticateWithKeyBPtr = event;
 288                 NFCUtil Util;
 289                 if( nfc_mifare_authenticate_with_keyB(handle, event->getSectorIndex(), Util.toCharPtr(event->getKey()),  MifareClassicAuthenticateWithKeyBCallback, this) != NFC_ERROR_NONE )
 290                 {
 291                         ThrowMsg(Commons::UnknownException, "call back set error");
 292                 }
 293         }
 294         catch (const Commons::Exception& ex) {
 295                 LogError("Exception: " << ex.GetMessage());
 296                 event->setResult(false);
 297
 298                 EventRequestReceiver<EventTagMifareClassicAuthenticateWithKeyB>::ManualAnswer(event);
 299         }
 300
 301 }
 302
 303 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicReadBlockPtr& event) {
 304         try {
 305                 event->switchToManualAnswer();
 306
 307                 m_EventTagMifareClassicReadBlockPtr = event;
 308
 309                 if( nfc_mifare_read_block(handle, event->getIndex(), MifareClassicReadBlockCallback, this) != NFC_ERROR_NONE )
 310                 {
 311                         ThrowMsg(Commons::UnknownException, "call back set error");
 312                 }
 313         }
 314         catch (const Commons::Exception& ex) {
 315                 LogError("Exception: " << ex.GetMessage());
 316                 event->setResult(false);
 317
 318                 EventRequestReceiver<EventTagMifareClassicReadBlock>::ManualAnswer(event);
 319         }
 320
 321 }
 322
 323 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicWriteBlockPtr& event) {
 324         try {
 325                 event->switchToManualAnswer();
 326
 327                 m_EventTagMifareClassicWriteBlockPtr = event;
 328
 329                 NFCUtil Util;
 330                 std::vector<unsigned char> data = event->getBlockData();
 331                 if( nfc_mifare_write_block(handle, event->getIndex(), Util.toCharPtr(data), data.size(), MifareClassicWriteBlockCallback, this) != NFC_ERROR_NONE )
 332                 {
 333                         ThrowMsg(Commons::UnknownException, "call back set error");
 334                 }
 335         }
 336         catch (const Commons::Exception& ex) {
 337                 LogError("Exception: " << ex.GetMessage());
 338                 event->setResult(false);
 339
 340                 EventRequestReceiver<EventTagMifareClassicWriteBlock>::ManualAnswer(event);
 341         }
 342
 343 }
 344
 345 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicIncrementBlockValuePtr& event) {
 346         try {
 347                 event->switchToManualAnswer();
 348
 349                 m_EventTagMifareClassicIncrementBlockValuePtr = event;
 350
 351                 if( nfc_mifare_increment(handle, event->getIndex(), event->getValue(), MifareClassicIncrementBlockValueCallback, this) != NFC_ERROR_NONE )
 352                 {
 353                         ThrowMsg(Commons::UnknownException, "call back set error");
 354                 }
 355         }
 356         catch (const Commons::Exception& ex) {
 357                 LogError("Exception: " << ex.GetMessage());
 358                 event->setResult(false);
 359
 360                 EventRequestReceiver<EventTagMifareClassicIncrementBlockValue>::ManualAnswer(event);
 361         }
 362
 363 }
 364
 365 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicDecrementBlockValuePtr& event) {
 366         try {
 367                 event->switchToManualAnswer();
 368
 369                 m_EventTagMifareClassicDecrementBlockValuePtr = event;
 370
 371                 NFCUtil Util;
 372                 if( nfc_mifare_decrement(handle, event->getIndex(), event->getValue(), MifareClassicDecrementBlockValueCallback, this) != NFC_ERROR_NONE )
 373                 {
 374                         ThrowMsg(Commons::UnknownException, "call back set error");
 375                 }
 376         }
 377         catch (const Commons::Exception& ex) {
 378                 LogError("Exception: " << ex.GetMessage());
 379                 event->setResult(false);
 380
 381                 EventRequestReceiver<EventTagMifareClassicDecrementBlockValue>::ManualAnswer(event);
 382         }
 383
 384 }
 385
 386 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicTransferPtr& event) {
 387         try {
 388                 event->switchToManualAnswer();
 389
 390                 m_EventTagMifareClassicTransferPtr = event;
 391
 392                 if( nfc_mifare_transfer(handle, event->getIndex(), MifareClassicTransferManualAnswerCallback, this) != NFC_ERROR_NONE )
 393                 {
 394                         ThrowMsg(Commons::UnknownException, "call back set error");
 395                 }
 396         }
 397         catch (const Commons::Exception& ex) {
 398                 LogError("Exception: " << ex.GetMessage());
 399                 event->setResult(false);
 400
 401                 EventRequestReceiver<EventTagMifareClassicTransfer>::ManualAnswer(event);
 402         }
 403
 404 }
 405
 406 void NFCTagMifareClassic::OnRequestReceived(const EventTagMifareClassicRestorePtr& event) {
 407         try {
 408                 event->switchToManualAnswer();
 409
 410                 m_EventTagMifareClassicRestorePtr = event;
 411
 412                 if( nfc_mifare_restore(handle, event->getIndex(), MifareClassicRestoreManualAnswerCallback, this) != NFC_ERROR_NONE )
 413                 {
 414                         ThrowMsg(Commons::UnknownException, "call back set error");
 415                 }
 416         }
 417         catch (const Commons::Exception& ex) {
 418                 LogError("Exception: " << ex.GetMessage());
 419                 event->setResult(false);
 420
 421                 EventRequestReceiver<EventTagMifareClassicRestore>::ManualAnswer(event);
 422         }
 423
 424 }
 425
 426 }
 427 }
 428 }