1 /* 2 * Copyright (C) 2012 The Android Open Source Project 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 * Tag-reading, tag-writing operations. 19 */ 20 #include "OverrideLog.h" 21 #include "NfcTag.h" 22 #include "JavaClassConstants.h" 23 #include "config.h" 24 #include <ScopedLocalRef.h> 25 #include <ScopedPrimitiveArray.h> 26 27 extern "C" 28 { 29 #include "rw_int.h" 30 #include "nfc_brcm_defs.h" 31 #include "phNxpExtns.h" 32 } 33 34 35 /******************************************************************************* 36 ** 37 ** Function: NfcTag 38 ** 39 ** Description: Initialize member variables. 40 ** 41 ** Returns: None 42 ** 43 *******************************************************************************/ 44 NfcTag::NfcTag () 45 : mNumTechList (0), 46 mTechnologyTimeoutsTable (MAX_NUM_TECHNOLOGY), 47 mNativeData (NULL), 48 mIsActivated (false), 49 mActivationState (Idle), 50 mProtocol(NFC_PROTOCOL_UNKNOWN), 51 mtT1tMaxMessageSize (0), 52 mReadCompletedStatus (NFA_STATUS_OK), 53 mLastKovioUidLen (0), 54 mNdefDetectionTimedOut (false), 55 mIsDynamicTagId (false), 56 mPresenceCheckAlgorithm (NFA_RW_PRES_CHK_DEFAULT), 57 mIsFelicaLite(false) 58 { 59 memset (mTechList, 0, sizeof(mTechList)); 60 memset (mTechHandles, 0, sizeof(mTechHandles)); 61 memset (mTechLibNfcTypes, 0, sizeof(mTechLibNfcTypes)); 62 memset (mTechParams, 0, sizeof(mTechParams)); 63 memset(mLastKovioUid, 0, NFC_KOVIO_MAX_LEN); 64 } 65 66 67 /******************************************************************************* 68 ** 69 ** Function: getInstance 70 ** 71 ** Description: Get a reference to the singleton NfcTag object. 72 ** 73 ** Returns: Reference to NfcTag object. 74 ** 75 *******************************************************************************/ 76 NfcTag& NfcTag::getInstance () 77 { 78 static NfcTag tag; 79 return tag; 80 } 81 82 83 /******************************************************************************* 84 ** 85 ** Function: initialize 86 ** 87 ** Description: Reset member variables. 88 ** native: Native data. 89 ** 90 ** Returns: None 91 ** 92 *******************************************************************************/ 93 void NfcTag::initialize (nfc_jni_native_data* native) 94 { 95 long num = 0; 96 97 mNativeData = native; 98 mIsActivated = false; 99 mActivationState = Idle; 100 mProtocol = NFC_PROTOCOL_UNKNOWN; 101 mNumTechList = 0; 102 mtT1tMaxMessageSize = 0; 103 mReadCompletedStatus = NFA_STATUS_OK; 104 resetTechnologies (); 105 if (GetNumValue(NAME_PRESENCE_CHECK_ALGORITHM, &num, sizeof(num))) 106 mPresenceCheckAlgorithm = num; 107 } 108 109 110 /******************************************************************************* 111 ** 112 ** Function: abort 113 ** 114 ** Description: Unblock all operations. 115 ** 116 ** Returns: None 117 ** 118 *******************************************************************************/ 119 void NfcTag::abort () 120 { 121 SyncEventGuard g (mReadCompleteEvent); 122 mReadCompleteEvent.notifyOne (); 123 } 124 125 126 /******************************************************************************* 127 ** 128 ** Function: getActivationState 129 ** 130 ** Description: What is the current state: Idle, Sleep, or Activated. 131 ** 132 ** Returns: Idle, Sleep, or Activated. 133 ** 134 *******************************************************************************/ 135 NfcTag::ActivationState NfcTag::getActivationState () 136 { 137 return mActivationState; 138 } 139 140 141 /******************************************************************************* 142 ** 143 ** Function: setDeactivationState 144 ** 145 ** Description: Set the current state: Idle or Sleep. 146 ** deactivated: state of deactivation. 147 ** 148 ** Returns: None. 149 ** 150 *******************************************************************************/ 151 void NfcTag::setDeactivationState (tNFA_DEACTIVATED& deactivated) 152 { 153 static const char fn [] = "NfcTag::setDeactivationState"; 154 mActivationState = Idle; 155 mNdefDetectionTimedOut = false; 156 if (deactivated.type == NFA_DEACTIVATE_TYPE_SLEEP) 157 mActivationState = Sleep; 158 ALOGD ("%s: state=%u", fn, mActivationState); 159 } 160 161 162 /******************************************************************************* 163 ** 164 ** Function: setActivationState 165 ** 166 ** Description: Set the current state to Active. 167 ** 168 ** Returns: None. 169 ** 170 *******************************************************************************/ 171 void NfcTag::setActivationState () 172 { 173 static const char fn [] = "NfcTag::setActivationState"; 174 mNdefDetectionTimedOut = false; 175 mActivationState = Active; 176 ALOGD ("%s: state=%u", fn, mActivationState); 177 } 178 179 /******************************************************************************* 180 ** 181 ** Function: isActivated 182 ** 183 ** Description: Is tag activated? 184 ** 185 ** Returns: True if tag is activated. 186 ** 187 *******************************************************************************/ 188 bool NfcTag::isActivated () 189 { 190 return mIsActivated; 191 } 192 193 194 /******************************************************************************* 195 ** 196 ** Function: getProtocol 197 ** 198 ** Description: Get the protocol of the current tag. 199 ** 200 ** Returns: Protocol number. 201 ** 202 *******************************************************************************/ 203 tNFC_PROTOCOL NfcTag::getProtocol() 204 { 205 return mProtocol; 206 } 207 208 /******************************************************************************* 209 ** 210 ** Function TimeDiff 211 ** 212 ** Description Computes time difference in milliseconds. 213 ** 214 ** Returns Time difference in milliseconds 215 ** 216 *******************************************************************************/ 217 UINT32 TimeDiff(timespec start, timespec end) 218 { 219 timespec temp; 220 if ((end.tv_nsec-start.tv_nsec)<0) 221 { 222 temp.tv_sec = end.tv_sec-start.tv_sec-1; 223 temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec; 224 } 225 else 226 { 227 temp.tv_sec = end.tv_sec-start.tv_sec; 228 temp.tv_nsec = end.tv_nsec-start.tv_nsec; 229 } 230 231 return (temp.tv_sec * 1000) + (temp.tv_nsec / 1000000); 232 } 233 234 /******************************************************************************* 235 ** 236 ** Function: IsSameKovio 237 ** 238 ** Description: Checks if tag activate is the same (UID) Kovio tag previously 239 ** activated. This is needed due to a problem with some Kovio 240 ** tags re-activating multiple times. 241 ** activationData: data from activation. 242 ** 243 ** Returns: true if the activation is from the same tag previously 244 ** activated, false otherwise 245 ** 246 *******************************************************************************/ 247 bool NfcTag::IsSameKovio(tNFA_ACTIVATED& activationData) 248 { 249 static const char fn [] = "NfcTag::IsSameKovio"; 250 ALOGD ("%s: enter", fn); 251 tNFC_ACTIVATE_DEVT& rfDetail = activationData.activate_ntf; 252 253 if (rfDetail.protocol != NFC_PROTOCOL_KOVIO) 254 return false; 255 256 memcpy (&(mTechParams[0]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 257 if (mTechParams [0].mode != NFC_DISCOVERY_TYPE_POLL_KOVIO) 258 return false; 259 260 struct timespec now; 261 clock_gettime(CLOCK_REALTIME, &now); 262 263 bool rVal = false; 264 if (mTechParams[0].param.pk.uid_len == mLastKovioUidLen) 265 { 266 if (memcmp(mLastKovioUid, &mTechParams [0].param.pk.uid, mTechParams[0].param.pk.uid_len) == 0) 267 { 268 //same tag 269 if (TimeDiff(mLastKovioTime, now) < 500) 270 { 271 // same tag within 500 ms, ignore activation 272 rVal = true; 273 } 274 } 275 } 276 277 // save Kovio tag info 278 if (!rVal) 279 { 280 if ((mLastKovioUidLen = mTechParams[0].param.pk.uid_len) > NFC_KOVIO_MAX_LEN) 281 mLastKovioUidLen = NFC_KOVIO_MAX_LEN; 282 memcpy(mLastKovioUid, mTechParams[0].param.pk.uid, mLastKovioUidLen); 283 } 284 mLastKovioTime = now; 285 ALOGD ("%s: exit, is same Kovio=%d", fn, rVal); 286 return rVal; 287 } 288 289 /******************************************************************************* 290 ** 291 ** Function: discoverTechnologies 292 ** 293 ** Description: Discover the technologies that NFC service needs by interpreting 294 ** the data structures from the stack. 295 ** activationData: data from activation. 296 ** 297 ** Returns: None 298 ** 299 *******************************************************************************/ 300 void NfcTag::discoverTechnologies (tNFA_ACTIVATED& activationData) 301 { 302 static const char fn [] = "NfcTag::discoverTechnologies (activation)"; 303 ALOGD ("%s: enter", fn); 304 tNFC_ACTIVATE_DEVT& rfDetail = activationData.activate_ntf; 305 306 mNumTechList = 0; 307 mTechHandles [mNumTechList] = rfDetail.rf_disc_id; 308 mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; 309 310 //save the stack's data structure for interpretation later 311 memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 312 313 if (NFC_PROTOCOL_T1T == rfDetail.protocol) 314 { 315 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 316 } 317 else if (NFC_PROTOCOL_T2T == rfDetail.protocol) 318 { 319 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 320 // could be MifFare UL or Classic or Kovio 321 { 322 // need to look at first byte of uid to find Manufacture Byte 323 tNFC_RF_TECH_PARAMS tech_params; 324 memcpy (&tech_params, &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 325 326 if ((tech_params.param.pa.nfcid1[0] == 0x04 && rfDetail.rf_tech_param.param.pa.sel_rsp == 0) || 327 rfDetail.rf_tech_param.param.pa.sel_rsp == 0x18 || 328 rfDetail.rf_tech_param.param.pa.sel_rsp == 0x08) 329 { 330 if (rfDetail.rf_tech_param.param.pa.sel_rsp == 0) 331 { 332 mNumTechList++; 333 mTechHandles [mNumTechList] = rfDetail.rf_disc_id; 334 mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; 335 //save the stack's data structure for interpretation later 336 memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 337 mTechList [mNumTechList] = TARGET_TYPE_MIFARE_UL; //is TagTechnology.MIFARE_ULTRALIGHT by Java API 338 } 339 } 340 } 341 } 342 else if (NFC_PROTOCOL_T3T == rfDetail.protocol) 343 { 344 UINT8 xx = 0; 345 346 mTechList [mNumTechList] = TARGET_TYPE_FELICA; 347 348 //see if it is Felica Lite. 349 while (xx < activationData.params.t3t.num_system_codes) 350 { 351 if (activationData.params.t3t.p_system_codes[xx++] == T3T_SYSTEM_CODE_FELICA_LITE) 352 { 353 mIsFelicaLite = true; 354 break; 355 } 356 } 357 } 358 else if (NFC_PROTOCOL_ISO_DEP == rfDetail.protocol) 359 { 360 //type-4 tag uses technology ISO-DEP and technology A or B 361 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_4; //is TagTechnology.ISO_DEP by Java API 362 if ( (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) || 363 (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) || 364 (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A) || 365 (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) 366 { 367 mNumTechList++; 368 mTechHandles [mNumTechList] = rfDetail.rf_disc_id; 369 mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; 370 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 371 //save the stack's data structure for interpretation later 372 memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 373 } 374 else if ( (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B) || 375 (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) || 376 (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B) || 377 (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ) 378 { 379 mNumTechList++; 380 mTechHandles [mNumTechList] = rfDetail.rf_disc_id; 381 mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; 382 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3B; //is TagTechnology.NFC_B by Java API 383 //save the stack's data structure for interpretation later 384 memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 385 } 386 } 387 else if (NFC_PROTOCOL_15693 == rfDetail.protocol) 388 { 389 //is TagTechnology.NFC_V by Java API 390 mTechList [mNumTechList] = TARGET_TYPE_ISO15693; 391 } 392 else if (NFC_PROTOCOL_KOVIO == rfDetail.protocol) 393 { 394 ALOGD ("%s: Kovio", fn); 395 mTechList [mNumTechList] = TARGET_TYPE_KOVIO_BARCODE; 396 } 397 else if (NFC_PROTOCOL_MIFARE == rfDetail.protocol) 398 { 399 ALOGD ("%s: Mifare Classic", fn); 400 EXTNS_MfcInit (activationData); 401 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 402 mNumTechList++; 403 mTechHandles [mNumTechList] = rfDetail.rf_disc_id; 404 mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; 405 //save the stack's data structure for interpretation later 406 memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); 407 mTechList [mNumTechList] = TARGET_TYPE_MIFARE_CLASSIC; //is TagTechnology.MIFARE_CLASSIC by Java API 408 } 409 else 410 { 411 ALOGE ("%s: unknown protocol ????", fn); 412 mTechList [mNumTechList] = TARGET_TYPE_UNKNOWN; 413 } 414 415 mNumTechList++; 416 for (int i=0; i < mNumTechList; i++) 417 { 418 ALOGD ("%s: index=%d; tech=%d; handle=%d; nfc type=%d", fn, 419 i, mTechList[i], mTechHandles[i], mTechLibNfcTypes[i]); 420 } 421 ALOGD ("%s: exit", fn); 422 } 423 424 425 /******************************************************************************* 426 ** 427 ** Function: discoverTechnologies 428 ** 429 ** Description: Discover the technologies that NFC service needs by interpreting 430 ** the data structures from the stack. 431 ** discoveryData: data from discovery events(s). 432 ** 433 ** Returns: None 434 ** 435 *******************************************************************************/ 436 void NfcTag::discoverTechnologies (tNFA_DISC_RESULT& discoveryData) 437 { 438 static const char fn [] = "NfcTag::discoverTechnologies (discovery)"; 439 tNFC_RESULT_DEVT& discovery_ntf = discoveryData.discovery_ntf; 440 441 ALOGD ("%s: enter: rf disc. id=%u; protocol=%u, mNumTechList=%u", fn, discovery_ntf.rf_disc_id, discovery_ntf.protocol, mNumTechList); 442 if (mNumTechList >= MAX_NUM_TECHNOLOGY) 443 { 444 ALOGE ("%s: exceed max=%d", fn, MAX_NUM_TECHNOLOGY); 445 goto TheEnd; 446 } 447 mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; 448 mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; 449 450 //save the stack's data structure for interpretation later 451 memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); 452 453 if (NFC_PROTOCOL_T1T == discovery_ntf.protocol) 454 { 455 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 456 } 457 else if (NFC_PROTOCOL_T2T == discovery_ntf.protocol) 458 { 459 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 460 //type-2 tags are identical to Mifare Ultralight, so Ultralight is also discovered 461 if ((discovery_ntf.rf_tech_param.param.pa.sel_rsp == 0) && 462 (mNumTechList < (MAX_NUM_TECHNOLOGY-1))) 463 { 464 // Mifare Ultralight 465 mNumTechList++; 466 mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; 467 mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; 468 mTechList [mNumTechList] = TARGET_TYPE_MIFARE_UL; //is TagTechnology.MIFARE_ULTRALIGHT by Java API 469 } 470 471 //save the stack's data structure for interpretation later 472 memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); 473 } 474 else if (NFC_PROTOCOL_T3T == discovery_ntf.protocol) 475 { 476 mTechList [mNumTechList] = TARGET_TYPE_FELICA; 477 } 478 else if (NFC_PROTOCOL_ISO_DEP == discovery_ntf.protocol) 479 { 480 //type-4 tag uses technology ISO-DEP and technology A or B 481 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_4; //is TagTechnology.ISO_DEP by Java API 482 if ( (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) || 483 (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) || 484 (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A) || 485 (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) 486 { 487 if (mNumTechList < (MAX_NUM_TECHNOLOGY-1)) 488 { 489 mNumTechList++; 490 mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; 491 mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; 492 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API 493 //save the stack's data structure for interpretation later 494 memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); 495 } 496 } 497 else if ( (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B) || 498 (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) || 499 (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B) || 500 (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ) 501 { 502 if (mNumTechList < (MAX_NUM_TECHNOLOGY-1)) 503 { 504 mNumTechList++; 505 mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; 506 mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; 507 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3B; //is TagTechnology.NFC_B by Java API 508 //save the stack's data structure for interpretation later 509 memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); 510 } 511 } 512 } 513 else if (NFC_PROTOCOL_15693 == discovery_ntf.protocol) 514 { 515 //is TagTechnology.NFC_V by Java API 516 mTechList [mNumTechList] = TARGET_TYPE_ISO15693; 517 } 518 else if (NFC_PROTOCOL_MIFARE == discovery_ntf.protocol) 519 { 520 mTechList [mNumTechList] = TARGET_TYPE_MIFARE_CLASSIC; 521 if (mNumTechList < (MAX_NUM_TECHNOLOGY-1)) 522 { 523 mNumTechList++; 524 mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; 525 mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; 526 mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; 527 //save the stack's data structure for interpretation later 528 memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); 529 } 530 } 531 else 532 { 533 ALOGE ("%s: unknown protocol ????", fn); 534 mTechList [mNumTechList] = TARGET_TYPE_UNKNOWN; 535 } 536 537 mNumTechList++; 538 if (discovery_ntf.more != NCI_DISCOVER_NTF_MORE) 539 { 540 for (int i=0; i < mNumTechList; i++) 541 { 542 ALOGD ("%s: index=%d; tech=%d; handle=%d; nfc type=%d", fn, 543 i, mTechList[i], mTechHandles[i], mTechLibNfcTypes[i]); 544 } 545 } 546 547 TheEnd: 548 ALOGD ("%s: exit", fn); 549 } 550 551 552 /******************************************************************************* 553 ** 554 ** Function: createNativeNfcTag 555 ** 556 ** Description: Create a brand new Java NativeNfcTag object; 557 ** fill the objects's member variables with data; 558 ** notify NFC service; 559 ** activationData: data from activation. 560 ** 561 ** Returns: None 562 ** 563 *******************************************************************************/ 564 void NfcTag::createNativeNfcTag (tNFA_ACTIVATED& activationData) 565 { 566 static const char fn [] = "NfcTag::createNativeNfcTag"; 567 ALOGD ("%s: enter", fn); 568 569 JNIEnv* e = NULL; 570 ScopedAttach attach(mNativeData->vm, &e); 571 if (e == NULL) 572 { 573 ALOGE("%s: jni env is null", fn); 574 return; 575 } 576 577 ScopedLocalRef<jclass> tag_cls(e, e->GetObjectClass(mNativeData->cached_NfcTag)); 578 if (e->ExceptionCheck()) 579 { 580 e->ExceptionClear(); 581 ALOGE("%s: failed to get class", fn); 582 return; 583 } 584 585 //create a new Java NativeNfcTag object 586 jmethodID ctor = e->GetMethodID(tag_cls.get(), "<init>", "()V"); 587 ScopedLocalRef<jobject> tag(e, e->NewObject(tag_cls.get(), ctor)); 588 589 //fill NativeNfcTag's mProtocols, mTechList, mTechHandles, mTechLibNfcTypes 590 fillNativeNfcTagMembers1(e, tag_cls.get(), tag.get()); 591 592 //fill NativeNfcTag's members: mHandle, mConnectedTechnology 593 fillNativeNfcTagMembers2(e, tag_cls.get(), tag.get(), activationData); 594 595 //fill NativeNfcTag's members: mTechPollBytes 596 fillNativeNfcTagMembers3(e, tag_cls.get(), tag.get(), activationData); 597 598 //fill NativeNfcTag's members: mTechActBytes 599 fillNativeNfcTagMembers4(e, tag_cls.get(), tag.get(), activationData); 600 601 //fill NativeNfcTag's members: mUid 602 fillNativeNfcTagMembers5(e, tag_cls.get(), tag.get(), activationData); 603 604 if (mNativeData->tag != NULL) 605 { 606 e->DeleteGlobalRef(mNativeData->tag); 607 } 608 mNativeData->tag = e->NewGlobalRef(tag.get()); 609 610 //notify NFC service about this new tag 611 ALOGD ("%s: try notify nfc service", fn); 612 e->CallVoidMethod(mNativeData->manager, android::gCachedNfcManagerNotifyNdefMessageListeners, tag.get()); 613 if (e->ExceptionCheck()) 614 { 615 e->ExceptionClear(); 616 ALOGE ("%s: fail notify nfc service", fn); 617 } 618 619 ALOGD ("%s: exit", fn); 620 } 621 622 623 /******************************************************************************* 624 ** 625 ** Function: fillNativeNfcTagMembers1 626 ** 627 ** Description: Fill NativeNfcTag's members: mProtocols, mTechList, mTechHandles, mTechLibNfcTypes. 628 ** e: JVM environment. 629 ** tag_cls: Java NativeNfcTag class. 630 ** tag: Java NativeNfcTag object. 631 ** 632 ** Returns: None 633 ** 634 *******************************************************************************/ 635 void NfcTag::fillNativeNfcTagMembers1 (JNIEnv* e, jclass tag_cls, jobject tag) 636 { 637 static const char fn [] = "NfcTag::fillNativeNfcTagMembers1"; 638 ALOGD ("%s", fn); 639 640 //create objects that represent NativeNfcTag's member variables 641 ScopedLocalRef<jintArray> techList(e, e->NewIntArray(mNumTechList)); 642 ScopedLocalRef<jintArray> handleList(e, e->NewIntArray(mNumTechList)); 643 ScopedLocalRef<jintArray> typeList(e, e->NewIntArray(mNumTechList)); 644 645 { 646 ScopedIntArrayRW technologies(e, techList.get()); 647 ScopedIntArrayRW handles(e, handleList.get()); 648 ScopedIntArrayRW types(e, typeList.get()); 649 for (int i = 0; i < mNumTechList; i++) { 650 mNativeData->tProtocols [i] = mTechLibNfcTypes [i]; 651 mNativeData->handles [i] = mTechHandles [i]; 652 technologies [i] = mTechList [i]; 653 handles [i] = mTechHandles [i]; 654 types [i] = mTechLibNfcTypes [i]; 655 } 656 } 657 658 jfieldID f = NULL; 659 660 f = e->GetFieldID(tag_cls, "mTechList", "[I"); 661 e->SetObjectField(tag, f, techList.get()); 662 663 f = e->GetFieldID(tag_cls, "mTechHandles", "[I"); 664 e->SetObjectField(tag, f, handleList.get()); 665 666 f = e->GetFieldID(tag_cls, "mTechLibNfcTypes", "[I"); 667 e->SetObjectField(tag, f, typeList.get()); 668 } 669 670 671 /******************************************************************************* 672 ** 673 ** Function: fillNativeNfcTagMembers2 674 ** 675 ** Description: Fill NativeNfcTag's members: mConnectedTechIndex or mConnectedTechnology. 676 ** The original Google's implementation is in set_target_pollBytes( 677 ** in com_android_nfc_NativeNfcTag.cpp; 678 ** e: JVM environment. 679 ** tag_cls: Java NativeNfcTag class. 680 ** tag: Java NativeNfcTag object. 681 ** activationData: data from activation. 682 ** 683 ** Returns: None 684 ** 685 *******************************************************************************/ 686 void NfcTag::fillNativeNfcTagMembers2 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& /*activationData*/) 687 { 688 static const char fn [] = "NfcTag::fillNativeNfcTagMembers2"; 689 ALOGD ("%s", fn); 690 jfieldID f = e->GetFieldID(tag_cls, "mConnectedTechIndex", "I"); 691 e->SetIntField(tag, f, (jint) 0); 692 } 693 694 695 /******************************************************************************* 696 ** 697 ** Function: fillNativeNfcTagMembers3 698 ** 699 ** Description: Fill NativeNfcTag's members: mTechPollBytes. 700 ** The original Google's implementation is in set_target_pollBytes( 701 ** in com_android_nfc_NativeNfcTag.cpp; 702 ** e: JVM environment. 703 ** tag_cls: Java NativeNfcTag class. 704 ** tag: Java NativeNfcTag object. 705 ** activationData: data from activation. 706 ** 707 ** Returns: None 708 ** 709 *******************************************************************************/ 710 void NfcTag::fillNativeNfcTagMembers3 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) 711 { 712 static const char fn [] = "NfcTag::fillNativeNfcTagMembers3"; 713 ScopedLocalRef<jbyteArray> pollBytes(e, e->NewByteArray(0)); 714 ScopedLocalRef<jclass> byteArrayClass(e, e->GetObjectClass(pollBytes.get())); 715 ScopedLocalRef<jobjectArray> techPollBytes(e, e->NewObjectArray(mNumTechList, byteArrayClass.get(), 0)); 716 int len = 0; 717 718 for (int i = 0; i < mNumTechList; i++) 719 { 720 ALOGD ("%s: index=%d; rf tech params mode=%u", fn, i, mTechParams [i].mode); 721 if (NFC_DISCOVERY_TYPE_POLL_A == mTechParams [i].mode 722 || NFC_DISCOVERY_TYPE_POLL_A_ACTIVE == mTechParams [i].mode 723 || NFC_DISCOVERY_TYPE_LISTEN_A == mTechParams [i].mode 724 || NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == mTechParams [i].mode) 725 { 726 ALOGD ("%s: tech A", fn); 727 pollBytes.reset(e->NewByteArray(2)); 728 e->SetByteArrayRegion(pollBytes.get(), 0, 2, (jbyte*) mTechParams [i].param.pa.sens_res); 729 } 730 else if (NFC_DISCOVERY_TYPE_POLL_B == mTechParams [i].mode 731 || NFC_DISCOVERY_TYPE_POLL_B_PRIME == mTechParams [i].mode 732 || NFC_DISCOVERY_TYPE_LISTEN_B == mTechParams [i].mode 733 || NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == mTechParams [i].mode) 734 { 735 if (mTechList [i] == TARGET_TYPE_ISO14443_3B) //is TagTechnology.NFC_B by Java API 736 { 737 /***************** 738 see NFC Forum Digital Protocol specification; section 5.6.2; 739 in SENSB_RES response, byte 6 through 9 is Application Data, byte 10-12 or 13 is Protocol Info; 740 used by public API: NfcB.getApplicationData(), NfcB.getProtocolInfo(); 741 *****************/ 742 ALOGD ("%s: tech B; TARGET_TYPE_ISO14443_3B", fn); 743 len = mTechParams [i].param.pb.sensb_res_len; 744 len = len - 4; //subtract 4 bytes for NFCID0 at byte 2 through 5 745 pollBytes.reset(e->NewByteArray(len)); 746 e->SetByteArrayRegion(pollBytes.get(), 0, len, (jbyte*) (mTechParams [i].param.pb.sensb_res+4)); 747 } 748 else 749 { 750 pollBytes.reset(e->NewByteArray(0)); 751 } 752 } 753 else if (NFC_DISCOVERY_TYPE_POLL_F == mTechParams [i].mode 754 || NFC_DISCOVERY_TYPE_POLL_F_ACTIVE == mTechParams [i].mode 755 || NFC_DISCOVERY_TYPE_LISTEN_F == mTechParams [i].mode 756 || NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == mTechParams [i].mode) 757 { 758 /**************** 759 see NFC Forum Type 3 Tag Operation Specification; sections 2.3.2, 2.3.1.2; 760 see NFC Forum Digital Protocol Specification; sections 6.6.2; 761 PMm: manufacture parameter; 8 bytes; 762 System Code: 2 bytes; 763 ****************/ 764 ALOGD ("%s: tech F", fn); 765 UINT8 result [10]; //return result to NFC service 766 memset (result, 0, sizeof(result)); 767 len = 10; 768 769 /**** 770 for (int ii = 0; ii < mTechParams [i].param.pf.sensf_res_len; ii++) 771 { 772 ALOGD ("%s: tech F, sendf_res[%d]=%d (0x%x)", 773 fn, ii, mTechParams [i].param.pf.sensf_res[ii],mTechParams [i].param.pf.sensf_res[ii]); 774 } 775 ***/ 776 memcpy (result, mTechParams [i].param.pf.sensf_res + 8, 8); //copy PMm 777 if (activationData.params.t3t.num_system_codes > 0) //copy the first System Code 778 { 779 UINT16 systemCode = *(activationData.params.t3t.p_system_codes); 780 result [8] = (UINT8) (systemCode >> 8); 781 result [9] = (UINT8) systemCode; 782 ALOGD ("%s: tech F; sys code=0x%X 0x%X", fn, result [8], result [9]); 783 } 784 pollBytes.reset(e->NewByteArray(len)); 785 e->SetByteArrayRegion(pollBytes.get(), 0, len, (jbyte*) result); 786 } 787 else if (NFC_DISCOVERY_TYPE_POLL_ISO15693 == mTechParams [i].mode 788 || NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == mTechParams [i].mode) 789 { 790 ALOGD ("%s: tech iso 15693", fn); 791 //iso 15693 response flags: 1 octet 792 //iso 15693 Data Structure Format Identifier (DSF ID): 1 octet 793 //used by public API: NfcV.getDsfId(), NfcV.getResponseFlags(); 794 uint8_t data [2]= {activationData.params.i93.afi, activationData.params.i93.dsfid}; 795 pollBytes.reset(e->NewByteArray(2)); 796 e->SetByteArrayRegion(pollBytes.get(), 0, 2, (jbyte *) data); 797 } 798 else 799 { 800 ALOGE ("%s: tech unknown ????", fn); 801 pollBytes.reset(e->NewByteArray(0)); 802 } //switch: every type of technology 803 e->SetObjectArrayElement(techPollBytes.get(), i, pollBytes.get()); 804 } //for: every technology in the array 805 jfieldID f = e->GetFieldID(tag_cls, "mTechPollBytes", "[[B"); 806 e->SetObjectField(tag, f, techPollBytes.get()); 807 } 808 809 810 /******************************************************************************* 811 ** 812 ** Function: fillNativeNfcTagMembers4 813 ** 814 ** Description: Fill NativeNfcTag's members: mTechActBytes. 815 ** The original Google's implementation is in set_target_activationBytes() 816 ** in com_android_nfc_NativeNfcTag.cpp; 817 ** e: JVM environment. 818 ** tag_cls: Java NativeNfcTag class. 819 ** tag: Java NativeNfcTag object. 820 ** activationData: data from activation. 821 ** 822 ** Returns: None 823 ** 824 *******************************************************************************/ 825 void NfcTag::fillNativeNfcTagMembers4 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) 826 { 827 static const char fn [] = "NfcTag::fillNativeNfcTagMembers4"; 828 ScopedLocalRef<jbyteArray> actBytes(e, e->NewByteArray(0)); 829 ScopedLocalRef<jclass> byteArrayClass(e, e->GetObjectClass(actBytes.get())); 830 ScopedLocalRef<jobjectArray> techActBytes(e, e->NewObjectArray(mNumTechList, byteArrayClass.get(), 0)); 831 832 for (int i = 0; i < mNumTechList; i++) 833 { 834 ALOGD ("%s: index=%d", fn, i); 835 if (NFC_PROTOCOL_T1T == mTechLibNfcTypes[i] || NFC_PROTOCOL_T2T == mTechLibNfcTypes[i]) 836 { 837 if (mTechLibNfcTypes[i] == NFC_PROTOCOL_T1T) 838 ALOGD ("%s: T1T; tech A", fn); 839 else if (mTechLibNfcTypes[i] == NFC_PROTOCOL_T2T) 840 ALOGD ("%s: T2T; tech A", fn); 841 actBytes.reset(e->NewByteArray(1)); 842 e->SetByteArrayRegion(actBytes.get(), 0, 1, (jbyte*) &mTechParams [i].param.pa.sel_rsp); 843 } 844 else if (NFC_PROTOCOL_T3T == mTechLibNfcTypes[i]) 845 { 846 //felica 847 ALOGD ("%s: T3T; felica; tech F", fn); 848 //really, there is no data 849 actBytes.reset(e->NewByteArray(0)); 850 } 851 else if (NFC_PROTOCOL_MIFARE == mTechLibNfcTypes[i]) 852 { 853 ALOGD ("%s: Mifare Classic; tech A", fn); 854 actBytes.reset (e->NewByteArray(1)); 855 e->SetByteArrayRegion (actBytes.get(), 0, 1, 856 (jbyte*) &mTechParams [i].param.pa.sel_rsp); 857 } 858 else if (NFC_PROTOCOL_ISO_DEP == mTechLibNfcTypes[i]) 859 { 860 //t4t 861 if (mTechList [i] == TARGET_TYPE_ISO14443_4) //is TagTechnology.ISO_DEP by Java API 862 { 863 if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) || 864 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) || 865 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A) || 866 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) 867 { 868 //see NFC Forum Digital Protocol specification, section 11.6.2, "RATS Response"; search for "historical bytes"; 869 //copy historical bytes into Java object; 870 //the public API, IsoDep.getHistoricalBytes(), returns this data; 871 if (activationData.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) 872 { 873 tNFC_INTF_PA_ISO_DEP& pa_iso = activationData.activate_ntf.intf_param.intf_param.pa_iso; 874 ALOGD ("%s: T4T; ISO_DEP for tech A; copy historical bytes; len=%u", fn, pa_iso.his_byte_len); 875 actBytes.reset(e->NewByteArray(pa_iso.his_byte_len)); 876 if (pa_iso.his_byte_len > 0) 877 e->SetByteArrayRegion(actBytes.get(), 0, pa_iso.his_byte_len, (jbyte*) (pa_iso.his_byte)); 878 } 879 else 880 { 881 ALOGE ("%s: T4T; ISO_DEP for tech A; wrong interface=%u", fn, activationData.activate_ntf.intf_param.type); 882 actBytes.reset(e->NewByteArray(0)); 883 } 884 } 885 else if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_B) || 886 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) || 887 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_B) || 888 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ) 889 { 890 //see NFC Forum Digital Protocol specification, section 12.6.2, "ATTRIB Response"; 891 //copy higher-layer response bytes into Java object; 892 //the public API, IsoDep.getHiLayerResponse(), returns this data; 893 if (activationData.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) 894 { 895 tNFC_INTF_PB_ISO_DEP& pb_iso = activationData.activate_ntf.intf_param.intf_param.pb_iso; 896 ALOGD ("%s: T4T; ISO_DEP for tech B; copy response bytes; len=%u", fn, pb_iso.hi_info_len); 897 actBytes.reset(e->NewByteArray(pb_iso.hi_info_len)); 898 if (pb_iso.hi_info_len > 0) 899 e->SetByteArrayRegion(actBytes.get(), 0, pb_iso.hi_info_len, (jbyte*) (pb_iso.hi_info)); 900 } 901 else 902 { 903 ALOGE ("%s: T4T; ISO_DEP for tech B; wrong interface=%u", fn, activationData.activate_ntf.intf_param.type); 904 actBytes.reset(e->NewByteArray(0)); 905 } 906 } 907 } 908 else if (mTechList [i] == TARGET_TYPE_ISO14443_3A) //is TagTechnology.NFC_A by Java API 909 { 910 ALOGD ("%s: T4T; tech A", fn); 911 actBytes.reset(e->NewByteArray(1)); 912 e->SetByteArrayRegion(actBytes.get(), 0, 1, (jbyte*) &mTechParams [i].param.pa.sel_rsp); 913 } 914 else 915 { 916 actBytes.reset(e->NewByteArray(0)); 917 } 918 } //case NFC_PROTOCOL_ISO_DEP: //t4t 919 else if (NFC_PROTOCOL_15693 == mTechLibNfcTypes[i]) 920 { 921 ALOGD ("%s: tech iso 15693", fn); 922 //iso 15693 response flags: 1 octet 923 //iso 15693 Data Structure Format Identifier (DSF ID): 1 octet 924 //used by public API: NfcV.getDsfId(), NfcV.getResponseFlags(); 925 uint8_t data [2]= {activationData.params.i93.afi, activationData.params.i93.dsfid}; 926 actBytes.reset(e->NewByteArray(2)); 927 e->SetByteArrayRegion(actBytes.get(), 0, 2, (jbyte *) data); 928 } 929 else 930 { 931 ALOGD ("%s: tech unknown ????", fn); 932 actBytes.reset(e->NewByteArray(0)); 933 } 934 e->SetObjectArrayElement(techActBytes.get(), i, actBytes.get()); 935 } //for: every technology in the array 936 jfieldID f = e->GetFieldID (tag_cls, "mTechActBytes", "[[B"); 937 e->SetObjectField(tag, f, techActBytes.get()); 938 } 939 940 941 /******************************************************************************* 942 ** 943 ** Function: fillNativeNfcTagMembers5 944 ** 945 ** Description: Fill NativeNfcTag's members: mUid. 946 ** The original Google's implementation is in nfc_jni_Discovery_notification_callback() 947 ** in com_android_nfc_NativeNfcManager.cpp; 948 ** e: JVM environment. 949 ** tag_cls: Java NativeNfcTag class. 950 ** tag: Java NativeNfcTag object. 951 ** activationData: data from activation. 952 ** 953 ** Returns: None 954 ** 955 *******************************************************************************/ 956 void NfcTag::fillNativeNfcTagMembers5 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) 957 { 958 static const char fn [] = "NfcTag::fillNativeNfcTagMembers5"; 959 int len = 0; 960 ScopedLocalRef<jbyteArray> uid(e, NULL); 961 962 if (NFC_DISCOVERY_TYPE_POLL_KOVIO == mTechParams [0].mode) 963 { 964 ALOGD ("%s: Kovio", fn); 965 len = mTechParams [0].param.pk.uid_len; 966 uid.reset(e->NewByteArray(len)); 967 e->SetByteArrayRegion(uid.get(), 0, len, 968 (jbyte*) &mTechParams [0].param.pk.uid); 969 } 970 else if (NFC_DISCOVERY_TYPE_POLL_A == mTechParams [0].mode 971 || NFC_DISCOVERY_TYPE_POLL_A_ACTIVE == mTechParams [0].mode 972 || NFC_DISCOVERY_TYPE_LISTEN_A == mTechParams [0].mode 973 || NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == mTechParams [0].mode) 974 { 975 ALOGD ("%s: tech A", fn); 976 len = mTechParams [0].param.pa.nfcid1_len; 977 uid.reset(e->NewByteArray(len)); 978 e->SetByteArrayRegion(uid.get(), 0, len, 979 (jbyte*) &mTechParams [0].param.pa.nfcid1); 980 //a tag's NFCID1 can change dynamically at each activation; 981 //only the first byte (0x08) is constant; a dynamic NFCID1's length 982 //must be 4 bytes (see NFC Digitial Protocol, 983 //section 4.7.2 SDD_RES Response, Requirements 20). 984 mIsDynamicTagId = (mTechParams [0].param.pa.nfcid1_len == 4) && 985 (mTechParams [0].param.pa.nfcid1 [0] == 0x08); 986 } 987 else if (NFC_DISCOVERY_TYPE_POLL_B == mTechParams [0].mode 988 || NFC_DISCOVERY_TYPE_POLL_B_PRIME == mTechParams [0].mode 989 || NFC_DISCOVERY_TYPE_LISTEN_B == mTechParams [0].mode 990 || NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == mTechParams [0].mode) 991 { 992 ALOGD ("%s: tech B", fn); 993 uid.reset(e->NewByteArray(NFC_NFCID0_MAX_LEN)); 994 e->SetByteArrayRegion(uid.get(), 0, NFC_NFCID0_MAX_LEN, 995 (jbyte*) &mTechParams [0].param.pb.nfcid0); 996 } 997 else if (NFC_DISCOVERY_TYPE_POLL_F == mTechParams [0].mode 998 || NFC_DISCOVERY_TYPE_POLL_F_ACTIVE == mTechParams [0].mode 999 || NFC_DISCOVERY_TYPE_LISTEN_F == mTechParams [0].mode 1000 || NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == mTechParams [0].mode) 1001 { 1002 uid.reset(e->NewByteArray(NFC_NFCID2_LEN)); 1003 e->SetByteArrayRegion(uid.get(), 0, NFC_NFCID2_LEN, 1004 (jbyte*) &mTechParams [0].param.pf.nfcid2); 1005 ALOGD ("%s: tech F", fn); 1006 } 1007 else if (NFC_DISCOVERY_TYPE_POLL_ISO15693 == mTechParams [0].mode 1008 || NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == mTechParams [0].mode) 1009 { 1010 ALOGD ("%s: tech iso 15693", fn); 1011 jbyte data [I93_UID_BYTE_LEN]; //8 bytes 1012 for (int i=0; i<I93_UID_BYTE_LEN; ++i) //reverse the ID 1013 data[i] = activationData.params.i93.uid [I93_UID_BYTE_LEN - i - 1]; 1014 uid.reset(e->NewByteArray(I93_UID_BYTE_LEN)); 1015 e->SetByteArrayRegion(uid.get(), 0, I93_UID_BYTE_LEN, data); 1016 } 1017 else 1018 { 1019 ALOGE ("%s: tech unknown ????", fn); 1020 uid.reset(e->NewByteArray(0)); 1021 } 1022 jfieldID f = e->GetFieldID(tag_cls, "mUid", "[B"); 1023 e->SetObjectField(tag, f, uid.get()); 1024 } 1025 1026 1027 /******************************************************************************* 1028 ** 1029 ** Function: isP2pDiscovered 1030 ** 1031 ** Description: Does the peer support P2P? 1032 ** 1033 ** Returns: True if the peer supports P2P. 1034 ** 1035 *******************************************************************************/ 1036 bool NfcTag::isP2pDiscovered () 1037 { 1038 static const char fn [] = "NfcTag::isP2pDiscovered"; 1039 bool retval = false; 1040 1041 for (int i = 0; i < mNumTechList; i++) 1042 { 1043 if (mTechLibNfcTypes[i] == NFA_PROTOCOL_NFC_DEP) 1044 { 1045 //if remote device supports P2P 1046 ALOGD ("%s: discovered P2P", fn); 1047 retval = true; 1048 break; 1049 } 1050 } 1051 ALOGD ("%s: return=%u", fn, retval); 1052 return retval; 1053 } 1054 1055 1056 /******************************************************************************* 1057 ** 1058 ** Function: selectP2p 1059 ** 1060 ** Description: Select the preferred P2P technology if there is a choice. 1061 ** 1062 ** Returns: None 1063 ** 1064 *******************************************************************************/ 1065 void NfcTag::selectP2p() 1066 { 1067 static const char fn [] = "NfcTag::selectP2p"; 1068 UINT8 rfDiscoveryId = 0; 1069 1070 for (int i = 0; i < mNumTechList; i++) 1071 { 1072 //if remote device does not support P2P, just skip it 1073 if (mTechLibNfcTypes[i] != NFA_PROTOCOL_NFC_DEP) 1074 continue; 1075 1076 //if remote device supports tech F; 1077 //tech F is preferred because it is faster than tech A 1078 if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_F) || 1079 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_F_ACTIVE) ) 1080 { 1081 rfDiscoveryId = mTechHandles[i]; 1082 break; //no need to search further 1083 } 1084 else if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) || 1085 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ) 1086 { 1087 //only choose tech A if tech F is unavailable 1088 if (rfDiscoveryId == 0) 1089 rfDiscoveryId = mTechHandles[i]; 1090 } 1091 } 1092 1093 if (rfDiscoveryId > 0) 1094 { 1095 ALOGD ("%s: select P2P; target rf discov id=0x%X", fn, rfDiscoveryId); 1096 tNFA_STATUS stat = NFA_Select (rfDiscoveryId, NFA_PROTOCOL_NFC_DEP, NFA_INTERFACE_NFC_DEP); 1097 if (stat != NFA_STATUS_OK) 1098 ALOGE ("%s: fail select P2P; error=0x%X", fn, stat); 1099 } 1100 else 1101 ALOGE ("%s: cannot find P2P", fn); 1102 resetTechnologies (); 1103 } 1104 1105 1106 /******************************************************************************* 1107 ** 1108 ** Function: resetTechnologies 1109 ** 1110 ** Description: Clear all data related to the technology, protocol of the tag. 1111 ** 1112 ** Returns: None 1113 ** 1114 *******************************************************************************/ 1115 void NfcTag::resetTechnologies () 1116 { 1117 static const char fn [] = "NfcTag::resetTechnologies"; 1118 ALOGD ("%s", fn); 1119 mNumTechList = 0; 1120 memset (mTechList, 0, sizeof(mTechList)); 1121 memset (mTechHandles, 0, sizeof(mTechHandles)); 1122 memset (mTechLibNfcTypes, 0, sizeof(mTechLibNfcTypes)); 1123 memset (mTechParams, 0, sizeof(mTechParams)); 1124 mIsDynamicTagId = false; 1125 mIsFelicaLite = false; 1126 resetAllTransceiveTimeouts (); 1127 } 1128 1129 1130 /******************************************************************************* 1131 ** 1132 ** Function: selectFirstTag 1133 ** 1134 ** Description: When multiple tags are discovered, just select the first one to activate. 1135 ** 1136 ** Returns: None 1137 ** 1138 *******************************************************************************/ 1139 void NfcTag::selectFirstTag () 1140 { 1141 static const char fn [] = "NfcTag::selectFirstTag"; 1142 int foundIdx = -1; 1143 tNFA_INTF_TYPE rf_intf = NFA_INTERFACE_FRAME; 1144 1145 for (int i = 0; i < mNumTechList; i++) 1146 { 1147 ALOGD ("%s: nfa target idx=%d h=0x%X; protocol=0x%X", 1148 fn, i, mTechHandles [i], mTechLibNfcTypes [i]); 1149 if (mTechLibNfcTypes[i] != NFA_PROTOCOL_NFC_DEP) 1150 { 1151 foundIdx = i; 1152 break; 1153 } 1154 } 1155 1156 if (foundIdx != -1) 1157 { 1158 if (mTechLibNfcTypes [foundIdx] == NFA_PROTOCOL_ISO_DEP) 1159 { 1160 rf_intf = NFA_INTERFACE_ISO_DEP; 1161 } 1162 else if (mTechLibNfcTypes [foundIdx] == NFA_PROTOCOL_MIFARE) 1163 { 1164 rf_intf = NFA_INTERFACE_MIFARE; 1165 } 1166 else 1167 rf_intf = NFA_INTERFACE_FRAME; 1168 1169 tNFA_STATUS stat = NFA_Select (mTechHandles [foundIdx], mTechLibNfcTypes [foundIdx], rf_intf); 1170 if (stat != NFA_STATUS_OK) 1171 ALOGE ("%s: fail select; error=0x%X", fn, stat); 1172 } 1173 else 1174 ALOGE ("%s: only found NFC-DEP technology.", fn); 1175 } 1176 1177 1178 /******************************************************************************* 1179 ** 1180 ** Function: getT1tMaxMessageSize 1181 ** 1182 ** Description: Get the maximum size (octet) that a T1T can store. 1183 ** 1184 ** Returns: Maximum size in octets. 1185 ** 1186 *******************************************************************************/ 1187 int NfcTag::getT1tMaxMessageSize () 1188 { 1189 static const char fn [] = "NfcTag::getT1tMaxMessageSize"; 1190 1191 if (mProtocol != NFC_PROTOCOL_T1T) 1192 { 1193 ALOGE ("%s: wrong protocol %u", fn, mProtocol); 1194 return 0; 1195 } 1196 return mtT1tMaxMessageSize; 1197 } 1198 1199 1200 /******************************************************************************* 1201 ** 1202 ** Function: calculateT1tMaxMessageSize 1203 ** 1204 ** Description: Calculate type-1 tag's max message size based on header ROM bytes. 1205 ** activate: reference to activation data. 1206 ** 1207 ** Returns: None 1208 ** 1209 *******************************************************************************/ 1210 void NfcTag::calculateT1tMaxMessageSize (tNFA_ACTIVATED& activate) 1211 { 1212 static const char fn [] = "NfcTag::calculateT1tMaxMessageSize"; 1213 1214 //make sure the tag is type-1 1215 if (activate.activate_ntf.protocol != NFC_PROTOCOL_T1T) 1216 { 1217 mtT1tMaxMessageSize = 0; 1218 return; 1219 } 1220 1221 //examine the first byte of header ROM bytes 1222 switch (activate.params.t1t.hr[0]) 1223 { 1224 case RW_T1T_IS_TOPAZ96: 1225 mtT1tMaxMessageSize = 90; 1226 break; 1227 case RW_T1T_IS_TOPAZ512: 1228 mtT1tMaxMessageSize = 462; 1229 break; 1230 default: 1231 ALOGE ("%s: unknown T1T HR0=%u", fn, activate.params.t1t.hr[0]); 1232 mtT1tMaxMessageSize = 0; 1233 break; 1234 } 1235 } 1236 1237 1238 /******************************************************************************* 1239 ** 1240 ** Function: isMifareUltralight 1241 ** 1242 ** Description: Whether the currently activated tag is Mifare Ultralight. 1243 ** 1244 ** Returns: True if tag is Mifare Ultralight. 1245 ** 1246 *******************************************************************************/ 1247 bool NfcTag::isMifareUltralight () 1248 { 1249 static const char fn [] = "NfcTag::isMifareUltralight"; 1250 bool retval = false; 1251 1252 for (int i =0; i < mNumTechList; i++) 1253 { 1254 if (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) 1255 { 1256 //see NFC Digital Protocol, section 4.6.3 (SENS_RES); section 4.8.2 (SEL_RES). 1257 //see "MF0ICU1 Functional specification MIFARE Ultralight", Rev. 3.4 - 4 February 2008, 1258 //section 6.7. 1259 if ( (mTechParams[i].param.pa.sens_res[0] == 0x44) && 1260 (mTechParams[i].param.pa.sens_res[1] == 0) && 1261 ( (mTechParams[i].param.pa.sel_rsp == 0) || (mTechParams[i].param.pa.sel_rsp == 0x04) ) && 1262 (mTechParams[i].param.pa.nfcid1[0] == 0x04) ) 1263 { 1264 retval = true; 1265 } 1266 break; 1267 } 1268 } 1269 ALOGD ("%s: return=%u", fn, retval); 1270 return retval; 1271 } 1272 1273 1274 /******************************************************************************* 1275 ** 1276 ** Function: isMifareDESFire 1277 ** 1278 ** Description: Whether the currently activated tag is Mifare DESFire. 1279 ** 1280 ** Returns: True if tag is Mifare DESFire. 1281 ** 1282 *******************************************************************************/ 1283 bool NfcTag::isMifareDESFire () 1284 { 1285 static const char fn [] = "NfcTag::isMifareDESFire"; 1286 bool retval = false; 1287 1288 for (int i =0; i < mNumTechList; i++) 1289 { 1290 if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) || 1291 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A) || 1292 (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) 1293 { 1294 /* DESfire has one sak byte and 2 ATQA bytes */ 1295 if ( (mTechParams[i].param.pa.sens_res[0] == 0x44) && 1296 (mTechParams[i].param.pa.sens_res[1] == 0x03) && 1297 (mTechParams[i].param.pa.sel_rsp == 0x20) ) 1298 { 1299 retval = true; 1300 } 1301 break; 1302 } 1303 } 1304 1305 ALOGD ("%s: return=%u", fn, retval); 1306 return retval; 1307 } 1308 1309 1310 /******************************************************************************* 1311 ** 1312 ** Function: isFelicaLite 1313 ** 1314 ** Description: Whether the currently activated tag is Felica Lite. 1315 ** 1316 ** Returns: True if tag is Felica Lite. 1317 ** 1318 *******************************************************************************/ 1319 1320 bool NfcTag::isFelicaLite () 1321 { 1322 return mIsFelicaLite; 1323 } 1324 1325 1326 /******************************************************************************* 1327 ** 1328 ** Function: isT2tNackResponse 1329 ** 1330 ** Description: Whether the response is a T2T NACK response. 1331 ** See NFC Digital Protocol Technical Specification (2010-11-17). 1332 ** Chapter 9 (Type 2 Tag Platform), section 9.6 (READ). 1333 ** response: buffer contains T2T response. 1334 ** responseLen: length of the response. 1335 ** 1336 ** Returns: True if the response is NACK 1337 ** 1338 *******************************************************************************/ 1339 bool NfcTag::isT2tNackResponse (const UINT8* response, UINT32 responseLen) 1340 { 1341 static const char fn [] = "NfcTag::isT2tNackResponse"; 1342 bool isNack = false; 1343 1344 if (responseLen == 1) 1345 { 1346 if (response[0] == 0xA) 1347 isNack = false; //an ACK response, so definitely not a NACK 1348 else 1349 isNack = true; //assume every value is a NACK 1350 } 1351 ALOGD ("%s: return %u", fn, isNack); 1352 return isNack; 1353 } 1354 1355 1356 /******************************************************************************* 1357 ** 1358 ** Function: isNdefDetectionTimedOut 1359 ** 1360 ** Description: Whether NDEF-detection algorithm timed out. 1361 ** 1362 ** Returns: True if NDEF-detection algorithm timed out. 1363 ** 1364 *******************************************************************************/ 1365 bool NfcTag::isNdefDetectionTimedOut () 1366 { 1367 return mNdefDetectionTimedOut; 1368 } 1369 1370 1371 /******************************************************************************* 1372 ** 1373 ** Function: connectionEventHandler 1374 ** 1375 ** Description: Handle connection-related events. 1376 ** event: event code. 1377 ** data: pointer to event data. 1378 ** 1379 ** Returns: None 1380 ** 1381 *******************************************************************************/ 1382 void NfcTag::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* data) 1383 { 1384 static const char fn [] = "NfcTag::connectionEventHandler"; 1385 1386 switch (event) 1387 { 1388 case NFA_DISC_RESULT_EVT: 1389 { 1390 tNFA_DISC_RESULT& disc_result = data->disc_result; 1391 if (disc_result.status == NFA_STATUS_OK) 1392 { 1393 discoverTechnologies (disc_result); 1394 } 1395 } 1396 break; 1397 1398 case NFA_ACTIVATED_EVT: 1399 // Only do tag detection if we are polling and it is not 'EE Direct RF' activation 1400 // (which may happen when we are activated as a tag). 1401 if (data->activated.activate_ntf.rf_tech_param.mode < NCI_DISCOVERY_TYPE_LISTEN_A 1402 && data->activated.activate_ntf.intf_param.type != NFC_INTERFACE_EE_DIRECT_RF) 1403 { 1404 tNFA_ACTIVATED& activated = data->activated; 1405 if (IsSameKovio(activated)) 1406 break; 1407 mIsActivated = true; 1408 mProtocol = activated.activate_ntf.protocol; 1409 calculateT1tMaxMessageSize (activated); 1410 discoverTechnologies (activated); 1411 createNativeNfcTag (activated); 1412 } 1413 break; 1414 1415 case NFA_DEACTIVATED_EVT: 1416 mIsActivated = false; 1417 mProtocol = NFC_PROTOCOL_UNKNOWN; 1418 resetTechnologies (); 1419 break; 1420 1421 case NFA_READ_CPLT_EVT: 1422 { 1423 SyncEventGuard g (mReadCompleteEvent); 1424 mReadCompletedStatus = data->status; 1425 mReadCompleteEvent.notifyOne (); 1426 } 1427 break; 1428 1429 case NFA_NDEF_DETECT_EVT: 1430 { 1431 tNFA_NDEF_DETECT& ndef_detect = data->ndef_detect; 1432 mNdefDetectionTimedOut = ndef_detect.status == NFA_STATUS_TIMEOUT; 1433 if (mNdefDetectionTimedOut) 1434 ALOGE ("%s: NDEF detection timed out", fn); 1435 } 1436 } 1437 } 1438 1439 1440 /******************************************************************************* 1441 ** 1442 ** Function setActive 1443 ** 1444 ** Description Sets the active state for the object 1445 ** 1446 ** Returns None. 1447 ** 1448 *******************************************************************************/ 1449 void NfcTag::setActive(bool active) 1450 { 1451 mIsActivated = active; 1452 } 1453 1454 1455 /******************************************************************************* 1456 ** 1457 ** Function: isDynamicTagId 1458 ** 1459 ** Description: Whether a tag has a dynamic tag ID. 1460 ** 1461 ** Returns: True if ID is dynamic. 1462 ** 1463 *******************************************************************************/ 1464 bool NfcTag::isDynamicTagId () 1465 { 1466 return mIsDynamicTagId && 1467 (mTechList [0] == TARGET_TYPE_ISO14443_4) && //type-4 tag 1468 (mTechList [1] == TARGET_TYPE_ISO14443_3A); //tech A 1469 } 1470 1471 1472 /******************************************************************************* 1473 ** 1474 ** Function: resetAllTransceiveTimeouts 1475 ** 1476 ** Description: Reset all timeouts for all technologies to default values. 1477 ** 1478 ** Returns: none 1479 ** 1480 *******************************************************************************/ 1481 void NfcTag::resetAllTransceiveTimeouts () 1482 { 1483 mTechnologyTimeoutsTable [TARGET_TYPE_ISO14443_3A] = 618; //NfcA 1484 mTechnologyTimeoutsTable [TARGET_TYPE_ISO14443_3B] = 1000; //NfcB 1485 mTechnologyTimeoutsTable [TARGET_TYPE_ISO14443_4] = 618; //ISO-DEP 1486 mTechnologyTimeoutsTable [TARGET_TYPE_FELICA] = 255; //Felica 1487 mTechnologyTimeoutsTable [TARGET_TYPE_ISO15693] = 1000;//NfcV 1488 mTechnologyTimeoutsTable [TARGET_TYPE_NDEF] = 1000; 1489 mTechnologyTimeoutsTable [TARGET_TYPE_NDEF_FORMATABLE] = 1000; 1490 mTechnologyTimeoutsTable [TARGET_TYPE_MIFARE_CLASSIC] = 618; //MifareClassic 1491 mTechnologyTimeoutsTable [TARGET_TYPE_MIFARE_UL] = 618; //MifareUltralight 1492 mTechnologyTimeoutsTable [TARGET_TYPE_KOVIO_BARCODE] = 1000; //NfcBarcode 1493 } 1494 1495 /******************************************************************************* 1496 ** 1497 ** Function: getTransceiveTimeout 1498 ** 1499 ** Description: Get the timeout value for one technology. 1500 ** techId: one of the values in TARGET_TYPE_* defined in NfcJniUtil.h 1501 ** 1502 ** Returns: Timeout value in millisecond. 1503 ** 1504 *******************************************************************************/ 1505 int NfcTag::getTransceiveTimeout (int techId) 1506 { 1507 static const char fn [] = "NfcTag::getTransceiveTimeout"; 1508 int retval = 1000; 1509 if ((techId > 0) && (techId < (int) mTechnologyTimeoutsTable.size())) 1510 retval = mTechnologyTimeoutsTable [techId]; 1511 else 1512 ALOGE ("%s: invalid tech=%d", fn, techId); 1513 return retval; 1514 } 1515 1516 1517 /******************************************************************************* 1518 ** 1519 ** Function: setTransceiveTimeout 1520 ** 1521 ** Description: Set the timeout value for one technology. 1522 ** techId: one of the values in TARGET_TYPE_* defined in NfcJniUtil.h 1523 ** timeout: timeout value in millisecond. 1524 ** 1525 ** Returns: Timeout value. 1526 ** 1527 *******************************************************************************/ 1528 void NfcTag::setTransceiveTimeout (int techId, int timeout) 1529 { 1530 static const char fn [] = "NfcTag::setTransceiveTimeout"; 1531 if ((techId >= 0) && (techId < (int) mTechnologyTimeoutsTable.size())) 1532 mTechnologyTimeoutsTable [techId] = timeout; 1533 else 1534 ALOGE ("%s: invalid tech=%d", fn, techId); 1535 } 1536 1537 1538 /******************************************************************************* 1539 ** 1540 ** Function: getPresenceCheckAlgorithm 1541 ** 1542 ** Description: Get presence-check algorithm from .conf file. 1543 ** 1544 ** Returns: Presence-check algorithm. 1545 ** 1546 *******************************************************************************/ 1547 tNFA_RW_PRES_CHK_OPTION NfcTag::getPresenceCheckAlgorithm () 1548 { 1549 return mPresenceCheckAlgorithm; 1550 } 1551 1552 1553 /******************************************************************************* 1554 ** 1555 ** Function: isInfineonMyDMove 1556 ** 1557 ** Description: Whether the currently activated tag is Infineon My-D Move. 1558 ** 1559 ** Returns: True if tag is Infineon My-D Move. 1560 ** 1561 *******************************************************************************/ 1562 bool NfcTag::isInfineonMyDMove () 1563 { 1564 static const char fn [] = "NfcTag::isInfineonMyDMove"; 1565 bool retval = false; 1566 1567 for (int i =0; i < mNumTechList; i++) 1568 { 1569 if (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) 1570 { 1571 //see Infineon my-d move, my-d move NFC, SLE 66R01P, SLE 66R01PN, 1572 //Short Product Information, 2011-11-24, section 3.5 1573 if (mTechParams[i].param.pa.nfcid1[0] == 0x05) 1574 { 1575 UINT8 highNibble = mTechParams[i].param.pa.nfcid1[1] & 0xF0; 1576 if (highNibble == 0x30) 1577 retval = true; 1578 } 1579 break; 1580 } 1581 } 1582 ALOGD ("%s: return=%u", fn, retval); 1583 return retval; 1584 } 1585 1586 1587 /******************************************************************************* 1588 ** 1589 ** Function: isKovioType2Tag 1590 ** 1591 ** Description: Whether the currently activated tag is Kovio Type-2 tag. 1592 ** 1593 ** Returns: True if tag is Kovio Type-2 tag. 1594 ** 1595 *******************************************************************************/ 1596 bool NfcTag::isKovioType2Tag () 1597 { 1598 static const char fn [] = "NfcTag::isKovioType2Tag"; 1599 bool retval = false; 1600 1601 for (int i =0; i < mNumTechList; i++) 1602 { 1603 if (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) 1604 { 1605 //Kovio 2Kb RFID Tag, Functional Specification, 1606 //March 2, 2012, v2.0, section 8.3. 1607 if (mTechParams[i].param.pa.nfcid1[0] == 0x37) 1608 retval = true; 1609 break; 1610 } 1611 } 1612 ALOGD ("%s: return=%u", fn, retval); 1613 return retval; 1614 } 1615
