NativeNfcManager.cpp revision d53c2b599c73f7404b5a604be4d9a5449cafdd72
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#include <semaphore.h> 18#include <errno.h> 19#include "OverrideLog.h" 20#include "NfcJniUtil.h" 21#include "NfcAdaptation.h" 22#include "SyncEvent.h" 23#include "PeerToPeer.h" 24#include "SecureElement.h" 25#include "RoutingManager.h" 26#include "NfcTag.h" 27#include "config.h" 28#include "PowerSwitch.h" 29#include "JavaClassConstants.h" 30#include "Pn544Interop.h" 31#include <ScopedLocalRef.h> 32#include <ScopedUtfChars.h> 33#include <ScopedPrimitiveArray.h> 34 35extern "C" 36{ 37 #include "nfa_api.h" 38 #include "nfa_p2p_api.h" 39 #include "rw_api.h" 40 #include "nfa_ee_api.h" 41 #include "nfc_brcm_defs.h" 42 #include "ce_api.h" 43} 44 45extern UINT8 *p_nfa_dm_start_up_cfg; 46extern const UINT8 nfca_version_string []; 47namespace android 48{ 49 extern bool gIsTagDeactivating; 50 extern bool gIsSelectingRfInterface; 51 extern void nativeNfcTag_doTransceiveStatus (uint8_t * buf, uint32_t buflen); 52 extern void nativeNfcTag_doConnectStatus (jboolean is_connect_ok); 53 extern void nativeNfcTag_doDeactivateStatus (int status); 54 extern void nativeNfcTag_doWriteStatus (jboolean is_write_ok); 55 extern void nativeNfcTag_doCheckNdefResult (tNFA_STATUS status, uint32_t max_size, uint32_t current_size, uint8_t flags); 56 extern void nativeNfcTag_doMakeReadonlyResult (tNFA_STATUS status); 57 extern void nativeNfcTag_doPresenceCheckResult (tNFA_STATUS status); 58 extern void nativeNfcTag_formatStatus (bool is_ok); 59 extern void nativeNfcTag_resetPresenceCheck (); 60 extern void nativeNfcTag_doReadCompleted (tNFA_STATUS status); 61 extern void nativeNfcTag_abortWaits (); 62 extern void nativeLlcpConnectionlessSocket_abortWait (); 63 extern void nativeNfcTag_registerNdefTypeHandler (); 64 extern void nativeLlcpConnectionlessSocket_receiveData (uint8_t* data, uint32_t len, uint32_t remote_sap); 65} 66 67 68/***************************************************************************** 69** 70** public variables and functions 71** 72*****************************************************************************/ 73 74namespace android 75{ 76 int gGeneralTransceiveTimeout = 1000; 77 jmethodID gCachedNfcManagerNotifyNdefMessageListeners; 78 jmethodID gCachedNfcManagerNotifyTransactionListeners; 79 jmethodID gCachedNfcManagerNotifyLlcpLinkActivation; 80 jmethodID gCachedNfcManagerNotifyLlcpLinkDeactivated; 81 jmethodID gCachedNfcManagerNotifyLlcpFirstPacketReceived; 82 jmethodID gCachedNfcManagerNotifySeFieldActivated; 83 jmethodID gCachedNfcManagerNotifySeFieldDeactivated; 84 jmethodID gCachedNfcManagerNotifySeListenActivated; 85 jmethodID gCachedNfcManagerNotifySeListenDeactivated; 86 jmethodID gCachedNfcManagerNotifyHostEmuActivated; 87 jmethodID gCachedNfcManagerNotifyHostEmuData; 88 jmethodID gCachedNfcManagerNotifyHostEmuDeactivated; 89 const char* gNativeP2pDeviceClassName = "com/android/nfc/dhimpl/NativeP2pDevice"; 90 const char* gNativeLlcpServiceSocketClassName = "com/android/nfc/dhimpl/NativeLlcpServiceSocket"; 91 const char* gNativeLlcpConnectionlessSocketClassName = "com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket"; 92 const char* gNativeLlcpSocketClassName = "com/android/nfc/dhimpl/NativeLlcpSocket"; 93 const char* gNativeNfcTagClassName = "com/android/nfc/dhimpl/NativeNfcTag"; 94 const char* gNativeNfcManagerClassName = "com/android/nfc/dhimpl/NativeNfcManager"; 95 const char* gNativeNfcSecureElementClassName = "com/android/nfc/dhimpl/NativeNfcSecureElement"; 96 void doStartupConfig (); 97 void startStopPolling (bool isStartPolling); 98 void startRfDiscovery (bool isStart); 99 void setUiccIdleTimeout (bool enable); 100} 101 102 103/***************************************************************************** 104** 105** private variables and functions 106** 107*****************************************************************************/ 108namespace android 109{ 110static jint sLastError = ERROR_BUFFER_TOO_SMALL; 111static jmethodID sCachedNfcManagerNotifySeApduReceived; 112static jmethodID sCachedNfcManagerNotifySeMifareAccess; 113static jmethodID sCachedNfcManagerNotifySeEmvCardRemoval; 114static jmethodID sCachedNfcManagerNotifyTargetDeselected; 115static SyncEvent sNfaEnableEvent; //event for NFA_Enable() 116static SyncEvent sNfaDisableEvent; //event for NFA_Disable() 117static SyncEvent sNfaEnableDisablePollingEvent; //event for NFA_EnablePolling(), NFA_DisablePolling() 118static SyncEvent sNfaSetConfigEvent; // event for Set_Config.... 119static SyncEvent sNfaGetConfigEvent; // event for Get_Config.... 120static bool sIsNfaEnabled = false; 121static bool sDiscoveryEnabled = false; //is polling for tag? 122static bool sIsDisabling = false; 123static bool sRfEnabled = false; // whether RF discovery is enabled 124static bool sSeRfActive = false; // whether RF with SE is likely active 125static bool sP2pActive = false; // whether p2p was last active 126static bool sAbortConnlessWait = false; 127static bool sIsSecElemSelected = false; //has NFC service selected a sec elem 128#define CONFIG_UPDATE_TECH_MASK (1 << 1) 129#define DEFAULT_TECH_MASK (NFA_TECHNOLOGY_MASK_A \ 130 | NFA_TECHNOLOGY_MASK_B \ 131 | NFA_TECHNOLOGY_MASK_F \ 132 | NFA_TECHNOLOGY_MASK_ISO15693 \ 133 | NFA_TECHNOLOGY_MASK_B_PRIME \ 134 | NFA_TECHNOLOGY_MASK_A_ACTIVE \ 135 | NFA_TECHNOLOGY_MASK_F_ACTIVE \ 136 | NFA_TECHNOLOGY_MASK_KOVIO) 137 138 139static void nfaConnectionCallback (UINT8 event, tNFA_CONN_EVT_DATA *eventData); 140static void nfaDeviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA *eventData); 141static bool isPeerToPeer (tNFA_ACTIVATED& activated); 142static bool isListenMode(tNFA_ACTIVATED& activated); 143 144static UINT16 sCurrentConfigLen; 145static UINT8 sConfig[256]; 146///////////////////////////////////////////////////////////// 147///////////////////////////////////////////////////////////// 148 149 150/******************************************************************************* 151** 152** Function: getNative 153** 154** Description: Get native data 155** 156** Returns: Native data structure. 157** 158*******************************************************************************/ 159nfc_jni_native_data *getNative (JNIEnv* e, jobject o) 160{ 161 static struct nfc_jni_native_data *sCachedNat = NULL; 162 if (e) 163 { 164 sCachedNat = nfc_jni_get_nat(e, o); 165 } 166 return sCachedNat; 167} 168 169 170/******************************************************************************* 171** 172** Function: handleRfDiscoveryEvent 173** 174** Description: Handle RF-discovery events from the stack. 175** discoveredDevice: Discovered device. 176** 177** Returns: None 178** 179*******************************************************************************/ 180static void handleRfDiscoveryEvent (tNFC_RESULT_DEVT* discoveredDevice) 181{ 182 if (discoveredDevice->more) 183 { 184 //there is more discovery notification coming 185 return; 186 } 187 188 bool isP2p = NfcTag::getInstance ().isP2pDiscovered (); 189 if (isP2p) 190 { 191 //select the peer that supports P2P 192 NfcTag::getInstance ().selectP2p(); 193 } 194 else 195 { 196 //select the first of multiple tags that is discovered 197 NfcTag::getInstance ().selectFirstTag(); 198 } 199} 200 201 202/******************************************************************************* 203** 204** Function: nfaConnectionCallback 205** 206** Description: Receive connection-related events from stack. 207** connEvent: Event code. 208** eventData: Event data. 209** 210** Returns: None 211** 212*******************************************************************************/ 213static void nfaConnectionCallback (UINT8 connEvent, tNFA_CONN_EVT_DATA* eventData) 214{ 215 tNFA_STATUS status = NFA_STATUS_FAILED; 216 ALOGD("%s: event= %u", __FUNCTION__, connEvent); 217 218 switch (connEvent) 219 { 220 case NFA_POLL_ENABLED_EVT: // whether polling successfully started 221 { 222 ALOGD("%s: NFA_POLL_ENABLED_EVT: status = %u", __FUNCTION__, eventData->status); 223 224 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 225 sNfaEnableDisablePollingEvent.notifyOne (); 226 } 227 break; 228 229 case NFA_POLL_DISABLED_EVT: // Listening/Polling stopped 230 { 231 ALOGD("%s: NFA_POLL_DISABLED_EVT: status = %u", __FUNCTION__, eventData->status); 232 233 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 234 sNfaEnableDisablePollingEvent.notifyOne (); 235 } 236 break; 237 238 case NFA_RF_DISCOVERY_STARTED_EVT: // RF Discovery started 239 { 240 ALOGD("%s: NFA_RF_DISCOVERY_STARTED_EVT: status = %u", __FUNCTION__, eventData->status); 241 242 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 243 sNfaEnableDisablePollingEvent.notifyOne (); 244 } 245 break; 246 247 case NFA_RF_DISCOVERY_STOPPED_EVT: // RF Discovery stopped event 248 { 249 ALOGD("%s: NFA_RF_DISCOVERY_STOPPED_EVT: status = %u", __FUNCTION__, eventData->status); 250 251 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 252 sNfaEnableDisablePollingEvent.notifyOne (); 253 } 254 break; 255 256 case NFA_DISC_RESULT_EVT: // NFC link/protocol discovery notificaiton 257 status = eventData->disc_result.status; 258 ALOGD("%s: NFA_DISC_RESULT_EVT: status = %d", __FUNCTION__, status); 259 if (status != NFA_STATUS_OK) 260 { 261 ALOGE("%s: NFA_DISC_RESULT_EVT error: status = %d", __FUNCTION__, status); 262 } 263 else 264 { 265 NfcTag::getInstance().connectionEventHandler(connEvent, eventData); 266 handleRfDiscoveryEvent(&eventData->disc_result.discovery_ntf); 267 } 268 break; 269 270 case NFA_SELECT_RESULT_EVT: // NFC link/protocol discovery select response 271 ALOGD("%s: NFA_SELECT_RESULT_EVT: status = %d, gIsSelectingRfInterface = %d, sIsDisabling=%d", __FUNCTION__, eventData->status, gIsSelectingRfInterface, sIsDisabling); 272 273 if (sIsDisabling) 274 break; 275 276 if (eventData->status != NFA_STATUS_OK) 277 { 278 if (gIsSelectingRfInterface) 279 { 280 nativeNfcTag_doConnectStatus(false); 281 } 282 283 ALOGE("%s: NFA_SELECT_RESULT_EVT error: status = %d", __FUNCTION__, eventData->status); 284 NFA_Deactivate (FALSE); 285 } 286 break; 287 288 case NFA_DEACTIVATE_FAIL_EVT: 289 ALOGD("%s: NFA_DEACTIVATE_FAIL_EVT: status = %d", __FUNCTION__, eventData->status); 290 break; 291 292 case NFA_ACTIVATED_EVT: // NFC link/protocol activated 293 ALOGD("%s: NFA_ACTIVATED_EVT: gIsSelectingRfInterface=%d, sIsDisabling=%d", __FUNCTION__, gIsSelectingRfInterface, sIsDisabling); 294 if (sIsDisabling || !sIsNfaEnabled) 295 break; 296 297 NfcTag::getInstance().setActivationState (); 298 if (gIsSelectingRfInterface) 299 { 300 nativeNfcTag_doConnectStatus(true); 301 break; 302 } 303 304 nativeNfcTag_resetPresenceCheck(); 305 if (isPeerToPeer(eventData->activated)) 306 { 307 sP2pActive = true; 308 ALOGD("%s: NFA_ACTIVATED_EVT; is p2p", __FUNCTION__); 309 // Disable RF field events in case of p2p 310 UINT8 nfa_disable_rf_events[] = { 0x00 }; 311 ALOGD ("%s: Disabling RF field events", __FUNCTION__); 312 status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_disable_rf_events), 313 &nfa_disable_rf_events[0]); 314 if (status == NFA_STATUS_OK) { 315 ALOGD ("%s: Disabled RF field events", __FUNCTION__); 316 } else { 317 ALOGE ("%s: Failed to disable RF field events", __FUNCTION__); 318 } 319 // For the SE, consider the field to be on while p2p is active. 320 SecureElement::getInstance().notifyRfFieldEvent (true); 321 } 322 else if (pn544InteropIsBusy() == false) 323 { 324 NfcTag::getInstance().connectionEventHandler (connEvent, eventData); 325 326 // We know it is not activating for P2P. If it activated in 327 // listen mode then it is likely for an SE transaction. 328 // Send the RF Event. 329 if (isListenMode(eventData->activated)) 330 { 331 sSeRfActive = true; 332 SecureElement::getInstance().notifyListenModeState (true); 333 } 334 } 335 336 break; 337 338 case NFA_DEACTIVATED_EVT: // NFC link/protocol deactivated 339 ALOGD("%s: NFA_DEACTIVATED_EVT Type: %u, gIsTagDeactivating: %d", __FUNCTION__, eventData->deactivated.type,gIsTagDeactivating); 340 NfcTag::getInstance().setDeactivationState (eventData->deactivated); 341 if (eventData->deactivated.type != NFA_DEACTIVATE_TYPE_SLEEP) 342 { 343 nativeNfcTag_resetPresenceCheck(); 344 NfcTag::getInstance().connectionEventHandler (connEvent, eventData); 345 nativeNfcTag_abortWaits(); 346 NfcTag::getInstance().abort (); 347 } 348 else if (gIsTagDeactivating) 349 { 350 nativeNfcTag_doDeactivateStatus(0); 351 } 352 353 // If RF is activated for what we think is a Secure Element transaction 354 // and it is deactivated to either IDLE or DISCOVERY mode, notify w/event. 355 if ((eventData->deactivated.type == NFA_DEACTIVATE_TYPE_IDLE) 356 || (eventData->deactivated.type == NFA_DEACTIVATE_TYPE_DISCOVERY)) 357 { 358 if (sSeRfActive) { 359 sSeRfActive = false; 360 if (!sIsDisabling && sIsNfaEnabled) 361 SecureElement::getInstance().notifyListenModeState (false); 362 } else if (sP2pActive) { 363 sP2pActive = false; 364 // Make sure RF field events are re-enabled 365 ALOGD("%s: NFA_DEACTIVATED_EVT; is p2p", __FUNCTION__); 366 // Disable RF field events in case of p2p 367 UINT8 nfa_enable_rf_events[] = { 0x01 }; 368 369 if (!sIsDisabling && sIsNfaEnabled) 370 { 371 ALOGD ("%s: Enabling RF field events", __FUNCTION__); 372 status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_enable_rf_events), 373 &nfa_enable_rf_events[0]); 374 if (status == NFA_STATUS_OK) { 375 ALOGD ("%s: Enabled RF field events", __FUNCTION__); 376 } else { 377 ALOGE ("%s: Failed to enable RF field events", __FUNCTION__); 378 } 379 // Consider the field to be off at this point 380 SecureElement::getInstance().notifyRfFieldEvent (false); 381 } 382 } 383 } 384 385 break; 386 387 case NFA_TLV_DETECT_EVT: // TLV Detection complete 388 status = eventData->tlv_detect.status; 389 ALOGD("%s: NFA_TLV_DETECT_EVT: status = %d, protocol = %d, num_tlvs = %d, num_bytes = %d", 390 __FUNCTION__, status, eventData->tlv_detect.protocol, 391 eventData->tlv_detect.num_tlvs, eventData->tlv_detect.num_bytes); 392 if (status != NFA_STATUS_OK) 393 { 394 ALOGE("%s: NFA_TLV_DETECT_EVT error: status = %d", __FUNCTION__, status); 395 } 396 break; 397 398 case NFA_NDEF_DETECT_EVT: // NDEF Detection complete; 399 //if status is failure, it means the tag does not contain any or valid NDEF data; 400 //pass the failure status to the NFC Service; 401 status = eventData->ndef_detect.status; 402 ALOGD("%s: NFA_NDEF_DETECT_EVT: status = 0x%X, protocol = %u, " 403 "max_size = %lu, cur_size = %lu, flags = 0x%X", __FUNCTION__, 404 status, 405 eventData->ndef_detect.protocol, eventData->ndef_detect.max_size, 406 eventData->ndef_detect.cur_size, eventData->ndef_detect.flags); 407 NfcTag::getInstance().connectionEventHandler (connEvent, eventData); 408 nativeNfcTag_doCheckNdefResult(status, 409 eventData->ndef_detect.max_size, eventData->ndef_detect.cur_size, 410 eventData->ndef_detect.flags); 411 break; 412 413 case NFA_DATA_EVT: // Data message received (for non-NDEF reads) 414 ALOGD("%s: NFA_DATA_EVT: len = %d", __FUNCTION__, eventData->data.len); 415 nativeNfcTag_doTransceiveStatus(eventData->data.p_data,eventData->data.len); 416 break; 417 418 case NFA_SELECT_CPLT_EVT: // Select completed 419 status = eventData->status; 420 ALOGD("%s: NFA_SELECT_CPLT_EVT: status = %d", __FUNCTION__, status); 421 if (status != NFA_STATUS_OK) 422 { 423 ALOGE("%s: NFA_SELECT_CPLT_EVT error: status = %d", __FUNCTION__, status); 424 } 425 break; 426 427 case NFA_READ_CPLT_EVT: // NDEF-read or tag-specific-read completed 428 ALOGD("%s: NFA_READ_CPLT_EVT: status = 0x%X", __FUNCTION__, eventData->status); 429 nativeNfcTag_doReadCompleted (eventData->status); 430 NfcTag::getInstance().connectionEventHandler (connEvent, eventData); 431 break; 432 433 case NFA_WRITE_CPLT_EVT: // Write completed 434 ALOGD("%s: NFA_WRITE_CPLT_EVT: status = %d", __FUNCTION__, eventData->status); 435 nativeNfcTag_doWriteStatus (eventData->status == NFA_STATUS_OK); 436 break; 437 438 case NFA_SET_TAG_RO_EVT: // Tag set as Read only 439 ALOGD("%s: NFA_SET_TAG_RO_EVT: status = %d", __FUNCTION__, eventData->status); 440 nativeNfcTag_doMakeReadonlyResult(eventData->status); 441 break; 442 443 case NFA_CE_NDEF_WRITE_START_EVT: // NDEF write started 444 ALOGD("%s: NFA_CE_NDEF_WRITE_START_EVT: status: %d", __FUNCTION__, eventData->status); 445 446 if (eventData->status != NFA_STATUS_OK) 447 ALOGE("%s: NFA_CE_NDEF_WRITE_START_EVT error: status = %d", __FUNCTION__, eventData->status); 448 break; 449 450 case NFA_CE_NDEF_WRITE_CPLT_EVT: // NDEF write completed 451 ALOGD("%s: FA_CE_NDEF_WRITE_CPLT_EVT: len = %lu", __FUNCTION__, eventData->ndef_write_cplt.len); 452 break; 453 454 case NFA_LLCP_ACTIVATED_EVT: // LLCP link is activated 455 ALOGD("%s: NFA_LLCP_ACTIVATED_EVT: is_initiator: %d remote_wks: %d, remote_lsc: %d, remote_link_miu: %d, local_link_miu: %d", 456 __FUNCTION__, 457 eventData->llcp_activated.is_initiator, 458 eventData->llcp_activated.remote_wks, 459 eventData->llcp_activated.remote_lsc, 460 eventData->llcp_activated.remote_link_miu, 461 eventData->llcp_activated.local_link_miu); 462 463 PeerToPeer::getInstance().llcpActivatedHandler (getNative(0, 0), eventData->llcp_activated); 464 break; 465 466 case NFA_LLCP_DEACTIVATED_EVT: // LLCP link is deactivated 467 ALOGD("%s: NFA_LLCP_DEACTIVATED_EVT", __FUNCTION__); 468 PeerToPeer::getInstance().llcpDeactivatedHandler (getNative(0, 0), eventData->llcp_deactivated); 469 break; 470 case NFA_LLCP_FIRST_PACKET_RECEIVED_EVT: // Received first packet over llcp 471 ALOGD("%s: NFA_LLCP_FIRST_PACKET_RECEIVED_EVT", __FUNCTION__); 472 PeerToPeer::getInstance().llcpFirstPacketHandler (getNative(0, 0)); 473 break; 474 case NFA_PRESENCE_CHECK_EVT: 475 ALOGD("%s: NFA_PRESENCE_CHECK_EVT", __FUNCTION__); 476 nativeNfcTag_doPresenceCheckResult (eventData->status); 477 break; 478 case NFA_FORMAT_CPLT_EVT: 479 ALOGD("%s: NFA_FORMAT_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status); 480 nativeNfcTag_formatStatus (eventData->status == NFA_STATUS_OK); 481 break; 482 483 case NFA_I93_CMD_CPLT_EVT: 484 ALOGD("%s: NFA_I93_CMD_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status); 485 break; 486 487 case NFA_CE_UICC_LISTEN_CONFIGURED_EVT : 488 ALOGD("%s: NFA_CE_UICC_LISTEN_CONFIGURED_EVT : status=0x%X", __FUNCTION__, eventData->status); 489 SecureElement::getInstance().connectionEventHandler (connEvent, eventData); 490 break; 491 492 case NFA_SET_P2P_LISTEN_TECH_EVT: 493 ALOGD("%s: NFA_SET_P2P_LISTEN_TECH_EVT", __FUNCTION__); 494 PeerToPeer::getInstance().connectionEventHandler (connEvent, eventData); 495 break; 496 497 default: 498 ALOGE("%s: unknown event ????", __FUNCTION__); 499 break; 500 } 501} 502 503 504/******************************************************************************* 505** 506** Function: nfcManager_initNativeStruc 507** 508** Description: Initialize variables. 509** e: JVM environment. 510** o: Java object. 511** 512** Returns: True if ok. 513** 514*******************************************************************************/ 515static jboolean nfcManager_initNativeStruc (JNIEnv* e, jobject o) 516{ 517 ALOGD ("%s: enter", __FUNCTION__); 518 519 nfc_jni_native_data* nat = (nfc_jni_native_data*)malloc(sizeof(struct nfc_jni_native_data)); 520 if (nat == NULL) 521 { 522 ALOGE ("%s: fail allocate native data", __FUNCTION__); 523 return JNI_FALSE; 524 } 525 526 memset (nat, 0, sizeof(*nat)); 527 e->GetJavaVM(&(nat->vm)); 528 nat->env_version = e->GetVersion(); 529 nat->manager = e->NewGlobalRef(o); 530 531 ScopedLocalRef<jclass> cls(e, e->GetObjectClass(o)); 532 jfieldID f = e->GetFieldID(cls.get(), "mNative", "I"); 533 e->SetIntField(o, f, (jint)nat); 534 535 /* Initialize native cached references */ 536 gCachedNfcManagerNotifyNdefMessageListeners = e->GetMethodID(cls.get(), 537 "notifyNdefMessageListeners", "(Lcom/android/nfc/dhimpl/NativeNfcTag;)V"); 538 gCachedNfcManagerNotifyTransactionListeners = e->GetMethodID(cls.get(), 539 "notifyTransactionListeners", "([B)V"); 540 gCachedNfcManagerNotifyLlcpLinkActivation = e->GetMethodID(cls.get(), 541 "notifyLlcpLinkActivation", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); 542 gCachedNfcManagerNotifyLlcpLinkDeactivated = e->GetMethodID(cls.get(), 543 "notifyLlcpLinkDeactivated", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); 544 gCachedNfcManagerNotifyLlcpFirstPacketReceived = e->GetMethodID(cls.get(), 545 "notifyLlcpLinkFirstPacketReceived", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); 546 sCachedNfcManagerNotifyTargetDeselected = e->GetMethodID(cls.get(), 547 "notifyTargetDeselected","()V"); 548 gCachedNfcManagerNotifySeFieldActivated = e->GetMethodID(cls.get(), 549 "notifySeFieldActivated", "()V"); 550 gCachedNfcManagerNotifySeFieldDeactivated = e->GetMethodID(cls.get(), 551 "notifySeFieldDeactivated", "()V"); 552 gCachedNfcManagerNotifySeListenActivated = e->GetMethodID(cls.get(), 553 "notifySeListenActivated", "()V"); 554 gCachedNfcManagerNotifySeListenDeactivated = e->GetMethodID(cls.get(), 555 "notifySeListenDeactivated", "()V"); 556 557 gCachedNfcManagerNotifyHostEmuActivated = e->GetMethodID(cls.get(), 558 "notifyHostEmuActivated", "()V"); 559 560 gCachedNfcManagerNotifyHostEmuData = e->GetMethodID(cls.get(), 561 "notifyHostEmuData", "([B)V"); 562 563 gCachedNfcManagerNotifyHostEmuDeactivated = e->GetMethodID(cls.get(), 564 "notifyHostEmuDeactivated", "()V"); 565 566 sCachedNfcManagerNotifySeApduReceived = e->GetMethodID(cls.get(), 567 "notifySeApduReceived", "([B)V"); 568 569 sCachedNfcManagerNotifySeMifareAccess = e->GetMethodID(cls.get(), 570 "notifySeMifareAccess", "([B)V"); 571 572 sCachedNfcManagerNotifySeEmvCardRemoval = e->GetMethodID(cls.get(), 573 "notifySeEmvCardRemoval", "()V"); 574 575 if (nfc_jni_cache_object(e, gNativeNfcTagClassName, &(nat->cached_NfcTag)) == -1) 576 { 577 ALOGE ("%s: fail cache NativeNfcTag", __FUNCTION__); 578 return JNI_FALSE; 579 } 580 581 if (nfc_jni_cache_object(e, gNativeP2pDeviceClassName, &(nat->cached_P2pDevice)) == -1) 582 { 583 ALOGE ("%s: fail cache NativeP2pDevice", __FUNCTION__); 584 return JNI_FALSE; 585 } 586 587 ALOGD ("%s: exit", __FUNCTION__); 588 return JNI_TRUE; 589} 590 591 592/******************************************************************************* 593** 594** Function: nfaDeviceManagementCallback 595** 596** Description: Receive device management events from stack. 597** dmEvent: Device-management event ID. 598** eventData: Data associated with event ID. 599** 600** Returns: None 601** 602*******************************************************************************/ 603void nfaDeviceManagementCallback (UINT8 dmEvent, tNFA_DM_CBACK_DATA* eventData) 604{ 605 ALOGD ("%s: enter; event=0x%X", __FUNCTION__, dmEvent); 606 607 switch (dmEvent) 608 { 609 case NFA_DM_ENABLE_EVT: /* Result of NFA_Enable */ 610 { 611 SyncEventGuard guard (sNfaEnableEvent); 612 ALOGD ("%s: NFA_DM_ENABLE_EVT; status=0x%X", 613 __FUNCTION__, eventData->status); 614 sIsNfaEnabled = eventData->status == NFA_STATUS_OK; 615 sIsDisabling = false; 616 sNfaEnableEvent.notifyOne (); 617 } 618 break; 619 620 case NFA_DM_DISABLE_EVT: /* Result of NFA_Disable */ 621 { 622 SyncEventGuard guard (sNfaDisableEvent); 623 ALOGD ("%s: NFA_DM_DISABLE_EVT", __FUNCTION__); 624 sIsNfaEnabled = false; 625 sIsDisabling = false; 626 sNfaDisableEvent.notifyOne (); 627 } 628 break; 629 630 case NFA_DM_SET_CONFIG_EVT: //result of NFA_SetConfig 631 ALOGD ("%s: NFA_DM_SET_CONFIG_EVT", __FUNCTION__); 632 { 633 SyncEventGuard guard (sNfaSetConfigEvent); 634 sNfaSetConfigEvent.notifyOne(); 635 } 636 break; 637 638 case NFA_DM_GET_CONFIG_EVT: /* Result of NFA_GetConfig */ 639 ALOGD ("%s: NFA_DM_GET_CONFIG_EVT", __FUNCTION__); 640 { 641 SyncEventGuard guard (sNfaGetConfigEvent); 642 if (eventData->status == NFA_STATUS_OK && 643 eventData->get_config.tlv_size <= sizeof(sConfig)) 644 { 645 sCurrentConfigLen = eventData->get_config.tlv_size; 646 memcpy(sConfig, eventData->get_config.param_tlvs, eventData->get_config.tlv_size); 647 } 648 else 649 { 650 ALOGE("%s: NFA_DM_GET_CONFIG failed", __FUNCTION__); 651 sCurrentConfigLen = 0; 652 } 653 sNfaGetConfigEvent.notifyOne(); 654 } 655 break; 656 657 case NFA_DM_RF_FIELD_EVT: 658 ALOGD ("%s: NFA_DM_RF_FIELD_EVT; status=0x%X; field status=%u", __FUNCTION__, 659 eventData->rf_field.status, eventData->rf_field.rf_field_status); 660 if (sIsDisabling || !sIsNfaEnabled) 661 break; 662 663 if (!sP2pActive && eventData->rf_field.status == NFA_STATUS_OK) 664 SecureElement::getInstance().notifyRfFieldEvent ( 665 eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON); 666 break; 667 668 case NFA_DM_NFCC_TRANSPORT_ERR_EVT: 669 case NFA_DM_NFCC_TIMEOUT_EVT: 670 { 671 if (dmEvent == NFA_DM_NFCC_TIMEOUT_EVT) 672 ALOGD ("%s: NFA_DM_NFCC_TIMEOUT_EVT; abort all outstanding operations", __FUNCTION__); 673 else 674 ALOGD ("%s: NFA_DM_NFCC_TRANSPORT_ERR_EVT; abort all outstanding operations", __FUNCTION__); 675 676 nativeNfcTag_abortWaits(); 677 NfcTag::getInstance().abort (); 678 sAbortConnlessWait = true; 679 nativeLlcpConnectionlessSocket_abortWait(); 680 { 681 ALOGD ("%s: aborting sNfaEnableDisablePollingEvent", __FUNCTION__); 682 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 683 sNfaEnableDisablePollingEvent.notifyOne(); 684 } 685 { 686 ALOGD ("%s: aborting sNfaEnableEvent", __FUNCTION__); 687 SyncEventGuard guard (sNfaEnableEvent); 688 sNfaEnableEvent.notifyOne(); 689 } 690 { 691 ALOGD ("%s: aborting sNfaDisableEvent", __FUNCTION__); 692 SyncEventGuard guard (sNfaDisableEvent); 693 sNfaDisableEvent.notifyOne(); 694 } 695 sDiscoveryEnabled = false; 696 PowerSwitch::getInstance ().abort (); 697 698 if (!sIsDisabling && sIsNfaEnabled) 699 { 700 NFA_Disable(FALSE); 701 sIsDisabling = true; 702 } 703 else 704 { 705 sIsNfaEnabled = false; 706 sIsDisabling = false; 707 } 708 PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); 709 ALOGD ("%s: aborted all waiting events", __FUNCTION__); 710 } 711 break; 712 713 case NFA_DM_PWR_MODE_CHANGE_EVT: 714 PowerSwitch::getInstance ().deviceManagementCallback (dmEvent, eventData); 715 break; 716 717 default: 718 ALOGD ("%s: unhandled event", __FUNCTION__); 719 break; 720 } 721} 722 723/******************************************************************************* 724** 725** Function: nfcManager_sendRawFrame 726** 727** Description: Send a raw frame. 728** e: JVM environment. 729** o: Java object. 730** 731** Returns: True if ok. 732** 733*******************************************************************************/ 734static jboolean nfcManager_sendRawFrame (JNIEnv* e, jobject o, jbyteArray data) 735{ 736 ScopedByteArrayRO bytes(e, data); 737 uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); 738 size_t bufLen = bytes.size(); 739 tNFA_STATUS status = NFA_SendRawFrame (buf, bufLen, 0); 740 741 return (status == NFA_STATUS_OK); 742} 743 744/******************************************************************************* 745** 746** Function: nfcManager_routeAid 747** 748** Description: Route an AID to an EE 749** e: JVM environment. 750** o: Java object. 751** 752** Returns: True if ok. 753** 754*******************************************************************************/ 755static jboolean nfcManager_routeAid (JNIEnv* e, jobject o, jbyteArray aid, jint route) 756{ 757 ScopedByteArrayRO bytes(e, aid); 758 uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); 759 size_t bufLen = bytes.size(); 760 bool result = RoutingManager::getInstance().addAidRouting(buf, bufLen, route); 761 return result; 762} 763 764/******************************************************************************* 765** 766** Function: nfcManager_unrouteAid 767** 768** Description: Remove a AID routing 769** e: JVM environment. 770** o: Java object. 771** 772** Returns: True if ok. 773** 774*******************************************************************************/ 775static jboolean nfcManager_unrouteAid (JNIEnv* e, jobject o, jbyteArray aid) 776{ 777 ScopedByteArrayRO bytes(e, aid); 778 uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); 779 size_t bufLen = bytes.size(); 780 bool result = RoutingManager::getInstance().removeAidRouting(buf, bufLen); 781 return result; 782} 783 784/******************************************************************************* 785** 786** Function: nfcManager_doInitialize 787** 788** Description: Turn on NFC. 789** e: JVM environment. 790** o: Java object. 791** 792** Returns: True if ok. 793** 794*******************************************************************************/ 795static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) 796{ 797 ALOGD ("%s: enter; NCI_VERSION=0x%02X", __FUNCTION__, NCI_VERSION); 798 tNFA_STATUS stat = NFA_STATUS_OK; 799 800 if (sIsNfaEnabled) 801 { 802 ALOGD ("%s: already enabled", __FUNCTION__); 803 goto TheEnd; 804 } 805 806 PowerSwitch::getInstance ().initialize (PowerSwitch::FULL_POWER); 807 808 { 809 unsigned long num = 0; 810 811 NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); 812 theInstance.Initialize(); //start GKI, NCI task, NFC task 813 814 { 815 SyncEventGuard guard (sNfaEnableEvent); 816 tHAL_NFC_ENTRY* halFuncEntries = theInstance.GetHalEntryFuncs (); 817 818 NFA_Init (halFuncEntries); 819 820 stat = NFA_Enable (nfaDeviceManagementCallback, nfaConnectionCallback); 821 if (stat == NFA_STATUS_OK) 822 { 823 num = initializeGlobalAppLogLevel (); 824 CE_SetTraceLevel (num); 825 LLCP_SetTraceLevel (num); 826 NFC_SetTraceLevel (num); 827 RW_SetTraceLevel (num); 828 NFA_SetTraceLevel (num); 829 NFA_P2pSetTraceLevel (num); 830 sNfaEnableEvent.wait(); //wait for NFA command to finish 831 } 832 } 833 834 if (stat == NFA_STATUS_OK) 835 { 836 //sIsNfaEnabled indicates whether stack started successfully 837 if (sIsNfaEnabled) 838 { 839 SecureElement::getInstance().initialize (getNative(e, o)); 840 RoutingManager::getInstance().initialize(getNative(e, o)); 841 nativeNfcTag_registerNdefTypeHandler (); 842 NfcTag::getInstance().initialize (getNative(e, o)); 843 PeerToPeer::getInstance().initialize (); 844 PeerToPeer::getInstance().handleNfcOnOff (true); 845 846 ///////////////////////////////////////////////////////////////////////////////// 847 // Add extra configuration here (work-arounds, etc.) 848 849 struct nfc_jni_native_data *nat = getNative(e, o); 850 851 if ( nat ) 852 { 853 if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) 854 nat->tech_mask = num; 855 else 856 nat->tech_mask = DEFAULT_TECH_MASK; 857 858 ALOGD ("%s: tag polling tech mask=0x%X", __FUNCTION__, nat->tech_mask); 859 } 860 861 // if this value exists, set polling interval. 862 if (GetNumValue(NAME_NFA_DM_DISC_DURATION_POLL, &num, sizeof(num))) 863 NFA_SetRfDiscoveryDuration(num); 864 865 // Do custom NFCA startup configuration. 866 doStartupConfig(); 867 goto TheEnd; 868 } 869 } 870 871 ALOGE ("%s: fail nfa enable; error=0x%X", __FUNCTION__, stat); 872 873 if (sIsNfaEnabled) 874 stat = NFA_Disable (FALSE /* ungraceful */); 875 876 theInstance.Finalize(); 877 } 878 879TheEnd: 880 if (sIsNfaEnabled) 881 PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); 882 ALOGD ("%s: exit", __FUNCTION__); 883 return sIsNfaEnabled ? JNI_TRUE : JNI_FALSE; 884} 885 886 887/******************************************************************************* 888** 889** Function: nfcManager_enableDiscovery 890** 891** Description: Start polling and listening for devices. 892** e: JVM environment. 893** o: Java object. 894** mode: Not used. 895** 896** Returns: None 897** 898*******************************************************************************/ 899static void nfcManager_enableDiscovery (JNIEnv* e, jobject o) 900{ 901 tNFA_TECHNOLOGY_MASK tech_mask = DEFAULT_TECH_MASK; 902 struct nfc_jni_native_data *nat = getNative(e, o); 903 904 if (nat) 905 tech_mask = (tNFA_TECHNOLOGY_MASK)nat->tech_mask; 906 907 ALOGD ("%s: enter; tech_mask = %02x", __FUNCTION__, tech_mask); 908 909 if (sDiscoveryEnabled) 910 { 911 ALOGE ("%s: already polling", __FUNCTION__); 912 return; 913 } 914 915 tNFA_STATUS stat = NFA_STATUS_OK; 916 917 ALOGD ("%s: sIsSecElemSelected=%u", __FUNCTION__, sIsSecElemSelected); 918 919 PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); 920 921 if (sRfEnabled) { 922 // Stop RF discovery to reconfigure 923 startRfDiscovery(false); 924 } 925 926 { 927 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 928 stat = NFA_EnablePolling (tech_mask); 929 if (stat == NFA_STATUS_OK) 930 { 931 ALOGD ("%s: wait for enable event", __FUNCTION__); 932 sDiscoveryEnabled = true; 933 sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT 934 ALOGD ("%s: got enabled event", __FUNCTION__); 935 } 936 else 937 { 938 ALOGE ("%s: fail enable discovery; error=0x%X", __FUNCTION__, stat); 939 } 940 } 941 942 // Start P2P listening if tag polling was enabled or the mask was 0. 943 if (sDiscoveryEnabled || (tech_mask == 0)) 944 { 945 ALOGD ("%s: Enable p2pListening", __FUNCTION__); 946 PeerToPeer::getInstance().enableP2pListening (true); 947 } 948 949 // Actually start discovery. 950 startRfDiscovery (true); 951 952 PowerSwitch::getInstance ().setModeOn (PowerSwitch::DISCOVERY); 953 954 ALOGD ("%s: exit", __FUNCTION__); 955} 956 957 958/******************************************************************************* 959** 960** Function: nfcManager_disableDiscovery 961** 962** Description: Stop polling and listening for devices. 963** e: JVM environment. 964** o: Java object. 965** 966** Returns: None 967** 968*******************************************************************************/ 969void nfcManager_disableDiscovery (JNIEnv*, jobject) 970{ 971 tNFA_STATUS status = NFA_STATUS_OK; 972 ALOGD ("%s: enter;", __FUNCTION__); 973 974 pn544InteropAbortNow (); 975 if (sDiscoveryEnabled == false) 976 { 977 ALOGD ("%s: already disabled", __FUNCTION__); 978 goto TheEnd; 979 } 980 981 // Stop RF Discovery. 982 startRfDiscovery (false); 983 984 if (sDiscoveryEnabled) 985 { 986 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 987 status = NFA_DisablePolling (); 988 if (status == NFA_STATUS_OK) 989 { 990 sDiscoveryEnabled = false; 991 sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT 992 } 993 else 994 ALOGE ("%s: Failed to disable polling; error=0x%X", __FUNCTION__, status); 995 } 996 997 PeerToPeer::getInstance().enableP2pListening (false); 998 999 //if nothing is active after this, then tell the controller to power down 1000 if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::DISCOVERY)) 1001 PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); 1002 1003 // We may have had RF field notifications that did not cause 1004 // any activate/deactive events. For example, caused by wireless 1005 // charging orbs. Those may cause us to go to sleep while the last 1006 // field event was indicating a field. To prevent sticking in that 1007 // state, always reset the rf field status when we disable discovery. 1008 SecureElement::getInstance().resetRfFieldStatus(); 1009TheEnd: 1010 ALOGD ("%s: exit", __FUNCTION__); 1011} 1012 1013void setUiccIdleTimeout (bool enable) 1014{ 1015 // This method is *NOT* thread-safe. Right now 1016 // it is only called from the same thread so it's 1017 // not an issue. 1018 tNFA_STATUS stat = NFA_STATUS_OK; 1019 UINT8 swp_cfg_byte0 = 0x00; 1020 { 1021 SyncEventGuard guard (sNfaGetConfigEvent); 1022 stat = NFA_GetConfig(1, new tNFA_PMID[1] {0xC2}); 1023 if (stat != NFA_STATUS_OK) 1024 { 1025 ALOGE("%s: NFA_GetConfig failed", __FUNCTION__); 1026 return; 1027 } 1028 sNfaGetConfigEvent.wait (); 1029 if (sCurrentConfigLen < 4 || sConfig[1] != 0xC2) { 1030 ALOGE("%s: Config TLV length %d returned is too short", __FUNCTION__, 1031 sCurrentConfigLen); 1032 return; 1033 } 1034 swp_cfg_byte0 = sConfig[3]; 1035 } 1036 SyncEventGuard guard(sNfaSetConfigEvent); 1037 if (enable) 1038 swp_cfg_byte0 |= 0x01; 1039 else 1040 swp_cfg_byte0 &= ~0x01; 1041 1042 stat = NFA_SetConfig(0xC2, 1, &swp_cfg_byte0); 1043 if (stat == NFA_STATUS_OK) 1044 sNfaSetConfigEvent.wait (); 1045 else 1046 ALOGE("%s: Could not configure UICC idle timeout feature", __FUNCTION__); 1047 return; 1048} 1049/******************************************************************************* 1050** 1051** Function nfc_jni_cache_object_local 1052** 1053** Description Allocates a java object and calls it's constructor 1054** 1055** Returns -1 on failure, 0 on success 1056** 1057*******************************************************************************/ 1058static int nfc_jni_cache_object_local (JNIEnv *e, const char *className, jobject *cachedObj) 1059{ 1060 ScopedLocalRef<jclass> cls(e, e->FindClass(className)); 1061 if(cls.get() == NULL) { 1062 ALOGE ("%s: find class error", __FUNCTION__); 1063 return -1; 1064 } 1065 1066 jmethodID ctor = e->GetMethodID(cls.get(), "<init>", "()V"); 1067 jobject obj = e->NewObject(cls.get(), ctor); 1068 if (obj == NULL) { 1069 ALOGE ("%s: create object error", __FUNCTION__); 1070 return -1; 1071 } 1072 1073 *cachedObj = obj; 1074 if (*cachedObj == NULL) { 1075 ALOGE ("%s: global ref error", __FUNCTION__); 1076 return -1; 1077 } 1078 return 0; 1079} 1080 1081 1082/******************************************************************************* 1083** 1084** Function: nfcManager_doCreateLlcpServiceSocket 1085** 1086** Description: Create a new LLCP server socket. 1087** e: JVM environment. 1088** o: Java object. 1089** nSap: Service access point. 1090** sn: Service name 1091** miu: Maximum information unit. 1092** rw: Receive window size. 1093** linearBufferLength: Max buffer size. 1094** 1095** Returns: NativeLlcpServiceSocket Java object. 1096** 1097*******************************************************************************/ 1098static jobject nfcManager_doCreateLlcpServiceSocket (JNIEnv* e, jobject, jint nSap, jstring sn, jint miu, jint rw, jint linearBufferLength) 1099{ 1100 PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle (); 1101 1102 ScopedUtfChars serviceName(e, sn); 1103 1104 ALOGD ("%s: enter: sap=%i; name=%s; miu=%i; rw=%i; buffLen=%i", __FUNCTION__, nSap, serviceName.c_str(), miu, rw, linearBufferLength); 1105 1106 /* Create new NativeLlcpServiceSocket object */ 1107 jobject serviceSocket = NULL; 1108 if (nfc_jni_cache_object(e, gNativeLlcpServiceSocketClassName, &(serviceSocket)) == -1) 1109 { 1110 ALOGE ("%s: Llcp socket object creation error", __FUNCTION__); 1111 return NULL; 1112 } 1113 1114 /* Get NativeLlcpServiceSocket class object */ 1115 ScopedLocalRef<jclass> clsNativeLlcpServiceSocket(e, e->GetObjectClass(serviceSocket)); 1116 if (e->ExceptionCheck()) 1117 { 1118 e->ExceptionClear(); 1119 ALOGE("%s: Llcp Socket get object class error", __FUNCTION__); 1120 return NULL; 1121 } 1122 1123 if (!PeerToPeer::getInstance().registerServer (jniHandle, serviceName.c_str())) 1124 { 1125 ALOGE("%s: RegisterServer error", __FUNCTION__); 1126 return NULL; 1127 } 1128 1129 jfieldID f; 1130 1131 /* Set socket handle to be the same as the NfaHandle*/ 1132 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mHandle", "I"); 1133 e->SetIntField(serviceSocket, f, (jint) jniHandle); 1134 ALOGD ("%s: socket Handle = 0x%X", __FUNCTION__, jniHandle); 1135 1136 /* Set socket linear buffer length */ 1137 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalLinearBufferLength", "I"); 1138 e->SetIntField(serviceSocket, f,(jint)linearBufferLength); 1139 ALOGD ("%s: buffer length = %d", __FUNCTION__, linearBufferLength); 1140 1141 /* Set socket MIU */ 1142 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalMiu", "I"); 1143 e->SetIntField(serviceSocket, f,(jint)miu); 1144 ALOGD ("%s: MIU = %d", __FUNCTION__, miu); 1145 1146 /* Set socket RW */ 1147 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalRw", "I"); 1148 e->SetIntField(serviceSocket, f,(jint)rw); 1149 ALOGD ("%s: RW = %d", __FUNCTION__, rw); 1150 1151 sLastError = 0; 1152 ALOGD ("%s: exit", __FUNCTION__); 1153 return serviceSocket; 1154} 1155 1156 1157/******************************************************************************* 1158** 1159** Function: nfcManager_doGetLastError 1160** 1161** Description: Get the last error code. 1162** e: JVM environment. 1163** o: Java object. 1164** 1165** Returns: Last error code. 1166** 1167*******************************************************************************/ 1168static jint nfcManager_doGetLastError(JNIEnv*, jobject) 1169{ 1170 ALOGD ("%s: last error=%i", __FUNCTION__, sLastError); 1171 return sLastError; 1172} 1173 1174 1175/******************************************************************************* 1176** 1177** Function: nfcManager_doDeinitialize 1178** 1179** Description: Turn off NFC. 1180** e: JVM environment. 1181** o: Java object. 1182** 1183** Returns: True if ok. 1184** 1185*******************************************************************************/ 1186static jboolean nfcManager_doDeinitialize (JNIEnv*, jobject) 1187{ 1188 ALOGD ("%s: enter", __FUNCTION__); 1189 1190 sIsDisabling = true; 1191 pn544InteropAbortNow (); 1192 SecureElement::getInstance().finalize (); 1193 1194 if (sIsNfaEnabled) 1195 { 1196 SyncEventGuard guard (sNfaDisableEvent); 1197 tNFA_STATUS stat = NFA_Disable (TRUE /* graceful */); 1198 if (stat == NFA_STATUS_OK) 1199 { 1200 ALOGD ("%s: wait for completion", __FUNCTION__); 1201 sNfaDisableEvent.wait (); //wait for NFA command to finish 1202 PeerToPeer::getInstance ().handleNfcOnOff (false); 1203 } 1204 else 1205 { 1206 ALOGE ("%s: fail disable; error=0x%X", __FUNCTION__, stat); 1207 } 1208 } 1209 nativeNfcTag_abortWaits(); 1210 NfcTag::getInstance().abort (); 1211 sAbortConnlessWait = true; 1212 nativeLlcpConnectionlessSocket_abortWait(); 1213 sIsNfaEnabled = false; 1214 sDiscoveryEnabled = false; 1215 sIsDisabling = false; 1216 sIsSecElemSelected = false; 1217 1218 { 1219 //unblock NFA_EnablePolling() and NFA_DisablePolling() 1220 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 1221 sNfaEnableDisablePollingEvent.notifyOne (); 1222 } 1223 1224 NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); 1225 theInstance.Finalize(); 1226 1227 ALOGD ("%s: exit", __FUNCTION__); 1228 return JNI_TRUE; 1229} 1230 1231 1232/******************************************************************************* 1233** 1234** Function: nfcManager_doCreateLlcpSocket 1235** 1236** Description: Create a LLCP connection-oriented socket. 1237** e: JVM environment. 1238** o: Java object. 1239** nSap: Service access point. 1240** miu: Maximum information unit. 1241** rw: Receive window size. 1242** linearBufferLength: Max buffer size. 1243** 1244** Returns: NativeLlcpSocket Java object. 1245** 1246*******************************************************************************/ 1247static jobject nfcManager_doCreateLlcpSocket (JNIEnv* e, jobject, jint nSap, jint miu, jint rw, jint linearBufferLength) 1248{ 1249 ALOGD ("%s: enter; sap=%d; miu=%d; rw=%d; buffer len=%d", __FUNCTION__, nSap, miu, rw, linearBufferLength); 1250 1251 PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle (); 1252 bool stat = PeerToPeer::getInstance().createClient (jniHandle, miu, rw); 1253 1254 /* Create new NativeLlcpSocket object */ 1255 jobject clientSocket = NULL; 1256 if (nfc_jni_cache_object_local(e, gNativeLlcpSocketClassName, &(clientSocket)) == -1) 1257 { 1258 ALOGE ("%s: fail Llcp socket creation", __FUNCTION__); 1259 return clientSocket; 1260 } 1261 1262 /* Get NativeConnectionless class object */ 1263 ScopedLocalRef<jclass> clsNativeLlcpSocket(e, e->GetObjectClass(clientSocket)); 1264 if (e->ExceptionCheck()) 1265 { 1266 e->ExceptionClear(); 1267 ALOGE ("%s: fail get class object", __FUNCTION__); 1268 return clientSocket; 1269 } 1270 1271 jfieldID f; 1272 1273 /* Set socket SAP */ 1274 f = e->GetFieldID (clsNativeLlcpSocket.get(), "mSap", "I"); 1275 e->SetIntField (clientSocket, f, (jint) nSap); 1276 1277 /* Set socket handle */ 1278 f = e->GetFieldID (clsNativeLlcpSocket.get(), "mHandle", "I"); 1279 e->SetIntField (clientSocket, f, (jint) jniHandle); 1280 1281 /* Set socket MIU */ 1282 f = e->GetFieldID (clsNativeLlcpSocket.get(), "mLocalMiu", "I"); 1283 e->SetIntField (clientSocket, f, (jint) miu); 1284 1285 /* Set socket RW */ 1286 f = e->GetFieldID (clsNativeLlcpSocket.get(), "mLocalRw", "I"); 1287 e->SetIntField (clientSocket, f, (jint) rw); 1288 1289 ALOGD ("%s: exit", __FUNCTION__); 1290 return clientSocket; 1291} 1292 1293 1294/******************************************************************************* 1295** 1296** Function: nfcManager_doCreateLlcpConnectionlessSocket 1297** 1298** Description: Create a connection-less socket. 1299** e: JVM environment. 1300** o: Java object. 1301** nSap: Service access point. 1302** sn: Service name. 1303** 1304** Returns: NativeLlcpConnectionlessSocket Java object. 1305** 1306*******************************************************************************/ 1307static jobject nfcManager_doCreateLlcpConnectionlessSocket (JNIEnv *, jobject, jint nSap, jstring /*sn*/) 1308{ 1309 ALOGD ("%s: nSap=0x%X", __FUNCTION__, nSap); 1310 return NULL; 1311} 1312 1313 1314/******************************************************************************* 1315** 1316** Function: nfcManager_doGetSecureElementList 1317** 1318** Description: Get a list of secure element handles. 1319** e: JVM environment. 1320** o: Java object. 1321** 1322** Returns: List of secure element handles. 1323** 1324*******************************************************************************/ 1325static jintArray nfcManager_doGetSecureElementList(JNIEnv* e, jobject) 1326{ 1327 ALOGD ("%s", __FUNCTION__); 1328 return SecureElement::getInstance().getListOfEeHandles (e); 1329} 1330 1331/******************************************************************************* 1332** 1333** Function: nfcManager_enableRoutingToHost 1334** 1335** Description: NFC controller starts routing data to host. 1336** e: JVM environment. 1337** o: Java object. 1338** 1339** Returns: None 1340** 1341*******************************************************************************/ 1342static void nfcManager_enableRoutingToHost(JNIEnv*, jobject) 1343{ 1344 ALOGD ("%s: enter", __FUNCTION__); 1345 PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); 1346 PowerSwitch::getInstance ().setModeOn (PowerSwitch::HOST_ROUTING); 1347 if (sRfEnabled) { 1348 // Stop RF discovery to reconfigure 1349 startRfDiscovery(false); 1350 } 1351 RoutingManager::getInstance().commitRouting(); 1352 startRfDiscovery(true); 1353 1354TheEnd: 1355 ALOGD ("%s: exit", __FUNCTION__); 1356} 1357 1358/******************************************************************************* 1359** 1360** Function: nfcManager_disableRoutingToHost 1361** 1362** Description: NFC controller stops routing data to host. 1363** e: JVM environment. 1364** o: Java object. 1365** 1366** Returns: None 1367** 1368*******************************************************************************/ 1369static void nfcManager_disableRoutingToHost(JNIEnv*, jobject) 1370{ 1371 ALOGD ("%s: enter", __FUNCTION__); 1372 bool rfWasEnabled = false; 1373 1374 if (PowerSwitch::getInstance ().getLevel() == PowerSwitch::LOW_POWER) 1375 { 1376 ALOGD ("%s: no need to disable routing while power is OFF", __FUNCTION__); 1377 goto TheEnd; 1378 } 1379 1380 if (sRfEnabled) { 1381 rfWasEnabled = true; 1382 // Stop RF discovery to reconfigure 1383 startRfDiscovery(false); 1384 } 1385 RoutingManager::getInstance().commitRouting(); 1386 if (rfWasEnabled) 1387 { 1388 startRfDiscovery(true); 1389 } 1390 if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::HOST_ROUTING)) 1391 PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); 1392TheEnd: 1393 ALOGD ("%s: exit", __FUNCTION__); 1394} 1395 1396/******************************************************************************* 1397** 1398** Function: nfcManager_doSelectSecureElement 1399** 1400** Description: NFC controller starts routing data in listen mode. 1401** e: JVM environment. 1402** o: Java object. 1403** 1404** Returns: None 1405** 1406*******************************************************************************/ 1407static void nfcManager_doSelectSecureElement(JNIEnv*, jobject) 1408{ 1409 ALOGD ("%s: enter", __FUNCTION__); 1410 bool stat = true; 1411 1412 if (sIsSecElemSelected) 1413 { 1414 ALOGD ("%s: already selected", __FUNCTION__); 1415 goto TheEnd; 1416 } 1417 1418 PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); 1419 1420 if (sRfEnabled) { 1421 // Stop RF Discovery if we were polling 1422 startRfDiscovery (false); 1423 } 1424 1425 1426 stat = SecureElement::getInstance().activate (0xABCDEF); 1427 sIsSecElemSelected = true; 1428 1429 startRfDiscovery (true); 1430 PowerSwitch::getInstance ().setModeOn (PowerSwitch::SE_ROUTING); 1431TheEnd: 1432 ALOGD ("%s: exit", __FUNCTION__); 1433} 1434 1435 1436/******************************************************************************* 1437** 1438** Function: nfcManager_doDeselectSecureElement 1439** 1440** Description: NFC controller stops routing data in listen mode. 1441** e: JVM environment. 1442** o: Java object. 1443** 1444** Returns: None 1445** 1446*******************************************************************************/ 1447static void nfcManager_doDeselectSecureElement(JNIEnv*, jobject) 1448{ 1449 ALOGD ("%s: enter", __FUNCTION__); 1450 bool stat = false; 1451 bool bRestartDiscovery = false; 1452 1453 if (! sIsSecElemSelected) 1454 { 1455 ALOGE ("%s: already deselected", __FUNCTION__); 1456 goto TheEnd; 1457 } 1458 1459 if (PowerSwitch::getInstance ().getLevel() == PowerSwitch::LOW_POWER) 1460 { 1461 ALOGD ("%s: do not deselect while power is OFF", __FUNCTION__); 1462 sIsSecElemSelected = false; 1463 goto TheEnd; 1464 } 1465 1466 if (sRfEnabled) { 1467 // Stop RF Discovery if we were polling 1468 startRfDiscovery (false); 1469 bRestartDiscovery = true; 1470 } 1471 1472 //if controller is not routing to sec elems AND there is no pipe connected, 1473 //then turn off the sec elems 1474 if (SecureElement::getInstance().isBusy() == false) 1475 SecureElement::getInstance().deactivate (0xABCDEF); 1476 1477 sIsSecElemSelected = false; 1478TheEnd: 1479 if (bRestartDiscovery) 1480 startRfDiscovery (true); 1481 1482 //if nothing is active after this, then tell the controller to power down 1483 if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::SE_ROUTING)) 1484 PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); 1485 1486 ALOGD ("%s: exit", __FUNCTION__); 1487} 1488 1489 1490/******************************************************************************* 1491** 1492** Function: isPeerToPeer 1493** 1494** Description: Whether the activation data indicates the peer supports NFC-DEP. 1495** activated: Activation data. 1496** 1497** Returns: True if the peer supports NFC-DEP. 1498** 1499*******************************************************************************/ 1500static bool isPeerToPeer (tNFA_ACTIVATED& activated) 1501{ 1502 return activated.activate_ntf.protocol == NFA_PROTOCOL_NFC_DEP; 1503} 1504 1505/******************************************************************************* 1506** 1507** Function: isListenMode 1508** 1509** Description: Indicates whether the activation data indicates it is 1510** listen mode. 1511** 1512** Returns: True if this listen mode. 1513** 1514*******************************************************************************/ 1515static bool isListenMode(tNFA_ACTIVATED& activated) 1516{ 1517 return ((NFC_DISCOVERY_TYPE_LISTEN_A == activated.activate_ntf.rf_tech_param.mode) 1518 || (NFC_DISCOVERY_TYPE_LISTEN_B == activated.activate_ntf.rf_tech_param.mode) 1519 || (NFC_DISCOVERY_TYPE_LISTEN_F == activated.activate_ntf.rf_tech_param.mode) 1520 || (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == activated.activate_ntf.rf_tech_param.mode) 1521 || (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == activated.activate_ntf.rf_tech_param.mode) 1522 || (NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == activated.activate_ntf.rf_tech_param.mode) 1523 || (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == activated.activate_ntf.rf_tech_param.mode)); 1524} 1525 1526/******************************************************************************* 1527** 1528** Function: nfcManager_doCheckLlcp 1529** 1530** Description: Not used. 1531** 1532** Returns: True 1533** 1534*******************************************************************************/ 1535static jboolean nfcManager_doCheckLlcp(JNIEnv*, jobject) 1536{ 1537 ALOGD("%s", __FUNCTION__); 1538 return JNI_TRUE; 1539} 1540 1541 1542/******************************************************************************* 1543** 1544** Function: nfcManager_doActivateLlcp 1545** 1546** Description: Not used. 1547** 1548** Returns: True 1549** 1550*******************************************************************************/ 1551static jboolean nfcManager_doActivateLlcp(JNIEnv*, jobject) 1552{ 1553 ALOGD("%s", __FUNCTION__); 1554 return JNI_TRUE; 1555} 1556 1557 1558/******************************************************************************* 1559** 1560** Function: nfcManager_doAbort 1561** 1562** Description: Not used. 1563** 1564** Returns: None 1565** 1566*******************************************************************************/ 1567static void nfcManager_doAbort(JNIEnv*, jobject) 1568{ 1569 ALOGE("%s: abort()", __FUNCTION__); 1570 abort(); 1571} 1572 1573 1574/******************************************************************************* 1575** 1576** Function: nfcManager_doDownload 1577** 1578** Description: Not used. 1579** 1580** Returns: True 1581** 1582*******************************************************************************/ 1583static jboolean nfcManager_doDownload(JNIEnv*, jobject) 1584{ 1585 ALOGD("%s", __FUNCTION__); 1586 return JNI_TRUE; 1587} 1588 1589 1590/******************************************************************************* 1591** 1592** Function: nfcManager_doResetTimeouts 1593** 1594** Description: Not used. 1595** 1596** Returns: None 1597** 1598*******************************************************************************/ 1599static void nfcManager_doResetTimeouts(JNIEnv*, jobject) 1600{ 1601 ALOGD ("%s: %d millisec", __FUNCTION__, DEFAULT_GENERAL_TRANS_TIMEOUT); 1602 gGeneralTransceiveTimeout = DEFAULT_GENERAL_TRANS_TIMEOUT; 1603} 1604 1605 1606/******************************************************************************* 1607** 1608** Function: nfcManager_doSetTimeout 1609** 1610** Description: Set timeout value. 1611** e: JVM environment. 1612** o: Java object. 1613** timeout: Timeout value. 1614** 1615** Returns: True if ok. 1616** 1617*******************************************************************************/ 1618static bool nfcManager_doSetTimeout(JNIEnv*, jobject, jint /*tech*/, jint timeout) 1619{ 1620 if (timeout <= 0) 1621 { 1622 ALOGE("%s: Timeout must be positive.",__FUNCTION__); 1623 return false; 1624 } 1625 1626 ALOGD ("%s: timeout=%d", __FUNCTION__, timeout); 1627 gGeneralTransceiveTimeout = timeout; 1628 return true; 1629} 1630 1631 1632/******************************************************************************* 1633** 1634** Function: nfcManager_doGetTimeout 1635** 1636** Description: Get timeout value. 1637** e: JVM environment. 1638** o: Java object. 1639** tech: Not used. 1640** 1641** Returns: Timeout value. 1642** 1643*******************************************************************************/ 1644static jint nfcManager_doGetTimeout(JNIEnv*, jobject, jint /*tech*/) 1645{ 1646 ALOGD ("%s: timeout=%d", __FUNCTION__, gGeneralTransceiveTimeout); 1647 return gGeneralTransceiveTimeout; 1648} 1649 1650 1651/******************************************************************************* 1652** 1653** Function: nfcManager_doDump 1654** 1655** Description: Not used. 1656** e: JVM environment. 1657** o: Java object. 1658** 1659** Returns: Text dump. 1660** 1661*******************************************************************************/ 1662static jstring nfcManager_doDump(JNIEnv* e, jobject) 1663{ 1664 char buffer[100]; 1665 snprintf(buffer, sizeof(buffer), "libnfc llc error_count=%u", /*libnfc_llc_error_count*/ 0); 1666 return e->NewStringUTF(buffer); 1667} 1668 1669 1670/******************************************************************************* 1671** 1672** Function: nfcManager_doSetP2pInitiatorModes 1673** 1674** Description: Set P2P initiator's activation modes. 1675** e: JVM environment. 1676** o: Java object. 1677** modes: Active and/or passive modes. The values are specified 1678** in external/libnfc-nxp/inc/phNfcTypes.h. See 1679** enum phNfc_eP2PMode_t. 1680** 1681** Returns: None. 1682** 1683*******************************************************************************/ 1684static void nfcManager_doSetP2pInitiatorModes (JNIEnv *e, jobject o, jint modes) 1685{ 1686 ALOGD ("%s: modes=0x%X", __FUNCTION__, modes); 1687 struct nfc_jni_native_data *nat = getNative(e, o); 1688 1689 tNFA_TECHNOLOGY_MASK mask = 0; 1690 if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A; 1691 if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F; 1692 if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F; 1693 if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE; 1694 if (modes & 0x10) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE; 1695 if (modes & 0x20) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE; 1696 nat->tech_mask = mask; 1697 1698 //this function is not called by the NFC service nor exposed by public API. 1699} 1700 1701 1702/******************************************************************************* 1703** 1704** Function: nfcManager_doSetP2pTargetModes 1705** 1706** Description: Set P2P target's activation modes. 1707** e: JVM environment. 1708** o: Java object. 1709** modes: Active and/or passive modes. 1710** 1711** Returns: None. 1712** 1713*******************************************************************************/ 1714static void nfcManager_doSetP2pTargetModes (JNIEnv*, jobject, jint modes) 1715{ 1716 ALOGD ("%s: modes=0x%X", __FUNCTION__, modes); 1717 // Map in the right modes 1718 tNFA_TECHNOLOGY_MASK mask = 0; 1719 if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A; 1720 if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F; 1721 if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F; 1722 if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE; 1723 1724 PeerToPeer::getInstance().setP2pListenMask(mask); 1725 //this function is not called by the NFC service nor exposed by public API. 1726} 1727 1728/***************************************************************************** 1729** 1730** JNI functions for android-4.0.1_r1 1731** 1732*****************************************************************************/ 1733static JNINativeMethod gMethods[] = 1734{ 1735 {"doDownload", "()Z", 1736 (void *)nfcManager_doDownload}, 1737 1738 {"initializeNativeStructure", "()Z", 1739 (void*) nfcManager_initNativeStruc}, 1740 1741 {"doInitialize", "()Z", 1742 (void*) nfcManager_doInitialize}, 1743 1744 {"doDeinitialize", "()Z", 1745 (void*) nfcManager_doDeinitialize}, 1746 1747 {"sendRawFrame", "([B)Z", 1748 (void*) nfcManager_sendRawFrame}, 1749 1750 {"routeAid", "([BI)Z", 1751 (void*) nfcManager_routeAid}, 1752 1753 {"unrouteAid", "([B)Z", 1754 (void*) nfcManager_unrouteAid}, 1755 1756 {"enableDiscovery", "()V", 1757 (void*) nfcManager_enableDiscovery}, 1758 1759 {"enableRoutingToHost", "()V", 1760 (void*) nfcManager_enableRoutingToHost}, 1761 1762 {"disableRoutingToHost", "()V", 1763 (void*) nfcManager_disableRoutingToHost}, 1764 1765 {"doGetSecureElementList", "()[I", 1766 (void *)nfcManager_doGetSecureElementList}, 1767 1768 {"doSelectSecureElement", "()V", 1769 (void *)nfcManager_doSelectSecureElement}, 1770 1771 {"doDeselectSecureElement", "()V", 1772 (void *)nfcManager_doDeselectSecureElement}, 1773 1774 {"doCheckLlcp", "()Z", 1775 (void *)nfcManager_doCheckLlcp}, 1776 1777 {"doActivateLlcp", "()Z", 1778 (void *)nfcManager_doActivateLlcp}, 1779 1780 {"doCreateLlcpConnectionlessSocket", "(ILjava/lang/String;)Lcom/android/nfc/dhimpl/NativeLlcpConnectionlessSocket;", 1781 (void *)nfcManager_doCreateLlcpConnectionlessSocket}, 1782 1783 {"doCreateLlcpServiceSocket", "(ILjava/lang/String;III)Lcom/android/nfc/dhimpl/NativeLlcpServiceSocket;", 1784 (void*) nfcManager_doCreateLlcpServiceSocket}, 1785 1786 {"doCreateLlcpSocket", "(IIII)Lcom/android/nfc/dhimpl/NativeLlcpSocket;", 1787 (void*) nfcManager_doCreateLlcpSocket}, 1788 1789 {"doGetLastError", "()I", 1790 (void*) nfcManager_doGetLastError}, 1791 1792 {"disableDiscovery", "()V", 1793 (void*) nfcManager_disableDiscovery}, 1794 1795 {"doSetTimeout", "(II)Z", 1796 (void *)nfcManager_doSetTimeout}, 1797 1798 {"doGetTimeout", "(I)I", 1799 (void *)nfcManager_doGetTimeout}, 1800 1801 {"doResetTimeouts", "()V", 1802 (void *)nfcManager_doResetTimeouts}, 1803 1804 {"doAbort", "()V", 1805 (void *)nfcManager_doAbort}, 1806 1807 {"doSetP2pInitiatorModes", "(I)V", 1808 (void *)nfcManager_doSetP2pInitiatorModes}, 1809 1810 {"doSetP2pTargetModes", "(I)V", 1811 (void *)nfcManager_doSetP2pTargetModes}, 1812 1813 {"doDump", "()Ljava/lang/String;", 1814 (void *)nfcManager_doDump}, 1815}; 1816 1817 1818/******************************************************************************* 1819** 1820** Function: register_com_android_nfc_NativeNfcManager 1821** 1822** Description: Regisgter JNI functions with Java Virtual Machine. 1823** e: Environment of JVM. 1824** 1825** Returns: Status of registration. 1826** 1827*******************************************************************************/ 1828int register_com_android_nfc_NativeNfcManager (JNIEnv *e) 1829{ 1830 ALOGD ("%s: enter", __FUNCTION__); 1831 PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); 1832 ALOGD ("%s: exit", __FUNCTION__); 1833 return jniRegisterNativeMethods (e, gNativeNfcManagerClassName, gMethods, NELEM (gMethods)); 1834} 1835 1836 1837/******************************************************************************* 1838** 1839** Function: startRfDiscovery 1840** 1841** Description: Ask stack to start polling and listening for devices. 1842** isStart: Whether to start. 1843** 1844** Returns: None 1845** 1846*******************************************************************************/ 1847void startRfDiscovery(bool isStart) 1848{ 1849 tNFA_STATUS status = NFA_STATUS_FAILED; 1850 1851 ALOGD ("%s: is start=%d", __FUNCTION__, isStart); 1852 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 1853 status = isStart ? NFA_StartRfDiscovery () : NFA_StopRfDiscovery (); 1854 if (status == NFA_STATUS_OK) 1855 { 1856 sNfaEnableDisablePollingEvent.wait (); //wait for NFA_RF_DISCOVERY_xxxx_EVT 1857 sRfEnabled = isStart; 1858 } 1859 else 1860 { 1861 ALOGE ("%s: Failed to start/stop RF discovery; error=0x%X", __FUNCTION__, status); 1862 } 1863} 1864 1865 1866/******************************************************************************* 1867** 1868** Function: doStartupConfig 1869** 1870** Description: Configure the NFC controller. 1871** 1872** Returns: None 1873** 1874*******************************************************************************/ 1875void doStartupConfig() 1876{ 1877 unsigned long num = 0; 1878 struct nfc_jni_native_data *nat = getNative(0, 0); 1879 tNFA_STATUS stat = NFA_STATUS_FAILED; 1880 1881 // If polling for Active mode, set the ordering so that we choose Active over Passive mode first. 1882 if (nat && (nat->tech_mask & (NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE))) 1883 { 1884 UINT8 act_mode_order_param[] = { 0x01 }; 1885 SyncEventGuard guard (sNfaSetConfigEvent); 1886 stat = NFA_SetConfig(NCI_PARAM_ID_ACT_ORDER, sizeof(act_mode_order_param), &act_mode_order_param[0]); 1887 if (stat == NFA_STATUS_OK) 1888 sNfaSetConfigEvent.wait (); 1889 } 1890} 1891 1892 1893/******************************************************************************* 1894** 1895** Function: nfcManager_isNfcActive 1896** 1897** Description: Used externaly to determine if NFC is active or not. 1898** 1899** Returns: 'true' if the NFC stack is running, else 'false'. 1900** 1901*******************************************************************************/ 1902bool nfcManager_isNfcActive() 1903{ 1904 return sIsNfaEnabled; 1905} 1906 1907 1908/******************************************************************************* 1909** 1910** Function: startStopPolling 1911** 1912** Description: Start or stop polling. 1913** isStartPolling: true to start polling; false to stop polling. 1914** 1915** Returns: None. 1916** 1917*******************************************************************************/ 1918void startStopPolling (bool isStartPolling) 1919{ 1920 ALOGD ("%s: enter; isStart=%u", __FUNCTION__, isStartPolling); 1921 tNFA_STATUS stat = NFA_STATUS_FAILED; 1922 1923 startRfDiscovery (false); 1924 if (isStartPolling) 1925 { 1926 tNFA_TECHNOLOGY_MASK tech_mask = DEFAULT_TECH_MASK; 1927 unsigned long num = 0; 1928 if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) 1929 tech_mask = num; 1930 1931 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 1932 ALOGD ("%s: enable polling", __FUNCTION__); 1933 stat = NFA_EnablePolling (tech_mask); 1934 if (stat == NFA_STATUS_OK) 1935 { 1936 ALOGD ("%s: wait for enable event", __FUNCTION__); 1937 sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT 1938 } 1939 else 1940 ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, stat); 1941 } 1942 else 1943 { 1944 SyncEventGuard guard (sNfaEnableDisablePollingEvent); 1945 ALOGD ("%s: disable polling", __FUNCTION__); 1946 stat = NFA_DisablePolling (); 1947 if (stat == NFA_STATUS_OK) 1948 { 1949 sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT 1950 } 1951 else 1952 ALOGE ("%s: fail disable polling; error=0x%X", __FUNCTION__, stat); 1953 } 1954 startRfDiscovery (true); 1955 ALOGD ("%s: exit", __FUNCTION__); 1956} 1957 1958 1959} /* namespace android */ 1960