C++ SyncEvent::wait方法代码示例

 INT32 nativeNfcLlcp_ConnLessReceiveMessage(UINT8* msg, UINT32 *length)
 {
        NXPLOG_API_D ("%s: enter\n", __FUNCTION__);
        if(msg == NULL || length == NULL){
            NXPLOG_API_E ("%s: Invalid buffer or length", __FUNCTION__);
            return NFA_STATUS_FAILED;
        }

        NXPLOG_API_D("nfaLlcpServerCallBack: remote sap ID 0x%04x\n ", bDestSap);
        if( (bServerReadState == FALSE) && (bClientReadState == FALSE) )
        {
            sNfaLlcpConnLessReadEvent.wait();
        }

        if(NFA_STATUS_OK != NFA_P2pReadUI ((size_t)sLlcpConnLessHandle,
                     LLCP_MAX_DATA_SIZE,
                     &bDestSap,
                     &dwLlcpReadLength,
                     &bLlcpReadData[0],
                     &blMoreDataRemaining))
        {
            NXPLOG_API_D ("%s: send response failed.", __FUNCTION__);
            return NFA_STATUS_FAILED;
        }
        else
        {
            memcpy(msg,bLlcpReadData, dwLlcpReadLength);
            *length = dwLlcpReadLength;
            NXPLOG_API_D ("%s: exit\n", __FUNCTION__);
            bServerReadState = FALSE;
            bClientReadState = FALSE;
            return NFA_STATUS_OK;
        }

 }

/*******************************************************************************
**
** Function:        nativeNfcTag_doRead
**
** Description:     Read the NDEF message on the tag.
**                  e: JVM environment.
**                  o: Java object.
**
** Returns:         NDEF message.
**
*******************************************************************************/
static jbyteArray nativeNfcTag_doRead (JNIEnv* e, jobject)
{
    ALOGD ("%s: enter", __FUNCTION__);
    tNFA_STATUS status = NFA_STATUS_FAILED;
    jbyteArray buf = NULL;

    sReadDataLen = 0;
    if (sReadData != NULL)
    {
        free (sReadData);
        sReadData = NULL;
    }

    if (sCheckNdefCurrentSize > 0)
    {
        {
            SyncEventGuard g (sReadEvent);
            sIsReadingNdefMessage = true;
            status = NFA_RwReadNDef ();
            sReadEvent.wait (); //wait for NFA_READ_CPLT_EVT
        }
        sIsReadingNdefMessage = false;

        if (sReadDataLen > 0) //if stack actually read data from the tag
        {
            ALOGD ("%s: read %u bytes", __FUNCTION__, sReadDataLen);
            buf = e->NewByteArray (sReadDataLen);
            e->SetByteArrayRegion (buf, 0, sReadDataLen, (jbyte*) sReadData);
        }
    }
    else
    {
        ALOGD ("%s: create empty buffer", __FUNCTION__);
        sReadDataLen = 0;
        sReadData = (uint8_t*) malloc (1);
        buf = e->NewByteArray (sReadDataLen);
        e->SetByteArrayRegion (buf, 0, sReadDataLen, (jbyte*) sReadData);
    }

    if (sReadData)
    {
        free (sReadData);
        sReadData = NULL;
    }
    sReadDataLen = 0;

    ALOGD ("%s: exit", __FUNCTION__);
    return buf;
}

INT32 nativeNfcLlcp_ConnLessRegisterClientCallback(nfcllcpConnlessClientCallback_t *clientCallback)
{
    tNFA_STATUS status = NFA_STATUS_FAILED;
    pthread_t llcpCleintRespThread;
    int ret = 1;
    NXPLOG_API_D ("%s:", __FUNCTION__);

    gSyncMutex.lock();
    if (!nativeNfcManager_isNfcActive())
    {
        NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
        gSyncMutex.unlock();
        return NFA_STATUS_FAILED;
    }

    sRfEnabled = isDiscoveryStarted();
    if (sRfEnabled)
    {
        /* Stop RF Discovery if we were polling */
        startRfDiscovery (FALSE);
    }

    {
        SyncEventGuard g (sNfaLlcpClientRegEvent);
        bClientReadState = FALSE;
        if(NFA_STATUS_OK != (status = NFA_P2pRegisterClient(NFA_P2P_LLINK_TYPE, nfaLlcpClientCallback)))
        {
            NXPLOG_API_E ("%s: fail to register client callback for LLCP", __FUNCTION__);
            if (sRfEnabled)
            {
                /*  Rollback to default */
                startRfDiscovery (TRUE);
                gSyncMutex.unlock();
                return status;
            }

        }
        sNfaLlcpClientRegEvent.wait();
    }

    sClientCallback = clientCallback;
    status = NFA_STATUS_OK;

    gSyncMutex.unlock();
    return status;
}

