diff options
| -rw-r--r-- | nci/jni/Android.mk | 3 | ||||
| -rw-r--r-- | nci/jni/Mutex.h | 11 | ||||
| -rwxr-xr-x | nci/jni/NativeNfcManager.cpp | 65 | ||||
| -rwxr-xr-x | nci/jni/NativeSecureElement.cpp | 1 | ||||
| -rw-r--r-- | nci/jni/PeerToPeer.cpp | 520 | ||||
| -rw-r--r-- | nci/jni/PeerToPeer.h | 185 | ||||
| -rwxr-xr-x | nci/jni/PowerSwitch.cpp | 12 | ||||
| -rwxr-xr-x | nci/jni/SecureElement.cpp | 2 | ||||
| -rwxr-xr-x | src/com/android/nfc/NfcService.java | 31 |
9 files changed, 480 insertions, 350 deletions
diff --git a/nci/jni/Android.mk b/nci/jni/Android.mk index 335e5f1..39832fd 100644 --- a/nci/jni/Android.mk +++ b/nci/jni/Android.mk @@ -25,11 +25,14 @@ LOCAL_C_INCLUDES += \ external/stlport/stlport \ external/libxml2/include \ external/icu4c/common \ + frameworks/native/include \ $(NFA)/include \ $(NFA)/brcm \ $(NFC)/include \ $(NFC)/brcm \ $(NFC)/int \ + $(VOB_COMPONENTS)/hal/include \ + $(VOB_COMPONENTS)/hal/int \ $(VOB_COMPONENTS)/include \ $(VOB_COMPONENTS)/gki/ulinux \ $(VOB_COMPONENTS)/gki/common diff --git a/nci/jni/Mutex.h b/nci/jni/Mutex.h index bd762c2..1b500ee 100644 --- a/nci/jni/Mutex.h +++ b/nci/jni/Mutex.h @@ -87,7 +87,18 @@ public: *******************************************************************************/ pthread_mutex_t* nativeHandle (); + class Autolock { + public: + inline Autolock(Mutex& mutex) : mLock(mutex) { mLock.lock(); } + inline Autolock(Mutex* mutex) : mLock(*mutex) { mLock.lock(); } + inline ~Autolock() { mLock.unlock(); } + private: + Mutex& mLock; + }; + + private: pthread_mutex_t mMutex; }; +typedef Mutex::Autolock AutoMutex; diff --git a/nci/jni/NativeNfcManager.cpp b/nci/jni/NativeNfcManager.cpp index b97a20f..fcab063 100755 --- a/nci/jni/NativeNfcManager.cpp +++ b/nci/jni/NativeNfcManager.cpp @@ -32,17 +32,16 @@ extern "C" { #include "nfa_api.h" #include "nfa_p2p_api.h" - #include "nfa_dta_api.h" #include "rw_api.h" #include "nfa_ee_api.h" - #include "nfa_brcm_api.h" + #include "nfc_brcm_defs.h" #include "nfa_cho_api.h" + #include "ce_api.h" } extern UINT8 *p_nfa_dm_lptd_cfg; extern UINT8 *p_nfa_dm_start_up_cfg; extern const UINT8 nfca_version_string []; -extern "C" void downloadFirmwarePatchFile (UINT32 brcm_hw_id); namespace android { extern bool gIsTagDeactivating; @@ -106,7 +105,6 @@ static SyncEvent sNfaEnableEvent; //event for NFA_Enable() static SyncEvent sNfaDisableEvent; //event for NFA_Disable() static SyncEvent sNfaEnableDisablePollingEvent; //event for NFA_EnablePolling(), NFA_DisablePolling() static SyncEvent sNfaSetConfigEvent; // event for Set_Config.... -static SyncEvent sNfaBuildInfoEvent; static bool sIsNfaEnabled = false; static bool sDiscoveryEnabled = false; //is polling for tag? static bool sIsDisabling = false; @@ -133,7 +131,6 @@ static void nfaConnectionCallback (UINT8 event, tNFA_CONN_EVT_DATA *eventData); static void nfaDeviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA *eventData); static bool isPeerToPeer (tNFA_ACTIVATED& activated); static void startRfDiscovery (bool isStart); -static void nfaBrcmInitCallback (UINT32 brcm_hw_id, UINT8 nvm_type); ///////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////// @@ -616,19 +613,6 @@ void nfaDeviceManagementCallback (UINT8 dmEvent, tNFA_DM_CBACK_DATA* eventData) PowerSwitch::getInstance ().deviceManagementCallback (dmEvent, eventData); break; - case NFA_DM_FIRMWARE_BUILD_INFO_EVT: - { - tNFA_BRCM_FW_BUILD_INFO* bldInfo = - (tNFA_BRCM_FW_BUILD_INFO*) eventData->p_vs_evt_data; - if (bldInfo != NULL) { - ALOGE("BCM2079x NFC FW version %d.%d", bldInfo->patch.major_ver, - bldInfo->patch.minor_ver); - } - SyncEventGuard versionGuard (sNfaBuildInfoEvent); - sNfaBuildInfoEvent.notifyOne(); - } - break; - default: ALOGD ("%s: unhandled event", __FUNCTION__); break; @@ -662,24 +646,15 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) { unsigned long num = 0; - tBRCM_DEV_INIT_CONFIG devInitConfig; - memset (&devInitConfig, 0, sizeof(devInitConfig)); NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); theInstance.Initialize(); //start GKI, NCI task, NFC task { SyncEventGuard guard (sNfaEnableEvent); - NFA_Init(); - - // Initialize the Crystal Frequency if configured. - if (GetNumValue((char*)NAME_XTAL_FREQUENCY, &devInitConfig.xtal_freq, sizeof(devInitConfig.xtal_freq))) - { - ALOGD("%s: setting XTAL Frequency=%d", __FUNCTION__, devInitConfig.xtal_freq); - devInitConfig.flags |= BRCM_DEV_INIT_FLAGS_SET_XTAL_FREQ; - } + tHAL_NFC_ENTRY* halFuncEntries = theInstance.GetHalEntryFuncs (); - NFA_BrcmInit (&devInitConfig, nfaBrcmInitCallback); + NFA_Init (halFuncEntries); stat = NFA_Enable (nfaDeviceManagementCallback, nfaConnectionCallback); if (stat == NFA_STATUS_OK) @@ -688,7 +663,6 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) CE_SetTraceLevel (num); LLCP_SetTraceLevel (num); NFC_SetTraceLevel (num); - NCI_SetTraceLevel (num); RW_SetTraceLevel (num); NFA_SetTraceLevel (num); NFA_ChoSetTraceLevel (num); @@ -703,14 +677,6 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) //sIsNfaEnabled indicates whether stack started successfully if (sIsNfaEnabled) { - { - SyncEventGuard versionGuard (sNfaBuildInfoEvent); - stat = NFA_BrcmGetFirmwareBuildInfo(); - if (stat == NFA_STATUS_OK) { - sNfaBuildInfoEvent.wait(); - } - } - SecureElement::getInstance().initialize (getNative(e, o)); nativeNfcTag_registerNdefTypeHandler (); NfcTag::getInstance().initialize (getNative(e, o)); @@ -736,11 +702,6 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) if (sOriginalLptdCfg != NULL) p_nfa_dm_lptd_cfg = sOriginalLptdCfg; - - // if this value is not set or set and non-zero, enable multi-technology responses. - if (!GetNumValue(NAME_NFA_DM_MULTI_TECH_RESP, &num, sizeof(num)) || (num != 0)) - NFA_SetMultiTechRsp(TRUE); - // if this value exists, set polling interval. if (GetNumValue(NAME_NFA_DM_DISC_DURATION_POLL, &num, sizeof(num))) NFA_SetRfDiscoveryDuration(num); @@ -1716,23 +1677,5 @@ bool nfcManager_isNfcActive() } -/******************************************************************************* -** -** Function: nfaBrcmInitCallback -** -** Description: Callback function for application to start device initialization. -** When platform-specific initialization is completed, -** NCI_BrcmDevInitDone() must be called to proceed with stack start up. -** -** Returns: None. -** -*******************************************************************************/ -void nfaBrcmInitCallback (UINT32 brcm_hw_id, UINT8 nvm_type) -{ - ALOGD ("%s: enter; brcm_hw_id=0x%lX; nvm_type=0x%X", __FUNCTION__, brcm_hw_id, nvm_type); - downloadFirmwarePatchFile (brcm_hw_id); -} - - } /* namespace android */ diff --git a/nci/jni/NativeSecureElement.cpp b/nci/jni/NativeSecureElement.cpp index 7054b26..9fa27e3 100755 --- a/nci/jni/NativeSecureElement.cpp +++ b/nci/jni/NativeSecureElement.cpp @@ -17,7 +17,6 @@ #include "OverrideLog.h" #include "SecureElement.h" #include "JavaClassConstants.h" -#include "nfa_brcm_api.h" namespace android diff --git a/nci/jni/PeerToPeer.cpp b/nci/jni/PeerToPeer.cpp index bf18df5..78132b8 100644 --- a/nci/jni/PeerToPeer.cpp +++ b/nci/jni/PeerToPeer.cpp @@ -15,6 +15,8 @@ #include "config.h" #include "JavaClassConstants.h" +using namespace android; + namespace android { extern void nativeNfcTag_registerNdefTypeHandler (); @@ -23,7 +25,7 @@ namespace android PeerToPeer PeerToPeer::sP2p; -const std::string PeerToPeer::sSnepServiceName ("urn:nfc:sn:snep"); +const std::string P2pServer::sSnepServiceName ("urn:nfc:sn:snep"); /******************************************************************************* @@ -100,15 +102,16 @@ void PeerToPeer::initialize () /******************************************************************************* ** -** Function: findServer +** Function: findServerLocked ** ** Description: Find a PeerToPeer object by connection handle. +** Assumes mMutex is already held ** nfaP2pServerHandle: Connectin handle. ** ** Returns: PeerToPeer object. ** *******************************************************************************/ -P2pServer *PeerToPeer::findServer (tNFA_HANDLE nfaP2pServerHandle) +sp<P2pServer> PeerToPeer::findServerLocked (tNFA_HANDLE nfaP2pServerHandle) { for (int i = 0; i < sMax; i++) { @@ -126,15 +129,16 @@ P2pServer *PeerToPeer::findServer (tNFA_HANDLE nfaP2pServerHandle) /******************************************************************************* ** -** Function: findServer +** Function: findServerLocked ** ** Description: Find a PeerToPeer object by connection handle. +** Assumes mMutex is already held ** serviceName: service name. ** ** Returns: PeerToPeer object. ** *******************************************************************************/ -P2pServer *PeerToPeer::findServer (tJNI_HANDLE jniHandle) +sp<P2pServer> PeerToPeer::findServerLocked (tJNI_HANDLE jniHandle) { for (int i = 0; i < sMax; i++) { @@ -152,15 +156,16 @@ P2pServer *PeerToPeer::findServer (tJNI_HANDLE jniHandle) /******************************************************************************* ** -** Function: findServer +** Function: findServerLocked ** ** Description: Find a PeerToPeer object by service name +** Assumes mMutex is already heldf ** serviceName: service name. ** ** Returns: PeerToPeer object. ** *******************************************************************************/ -P2pServer *PeerToPeer::findServer (const char *serviceName) +sp<P2pServer> PeerToPeer::findServerLocked (const char *serviceName) { for (int i = 0; i < sMax; i++) { @@ -189,16 +194,18 @@ bool PeerToPeer::registerServer (tJNI_HANDLE jniHandle, const char *serviceName) static const char fn [] = "PeerToPeer::registerServer"; ALOGD ("%s: enter; service name: %s JNI handle: %u", fn, serviceName, jniHandle); tNFA_STATUS stat = NFA_STATUS_OK; - P2pServer *pSrv = NULL; + sp<P2pServer> pSrv = NULL; UINT8 serverSap = NFA_P2P_ANY_SAP; + mMutex.lock(); // Check if already registered - if ((pSrv = findServer(serviceName)) != NULL) + if ((pSrv = findServerLocked(serviceName)) != NULL) { ALOGD ("%s: service name=%s already registered, handle: 0x%04x", fn, serviceName, pSrv->mNfaP2pServerHandle); // Update JNI handle pSrv->mJniHandle = jniHandle; + mMutex.unlock(); return (true); } @@ -206,14 +213,13 @@ bool PeerToPeer::registerServer (tJNI_HANDLE jniHandle, const char *serviceName) { if (mServers[ii] == NULL) { - pSrv = mServers[ii] = new P2pServer; - pSrv->mServiceName.assign (serviceName); - pSrv->mJniHandle = jniHandle; + pSrv = mServers[ii] = new P2pServer(jniHandle, serviceName); ALOGD ("%s: added new p2p server index: %d handle: %u name: %s", fn, ii, jniHandle, serviceName); break; } } + mMutex.unlock(); if (pSrv == NULL) { @@ -221,58 +227,14 @@ bool PeerToPeer::registerServer (tJNI_HANDLE jniHandle, const char *serviceName) return (false); } - /********************** - default values for all LLCP parameters: - - Local Link MIU (LLCP_MIU) - - Option parameter (LLCP_OPT_VALUE) - - Response Waiting Time Index (LLCP_WAITING_TIME) - - Local Link Timeout (LLCP_LTO_VALUE) - - Inactivity Timeout as initiator role (LLCP_INIT_INACTIVITY_TIMEOUT) - - Inactivity Timeout as target role (LLCP_TARGET_INACTIVITY_TIMEOUT) - - Delay SYMM response (LLCP_DELAY_RESP_TIME) - - Data link connection timeout (LLCP_DATA_LINK_CONNECTION_TOUT) - - Delay timeout to send first PDU as initiator (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU) - ************************/ - stat = NFA_P2pSetLLCPConfig (LLCP_MIU, - LLCP_OPT_VALUE, - LLCP_WAITING_TIME, - LLCP_LTO_VALUE, - 0, //use 0 for infinite timeout for symmetry procedure when acting as initiator - 0, //use 0 for infinite timeout for symmetry procedure when acting as target - LLCP_DELAY_RESP_TIME, - LLCP_DATA_LINK_CONNECTION_TOUT, - LLCP_DELAY_TIME_TO_SEND_FIRST_PDU); - if (stat != NFA_STATUS_OK) - ALOGE ("%s: fail set LLCP config; error=0x%X", fn, stat); - - if (sSnepServiceName.compare(serviceName) == 0) - serverSap = LLCP_SAP_SNEP; //LLCP_SAP_SNEP == 4 - - { - SyncEventGuard guard (pSrv->mRegServerEvent); - stat = NFA_P2pRegisterServer (serverSap, NFA_P2P_DLINK_TYPE, const_cast<char*>(serviceName), nfaServerCallback); - if (stat != NFA_STATUS_OK) - { - ALOGE ("%s: fail register p2p server; error=0x%X", fn, stat); - removeServer (jniHandle); - return (false); - } - ALOGD ("%s: wait for listen-completion event", fn); - // Wait for NFA_P2P_REG_SERVER_EVT - pSrv->mRegServerEvent.wait (); - } - - if (pSrv->mNfaP2pServerHandle == NFA_HANDLE_INVALID) - { + if (pSrv->registerWithStack()) { + ALOGD ("%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle); + return (true); + } else { ALOGE ("%s: invalid server handle", fn); removeServer (jniHandle); return (false); } - else - { - ALOGD ("%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle); - return (true); - } } @@ -290,6 +252,8 @@ void PeerToPeer::removeServer (tJNI_HANDLE jniHandle) { static const char fn [] = "PeerToPeer::removeServer"; + AutoMutex mutex(mMutex); + for (int i = 0; i < sMax; i++) { if ( (mServers[i] != NULL) && (mServers[i]->mJniHandle == jniHandle) ) @@ -297,7 +261,6 @@ void PeerToPeer::removeServer (tJNI_HANDLE jniHandle) ALOGD ("%s: server jni_handle: %u; nfa_handle: 0x%04x; name: %s; index=%d", fn, jniHandle, mServers[i]->mNfaP2pServerHandle, mServers[i]->mServiceName.c_str(), i); - delete mServers [i]; mServers [i] = NULL; return; } @@ -453,70 +416,24 @@ bool PeerToPeer::accept (tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle, { static const char fn [] = "PeerToPeer::accept"; tNFA_STATUS nfaStat = NFA_STATUS_FAILED; - NfaConn *pConn = NULL; + sp<NfaConn> *pConn = NULL; bool stat = false; int ii = 0; - P2pServer *pSrv = NULL; + sp<P2pServer> pSrv = NULL; ALOGD ("%s: enter; server jni handle: %u; conn jni handle: %u; maxInfoUnit: %d; recvWindow: %d", fn, serverJniHandle, connJniHandle, maxInfoUnit, recvWindow); - if ((pSrv = findServer (serverJniHandle)) == NULL) + mMutex.lock(); + if ((pSrv = findServerLocked (serverJniHandle)) == NULL) { ALOGE ("%s: unknown server jni handle: %u", fn, serverJniHandle); + mMutex.unlock(); return (false); } + mMutex.unlock(); - // First, find a free connection block to handle the connection - for (ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++) - { - if (pSrv->mServerConn[ii] == NULL) - { - ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; allocate server conn index: %u", fn, - serverJniHandle, connJniHandle, ii); - pSrv->mServerConn[ii] = new NfaConn; - pSrv->mServerConn[ii]->mJniHandle = connJniHandle; - break; - } - } - - if (ii == MAX_NFA_CONNS_PER_SERVER) - { - ALOGE ("%s: fail allocate connection block", fn); - return (false); - } - - { - // Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device requests connection - SyncEventGuard guard (pSrv->mConnRequestEvent); - ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; server conn index: %u; wait for incoming connection", fn, - serverJniHandle, connJniHandle, ii); - pSrv->mConnRequestEvent.wait(); - ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; server conn index: %u; nfa conn h: 0x%X; got incoming connection", fn, - serverJniHandle, connJniHandle, ii, pSrv->mServerConn[ii]->mNfaConnHandle); - } - - if (pSrv->mServerConn[ii]->mNfaConnHandle == NFA_HANDLE_INVALID) - { - delete (pSrv->mServerConn[ii]); - pSrv->mServerConn[ii] = NULL; - ALOGD ("%s: no handle assigned", fn); - return (false); - } - - ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; server conn index: %u; nfa conn h: 0x%X; try accept", fn, - serverJniHandle, connJniHandle, ii, pSrv->mServerConn[ii]->mNfaConnHandle); - nfaStat = NFA_P2pAcceptConn (pSrv->mServerConn[ii]->mNfaConnHandle, maxInfoUnit, recvWindow); - - if (nfaStat != NFA_STATUS_OK) - { - ALOGE ("%s: fail to accept remote; error=0x%X", fn, nfaStat); - return (false); - } - - ALOGD ("%s: exit; serverJniHandle: %u; connJniHandle: %u; server conn index: %u; nfa conn h: 0x%X", fn, - serverJniHandle, connJniHandle, ii, pSrv->mServerConn[ii]->mNfaConnHandle); - return (true); + return pSrv->accept(serverJniHandle, connJniHandle, maxInfoUnit, recvWindow); } @@ -534,13 +451,16 @@ bool PeerToPeer::deregisterServer (tJNI_HANDLE jniHandle) static const char fn [] = "PeerToPeer::deregisterServer"; ALOGD ("%s: enter; JNI handle: %u", fn, jniHandle); tNFA_STATUS nfaStat = NFA_STATUS_FAILED; - P2pServer *pSrv = NULL; + sp<P2pServer> pSrv = NULL; - if ((pSrv = findServer (jniHandle)) == NULL) + mMutex.lock(); + if ((pSrv = findServerLocked (jniHandle)) == NULL) { ALOGE ("%s: unknown service handle: %u", fn, jniHandle); + mMutex.unlock(); return (false); } + mMutex.unlock(); { // Server does not call NFA_P2pDisconnect(), so unblock the accept() @@ -579,39 +499,44 @@ bool PeerToPeer::createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw) int i = 0; ALOGD ("%s: enter: jni h: %u miu: %u rw: %u", fn, jniHandle, miu, rw); + mMutex.lock(); + sp<P2pClient> client = NULL; for (i = 0; i < sMax; i++) { if (mClients[i] == NULL) { - mClients [i] = new P2pClient; + mClients [i] = client = new P2pClient(); - mClients [i]->mClientConn.mJniHandle = jniHandle; - mClients [i]->mClientConn.mMaxInfoUnit = miu; - mClients [i]->mClientConn.mRecvWindow = rw; + mClients [i]->mClientConn->mJniHandle = jniHandle; + mClients [i]->mClientConn->mMaxInfoUnit = miu; + mClients [i]->mClientConn->mRecvWindow = rw; break; } } + mMutex.unlock(); - if (i == sMax) + if (client == NULL) { ALOGE ("%s: fail", fn); return (false); } - ALOGD ("%s: pClient: 0x%p assigned for client jniHandle: %u", fn, mClients[i], jniHandle); + ALOGD ("%s: pClient: 0x%p assigned for client jniHandle: %u", fn, client.get(), jniHandle); - SyncEventGuard guard (mClients[i]->mRegisteringEvent); - NFA_P2pRegisterClient (NFA_P2P_DLINK_TYPE, nfaClientCallback); - mClients[i]->mRegisteringEvent.wait(); //wait for NFA_P2P_REG_CLIENT_EVT + { + SyncEventGuard guard (mClients[i]->mRegisteringEvent); + NFA_P2pRegisterClient (NFA_P2P_DLINK_TYPE, nfaClientCallback); + mClients[i]->mRegisteringEvent.wait(); //wait for NFA_P2P_REG_CLIENT_EVT + } if (mClients[i]->mNfaP2pClientHandle != NFA_HANDLE_INVALID) { - ALOGD ("%s: exit; new client jniHandle: %u NFA Handle: 0x%04x", fn, jniHandle, mClients[i]->mClientConn.mNfaConnHandle); + ALOGD ("%s: exit; new client jniHandle: %u NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle); return (true); } else { - ALOGE ("%s: FAILED; new client jniHandle: %u NFA Handle: 0x%04x", fn, jniHandle, mClients[i]->mClientConn.mNfaConnHandle); + ALOGE ("%s: FAILED; new client jniHandle: %u NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle); removeConn (jniHandle); return (false); } @@ -633,15 +558,15 @@ void PeerToPeer::removeConn(tJNI_HANDLE jniHandle) static const char fn[] = "PeerToPeer::removeConn"; int ii = 0, jj = 0; + AutoMutex mutex(mMutex); // If the connection is a for a client, delete the client itself for (ii = 0; ii < sMax; ii++) { - if (mClients[ii] && (mClients[ii]->mClientConn.mJniHandle == jniHandle)) + if ((mClients[ii] != NULL) && (mClients[ii]->mClientConn->mJniHandle == jniHandle)) { if (mClients[ii]->mNfaP2pClientHandle != NFA_HANDLE_INVALID) NFA_P2pDeregister (mClients[ii]->mNfaP2pClientHandle); - delete mClients[ii]; mClients[ii] = NULL; ALOGD ("%s: deleted client handle: %u index: %u", fn, jniHandle, ii); return; @@ -653,17 +578,8 @@ void PeerToPeer::removeConn(tJNI_HANDLE jniHandle) { if (mServers[ii] != NULL) { - for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) - { - if ( (mServers[ii]->mServerConn[jj] != NULL) - && (mServers[ii]->mServerConn[jj]->mJniHandle == jniHandle) ) - { - ALOGD ("%s: delete server conn jni h: %u; index: %d; server jni h: %u", - fn, mServers[ii]->mServerConn[jj]->mJniHandle, jj, mServers[ii]->mJniHandle); - delete mServers[ii]->mServerConn[jj]; - mServers[ii]->mServerConn[jj] = NULL; - return; - } + if (mServers[ii]->removeServerConnection(jniHandle)) { + return; } } } @@ -731,7 +647,7 @@ bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceN static const char fn [] = "PeerToPeer::createDataLinkConn"; ALOGD ("%s: enter", fn); tNFA_STATUS nfaStat = NFA_STATUS_FAILED; - P2pClient *pClient = NULL; + sp<P2pClient> pClient = NULL; if ((pClient = findClient (jniHandle)) == NULL) { @@ -745,21 +661,21 @@ bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceN if (serviceName) nfaStat = NFA_P2pConnectByName (pClient->mNfaP2pClientHandle, - const_cast<char*>(serviceName), pClient->mClientConn.mMaxInfoUnit, - pClient->mClientConn.mRecvWindow); + const_cast<char*>(serviceName), pClient->mClientConn->mMaxInfoUnit, + pClient->mClientConn->mRecvWindow); else if (destinationSap) nfaStat = NFA_P2pConnectBySap (pClient->mNfaP2pClientHandle, destinationSap, - pClient->mClientConn.mMaxInfoUnit, pClient->mClientConn.mRecvWindow); + pClient->mClientConn->mMaxInfoUnit, pClient->mClientConn->mRecvWindow); if (nfaStat == NFA_STATUS_OK) { - ALOGD ("%s: wait for connected event mConnectingEvent: 0x%p", fn, pClient); + ALOGD ("%s: wait for connected event mConnectingEvent: 0x%p", fn, pClient.get()); pClient->mConnectingEvent.wait(); } } if (nfaStat == NFA_STATUS_OK) { - if (pClient->mClientConn.mNfaConnHandle == NFA_HANDLE_INVALID) + if (pClient->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID) { removeConn (jniHandle); nfaStat = NFA_STATUS_FAILED; @@ -788,11 +704,12 @@ bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceN ** Returns: PeerToPeer object. ** *******************************************************************************/ -P2pClient *PeerToPeer::findClient (tNFA_HANDLE nfaConnHandle) +sp<P2pClient> PeerToPeer::findClient (tNFA_HANDLE nfaConnHandle) { + AutoMutex mutex(mMutex); for (int i = 0; i < sMax; i++) { - if (mClients[i] && (mClients[i]->mNfaP2pClientHandle == nfaConnHandle)) + if ((mClients[i] != NULL) && (mClients[i]->mNfaP2pClientHandle == nfaConnHandle)) return (mClients[i]); } return (NULL); @@ -809,11 +726,12 @@ P2pClient *PeerToPeer::findClient (tNFA_HANDLE nfaConnHandle) ** Returns: PeerToPeer object. ** *******************************************************************************/ -P2pClient *PeerToPeer::findClient (tJNI_HANDLE jniHandle) +sp<P2pClient> PeerToPeer::findClient (tJNI_HANDLE jniHandle) { + AutoMutex mutex(mMutex); for (int i = 0; i < sMax; i++) { - if (mClients[i] && (mClients[i]->mClientConn.mJniHandle == jniHandle)) + if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mJniHandle == jniHandle)) return (mClients[i]); } return (NULL); @@ -830,11 +748,12 @@ P2pClient *PeerToPeer::findClient (tJNI_HANDLE jniHandle) ** Returns: PeerToPeer object. ** *******************************************************************************/ -P2pClient *PeerToPeer::findClientCon (tNFA_HANDLE nfaConnHandle) +sp<P2pClient> PeerToPeer::findClientCon (tNFA_HANDLE nfaConnHandle) { + AutoMutex mutex(mMutex); for (int i = 0; i < sMax; i++) { - if (mClients[i] && (mClients[i]->mClientConn.mNfaConnHandle == nfaConnHandle)) + if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mNfaConnHandle == nfaConnHandle)) return (mClients[i]); } return (NULL); @@ -851,16 +770,18 @@ P2pClient *PeerToPeer::findClientCon (tNFA_HANDLE nfaConnHandle) ** Returns: PeerToPeer object. ** *******************************************************************************/ -NfaConn *PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle) +sp<NfaConn> PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle) { int ii = 0, jj = 0; + AutoMutex mutex(mMutex); // First, look through all the client control blocks for (ii = 0; ii < sMax; ii++) { if ( (mClients[ii] != NULL) - && (mClients[ii]->mClientConn.mNfaConnHandle == nfaConnHandle) ) - return (&mClients[ii]->mClientConn); + && (mClients[ii]->mClientConn->mNfaConnHandle == nfaConnHandle) ) { + return mClients[ii]->mClientConn; + } } // Not found yet. Look through all the server control blocks @@ -868,11 +789,9 @@ NfaConn *PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle) { if (mServers[ii] != NULL) { - for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) - { - if ( (mServers[ii]->mServerConn[jj] != NULL) - && (mServers[ii]->mServerConn[jj]->mNfaConnHandle == nfaConnHandle) ) - return (mServers[ii]->mServerConn[jj]); + sp<NfaConn> conn = mServers[ii]->findServerConnection(nfaConnHandle); + if (conn != NULL) { + return conn; } } } @@ -892,16 +811,18 @@ NfaConn *PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle) ** Returns: PeerToPeer object. ** *******************************************************************************/ -NfaConn *PeerToPeer::findConnection (tJNI_HANDLE jniHandle) +sp<NfaConn> PeerToPeer::findConnection (tJNI_HANDLE jniHandle) { int ii = 0, jj = 0; + AutoMutex mutex(mMutex); // First, look through all the client control blocks for (ii = 0; ii < sMax; ii++) { if ( (mClients[ii] != NULL) - && (mClients[ii]->mClientConn.mJniHandle == jniHandle) ) - return (&mClients[ii]->mClientConn); + && (mClients[ii]->mClientConn->mJniHandle == jniHandle) ) { + return mClients[ii]->mClientConn; + } } // Not found yet. Look through all the server control blocks @@ -909,11 +830,9 @@ NfaConn *PeerToPeer::findConnection (tJNI_HANDLE jniHandle) { if (mServers[ii] != NULL) { - for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) - { - if ( (mServers[ii]->mServerConn[jj] != NULL) - && (mServers[ii]->mServerConn[jj]->mJniHandle == jniHandle) ) - return (mServers[ii]->mServerConn[jj]); + sp<NfaConn> conn = mServers[ii]->findServerConnection(jniHandle); + if (conn != NULL) { + return conn; } } } @@ -939,7 +858,7 @@ bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen) { static const char fn [] = "PeerToPeer::send"; tNFA_STATUS nfaStat = NFA_STATUS_FAILED; - NfaConn *pConn = NULL; + sp<NfaConn> pConn = NULL; if ((pConn = findConnection (jniHandle)) == NULL) { @@ -993,7 +912,7 @@ bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen { static const char fn [] = "PeerToPeer::receive"; ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; jniHandle: %u bufferLen: %u", fn, jniHandle, bufferLen); - NfaConn *pConn = NULL; + sp<NfaConn> pConn = NULL; tNFA_STATUS stat = NFA_STATUS_FAILED; UINT32 actualDataLen2 = 0; BOOLEAN isMoreData = TRUE; @@ -1043,8 +962,8 @@ bool PeerToPeer::disconnectConnOriented (tJNI_HANDLE jniHandle) { static const char fn [] = "PeerToPeer::disconnectConnOriented"; tNFA_STATUS nfaStat = NFA_STATUS_FAILED; - P2pClient *pClient = NULL; - NfaConn *pConn = NULL; + sp<P2pClient> pClient = NULL; + sp<NfaConn> pConn = NULL; ALOGD ("%s: enter; jni handle: %u", fn, jniHandle); @@ -1105,7 +1024,7 @@ bool PeerToPeer::disconnectConnOriented (tJNI_HANDLE jniHandle) UINT16 PeerToPeer::getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle) { static const char fn [] = "PeerToPeer::getRemoteMaxInfoUnit"; - NfaConn *pConn = NULL; + sp<NfaConn> pConn = NULL; if ((pConn = findConnection(jniHandle)) == NULL) { @@ -1131,7 +1050,7 @@ UINT8 PeerToPeer::getRemoteRecvWindow (tJNI_HANDLE jniHandle) { static const char fn [] = "PeerToPeer::getRemoteRecvWindow"; ALOGD ("%s: client jni handle: %u", fn, jniHandle); - NfaConn *pConn = NULL; + sp<NfaConn> pConn = NULL; if ((pConn = findConnection(jniHandle)) == NULL) { @@ -1218,6 +1137,7 @@ void PeerToPeer::handleNfcOnOff (bool isOn) mIsP2pListening = false; // In both cases, P2P will not be listening + AutoMutex mutex(mMutex); if (isOn) { // Start with no clients or servers @@ -1233,21 +1153,21 @@ void PeerToPeer::handleNfcOnOff (bool isOn) { if (mClients[ii] != NULL) { - if (mClients[ii]->mClientConn.mNfaConnHandle == NFA_HANDLE_INVALID) + if (mClients[ii]->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID) { SyncEventGuard guard (mClients[ii]->mConnectingEvent); mClients[ii]->mConnectingEvent.notifyOne(); } else { - mClients[ii]->mClientConn.mNfaConnHandle = NFA_HANDLE_INVALID; + mClients[ii]->mClientConn->mNfaConnHandle = NFA_HANDLE_INVALID; { - SyncEventGuard guard1 (mClients[ii]->mClientConn.mCongEvent); - mClients[ii]->mClientConn.mCongEvent.notifyOne (); //unblock send() + SyncEventGuard guard1 (mClients[ii]->mClientConn->mCongEvent); + mClients[ii]->mClientConn->mCongEvent.notifyOne (); //unblock send() } { - SyncEventGuard guard2 (mClients[ii]->mClientConn.mReadEvent); - mClients[ii]->mClientConn.mReadEvent.notifyOne (); //unblock receive() + SyncEventGuard guard2 (mClients[ii]->mClientConn->mReadEvent); + mClients[ii]->mClientConn->mReadEvent.notifyOne (); //unblock receive() } } } @@ -1258,21 +1178,7 @@ void PeerToPeer::handleNfcOnOff (bool isOn) { if (mServers[ii] != NULL) { - for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) - { - if (mServers[ii]->mServerConn[jj] != NULL) - { - mServers[ii]->mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID; - { - SyncEventGuard guard1 (mServers[ii]->mServerConn[jj]->mCongEvent); - mServers[ii]->mServerConn[jj]->mCongEvent.notifyOne (); //unblock write (if congested) - } - { - SyncEventGuard guard2 (mServers[ii]->mServerConn[jj]->mReadEvent); - mServers[ii]->mServerConn[jj]->mReadEvent.notifyOne (); //unblock receive() - } - } - } + mServers[ii]->unblockAll(); } } //loop @@ -1295,8 +1201,8 @@ void PeerToPeer::handleNfcOnOff (bool isOn) void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData) { static const char fn [] = "PeerToPeer::nfaServerCallback"; - P2pServer *pSrv = NULL; - NfaConn *pConn = NULL; + sp<P2pServer> pSrv = NULL; + sp<NfaConn> pConn = NULL; ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=0x%X", fn, p2pEvent); @@ -1306,7 +1212,10 @@ void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev ALOGD ("%s: NFA_P2P_REG_SERVER_EVT; handle: 0x%04x; service sap=0x%02x name: %s", fn, eventData->reg_server.server_handle, eventData->reg_server.server_sap, eventData->reg_server.service_name); - if ((pSrv = sP2p.findServer(eventData->reg_server.service_name)) == NULL) + sP2p.mMutex.lock(); + pSrv = sP2p.findServerLocked(eventData->reg_server.service_name); + sP2p.mMutex.unlock(); + if (pSrv == NULL) { ALOGE ("%s: NFA_P2P_REG_SERVER_EVT for unknown service: %s", fn, eventData->reg_server.service_name); } @@ -1330,7 +1239,10 @@ void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; nfa server h=0x%04x; nfa conn h=0x%04x; remote sap=0x%02x", fn, eventData->conn_req.server_handle, eventData->conn_req.conn_handle, eventData->conn_req.remote_sap); - if ((pSrv = sP2p.findServer(eventData->conn_req.server_handle)) == NULL) + sP2p.mMutex.lock(); + pSrv = sP2p.findServerLocked(eventData->conn_req.server_handle); + sP2p.mMutex.unlock(); + if (pSrv == NULL) { ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; unknown server h", fn); return; @@ -1338,7 +1250,7 @@ void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u", fn, pSrv->mJniHandle); // Look for a connection block that is waiting (handle invalid) - if ((pConn = pSrv->findServerConnection(NFA_HANDLE_INVALID)) == NULL) + if ((pConn = pSrv->findServerConnection((tNFA_HANDLE) NFA_HANDLE_INVALID)) == NULL) { ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; server not listening", fn); } @@ -1446,8 +1358,8 @@ void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData) { static const char fn [] = "PeerToPeer::nfaClientCallback"; - NfaConn *pConn = NULL; - P2pClient *pClient = NULL; + sp<NfaConn> pConn = NULL; + sp<P2pClient> pClient = NULL; ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=%u", fn, p2pEvent); @@ -1461,7 +1373,7 @@ void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev } else { - ALOGD ("%s: NFA_P2P_REG_CLIENT_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->reg_client.client_handle, pClient); + ALOGD ("%s: NFA_P2P_REG_CLIENT_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->reg_client.client_handle, pClient.get()); SyncEventGuard guard (pClient->mRegisteringEvent); pClient->mNfaP2pClientHandle = eventData->reg_client.client_handle; @@ -1477,7 +1389,7 @@ void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev } else { - ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->activated.handle, pClient); + ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->activated.handle, pClient.get()); } break; @@ -1494,12 +1406,12 @@ void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev else { ALOGD ("%s: NFA_P2P_CONNECTED_EVT; client_handle=0x%04x conn_handle: 0x%04x remote sap=0x%X pClient: 0x%p", fn, - eventData->connected.client_handle, eventData->connected.conn_handle, eventData->connected.remote_sap, pClient); + eventData->connected.client_handle, eventData->connected.conn_handle, eventData->connected.remote_sap, pClient.get()); SyncEventGuard guard (pClient->mConnectingEvent); - pClient->mClientConn.mNfaConnHandle = eventData->connected.conn_handle; - pClient->mClientConn.mRemoteMaxInfoUnit = eventData->connected.remote_miu; - pClient->mClientConn.mRemoteRecvWindow = eventData->connected.remote_rw; + pClient->mClientConn->mNfaConnHandle = eventData->connected.conn_handle; + pClient->mClientConn->mRemoteMaxInfoUnit = eventData->connected.remote_miu; + pClient->mClientConn->mRemoteRecvWindow = eventData->connected.remote_rw; pClient->mConnectingEvent.notifyOne(); //unblock createDataLinkConn() } break; @@ -1641,13 +1553,147 @@ PeerToPeer::tJNI_HANDLE PeerToPeer::getNewJniHandle () ** Returns: None ** *******************************************************************************/ -P2pServer::P2pServer() +P2pServer::P2pServer(PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName) : mNfaP2pServerHandle (NFA_HANDLE_INVALID), - mJniHandle (0) + mJniHandle (jniHandle) { + mServiceName.assign (serviceName); + memset (mServerConn, 0, sizeof(mServerConn)); } +bool P2pServer::registerWithStack() +{ + static const char fn [] = "P2pServer::registerWithStack"; + ALOGD ("%s: enter; service name: %s JNI handle: %u", fn, mServiceName.c_str(), mJniHandle); + tNFA_STATUS stat = NFA_STATUS_OK; + UINT8 serverSap = NFA_P2P_ANY_SAP; + + /********************** + default values for all LLCP parameters: + - Local Link MIU (LLCP_MIU) + - Option parameter (LLCP_OPT_VALUE) + - Response Waiting Time Index (LLCP_WAITING_TIME) + - Local Link Timeout (LLCP_LTO_VALUE) + - Inactivity Timeout as initiator role (LLCP_INIT_INACTIVITY_TIMEOUT) + - Inactivity Timeout as target role (LLCP_TARGET_INACTIVITY_TIMEOUT) + - Delay SYMM response (LLCP_DELAY_RESP_TIME) + - Data link connection timeout (LLCP_DATA_LINK_CONNECTION_TOUT) + - Delay timeout to send first PDU as initiator (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU) + ************************/ + stat = NFA_P2pSetLLCPConfig (LLCP_MIU, + LLCP_OPT_VALUE, + LLCP_WAITING_TIME, + LLCP_LTO_VALUE, + 0, //use 0 for infinite timeout for symmetry procedure when acting as initiator + 0, //use 0 for infinite timeout for symmetry procedure when acting as target + LLCP_DELAY_RESP_TIME, + LLCP_DATA_LINK_CONNECTION_TOUT, + LLCP_DELAY_TIME_TO_SEND_FIRST_PDU); + if (stat != NFA_STATUS_OK) + ALOGE ("%s: fail set LLCP config; error=0x%X", fn, stat); + + if (sSnepServiceName.compare(mServiceName) == 0) + serverSap = LLCP_SAP_SNEP; //LLCP_SAP_SNEP == 4 + + { + SyncEventGuard guard (mRegServerEvent); + stat = NFA_P2pRegisterServer (serverSap, NFA_P2P_DLINK_TYPE, const_cast<char*>(mServiceName.c_str()), + PeerToPeer::nfaServerCallback); + if (stat != NFA_STATUS_OK) + { + ALOGE ("%s: fail register p2p server; error=0x%X", fn, stat); + return (false); + } + ALOGD ("%s: wait for listen-completion event", fn); + // Wait for NFA_P2P_REG_SERVER_EVT + mRegServerEvent.wait (); + } + + return (mNfaP2pServerHandle != NFA_HANDLE_INVALID); +} + +bool P2pServer::accept(PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle, + int maxInfoUnit, int recvWindow) +{ + static const char fn [] = "P2pServer::accept"; + tNFA_STATUS nfaStat = NFA_STATUS_OK; + + sp<NfaConn> connection = allocateConnection(connJniHandle); + if (connection == NULL) { + ALOGE ("%s: failed to allocate new server connection", fn); + return false; + } + + { + // Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device requests connection + SyncEventGuard guard (mConnRequestEvent); + ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; wait for incoming connection", fn, + serverJniHandle, connJniHandle); + mConnRequestEvent.wait(); + ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; got incoming connection", fn, + serverJniHandle, connJniHandle, connection->mNfaConnHandle); + } + + if (connection->mNfaConnHandle == NFA_HANDLE_INVALID) + { + removeServerConnection(connJniHandle); + ALOGD ("%s: no handle assigned", fn); + return (false); + } + + ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; try accept", fn, + serverJniHandle, connJniHandle, connection->mNfaConnHandle); + nfaStat = NFA_P2pAcceptConn (connection->mNfaConnHandle, maxInfoUnit, recvWindow); + + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail to accept remote; error=0x%X", fn, nfaStat); + return (false); + } + + ALOGD ("%s: exit; serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X", fn, + serverJniHandle, connJniHandle, connection->mNfaConnHandle); + return (true); +} + +void P2pServer::unblockAll() +{ + AutoMutex mutex(mMutex); + for (int jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if (mServerConn[jj] != NULL) + { + mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID; + { + SyncEventGuard guard1 (mServerConn[jj]->mCongEvent); + mServerConn[jj]->mCongEvent.notifyOne (); //unblock write (if congested) + } + { + SyncEventGuard guard2 (mServerConn[jj]->mReadEvent); + mServerConn[jj]->mReadEvent.notifyOne (); //unblock receive() + } + } + } +} + +sp<NfaConn> P2pServer::allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle) +{ + AutoMutex mutex(mMutex); + // First, find a free connection block to handle the connection + for (int ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++) + { + if (mServerConn[ii] == NULL) + { + mServerConn[ii] = new NfaConn; + mServerConn[ii]->mJniHandle = jniHandle; + return mServerConn[ii]; + } + } + + return NULL; +} + /******************************************************************************* ** @@ -1659,10 +1705,11 @@ P2pServer::P2pServer() ** Returns: P2pServer object. ** *******************************************************************************/ -NfaConn *P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle) +sp<NfaConn> P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle) { int jj = 0; + AutoMutex mutex(mMutex); for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) { if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mNfaConnHandle == nfaConnHandle) ) @@ -1673,7 +1720,57 @@ NfaConn *P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle) return (NULL); } +/******************************************************************************* +** +** Function: findServerConnection +** +** Description: Find a P2pServer that has the handle. +** nfaConnHandle: NFA connection handle. +** +** Returns: P2pServer object. +** +*******************************************************************************/ +sp<NfaConn> P2pServer::findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle) +{ + int jj = 0; + + AutoMutex mutex(mMutex); + for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) + return (mServerConn[jj]); + } + + // If here, not found + return (NULL); +} + +/******************************************************************************* +** +** Function: removeServerConnection +** +** Description: Find a P2pServer that has the handle. +** nfaConnHandle: NFA connection handle. +** +** Returns: P2pServer object. +** +*******************************************************************************/ +bool P2pServer::removeServerConnection (PeerToPeer::tJNI_HANDLE jniHandle) +{ + int jj = 0; + AutoMutex mutex(mMutex); + for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) { + mServerConn[jj] = NULL; + return true; + } + } + + // If here, not found + return false; +} ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// @@ -1691,6 +1788,7 @@ P2pClient::P2pClient () : mNfaP2pClientHandle (NFA_HANDLE_INVALID), mIsConnecting (false) { + mClientConn = new NfaConn(); } diff --git a/nci/jni/PeerToPeer.h b/nci/jni/PeerToPeer.h index 040ca78..951b69e 100644 --- a/nci/jni/PeerToPeer.h +++ b/nci/jni/PeerToPeer.h @@ -9,6 +9,8 @@ ** *****************************************************************************/ #pragma once +#include <utils/RefBase.h> +#include <utils/StrongPointer.h> #include "SyncEvent.h" #include "NfcJniUtil.h" #include <string> @@ -23,7 +25,6 @@ class P2pClient; class NfaConn; #define MAX_NFA_CONNS_PER_SERVER 5 - /***************************************************************************** ** ** Name: PeerToPeer @@ -36,7 +37,6 @@ class PeerToPeer public: typedef unsigned int tJNI_HANDLE; - /******************************************************************************* ** ** Function: PeerToPeer @@ -331,26 +331,6 @@ public: *******************************************************************************/ tJNI_HANDLE getNewJniHandle (); - -private: - static const int sMax = 10; - static PeerToPeer sP2p; - static const std::string sSnepServiceName; - static const std::string sNppServiceName; - UINT16 mRemoteWKS; // Peer's well known services - bool mIsP2pListening; // If P2P listening is enabled or not - tNFA_TECHNOLOGY_MASK mP2pListenTechMask; // P2P Listen mask - tJNI_HANDLE mNextJniHandle; - - P2pServer *mServers [sMax]; - P2pClient *mClients [sMax]; - SyncEvent mSetTechEvent; // completion event for NFA_SetP2pListenTech() - SyncEvent mSnepDefaultServerStartStopEvent; // completion event for NFA_SnepStartDefaultServer(), NFA_SnepStopDefaultServer() - SyncEvent mSnepRegisterEvent; // completion event for NFA_SnepRegisterClient() - Mutex mDisconnectMutex; // synchronize the disconnect operation - Mutex mNewJniHandleMutex; // synchronize the creation of a new JNI handle - - /******************************************************************************* ** ** Function: nfaServerCallback @@ -378,6 +358,31 @@ private: *******************************************************************************/ static void nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA *eventData); +private: + static const int sMax = 10; + static PeerToPeer sP2p; + + // Variables below only accessed from a single thread + UINT16 mRemoteWKS; // Peer's well known services + bool mIsP2pListening; // If P2P listening is enabled or not + tNFA_TECHNOLOGY_MASK mP2pListenTechMask; // P2P Listen mask + + // Variable below is protected by mNewJniHandleMutex + tJNI_HANDLE mNextJniHandle; + + // Variables below protected by mMutex + // A note on locking order: mMutex in PeerToPeer is *ALWAYS* + // locked before any locks / guards in P2pServer / P2pClient + Mutex mMutex; + android::sp<P2pServer> mServers [sMax]; + android::sp<P2pClient> mClients [sMax]; + + // Synchronization variables + SyncEvent mSetTechEvent; // completion event for NFA_SetP2pListenTech() + SyncEvent mSnepDefaultServerStartStopEvent; // completion event for NFA_SnepStartDefaultServer(), NFA_SnepStopDefaultServer() + SyncEvent mSnepRegisterEvent; // completion event for NFA_SnepRegisterClient() + Mutex mDisconnectMutex; // synchronize the disconnect operation + Mutex mNewJniHandleMutex; // synchronize the creation of a new JNI handle /******************************************************************************* ** @@ -417,7 +422,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - P2pServer *findServer (tNFA_HANDLE nfaP2pServerHandle); + android::sp<P2pServer> findServerLocked (tNFA_HANDLE nfaP2pServerHandle); /******************************************************************************* @@ -430,7 +435,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - P2pServer *findServer (tJNI_HANDLE jniHandle); + android::sp<P2pServer> findServerLocked (tJNI_HANDLE jniHandle); /******************************************************************************* @@ -443,7 +448,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - P2pServer *findServer (const char *serviceName); + android::sp<P2pServer> findServerLocked (const char *serviceName); /******************************************************************************* @@ -497,7 +502,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - P2pClient *findClient (tNFA_HANDLE nfaConnHandle); + android::sp<P2pClient> findClient (tNFA_HANDLE nfaConnHandle); /******************************************************************************* @@ -510,7 +515,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - P2pClient *findClient (tJNI_HANDLE jniHandle); + android::sp<P2pClient> findClient (tJNI_HANDLE jniHandle); /******************************************************************************* @@ -523,7 +528,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - P2pClient *findClientCon (tNFA_HANDLE nfaConnHandle); + android::sp<P2pClient> findClientCon (tNFA_HANDLE nfaConnHandle); /******************************************************************************* @@ -536,7 +541,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - NfaConn *findConnection (tNFA_HANDLE nfaConnHandle); + android::sp<NfaConn> findConnection (tNFA_HANDLE nfaConnHandle); /******************************************************************************* @@ -549,7 +554,7 @@ private: ** Returns: PeerToPeer object. ** *******************************************************************************/ - NfaConn *findConnection (tJNI_HANDLE jniHandle); + android::sp<NfaConn> findConnection (tJNI_HANDLE jniHandle); }; @@ -560,11 +565,11 @@ private: ** Description: Store information about a connection related to a peer. ** *****************************************************************************/ -class NfaConn +class NfaConn : public android::RefBase { public: tNFA_HANDLE mNfaConnHandle; // NFA handle of the P2P connection - PeerToPeer::tJNI_HANDLE mJniHandle; // JNI handle of the P2P connection + PeerToPeer::tJNI_HANDLE mJniHandle; // JNI handle of the P2P connection UINT16 mMaxInfoUnit; UINT8 mRecvWindow; UINT16 mRemoteMaxInfoUnit; @@ -594,15 +599,16 @@ public: ** Description: Store information about an in-bound connection from a peer. ** *****************************************************************************/ -class P2pServer +class P2pServer : public android::RefBase { public: + static const std::string sSnepServiceName; + tNFA_HANDLE mNfaP2pServerHandle; // NFA p2p handle of local server - PeerToPeer::tJNI_HANDLE mJniHandle; // JNI Handle + PeerToPeer::tJNI_HANDLE mJniHandle; // JNI Handle SyncEvent mRegServerEvent; // for NFA_P2pRegisterServer() SyncEvent mConnRequestEvent; // for accept() std::string mServiceName; - NfaConn *mServerConn[MAX_NFA_CONNS_PER_SERVER]; /******************************************************************************* ** @@ -613,8 +619,45 @@ public: ** Returns: None ** *******************************************************************************/ - P2pServer (); + P2pServer (PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName); + /******************************************************************************* + ** + ** Function: registerWithStack + ** + ** Description: Register this server with the stack. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool registerWithStack(); + + /******************************************************************************* + ** + ** Function: accept + ** + ** Description: Accept a peer's request to connect. + ** serverJniHandle: Server's handle. + ** connJniHandle: Connection handle. + ** maxInfoUnit: Maximum information unit. + ** recvWindow: Receive window size. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool accept (PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle, + int maxInfoUnit, int recvWindow); + + /******************************************************************************* + ** + ** Function: unblockAll + ** + ** Description: Unblocks all server connections + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + void unblockAll(); /******************************************************************************* ** @@ -626,7 +669,49 @@ public: ** Returns: P2pServer object. ** *******************************************************************************/ - NfaConn *findServerConnection (tNFA_HANDLE nfaConnHandle); + android::sp<NfaConn> findServerConnection (tNFA_HANDLE nfaConnHandle); + + /******************************************************************************* + ** + ** Function: findServerConnection + ** + ** Description: Find a P2pServer that has the handle. + ** jniHandle: JNI connection handle. + ** + ** Returns: P2pServer object. + ** + *******************************************************************************/ + android::sp<NfaConn> findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle); + + /******************************************************************************* + ** + ** Function: removeServerConnection + ** + ** Description: Remove a server connection with the provided handle. + ** jniHandle: JNI connection handle. + ** + ** Returns: True if connection found and removed. + ** + *******************************************************************************/ + bool removeServerConnection(PeerToPeer::tJNI_HANDLE jniHandle); + +private: + Mutex mMutex; + // mServerConn is protected by mMutex + android::sp<NfaConn> mServerConn[MAX_NFA_CONNS_PER_SERVER]; + + /******************************************************************************* + ** + ** Function: allocateConnection + ** + ** Description: Allocate a new connection to accept on + ** jniHandle: JNI connection handle. + ** + ** Returns: Allocated connection object + ** NULL if the maximum number of connections was reached + ** + *******************************************************************************/ + android::sp<NfaConn> allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle); }; @@ -637,15 +722,15 @@ public: ** Description: Store information about an out-bound connection to a peer. ** *****************************************************************************/ -class P2pClient +class P2pClient : public android::RefBase { public: - tNFA_HANDLE mNfaP2pClientHandle; // NFA p2p handle of client - bool mIsConnecting; // Set true while connecting - NfaConn mClientConn; - SyncEvent mRegisteringEvent; // For client registration - SyncEvent mConnectingEvent; // for NFA_P2pConnectByName or Sap() - SyncEvent mSnepEvent; // To wait for SNEP completion + tNFA_HANDLE mNfaP2pClientHandle; // NFA p2p handle of client + bool mIsConnecting; // Set true while connecting + android::sp<NfaConn> mClientConn; + SyncEvent mRegisteringEvent; // For client registration + SyncEvent mConnectingEvent; // for NFA_P2pConnectByName or Sap() + SyncEvent mSnepEvent; // To wait for SNEP completion /******************************************************************************* ** @@ -669,5 +754,17 @@ public: ** *******************************************************************************/ ~P2pClient (); + + + /******************************************************************************* + ** + ** Function: unblock + ** + ** Description: Unblocks any threads that are locked on this connection + ** + ** Returns: None + ** + *******************************************************************************/ + void unblock(); }; diff --git a/nci/jni/PowerSwitch.cpp b/nci/jni/PowerSwitch.cpp index ba1a96b..11d1abe 100755 --- a/nci/jni/PowerSwitch.cpp +++ b/nci/jni/PowerSwitch.cpp @@ -13,7 +13,6 @@ #include "NfcJniUtil.h" #include "config.h" #include "SecureElement.h" -#include "userial.h" namespace android @@ -226,17 +225,6 @@ bool PowerSwitch::setPowerOffSleepState (bool sleep) { mPowerStateEvent.wait (); mCurrLevel = LOW_POWER; - ALOGD ("%s: wait for userial close", fn); - int count = 0; - while (USERIAL_IsClosed() == FALSE) - { - //must wait for userial to close completely; - //otherwise there is a race condition when the next operation - //wants to go to full-power again; - count++; - usleep (5000); //5 milliseconds = 5 000 microseconds - } - ALOGD ("%s: userial close ok; count=%d", fn, count); } else { diff --git a/nci/jni/SecureElement.cpp b/nci/jni/SecureElement.cpp index 57c33bb..5008998 100755 --- a/nci/jni/SecureElement.cpp +++ b/nci/jni/SecureElement.cpp @@ -16,8 +16,6 @@ #include "config.h" #include "PowerSwitch.h" #include "HostAidRouter.h" -#include "nfa_vs_brcm_api.h" -#include "nfa_brcm_api.h" #include "JavaClassConstants.h" diff --git a/src/com/android/nfc/NfcService.java b/src/com/android/nfc/NfcService.java index 3acfa1c..e8fc9e4 100755 --- a/src/com/android/nfc/NfcService.java +++ b/src/com/android/nfc/NfcService.java @@ -187,9 +187,8 @@ public class NfcService extends Application implements DeviceHostListener { private SharedPreferences mPrefs; private SharedPreferences.Editor mPrefsEditor; private PowerManager.WakeLock mRoutingWakeLock; - private PowerManager.WakeLock mOpenWakeLock; - private PowerManager.WakeLock mDisconnectWakeLock; - private PowerManager.WakeLock mTransceiveWakeLock; + private PowerManager.WakeLock mEeWakeLock; + int mStartSound; int mEndSound; int mErrorSound; @@ -323,16 +322,10 @@ public class NfcService extends Application implements DeviceHostListener { mPowerManager = (PowerManager) getSystemService(Context.POWER_SERVICE); - // TODO(mikey|maco): consolidate as a single wakelock when individual - // stats are no longer useful. mRoutingWakeLock = mPowerManager.newWakeLock( PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mRoutingWakeLock"); - mOpenWakeLock = mPowerManager.newWakeLock( - PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mOpenWakeLock"); - mDisconnectWakeLock = mPowerManager.newWakeLock( - PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mDisconnectWakeLock"); - mTransceiveWakeLock = mPowerManager.newWakeLock( - PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mTransceiveWakeLock"); + mEeWakeLock = mPowerManager.newWakeLock( + PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mEeWakeLock"); mKeyguard = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE); mScreenState = checkScreenState(); @@ -417,20 +410,20 @@ public class NfcService extends Application implements DeviceHostListener { } int doOpenSecureElementConnection() { - mOpenWakeLock.acquire(); + mEeWakeLock.acquire(); try { return mSecureElement.doOpenSecureElementConnection(); } finally { - mOpenWakeLock.release(); + mEeWakeLock.release(); } } byte[] doTransceive(int handle, byte[] cmd) { - mTransceiveWakeLock.acquire(); + mEeWakeLock.acquire(); try { return doTransceiveNoLock(handle, cmd); } finally { - mTransceiveWakeLock.release(); + mEeWakeLock.release(); } } @@ -439,11 +432,11 @@ public class NfcService extends Application implements DeviceHostListener { } void doDisconnect(int handle) { - mDisconnectWakeLock.acquire(); + mEeWakeLock.acquire(); try { mSecureElement.doDisconnect(handle); } finally { - mDisconnectWakeLock.release(); + mEeWakeLock.release(); } } @@ -640,7 +633,7 @@ public class NfcService extends Application implements DeviceHostListener { } try { - mTransceiveWakeLock.acquire(); + mEeWakeLock.acquire(); try { mDeviceHost.setTimeout(TagTechnology.ISO_DEP, 10000); @@ -654,7 +647,7 @@ public class NfcService extends Application implements DeviceHostListener { mDeviceHost.resetTimeouts(); } finally { - mTransceiveWakeLock.release(); + mEeWakeLock.release(); } } finally { doDisconnect(handle); |