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