static void *snepServerThread(void *arg)
{
    (void)arg;
    SyncEventGuard guard (sNfaSnepServerPutRspEvent);

    NXPLOG_API_D ("%s: enter\n", __FUNCTION__);
    while(sSnepServerState == SNEP_SERVER_STARTED)
    {
        sNfaSnepServerPutRspEvent.wait();
        if (sSnepServerConnectionHandle == 0)
            break;
        if(NFA_STATUS_OK != NFA_SnepPutResponse(sSnepServerConnectionHandle, sNfaSnepRespCode))
        {
            NXPLOG_API_D ("%s: send response failed.", __FUNCTION__);
        }
    }
    NXPLOG_API_D ("%s: exit\n", __FUNCTION__);
    pthread_exit(NULL);
    return NULL;
}

INT32 nativeNfcSnep_registerClientCallback(nfcSnepClientCallback_t *clientCallback)
{
    tNFA_STATUS status = NFA_STATUS_FAILED;
    NXPLOG_API_D ("%s:", __FUNCTION__);
    gSyncMutex.lock();
    if (!nativeNfcManager_isNfcActive())
    {
        NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
        gSyncMutex.unlock();
        return NFA_STATUS_FAILED;
    }
    sRfEnabled = isDiscoveryStarted();
    if (sRfEnabled)
    {
        // Stop RF Discovery if we were polling
        startRfDiscovery (FALSE);
    }
    {
        SyncEventGuard g (sNfaSnepClientRegEvent);
        if(NFA_STATUS_OK != (status = NFA_SnepRegisterClient(nfaSnepClientCallback)))
        {
            NXPLOG_API_E ("%s: fail to register client callback for SNEP", __FUNCTION__);
            goto clean_and_return;
        }
        sNfaSnepClientRegEvent.wait();
    }
    sClientCallback = clientCallback;
    status = NFA_STATUS_OK;
clean_and_return:
    if (sRfEnabled)
    {
        // Stop RF Discovery if we were polling
        startRfDiscovery (TRUE);
    }
    gSyncMutex.unlock();
    return status;
}

INT32 nativeNfcSnep_putMessage(UINT8* msg, UINT32 length)
{
    tNFA_STATUS status = NFA_STATUS_FAILED;
    NXPLOG_API_D ("%s: data length = %d", __FUNCTION__, length);

    if (!sSnepClientHandle)
    {
        NXPLOG_API_E ("%s: no connection", __FUNCTION__);
        return NFA_STATUS_FAILED;
    }
    if (!msg || length == 0)
    {
        NXPLOG_API_E ("%s: wrong param", __FUNCTION__);
        return NFA_STATUS_FAILED;
    }
    if(NFA_STATUS_OK != NDEF_MsgValidate(msg, length, FALSE))
    {
        NXPLOG_API_E ("%s: not NDEF message", __FUNCTION__);
        return NFA_STATUS_FAILED;
    }
    gSyncMutex.lock();
    if (!nativeNfcManager_isNfcActive())
    {
        NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
        status = NFA_STATUS_FAILED;
        goto clean_and_return;
    }
    if (sSnepClientHandle){
        SyncEventGuard guard (sNfaSnepClientConnEvent);
        if(NFA_STATUS_OK != NFA_SnepConnect(sSnepClientHandle, SNEP_SERVER_NAME))
        {
            status = NFA_STATUS_FAILED;
            goto clean_and_return;
        }
        sNfaSnepClientConnEvent.wait();
    }

    /* Send Put Request */
    if (sSnepClientConnectionHandle != 0)
    {
        SyncEventGuard guard (sNfaSnepClientPutMsgEvent);
        if(NFA_STATUS_OK != NFA_SnepPut (sSnepClientConnectionHandle, length, msg))
        {
            status = NFA_STATUS_FAILED;
            goto clean_and_return;
        }
        sNfaSnepClientPutMsgEvent.wait();
        if (sSnepClientPutState != NFA_STATUS_OK)
        {
            status = NFA_STATUS_FAILED;
        }
        else
        {
            status = NFA_STATUS_OK;
            sSnepClientPutState = NFA_STATUS_FAILED;
        }
    }
    /* Disconnect from Snep Server */
    if (sSnepClientConnectionHandle != 0)
    {
        SyncEventGuard guard (sNfaSnepClientDisconnEvent);
        if(NFA_STATUS_OK != NFA_SnepDisconnect (sSnepClientConnectionHandle, 0x01))
        {
            status = NFA_STATUS_FAILED;
            goto clean_and_return;
        }
        sNfaSnepClientDisconnEvent.wait();
    }
clean_and_return:
    NXPLOG_API_D ("%s: return = %d", __FUNCTION__, status);
    gSyncMutex.unlock();
    return status;
}

INT32 nativeNfcSnep_startServer(nfcSnepServerCallback_t *serverCallback)
{
    tNFA_STATUS status = NFA_STATUS_OK;
    int ret;
    pthread_t snepRespThread;

    NXPLOG_API_D ("%s:", __FUNCTION__);
    if (serverCallback == NULL)
    {
        NXPLOG_API_E ("%s: callback is NULL!", __FUNCTION__);
        return NFA_STATUS_FAILED;
    }

    gSyncMutex.lock();
    if (!nativeNfcManager_isNfcActive())
    {
        NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
        gSyncMutex.unlock();
        return NFA_STATUS_FAILED;
    }

    if (sSnepServerState == SNEP_SERVER_STARTED && serverCallback == sServerCallback)
    {
        NXPLOG_API_D ("%s: alread started!", __FUNCTION__);
        gSyncMutex.unlock();
        return NFA_STATUS_OK;
    }
    if (sSnepServerState != SNEP_SERVER_IDLE)
    {
        NXPLOG_API_E ("%s: Server is started or busy. State = 0x%X", __FUNCTION__, sSnepServerState);
        gSyncMutex.unlock();
        return NFA_STATUS_FAILED;
    }

    sServerCallback = serverCallback;
    sSnepServerState = SNEP_SERVER_STARTING;

    sRfEnabled = isDiscoveryStarted();
    if (sRfEnabled)
    {
        // Stop RF Discovery if we were polling
        startRfDiscovery (FALSE);
    }
    {
        SyncEventGuard guard (sNfaSnepServerRegEvent);
        if(NFA_STATUS_OK != NFA_SnepRegisterServer(0x04, SNEP_SERVER_NAME, nfaSnepServerCallback))
        {
            status = NFA_STATUS_FAILED;
            sSnepServerState = SNEP_SERVER_IDLE;
            sServerCallback = NULL;
            goto clean_and_return;
        }
        sNfaSnepServerRegEvent.wait();
    }
    ret = pthread_create(&snepRespThread, NULL, snepServerThread, NULL);
    if(ret != 0)
    {
        NXPLOG_API_E("Unable to create snep server thread");
        sSnepServerState = SNEP_SERVER_IDLE;
        NFA_SnepDeregister(sSnepServerHandle);
        sServerCallback = NULL;
        status = NFA_STATUS_FAILED;
        goto clean_and_return;
    }

    sSnepServerState = SNEP_SERVER_STARTED;
clean_and_return:
    if (sRfEnabled)
    {
        startRfDiscovery (TRUE);
    }
    gSyncMutex.unlock();
    return status;
}

INT32 nativeNfcLlcp_ConnLessStartServer(nfcllcpConnlessServerCallback_t *serverCallback)
 {
    tNFA_STATUS status = NFA_STATUS_OK;
    int ret;
    pthread_t llcpRespThread;
    bServerReadState = FALSE;
    NXPLOG_API_D ("%s:", __FUNCTION__);
    if (serverCallback == NULL)
    {
        NXPLOG_API_E ("%s: callback is NULL!", __FUNCTION__);
        return NFA_STATUS_FAILED;
    }
    gSyncMutex.lock();
    if (!nativeNfcManager_isNfcActive())
    {
        NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
        gSyncMutex.unlock();
        return NFA_STATUS_FAILED;
    }
    if (sLlcpServerState == LLCP_SERVER_STARTED && serverCallback == sServerCallback)
    {
        NXPLOG_API_D ("%s: alread started!", __FUNCTION__);
        gSyncMutex.unlock();
        return NFA_STATUS_OK;
    }
    if (sLlcpServerState != LLCP_SERVER_IDLE)
    {
        NXPLOG_API_E ("%s: Server is started or busy. State = 0x%X", __FUNCTION__, sLlcpServerState);
        gSyncMutex.unlock();
        return NFA_STATUS_FAILED;
    }
    sServerCallback = serverCallback;
    sLlcpServerState = LLCP_SERVER_STARTING;
    sRfEnabled = isDiscoveryStarted();
    if (sRfEnabled)
    {
        /* Stop RF Discovery if we were polling */
        startRfDiscovery (FALSE);
    }
    SyncEventGuard guard (sNfaLlcpServerRegEvent);
    if(NFA_STATUS_OK != NFA_P2pRegisterServer ( LLCP_CL_SAP_ID_DEFAULT,
                                    NFA_P2P_LLINK_TYPE,
                                    (char *)LLCP_SERVER_NAME,
                                    nfaLlcpServerCallBack))
    {
        status = NFA_STATUS_FAILED;
        sLlcpServerState = LLCP_SERVER_IDLE;
        sServerCallback = NULL;
        if (sRfEnabled)
        {
            /*  Rollback to default */
            startRfDiscovery (TRUE);
            gSyncMutex.unlock();
            return status;
        }
    }
    sNfaLlcpServerRegEvent.wait();

    gSyncMutex.unlock();
    return status;


 }

/*******************************************************************************
**
** Function:        setLevel
**
** Description:     Set the controller's power level.
**                  level: power level.
**
** Returns:         True if ok.
**
*******************************************************************************/
bool PowerSwitch::setLevel (PowerLevel newLevel)
{
    static const char fn [] = "PowerSwitch::setLevel";
    bool retval = false;

    mMutex.lock ();

    ALOGD ("%s: level=%s (%u)", fn, powerLevelToString(newLevel), newLevel);
    if (mCurrLevel == newLevel)
    {
        retval = true;
        goto TheEnd;
    }

    if (mCurrLevel == UNKNOWN_LEVEL)
    {
        ALOGE ("%s: unknown power level", fn);
        goto TheEnd;
    }

    if ( (mCurrLevel == LOW_POWER && newLevel == FULL_POWER) ||
         (mCurrLevel == FULL_POWER && newLevel == LOW_POWER) )
    {
        mMutex.unlock ();
        SyncEventGuard g (gDeactivatedEvent);
        if (gActivated)
        {
            ALOGD("%s: wait for deactivation", fn);
            gDeactivatedEvent.wait ();
        }
        mMutex.lock ();
    }

    switch (newLevel)
    {
    case FULL_POWER:
        if (mCurrDeviceMgtPowerState == NFA_DM_PWR_MODE_OFF_SLEEP)
            retval = setPowerOffSleepState (false);
        break;

    case LOW_POWER:
    case POWER_OFF:
        if (isPowerOffSleepFeatureEnabled())
            retval = setPowerOffSleepState (true);
        else if (mDesiredScreenOffPowerState == 1) //.conf file desires full-power
        {
            mCurrLevel = FULL_POWER;
            retval = true;
        }
        break;

    default:
        ALOGE ("%s: not handled", fn);
        break;
    }

    ALOGD("%s: actual power level=%s", fn, powerLevelToString(mCurrLevel));

TheEnd:
    mMutex.unlock ();
    return retval;
}

/*******************************************************************************
**
** Function:        nativeNfcTag_doTransceive
**
** Description:     Send raw data to the tag; receive tag's response.
**                  e: JVM environment.
**                  o: Java object.
**                  raw: Not used.
**                  statusTargetLost: Whether tag responds or times out.
**
** Returns:         Response from tag.
**
*******************************************************************************/
static jbyteArray nativeNfcTag_doTransceive (JNIEnv* e, jobject, jbyteArray data, jboolean raw, jintArray statusTargetLost)
{
    int timeout = NfcTag::getInstance ().getTransceiveTimeout (sCurrentConnectedTargetType);
    ALOGD ("%s: enter; raw=%u; timeout = %d", __FUNCTION__, raw, timeout);
    bool waitOk = false;
    bool isNack = false;
    jint *targetLost = NULL;

    if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
    {
        if (statusTargetLost)
        {
            targetLost = e->GetIntArrayElements (statusTargetLost, 0);
            if (targetLost)
                *targetLost = 1; //causes NFC service to throw TagLostException
            e->ReleaseIntArrayElements (statusTargetLost, targetLost, 0);
        }
        ALOGD ("%s: tag not active", __FUNCTION__);
        return NULL;
    }

    NfcTag& natTag = NfcTag::getInstance ();

    // get input buffer and length from java call
    ScopedByteArrayRO bytes(e, data);
    uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); // TODO: API bug; NFA_SendRawFrame should take const*!
    size_t bufLen = bytes.size();

    if (statusTargetLost)
    {
        targetLost = e->GetIntArrayElements (statusTargetLost, 0);
        if (targetLost)
            *targetLost = 0; //success, tag is still present
    }

    sSwitchBackTimer.kill ();
    ScopedLocalRef<jbyteArray> result(e, NULL);
    do
    {
        {
            SyncEventGuard g (sTransceiveEvent);
            sTransceiveRfTimeout = false;
            sWaitingForTransceive = true;
            sRxDataStatus = NFA_STATUS_OK;
            sRxDataBuffer.clear ();
            tNFA_STATUS status = NFA_SendRawFrame (buf, bufLen,
                    NFA_DM_DEFAULT_PRESENCE_CHECK_START_DELAY);
            if (status != NFA_STATUS_OK)
            {
                ALOGE ("%s: fail send; error=%d", __FUNCTION__, status);
                break;
            }
            waitOk = sTransceiveEvent.wait (timeout);
        }

        if (waitOk == false || sTransceiveRfTimeout) //if timeout occurred
        {
            ALOGE ("%s: wait response timeout", __FUNCTION__);
            if (targetLost)
                *targetLost = 1; //causes NFC service to throw TagLostException
            break;
        }

        if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
        {
            ALOGE ("%s: already deactivated", __FUNCTION__);
            if (targetLost)
                *targetLost = 1; //causes NFC service to throw TagLostException
            break;
        }

        ALOGD ("%s: response %d bytes", __FUNCTION__, sRxDataBuffer.size());

        if ((natTag.getProtocol () == NFA_PROTOCOL_T2T) &&
            natTag.isT2tNackResponse (sRxDataBuffer.data(), sRxDataBuffer.size()))
        {
            isNack = true;
        }

        if (sRxDataBuffer.size() > 0)
        {
            if (isNack)
            {
                //Some Mifare Ultralight C tags enter the HALT state after it
                //responds with a NACK.  Need to perform a "reconnect" operation
                //to wake it.
                ALOGD ("%s: try reconnect", __FUNCTION__);
//.........这里部分代码省略.........

/*******************************************************************************
**
** Function:        reSelect
**
** Description:     Deactivates the tag and re-selects it with the specified
**                  rf interface.
**
** Returns:         status code, 0 on success, 1 on failure,
**                  146 (defined in service) on tag lost
**
*******************************************************************************/
static int reSelect (tNFA_INTF_TYPE rfInterface, bool fSwitchIfNeeded)
{
    ALOGD ("%s: enter; rf intf = %d, current intf = %d", __FUNCTION__, rfInterface, sCurrentRfInterface);

    sRfInterfaceMutex.lock ();

    if (fSwitchIfNeeded && (rfInterface == sCurrentRfInterface))
    {
        // already in the requested interface
        sRfInterfaceMutex.unlock ();
        return 0;   // success
    }

    NfcTag& natTag = NfcTag::getInstance ();

    tNFA_STATUS status;
    int rVal = 1;

    do
    {
        //if tag has shutdown, abort this method
        if (NfcTag::getInstance ().isNdefDetectionTimedOut())
        {
            ALOGD ("%s: ndef detection timeout; break", __FUNCTION__);
            rVal = STATUS_CODE_TARGET_LOST;
            break;
        }

        {
            SyncEventGuard g (sReconnectEvent);
            gIsTagDeactivating = true;
            sGotDeactivate = false;
            ALOGD ("%s: deactivate to sleep", __FUNCTION__);
            if (NFA_STATUS_OK != (status = NFA_Deactivate (TRUE))) //deactivate to sleep state
            {
                ALOGE ("%s: deactivate failed, status = %d", __FUNCTION__, status);
                break;
            }

            if (sReconnectEvent.wait (1000) == false) //if timeout occurred
            {
                ALOGE ("%s: timeout waiting for deactivate", __FUNCTION__);
            }
        }

        if (!sGotDeactivate)
        {
            rVal = STATUS_CODE_TARGET_LOST;
            break;
        }

        if (NfcTag::getInstance ().getActivationState () != NfcTag::Sleep)
        {
            ALOGE ("%s: tag is not in sleep", __FUNCTION__);
            rVal = STATUS_CODE_TARGET_LOST;
            break;
        }

        gIsTagDeactivating = false;

        {
            SyncEventGuard g2 (sReconnectEvent);

            sConnectWaitingForComplete = JNI_TRUE;
            ALOGD ("%s: select interface %u", __FUNCTION__, rfInterface);
            gIsSelectingRfInterface = true;
            if (NFA_STATUS_OK != (status = NFA_Select (natTag.mTechHandles[0], natTag.mTechLibNfcTypes[0], rfInterface)))
            {
                ALOGE ("%s: NFA_Select failed, status = %d", __FUNCTION__, status);
                break;
            }

            sConnectOk = false;
            if (sReconnectEvent.wait (1000) == false) //if timeout occured
            {
                ALOGE ("%s: timeout waiting for select", __FUNCTION__);
                break;
            }
        }

        ALOGD("%s: select completed; sConnectOk=%d", __FUNCTION__, sConnectOk);
        if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
        {
            ALOGE("%s: tag is not active", __FUNCTION__);
            rVal = STATUS_CODE_TARGET_LOST;
            break;
        }
        if (sConnectOk)
        {
//.........这里部分代码省略.........

/*******************************************************************************
**
** Function:        nativeNfcTag_doPresenceCheck
**
** Description:     Check if the tag is in the RF field.
**                  e: JVM environment.
**                  o: Java object.
**
** Returns:         True if tag is in RF field.
**
*******************************************************************************/
static jboolean nativeNfcTag_doPresenceCheck (JNIEnv*, jobject)
{
    ALOGD ("%s", __FUNCTION__);
    tNFA_STATUS status = NFA_STATUS_OK;
    jboolean isPresent = JNI_FALSE;

    // Special case for Kovio.  The deactivation would have already occurred
    // but was ignored so that normal tag opertions could complete.  Now we
    // want to process as if the deactivate just happened.
    if (NfcTag::getInstance ().mTechList [0] == TARGET_TYPE_KOVIO_BARCODE)
    {
        ALOGD ("%s: Kovio, force deactivate handling", __FUNCTION__);
        tNFA_DEACTIVATED deactivated = {NFA_DEACTIVATE_TYPE_IDLE};
        {
            SyncEventGuard g (gDeactivatedEvent);
            gActivated = false; //guard this variable from multi-threaded access
            gDeactivatedEvent.notifyOne ();
        }

        NfcTag::getInstance().setDeactivationState (deactivated);
        nativeNfcTag_resetPresenceCheck();
        NfcTag::getInstance().connectionEventHandler (NFA_DEACTIVATED_EVT, NULL);
        nativeNfcTag_abortWaits();
        NfcTag::getInstance().abort ();

        return JNI_FALSE;
    }

    if (nfcManager_isNfcActive() == false)
    {
        ALOGD ("%s: NFC is no longer active.", __FUNCTION__);
        return JNI_FALSE;
    }

    if (!sRfInterfaceMutex.tryLock())
    {
        ALOGD ("%s: tag is being reSelected assume it is present", __FUNCTION__);
        return JNI_TRUE;
    }

    sRfInterfaceMutex.unlock();

    if (NfcTag::getInstance ().isActivated () == false)
    {
        ALOGD ("%s: tag already deactivated", __FUNCTION__);
        return JNI_FALSE;
    }

    {
        SyncEventGuard guard (sPresenceCheckEvent);
        status = NFA_RwPresenceCheck (NfcTag::getInstance().getPresenceCheckAlgorithm());
        if (status == NFA_STATUS_OK)
        {
            sPresenceCheckEvent.wait ();
            isPresent = sIsTagPresent ? JNI_TRUE : JNI_FALSE;
        }
    }

    if (isPresent == JNI_FALSE)
        ALOGD ("%s: tag absent", __FUNCTION__);
    return isPresent;
}